@vellumai/assistant 0.12.0 → 0.12.1-staging.1

package/scripts/smoke-desktop-window-theme.ts

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { writeDesktopWindowTheme } from "../src/desktop/desktop-window-theme.js";
+
+if (process.platform !== "linux") {
+  throw new Error(
+    "Run in a disposable Linux environment with Xvfb, Openbox, xterm, xdotool, xwininfo and xmllint installed",
+  );
+}
+
+const directory = await mkdtemp(join(tmpdir(), "window-theme-smoke-"));
+const env = { ...process.env, DISPLAY: ":97" };
+const children: ReturnType<typeof Bun.spawn>[] = [];
+const start = (cmd: string[]) => {
+  const child = Bun.spawn(cmd, {
+    env,
+    stdout: "ignore",
+    stderr: "inherit",
+    windowsHide: true,
+  });
+  children.push(child);
+  return child;
+};
+const run = (...cmd: string[]) => {
+  const result = Bun.spawnSync(cmd, {
+    env,
+
+    windowsHide: true,
+  });
+  assert.equal(result.exitCode, 0, result.stderr.toString());
+  return result.stdout.toString();
+};
+const waitFor = async (predicate: () => boolean) => {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      if (predicate()) {
+        return;
+      }
+    } catch {}
+    await Bun.sleep(50);
+  }
+  throw new Error("Window theme smoke condition timed out");
+};
+const pointer = async (...args: string[]) => {
+  run("xdotool", ...args);
+  await Bun.sleep(200);
+};
+const geometry = () => {
+  const info = run("xwininfo", "-name", "Theme smoke");
+  return [
+    "Absolute upper-left X",
+    "Absolute upper-left Y",
+    "Width",
+    "Height",
+  ].map((label) =>
+    Number(new RegExp(`${label}:\\s+(-?\\d+)`).exec(info)?.[1]),
+  ) as [number, number, number, number];
+};
+const state = () => run("xprop", "-name", "Theme smoke", "_NET_WM_STATE");
+const button = async (offset: number) => {
+  const [x, y, width] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - offset),
+    String(y - 16),
+    "click",
+    "1",
+  );
+};
+
+try {
+  const home = join(directory, "home");
+  const sourceDir = join(home, ".config", "openbox");
+  await mkdir(sourceDir, { recursive: true });
+  const original = await readFile("/etc/xdg/openbox/rc.xml", "utf8");
+  const mouse = original.match(/<mouse>[^]*?<\/mouse>/)![0];
+  const keyboard = original.match(/<keyboard>[^]*?<\/keyboard>/)![0];
+  const source = original
+    .replace(
+      mouse,
+      `<xi:include href="bindings.xml" xpointer="xpointer(/*/*)"/>`,
+    )
+    .replace(keyboard, "");
+  const sourcePath = join(sourceDir, "rc.xml");
+  await writeFile(sourcePath, source);
+  await writeFile(
+    join(sourceDir, "bindings.xml"),
+    `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
+  );
+  const configDir = join(directory, "managed & theme");
+  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  const expanded = run("xmllint", "--xinclude", config);
+  assert(
+    expanded.includes("NextWindow") && expanded.includes("Move"),
+    "Relative includes must retain the actual keyboard and mouse bindings",
+  );
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  writeDesktopWindowTheme(configDir, home, "#bc7799");
+  writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const blocked = join(directory, "blocked");
+  await writeFile(blocked, "not a directory");
+  assert.throws(() => writeDesktopWindowTheme(blocked, home));
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const customBase = source.replace(
+    "<openbox_config",
+    '<openbox_config xml:base="./custom/"',
+  );
+  await writeFile(sourcePath, customBase);
+  assert.throws(() => writeDesktopWindowTheme(configDir, home));
+  assert.equal(await readFile(sourcePath, "utf8"), customBase);
+  await writeFile(sourcePath, source);
+
+  start(["Xvfb", ":97", "-screen", "0", "1100x700x24"]);
+  await waitFor(
+    () => run("xdotool", "getdisplaygeometry").trim() === "1100 700",
+  );
+  start(["openbox", "--config-file", config]);
+  await waitFor(() =>
+    run("xprop", "-root", "_OB_THEME").includes("window-theme"),
+  );
+  start([
+    "xterm",
+    "-title",
+    "Theme smoke",
+    "-geometry",
+    "48x12+450+250",
+    "-e",
+    "sleep",
+    "60",
+  ]);
+  await waitFor(
+    () => run("xdotool", "search", "--name", "^Theme smoke$").trim().length > 0,
+  );
+  await Bun.sleep(300);
+  const id = run("xdotool", "search", "--name", "^Theme smoke$").trim();
+  await button(39);
+  assert(
+    state().includes("MAXIMIZED_HORZ") && state().includes("MAXIMIZED_VERT"),
+  );
+  await button(39);
+  assert(!state().includes("MAXIMIZED"));
+  await button(62);
+  assert(state().includes("HIDDEN"));
+  await pointer("windowactivate", id);
+  assert(!state().includes("HIDDEN"));
+  let [x, y, width, height] = geometry();
+  await pointer("mousemove", String(x + 100), String(y - 16), "mousedown", "1");
+  await pointer("mousemove", String(x + 90), String(y - 26));
+  await pointer("mousemove", String(x + 45), String(y - 65));
+  await pointer("mouseup", "1");
+  const [movedX, movedY] = geometry();
+  assert(Math.abs(movedX - x) >= 30 && Math.abs(movedY - y) >= 30);
+  [x, y, width, height] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - 2),
+    String(y + height + 2),
+    "mousedown",
+    "1",
+  );
+  await pointer("mousemove", String(x + width + 10), String(y + height + 10));
+  await pointer("mousemove", String(x + width + 60), String(y + height + 40));
+  await pointer("mouseup", "1");
+  const [, , resizedWidth, resizedHeight] = geometry();
+  assert(resizedWidth > width && resizedHeight > height);
+  await pointer("key", "alt+F4");
+  await waitFor(
+    () =>
+      !run("xprop", "-root", "_NET_CLIENT_LIST").includes(
+        `0x${Number(id).toString(16)}`,
+      ),
+  );
+  console.log(
+    "PASS: relative includes, preserved source, repeated theme updates, maximize/restore, minimize/activation, dragging, resizing, and keyboard close",
+  );
+} finally {
+  for (const child of children.reverse()) {
+    child.kill();
+  }
+  await Promise.all(children.map((child) => child.exited));
+  await rm(directory, { recursive: true, force: true });
+}

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__/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__/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

@@ -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",