@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/conversation-history-boundary-repair-failure.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../plugins/defaults/memory/indexer.js", () => ({
+  MIN_SEGMENT_CHARS: 50,
+  indexMessageNow: async () => ({ indexedSegments: 0, enqueuedJobs: 0 }),
+  enqueueBackfillJob: () => "",
+  enqueueRebuildIndexJob: () => "",
+}));
+
+import { consolidateAssistantMessages } from "../daemon/conversation-history.js";
+import {
+  addMessage,
+  createConversation,
+  deleteLastExchange,
+  getMessages,
+} from "../persistence/conversation-crud.js";
+import {
+  beginConversationModeSession,
+  updateConversationModeSessionBoundaries,
+} from "../persistence/conversation-mode-sessions.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+const FAIL_REPAIR_TRIGGER = "fail_mode_session_boundary_repair";
+
+function installFailingBoundaryRepairTrigger(): void {
+  getDb().run(/* sql */ `
+    CREATE TRIGGER ${FAIL_REPAIR_TRIGGER}
+    BEFORE UPDATE ON conversation_mode_sessions
+    BEGIN
+      SELECT RAISE(ABORT, 'injected boundary repair failure');
+    END
+  `);
+}
+
+afterEach(() => {
+  getDb().run(`DROP TRIGGER IF EXISTS ${FAIL_REPAIR_TRIGGER}`);
+});
+
+describe("message deletion mode-session boundary repair failures", () => {
+  test("consolidation deletes every donor without duplicating copied content", async () => {
+    const conversation = createConversation("Boundary repair consolidation");
+    const sessionId = `session-${conversation.id}`;
+    const owner = { id: sessionId, mode: "browser" as const };
+    const sourceStartedAt = Date.now() - 10_000;
+    expect(
+      beginConversationModeSession({
+        id: sessionId,
+        conversationId: conversation.id,
+        mode: owner.mode,
+        sourceStartedAt,
+      }),
+    ).toMatchObject({ ok: true });
+
+    const user = await addMessage(conversation.id, "user", "Run the tool");
+    const retained = await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([
+        { type: "tool_use", id: "tool-1", name: "example", input: {} },
+      ]),
+      { metadata: { modeSession: owner } },
+    );
+    const toolResult = await addMessage(
+      conversation.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tool-1", content: "done" },
+      ]),
+      { metadata: { modeSession: owner } },
+    );
+    const donor = await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Finished once." }]),
+      { metadata: { modeSession: owner } },
+    );
+    expect(
+      updateConversationModeSessionBoundaries({
+        id: sessionId,
+        conversationId: conversation.id,
+        expectedRevision: 1,
+        firstIncluded: {
+          at: retained.createdAt,
+          messageId: retained.id,
+        },
+        lastActivityAt: donor.createdAt,
+        lastOwnedMessageId: donor.id,
+      }),
+    ).toMatchObject({ ok: true });
+    installFailingBoundaryRepairTrigger();
+
+    expect(consolidateAssistantMessages(conversation.id, user.id)).toBe(true);
+    const rows = getMessages(conversation.id);
+    expect(rows.map((row) => row.id)).toEqual([user.id, retained.id]);
+    const retainedContent = rows[1]!.content;
+    expect(retainedContent).toEqual([
+      { type: "tool_use", id: "tool-1", name: "example", input: {} },
+      { type: "text", text: "Finished once." },
+      { type: "tool_result", tool_use_id: "tool-1", content: "done" },
+    ]);
+
+    expect(consolidateAssistantMessages(conversation.id, user.id)).toBe(false);
+    expect(getMessages(conversation.id)[1]!.content).toEqual(retainedContent);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === donor.id),
+    ).toBe(false);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === toolResult.id),
+    ).toBe(false);
+  });
+
+  test("tail deletion returns its committed count when boundary repair fails", async () => {
+    const conversation = createConversation("Boundary repair tail delete");
+    const sessionId = `session-${conversation.id}`;
+    const owner = { id: sessionId, mode: "browser" as const };
+    expect(
+      beginConversationModeSession({
+        id: sessionId,
+        conversationId: conversation.id,
+        mode: owner.mode,
+        sourceStartedAt: Date.now() - 10_000,
+      }),
+    ).toMatchObject({ ok: true });
+    const keptUser = await addMessage(conversation.id, "user", "Keep this");
+    const keptAssistant = await addMessage(
+      conversation.id,
+      "assistant",
+      "Kept reply",
+    );
+    const deletedUser = await addMessage(
+      conversation.id,
+      "user",
+      "Delete this",
+      { metadata: { modeSession: owner } },
+    );
+    const deletedAssistant = await addMessage(
+      conversation.id,
+      "assistant",
+      "Deleted reply",
+      { metadata: { modeSession: owner } },
+    );
+    expect(
+      updateConversationModeSessionBoundaries({
+        id: sessionId,
+        conversationId: conversation.id,
+        expectedRevision: 1,
+        firstIncluded: {
+          at: deletedAssistant.createdAt,
+          messageId: deletedAssistant.id,
+        },
+        lastActivityAt: deletedAssistant.createdAt,
+        lastOwnedMessageId: deletedAssistant.id,
+      }),
+    ).toMatchObject({ ok: true });
+    installFailingBoundaryRepairTrigger();
+
+    expect(deleteLastExchange(conversation.id)).toBe(2);
+    expect(getMessages(conversation.id).map((row) => row.id)).toEqual([
+      keptUser.id,
+      keptAssistant.id,
+    ]);
+    expect(
+      getMessages(conversation.id).some((row) => row.id === deletedUser.id),
+    ).toBe(false);
+    expect(
+      getMessages(conversation.id).some(
+        (row) => row.id === deletedAssistant.id,
+      ),
+    ).toBe(false);
+  });
+});

