@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/system-prompt.test.ts

@@ -79,7 +79,7 @@ const {
 } = await import("../prompts/system-prompt.js");
 
 /**
- * Extract just the workspace-file content (IDENTITY.md, SOUL.md, USER.md,
+ * Extract just the workspace-file content (IDENTITY.md, SOUL.md,
  * BOOTSTRAP.md) from the full system prompt, stripping all static
  * instruction sections, configuration, and skills catalog.
  *
@@ -123,6 +123,7 @@ describe("buildSystemPrompt", () => {
       "BOOTSTRAP.md",
       "UPDATES.md",
       "skills",
+      "users",
     ]) {
       const p = join(TEST_DIR, name);
       if (existsSync(p)) rmSync(p, { recursive: true, force: true });
@@ -249,31 +250,80 @@ describe("buildSystemPrompt", () => {
     expect(result).not.toContain("incident-response");
   });
 
-  test("appends USER.md after base prompt", () => {
-    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Base prompt");
-    writeFileSync(join(TEST_DIR, "USER.md"), "# User\n\nName: Alice");
+  test("builds prompt without error when USER.md does not exist on disk", () => {
+    // Persona content now flows through options.userPersona (resolved via
+    // resolveGuardianPersona upstream). buildSystemPrompt must never read
+    // USER.md from disk — verify it returns a well-formed prompt when the
+    // file is absent.
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("Base prompt\n\n# User\n\nName: Alice");
+    expect(basePrompt(result)).toBe("Identity\n\nSoul");
   });
 
-  test("appends USER.md after IDENTITY + SOUL", () => {
+  test("does not read USER.md content from disk even when the file is present", () => {
+    // USER.md has been removed from PROMPT_FILES and the fallback read
+    // path. A stale file on disk must not leak into the prompt.
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
-    writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
-    writeFileSync(join(TEST_DIR, "USER.md"), "User info");
+    writeFileSync(
+      join(TEST_DIR, "USER.md"),
+      "stale user content that should be ignored",
+    );
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("Identity\n\nSoul\n\nUser info");
+    expect(result).not.toContain("stale user content");
+    expect(basePrompt(result)).toBe("Identity");
   });
 
-  test("USER.md alone becomes the prompt", () => {
-    writeFileSync(join(TEST_DIR, "USER.md"), "Just user");
-    const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("Just user");
+  test("uses options.userPersona instead of USER.md", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
+    const result = buildSystemPrompt({
+      userPersona: "# User persona\n\nName: Alice",
+    });
+    expect(basePrompt(result)).toBe(
+      "Identity\n\nSoul\n\n# User persona\n\nName: Alice",
+    );
   });
 
-  test("ignores empty USER.md", () => {
-    writeFileSync(join(TEST_DIR, "USER.md"), "  \n  ");
-    const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("");
+  describe("BOOTSTRAP.md user persona placeholder", () => {
+    test("substitutes {{USER_PERSONA_FILE}} with users/<slug>.md when userSlug is provided", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nSave facts to users/{{USER_PERSONA_FILE}} immediately.",
+      );
+      const result = buildSystemPrompt({ userSlug: "alice" });
+      expect(result).toContain("users/alice.md");
+      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+    });
+
+    test("falls back to users/default.md when userSlug is omitted", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# First run\n\nSave facts to users/{{USER_PERSONA_FILE}} immediately.",
+      );
+      const result = buildSystemPrompt();
+      expect(result).toContain("users/default.md");
+      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+    });
+
+    test("substitutes the unmodified bundled BOOTSTRAP.md template", () => {
+      // Copy the real bundled BOOTSTRAP.md into the test workspace so we
+      // verify substitution against the actual template the daemon ships.
+      const bundled = readFileSync(
+        join(
+          import.meta.dirname,
+          "..",
+          "prompts",
+          "templates",
+          "BOOTSTRAP.md",
+        ),
+        "utf-8",
+      );
+      writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), bundled);
+      const result = buildSystemPrompt({ userSlug: "alice" });
+      expect(result).toContain("users/alice.md");
+      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+    });
   });
 
   describe("app-builder tool ownership guidance", () => {
@@ -541,17 +591,20 @@ describe("ensurePromptFiles", () => {
       "SOUL.md",
       "USER.md",
       "BOOTSTRAP.md",
+      "BOOTSTRAP-REFERENCE.md",
+      "HEARTBEAT.md",
       "conversations",
+      "users",
     ]) {
       const p = join(TEST_DIR, name);
       if (existsSync(p)) rmSync(p, { recursive: true, force: true });
     }
   });
 
-  test("creates all 3 files from templates when none exist", () => {
+  test("creates SOUL.md and IDENTITY.md from templates when none exist", () => {
     ensurePromptFiles();
 
-    for (const file of ["SOUL.md", "IDENTITY.md", "USER.md"]) {
+    for (const file of ["SOUL.md", "IDENTITY.md"]) {
       const dest = join(TEST_DIR, file);
       expect(existsSync(dest)).toBe(true);
       const content = readFileSync(dest, "utf-8");
@@ -559,6 +612,24 @@ describe("ensurePromptFiles", () => {
     }
   });
 
+  test("does not seed USER.md", () => {
+    // USER.md is no longer part of the seeded prompt files — persona
+    // content lives in users/<slug>.md and is resolved via the guardian
+    // persona path.
+    ensurePromptFiles();
+
+    expect(existsSync(join(TEST_DIR, "USER.md"))).toBe(false);
+  });
+
+  test("seeds users/default.md persona template", () => {
+    ensurePromptFiles();
+
+    const defaultPersonaPath = join(TEST_DIR, "users", "default.md");
+    expect(existsSync(defaultPersonaPath)).toBe(true);
+    const content = readFileSync(defaultPersonaPath, "utf-8");
+    expect(content.length).toBeGreaterThan(0);
+  });
+
   test("does not overwrite existing files", () => {
     const customContent = "My custom identity";
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), customContent);
@@ -568,9 +639,8 @@ describe("ensurePromptFiles", () => {
     const content = readFileSync(join(TEST_DIR, "IDENTITY.md"), "utf-8");
     expect(content).toBe(customContent);
 
-    // Other files should be created
+    // The other seeded file should be created
     expect(existsSync(join(TEST_DIR, "SOUL.md"))).toBe(true);
-    expect(existsSync(join(TEST_DIR, "USER.md"))).toBe(true);
   });
 
   test("handles missing template gracefully (warn, no crash)", () => {
@@ -595,7 +665,6 @@ describe("ensurePromptFiles", () => {
     // BOOTSTRAP.md was deleted by the user.
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
-    writeFileSync(join(TEST_DIR, "USER.md"), "My user");
 
     ensurePromptFiles();
 
@@ -613,11 +682,25 @@ describe("ensurePromptFiles", () => {
     expect(existsSync(bootstrapPath)).toBe(false);
   });
 
+  test("does not treat a workspace with populated users/ as a first run", () => {
+    // Upgraded workspaces may have dropped USER.md but still carry a
+    // populated users/ directory.  Presence of users/<slug>.md signals an
+    // existing install, so BOOTSTRAP.md must not be re-seeded even when
+    // SOUL.md and IDENTITY.md are absent (they will be freshly seeded from
+    // templates, but onboarding should not re-trigger).
+    mkdirSync(join(TEST_DIR, "users"), { recursive: true });
+    writeFileSync(join(TEST_DIR, "users", "sidd.md"), "# Sidd persona");
+
+    ensurePromptFiles();
+
+    const bootstrapPath = join(TEST_DIR, "BOOTSTRAP.md");
+    expect(existsSync(bootstrapPath)).toBe(false);
+  });
+
   test("auto-deletes stale BOOTSTRAP.md when prior conversations exist", () => {
     // Simulate a non-first-run workspace: core files + BOOTSTRAP.md still present
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "My identity");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "My soul");
-    writeFileSync(join(TEST_DIR, "USER.md"), "My user");
     writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# Stale bootstrap");
 
     // Create a conversations directory with at least one entry
@@ -630,15 +713,18 @@ describe("ensurePromptFiles", () => {
     expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
   });
 
-  test("keeps BOOTSTRAP.md on first run even if conversations dir exists", () => {
-    // First run: no core files exist, BOOTSTRAP.md should be created and kept
+  test("does not seed BOOTSTRAP.md when conversations exist even if core files are missing", () => {
+    // An upgraded workspace might have dropped SOUL.md/IDENTITY.md (they
+    // will be re-seeded from templates) but still carries prior
+    // conversations.  Existing conversation history signals a non-fresh
+    // install, so onboarding must not re-trigger.
     const convDir = join(TEST_DIR, "conversations");
     mkdirSync(convDir, { recursive: true });
     writeFileSync(join(convDir, "conv-001.json"), "{}");
 
     ensurePromptFiles();
 
-    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "BOOTSTRAP.md"))).toBe(false);
   });
 
   test("keeps BOOTSTRAP.md when no conversations exist yet", () => {

package/src/__tests__/telephony-stt-routing.test.ts

@@ -0,0 +1,329 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be declared before any subject imports
+// ---------------------------------------------------------------------------
+
+// -- Logger mock ----------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// -- Config mock ----------------------------------------------------------
+
+let mockConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+}));
+
+// ---------------------------------------------------------------------------
+// Subject import (after mocks)
+// ---------------------------------------------------------------------------
+
+import {
+  type ConversationRelayNativeStrategy,
+  type MediaStreamCustomStrategy,
+  resolveTelephonySttRouting,
+} from "../calls/telephony-stt-routing.js";
+import {
+  getProviderEntry,
+  listProviderEntries,
+} from "../providers/speech-to-text/provider-catalog.js";
+import type { SttProviderId } from "../stt/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildConfig(overrides: {
+  provider?: string;
+}): Record<string, unknown> {
+  return {
+    services: {
+      stt: {
+        mode: "your-own",
+        provider: overrides.provider ?? "deepgram",
+        providers: {},
+      },
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests — Provider-to-strategy mapping (catalog-driven)
+// ---------------------------------------------------------------------------
+
+describe("resolveTelephonySttRouting", () => {
+  beforeEach(() => {
+    mockConfig = buildConfig({});
+  });
+
+  // -----------------------------------------------------------------------
+  // Deepgram → conversation-relay-native (from catalog)
+  // -----------------------------------------------------------------------
+
+  describe("deepgram", () => {
+    test("resolves to conversation-relay-native with Deepgram transcriptionProvider", () => {
+      mockConfig = buildConfig({ provider: "deepgram" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      expect(result.strategy.strategy).toBe("conversation-relay-native");
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.providerId).toBe("deepgram");
+      expect(strategy.transcriptionProvider).toBe("Deepgram");
+    });
+
+    test("defaults speechModel to nova-3", () => {
+      mockConfig = buildConfig({ provider: "deepgram" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.speechModel).toBe("nova-3");
+    });
+
+    test("speechModel matches catalog telephonyRouting.twilioNativeMapping.defaultSpeechModel", () => {
+      mockConfig = buildConfig({ provider: "deepgram" });
+      const entry = getProviderEntry("deepgram");
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.speechModel).toBe(
+        entry?.telephonyRouting.twilioNativeMapping?.defaultSpeechModel,
+      );
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Google Gemini → conversation-relay-native (from catalog)
+  // -----------------------------------------------------------------------
+
+  describe("google-gemini", () => {
+    test("resolves to conversation-relay-native with Google transcriptionProvider", () => {
+      mockConfig = buildConfig({ provider: "google-gemini" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      expect(result.strategy.strategy).toBe("conversation-relay-native");
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.providerId).toBe("google-gemini");
+      expect(strategy.transcriptionProvider).toBe("Google");
+    });
+
+    test("leaves speechModel undefined (uses provider default)", () => {
+      mockConfig = buildConfig({ provider: "google-gemini" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.speechModel).toBeUndefined();
+    });
+
+    test("speechModel matches catalog telephonyRouting.twilioNativeMapping.defaultSpeechModel", () => {
+      mockConfig = buildConfig({ provider: "google-gemini" });
+      const entry = getProviderEntry("google-gemini");
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      const strategy = result.strategy as ConversationRelayNativeStrategy;
+      expect(strategy.speechModel).toBe(
+        entry?.telephonyRouting.twilioNativeMapping?.defaultSpeechModel,
+      );
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // OpenAI Whisper → media-stream-custom (from catalog)
+  // -----------------------------------------------------------------------
+
+  describe("openai-whisper", () => {
+    test("resolves to media-stream-custom strategy", () => {
+      mockConfig = buildConfig({ provider: "openai-whisper" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      expect(result.strategy.strategy).toBe("media-stream-custom");
+      const strategy = result.strategy as MediaStreamCustomStrategy;
+      expect(strategy.providerId).toBe("openai-whisper");
+    });
+
+    test("media-stream-custom strategy does not include speechModel", () => {
+      mockConfig = buildConfig({ provider: "openai-whisper" });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      // media-stream-custom has no speechModel property
+      expect(result.strategy.strategy).toBe("media-stream-custom");
+      expect("speechModel" in result.strategy).toBe(false);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Unknown / malformed provider handling
+  // -----------------------------------------------------------------------
+
+  describe("unknown provider handling", () => {
+    test("returns unknown-provider for a provider not in the catalog", () => {
+      mockConfig = buildConfig({ provider: "nonexistent-provider" as string });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("unknown-provider");
+      if (result.status !== "unknown-provider") return;
+
+      expect(result.providerId).toBe("nonexistent-provider");
+      expect(result.reason).toContain("nonexistent-provider");
+      expect(result.reason).toContain("not in the provider catalog");
+    });
+
+    test("returns unknown-provider for empty-string provider", () => {
+      mockConfig = buildConfig({ provider: "" as string });
+
+      const result = resolveTelephonySttRouting();
+
+      expect(result.status).toBe("unknown-provider");
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Strategy discrimination correctness
+  // -----------------------------------------------------------------------
+
+  describe("strategy discrimination", () => {
+    test("conversation-relay-native strategies always have transcriptionProvider", () => {
+      for (const provider of ["deepgram", "google-gemini"]) {
+        mockConfig = buildConfig({ provider });
+
+        const result = resolveTelephonySttRouting();
+        expect(result.status).toBe("resolved");
+        if (result.status !== "resolved") return;
+
+        expect(result.strategy.strategy).toBe("conversation-relay-native");
+        const strategy = result.strategy as ConversationRelayNativeStrategy;
+        expect(strategy.transcriptionProvider).toBeDefined();
+        expect(strategy.transcriptionProvider.length).toBeGreaterThan(0);
+      }
+    });
+
+    test("media-stream-custom strategies never have transcriptionProvider", () => {
+      mockConfig = buildConfig({ provider: "openai-whisper" });
+
+      const result = resolveTelephonySttRouting();
+      expect(result.status).toBe("resolved");
+      if (result.status !== "resolved") return;
+
+      expect(result.strategy.strategy).toBe("media-stream-custom");
+      expect("transcriptionProvider" in result.strategy).toBe(false);
+    });
+
+    test("all resolved strategies include the original providerId", () => {
+      const providers: SttProviderId[] = [
+        "deepgram",
+        "google-gemini",
+        "openai-whisper",
+      ];
+      for (const provider of providers) {
+        mockConfig = buildConfig({ provider });
+
+        const result = resolveTelephonySttRouting();
+        expect(result.status).toBe("resolved");
+        if (result.status !== "resolved") return;
+
+        expect(result.strategy.providerId).toBe(provider);
+      }
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Catalog-driven mapping verification
+  // -----------------------------------------------------------------------
+
+  describe("catalog-driven mapping", () => {
+    test("every catalog entry with conversation-relay-native routing resolves to that strategy", () => {
+      const nativeEntries = listProviderEntries().filter(
+        (e) => e.telephonyRouting.strategyKind === "conversation-relay-native",
+      );
+      expect(nativeEntries.length).toBeGreaterThan(0);
+
+      for (const entry of nativeEntries) {
+        mockConfig = buildConfig({ provider: entry.id });
+
+        const result = resolveTelephonySttRouting();
+        expect(result.status).toBe("resolved");
+        if (result.status !== "resolved") return;
+
+        expect(result.strategy.strategy).toBe("conversation-relay-native");
+        const strategy = result.strategy as ConversationRelayNativeStrategy;
+        expect(strategy.transcriptionProvider).toBe(
+          entry.telephonyRouting.twilioNativeMapping!.provider,
+        );
+        expect(strategy.speechModel).toBe(
+          entry.telephonyRouting.twilioNativeMapping!.defaultSpeechModel,
+        );
+      }
+    });
+
+    test("every catalog entry with media-stream-custom routing resolves to that strategy", () => {
+      const customEntries = listProviderEntries().filter(
+        (e) => e.telephonyRouting.strategyKind === "media-stream-custom",
+      );
+      expect(customEntries.length).toBeGreaterThan(0);
+
+      for (const entry of customEntries) {
+        mockConfig = buildConfig({ provider: entry.id });
+
+        const result = resolveTelephonySttRouting();
+        expect(result.status).toBe("resolved");
+        if (result.status !== "resolved") return;
+
+        expect(result.strategy.strategy).toBe("media-stream-custom");
+        expect(result.strategy.providerId).toBe(entry.id);
+      }
+    });
+
+    test("routing module contains no hardcoded provider-to-Twilio map", async () => {
+      // Read the source file and verify the hardcoded map was removed.
+      // This is a structural assertion: the catalog is the sole source of truth.
+      const sourceFile = Bun.file(
+        new URL("../calls/telephony-stt-routing.ts", import.meta.url).pathname,
+      );
+      const source = await sourceFile.text();
+
+      expect(source).not.toContain("TWILIO_NATIVE_PROVIDER_MAP");
+      expect(source).not.toContain("new Map<SttProviderId");
+      expect(source).not.toContain("DEEPGRAM_DEFAULT_SPEECH_MODEL");
+    });
+  });
+});

package/src/__tests__/terminal-tools.test.ts

@@ -450,8 +450,10 @@ describe("buildSanitizedEnv", () => {
     delete process.env.LC_ALL;
 
     const env = buildSanitizedEnv();
-    expect(env.LANG).toBe("C.UTF-8");
-    expect(env.LC_ALL).toBe("C.UTF-8");
+    const expectedLocale =
+      process.platform === "darwin" ? "en_US.UTF-8" : "C.UTF-8";
+    expect(env.LANG).toBe(expectedLocale);
+    expect(env.LC_ALL).toBe(expectedLocale);
   });
 
   test("injects INTERNAL_GATEWAY_BASE_URL from gateway config", () => {
@@ -530,12 +532,21 @@ describe("Native sandbox backend", () => {
       expect(result.sandboxed).toBe(true);
     });
 
-    test("rejects working dir with SBPL metacharacters", () => {
+    test("escapes working dir with SBPL metacharacters", () => {
+      // SBPL metacharacters (", (, ), ;, \) are backslash-escaped inside the
+      // profile string rather than rejected, so wrap() should succeed.
       const backend = new NativeBackend();
-      expect(() => backend.wrap("echo hi", '/tmp/foo"bar')).toThrow(ToolError);
-      expect(() => backend.wrap("echo hi", "/tmp/foo(bar")).toThrow(ToolError);
-      expect(() => backend.wrap("echo hi", "/tmp/foo;bar")).toThrow(ToolError);
-      expect(() => backend.wrap("echo hi", "/tmp/foo\\bar")).toThrow(ToolError);
+      expect(backend.wrap("echo hi", '/tmp/foo"bar').sandboxed).toBe(true);
+      expect(backend.wrap("echo hi", "/tmp/foo(bar").sandboxed).toBe(true);
+      expect(backend.wrap("echo hi", "/tmp/foo;bar").sandboxed).toBe(true);
+      expect(backend.wrap("echo hi", "/tmp/foo\\bar").sandboxed).toBe(true);
+    });
+
+    test("rejects working dir with newline characters", () => {
+      // Newlines/CRs cannot appear in real paths and would break the profile.
+      const backend = new NativeBackend();
+      expect(() => backend.wrap("echo hi", "/tmp/foo\nbar")).toThrow(ToolError);
+      expect(() => backend.wrap("echo hi", "/tmp/foo\rbar")).toThrow(ToolError);
     });
 
     test("accepts working dir with safe special characters", () => {

package/src/__tests__/test-preload.ts

@@ -16,7 +16,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll } from "bun:test";
 
+import { installGatewayIpcMock } from "../__tests__/mock-gateway-ipc.js";
 import { resetDb } from "../memory/db-connection.js";
+import { _setStorePath } from "../security/encrypted-store.js";
 
 const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "vellum-test-workspace-")),
@@ -25,6 +27,22 @@ process.env.VELLUM_WORKSPACE_DIR = testDir;
 process.env.VELLUM_PLATFORM_URL = "https://test-platform.vellum.ai";
 process.exitCode = 0;
 
+// Isolate the encrypted credential store per test file. Without this,
+// parallel test processes all read/write the same ~/.vellum/protected/keys.enc,
+// causing races when one file deletes a key while another sets it.
+_setStorePath(join(testDir, "keys.enc"));
+
+// Mock gateway IPC so no test accidentally connects to a real gateway socket.
+// Tests that need to control IPC responses use mockGatewayIpc() / resetMockGatewayIpc().
+installGatewayIpcMock();
+
+// Force-close any DB connection inherited from the parent process (e.g. when
+// the test runner is spawned by the running assistant via a pre-push hook).
+// Without this, the db singleton in db-connection.ts may still point at the
+// real ~/.vellum/workspace database, and test cleanup (DELETE FROM …) would
+// wipe production data — contacts, channels, credentials, etc.
+resetDb();
+
 // Prevent tests from routing credential writes through the real CES
 // (Credential Execution Service). Without this, setSecureKeyAsync() in
 // containerized environments writes to the live credential store.

package/src/__tests__/test-support/browser-skill-harness.ts

@@ -1,11 +1,13 @@
 import type { Message } from "../../providers/types.js";
 
-/** The 14 browser tool names provided by the browser skill. */
+/** The browser tool names provided by the browser skill. */
 export const BROWSER_TOOL_NAMES = [
   "browser_navigate",
   "browser_snapshot",
   "browser_screenshot",
   "browser_close",
+  "browser_attach",
+  "browser_detach",
   "browser_click",
   "browser_type",
   "browser_press_key",
@@ -16,6 +18,7 @@ export const BROWSER_TOOL_NAMES = [
   "browser_extract",
   "browser_wait_for_download",
   "browser_fill_credential",
+  "browser_status",
 ] as const;
 
 /** Number of browser tools provided by the skill. */