@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/db-acp-history.test.ts

@@ -5,6 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrate230AcpSessionHistory } from "../memory/migrations/230-acp-session-history.js";
+import { migrateAcpSessionHistoryCwd } from "../memory/migrations/272-acp-session-history-cwd.js";
 import * as schema from "../memory/schema.js";
 
 function createTestDb() {
@@ -282,3 +283,103 @@ describe("acp_session_history migration", () => {
     expect(row?.id).toBe("history-rerun");
   });
 });
+
+describe("acp_session_history cwd migration (272)", () => {
+  function readColumns(raw: Database): Map<string, ColumnRow> {
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    return new Map(columns.map((c) => [c.name, c]));
+  }
+
+  test("adds a nullable cwd TEXT column to an upgraded table", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    expect(readColumns(raw).has("cwd")).toBe(false);
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const cwd = readColumns(raw).get("cwd");
+    expect(cwd).toBeDefined();
+    expect(cwd?.type).toBe("TEXT");
+    expect(cwd?.notnull).toBe(0);
+  });
+
+  test("re-running is a no-op, including with a cleared checkpoint", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    migrateAcpSessionHistoryCwd(db);
+
+    // Second run short-circuits on the completed checkpoint.
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    // Even with the checkpoint cleared (simulating crash recovery), the
+    // column-existence guard makes the ALTER a no-op.
+    raw
+      .query(`DELETE FROM memory_checkpoints WHERE key = ?`)
+      .run("migration_acp_session_history_cwd_v1");
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    expect(columns.filter((c) => c.name === "cwd")).toHaveLength(1);
+  });
+
+  test("legacy rows read back with cwd null; new rows round-trip cwd", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+
+    // Legacy row inserted before the cwd column existed.
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run("legacy-1", "agent-old", "acp-old", "conv-old", 100, "completed");
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const legacy = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'legacy-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(legacy?.cwd).toBeNull();
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status, cwd
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "new-1",
+        "agent-new",
+        "acp-new",
+        "conv-new",
+        200,
+        "completed",
+        "/Users/me/project",
+      );
+
+    const fresh = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'new-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(fresh?.cwd).toBe("/Users/me/project");
+  });
+});

package/src/__tests__/dynamic-page-surface.test.ts

@@ -94,6 +94,37 @@ describe("ui_show dynamic_page app substitute guard", () => {
     expect(proxied).toBe(false);
   });
 
+  test("rejects dynamic_page with a clean title but substantial interactive html", async () => {
+    let proxied = false;
+
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "dynamic_page",
+        title: "Labor Market Stats",
+        data: {
+          html:
+            "<div id='root'></div><script>" +
+            "const data=[/*...*/];".padEnd(2100, "/") +
+            "new Chart(document.getElementById('root'), {});</script>",
+          preview: { title: "Labor Market Stats" },
+        },
+      },
+      {
+        conversationId: "conversation-123",
+        workingDir: "/tmp",
+        trustClass: "guardian",
+        proxyToolResolver: async () => {
+          proxied = true;
+          return { content: "proxied", isError: false };
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(proxied).toBe(false);
+  });
+
   test("allows transient non-app dynamic_page surfaces", async () => {
     let proxied = false;
 

package/src/__tests__/embedding-managed-proxy-selection.test.ts

@@ -2,8 +2,7 @@
  * Tests for managed proxy Gemini embedding backend selection.
  *
  * Verifies that selectEmbeddingBackend correctly routes through the
- * managed proxy when the feature flag is enabled and managed proxy
- * prerequisites are satisfied.
+ * managed proxy when managed proxy prerequisites are satisfied.
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -42,13 +41,9 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
-// Feature flag mock
-const mockFeatureFlags: Record<string, boolean> = {};
-
+// Feature flag mock — always returns true (flag is GA'ed)
 mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown) => {
-    return mockFeatureFlags[key] ?? false;
-  },
+  isAssistantFeatureFlagEnabled: () => true,
 }));
 
 import type { AssistantConfig } from "../config/types.js";
