@vellumai/assistant 0.5.13 → 0.5.15

package/src/__tests__/invite-redemption-service.test.ts

@@ -1,21 +1,5 @@
-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(), "invite-redemption-service-test-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -45,11 +29,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function resetTables() {

package/src/__tests__/invite-routes-http.test.ts

@@ -1,21 +1,5 @@
-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(), "invite-routes-http-test-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -73,11 +57,6 @@ function createTargetContact(displayName = "Test Contact"): string {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function resetTables() {

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -1,6 +1,3 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   beforeAll,
@@ -11,19 +8,6 @@ import {
   test,
 } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "jobs-store-qdrant-breaker-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -61,7 +45,6 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
   afterAll(() => {
     resetDb();
-    rmSync(testDir, { recursive: true, force: true });
   });
 
   test("claims embed jobs when circuit breaker is closed (healthy)", () => {

package/src/__tests__/journal-context.test.ts

@@ -1,79 +1,15 @@
 import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-const TEST_DIR = join(tmpdir(), `vellum-journal-test-${crypto.randomUUID()}`);
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  getWorkspaceDir: () => TEST_DIR,
-}));
-
-const {
-  buildJournalContext,
-  formatJournalRelativeTime,
-  formatJournalAbsoluteTime,
-} = await import("../prompts/journal-context.js");
+const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const { buildJournalContext, formatJournalAbsoluteTime } = await import(
+  "../prompts/journal-context.js"
+);
 
 /** Small delay to ensure distinct file birthtimes on APFS. */
 const tick = () => Bun.sleep(5);
 
