@vellumai/assistant 0.5.13 → 0.5.14

package/src/__tests__/heartbeat-service.test.ts

@@ -1,20 +1,15 @@
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Mock platform to use a temp workspace dir
-let testWorkspaceDir: string;
-
-mock.module("../util/platform.js", () => ({
-  getWorkspacePromptPath: (file: string) => join(testWorkspaceDir, file),
-}));
+const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
 // Mock config loader
 let mockConfig = {
   heartbeat: {
     enabled: true,
     intervalMs: 60_000,
+    speed: "standard" as "standard" | "fast",
     activeHoursStart: undefined as number | undefined,
     activeHoursEnd: undefined as number | undefined,
   },
@@ -80,16 +75,19 @@ mock.module("../memory/conversation-title-service.js", () => ({
 const { HeartbeatService } = await import("../heartbeat/heartbeat-service.js");
 
 describe("HeartbeatService", () => {
-  let processMessageCalls: Array<{ conversationId: string; content: string }>;
+  let processMessageCalls: Array<{
+    conversationId: string;
+    content: string;
+    options?: { speed?: string };
+  }>;
   let alerterCalls: Array<{ type: string; title: string; body: string }>;
 
-  beforeEach(() => {
-    testWorkspaceDir = join(
-      tmpdir(),
-      `vellum-hb-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(testWorkspaceDir, { recursive: true });
+  afterEach(() => {
+    // Clean up HEARTBEAT.md between tests so file-existence tests don't leak
+    rmSync(join(testWorkspaceDir, "HEARTBEAT.md"), { force: true });
+  });
 
+  beforeEach(() => {
     processMessageCalls = [];
     alerterCalls = [];
     createdConversations.length = 0;
@@ -99,6 +97,7 @@ describe("HeartbeatService", () => {
       heartbeat: {
         enabled: true,
         intervalMs: 60_000,
+        speed: "standard",
         activeHoursStart: undefined,
         activeHoursEnd: undefined,
       },
@@ -109,14 +108,19 @@ describe("HeartbeatService", () => {
     processMessage?: (
       id: string,
       content: string,
+      options?: { speed?: string },
     ) => Promise<{ messageId: string }>;
     getCurrentHour?: () => number;
   }) {
     return new HeartbeatService({
       processMessage:
         overrides?.processMessage ??
-        (async (conversationId: string, content: string) => {
-          processMessageCalls.push({ conversationId, content });
+        (async (
+          conversationId: string,
+          content: string,
+          options?: { speed?: string },
+        ) => {
+          processMessageCalls.push({ conversationId, content, options });
           return { messageId: "msg-1" };
         }),
       alerter: (alert: { type: string; title: string; body: string }) => {
@@ -150,13 +154,60 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls[0].content).toContain("Water the plants");
   });
 
+  test("comment lines in HEARTBEAT.md are stripped from prompt", async () => {
+    const checklist = [
+      "_ This is a comment that should be stripped",
+      "_ Another comment line",
+      "- Do the real task",
+      "- Check on something important",
+    ].join("\n");
+    writeFileSync(join(testWorkspaceDir, "HEARTBEAT.md"), checklist);
+
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain("Do the real task");
+    expect(processMessageCalls[0].content).toContain(
+      "Check on something important",
+    );
+    expect(processMessageCalls[0].content).not.toContain(
+      "This is a comment that should be stripped",
+    );
+    expect(processMessageCalls[0].content).not.toContain(
+      "Another comment line",
+    );
+  });
+
+  test("comment lines inside fenced code blocks are preserved", async () => {
+    const checklist = [
+      "_ This comment should be stripped",
+      "- Check the Python snippet below still works:",
+      "```python",
+      "_instance = None",
+      "_private_var = 42",
+      "```",
+    ].join("\n");
+    writeFileSync(join(testWorkspaceDir, "HEARTBEAT.md"), checklist);
+
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toContain("_instance = None");
+    expect(processMessageCalls[0].content).toContain("_private_var = 42");
+    expect(processMessageCalls[0].content).not.toContain(
+      "This comment should be stripped",
+    );
+  });
+
   test("default checklist used when no HEARTBEAT.md", async () => {
     const service = createService();
     await service.runOnce();
 
     expect(processMessageCalls).toHaveLength(1);
     expect(processMessageCalls[0].content).toContain(
-      "Check the current weather",
+      "Check in with yourself",
     );
   });
 
@@ -343,7 +394,9 @@ describe("HeartbeatService", () => {
 
     expect(afterReset).not.toBeNull();
     // The new nextRunAt should be >= the interval from now
-    expect(afterReset!).toBeGreaterThanOrEqual(before + mockConfig.heartbeat.intervalMs);
+    expect(afterReset!).toBeGreaterThanOrEqual(
+      before + mockConfig.heartbeat.intervalMs,
+    );
     service.stop();
   });
 
@@ -364,11 +417,31 @@ describe("HeartbeatService", () => {
     expect(service.nextRunAt).toBeNull();
   });
 
-  test("cleanup", () => {
-    try {
-      rmSync(testWorkspaceDir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
+  test("passes heartbeat config speed to processMessage", async () => {
+    mockConfig.heartbeat.speed = "standard";
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options).toEqual({ speed: "standard" });
+  });
+
+  test("heartbeat uses its own speed even when global config differs", async () => {
+    // Simulate: global config has fast, but heartbeat config has standard
+    mockConfig.heartbeat.speed = "standard";
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options?.speed).toBe("standard");
+  });
+
+  test("heartbeat passes fast speed when explicitly configured", async () => {
+    mockConfig.heartbeat.speed = "fast";
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options?.speed).toBe("fast");
   });
 });

package/src/__tests__/hooks-blocking.test.ts

@@ -9,9 +9,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use getWorkspaceDir()
 const testDir = join(tmpdir(), `hooks-blocking-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import { saveHooksConfig } from "../hooks/config.js";
 import { HookManager, resetHookManager } from "../hooks/manager.js";
@@ -45,7 +45,7 @@ describe("Blocking Hooks", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
     resetHookManager();
   });

package/src/__tests__/hooks-config.test.ts

@@ -9,9 +9,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use getWorkspaceDir()
 const testDir = join(tmpdir(), `hooks-config-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import {
   ensureHookInConfig,
@@ -23,7 +23,7 @@ import {
 
 describe("Hooks Config", () => {
   beforeEach(() => {
-    const hooksDir = join(testDir, ".vellum", "hooks");
+    const hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
   });
 
@@ -38,7 +38,7 @@ describe("Hooks Config", () => {
   });
 
   test("loadHooksConfig reads existing config", () => {
-    const configPath = join(testDir, ".vellum", "hooks", "config.json");
+    const configPath = join(testDir, "hooks", "config.json");
     writeFileSync(
       configPath,
       JSON.stringify({
@@ -52,7 +52,7 @@ describe("Hooks Config", () => {
   });
 
   test("loadHooksConfig returns defaults for invalid JSON", () => {
-    const configPath = join(testDir, ".vellum", "hooks", "config.json");
+    const configPath = join(testDir, "hooks", "config.json");
     writeFileSync(configPath, "NOT VALID JSON {{{");
 
     const config = loadHooksConfig();
@@ -61,7 +61,7 @@ describe("Hooks Config", () => {
   });
 
   test("loadHooksConfig returns defaults for invalid structure", () => {
-    const configPath = join(testDir, ".vellum", "hooks", "config.json");
+    const configPath = join(testDir, "hooks", "config.json");
     writeFileSync(configPath, JSON.stringify({ foo: "bar" }));
 
     const config = loadHooksConfig();
@@ -73,7 +73,7 @@ describe("Hooks Config", () => {
     const config = { version: 1, hooks: { "test-hook": { enabled: true } } };
     saveHooksConfig(config);
 
-    const configPath = join(testDir, ".vellum", "hooks", "config.json");
+    const configPath = join(testDir, "hooks", "config.json");
     expect(existsSync(configPath)).toBe(true);
     const read = JSON.parse(readFileSync(configPath, "utf-8"));
     expect(read.hooks["test-hook"].enabled).toBe(true);

package/src/__tests__/hooks-discovery.test.ts

@@ -6,9 +6,9 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { saveHooksConfig } from "../hooks/config.js";
 import { discoverHooks } from "../hooks/discovery.js";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
 const testDir = join(tmpdir(), `hooks-discovery-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 function createHook(
   hooksDir: string,
@@ -29,7 +29,7 @@ describe("Hooks Discovery", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
   });
 

package/src/__tests__/hooks-integration.test.ts

@@ -9,9 +9,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use getWorkspaceDir()
 const testDir = join(tmpdir(), `hooks-integration-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import { saveHooksConfig } from "../hooks/config.js";
 import { HookManager, resetHookManager } from "../hooks/manager.js";
@@ -43,7 +43,7 @@ describe("Hooks Integration", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
     resetHookManager();
   });
@@ -89,7 +89,7 @@ describe("Hooks Integration", () => {
       hooksDir,
       "env-capture",
       ["daemon-start"],
-      `#!/bin/bash\necho "$VELLUM_HOOK_EVENT|$VELLUM_HOOK_NAME|$VELLUM_ROOT_DIR" > "${outputFile}"`,
+      `#!/bin/bash\necho "$VELLUM_HOOK_EVENT|$VELLUM_HOOK_NAME|$VELLUM_WORKSPACE_DIR" > "${outputFile}"`,
     );
     saveHooksConfig({
       version: 1,
@@ -106,7 +106,7 @@ describe("Hooks Integration", () => {
     const parts = output.split("|");
     expect(parts[0]).toBe("daemon-start");
     expect(parts[1]).toBe("env-capture");
-    expect(parts[2]).toContain(".vellum");
+    expect(parts[2]).toBe(testDir);
   });
 
   test("multiple hooks for same event run in order", async () => {

package/src/__tests__/hooks-manager.test.ts

@@ -3,9 +3,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use getWorkspaceDir()
 const testDir = join(tmpdir(), `hooks-manager-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import { saveHooksConfig } from "../hooks/config.js";
 import {
@@ -41,7 +41,7 @@ describe("HookManager", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
     resetHookManager();
   });

package/src/__tests__/hooks-runner.test.ts

@@ -3,9 +3,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
 const testDir = join(tmpdir(), `hooks-runner-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import { runHookScript } from "../hooks/runner.js";
 import type { DiscoveredHook, HookEventData } from "../hooks/types.js";
@@ -40,7 +40,7 @@ describe("Hook Runner", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
   });
 
@@ -136,26 +136,8 @@ describe("Hook Runner", () => {
     const result = await runHookScript(hook, eventData);
     expect(result.exitCode).toBe(0);
     const wsDir = result.stdout.trim();
-    expect(wsDir).toContain(".vellum");
-    expect(wsDir).toEndWith("workspace");
-  });
-
-  test("sets both VELLUM_ROOT_DIR and VELLUM_WORKSPACE_DIR", async () => {
-    const hook = createTestHook(
-      hooksDir,
-      "both-dirs-hook",
-      '#!/bin/bash\necho "$VELLUM_ROOT_DIR|$VELLUM_WORKSPACE_DIR"',
-    );
-    const eventData: HookEventData = { event: "pre-tool-execute" };
-
-    const result = await runHookScript(hook, eventData);
-    expect(result.exitCode).toBe(0);
-    const [rootDir, wsDir] = result.stdout.trim().split("|");
-    expect(rootDir).toContain(".vellum");
-    expect(wsDir).toContain(".vellum");
-    expect(wsDir).toEndWith("workspace");
-    // workspace dir should be a subdirectory of root dir
-    expect(wsDir).toStartWith(rootDir);
+    expect(wsDir.length).toBeGreaterThan(0);
+    expect(wsDir).toBe(testDir);
   });
 
   test("handles non-existent script gracefully", async () => {

package/src/__tests__/hooks-settings.test.ts

@@ -9,9 +9,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
 const testDir = join(tmpdir(), `hooks-settings-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import { getHookSettings } from "../hooks/config.js";
 import { saveHooksConfig } from "../hooks/config.js";
@@ -22,7 +22,7 @@ describe("Hook Settings", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
   });
 

package/src/__tests__/hooks-templates.test.ts

@@ -13,9 +13,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-// Set BASE_DATA_DIR before importing modules that use getRootDir()
+// Set VELLUM_WORKSPACE_DIR before importing modules that use platform helpers
 const testDir = join(tmpdir(), `hooks-templates-test-${Date.now()}`);
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_WORKSPACE_DIR = testDir;
 
 import {
   ensureHookInConfig,
@@ -45,7 +45,7 @@ describe("Hook Templates", () => {
   let hooksDir: string;
 
   beforeEach(() => {
-    hooksDir = join(testDir, ".vellum", "hooks");
+    hooksDir = join(testDir, "hooks");
     mkdirSync(hooksDir, { recursive: true });
   });
 

package/src/__tests__/http-conversation-lineage.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(), "http-conversation-lineage-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>, {
@@ -86,11 +64,6 @@ describe("conversation lineage in HTTP reads", () => {
   afterAll(async () => {
     await server?.stop();
     resetDb();
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   test("GET /v1/conversations returns forkParent for surviving parents", async () => {

package/src/__tests__/identity-intro-cache.test.ts

@@ -32,10 +32,6 @@ mock.module("../memory/checkpoints.js", () => ({
 // Simulated workspace file contents
 const workspaceFiles: Record<string, string> = {};
 
-mock.module("../util/platform.js", () => ({
-  getWorkspacePromptPath: (name: string) => `/mock/workspace/${name}`,
-}));
-
 mock.module("node:fs", () => ({
   existsSync: (path: string) => {
     const name = path.split("/").pop() ?? "";

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

@@ -5,29 +5,12 @@
  * granted access without guardian approval, and that invalid/expired/revoked
  * tokens produce the correct deterministic refusal 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";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
 
-const testDir = mkdtempSync(join(tmpdir(), "inbound-invite-redemption-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>, {
@@ -94,11 +77,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -13,8 +13,7 @@
  * 5. Continue matching the existing skill_load:* flow for non-dynamic skills.
  */
 
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,20 +21,10 @@ import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 
 // ── Mock setup (must be before any imports from the project) ──────────────
 
-const testDir = mkdtempSync(join(tmpdir(), "inline-skill-perm-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => join(testDir, "data"),
-  getWorkspaceSkillsDir: () => join(testDir, "skills"),
-  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: () => {},
-}));
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+
+// Point the file-based trust backend at the test temp dir.
+process.env.GATEWAY_SECURITY_DIR = join(testDir, "protected");
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>

package/src/__tests__/intent-routing.test.ts

@@ -1,39 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ── Mock platform to isolate tests from the real workspace ────────────
-const TEST_DIR = join(tmpdir(), `vellum-routing-test-${crypto.randomUUID()}`);
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  getRootDir: () => TEST_DIR,
-  getDataDir: () => TEST_DIR,
-  getWorkspaceDir: () => TEST_DIR,
-  getWorkspaceConfigPath: () => join(TEST_DIR, "config.json"),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
-  getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
-  getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
-  ensureDataDir: () => {},
-  getPidPath: () => join(TEST_DIR, "vellum.pid"),
-  getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
-  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
-  getHistoryPath: () => join(TEST_DIR, "history"),
-  getHooksDir: () => join(TEST_DIR, "hooks"),
-
-  getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
-  getSandboxWorkingDir: () => TEST_DIR,
-  getInterfacesDir: () => join(TEST_DIR, "interfaces"),
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPlatformName: () => process.platform,
-  getClipboardCommand: () => null,
-  readSessionToken: () => null,
-}));
+import { describe, expect, mock, test } from "bun:test";
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
   get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
@@ -120,16 +87,6 @@ const sendNotificationDef = notifToolsJson.tools.find(
 // =====================================================================
 
 describe("Task/Schedule routing NOT in system prompt (moved to tool descriptions)", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-  });
-
   test("system prompt does not contain the old routing section", () => {
     const prompt = buildSystemPrompt();
     expect(prompt).not.toContain(
@@ -227,16 +184,6 @@ describe("cross-tool routing consistency", () => {
 // =====================================================================
 
 describe("Activation hints in skills catalog", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-  });
-
   test("phone-calls skill includes hints and avoid-when in catalog line", () => {
     const prompt = buildSystemPrompt();
     const line = prompt.split("\n").find((l) => l.includes("**phone-calls**"));