@@ -75,14 +70,6 @@ function disableManagedProxy() {
   mockAssistantApiKey = null;
 }
 
-function enableFlag() {
-  mockFeatureFlags["managed-gemini-embeddings-enabled"] = true;
-}
-
-function disableFlag() {
-  mockFeatureFlags["managed-gemini-embeddings-enabled"] = false;
-}
-
 function makeConfig(
   overrides: {
     provider?: string;
@@ -116,7 +103,6 @@ function makeConfig(
 
 beforeEach(() => {
   disableManagedProxy();
-  disableFlag();
   mockProviderKeys = {};
   clearEmbeddingBackendCache();
 });
@@ -126,9 +112,8 @@ afterEach(() => {
 });
 
 describe("managed proxy Gemini embedding selection", () => {
-  test("selects managed proxy Gemini when flag enabled and proxy context available", async () => {
+  test("selects managed proxy Gemini when proxy context available", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend, reason } = await selectEmbeddingBackend(config);
@@ -141,7 +126,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses default 3072 dimensions when geminiDimensions not set", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -155,7 +139,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses explicit geminiDimensions when set", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ geminiDimensions: 768 });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -168,7 +151,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("managed proxy backend uses managedBaseUrl (not direct Google API)", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -179,32 +161,19 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(managedBaseUrl).toBe(`${PLATFORM_BASE}/v1/runtime-proxy/gemini`);
   });
 
-  test("falls back to local when flag is disabled (no managed proxy)", async () => {
-    enableManagedProxy();
-    disableFlag();
-    const config = makeConfig();
-
-    const { backend } = await selectEmbeddingBackend(config);
-
-    // With auto and no provider keys, falls through to local
-    expect(backend).not.toBeNull();
-    expect(backend!.provider).toBe("local");
-  });
-
   test("falls back to local when managed proxy context unavailable", async () => {
     disableManagedProxy();
-    enableFlag();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
 
+    // With auto and no provider keys or proxy, falls through to local
     expect(backend).not.toBeNull();
     expect(backend!.provider).toBe("local");
   });
 
   test("selects managed proxy when provider is explicitly gemini", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ provider: "gemini" });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -217,7 +186,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("does not use managed proxy when provider is explicitly local", async () => {
     enableManagedProxy();
-    enableFlag();
     const config = makeConfig({ provider: "local" });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -228,7 +196,6 @@ describe("managed proxy Gemini embedding selection", () => {
 
   test("does not use managed proxy when provider is explicitly openai", async () => {
     enableManagedProxy();
-    enableFlag();
     mockProviderKeys[credentialKey("openai", "api_key")] = "user-openai-key";
     const config = makeConfig({ provider: "openai" });
 
@@ -238,9 +205,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(backend!.provider).toBe("openai");
   });
 
-  test("direct Gemini key still works when flag is off", async () => {
+  test("direct Gemini key still works without managed proxy", async () => {
     disableManagedProxy();
-    disableFlag();
     mockProviderKeys[credentialKey("gemini", "api_key")] = "user-gemini-key";
     const config = makeConfig({ provider: "gemini" });
 

package/src/__tests__/empty-response-hook.test.ts

@@ -31,7 +31,7 @@ import {
   REFUSAL_NUDGE_TEXT,
 } from "../plugins/defaults/empty-response/hooks/stop.js";
 import stop from "../plugins/defaults/empty-response/hooks/stop.js";
-import { defaultEmptyResponsePlugin } from "../plugins/defaults/empty-response/register.js";
+import { defaultEmptyResponsePlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,

package/src/__tests__/file-write-tool.test.ts

@@ -260,3 +260,66 @@ describe("file_write tool PKB re-index hook", () => {
     expect(existsSync(join(workingDir, "pkb", "oops.md"))).toBe(true);
   });
 });
+
+describe("file_write artifact-HTML guard", () => {
+  test("rejects a self-contained interactive HTML visualization", async () => {
+    const dir = makeTempDir();
+    const html =
+      "<!doctype html><html><head><title>Food Market</title></head>" +
+      "<body><canvas id='c'></canvas><script>" +
+      ("const data=[{x:1,y:2}];").padEnd(4000, "/") +
+      "new Chart(document.getElementById('c'), {data});</script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "food-market-stats.html", content: html },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(existsSync(join(dir, "food-market-stats.html"))).toBe(false);
+  });
+
+  test("allows app-builder's thin shell index.html (external module script)", async () => {
+    const dir = makeTempDir();
+    const shell =
+      "<!doctype html><html><head>" +
+      "<link rel='stylesheet' href='/src/styles.css'>".padEnd(3200, " ") +
+      "</head><body><div id='app'></div>" +
+      "<script type='module' src='/src/main.tsx'></script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "src/index.html", content: shell },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "src", "index.html"))).toBe(true);
+  });
+
+  test("allows a small/static HTML snippet", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      { path: "note.html", content: "<html><body><h1>Hi</h1></body></html>" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "note.html"))).toBe(true);
+  });
+
+  test("allows a non-HTML file even with inline script-like content", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      {
+        path: "notes.md",
+        content:
+          "<script>" + "x".padEnd(2000, "x") + "</script>" + "\n# notes\n",
+      },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "notes.md"))).toBe(true);
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -27,6 +27,7 @@ const ALLOWLIST = new Set([
   "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
+  "apps/macos/src/main/bundle-flow.ts", // Electron main calls the local gateway (gatewayPort) with a Guardian token to scan bundles
   ".claude/skills/update/SKILL.md", // daemon health check script
 
   // --- Test fixtures that poll the daemon directly (gateway may require auth) ---
@@ -84,12 +85,26 @@ function isGatewayInternal(filePath: string): boolean {
   return filePath.startsWith("gateway/");
 }
 
+/** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
+const INTERPOLATED_PORT_ALLOWLIST = new Set([
+  "apps/macos/src/main/bundle-flow.ts",
+  // Electron main bridges the host proxy to a local assistant's gateway
+  // (gatewayPort) over loopback with a Guardian-minted gateway token — same
+  // class as bundle-flow.ts. Added with #34049 (host proxy for cloud/managed
+  // assistants); the allowlist entry was missed there.
+  "apps/macos/src/main/host-proxy-router.ts",
+]);
+
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */
-function filterViolations(files: string[]): string[] {
+function filterViolations(
+  files: string[],
+  extraAllowlist?: Set<string>,
+): string[] {
   return files.filter((f) => {
     if (isTestFile(f)) return false;
     if (isGatewayInternal(f)) return false;
     if (ALLOWLIST.has(f)) return false;
+    if (extraAllowlist?.has(f)) return false;
     return true;
   });
 }
@@ -181,7 +196,7 @@ describe("gateway-only API consumption guard", () => {
     }
 
     const files = grepOutput.split("\n").filter((f) => f.length > 0);
-    const violations = filterViolations(files);
+    const violations = filterViolations(files, INTERPOLATED_PORT_ALLOWLIST);
 
     if (violations.length > 0) {
       const message = [

package/src/__tests__/guardian-grant-minting.test.ts

@@ -20,7 +20,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -21,7 +21,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
@@ -51,9 +51,7 @@ import {
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import {
-  listGuardianDecisionPrompts,
-} from "../runtime/routes/guardian-action-routes.js";
+import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
 
@@ -1334,6 +1332,97 @@ describe("routing invariant: callback buttons route through canonical primitive"
   });
 });
 
+// ===========================================================================
+// SECTION 8b: route-owned (directResolve) confirmations resolve via the
+// channel/guardian-action path too.
+//
+// The ACP spawn/steer approval gate (acp-routes.ts, ATL-822) registers
+// pending confirmations with a `directResolve` callback rather than a
+// Conversation.prompter. The tool_approval resolver must fire that callback
+// directly; otherwise a guardian approval submitted over a channel never
+// reaches the waiting route and the spawn/resume hangs until timeout.
+// ===========================================================================
+
+describe("routing invariant: directResolve interactions resolve via guardian decisions", () => {
+  beforeEach(() => resetTables());
+
+  function registerDirectResolveInteraction(
+    requestId: string,
+    conversationId: string,
+  ): string[] {
+    const decisions: string[] = [];
+    pendingInteractions.register(requestId, {
+      conversationId,
+      kind: "confirmation",
+      confirmationDetails: {
+        toolName: "acp_spawn",
+        input: { agent: "claude", task: "t", cwd: "/work" },
+        riskLevel: "high",
+        executionTarget: "host",
+        allowlistOptions: [],
+        scopeOptions: [],
+        persistentDecisionsAllowed: false,
+      },
+      directResolve: (d) => decisions.push(d),
+    });
+    return decisions;
+  }
+
+  test("channel approval fires directResolve('allow') with no live Conversation", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    // Deliberately no _conversationMocks entry: the prompter path would have
+    // failed with conversation_not_found, proving directResolve is what runs.
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:approve_once`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["allow"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("approved");
+  });
+
+  test("channel rejection fires directResolve('deny')", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:reject`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["deny"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("denied");
+  });
+});
+
 // ===========================================================================
 // SECTION 9: Destination hints do not bypass principal binding for tool_approval
 // ===========================================================================

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -143,7 +143,7 @@ mock.module("../util/logger.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { handleConfirmationResponse } from "../daemon/handlers/conversations.js";
 
 describe("handleConfirmationResponse canonical status sync", () => {

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -56,6 +56,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   countCompletedHeartbeatRuns: mock(() => 10),
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/heartbeat-service.test.ts

@@ -32,6 +32,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   listHeartbeatRuns: mockListHeartbeatRuns,
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/history-repair-hook.test.ts

@@ -21,8 +21,8 @@ import type {
   UserPromptSubmitContext,
 } from "../plugin-api/types.js";
 import userPromptSubmit from "../plugins/defaults/history-repair/hooks/user-prompt-submit.js";
-import { defaultHistoryRepairPlugin } from "../plugins/defaults/history-repair/register.js";
 import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import { defaultHistoryRepairPlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,
@@ -40,6 +40,10 @@ const noopLogger: PluginLogger = {
 function makeCtx(messages: Message[]): UserPromptSubmitContext {
   return {
     conversationId: "conv-test",
+    userMessageId: "msg-test",
+    requestId: "req-test",
+    modelProfileKey: null,
+    isNonInteractive: false,
     prompt: "",
     originalMessages: messages,
     latestMessages: messages,

package/src/__tests__/host-app-control-proxy.test.ts

@@ -372,6 +372,49 @@ describe("HostAppControlProxy", () => {
       proxy.dispose();
     });
 
+    test("non-start tool with mismatched target client is rejected", async () => {
+      mockActorMap.set("client-A", "user-1");
+      mockActorMap.set("client-B", "user-1");
+      const proxy = new HostAppControlProxy("conv-1");
+      const startCtrl = new AbortController();
+
+      const pStart = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        startCtrl.signal,
+        "user-1",
+        "client-A",
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await pStart;
+      sentMessages.length = 0;
+
+      const result = await proxy.request(
+        "app_control_type",
+        {
+          tool: "type",
+          app: "com.example.editor",
+          text: "hello",
+        },
+        "conv-1",
+        new AbortController().signal,
+        "user-1",
+        "client-B",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("client-A");
+      expect(result.content).toContain("client-B");
+      expect(result.content).toContain("app_control_start");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
     test("non-start tool with case-different but otherwise matching app is allowed", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const startCtrl = new AbortController();
@@ -1297,6 +1340,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(
@@ -1332,6 +1376,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(

package/src/__tests__/host-app-control-routes.test.ts

@@ -47,7 +47,7 @@ interface FakeConversation {
 
 const conversations = new Map<string, FakeConversation>();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversations.get(id),
 }));