@vellumai/assistant 0.5.13 → 0.5.15

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -3,27 +3,8 @@
  * job also deletes the schedule, preventing orphaned scheduled automations.
  */
 
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = mkdtempSync(
-  join(tmpdir(), "conv-delete-schedule-cleanup-test-"),
-);
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -50,11 +31,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function getRawDb(): Database {

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

@@ -8,12 +8,10 @@
 import {
   existsSync,
   mkdirSync,
-  mkdtempSync,
   readdirSync,
   readFileSync,
   rmSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -21,25 +19,10 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 // Mocks — must come before any imports that depend on them
 // ---------------------------------------------------------------------------
 
-const testDir = mkdtempSync(join(tmpdir(), "conv-disk-view-integration-"));
-const workspaceDir = join(testDir, "workspace");
+const workspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 const conversationsDir = join(workspaceDir, "conversations");
 mkdirSync(conversationsDir, { recursive: true });
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => join(workspaceDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => conversationsDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-  getRootDir: () => testDir,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -82,11 +65,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function resetTables() {

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

@@ -14,25 +14,10 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 // Mocks — must come before any imports that depend on them
 // ---------------------------------------------------------------------------
 
-const testDir = mkdtempSync(join(tmpdir(), "conv-disk-view-test-"));
-const workspaceDir = join(testDir, "workspace");
+const workspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 const conversationsDir = join(workspaceDir, "conversations");
 mkdirSync(conversationsDir, { recursive: true });
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => join(workspaceDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => conversationsDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-  getRootDir: () => testDir,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -82,11 +67,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function resetTables() {
@@ -555,9 +535,7 @@ describe("syncMessageToDisk", () => {
 
     syncMessageToDisk(conv.id, msg.id, createdAt);
 
-    expect(
-      existsSync(join(legacyDirPath, "messages.jsonl")),
-    ).toBe(true);
+    expect(existsSync(join(legacyDirPath, "messages.jsonl"))).toBe(true);
     expect(existsSync(join(newDirPath, "messages.jsonl"))).toBe(false);
     expect(existsSync(join(legacyDirPath, "attachments", "legacy.png"))).toBe(
       true,
@@ -611,9 +589,9 @@ describe("syncMessageToDisk", () => {
     const record = JSON.parse(lines[0]);
     expect(record.content).toBe("Disk repair");
     expect(record.attachments).toHaveLength(1);
-    expect(existsSync(join(dirPath, "attachments", record.attachments[0]))).toBe(
-      true,
-    );
+    expect(
+      existsSync(join(dirPath, "attachments", record.attachments[0])),
+    ).toBe(true);
 
     rmSync(dirPath, { recursive: true, force: true });
   });

package/src/__tests__/conversation-error.test.ts

@@ -368,7 +368,7 @@ describe("classifyConversationError", () => {
         baseCtx,
       );
       expect(result.code).toBe("CONVERSATION_PROCESSING_FAILED");
-      expect(result.retryable).toBe(false);
+      expect(result.retryable).toBe(true);
       expect(result.userMessage).toContain("something completely unexpected");
       expect(result.errorCategory).toBe("processing_failed");
     });

package/src/__tests__/conversation-fork-crud.test.ts

@@ -1,36 +1,9 @@
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { eq, like } from "drizzle-orm";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "conversation-fork-crud-test-")),
-);
-const workspaceDir = join(testDir, ".vellum", "workspace");
-const conversationsDir = join(workspaceDir, "conversations");
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => join(testDir, ".vellum"),
-  getDataDir: () => join(workspaceDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => conversationsDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -100,11 +73,6 @@ function parseMetadata(metadata: string | null): unknown {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("forkConversation", () => {

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

@@ -1,27 +1,5 @@
-import { mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "conversation-fork-route-test-")),
-);
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => join(testDir, ".vellum"),
-  getDataDir: () => join(testDir, ".vellum", "workspace", "data"),
-  getWorkspaceDir: () => join(testDir, ".vellum", "workspace"),
-  getConversationsDir: () =>
-    join(testDir, ".vellum", "workspace", "conversations"),
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -123,11 +101,6 @@ describe("POST /v1/conversations/fork", () => {
   afterAll(async () => {
     await server?.stop();
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   test("returns the same conversation summary shape as GET /v1/conversations/:id", async () => {

package/src/__tests__/conversation-history-web-search.test.ts

@@ -60,6 +60,10 @@ mock.module("../memory/jobs-store.js", () => ({
   enqueueMemoryJob: () => {},
 }));
 
+mock.module("../memory/llm-request-log-store.js", () => ({
+  relinkLlmRequestLogs: () => {},
+}));
+
 mock.module("../memory/qdrant-circuit-breaker.js", () => ({
   withQdrantBreaker: async (fn: () => Promise<unknown>) => fn(),
 }));
@@ -504,22 +508,25 @@ describe("ensureToolPairing with server_tool_use / web_search_tool_result", () =
     default: class MockAnthropic {
       static APIError = FakeAPIError;
       constructor(_args: Record<string, unknown>) {}
-      messages = {
-        stream: (
-          params: Record<string, unknown>,
-          _options?: Record<string, unknown>,
-        ) => {
-          lastStreamParams = JSON.parse(JSON.stringify(params));
-          const handlers: Record<string, ((...args: unknown[]) => void)[]> = {};
-          return {
-            on(event: string, cb: (...args: unknown[]) => void) {
-              (handlers[event] ??= []).push(cb);
-              return this;
-            },
-            async finalMessage() {
-              return fakeResponse;
-            },
-          };
+      beta = {
+        messages: {
+          stream: (
+            params: Record<string, unknown>,
+            _options?: Record<string, unknown>,
+          ) => {
+            lastStreamParams = JSON.parse(JSON.stringify(params));
+            const handlers: Record<string, ((...args: unknown[]) => void)[]> =
+              {};
+            return {
+              on(event: string, cb: (...args: unknown[]) => void) {
+                (handlers[event] ??= []).push(cb);
+                return this;
+              },
+              async finalMessage() {
+                return fakeResponse;
+              },
+            };
+          },
         },
       };
     },

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -18,8 +18,7 @@
  * - Conversation creation (3 preactivated skills): < 300ms
  * - Conversation constructor (sync, no loadFromDb): < 10ms
  */
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterAll, describe, expect, mock, test } from "bun:test";
 
@@ -31,7 +30,7 @@ function median(sorted: number[]): number {
     : sorted[mid];
 }
 
-const testDir = mkdtempSync(join(tmpdir(), "session-init-bench-"));
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 
 // Create subdirectories expected by platform helpers
 mkdirSync(join(testDir, "data"), { recursive: true });
@@ -83,39 +82,6 @@ for (const skillId of testSkillIds) {
   writeFileSync(join(skillDir, "run.sh"), "#!/bin/sh\necho ok");
 }
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  getRootDir: () => testDir,
-  getWorkspaceDir: () => testDir,
-  getWorkspaceConfigPath: () => join(testDir, "config.json"),
-  getWorkspaceSkillsDir: () => join(testDir, "skills"),
-  getWorkspaceHooksDir: () => join(testDir, "hooks"),
-  getWorkspacePromptPath: (file: string) => join(testDir, file),
-  getSessionTokenPath: () => join(testDir, "session-token"),
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "data", "test.db"),
-  getLogPath: () => join(testDir, "logs", "test.log"),
-  getHistoryPath: () => join(testDir, "history"),
-  getHooksDir: () => join(testDir, "hooks"),
-
-  getSandboxRootDir: () => join(testDir, "sandbox"),
-  getSandboxWorkingDir: () => testDir,
-  getInterfacesDir: () => join(testDir, "interfaces"),
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPlatformName: () => process.platform,
-  getClipboardCommand: () => null,
-  getPlatformTokenPath: () => join(testDir, "platform-token"),
-  getTCPHost: () => "127.0.0.1",
-  getTCPPort: () => 8765,
-  isIOSPairingEnabled: () => false,
-  isTCPEnabled: () => false,
-  readPlatformToken: () => null,
-  readSessionToken: () => null,
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -201,6 +167,24 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   parseConversation: () => null,
   parseMessage: () => null,
+  getAssistantMessageIdsInTurn: () => [],
+  getTurnTimeBounds: () => null,
+  PRIVATE_CONVERSATION_FORK_ERROR: "Cannot fork a private conversation",
+  countConversationsByScheduleJobId: () => 0,
+  forkConversation: () => null,
+  wipeConversation: () => ({
+    conversations: 0,
+    messages: 0,
+    memoryItemIds: [],
+    memoryEntityIds: [],
+  }),
+  purgePrivateConversations: () => ({
+    purged: 0,
+    memoryItemIds: [],
+    memoryEntityIds: [],
+  }),
+  getMessagesPaginated: () => ({ messages: [], hasMore: false }),
+  getLastAssistantTimestampBefore: () => null,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -298,11 +282,6 @@ import type { Provider } from "../providers/types.js";
 
 afterAll(() => {
   __resetRegistryForTesting();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    // best-effort cleanup
-  }
 });
 
 describe("Conversation initialization benchmark", () => {
@@ -380,9 +359,9 @@ describe("Conversation initialization benchmark", () => {
     await initializeTools();
     const definitions = getAllToolDefinitions();
 
-    // Sanity: we expect a meaningful number of core tools (at least 18)
+    // Sanity: we expect a meaningful number of core tools (at least 14)
     // but not an unreasonable explosion (under 200)
-    expect(definitions.length).toBeGreaterThanOrEqual(18);
+    expect(definitions.length).toBeGreaterThanOrEqual(14);
     expect(definitions.length).toBeLessThan(200);
   });
 });

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -1,39 +1,19 @@
 import {
   existsSync,
   mkdirSync,
-  mkdtempSync,
   readdirSync,
   readFileSync,
-  realpathSync,
   rmSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { eq } from "drizzle-orm";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "conversation-key-store-disk-view-")),
-);
-const workspaceDir = join(testDir, "workspace");
-const conversationsDir = join(workspaceDir, "conversations");
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const conversationsDir = join(testDir, "conversations");
 mkdirSync(conversationsDir, { recursive: true });
 
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => conversationsDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -67,7 +47,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { conversationKeys, conversations } from "../memory/schema.js";
 
 initializeDb();
@@ -81,15 +61,6 @@ beforeEach(() => {
   mkdirSync(conversationsDir, { recursive: true });
 });
 
-afterAll(() => {
-  resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 describe("conversation-key-store disk view", () => {
   test("creates disk-view directory on first key use and reuses it on second call", () => {
     const first = getOrCreateConversation("client-key");
@@ -122,7 +93,10 @@ describe("conversation-key-store disk view", () => {
       .select({ id: conversations.id })
       .from(conversations)
       .all();
-    const keyRows = db.select({ id: conversationKeys.id }).from(conversationKeys).all();
+    const keyRows = db
+      .select({ id: conversationKeys.id })
+      .from(conversationKeys)
+      .all();
     expect(conversationRows).toHaveLength(1);
     expect(keyRows).toHaveLength(1);
     expect(readdirSync(conversationsDir)).toEqual([expectedDirName]);

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -8,10 +8,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: () => {},

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -10,10 +10,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -10,10 +10,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

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

@@ -34,12 +34,6 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-  getWorkspaceDir: () => "/tmp/workspace",
-  getConversationsDir: () => "/tmp/workspace/conversations",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},
@@ -1459,8 +1453,13 @@ describe("Conversation host attachment directives", () => {
       expect(warningDelta).toBeUndefined();
       const completion = events.find((e) => e.type === "message_complete");
       expect(completion).toBeDefined();
-      expect((completion as { attachmentWarnings?: string[] }).attachmentWarnings)
-        .toEqual(expect.arrayContaining([expect.stringContaining("access denied by user")]));
+      expect(
+        (completion as { attachmentWarnings?: string[] }).attachmentWarnings,
+      ).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining("access denied by user"),
+        ]),
+      );
     } finally {
       rmSync(hostPath, { force: true });
     }
@@ -1851,6 +1850,7 @@ describe("MessageQueue byte budget", () => {
       })),
       requestId,
       onEvent: () => {},
+      sentAt: Date.now(),
     };
   }
 

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

@@ -1,14 +1,6 @@
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { createAssistantMessage } from "../agent/message-types.js";
 import type { Conversation } from "../daemon/conversation.js";
@@ -26,32 +18,15 @@ import {
   getConversationByKey,
   getOrCreateConversation as getOrCreateConversationMapping,
 } from "../memory/conversation-key-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "conversation-routes-disk-view-test-")),
-);
-const workspaceDir = join(testDir, "workspace");
-const conversationsDir = join(workspaceDir, "conversations");
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const conversationsDir = join(testDir, "conversations");
 mkdirSync(conversationsDir, { recursive: true });
 
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => conversationsDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -129,18 +104,14 @@ function createFakeConversation(conversationId: string): Conversation {
     currentRequestId: undefined as string | undefined,
     abortController: null as AbortController | null,
     trustContext: undefined as unknown,
-    turnChannelContext: null as
-      | {
-          userMessageChannel: string;
-          assistantMessageChannel: string;
-        }
-      | null,
-    turnInterfaceContext: null as
-      | {
-          userMessageInterface: string;
-          assistantMessageInterface: string;
-        }
-      | null,
+    turnChannelContext: null as {
+      userMessageChannel: string;
+      assistantMessageChannel: string;
+    } | null,
+    turnInterfaceContext: null as {
+      userMessageInterface: string;
+      assistantMessageInterface: string;
+    } | null,
     messages: [] as Array<unknown>,
     hostBashProxy: undefined as unknown,
     hostFileProxy: undefined as unknown,
@@ -355,15 +326,6 @@ beforeEach(() => {
   conversationInstances.clear();
 });
 
-afterAll(() => {
-  resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 describe("conversationKey send path disk-view regression", () => {
   test("first send on a fresh conversationKey creates disk-view dir and writes user+assistant records", async () => {
     const conversationKey = `fresh-conv-key-${crypto.randomUUID()}`;