@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -153,25 +153,18 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).toContain("## First-Run User Context");
       expect(dynamic).toContain(
-        "The user completed the native pre-chat onboarding.",
-      );
-      expect(dynamic).toContain('"tools"');
-      expect(dynamic).toContain('"slack"');
-      expect(dynamic).toContain('"linear"');
-      expect(dynamic).toContain('"tasks"');
-      expect(dynamic).toContain('"code-building"');
-      expect(dynamic).toContain('"tone": "warm"');
-      expect(dynamic).toContain('"userName": "Alex"');
-      expect(dynamic).toContain('"assistantName": "Nova"');
-      expect(dynamic).toContain("```json");
-      expect(dynamic).toContain(
-        "Use this to personalize your opener and skip redundant discovery.",
-      );
-      expect(dynamic).toContain(
-        "If `assistantName` is present, it is the name the user chose for you; preserve it in IDENTITY.md.",
+        "The user completed setup before this conversation.",
       );
+      expect(dynamic).toContain("- Daily tools: Slack, Linear");
+      expect(dynamic).toContain("- Common work: builds code, apps, or tools");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).toContain("- Chosen assistant name: Nova");
+      expect(dynamic).toContain("Apply this context quietly.");
+
+      // Raw JSON must NOT be present
+      expect(dynamic).not.toContain("```json");
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {
@@ -186,9 +179,9 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
-      expect(dynamic).not.toContain("pre-chat onboarding");
-      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
     });
 
     test("does NOT inject onboarding context when excludeBootstrap is true", () => {
@@ -209,7 +202,7 @@ describe("pre-chat onboarding contract", () => {
       });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
       expect(dynamic).not.toContain("First-Run Ritual");
     });
 
@@ -225,7 +218,7 @@ describe("pre-chat onboarding contract", () => {
       // Bootstrap should still be present
       expect(dynamic).toContain("First-Run Ritual");
       // But no onboarding context section
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
     });
 
     test("accepts all four personality tones", () => {
@@ -247,12 +240,12 @@ describe("pre-chat onboarding contract", () => {
         const result = buildSystemPrompt({ onboardingContext: context });
         const dynamic = dynamicBlock(result);
 
-        expect(dynamic).toContain("## Pre-chat Onboarding Context");
-        expect(dynamic).toContain(`"tone": "${tone}"`);
+        expect(dynamic).toContain("## First-Run User Context");
+        expect(dynamic).toContain(`- Preferred initial voice: ${tone}`);
       }
     });
 
-    test("serializes onboarding context as pretty-printed JSON", () => {
+    test("renders compact markdown, not JSON", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
         "# Bootstrap\n\nOnboarding.",
@@ -269,9 +262,65 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      // Verify it contains the pretty-printed JSON (indented with 2 spaces)
+      // Should contain compact markdown lines
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Jane");
+      expect(dynamic).toContain("- Common work: plans and coordinates work");
+      expect(dynamic).toContain("- Daily tools: Notion");
+      expect(dynamic).toContain("- Chosen assistant name: Kit");
+      expect(dynamic).toContain("- Preferred initial voice: warm");
+
+      // Must NOT contain JSON output
+      expect(dynamic).not.toContain("```json");
       const expectedJson = JSON.stringify(context, null, 2);
-      expect(dynamic).toContain(expectedJson);
+      expect(dynamic).not.toContain(expectedJson);
+    });
+
+    test("empty tools/tasks arrays result in no Daily tools / Common work lines", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: [],
+        tasks: [],
+        tone: "warm",
+        userName: "Alex",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Common work:");
+    });
+
+    test("absent userName results in no Name line", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Name:");
+      // Other fields should still be present
+      expect(dynamic).toContain("- Daily tools: Slack");
+      expect(dynamic).toContain(
+        "- Common work: writes docs, emails, or content",
+      );
+      expect(dynamic).toContain("- Preferred initial voice: warm");
     });
   });
 
@@ -290,4 +339,142 @@ describe("pre-chat onboarding contract", () => {
       expect(true).toBe(true); // structural acknowledgment
     });
   });