-describe("formatJournalRelativeTime", () => {
-  test("returns 'just now' for times less than 60 seconds ago", () => {
-    const now = Date.now();
-    expect(formatJournalRelativeTime(now - 30_000)).toBe("just now");
-    expect(formatJournalRelativeTime(now - 1_000)).toBe("just now");
-    expect(formatJournalRelativeTime(now)).toBe("just now");
-  });
-
-  test("returns minutes for times between 1-59 minutes ago", () => {
-    const now = Date.now();
-    expect(formatJournalRelativeTime(now - 60_000)).toBe("1 minute ago");
-    expect(formatJournalRelativeTime(now - 5 * 60_000)).toBe("5 minutes ago");
-    expect(formatJournalRelativeTime(now - 59 * 60_000)).toBe("59 minutes ago");
-  });
-
-  test("returns hours for times between 1-23 hours ago", () => {
-    const now = Date.now();
-    expect(formatJournalRelativeTime(now - 60 * 60_000)).toBe("1 hour ago");
-    expect(formatJournalRelativeTime(now - 3 * 60 * 60_000)).toBe(
-      "3 hours ago",
-    );
-    expect(formatJournalRelativeTime(now - 23 * 60 * 60_000)).toBe(
-      "23 hours ago",
-    );
-  });
-
-  test("returns days for times between 1-6 days ago", () => {
-    const now = Date.now();
-    expect(formatJournalRelativeTime(now - 24 * 60 * 60_000)).toBe(
-      "1 day ago",
-    );
-    expect(formatJournalRelativeTime(now - 3 * 24 * 60 * 60_000)).toBe(
-      "3 days ago",
-    );
-    expect(formatJournalRelativeTime(now - 6 * 24 * 60 * 60_000)).toBe(
-      "6 days ago",
-    );
-  });
-
-  test("returns weeks for times 7 or more days ago", () => {
-    const now = Date.now();
-    expect(formatJournalRelativeTime(now - 7 * 24 * 60 * 60_000)).toBe(
-      "1 week ago",
-    );
-    expect(formatJournalRelativeTime(now - 14 * 24 * 60 * 60_000)).toBe(
-      "2 weeks ago",
-    );
-    expect(formatJournalRelativeTime(now - 30 * 24 * 60 * 60_000)).toBe(
-      "4 weeks ago",
-    );
-  });
-});
-
 describe("formatJournalAbsoluteTime", () => {
   test("formats a timestamp as MM/DD/YY HH:MM", () => {
     // 2025-03-15 14:30:00
@@ -246,15 +182,12 @@ describe("buildJournalContext", () => {
     expect(result).not.toContain("LEAVING CONTEXT");
   });
 
-  test("includes both absolute and relative timestamps in headers", () => {
+  test("includes absolute timestamps in headers", () => {
     const userDir = join(journalDir, "testuser");
     mkdirSync(userDir, { recursive: true });
     writeFileSync(join(userDir, "recent.md"), "recent content");
 
     const result = buildJournalContext(10, "testuser")!;
-    // File was just created, so relative time should be "just now"
-    expect(result).toContain("just now");
-    // Absolute time should match the file's birthtime
     const birthtime = statSync(join(userDir, "recent.md")).birthtimeMs;
     const expected = formatJournalAbsoluteTime(birthtime);
     expect(result).toContain(expected);
@@ -272,9 +205,9 @@ describe("buildJournalContext", () => {
 
     const result = buildJournalContext(3, "testuser")!;
     // Middle entry should have plain header format (no MOST RECENT, no LEAVING CONTEXT)
-    // Format: ## middle.md (MM/DD/YY HH:MM, <relative time>)
+    // Format: ## middle.md (MM/DD/YY HH:MM)
     expect(result).toMatch(
-      /## middle\.md \(\d{2}\/\d{2}\/\d{2} \d{2}:\d{2}, .+\)/,
+      /## middle\.md \(\d{2}\/\d{2}\/\d{2} \d{2}:\d{2}\)/,
     );
   });
 

package/src/__tests__/list-messages-attachments.test.ts

@@ -7,25 +7,8 @@
  * - Assistant message image attachments include base64 data (same as user messages)
  */
 
-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(), "list-messages-test-"));
-
-mock.module("../util/platform.js", () => ({
-  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: () => {},
-  getRootDir: () => testDir,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -55,11 +38,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function resetTables() {

package/src/__tests__/llm-context-route-provider.test.ts

@@ -1,21 +1,5 @@
-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(), "llm-context-route-provider-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -31,11 +15,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 const routes = conversationQueryRouteDefinitions();

package/src/__tests__/llm-request-log-turn-query.test.ts

@@ -1,28 +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(), "llm-request-log-turn-query-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>, {
@@ -53,6 +30,7 @@ import {
   backfillMessageIdOnLogs,
   getRequestLogsByMessageId,
   recordRequestLog,
+  relinkLlmRequestLogs,
 } from "../memory/llm-request-log-store.js";
 import { llmRequestLogs, toolInvocations } from "../memory/schema.js";
 
@@ -81,11 +59,6 @@ function toolResultContent(toolUseIds: string[]): string {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("getRequestLogsByMessageId — turn-aware query", () => {
@@ -331,4 +304,49 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     expect(logs[1]?.id).toBe("log-orphan-2");
     expect(logs[2]?.id).toBe("log-surviving");
   });
+
+  test("relinkLlmRequestLogs moves logs from deleted messages to consolidated message", async () => {
+    const conv = createConversation("relink-test");
+
+    // Simulate multi-step turn: user → A1 (+ log1) → tool_result → A2 (+ log2)
+    await addMessage(conv.id, "user", "Do the task", undefined, {
+      skipIndexing: true,
+    });
+
+    // First LLM call → A1 (tool_use response)
+    recordRequestLog(conv.id, '{"step":1}', '{"tool_use":"bash"}');
+    const a1 = await addMessage(
+      conv.id,
+      "assistant",
+      "Using tool...",
+      undefined,
+      { skipIndexing: true },
+    );
+    backfillMessageIdOnLogs(conv.id, a1.id);
+
+    // tool_result user message
+    await addMessage(
+      conv.id,
+      "user",
+      toolResultContent(["tool-1"]),
+      undefined,
+      { skipIndexing: true },
+    );
+
+    // Second LLM call → A2 (text response)
+    recordRequestLog(conv.id, '{"step":2}', '{"result":"done"}');
+    const a2 = await addMessage(conv.id, "assistant", "All done!", undefined, {
+      skipIndexing: true,
+    });
+    backfillMessageIdOnLogs(conv.id, a2.id);
+
+    // Simulate consolidation: re-link logs from A2 to A1, then delete A2
+    relinkLlmRequestLogs([a2.id], a1.id);
+
+    // Both logs should now be findable via A1
+    const logs = getRequestLogsByMessageId(a1.id);
+    expect(logs).toHaveLength(2);
+    expect(logs[0]?.messageId).toBe(a1.id);
+    expect(logs[1]?.messageId).toBe(a1.id);
+  });
 });

package/src/__tests__/llm-usage-store.test.ts

@@ -1,21 +1,5 @@
-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(), "llm-usage-store-test-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -39,11 +23,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function makeInput(overrides?: Partial<UsageEventInput>): UsageEventInput {

package/src/__tests__/log-export-workspace.test.ts

@@ -36,7 +36,7 @@ mkdirSync(testWorkspaceDir, { recursive: true });
 mkdirSync(testDbDir, { recursive: true });
 
 mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
+  getProtectedDir: () => join(testDir, "protected"),
   getDataDir: () => testDir,
   getWorkspaceDir: () => testWorkspaceDir,
   getWorkspaceConfigPath: () => join(testWorkspaceDir, "config.json"),

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -39,7 +39,7 @@ const mockConfig = {
 };
 
 mock.module("../util/platform.js", () => ({
-  getRootDir: () => TEST_DIR,
+  getProtectedDir: () => join(TEST_DIR, "protected"),
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
   getDataDir: () => TEST_DIR,
   ensureDataDir: () => {},

package/src/__tests__/managed-store.test.ts

@@ -25,7 +25,7 @@ import { parse as parseYaml } from "yaml";
 let TEST_DIR = "";
 
 mock.module("../util/platform.js", () => ({
-  getRootDir: () => TEST_DIR,
+  getProtectedDir: () => join(TEST_DIR, "protected"),
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
 }));
 

package/src/__tests__/mcp-cli.test.ts

@@ -93,7 +93,7 @@ async function runMcp(
   }) as typeof process.exit;
 
   // Point config loader at the test data dir
-  process.env.BASE_DATA_DIR = testDataDir;
+  process.env.VELLUM_WORKSPACE_DIR = testDataDir;
 
   try {
     const program = new Command();
@@ -137,9 +137,8 @@ describe("assistant mcp list", () => {
       tmpdir(),
       `vellum-mcp-cli-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
-    const workspaceDir = join(testDataDir, ".vellum", "workspace");
-    mkdirSync(workspaceDir, { recursive: true });
-    configPath = join(workspaceDir, "config.json");
+    mkdirSync(testDataDir, { recursive: true });
+    configPath = join(testDataDir, "config.json");
     writeConfig({});
   });
 
@@ -264,9 +263,8 @@ describe("assistant mcp add", () => {
       tmpdir(),
       `vellum-mcp-add-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
-    const workspaceDir = join(testDataDir, ".vellum", "workspace");
-    mkdirSync(workspaceDir, { recursive: true });
-    configPath = join(workspaceDir, "config.json");
+    mkdirSync(testDataDir, { recursive: true });
+    configPath = join(testDataDir, "config.json");
     writeConfig({});
   });
 
@@ -404,9 +402,8 @@ describe("assistant mcp remove", () => {
         .toString(36)
         .slice(2)}`,
     );
-    const workspaceDir = join(testDataDir, ".vellum", "workspace");
-    mkdirSync(workspaceDir, { recursive: true });
-    configPath = join(workspaceDir, "config.json");
+    mkdirSync(testDataDir, { recursive: true });
+    configPath = join(testDataDir, "config.json");
     writeConfig({});
   });
 

package/src/__tests__/memory-context-benchmark.benchmark.test.ts

@@ -7,9 +7,6 @@
  * - recall.injectedTokens: <= computed dynamic budget
  * - recall.enabled: true
  */
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   beforeAll,
@@ -29,19 +26,6 @@ import { buildMemoryRecall } from "../memory/retriever.js";
 import { conversations, memorySegments, messages } from "../memory/schema.js";
 import type { Message, Provider } from "../providers/types.js";
 
-const testDir = mkdtempSync(join(tmpdir(), "memory-context-benchmark-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -204,11 +188,6 @@ describe("Memory context benchmark", () => {
 
   afterAll(() => {
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true });
-    } catch {
-      // best effort cleanup
-    }
   });
 
   test("long-session compaction + recall benchmark remains within expected bounds", async () => {

package/src/__tests__/memory-jobs-worker-backoff.test.ts

@@ -9,17 +9,6 @@ import { describe, expect, mock, test } from "bun:test";
 
 // ── Mocks (must precede imports of tested module) ──────────────────
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp/test-backoff",
-  isMacOS: () => false,
-  isLinux: () => true,
-  isWindows: () => false,
-  getPidPath: () => "/tmp/test-backoff/test.pid",
-  getDbPath: () => "/tmp/test-backoff/test.db",
-  getLogPath: () => "/tmp/test-backoff/test.log",
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {

package/src/__tests__/memory-lifecycle-e2e.test.ts

@@ -9,9 +9,6 @@
  * - Stripping removes <memory_context> tags
  * - No conflict gate references
  */
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   beforeAll,
@@ -24,19 +21,6 @@ import {
 
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 
-const testDir = mkdtempSync(join(tmpdir(), "memory-lifecycle-e2e-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -142,11 +126,6 @@ describe("Memory lifecycle E2E regression", () => {
 
   afterAll(() => {
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true });
-    } catch {
-      // best effort cleanup
-    }
   });
 
   test("extraction produces items with standard-kind enum and supersession chains form correctly", async () => {

package/src/__tests__/memory-recall-log-store.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(), "memory-recall-log-store-test-")),
-);
-const workspaceDir = join(testDir, ".vellum", "workspace");
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => join(testDir, ".vellum"),
-  getDataDir: () => join(workspaceDir, "data"),
-  getWorkspaceDir: () => workspaceDir,
-  getConversationsDir: () => join(workspaceDir, "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>, {
@@ -57,11 +35,6 @@ function resetTables(): void {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("memory-recall-log-store", () => {

package/src/__tests__/memory-recall-quality.test.ts

@@ -6,9 +6,6 @@
  * These tests fail if memory quality degrades — they act as guardrails
  * before any retrieval or ranking changes.
  */
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   beforeAll,
@@ -19,19 +16,6 @@ import {
   test,
 } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "memory-recall-quality-"));
-
-mock.module("../util/platform.js", () => ({
-  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>, {
@@ -272,11 +256,6 @@ describe("Memory Recall Quality", () => {
 
   afterAll(() => {
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true });
-    } catch {
-      // best effort cleanup
-    }
   });
 
   // -------------------------------------------------------------------------