@vellumai/assistant 0.12.0 → 0.12.1-dev.202609142113.d1590bc

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -26,7 +26,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 with recall occupying the existing slot", async () => {
+  test("should be exactly 19 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = getAllToolDefinitions();
 
@@ -44,23 +44,31 @@ describe("always-loaded tool count", () => {
     );
     const activeNames = activeTools.map((t) => t.name).sort();
 
-    // Host tools (host_bash, host_file_*) are excluded when no client is
-    // connected — without a human in the loop, the guardian auto-approve
-    // path would allow unchecked host command execution.
-    //
-    // `watch_retro_report` is here for the same reason the ui_surface tools are
-    // NOT: a watch retrospective runs clientless, so it can only report through
-    // a tool that survives this baseline. Its description and schema are kept
-    // deliberately terse because that is the cost of the slot.
+    // `watch_retro_report` survives this baseline for the same reason the
+    // ui_* tools do: a watch retrospective runs clientless, so it can only
+    // report through a tool that survives this baseline. The ui_* tools are
+    // here because background UI surfaces persist and return instead of
+    // awaiting action, so they no longer need a connected client.
+    // Host tool definitions stay on the wire for background turns: schemas
+    // are cache-stable, and the shared execution gate rejects host tools on
+    // explicitly non-interactive turns before any proxy dispatch.
     const expectedNames = [
       "bash",
       "file_edit",
       "file_read",
       "file_write",
+      "host_bash",
+      "host_file_edit",
+      "host_file_read",
+      "host_file_transfer",
+      "host_file_write",
       "recall",
       "remember",
       "skill_execute",
       "skill_load",
+      "ui_dismiss",
+      "ui_show",
+      "ui_update",
       "watch_retro_report",
       "web_fetch",
       "web_search",
@@ -68,6 +76,6 @@ describe("always-loaded tool count", () => {
 
     expect(activeNames).toEqual(expectedNames);
     expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
-    expect(activeTools.length).toBe(11);
+    expect(activeTools.length).toBe(19);
   });
 });

package/src/__tests__/anthropic-provider.test.ts

@@ -3029,69 +3029,6 @@ describe("AnthropicProvider - internal attachment id", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests — Orphaned UTF-16 surrogate sanitization
-// ---------------------------------------------------------------------------
-
-describe("AnthropicProvider — surrogate sanitization", () => {
-  let provider: AnthropicProvider;
-
-  beforeEach(() => {
-    lastStreamParams = null;
-    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
-  });
-
-  test("strips orphaned high surrogate from a tool result before sending", async () => {
-    // An orphaned high surrogate — the exact shape that triggers Anthropic's
-    // "no low surrogate in string" 400. The mock's JSON.parse(JSON.stringify)
-    // on line ~44 would throw if sanitization didn't happen.
-    const LONE_HIGH = "\uD83C";
-    const messages: Message[] = [
-      toolUseMsg("tu1", "bash"),
-      toolResultMsg("tu1", `shell output ${LONE_HIGH} more output`),
-      userMsg("what happened?"),
-    ];
-
-    await provider.sendMessage(messages);
-
-    const sent = lastStreamParams!.messages as Array<{
-      role: string;
-      content: Array<{ type: string; content?: string; text?: string }>;
-    }>;
-    // Find the tool_result block in the captured payload and assert no orphans.
-    const toolResult = sent
-      .flatMap((m) => m.content)
-      .find((b) => b.type === "tool_result");
-    expect(toolResult).toBeDefined();
-    expect(toolResult!.content).toBeDefined();
-    const content = toolResult!.content as string;
-    for (let i = 0; i < content.length; i++) {
-      const code = content.charCodeAt(i);
-      if (code >= 0xd800 && code <= 0xdbff) {
-        const next = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
-        expect(next >= 0xdc00 && next <= 0xdfff).toBe(true);
-        i++;
-      } else {
-        expect(code < 0xdc00 || code > 0xdfff).toBe(true);
-      }
-    }
-  });
-
-  test("clean payloads are not copied unnecessarily", async () => {
-    // When there are no orphans, the sanitizer should be a no-op. We can't
-    // easily assert reference equality through the mock boundary (the mock
-    // JSON-round-trips params for capture), but we can at least confirm the
-    // call succeeds without error on ordinary payloads containing valid
-    // surrogate pairs (emoji).
-    const EMOJI = "\uD83C\uDF89";
-    await provider.sendMessage([userMsg(`hello ${EMOJI} world`)]);
-    const sent = lastStreamParams!.messages as Array<{
-      content: Array<{ text?: string }>;
-    }>;
-    expect(sent[0].content[0].text).toContain(EMOJI);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Haiku model gating
 // ---------------------------------------------------------------------------

package/src/__tests__/app-compiler.test.ts

@@ -112,6 +112,12 @@ describe("compileApp", () => {
     const html = await readFile(join(appDir, "dist", "index.html"), "utf-8");
     expect(html).toContain('src="main.js"');
     expect(html).toContain('type="module"');
+
+    const fingerprint = JSON.parse(
+      await readFile(join(appDir, "dist", ".source-fingerprint.json"), "utf-8"),
+    ) as { algorithm: string; files: Record<string, string> };
+    expect(fingerprint.algorithm).toBe("sha256");
+    expect(fingerprint.files["src/main.tsx"]).toMatch(/^[0-9a-f]{64}$/);
   });
 
   test("compiles preact JSX correctly", async () => {

package/src/__tests__/app-control-tool-schemas.test.ts

@@ -591,8 +591,11 @@ describe("forwardAppControlProxyTool", () => {
       ctx,
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("app_control_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to control apps on your computer",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("app_control_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/app-dir-path-guard.test.ts

@@ -9,15 +9,13 @@ import { describe, expect, test } from "bun:test";
  * This prevents regressions where new code bypasses the dirName-based path
  * resolution and constructs UUID-based paths directly.
  *
- * Allowlist: only app-store.ts itself, app-source-watcher.ts (uses getAppsDir
- * for the fs.watch root, not for per-app paths), and workspace migrations
+ * Allowlist: only app-store.ts itself and workspace migrations
  * (self-contained, don't import from app-store).
  */
 
 /** Files that are permitted to import getAppsDir. */
 const ALLOWLIST = new Set([
   "assistant/src/apps/app-store.ts", // defines getAppsDir
-  "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
   "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
 ]);
 

package/src/__tests__/assistant-event-hub-machine-name.test.ts

@@ -125,7 +125,10 @@ describe("AssistantEventHub — machineName", () => {
   });
 });
 
-describe("window capture negotiation", () => {
+describe.each([
+  ["x-vellum-cu-window-capture", "host_cu_window_capture"],
+  ["x-vellum-cu-sequence", "host_cu_sequence"],
+] as const)("%s negotiation", (header, capability) => {
   test.each([
     ["macos", undefined, false],
     ["macos", "0", false],
@@ -145,18 +148,14 @@ describe("window capture negotiation", () => {
             headers: {
               "x-vellum-client-id": "client-1",
               "x-vellum-interface-id": interfaceId,
-              ...(advertised
-                ? { "x-vellum-cu-window-capture": advertised }
-                : {}),
+              ...(advertised ? { [header]: advertised } : {}),
             },
             abortSignal: ac.signal,
           },
           { hub },
         );
         expect(
-          hub
-            .getClientById("client-1")
-            ?.capabilities.includes("host_cu_window_capture"),
+          hub.getClientById("client-1")?.capabilities.includes(capability),
         ).toBe(supported);
       } finally {
         ac.abort();

package/src/__tests__/assistant-event-hub.test.ts

@@ -690,3 +690,47 @@ test("window requests never reach an older overlapping connection with the same
     supported.dispose();
   }
 });
+
+test("batched action requests never reach an older overlapping connection with the same device ID", async () => {
+  const receivedLegacy: unknown[] = [];
+  const receivedSupported: unknown[] = [];
+  const legacy = assistantEventHub.subscribe({
+    type: "client",
+    clientId: "sequence-client",
+    interfaceId: "macos",
+    capabilities: ["host_cu"],
+    callback: (event) => {
+      receivedLegacy.push(event);
+    },
+  });
+  const supported = assistantEventHub.subscribe({
+    type: "client",
+    clientId: "sequence-client",
+    interfaceId: "macos",
+    capabilities: ["host_cu", "host_cu_sequence"],
+    callback: (event) => {
+      receivedSupported.push(event);
+    },
+  });
+  try {
+    broadcastMessage(
+      {
+        type: "host_cu_request",
+        requestId: "sequence-request",
+        conversationId: "sequence-session",
+        toolName: "computer_use_sequence",
+        input: { actions: [{ action: "key", key: "cmd+n" }] },
+        stepNumber: 1,
+        targetClientId: "sequence-client",
+      },
+      "sequence-session",
+      { targetClientId: "sequence-client" },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(receivedLegacy).toHaveLength(0);
+    expect(receivedSupported).toHaveLength(1);
+  } finally {
+    legacy.dispose();
+    supported.dispose();
+  }
+});

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -29,7 +29,7 @@ const manifestPath = resolve(
 const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
 
 describe("computer-use skill manifest regression", () => {
-  test("manifest has exactly 11 tools", () => {
+  test("manifest has exactly 12 tools", () => {
     expect(manifest.tools).toHaveLength(COMPUTER_USE_TOOL_COUNT);
   });
 

package/src/__tests__/computer-use-skill-proxy-bridge.test.ts

@@ -13,8 +13,11 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("computer_use_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("computer_use_click");
   });
 
   test("forwards to proxyToolResolver when present", async () => {

package/src/__tests__/computer-use-tools.test.ts

@@ -37,8 +37,8 @@ const ctx: ToolContext = {
 // ── Tool definitions ────────────────────────────────────────────────
 
 describe("computer-use tool definitions", () => {
-  test("allComputerUseTools contains 11 tools", () => {
-    expect(allComputerUseTools.length).toBe(11);
+  test("allComputerUseTools contains 12 tools", () => {
+    expect(allComputerUseTools.length).toBe(12);
   });
 
   test("all tools belong to computer-use category", () => {
@@ -104,7 +104,10 @@ describe("computer_use_click (unified)", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseClickTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -119,7 +122,10 @@ describe("computer_use_type_text", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseTypeTextTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -134,7 +140,10 @@ describe("computer_use_key", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseKeyTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -241,8 +250,11 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("computer_use_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("computer_use_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/config-schema-cmd.test.ts

@@ -130,7 +130,7 @@ describe("getSchemaAtPath", () => {
     expect(properties).toBeDefined();
     expect(properties.enabled).toBeDefined();
     expect(properties.voice).toBeDefined();
-    expect(properties.safety).toBeDefined();
+    expect(properties.disclosure).toBeDefined();
   });
 
   test("navigates through .transform() wrappers (ingress → object schema)", () => {
@@ -230,7 +230,7 @@ describe("z.toJSONSchema integration", () => {
     expect(properties).toBeDefined();
     expect(properties!.enabled).toBeDefined();
     expect(properties!.voice).toBeDefined();
-    expect(properties!.safety).toBeDefined();
+    expect(properties!.disclosure).toBeDefined();
   });
 
   test("sub-schema at a leaf like llm.profileSession.defaultTtlSeconds produces integer schema", () => {

package/src/__tests__/config-schema.test.ts

@@ -952,11 +952,7 @@ describe("AssistantConfigSchema", () => {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
       },
-      safety: {
-        denyCategories: [],
-      },
       voice: {
-        interruptSensitivity: "low",
         telephonyStreaming: true,
         utteranceEndMs: 1000,
       },
@@ -978,7 +974,6 @@ describe("AssistantConfigSchema", () => {
         maxDurationSeconds: 1800,
         userConsultTimeoutSeconds: 60,
         disclosure: { enabled: false, text: "Custom disclosure" },
-        safety: { denyCategories: ["spam"] },
       },
     });
     expect(result.calls.enabled).toBe(false);
@@ -986,7 +981,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.userConsultTimeoutSeconds).toBe(60);
     expect(result.calls.disclosure.enabled).toBe(false);
     expect(result.calls.disclosure.text).toBe("Custom disclosure");
-    expect(result.calls.safety.denyCategories).toEqual(["spam"]);
   });
 
   // ── Live voice config ───────────────────────────────────────────────
@@ -994,7 +988,6 @@ describe("AssistantConfigSchema", () => {
   test("applies liveVoice defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.liveVoice).toEqual({
-      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -1005,6 +998,18 @@ describe("AssistantConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
+      flux: {
+        turnEnd: { enabled: true },
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
+      archiveAudio: false,
+    });
+  });
+
+  test("applies voice defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.voice).toEqual({
       frontModel: {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
@@ -1019,35 +1024,24 @@ describe("AssistantConfigSchema", () => {
           generationTimeoutMs: 1500,
         },
       },
-      flux: {
-        turnEnd: { enabled: true },
-        eotThreshold: 0.7,
-        eotTimeoutMs: 5000,
-      },
-      maxSessionDurationSeconds: 1800,
-      archiveAudio: false,
     });
   });
 
   test("accepts valid liveVoice config overrides", () => {
     const result = AssistantConfigSchema.parse({
       liveVoice: {
-        mode: "ptt",
         vad: {
           speechEnergyThreshold: 1500,
           silenceThresholdMs: 1000,
           bargeInMinSpeechMs: 120,
         },
-        maxSessionDurationSeconds: 900,
       },
     });
-    expect(result.liveVoice.mode).toBe("ptt");
     expect(result.liveVoice.vad.speechEnergyThreshold).toBe(1500);
     expect(result.liveVoice.vad.silenceThresholdMs).toBe(1000);
     expect(result.liveVoice.vad.bargeInMinSpeechMs).toBe(120);
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
-    expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
     // A partial liveVoice override leaves Flux turn-end disabled by default.
     expect(result.liveVoice.flux.turnEnd.enabled).toBe(true);
   });
@@ -1136,18 +1130,10 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects non-array calls.safety.denyCategories", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { safety: { denyCategories: "spam" } },
-    });
-    expect(result.success).toBe(false);
-  });
-
   // ── Calls voice config ──────────────────────────────────────────────
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.calls.voice.interruptSensitivity).toBe("low");
     expect(result.calls.voice.telephonyStreaming).toBe(true);
     expect(result.calls.voice.utteranceEndMs).toBe(1000);
   });
@@ -1165,9 +1151,23 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.voice.utteranceEndMs).toBe(2500);
   });
 
+  test("persisted calls configs carrying retired keys keep parsing", () => {
+    // Zod strips unrecognized keys, so a persisted config that still carries
+    // `calls.safety.denyCategories` or `calls.voice.interruptSensitivity`
+    // parses.
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        safety: { denyCategories: ["spam"] },
+        voice: { interruptSensitivity: "high" },
+      },
+    });
+    expect(result.calls).not.toHaveProperty("safety");
+    expect(result.calls.voice).not.toHaveProperty("interruptSensitivity");
+  });
+
   test("language is no longer part of the voice config schema", () => {
-    // The retired knob was read by nothing; Zod strips the unrecognized key
-    // so persisted configs that still carry it keep parsing.
+    // Zod strips the unrecognized key, so persisted configs that still carry
+    // it parse.
     const result = AssistantConfigSchema.parse({
       calls: { voice: { language: "es-ES" } },
     });
@@ -2633,7 +2633,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.maxDurationSeconds).toBe(3600);
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
-    expect(config.calls.safety.denyCategories).toEqual([]);
     expect(
       (config.calls.voice as Record<string, unknown>).language,
     ).toBeUndefined();

package/src/__tests__/config-watcher.test.ts

@@ -113,8 +113,11 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => null,
 }));
 
+let mcpReloadCallCount = 0;
 mock.module("../daemon/mcp-reload-service.js", () => ({
-  reloadMcpServers: async () => {},
+  reloadMcpServers: async () => {
+    mcpReloadCallCount += 1;
+  },
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({
@@ -154,10 +157,6 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
-mock.module("../daemon/skill-memory-refresh.js", () => ({
-  refreshSkillCapabilityMemories: () => {},
-}));
-
 mock.module("../platform/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
@@ -183,6 +182,7 @@ function findFileWatch(filePath: string): CapturedFileWatch | undefined {
 
 const WORKSPACE_FILES = new Set([
   "config.json",
+  "mcp.json",
   "SOUL.md",
   "IDENTITY.md",
   "ui/theme.json",
@@ -239,6 +239,7 @@ beforeEach(() => {
   evictCallCount = 0;
   identityCallCount = 0;
   themeCallCount = 0;
+  mcpReloadCallCount = 0;
   watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
@@ -270,9 +271,9 @@ describe("ConfigWatcher workspace file handlers", () => {
 
   test("unregistered workspace files are not subscribed (only the registered handler set is)", () => {
     watcher.start();
-    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md,
-    // and ui/theme.json. The whole workspace dir must not be watched
-    // either — that was the ENXIO-on-Unix-sockets bug.
+    // Per-file watching only registers config.json, mcp.json, SOUL.md,
+    // IDENTITY.md, and ui/theme.json. The whole workspace dir must not
+    // be watched either: that was the ENXIO-on-Unix-sockets bug.
     expect(findFileWatch(join(WORKSPACE_DIR, "OTHER.md"))).toBeUndefined();
     expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
@@ -285,6 +286,14 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(0);
   });
 
+  test("mcp.json change reloads MCP servers without evicting conversations", async () => {
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "mcp.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(mcpReloadCallCount).toBe(1);
+    expect(evictCallCount).toBe(0);
+  });
+
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {
@@ -332,6 +341,12 @@ describe("ConfigWatcher watcher lifecycle", () => {
     expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
+  test("start does not watch the skills directory", () => {
+    mkdirSync(join(WORKSPACE_DIR, "skills"), { recursive: true });
+    watcher.start();
+    expect(findWatcher(join(WORKSPACE_DIR, "skills"))).toBeUndefined();
+  });
+
   test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start();
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");

package/src/__tests__/connection-model-compat.test.ts

@@ -19,7 +19,7 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(
       isConnectionCompatibleWithModel(
         { auth: { type: "oauth_subscription" } as never },
-        "gpt-5.4",
+        "gpt-5.5",
       ),
     ).toBe(true);
   });
@@ -79,7 +79,7 @@ describe("describeSubscriptionModelIncompatibility", () => {
 
   test("returns null when model is Codex-compatible", () => {
     expect(
-      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.4"),
+      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.5"),
     ).toBeNull();
   });
 });

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -59,7 +59,7 @@ describe("conversation-key-store disk view", () => {
 
     const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
     expect(meta.id).toBe(first.conversationId);
-    expect(meta.title).toBe("Generating title...");
+    expect(meta.title).toBe("conversation.title.generating");
     expect(meta.type).toBe("standard");
     expect(meta.channel).toBeNull();
     expect(readdirSync(conversationsDir)).toEqual([expectedDirName]);

package/src/__tests__/conversation-pairing.test.ts

@@ -901,6 +901,32 @@ describe("pairDeliveryWithConversation", () => {
   // body has to land there for that button to open something that contains
   // the notification the user tapped.
 
+  test("assistant reply keeps the source conversation without appending its preview", async () => {
+    mockExistingConversations["conv-user-chat"] = {
+      id: "conv-user-chat",
+      source: "user",
+      title: "An ordinary chat",
+    };
+    const signal = makeSignal({
+      requiresConversation: undefined,
+      sourceContextId: "conv-user-chat",
+      sourceEventName: "chat.assistant_reply",
+    });
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      makeCopy({ body: "A short push preview…" }),
+    );
+
+    expect(result.conversationId).toBe("conv-user-chat");
+    expect(result.messageId).toBeNull();
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+    expect(messagesInvalidated).toEqual([]);
+  });
+
   test("passive vellum signal appends the body to the producing conversation", async () => {
     mockExistingConversations["conv-producer"] = {
       id: "conv-producer",