+
+  describe("end-to-end onboarding integration", () => {
+    test("with BOOTSTRAP.md present, onboarding context produces compact markdown with normalized labels", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nWelcome to your first conversation.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack", "notion", "linear"],
+        tasks: ["code-building", "writing", "project-management"],
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Heading is present
+      expect(dynamic).toContain("## First-Run User Context");
+
+      // Normalized labels appear (capitalised tool names, human-readable task descriptions)
+      expect(dynamic).toContain("- Daily tools: Slack, Notion, Linear");
+      expect(dynamic).toContain("- Name: Alice");
+      expect(dynamic).toContain("- Chosen assistant name: Pax");
+      expect(dynamic).toContain("- Preferred initial voice: grounded");
+      // Common work descriptions are normalised from task IDs
+      expect(dynamic).toContain("- Common work:");
+
+      // No raw JSON anywhere in the dynamic block
+      expect(dynamic).not.toContain("```json");
+      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain('"tasks"');
+      expect(dynamic).not.toContain('"tone"');
+      expect(dynamic).not.toContain('"userName"');
+      expect(dynamic).not.toContain('"assistantName"');
+    });
+
+    test("without BOOTSTRAP.md, onboarding context does NOT appear in system prompt", () => {
+      // No BOOTSTRAP.md created — simulates a returning user session
+      const context: OnboardingContext = {
+        tools: ["slack", "figma"],
+        tasks: ["design", "writing"],
+        tone: "warm",
+        userName: "Bob",
+        assistantName: "Kit",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Onboarding section must be absent
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Bob");
+      expect(dynamic).not.toContain("- Chosen assistant name:");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("excludeBootstrap suppresses both bootstrap and onboarding sections", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nFirst run instructions.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["linear"],
+        tasks: ["code-building"],
+        tone: "energetic",
+        userName: "Charlie",
+        assistantName: "Nova",
+      };
+
+      const result = buildSystemPrompt({
+        onboardingContext: context,
+        excludeBootstrap: true,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both bootstrap and onboarding must be suppressed
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Charlie");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("userPersona is included independently of onboarding context", () => {
+      // No BOOTSTRAP.md — the durable persona path after bootstrap is deleted
+      const personaContent =
+        "# User Persona\n\nPrefers concise answers. Works in fintech.";
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        // No onboardingContext — simulates post-onboarding conversation
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Persona content appears in prompt even without bootstrap or onboarding
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Prefers concise answers. Works in fintech.");
+
+      // No onboarding section should be present
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+    });
+
+    test("userPersona appears alongside onboarding context during first run", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding flow.",
+      );
+
+      const personaContent =
+        "# User Persona\n\nEarly-stage startup founder. Likes bullet points.";
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+        userName: "Dana",
+      };
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        onboardingContext: context,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both persona and onboarding context appear
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Likes bullet points.");
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Dana");
+      expect(dynamic).toContain("- Daily tools: Slack");
+    });
+  });
 });

package/src/__tests__/provider-tool-name.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isProviderSafeToolName,
+  toProviderSafeToolName,
+} from "../tools/provider-tool-name.js";
+
+describe("provider tool names", () => {
+  test("leaves already-safe names unchanged", () => {
+    expect(toProviderSafeToolName("deploy")).toBe("deploy");
+    expect(isProviderSafeToolName("deploy")).toBe(true);
+  });
+
+  test("preserves raw-name identity for names that differ by edge whitespace", () => {
+    const plain = toProviderSafeToolName("deploy");
+    const padded = toProviderSafeToolName(" deploy ");
+
+    expect(plain).toBe("deploy");
+    expect(padded).toMatch(/^deploy__[a-f0-9]{12}$/);
+    expect(padded).not.toBe(plain);
+    expect(isProviderSafeToolName(padded)).toBe(true);
+  });
+});

package/src/__tests__/relay-server.test.ts