package/src/__tests__/conversation-loop-db-lock-resilience.test.ts

@@ -89,6 +89,7 @@ import {
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const CONVERSATION_ID = "test-session-id";
 
@@ -101,6 +102,7 @@ function createMockDeps(): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (_msg: AssistantEvent) => {},
     reqId: "test-req-id",

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -87,6 +87,7 @@ import {
   type QueuedMessage,
 } from "../daemon/conversation-queue-manager.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ---------------------------------------------------------------------------
 // Fake context — captures preactivation calls, satisfies the bare minimum
@@ -117,6 +118,7 @@ function makeFakeContext(opts: {
     abortController: null,
     queue: opts.queue,
     surfaceActionRequestIds: new Set<string>(),
+    modeSessions: mockUnownedModeSessions(),
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     get preactivatedSkillIds(): string[] | undefined {
       return preactivatedSkillIds;

package/src/__tests__/conversation-rendered-delegation-state.test.ts

@@ -0,0 +1,276 @@
+/**
+ * `Conversation.buildCurrentSystemPrompt` captures the delegation-section
+ * state the prompt it builds renders (`renderedDelegateIndependentTasks`),
+ * which the wire-surface recorder persists for a retrospective fork to
+ * replay. The loop sends the prompt built before the run and never rebuilds
+ * it mid-run, so the captured state has to be the one that build used: not a
+ * re-derivation at send time, and not the state of a build that failed while
+ * the loop kept its previous prompt.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede Conversation import
+// ---------------------------------------------------------------------------
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+// The builder under the conversation's control: records the options each
+// build receives and can be made to throw, which is what a wake's prompt
+// sync swallows before running on the previous prompt.
+let builtWith: Array<Record<string, unknown> | undefined> = [];
+let throwOnBuild = false;
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: (options?: Record<string, unknown>) => {
+    if (throwOnBuild) {
+      throw new Error("prompt build failed");
+    }
+    builtWith.push(options);
+    return "system prompt";
+  },
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: `msg-${Date.now()}` }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../persistence/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: `att-${Date.now()}` }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
+  ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
+    constructor() {}
+    updateConfig() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+    resetOverflowRecovery() {}
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../persistence/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
+    setSystemPrompt() {}
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import Conversation AFTER mocks
+// ---------------------------------------------------------------------------
+
+import { Conversation } from "../daemon/conversation.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProvider() {
+  return {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+let conversationSeq = 0;
+
+/**
+ * A conversation whose prompt is built, or, given a prompt other than the
+ * builder's, one running on a verbatim system-prompt override.
+ */
+function makeConversation(systemPrompt = "system prompt"): Conversation {
+  conversationSeq += 1;
+  return new Conversation(
+    `conv-rendered-delegation-${conversationSeq}`,
+    makeProvider(),
+    systemPrompt,
+    (_msg: AssistantEvent) => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+}
+
+function lastBuildDelegation(): unknown {
+  return builtWith.at(-1)?.delegateIndependentTasks;
+}
+
+beforeEach(() => {
+  builtWith = [];
+  throwOnBuild = false;
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Conversation.buildCurrentSystemPrompt delegation-state capture", () => {
+  test("captures the state the build rendered and hands the builder the same value", () => {
+    const conversation = makeConversation();
+    expect(conversation.renderedDelegateIndependentTasks).toBeUndefined();
+
+    conversation.buildCurrentSystemPrompt();
+
+    // An unrestricted turn can spawn, so the section renders on.
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+    expect(lastBuildDelegation()).toBe(true);
+  });
+
+  test("a change to the gate's inputs after the build does not touch the captured state until the next build", () => {
+    const conversation = makeConversation();
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    // The loop is still sending the prompt built above, so the recorder must
+    // see that prompt's state, whatever the gate would derive now.
+    conversation.setSubagentAllowedTools(new Set(["remember"]));
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(false);
+    expect(lastBuildDelegation()).toBe(false);
+  });
+
+  test("a failed build leaves the previously captured state in place", () => {
+    const conversation = makeConversation();
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    // A wake's prompt sync swallows this and runs on the previous prompt,
+    // whose section is still on, even though a rebuild would now render it
+    // off.
+    conversation.setSubagentAllowedTools(new Set(["remember"]));
+    throwOnBuild = true;
+    expect(() => conversation.buildCurrentSystemPrompt()).toThrow(
+      "prompt build failed",
+    );
+
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+  });
+
+  test("a verbatim system-prompt override captures unknown", () => {
+    const conversation = makeConversation("override prompt");
+    builtWith = [];
+
+    expect(conversation.buildCurrentSystemPrompt()).toBe("override prompt");
+
+    expect(conversation.renderedDelegateIndependentTasks).toBeNull();
+    // The override is returned as is; nothing is built.
+    expect(builtWith).toEqual([]);
+  });
+
+  test("a replaying wake's recorded state wins over the derivation", () => {
+    const conversation = makeConversation();
+    // Replaying a channel-sourced conversation that recorded the section off,
+    // on a wake whose own scope could spawn.
+    conversation.delegateIndependentTasksReplay = false;
+
+    conversation.buildCurrentSystemPrompt();
+
+    expect(conversation.renderedDelegateIndependentTasks).toBe(false);
+    expect(lastBuildDelegation()).toBe(false);
+  });
+});

package/src/__tests__/conversation-retry-route.test.ts

@@ -197,6 +197,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
   const emitActivityState = mock(
     (_phase: string, _reason: string, _options?: unknown) => {},
   );
+  const invalidateAllStructuralWaits = mock(() => 0);
   const conversation = {
     conversationId: "conv-retry-test",
     trustContext: undefined,
@@ -209,6 +210,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
     loadFromDb,
     runAgentLoop,
     emitActivityState,
+    modeSessions: { invalidateAllStructuralWaits },
   };
   return {
     conversation,
@@ -217,6 +219,7 @@ function makeConversation(opts: { processing?: boolean } = {}) {
     loadFromDb,
     runAgentLoop,
     emitActivityState,
+    invalidateAllStructuralWaits,
   };
 }
 
@@ -264,6 +267,24 @@ beforeEach(() => {
 });
 
 describe("POST /v1/conversations/:id/retry", () => {
+  test("tracking invalidation failure does not prevent retry", async () => {
+    const ctx = makeConversation();
+    activeConversation = ctx.conversation;
+    ctx.invalidateAllStructuralWaits.mockImplementation(() => {
+      throw new Error("session tracking unavailable");
+    });
+    const res = await callHandler(
+      retryHandler,
+      makeRequest(),
+      { id: "conv-retry-test" },
+      202,
+    );
+    expect(res.status).toBe(202);
+    await settle();
+    expect(discardMock).toHaveBeenCalledTimes(1);
+    expect(ctx.runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+
   test("202s, discards the tail, and re-runs the loop from the anchor", async () => {
     const ctx = makeConversation();
     activeConversation = ctx.conversation;
@@ -299,6 +320,7 @@ describe("POST /v1/conversations/:id/retry", () => {
     expect(ctx.conversation.isProcessing()).toBe(true);
     expect(ctx.conversation.abortController).not.toBeNull();
     expect(discardMock).toHaveBeenCalledWith("conv-retry-test");
+    expect(ctx.invalidateAllStructuralWaits).toHaveBeenCalledTimes(1);
 
     // Origin-less invalidation: the initiating client reconciles too.
     expect(publishConversationMessagesChangedMock).toHaveBeenCalledTimes(1);

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -32,6 +32,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import { setConfig } from "./helpers/set-config.js";
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
@@ -88,6 +89,7 @@ function createFakeConversation(conversationId: string): Conversation {
     conversationId,
     processing: false,
     currentRequestId: undefined as string | undefined,
+    modeSessions: mockUnownedModeSessions(),
     abortController: null as AbortController | null,
     trustContext: undefined as unknown,
     turnChannelContext: null as {

package/src/__tests__/conversation-routes-enabled-plugins.test.ts

@@ -135,6 +135,7 @@ mock.module("../ipc/gateway-client.js", () => ({
 import { getEffectiveEnabledPluginSet } from "../daemon/conversation-tool-setup.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 function makeConversation() {
   const runAgentLoop = mock(async () => undefined);
@@ -156,6 +157,7 @@ function makeConversation() {
     },
     abortController: null,
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: { length: 0 },
     setTrustContext: () => {},
     replayActivityState: () => {},

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -113,6 +113,7 @@ mock.module("../contacts/guardian-delivery-reader.js", () => ({
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const _testAuthContext: AuthContext = {
   subject: "actor:self:test-guardian",
@@ -185,6 +186,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -275,6 +277,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -353,6 +356,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -442,6 +446,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -529,6 +534,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -612,6 +618,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -689,6 +696,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -768,6 +776,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -848,6 +857,7 @@ describe("handleSendMessage guardian reply interception", () => {
       setHostAppControlProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as import("../daemon/conversation.js").Conversation;
 
     const req = new Request("http://localhost/v1/messages", {

package/src/__tests__/conversation-routes-hidden-queue.test.ts

@@ -126,6 +126,7 @@ import {
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const CONV_ID = "conv-hidden-queue";
 
@@ -159,6 +160,7 @@ function makeConversationWithPendingConfirmation(
       },
     },
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: {
       length: 0,
       promoteToHead: (requestId: string) => ({ requestId }),

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -166,6 +166,7 @@ import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const _testAuthContext: AuthContext = {
   subject: "actor:self:test-guardian",
@@ -233,6 +234,7 @@ function makeConversation() {
     messages,
     abortController: null,
     currentRequestId: undefined,
+    modeSessions: mockUnownedModeSessions(),
     queue: { length: 0 },
     setTrustContext: () => {},
     replayActivityState: () => {},