@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/{session-queue.test.ts → conversation-queue.test.ts}

@@ -10,7 +10,7 @@ import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
-// Mocks — must precede the Session import so Bun applies them at load time.
+// Mocks — must precede the Conversation import so Bun applies them at load time.
 // ---------------------------------------------------------------------------
 
 function makeLoggerStub(): Record<string, unknown> {
@@ -69,11 +69,10 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
     skills: { entries: {}, allowBundled: true },
     permissions: { mode: "workspace" },
-    sandbox: { enabled: false },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -81,6 +80,19 @@ mock.module("../config/loader.js", () => ({
       titleGenerationMaxTokens: 30,
       standaloneRecording: true,
     },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -101,13 +113,6 @@ mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => [],
 }));
 
-mock.module("../skills/slash-commands.js", () => ({
-  buildInvocableSlashCatalog: () => new Map(),
-  resolveSlashSkillCommand: () => ({ kind: "not_slash" }),
-  rewriteKnownSlashCommandPrompt: () => "",
-  parseSlashCandidate: () => ({ kind: "not_slash" }),
-}));
-
 mock.module("../permissions/trust-store.js", () => ({
   addRule: () => {},
   findHighestPriorityRule: () => null,
@@ -119,7 +124,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -172,7 +177,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../context/window-manager.js", () => ({
@@ -198,7 +203,7 @@ mock.module("../context/window-manager.js", () => ({
 
 const turnCommitCalls: Array<{
   workspaceDir: string;
-  sessionId: string;
+  conversationId: string;
   turnNumber: number;
 }> = [];
 let turnCommitHangForever = false;
@@ -284,27 +289,29 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Import Session AFTER mocks are registered.
+// Import Conversation AFTER mocks are registered.
 // ---------------------------------------------------------------------------
 
-import type { QueueDrainReason, QueuePolicy } from "../daemon/session.js";
-import { Session } from "../daemon/session.js";
-import { MessageQueue } from "../daemon/session-queue-manager.js";
+import type { QueueDrainReason, QueuePolicy } from "../daemon/conversation.js";
+import { Conversation } from "../daemon/conversation.js";
+import { MessageQueue } from "../daemon/conversation-queue-manager.js";
 
-type SessionWithWorkspaceDeps = Session & {
+type ConversationWithWorkspaceDeps = Conversation & {
   getWorkspaceGitService?: (_workspaceDir: string) => {
     ensureInitialized: () => Promise<void>;
   };
   commitTurnChanges?: (
     workspaceDir: string,
-    sessionId: string,
+    conversationId: string,
     turnNumber: number,
     provider?: unknown,
     deadlineMs?: number,
   ) => Promise<void>;
 };
 
-function makeSession(sendToClient?: (msg: ServerMessage) => void): Session {
+function makeConversation(
+  sendToClient?: (msg: ServerMessage) => void,
+): Conversation {
   const provider = {
     name: "mock",
     async sendMessage(): Promise<ProviderResponse> {
@@ -316,7 +323,7 @@ function makeSession(sendToClient?: (msg: ServerMessage) => void): Session {
       };
     },
   };
-  const session = new Session(
+  const conversationObj = new Conversation(
     "conv-1",
     provider,
     "system prompt",
@@ -324,22 +331,23 @@ function makeSession(sendToClient?: (msg: ServerMessage) => void): Session {
     sendToClient ?? (() => {}),
     "/tmp",
   );
-  const sessionWithWorkspaceDeps = session as SessionWithWorkspaceDeps;
-  sessionWithWorkspaceDeps.getWorkspaceGitService = () => ({
+  const conversationWithWorkspaceDeps =
+    conversationObj as ConversationWithWorkspaceDeps;
+  conversationWithWorkspaceDeps.getWorkspaceGitService = () => ({
     ensureInitialized: async () => {},
   });
-  sessionWithWorkspaceDeps.commitTurnChanges = async (
+  conversationWithWorkspaceDeps.commitTurnChanges = async (
     workspaceDir: string,
-    sessionId: string,
+    conversationId: string,
     turnNumber: number,
   ) => {
-    turnCommitCalls.push({ workspaceDir, sessionId, turnNumber });
+    turnCommitCalls.push({ workspaceDir, conversationId, turnNumber });
     if (turnCommitHangForever) {
       // Simulate a commit that never resolves within the timeout budget
       await new Promise<void>(() => {});
     }
   };
-  return session;
+  return conversationObj;
 }
 
 /**
@@ -378,7 +386,7 @@ async function waitForCondition(
 
 /**
  * Resolve the Nth pending AgentLoop.run() call. Fires the minimal events
- * that `runAgentLoop` expects (usage + message_complete) so the session
+ * that `runAgentLoop` expects (usage + message_complete) so the conversation
  * cleanly transitions out of its processing state.
  */
 function resolveRun(index: number) {
@@ -415,20 +423,20 @@ afterAll(() => {
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("Session message queue", () => {
+describe("Conversation message queue", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
 
-  test("second message is queued when session is busy (does not throw)", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+  test("second message is queued when conversation is busy (does not throw)", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events1: ServerMessage[] = [];
     const events2: ServerMessage[] = [];
 
     // Start first message — this will block on AgentLoop.run
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events1.push(e),
@@ -438,11 +446,11 @@ describe("Session message queue", () => {
     // Wait for the first AgentLoop.run to be registered
     await waitForPendingRun(1);
 
-    // Session should now be processing
-    expect(session.isProcessing()).toBe(true);
+    // Conversation should now be processing
+    expect(conversation.isProcessing()).toBe(true);
 
     // Enqueue second message — should NOT throw
-    const result = session.enqueueMessage(
+    const result = conversation.enqueueMessage(
       "msg-2",
       [],
       (e) => events2.push(e),
@@ -450,7 +458,7 @@ describe("Session message queue", () => {
     );
     expect(result.queued).toBe(true);
     expect(result.requestId).toBe("req-2");
-    expect(session.getQueueDepth()).toBe(1);
+    expect(conversation.getQueueDepth()).toBe(1);
 
     // Complete the first message
     resolveRun(0);
@@ -471,8 +479,8 @@ describe("Session message queue", () => {
   });
 
   test("[experimental] queued messages are processed in FIFO order", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const processedOrder: string[] = [];
 
@@ -481,7 +489,7 @@ describe("Session message queue", () => {
     };
 
     // Start first message
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       makeHandler("msg-1"),
@@ -490,9 +498,9 @@ describe("Session message queue", () => {
     await waitForPendingRun(1);
 
     // Enqueue two more
-    session.enqueueMessage("msg-2", [], makeHandler("msg-2"), "req-2");
-    session.enqueueMessage("msg-3", [], makeHandler("msg-3"), "req-3");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("msg-2", [], makeHandler("msg-2"), "req-2");
+    conversation.enqueueMessage("msg-3", [], makeHandler("msg-3"), "req-3");
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete first → triggers second
     resolveRun(0);
@@ -511,17 +519,17 @@ describe("Session message queue", () => {
   });
 
   test("message_queued and message_dequeued events are emitted", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events2: ServerMessage[] = [];
 
     // Start first message
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // Enqueue second — simulating what handleUserMessage does
-    const result = session.enqueueMessage(
+    const result = conversation.enqueueMessage(
       "msg-2",
       [],
       (e) => events2.push(e),
@@ -539,71 +547,75 @@ describe("Session message queue", () => {
     expect(dequeued).toBeDefined();
     expect(dequeued).toEqual({
       type: "message_dequeued",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
       requestId: "req-2",
     });
 
-    // Complete second run so the session finishes cleanly
+    // Complete second run so the conversation finishes cleanly
     resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
   test("abort() clears the queue and sends generation_cancelled for each queued message", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events2: ServerMessage[] = [];
     const events3: ServerMessage[] = [];
 
     // Start first message
-    session.processMessage("msg-1", [], () => {}, "req-1");
+    conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // Enqueue two more
-    session.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
-    session.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
+    conversation.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Abort
-    session.abort();
+    conversation.abort();
 
     // Queue should be empty
-    expect(session.getQueueDepth()).toBe(0);
+    expect(conversation.getQueueDepth()).toBe(0);
 
-    // Both queued messages should receive session-scoped cancellation events.
+    // Both queued messages should receive conversation-scoped cancellation events.
     const cancel2 = events2.find((e) => e.type === "generation_cancelled");
     expect(cancel2).toEqual({
       type: "generation_cancelled",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
     });
 
     const cancel3 = events3.find((e) => e.type === "generation_cancelled");
     expect(cancel3).toEqual({
       type: "generation_cancelled",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
     });
 
-    // abort() must NOT emit session_error or generic error for queued discards.
+    // abort() must NOT emit conversation_error or generic error for queued discards.
     const err2 = events2.find((e) => e.type === "error");
     expect(err2).toBeUndefined();
     const err3 = events3.find((e) => e.type === "error");
     expect(err3).toBeUndefined();
 
-    const sessionErr2 = events2.find((e) => e.type === "session_error");
-    expect(sessionErr2).toBeUndefined();
+    const conversationErr2 = events2.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationErr2).toBeUndefined();
 
-    const sessionErr3 = events3.find((e) => e.type === "session_error");
-    expect(sessionErr3).toBeUndefined();
+    const conversationErr3 = events3.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationErr3).toBeUndefined();
   });
 
-  test("session-scoped errors emit both session_error and generic error", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+  test("conversation-scoped errors emit both conversation_error and generic error", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events: ServerMessage[] = [];
 
     // Start a message — blocks on AgentLoop.run
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events.push(e),
@@ -616,9 +628,9 @@ describe("Session message queue", () => {
     pendingRuns[0].reject(new Error("Provider returned 500"));
     await p1;
 
-    // Should emit session_error (typed, structured)
-    const sessionErr = events.find((e) => e.type === "session_error");
-    expect(sessionErr).toBeDefined();
+    // Should emit conversation_error (typed, structured)
+    const conversationErr = events.find((e) => e.type === "conversation_error");
+    expect(conversationErr).toBeDefined();
 
     // Should also emit generic error (callers rely on error events to detect failures)
     const genericErr = events.find((e) => e.type === "error");
@@ -626,42 +638,42 @@ describe("Session message queue", () => {
   });
 
   test("queue depth is reported correctly as messages are added and drained", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start first message
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
-    expect(session.getQueueDepth()).toBe(0);
+    expect(conversation.getQueueDepth()).toBe(0);
 
-    session.enqueueMessage("msg-2", [], () => {}, "req-2");
-    expect(session.getQueueDepth()).toBe(1);
+    conversation.enqueueMessage("msg-2", [], () => {}, "req-2");
+    expect(conversation.getQueueDepth()).toBe(1);
 
-    session.enqueueMessage("msg-3", [], () => {}, "req-3");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("msg-3", [], () => {}, "req-3");
+    expect(conversation.getQueueDepth()).toBe(2);
 
-    session.enqueueMessage("msg-4", [], () => {}, "req-4");
-    expect(session.getQueueDepth()).toBe(3);
+    conversation.enqueueMessage("msg-4", [], () => {}, "req-4");
+    expect(conversation.getQueueDepth()).toBe(3);
 
     // Complete first → drains one from queue
     resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(session.getQueueDepth()).toBe(2);
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete second → drains another
     resolveRun(1);
     await waitForPendingRun(3);
 
-    expect(session.getQueueDepth()).toBe(1);
+    expect(conversation.getQueueDepth()).toBe(1);
 
     // Complete third → drains last
     resolveRun(2);
     await waitForPendingRun(4);
 
-    expect(session.getQueueDepth()).toBe(0);
+    expect(conversation.getQueueDepth()).toBe(0);
 
     // Complete fourth (final queued message)
     resolveRun(3);
@@ -669,15 +681,15 @@ describe("Session message queue", () => {
   });
 
   test("[experimental] drain continues after a queued message fails to persist", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events1: ServerMessage[] = [];
     const events2: ServerMessage[] = [];
     const events3: ServerMessage[] = [];
 
     // Start first message — blocks on AgentLoop.run
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events1.push(e),
@@ -686,10 +698,10 @@ describe("Session message queue", () => {
     await waitForPendingRun(1);
 
     // Enqueue a message with empty content (will fail persistUserMessage)
-    session.enqueueMessage("", [], (e) => events2.push(e), "req-2");
+    conversation.enqueueMessage("", [], (e) => events2.push(e), "req-2");
     // Enqueue a valid message after the bad one
-    session.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete first message — triggers drain. The empty message should fail
     // to persist, but the drain should continue to msg-3.
@@ -722,28 +734,28 @@ describe("Session message queue", () => {
 // Queue policy primitives
 // ---------------------------------------------------------------------------
 
-describe("Session queue policy helpers", () => {
+describe("Conversation queue policy helpers", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
 
-  test("hasQueuedMessages() returns false on a fresh session", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
-    expect(session.hasQueuedMessages()).toBe(false);
+  test("hasQueuedMessages() returns false on a fresh conversation", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    expect(conversation.hasQueuedMessages()).toBe(false);
   });
 
   test("hasQueuedMessages() returns true after enqueuing while processing", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing to make the session busy
-    session.processMessage("msg-1", [], () => {}, "req-1");
+    conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // Enqueue a message while processing
-    session.enqueueMessage("msg-2", [], () => {}, "req-2");
-    expect(session.hasQueuedMessages()).toBe(true);
+    conversation.enqueueMessage("msg-2", [], () => {}, "req-2");
+    expect(conversation.hasQueuedMessages()).toBe(true);
 
     // Cleanup: resolve the pending run
     resolveRun(0);
@@ -753,24 +765,24 @@ describe("Session queue policy helpers", () => {
   });
 
   test("canHandoffAtCheckpoint() returns false when not processing", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Not processing, no queued messages
-    expect(session.canHandoffAtCheckpoint()).toBe(false);
+    expect(conversation.canHandoffAtCheckpoint()).toBe(false);
   });
 
   test("canHandoffAtCheckpoint() returns false when processing but no queued messages", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing — but don't enqueue anything
-    session.processMessage("msg-1", [], () => {}, "req-1");
+    conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
-    expect(session.isProcessing()).toBe(true);
-    expect(session.hasQueuedMessages()).toBe(false);
-    expect(session.canHandoffAtCheckpoint()).toBe(false);
+    expect(conversation.isProcessing()).toBe(true);
+    expect(conversation.hasQueuedMessages()).toBe(false);
+    expect(conversation.canHandoffAtCheckpoint()).toBe(false);
 
     // Cleanup
     resolveRun(0);
@@ -778,19 +790,19 @@ describe("Session queue policy helpers", () => {
   });
 
   test("canHandoffAtCheckpoint() returns true when processing and queue has messages", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing
-    session.processMessage("msg-1", [], () => {}, "req-1");
+    conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // Enqueue a message
-    session.enqueueMessage("msg-2", [], () => {}, "req-2");
+    conversation.enqueueMessage("msg-2", [], () => {}, "req-2");
 
-    expect(session.isProcessing()).toBe(true);
-    expect(session.hasQueuedMessages()).toBe(true);
-    expect(session.canHandoffAtCheckpoint()).toBe(true);
+    expect(conversation.isProcessing()).toBe(true);
+    expect(conversation.hasQueuedMessages()).toBe(true);
+    expect(conversation.canHandoffAtCheckpoint()).toBe(true);
 
     // Cleanup
     resolveRun(0);
@@ -821,19 +833,19 @@ describe("Session queue policy helpers", () => {
 // Checkpoint handoff tests
 // ---------------------------------------------------------------------------
 
-describe("Session checkpoint handoff", () => {
+describe("Conversation checkpoint handoff", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
 
   test("[experimental] onCheckpoint yields when there is a queued message", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events1: ServerMessage[] = [];
 
     // Start processing first message
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events1.push(e),
@@ -842,8 +854,8 @@ describe("Session checkpoint handoff", () => {
     await waitForPendingRun(1);
 
     // Enqueue a second message while the first is processing
-    session.enqueueMessage("msg-2", [], () => {}, "req-2");
-    expect(session.hasQueuedMessages()).toBe(true);
+    conversation.enqueueMessage("msg-2", [], () => {}, "req-2");
+    expect(conversation.hasQueuedMessages()).toBe(true);
 
     // The pending run should have received an onCheckpoint callback.
     // Simulate the agent loop calling it at a turn boundary.
@@ -859,7 +871,7 @@ describe("Session checkpoint handoff", () => {
     // Because there is a queued message, the callback should return 'yield'
     expect(decision).toBe("yield");
 
-    // Complete the run so the session finishes cleanly
+    // Complete the run so the conversation finishes cleanly
     resolveRun(0);
     await p1;
 
@@ -868,7 +880,7 @@ describe("Session checkpoint handoff", () => {
     expect(handoff).toBeDefined();
     expect(handoff).toMatchObject({
       type: "generation_handoff",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
       requestId: "req-1",
       queuedCount: 1,
     });
@@ -880,14 +892,14 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("onCheckpoint returns continue when queue is empty", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing — no enqueued messages
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
-    expect(session.hasQueuedMessages()).toBe(false);
+    expect(conversation.hasQueuedMessages()).toBe(false);
 
     // The pending run should have an onCheckpoint callback
     const run = pendingRuns[0];
@@ -908,8 +920,8 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("[experimental] FIFO ordering is preserved through checkpoint handoff", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const processedOrder: string[] = [];
 
@@ -919,7 +931,7 @@ describe("Session checkpoint handoff", () => {
     };
 
     // Start first message
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       makeHandler("msg-1"),
@@ -928,9 +940,9 @@ describe("Session checkpoint handoff", () => {
     await waitForPendingRun(1);
 
     // Enqueue two messages
-    session.enqueueMessage("msg-2", [], makeHandler("msg-2"), "req-2");
-    session.enqueueMessage("msg-3", [], makeHandler("msg-3"), "req-3");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("msg-2", [], makeHandler("msg-2"), "req-2");
+    conversation.enqueueMessage("msg-3", [], makeHandler("msg-3"), "req-3");
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Simulate the agent loop yielding at the checkpoint (first run)
     const run0 = pendingRuns[0];
@@ -963,14 +975,14 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("[experimental] active run with repeated tool turns + queued message triggers checkpoint handoff", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const events1: ServerMessage[] = [];
     const events2: ServerMessage[] = [];
 
     // Start processing first message
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events1.push(e),
@@ -979,8 +991,8 @@ describe("Session checkpoint handoff", () => {
     await waitForPendingRun(1);
 
     // Enqueue a second message while the first is processing
-    session.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
-    expect(session.hasQueuedMessages()).toBe(true);
+    conversation.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
+    expect(conversation.hasQueuedMessages()).toBe(true);
 
     // Simulate tool-use turns: the agent loop calls onCheckpoint at each turn boundary.
     // Because there is a queued message, the callback should return 'yield'.
@@ -1006,13 +1018,13 @@ describe("Session checkpoint handoff", () => {
     expect(handoff).toBeDefined();
     expect(handoff).toMatchObject({
       type: "generation_handoff",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
       requestId: "req-1",
       queuedCount: 1,
     });
     // message_complete should NOT be in events1 (handoff replaces it)
     const messageComplete = events1.find(
-      (e) => e.type === "message_complete" && "sessionId" in e,
+      (e) => e.type === "message_complete" && "conversationId" in e,
     );
     expect(messageComplete).toBeUndefined();
 
@@ -1026,8 +1038,8 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("queued messages still drain FIFO under multiple handoffs", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const dequeueOrder: string[] = [];
 
@@ -1037,7 +1049,7 @@ describe("Session checkpoint handoff", () => {
     };
 
     // Start processing message A
-    const pA = session.processMessage(
+    const pA = conversation.processMessage(
       "msg-A",
       [],
       (e) => eventsA.push(e),
@@ -1046,10 +1058,10 @@ describe("Session checkpoint handoff", () => {
     await waitForPendingRun(1);
 
     // Enqueue messages B, C, D
-    session.enqueueMessage("msg-B", [], makeHandler("B"), "req-B");
-    session.enqueueMessage("msg-C", [], makeHandler("C"), "req-C");
-    session.enqueueMessage("msg-D", [], makeHandler("D"), "req-D");
-    expect(session.getQueueDepth()).toBe(3);
+    conversation.enqueueMessage("msg-B", [], makeHandler("B"), "req-B");
+    conversation.enqueueMessage("msg-C", [], makeHandler("C"), "req-C");
+    conversation.enqueueMessage("msg-D", [], makeHandler("D"), "req-D");
+    expect(conversation.getQueueDepth()).toBe(3);
 
     // Handoff from A -> B
     const runA = pendingRuns[0];
@@ -1117,15 +1129,15 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("[experimental] queued persistence failure does not strand later messages", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const eventsA: ServerMessage[] = [];
     const eventsB: ServerMessage[] = [];
     const eventsC: ServerMessage[] = [];
 
     // Start processing message A
-    const pA = session.processMessage(
+    const pA = conversation.processMessage(
       "msg-A",
       [],
       (e) => eventsA.push(e),
@@ -1134,9 +1146,9 @@ describe("Session checkpoint handoff", () => {
     await waitForPendingRun(1);
 
     // Enqueue B (empty content — will fail to persist) and C (valid)
-    session.enqueueMessage("", [], (e) => eventsB.push(e), "req-B");
-    session.enqueueMessage("msg-C", [], (e) => eventsC.push(e), "req-C");
-    expect(session.getQueueDepth()).toBe(2);
+    conversation.enqueueMessage("", [], (e) => eventsB.push(e), "req-B");
+    conversation.enqueueMessage("msg-C", [], (e) => eventsC.push(e), "req-C");
+    expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete message A — triggers drain. B should fail, C should proceed.
     resolveRun(0);
@@ -1164,11 +1176,11 @@ describe("Session checkpoint handoff", () => {
   });
 
   test("onCheckpoint callback is passed to both initial and retry runs", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // The first run should have onCheckpoint
@@ -1202,17 +1214,17 @@ describe("Session checkpoint handoff", () => {
 // Usage requestId correlation
 // ---------------------------------------------------------------------------
 
-describe("Session usage requestId correlation", () => {
+describe("Conversation usage requestId correlation", () => {
   beforeEach(() => {
     pendingRuns = [];
     capturedUsageEvents = [];
   });
 
   test("usage events recorded during a request carry that request ID", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-42");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-42");
     await waitForPendingRun(1);
 
     // Complete the run — this triggers recordUsage with the request's ID
@@ -1239,19 +1251,19 @@ describe("Terminal trace events on rejection/failure", () => {
 
   test("queued persist failure emits request_error trace", async () => {
     const traceEvents: ServerMessage[] = [];
-    const session = makeSession((msg) => {
+    const conversation = makeConversation((msg) => {
       if ("type" in msg && msg.type === "trace_event") traceEvents.push(msg);
     });
-    await session.loadFromDb();
+    await conversation.loadFromDb();
 
     // Start first message
-    const p1 = session.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
     await waitForPendingRun(1);
 
     // Enqueue empty content (will fail persistUserMessage)
-    session.enqueueMessage("", [], () => {}, "req-bad");
+    conversation.enqueueMessage("", [], () => {}, "req-bad");
     // Enqueue valid message so drain continues
-    session.enqueueMessage("msg-3", [], () => {}, "req-3");
+    conversation.enqueueMessage("msg-3", [], () => {}, "req-3");
 
     // Complete first — triggers drain, empty msg fails persist
     resolveRun(0);
@@ -1278,7 +1290,7 @@ describe("Terminal trace events on rejection/failure", () => {
 // Host attachment approval tests
 // ---------------------------------------------------------------------------
 
-describe("Session host attachment directives", () => {
+describe("Conversation host attachment directives", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
@@ -1290,10 +1302,10 @@ describe("Session host attachment directives", () => {
     try {
       const clientEvents: ServerMessage[] = [];
       const events: ServerMessage[] = [];
-      const session = makeSession((msg) => clientEvents.push(msg));
-      await session.loadFromDb();
+      const conversation = makeConversation((msg) => clientEvents.push(msg));
+      await conversation.loadFromDb();
 
-      const p1 = session.processMessage(
+      const p1 = conversation.processMessage(
         "msg-1",
         [],
         (e) => events.push(e),
@@ -1328,16 +1340,18 @@ describe("Session host attachment directives", () => {
         (e) => e.type === "confirmation_request",
       );
       expect(confirmation).toBeDefined();
-      session.handleConfirmationResponse(
+      conversation.handleConfirmationResponse(
         (confirmation as { requestId: string }).requestId,
         "allow",
       );
 
       await p1;
 
-      expect(session.lastAssistantAttachments).toHaveLength(1);
-      expect(session.lastAssistantAttachments[0].sourceType).toBe("host_file");
-      expect(session.lastAttachmentWarnings).toHaveLength(0);
+      expect(conversation.lastAssistantAttachments).toHaveLength(1);
+      expect(conversation.lastAssistantAttachments[0].sourceType).toBe(
+        "host_file",
+      );
+      expect(conversation.lastAttachmentWarnings).toHaveLength(0);
 
       const completion = events.find((e) => e.type === "message_complete");
       expect(completion).toBeDefined();
@@ -1353,10 +1367,10 @@ describe("Session host attachment directives", () => {
     try {
       const clientEvents: ServerMessage[] = [];
       const events: ServerMessage[] = [];
-      const session = makeSession((msg) => clientEvents.push(msg));
-      await session.loadFromDb();
+      const conversation = makeConversation((msg) => clientEvents.push(msg));
+      await conversation.loadFromDb();
 
-      const p1 = session.processMessage(
+      const p1 = conversation.processMessage(
         "msg-1",
         [],
         (e) => events.push(e),
@@ -1391,16 +1405,16 @@ describe("Session host attachment directives", () => {
         (e) => e.type === "confirmation_request",
       );
       expect(confirmation).toBeDefined();
-      session.handleConfirmationResponse(
+      conversation.handleConfirmationResponse(
         (confirmation as { requestId: string }).requestId,
         "deny",
       );
 
       await p1;
 
-      expect(session.lastAssistantAttachments).toHaveLength(0);
+      expect(conversation.lastAssistantAttachments).toHaveLength(0);
       expect(
-        session.lastAttachmentWarnings.some((w) =>
+        conversation.lastAttachmentWarnings.some((w) =>
           w.includes("access denied by user"),
         ),
       ).toBe(true);
@@ -1423,17 +1437,17 @@ describe("Session host attachment directives", () => {
 // Attachment payload emission tests
 // ---------------------------------------------------------------------------
 
-describe("Session attachment event payloads", () => {
+describe("Conversation attachment event payloads", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
 
   test("message_complete includes assistant attachments", async () => {
     const events: ServerMessage[] = [];
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events.push(e),
@@ -1487,10 +1501,10 @@ describe("Session attachment event payloads", () => {
 
   test("generation_handoff includes assistant attachments", async () => {
     const events1: ServerMessage[] = [];
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events1.push(e),
@@ -1499,7 +1513,7 @@ describe("Session attachment event payloads", () => {
     await waitForPendingRun(1);
 
     // Queue a second message so the first run yields via checkpoint handoff.
-    session.enqueueMessage("msg-2", [], () => {}, "req-2");
+    conversation.enqueueMessage("msg-2", [], () => {}, "req-2");
 
     const run = pendingRuns[0];
     expect(run.onCheckpoint).toBeDefined();
@@ -1560,7 +1574,7 @@ describe("Session attachment event payloads", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Regression: cancel semantics + session/global error channel split
+// Regression: cancel semantics + conversation/global error channel split
 // ---------------------------------------------------------------------------
 
 describe("Regression: cancel semantics and error channel split", () => {
@@ -1568,13 +1582,13 @@ describe("Regression: cancel semantics and error channel split", () => {
     pendingRuns = [];
   });
 
-  test("user cancellation emits generation_cancelled, never session_error", async () => {
+  test("user cancellation emits generation_cancelled, never conversation_error", async () => {
     const msgEvents: ServerMessage[] = [];
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     // Start processing a message — collect events from the per-message callback
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => msgEvents.push(e),
@@ -1583,7 +1597,7 @@ describe("Regression: cancel semantics and error channel split", () => {
     await waitForPendingRun(1);
 
     // User cancels — sets the abort signal
-    session.abort();
+    conversation.abort();
 
     // Resolve the pending run so the abort-check path fires
     resolveRun(0);
@@ -1595,18 +1609,20 @@ describe("Regression: cancel semantics and error channel split", () => {
     );
     expect(cancelEvent).toBeDefined();
 
-    // session_error must never appear on cancel
-    const sessionErr = msgEvents.find((e) => e.type === "session_error");
-    expect(sessionErr).toBeUndefined();
+    // conversation_error must never appear on cancel
+    const conversationErr = msgEvents.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationErr).toBeUndefined();
   });
 
   test("post-processing failure still attempts turn-boundary commit", async () => {
     const events: ServerMessage[] = [];
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
     linkAttachmentShouldThrow = true;
 
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => events.push(e),
@@ -1644,19 +1660,19 @@ describe("Regression: cancel semantics and error channel split", () => {
     expect(turnCommitCalls).toHaveLength(1);
     expect(turnCommitCalls[0]).toEqual({
       workspaceDir: "/tmp",
-      sessionId: "conv-1",
+      conversationId: "conv-1",
       turnNumber: 1,
     });
     const err = events.find((e) => e.type === "error");
     expect(err).toBeDefined();
   });
 
-  test("provider failure during processing emits both session_error and generic error", async () => {
+  test("provider failure during processing emits both conversation_error and generic error", async () => {
     const allEvents: ServerMessage[] = [];
-    const session = makeSession();
-    await session.loadFromDb();
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
-    const p1 = session.processMessage(
+    const p1 = conversation.processMessage(
       "msg-1",
       [],
       (e) => allEvents.push(e),
@@ -1668,22 +1684,24 @@ describe("Regression: cancel semantics and error channel split", () => {
     pendingRuns[0].reject(new Error("Connection refused"));
     await p1;
 
-    // Should get session_error (structured)
-    const sessionErr = allEvents.find((e) => e.type === "session_error");
-    expect(sessionErr).toBeDefined();
+    // Should get conversation_error (structured)
+    const conversationErr = allEvents.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationErr).toBeDefined();
 
     // Should also get generic error
     const genericErr = allEvents.find((e) => e.type === "error");
     expect(genericErr).toBeDefined();
   });
 
-  test("cancel after queued messages produces no session_error for any queued entry", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
+  test("cancel after queued messages produces no conversation_error for any queued entry", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
 
     const eventsPerMsg: ServerMessage[][] = [[], [], []];
 
-    session.processMessage(
+    conversation.processMessage(
       "msg-1",
       [],
       (e) => eventsPerMsg[0].push(e),
@@ -1691,40 +1709,53 @@ describe("Regression: cancel semantics and error channel split", () => {
     );
     await waitForPendingRun(1);
 
-    session.enqueueMessage(
+    conversation.enqueueMessage(
       "msg-2",
       [],
       (e) => eventsPerMsg[1].push(e),
       "req-2",
     );
-    session.enqueueMessage(
+    conversation.enqueueMessage(
       "msg-3",
       [],
       (e) => eventsPerMsg[2].push(e),
       "req-3",
     );
 
-    session.abort();
+    conversation.abort();
 
-    // No queued message should have received session_error
+    // No queued message should have received conversation_error
     for (const events of eventsPerMsg) {
-      const sessionErr = events.find((e) => e.type === "session_error");
-      expect(sessionErr).toBeUndefined();
+      const conversationErr = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationErr).toBeUndefined();
     }
   });
 
   test("commitTurnChanges never resolving within budget -> turn still completes and drains queue", async () => {
-    const session = makeSession();
-    await session.loadFromDb();
-
-    turnCommitHangForever = true;
+    // Replace setTimeout with a zero-delay version so the 4000ms
+    // raceWithTimeout fires instantly instead of waiting real time.
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
 
     try {
+      const conversation = makeConversation();
+      await conversation.loadFromDb();
+
+      turnCommitHangForever = true;
+
       const events1: ServerMessage[] = [];
       const events2: ServerMessage[] = [];
 
       // Start first message (promise intentionally not awaited — we test queue drain behavior)
-      const _p1 = session.processMessage(
+      const _p1 = conversation.processMessage(
         "msg-1",
         [],
         (e) => events1.push(e),
@@ -1733,17 +1764,15 @@ describe("Regression: cancel semantics and error channel split", () => {
       await waitForPendingRun(1);
 
       // Enqueue a second message while the first is processing
-      session.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
+      conversation.enqueueMessage("msg-2", [], (e) => events2.push(e), "req-2");
 
       // Complete the first agent loop run
       resolveRun(0);
 
       // The turn should still complete (timeout fires) and drain the queue
       // even though commitTurnChanges never resolves.
-      // The default turnCommitMaxWaitMs is 4000ms in the config mock,
-      // but the mock config doesn't set it, so it defaults to 4000ms.
-      // We wait for the second run to be registered, which proves the
-      // turn completed and the queue drained despite the hanging commit.
+      // With the zero-delay setTimeout wrapper the 4000ms budget fires
+      // instantly, so we only need a short wait for the second run.
       await waitForPendingRun(2, 10_000);
 
       // First message should have completed
@@ -1760,9 +1789,10 @@ describe("Regression: cancel semantics and error channel split", () => {
       // Complete the second run so the test can clean up
       turnCommitHangForever = false;
       resolveRun(1);
-      await new Promise((r) => setTimeout(r, 10));
+      await new Promise((r) => origSetTimeout(r, 10));
     } finally {
       turnCommitHangForever = false;
+      globalThis.setTimeout = origSetTimeout;
     }
   }, 15_000);
 });