@@ -362,11 +362,24 @@ function getLatestAssistantText(conversationId: string): string | null {
     if (Array.isArray(parsed)) {
       return parsed
         .filter(
-          (block): block is { type: string; text?: string } =>
-            typeof block === "object" && block != null,
+          (
+            block,
+          ): block is {
+            type: string;
+            text?: string;
+            surfaceType?: string;
+            data?: { summaryText?: string };
+          } => typeof block === "object" && block != null,
         )
-        .filter((block) => block.type === "text")
-        .map((block) => block.text ?? "")
+        .map((block) => {
+          if (block.type === "text") return block.text ?? "";
+          if (
+            block.type === "ui_surface" &&
+            block.surfaceType === "call_summary"
+          )
+            return block.data?.summaryText ?? "";
+          return "";
+        })
         .join("");
     }
     if (typeof parsed === "string") return parsed;
@@ -2321,7 +2334,7 @@ describe("relay-server", () => {
 
       expect(relay.getConnectionState()).toBe("awaiting_name");
 
-      // Fallback prompt should NOT include assistant name but should include guardian label
+      // Fallback prompt should use the existing guardian-label wording.
       const textMessages = ws.sentMessages
         .map((raw) => JSON.parse(raw) as { type: string; token?: string })
         .filter((m) => m.type === "text");
@@ -2337,6 +2350,48 @@ describe("relay-server", () => {
     }
   });
 
+  test("inbound voice: unknown caller name capture does not speak a UUID assistant name", async () => {
+    const prevName = mockAssistantName;
+    mockAssistantName = "11111111-2222-4333-8444-555555555555";
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    try {
+      ensureConversation("conv-invite-uuid-name");
+      const session = createCallSession({
+        conversationId: "conv-invite-uuid-name",
+        provider: "twilio",
+        fromNumber: "+12125550157",
+        toNumber: "+12125550111",
+      });
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_invite_uuid_name",
+          from: "+12125550157",
+          to: "+12125550111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("awaiting_name");
+
+      const promptText = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text")
+        .map((m) => m.token ?? "")
+        .join("");
+      expect(promptText).toContain("Hi, this is my human's assistant.");
+      expect(promptText).not.toContain("11111111-2222-4333-8444-555555555555");
+
+      relay.destroy();
+    } finally {
+      mockAssistantName = prevName;
+    }
+  });
+
   // ── Friend-initiated in-call guardian approval flow ────────────────────
 
   test("name capture flow: caller provides name and enters guardian decision wait", async () => {

package/src/__tests__/runtime-events-sse.test.ts

@@ -135,12 +135,10 @@ describe("SSE assistant-events endpoint", () => {
     // Read the first frame directly from the stream.
     const reader = stream.getReader();
 
-    // The first chunk is the immediate heartbeat (comment + data event) enqueued in start().
+    // The first chunk is the immediate heartbeat comment enqueued in start().
     const initial = await reader.read();
     expect(initial.done).toBe(false);
-    const initialText = new TextDecoder().decode(initial.value);
-    expect(initialText).toContain(": heartbeat");
-    expect(initialText).toContain('{"type":"heartbeat"}');
+    expect(new TextDecoder().decode(initial.value)).toBe(": heartbeat\n\n");
 
     // The second chunk is the actual assistant event.
     const { value, done } = await reader.read();
@@ -172,12 +170,10 @@ describe("SSE assistant-events endpoint", () => {
 
     const reader = stream.getReader();
 
-    // Consume the initial heartbeat (comment + data event).
+    // Consume the initial heartbeat.
     const heartbeat = await reader.read();
     expect(heartbeat.done).toBe(false);
-    const heartbeatText = new TextDecoder().decode(heartbeat.value);
-    expect(heartbeatText).toContain(": heartbeat");
-    expect(heartbeatText).toContain('{"type":"heartbeat"}');
+    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
 
     // Publish events with two different conversationIds.
     const eventA = buildAssistantEvent({ type: "pong" }, "conversation-aaa");

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

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+  truncateForLog: (value: string) => value,
+}));
+
+mock.module("../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: mock(() =>
+    Promise.resolve({ invoked: true, producedToolCalls: false }),
+  ),
+}));
+
+mock.module("../home/emit-feed-event.js", () => ({
+  emitFeedEvent: mock(() => Promise.resolve()),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getConfigReadOnly: () => ({}),
+  applyNestedDefaults: (config: unknown) => config,
+  deepMergeOverwrite: (base: unknown) => base,
+  mergeDefaultWorkspaceConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  API_KEY_PROVIDERS: [],
+  _appendQuarantineBulletin: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+let locked = true;
+mock.module("../daemon/disk-pressure-background-gate.js", () => ({
+  checkDiskPressureBackgroundGate: () =>
+    locked
+      ? {
+          action: "skip",
+          reason: "disk_pressure",
+          blockedCapability: "background-work",
+          status: {
+            enabled: true,
+            state: "critical",
+            locked: true,
+            acknowledged: true,
+            overrideActive: false,
+            effectivelyLocked: true,
+            lockId: "disk-pressure-test",
+            usagePercent: 98,
+            thresholdPercent: 95,
+            path: "/",
+            lastCheckedAt: "2026-05-05T00:00:00.000Z",
+            blockedCapabilities: [
+              "agent-turns",
+              "background-work",
+              "remote-ingress",
+            ],
+            error: null,
+          },
+        }
+      : {
+          action: "allow",
+          status: {
+            enabled: false,
+            state: "disabled",
+            locked: false,
+            acknowledged: false,
+            overrideActive: false,
+            effectivelyLocked: false,
+            lockId: null,
+            usagePercent: null,
+            thresholdPercent: 95,
+            path: null,
+            lastCheckedAt: null,
+            blockedCapabilities: [],
+            error: null,
+          },
+        },
+  diskPressureBackgroundSkipLogFields: () => ({
+    reason: "disk_pressure",
+    thresholdPercent: 95,
+    usagePercent: 98,
+    blockedCapability: "background-work",
+    lockId: "disk-pressure-test",
+    path: "/",
+  }),
+  shouldLogDiskPressureBackgroundSkip: () => true,
+}));
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { createSchedule } from "../schedule/schedule-store.js";
+import { runScheduleOnce } from "../schedule/scheduler.js";
+
+initializeDb();
+
+function rawDb(): import("bun:sqlite").Database {
+  return (getDb() as unknown as { $client: import("bun:sqlite").Database })
+    .$client;
+}
+
+describe("scheduler disk pressure gate", () => {
+  beforeEach(() => {
+    locked = true;
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+    db.run("DELETE FROM task_runs");
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("skips before claiming due schedules while disk pressure is locked", async () => {
+    const dueAt = Date.now() - 10_000;
+    const schedule = createSchedule({
+      name: "Due reminder",
+      message: "Do not fire while locked",
+      mode: "notify",
+      nextRunAt: dueAt,
+    });
+
+    const processMessage = mock(() => Promise.resolve());
+    const notify = mock(() => Promise.resolve());
+
+    const processed = await runScheduleOnce(processMessage, notify);
+
+    expect(processed).toBe(0);
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(notify).not.toHaveBeenCalled();
+
+    const row = rawDb()
+      .query("SELECT status, next_run_at FROM cron_jobs WHERE id = ?")
+      .get(schedule.id) as { status: string; next_run_at: number } | null;
+    expect(row).toEqual({ status: "active", next_run_at: dueAt });
+
+    const runCount = rawDb()
+      .query("SELECT COUNT(*) AS count FROM cron_runs")
+      .get() as { count: number };
+    expect(runCount.count).toBe(0);
+  });
+});

package/src/__tests__/secret-ingress-http.test.ts

@@ -106,7 +106,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => undefined,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
-  getConversationMemoryScopeId: () => undefined,
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({

package/src/__tests__/secret-prompt-log-hygiene.test.ts

@@ -39,15 +39,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 }));
 
 // Stub pendingInteractions — SecretPrompter registers/resolves there now
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -38,15 +38,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: ServerMessage) => broadcastMessages.push(msg),
 }));
 
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 const { SecretPrompter } = await import("../permissions/secret-prompter.js");

package/src/__tests__/secret-response-routing.test.ts

@@ -11,15 +11,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
 }));
 
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 const { SecretPrompter } = await import("../permissions/secret-prompter.js");