feat(webui): K area — memory, AGENTS.md and the personalization tab

packages/config/test/config-update-preservation.test.ts

@@ -184,4 +184,51 @@ describe("valid local config updates", () => {
       permissionMode: "default",
     });
   });
+
+  /**
+   * The memory switches reach the config through `put`, not through the
+   * `preparedCommitPayload` argument. That argument is a shallow
+   * `Object.assign`, so `{ memory: { enabled, proactive } }` through it would
+   * replace the whole `memory` subtree and silently delete `dailyDigest` from
+   * the user's config — a setting they enabled, with no error and no trace.
+   *
+   * This is the only place that failure would be visible: the WebUI reports
+   * the two booleans it wrote, and it has no reason to look at a sibling key.
+   */
+  it("keeps sibling keys of a subtree when writing through put", async () => {
+    const source = {
+      memory: {
+        enabled: true,
+        dailyDigest: { enabled: true, customRetention: 7 },
+      },
+    };
+    fs.writeFileSync(configPath, yaml.dump(source));
+
+    await updateLocalConfigFile({
+      field: "memory",
+      put: { proactive: true },
+    });
+
+    expect(yaml.load(fs.readFileSync(configPath, "utf8"))).toEqual({
+      memory: {
+        enabled: true,
+        dailyDigest: { enabled: true, customRetention: 7 },
+        proactive: true,
+      },
+    });
+  });
+
+  it("refuses a field the whitelist does not carry, without touching the file", async () => {
+    // The WebUI's operation frame is two booleans, but the writer is shared by
+    // every caller — the whitelist is what stops a general payload from
+    // reaching the API-key roots through this same code path.
+    const source = `minimax_api:\n  apiKey: ${secret}\n`;
+    fs.writeFileSync(configPath, source);
+
+    await expect(
+      updateLocalConfigFile({ field: "minimax_api", put: { apiKey: "other" } }),
+    ).rejects.toThrow(/cannot update config field/u);
+
+    expect(fs.readFileSync(configPath, "utf8")).toBe(source);
+  });
 });

packages/local-runtime-v2/src/application/session/process-local-application-contract.ts

