@vellumai/assistant 0.5.13 → 0.5.14

package/src/__tests__/platform.test.ts

@@ -1,6 +1,5 @@
-import { randomBytes } from "node:crypto";
 import { existsSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, test } from "bun:test";
 
@@ -9,11 +8,9 @@ import {
   getDataDir,
   getDbPath,
   getHistoryPath,
-  getHooksDir,
   getInterfacesDir,
   getLogPath,
   getPidPath,
-  getRootDir,
   getSandboxRootDir,
   getSandboxWorkingDir,
   getWorkspaceConfigPath,
@@ -23,34 +20,33 @@ import {
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
 
-const originalBaseDataDir = process.env.BASE_DATA_DIR;
+const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
 
 afterEach(() => {
-  if (originalBaseDataDir == null) {
-    delete process.env.BASE_DATA_DIR;
+  if (originalWorkspaceDir == null) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
   } else {
-    process.env.BASE_DATA_DIR = originalBaseDataDir;
+    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
   }
 });
 
-// Baseline path characterization: documents current pre-migration path layout.
-// After workspace migration, paths marked "WILL MOVE" below will resolve under
-// ~/.vellum/workspace/ instead. Paths marked "STAYS ROOT" remain at ~/.vellum/.
-describe("baseline path characterization (pre-migration)", () => {
-  test("all path helpers resolve to expected pre-migration locations", () => {
-    const base = join(
-      tmpdir(),
-      `platform-test-${randomBytes(4).toString("hex")}`,
-    );
-    process.env.BASE_DATA_DIR = base;
-    const root = join(base, ".vellum");
-    const data = join(root, "workspace", "data");
-
-    // Root dir — stays as anchor for all paths
-    expect(getRootDir()).toBe(root);
-
-    // Now resolves under workspace/data
-    expect(getDataDir()).toBe(join(root, "workspace", "data"));
+// Path characterization: documents the current path layout.
+// Root-level helpers always resolve under ~/.vellum (from homedir()).
+// Workspace helpers resolve under VELLUM_WORKSPACE_DIR when set,
+// otherwise under ~/.vellum/workspace.
+describe("path characterization", () => {
+  test("all path helpers resolve to expected locations", () => {
+    // Without VELLUM_WORKSPACE_DIR override, workspace is under ~/.vellum
+    delete process.env.VELLUM_WORKSPACE_DIR;
+    const root = join(homedir(), ".vellum");
+    const ws = getWorkspaceDir();
+    const data = getDataDir();
+
+    // Workspace is under root
+    expect(ws).toBe(join(root, "workspace"));
+
+    // Data dir is under workspace
+    expect(data).toBe(join(ws, "data"));
 
     // Sub-paths under workspace/data
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
@@ -58,81 +54,66 @@ describe("baseline path characterization (pre-migration)", () => {
     expect(getHistoryPath()).toBe(join(data, "history"));
     expect(getInterfacesDir()).toBe(join(data, "interfaces"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
-    expect(getSandboxWorkingDir()).toBe(join(root, "workspace"));
+    expect(getSandboxWorkingDir()).toBe(ws);
 
-    // Hooks remain outside the workspace sandbox boundary
-    expect(getHooksDir()).toBe(join(root, "hooks"));
+    // Hooks live under workspace
+    expect(getWorkspaceHooksDir()).toBe(join(ws, "hooks"));
 
-    // STAYS ROOT — runtime files remain at ~/.vellum/
+    // Root-level runtime files remain at ~/.vellum/
     expect(getPidPath()).toBe(join(root, "vellum.pid"));
   });
 
-  test("hooks directory is outside the sandbox boundary", () => {
-    const base = join(
-      tmpdir(),
-      `platform-test-${randomBytes(4).toString("hex")}`,
-    );
-    process.env.BASE_DATA_DIR = base;
-    const hooksDir = getHooksDir();
-    const sandboxDir = getSandboxWorkingDir();
-    expect(hooksDir.startsWith(sandboxDir)).toBe(false);
+  test("VELLUM_WORKSPACE_DIR overrides workspace location", () => {
+    process.env.VELLUM_WORKSPACE_DIR = "/tmp/custom-workspace";
+    expect(getWorkspaceDir()).toBe("/tmp/custom-workspace");
+    expect(getDataDir()).toBe("/tmp/custom-workspace/data");
+    // Root-level paths are NOT affected by VELLUM_WORKSPACE_DIR
+    expect(getPidPath()).toBe(join(homedir(), ".vellum", "vellum.pid"));
   });
 
-  test("ensureDataDir creates all expected directories", () => {
-    const base = join(
-      tmpdir(),
-      `platform-test-${randomBytes(4).toString("hex")}`,
-    );
-    process.env.BASE_DATA_DIR = base;
-    const rootDir = getRootDir();
-    const ws = getWorkspaceDir();
-    const wsData = join(ws, "data");
+  test("hooks directory is inside the workspace boundary", () => {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+    expect(getWorkspaceHooksDir().startsWith(getWorkspaceDir())).toBe(true);
+  });
 
-    if (existsSync(rootDir)) {
-      rmSync(rootDir, { recursive: true, force: true });
-    }
+  test("ensureDataDir creates all expected directories", () => {
+    // Use a temp VELLUM_WORKSPACE_DIR so ensureDataDir writes to a temp dir
+    // rather than the real ~/.vellum. Root-level dirs still go to ~/.vellum
+    // but we only verify workspace dirs here to avoid side effects.
+    const wsDir = join(tmpdir(), `platform-test-ws-${Date.now()}`);
+    process.env.VELLUM_WORKSPACE_DIR = wsDir;
 
     ensureDataDir();
 
-    // Root-level dirs (runtime / protected)
-    expect(existsSync(getRootDir())).toBe(true);
-    expect(existsSync(join(getRootDir(), "protected"))).toBe(true);
+    // Root-level dirs (ensureDataDir always creates these)
+    const root = join(homedir(), ".vellum");
+    expect(existsSync(root)).toBe(true);
 
-    // Workspace dirs
-    expect(existsSync(ws)).toBe(true);
-    expect(existsSync(join(getRootDir(), "hooks"))).toBe(true);
-    expect(existsSync(join(ws, "skills"))).toBe(true);
+    // Workspace dirs (in our temp location)
+    expect(existsSync(wsDir)).toBe(true);
+    expect(existsSync(join(wsDir, "hooks"))).toBe(true);
+    expect(existsSync(join(wsDir, "skills"))).toBe(true);
 
     // Data sub-dirs under workspace
-    expect(existsSync(wsData)).toBe(true);
-    expect(existsSync(join(wsData, "db"))).toBe(true);
-    expect(existsSync(join(wsData, "qdrant"))).toBe(true);
-    expect(existsSync(join(wsData, "logs"))).toBe(true);
-    expect(existsSync(join(wsData, "memory"))).toBe(true);
-    expect(existsSync(join(wsData, "memory", "knowledge"))).toBe(true);
-    expect(existsSync(join(wsData, "apps"))).toBe(true);
-    expect(existsSync(join(wsData, "interfaces"))).toBe(true);
-
-    // Legacy dirs should NOT be created
-    expect(existsSync(join(getRootDir(), "skills"))).toBe(false);
-    expect(existsSync(join(getRootDir(), "data", "sandbox"))).toBe(false);
-    expect(existsSync(join(getRootDir(), "data", "sandbox", "fs"))).toBe(false);
-
-    rmSync(rootDir, { recursive: true, force: true });
+    const data = join(wsDir, "data");
+    expect(existsSync(data)).toBe(true);
+    expect(existsSync(join(data, "db"))).toBe(true);
+    expect(existsSync(join(data, "qdrant"))).toBe(true);
+    expect(existsSync(join(data, "logs"))).toBe(true);
+    expect(existsSync(join(data, "memory"))).toBe(true);
+    expect(existsSync(join(data, "memory", "knowledge"))).toBe(true);
+    expect(existsSync(join(data, "apps"))).toBe(true);
+    expect(existsSync(join(data, "interfaces"))).toBe(true);
+
+    rmSync(wsDir, { recursive: true, force: true });
   });
 });
 
 describe("workspace path primitives", () => {
-  test("workspace helpers resolve under getRootDir()/workspace", () => {
-    const base = join(
-      tmpdir(),
-      `platform-test-${randomBytes(4).toString("hex")}`,
-    );
-    process.env.BASE_DATA_DIR = base;
-    const root = join(base, ".vellum");
-    const ws = join(root, "workspace");
-
-    expect(getWorkspaceDir()).toBe(ws);
+  test("workspace helpers resolve under workspace dir", () => {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+    const ws = getWorkspaceDir();
+
     expect(getWorkspaceConfigPath()).toBe(join(ws, "config.json"));
     expect(getWorkspaceSkillsDir()).toBe(join(ws, "skills"));
     expect(getWorkspaceHooksDir()).toBe(join(ws, "hooks"));
@@ -140,9 +121,4 @@ describe("workspace path primitives", () => {
     expect(getWorkspacePromptPath("SOUL.md")).toBe(join(ws, "SOUL.md"));
     expect(getWorkspacePromptPath("USER.md")).toBe(join(ws, "USER.md"));
   });
-
-  test("workspace helpers honor BASE_DATA_DIR", () => {
-    process.env.BASE_DATA_DIR = "/tmp/custom-base";
-    expect(getWorkspaceDir()).toBe("/tmp/custom-base/.vellum/workspace");
-  });
 });

package/src/__tests__/playbook-execution.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(), "playbook-exec-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>, {
@@ -53,11 +37,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function getRawDb(): Database {

package/src/__tests__/playbook-tools.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(), "playbook-tools-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>, {
@@ -48,11 +32,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function getRawDb(): Database {

package/src/__tests__/pricing.test.ts

@@ -294,6 +294,106 @@ describe("resolvePricingForUsage", () => {
   });
 });
 
+describe("fast mode pricing", () => {
+  test("applies 6x multiplier when speed is fast", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      anthropicCacheCreation: null,
+      speed: "fast",
+    };
+
+    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+
+    // Base: $5 input + $25 output = $30; fast: $30 * 6 = $180
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe((5 + 25) * 6);
+  });
+
+  test("does not apply multiplier when speed is standard", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      anthropicCacheCreation: null,
+      speed: "standard",
+    };
+
+    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(5 + 25);
+  });
+
+  test("does not apply multiplier when speed is null", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      anthropicCacheCreation: null,
+      speed: null,
+    };
+
+    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(5 + 25);
+  });
+
+  test("fast mode multiplier stacks with cache pricing", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 1_000_000,
+      cacheReadInputTokens: 1_000_000,
+      anthropicCacheCreation: {
+        ephemeral_5m_input_tokens: 1_000_000,
+        ephemeral_1h_input_tokens: 0,
+      },
+      speed: "fast",
+    };
+
+    const standardUsage: PricingUsage = { ...usage, speed: "standard" };
+
+    const fastResult = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
+    const standardResult = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      standardUsage,
+    );
+
+    expect(fastResult.pricingStatus).toBe("priced");
+    expect(standardResult.pricingStatus).toBe("priced");
+    // Fast mode applies 6x to base rates; cache multipliers stack on top
+    expect(fastResult.estimatedCostUsd).toBe(standardResult.estimatedCostUsd! * 6);
+  });
+
+  test("does not apply fast mode multiplier for non-Anthropic providers", () => {
+    const usage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      anthropicCacheCreation: null,
+      speed: "fast",
+    };
+
+    const result = resolvePricingForUsage("openai", "gpt-4o", usage);
+
+    // Should be standard pricing, not 6x
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(2.5 + 10);
+  });
+});
+
 describe("resolvePricingForUsageWithOverrides", () => {
   test("uses override pricing for structured Anthropic usage", () => {
     const usage: PricingUsage = {

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

@@ -14,9 +14,6 @@
  * - Malformed message resilience
  */
 import { createHash, randomUUID } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   beforeEach,
@@ -28,24 +25,8 @@ import {
   test,
 } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "relay-server-test-"));
-
 // ── Platform + logger mocks (must come before any source imports) ────
 
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  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: () => {},
-}));
-
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const realLogger = require("../util/logger.js");
 mock.module("../util/logger.js", () => ({
@@ -162,7 +143,7 @@ mock.module("../providers/registry.js", () => {
         gemini: "gemini-3-flash",
         ollama: "llama3.2",
         fireworks: "accounts/fireworks/models/kimi-k2p5",
-        openrouter: "x-ai/grok-4",
+        openrouter: "x-ai/grok-4.20-beta",
       };
       return defaults[providerName] ?? defaults.anthropic;
     },
@@ -214,11 +195,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 // ── Mock WebSocket factory ──────────────────────────────────────────

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -1,6 +1,3 @@
-import { mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import {
   afterAll,
   afterEach,
@@ -13,22 +10,6 @@ import {
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "runtime-attach-meta-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>, {
@@ -63,11 +44,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 const TEST_TOKEN = "test-bearer-token-attach";

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

@@ -15,27 +15,8 @@
  *   - generation_handoff (terminal)
  *   - generation_cancelled (terminal)
  */
-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(), "runtime-events-sse-parity-")),
-);
-
-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>, {
@@ -66,11 +47,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 // ---------------------------------------------------------------------------
@@ -165,12 +141,14 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     const msg = {
       type: "assistant_thinking_delta" as const,
       thinking: "Let me reason through this...",
+      conversationId: "conv-thinking-test",
     };
     const event = await publishAndReadFrame("parity-thinking-delta", msg);
 
     expect(event.message.type).toBe("assistant_thinking_delta");
     const m = event.message as typeof msg;
     expect(m.thinking).toBe("Let me reason through this...");
+    expect(m.conversationId).toBe("conv-thinking-test");
   });
 
   // ── tool_input_delta ─────────────────────────────────────────────────────

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

@@ -7,27 +7,8 @@
  *   - Happy path: stream receives a published AssistantEvent
  *   - Unfiltered: streams events from multiple conversations
  */
-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(), "runtime-events-sse-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>, {
@@ -77,11 +58,6 @@ describe("SSE assistant-events endpoint", () => {
 
   afterAll(() => {
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   async function startServer(): Promise<void> {

package/src/__tests__/sandbox-diagnostics.test.ts

@@ -1,4 +1,5 @@
 import * as realChildProcess from "node:child_process";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const execSyncMock = mock(
@@ -17,7 +18,7 @@ let mockIsLinux = false;
 mock.module("../util/platform.js", () => ({
   isMacOS: () => mockIsMacOS,
   isLinux: () => mockIsLinux,
-  getRootDir: () => "/tmp/vellum-test",
+  getProtectedDir: () => join("/tmp/vellum-test", "protected"),
   getDataDir: () => "/tmp/vellum-test/data",
   getDbPath: () => "/tmp/vellum-test/data/db/assistant.db",
   getLogPath: () => "/tmp/vellum-test/data/logs/daemon.log",

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -7,7 +7,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 let TEST_DIR = "";
 
 mock.module("../util/platform.js", () => ({
-  getRootDir: () => TEST_DIR,
+  getProtectedDir: () => join(TEST_DIR, "protected"),
   getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
 }));
 

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

@@ -1,22 +1,6 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 import { mock } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "schedule-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>, {
@@ -48,11 +32,6 @@ function getRawDb(): import("bun:sqlite").Database {
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 // ── Cron schedules ──────────────────────────────────────────────────

package/src/__tests__/schedule-tools.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(), "schedule-tools-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>, {
@@ -43,11 +27,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 function getRawDb(): Database {