@@ -260,6 +260,25 @@ export interface LocalRuntimeApplication {
     setPermissionMode(input: {
       mode: "default" | "acceptEdits" | "bypassPermissions" | "auto" | "off";
     }): Promise<unknown>;
+    /**
+     * The two long-term-memory switches, read and written as their own
+     * narrow surface rather than as a general config patch.
+     *
+     * Optional because a host that predates this surface still has to
+     * type-check, and every consumer must fail closed with one clear
+     * message instead of crashing on an absent method — the same rule the
+     * permission-mode pair already follows. Callers must not treat a missing
+     * method as "off": absence means "this host cannot answer", which is a
+     * different statement from either boolean value.
+     */
+    getMemorySettings?(): Promise<{
+      enabled: boolean;
+      proactive: boolean;
+    }>;
+    setMemorySettings?(input: {
+      enabled?: boolean;
+      proactive?: boolean;
+    }): Promise<{ enabled: boolean; proactive: boolean }>;
   };
   readonly models?: {
     list(input?: { sessionId?: string }): Promise<readonly unknown[]>;

packages/local-runtime-v2/src/compat/v1/runtime.ts

@@ -741,6 +741,39 @@ function createPeripheralApplication(
         readLocalPermissionMode(host.apiHost.configGetter().permissionMode),
       setPermissionMode: ({ mode }) =>
         host.apiHost.setProcessLocalPermissionMode(mode),
+      /**
+       * Reads the two long-term-memory switches with the same defaults the
+       * config declares (`packages/config/src/config.ts`: `enabled` true,
+       * `proactive` false). A missing `memory` tree is not an error — it is the
+       * documented default state, and reporting it as "off" would be a lie the
+       * settings UI would then write back.
+       */
+      getMemorySettings: async () => {
+        const memory = host.apiHost.configGetter().memory;
+        return {
+          enabled: memory?.enabled !== false,
+          proactive: memory?.proactive === true,
+        };
+      },
+      /**
+       * `put` rather than the `preparedCommitPayload` argument: that path does
+       * a shallow `Object.assign`, so passing `{ memory: { enabled, proactive } }`
+       * would silently drop `memory.dailyDigest` from the user's config. `put`
+       * deep-merges into the existing subtree and touches one key per call.
+       */
+      setMemorySettings: async ({ enabled, proactive }) => {
+        const put: Record<string, boolean> = {};
+        if (enabled !== undefined) put.enabled = enabled;
+        if (proactive !== undefined) put.proactive = proactive;
+        if (Object.keys(put).length > 0) {
+          await updateLocalConfigFile({ field: "memory", put });
+        }
+        const memory = host.apiHost.configGetter().memory;
+        return {
+          enabled: memory?.enabled !== false,
+          proactive: memory?.proactive === true,
+        };
+      },
     },
     backgroundTasks: {
       list: async ({

packages/local-runtime-v2/src/local/cli-service.ts

@@ -827,6 +827,33 @@ export class CliService {
     ).setPermissionMode(input);
   }
 
+  /**
+   * The memory switches are optional on the capability, so a host that
+   * predates the surface must produce one clear failure here rather than a
+   * `TypeError` from calling `undefined`. Absence means "this host cannot
+   * answer" — it is deliberately not reported as a boolean value, because
+   * `false` would read as "the user turned memory off".
+   */
+  getMemorySettings(): Promise<{ enabled: boolean; proactive: boolean }> {
+    const configuration = this.requireCapability("configuration", "Configuration");
+    if (!configuration.getMemorySettings)
+      throw new Error("Runtime host does not expose memory settings");
+    return configuration.getMemorySettings();
+  }
+
+  setMemorySettings(
+    input: Parameters<
+      NonNullable<
+        NonNullable<LocalRuntimeApplication["configuration"]>["setMemorySettings"]
+      >
+    >[0],
+  ): Promise<{ enabled: boolean; proactive: boolean }> {
+    const configuration = this.requireCapability("configuration", "Configuration");
+    if (!configuration.setMemorySettings)
+      throw new Error("Runtime host does not expose memory settings");
+    return configuration.setMemorySettings(input);
+  }
+
   listModels(
     input?: Parameters<
       NonNullable<LocalRuntimeApplication["models"]>["list"]

packages/webui/src/client/components/SessionComposer.tsx

@@ -156,6 +156,7 @@ import {
   removeWebuiSlashToken,
   replaceWebuiSlashToken,
   webuiAttachmentLimitError,
+  webuiTextAttachmentDataUrl,
   type WebuiMentionRange,
 } from "../projection/composer-interactions.js";
 import {
@@ -616,6 +617,7 @@ export function WebuiComposer({
   workspaceDir,
   onSelectSession,
   onOpenPluginManagement,
+  seedAttachment,
 }: {
   readonly sessionId?: string;
   readonly sessionStatus?: unknown;
@@ -661,6 +663,23 @@ export function WebuiComposer({
   /** The draft lives on the shell so it survives silent first-session creation. */
   readonly draft: string;
   readonly onDraftChange: (next: string) => void;
+  /**
+   * A file dropped into the composer from outside it — 记忆摘要's 「在会话中创建」
+   * hands the memory file over this way, because the composer is the only
+   * surface that can render an attachment chip and the only one that can put it
+   * on the wire.
+   *
+   * One-shot by `token`: the shell keeps the seed around across the view switch
+   * that opens the composer, so an effect keyed on anything else would re-attach
+   * the same 74KB file on every re-render of this 3000-line component.
+   */
+  readonly seedAttachment?: {
+    readonly token: string;
+    readonly fileName: string;
+    readonly mimeType: string;
+    readonly sizeBytes: number;
+    readonly content: string;
+  };
   /**
    * Submitted-input history for ↑ recall (roadmap Module B: 输入历史/草稿).
    * Keyed by session on the shell; the composer only walks it with the pure
@@ -1520,6 +1539,31 @@ export function WebuiComposer({
       setAttachmentBusy(false);
     }
   };
+  const seededTokenRef = useRef<string>();
+  useEffect(() => {
+    const seed = seedAttachment;
+    if (!seed || seededTokenRef.current === seed.token) return;
+    // Mark it consumed before anything that can bail. A seed the composer
+    // refuses has to stay refused; retrying on every attachment change would
+    // pin the error in place.
+    seededTokenRef.current = seed.token;
+    const limitError = webuiAttachmentLimitError(attachments, [{ sizeBytes: seed.sizeBytes }]);
+    if (limitError) {
+      setInteractionError(limitError);
+      return;
+    }
+    setAttachments((current) => [
+      ...current,
+      {
+        id: `seed-${seed.token}`,
+        fileName: seed.fileName,
+        mimeType: seed.mimeType,
+        sizeBytes: seed.sizeBytes,
+        dataUrl: webuiTextAttachmentDataUrl(seed.mimeType, seed.content),
+        kind: "file",
+      },
+    ]);
+  }, [attachments, seedAttachment]);
   const attachmentWire = attachments.map((attachment) => ({
     meta: {
       attachmentType: attachment.kind,