@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/subagent-notify-parent.test.ts

@@ -27,6 +27,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getMessages: () => null,
   createConversation: () => ({ id: "mock-conv" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 /**
@@ -37,11 +38,11 @@ const capturedMessages: string[] = [];
 
 mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (_id: string) => ({
-    enqueueMessage: (content: string) => {
-      capturedMessages.push(content);
+    enqueueMessage: (options: { content: string }) => {
+      capturedMessages.push(options.content);
       return { queued: true };
     },
-    persistUserMessage: async () => "mock-msg",
+    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
   addConversation: () => {},
@@ -106,7 +107,7 @@ function injectSubagent(
     sendToClient: () => {},
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     enqueueMessage: () => ({ queued: false }),
-    persistUserMessage: () => "msg-1",
+    persistUserMessage: async () => ({ id: "msg-1", deduplicated: false }),
     runAgentLoop: async () => {},
   };
   internals.subagents.set(subagentId, {

package/src/__tests__/subagent-spawn-tool-fork.test.ts

@@ -26,6 +26,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getMessages: () => null,
   createConversation: () => ({ id: "mock-conv" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import {
@@ -318,6 +319,63 @@ describe("subagent_spawn fork parameter", () => {
     );
   });
 
+  test("threads context.toolUseId into config as parentToolUseId", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+
+    let capturedConfig: Record<string, unknown> | undefined;
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "tool-use-id-subagent";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Stamped task",
+          objective: "Do something",
+        },
+        makeContext("tool-use-conv", {
+          sendToClient: () => {},
+          toolUseId: "toolu_123",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig).toBeDefined();
+      expect(capturedConfig!.parentToolUseId).toBe("toolu_123");
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("omits parentToolUseId when no toolUseId is in context", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+
+    let capturedConfig: Record<string, unknown> | undefined;
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "no-tool-use-id-subagent";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Unstamped task",
+          objective: "Do something",
+        },
+        makeContext("no-tool-use-conv", { sendToClient: () => {} }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig).toBeDefined();
+      expect(capturedConfig!.parentToolUseId).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
   test("fork: true shallow copies parent messages", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);

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

@@ -30,6 +30,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getMessages: (conversationId: string) => mockGetMessages(conversationId),
   createConversation: () => ({ id: "mock-conv" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { getSubagentManager } from "../subagent/index.js";
@@ -97,7 +98,7 @@ function injectSubagent(
     sendToClient: () => {},
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     enqueueMessage: () => ({ queued: false }),
-    persistUserMessage: () => "msg-1",
+    persistUserMessage: async () => ({ id: "msg-1", deduplicated: false }),
     runAgentLoop: async () => {},
   };
   internals.subagents.set(subagentId, {

package/src/__tests__/suggestion-routes.test.ts

@@ -52,6 +52,7 @@ const mockGetMessages = mock((_conversationId: string) => [
 mock.module("../memory/conversation-crud.js", () => ({
   getMessages: mockGetMessages,
   getConversation: (_id: string) => null,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const mockGetConfiguredProvider = mock(async () => ({

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

@@ -171,6 +171,44 @@ describe("buildSystemPrompt", () => {
     expect(result).toContain("# Soul\n\nBe thoughtful.");
   });
 
+  test("gates off the unmodified bundled IDENTITY.md template when no BOOTSTRAP.md is present", () => {
+    // Regression: the seeded IDENTITY.md ships with `_`-comment lines, so
+    // the raw workspace body never equals the comment-stripped bundled
+    // template. `isTemplateContent` must comment-strip BOTH sides — otherwise
+    // detection fails and the `08-identity` transform leaks the blank
+    // template scaffolding into every fresh post-onboarding prompt.
+    const bundledIdentity = readFileSync(
+      join(import.meta.dirname, "..", "prompts", "templates", "IDENTITY.md"),
+      "utf-8",
+    );
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), bundledIdentity);
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
+    const result = buildSystemPrompt();
+    // SOUL still renders; the template scaffolding must not.
+    expect(result).toContain("# Soul\n\nBe thoughtful.");
+    expect(result).not.toContain("(not yet chosen)");
+  });
+
+  test("includes the unmodified bundled IDENTITY.md template during bootstrap", () => {
+    // The mirror case: when BOOTSTRAP.md is active the template is included
+    // verbatim so the model can see the field structure and produce a valid
+    // file_write on the first turn.
+    const bundledIdentity = readFileSync(
+      join(import.meta.dirname, "..", "prompts", "templates", "IDENTITY.md"),
+      "utf-8",
+    );
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), bundledIdentity);
+    writeFileSync(
+      join(TEST_DIR, "BOOTSTRAP.md"),
+      "# First run\n\nGet started.",
+    );
+    const result = buildSystemPrompt();
+    // The bundled template's placeholder scaffolding (the `(not yet chosen)`
+    // field markers) renders verbatim during bootstrap — the mirror of the
+    // gating test above, which asserts it is absent without BOOTSTRAP.md.
+    expect(result).toContain("(not yet chosen)");
+  });
+
   test("trims whitespace from file content", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "\n  Be kind  \n\n");
     const result = buildSystemPrompt();

package/src/__tests__/test-preload-verifier.ts

@@ -0,0 +1,68 @@
+/**
+ * Test preload verifier — runs immediately after test-preload.ts.
+ *
+ * Bun already exits with code 1 when a preload throws, has an unresolvable
+ * import, or doesn't exist on disk (verified empirically). This file is
+ * the explicit check for the remaining failure mode: the main preload
+ * ran successfully but didn't actually isolate workspace state (e.g. a
+ * future refactor of test-preload.ts introduces a logic bug that no-ops
+ * the env override).
+ *
+ * Without this verifier, that failure mode would silently let tests
+ * resolve `VELLUM_WORKSPACE_DIR` to the real `/workspace` and potentially
+ * destroy live data.
+ *
+ * Order matters: bunfig.toml lists this AFTER test-preload.ts so the
+ * main preload's env writes are observable here.
+ *
+ * No source-module imports — only node stdlib (matches the same rule
+ * test-preload.ts enforces).
+ *
+ * Positive assertion: `VELLUM_WORKSPACE_DIR` MUST resolve under
+ * `os.tmpdir()`. This mirrors exactly what test-preload.ts does
+ * (`mkdtempSync(join(tmpdir(), "vellum-test-"))`), so any other value
+ * indicates the preload either didn't run or didn't take effect.
+ */
+
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { sep } from "node:path";
+
+function fail(reason: string): never {
+  throw new Error(
+    [
+      `Test preload verifier failed: ${reason}.`,
+      "",
+      "test-preload.ts ran but did not isolate workspace state. Common",
+      "causes:",
+      "  - a logic bug in test-preload.ts (env override removed/reordered)",
+      "  - a preload phase threw silently and the verifier still picked up",
+      "    partial state",
+    ].join("\n"),
+  );
+}
+
+function canonicalize(p: string): string {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+
+const workspaceDir = process.env.VELLUM_WORKSPACE_DIR?.trim();
+if (!workspaceDir) {
+  fail("VELLUM_WORKSPACE_DIR is not set after main preload");
+}
+
+const resolvedWorkspace = canonicalize(workspaceDir);
+const tmpRoot = canonicalize(tmpdir());
+
+if (
+  resolvedWorkspace !== tmpRoot &&
+  !resolvedWorkspace.startsWith(tmpRoot + sep)
+) {
+  fail(
+    `VELLUM_WORKSPACE_DIR resolves to ${resolvedWorkspace}, which is not under ${tmpRoot}`,
+  );
+}

package/src/__tests__/test-preload.ts

@@ -1,56 +1,42 @@
 /**
  * Shared test preload — runs before every test file.
  *
- * Creates a per-file temporary directory and sets VELLUM_WORKSPACE_DIR so that
- * all workspace-derived helpers (getDataDir, getDbPath, getConversationsDir, …)
- * resolve under the temp dir instead of the real ~/.vellum/workspace.
- *
- * Individual test files can retrieve the workspace dir via getWorkspaceDir()
- * from platform.ts, or directly from process.env.VELLUM_WORKSPACE_DIR.
+ * Creates a per-process temporary directory and sets VELLUM_WORKSPACE_DIR so
+ * that all workspace-derived helpers (getDataDir, getDbPath,
+ * getConversationsDir, getProtectedDir, …) resolve under the temp dir
+ * instead of the real $VELLUM_WORKSPACE_DIR.
  *
  * Cleanup: the temp dir is removed after all tests in the file complete.
+ *
+ * No source-module imports
+ * ------------------------
+ * The only static imports in this file are node stdlib (`node:fs`,
+ * `node:os`, `node:path`), `bun:test`, and helpers in this same directory.
+ * Importing from the assistant directly runs the risk of triggering import
+ * time side effects and import from node modules that may not exist in
+ * some environments.
  */
 
-import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll } from "bun:test";
 
-import { installGatewayIpcMock } from "../__tests__/mock-gateway-ipc.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-import { resetDb } from "../memory/db-connection.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { installGatewayIpcMock } from "./mock-gateway-ipc.js";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "vellum-test-workspace-")),
-);
+// --- Phase 1: env override (zero source-module imports above this point) ---
+
+// Layout: <tmpRoot>/workspace as VELLUM_WORKSPACE_DIR. The parent of
+// VELLUM_WORKSPACE_DIR is what `vellumRoot()` resolves to, so a separate
+// tmpRoot per process gives `getProtectedDir()` and friends per-process
+// isolation without needing an explicit `setStorePathForTesting()`.
+const tmpRoot = realpathSync(mkdtempSync(join(tmpdir(), "vellum-test-")));
+const testDir = join(tmpRoot, "workspace");
+mkdirSync(testDir);
 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();
-
-// Pre-populate the feature-flag override cache so `initFeatureFlagOverrides()`
-// short-circuits its retry loop — there is no real gateway in tests, and the
-// retry backoff would otherwise exceed the per-test timeout for any test that
-// builds the CLI program. Tests exercising the retry behavior call
-// `clearFeatureFlagOverridesCache()` first.
-_setOverridesForTesting({});
-
-// 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.
@@ -59,8 +45,15 @@ const savedCesCredentialUrl = process.env.CES_CREDENTIAL_URL;
 delete process.env.IS_CONTAINERIZED;
 delete process.env.CES_CREDENTIAL_URL;
 
+// --- Phase 2: install the IPC mock (no source-module imports) ---
+
+// Mock gateway IPC so no test accidentally connects to a real gateway socket.
+// The mock returns a sentinel for `get_feature_flags` to short-circuit the
+// retry loop in `initFeatureFlagOverrides()`. Tests that need specific IPC
+// responses use `mockGatewayIpc()` / `resetMockGatewayIpc()`.
+installGatewayIpcMock();
+
 afterAll(() => {
-  resetDb();
   process.exitCode = 0;
   delete process.env.VELLUM_WORKSPACE_DIR;
   delete process.env.VELLUM_PLATFORM_URL;
@@ -71,7 +64,7 @@ afterAll(() => {
     process.env.CES_CREDENTIAL_URL = savedCesCredentialUrl;
   }
   try {
-    rmSync(testDir, { recursive: true, force: true });
+    rmSync(tmpRoot, { recursive: true, force: true });
   } catch {
     /* best-effort cleanup */
   }

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -72,6 +72,7 @@ mock.module("../permissions/checker.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   createConversation: (title: string) => ({ id: "conversation-1", title }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Mock every export so downstream test files that dynamically import modules
@@ -85,15 +86,16 @@ mock.module("../memory/tool-usage-store.js", () => ({
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => {
     if (name === "unknown_tool") return undefined;
-    // Skill tools carry origin and executionTarget from their manifest
+    // Skill tools carry executionTarget from their manifest. Ownership lives
+    // on the registry (mocked below via getToolOwner reading the override's
+    // owner field), so it doesn't appear on the Tool object itself.
     if (name === "skill_host_tool") {
       return {
         name,
         description: "skill host tool",
         category: "skill",
         defaultRiskLevel: "low",
-        origin: "skill" as const,
-        ownerSkillId: "test-skill",
+        owner: { kind: "skill", id: "test-skill" },
         executionTarget: "host" as const,
         input_schema: {},
         execute: async () => {
@@ -108,8 +110,7 @@ mock.module("../tools/registry.js", () => ({
         description: "skill sandbox tool",
         category: "skill",
         defaultRiskLevel: "low",
-        origin: "skill" as const,
-        ownerSkillId: "test-skill",
+        owner: { kind: "skill", id: "test-skill" },
         executionTarget: "sandbox" as const,
         input_schema: {},
         execute: async () => {
@@ -126,8 +127,7 @@ mock.module("../tools/registry.js", () => ({
         description: "skill tool with host_ prefix but sandbox target",
         category: "skill",
         defaultRiskLevel: "low",
-        origin: "skill" as const,
-        ownerSkillId: "test-skill",
+        owner: { kind: "skill", id: "test-skill" },
         executionTarget: "sandbox" as const,
         input_schema: {},
         execute: async () => {
@@ -158,6 +158,19 @@ mock.module("../tools/registry.js", () => ({
       },
     };
   },
+  // Ownership lives on the registry post-refactor. Mirror that by surfacing
+  // the optional `owner`-shaped field set inline on the override-produced
+  // tool (see the skill_* branches above).
+  getToolOwner: (name: string) => {
+    if (
+      name === "skill_host_tool" ||
+      name === "skill_sandbox_tool" ||
+      name === "host_skill_sandboxed"
+    ) {
+      return { kind: "skill" as const, id: "test-skill" };
+    }
+    return undefined;
+  },
 }));
 
 mock.module("../tools/shared/filesystem/path-policy.js", () => ({

package/src/__tests__/tool-executor.test.ts

@@ -148,6 +148,16 @@ mock.module("../tools/registry.js", () => ({
     };
   },
   getAllTools: () => (getAllToolsOverride ? getAllToolsOverride() : []),
+  // Ownership lives on the registry post-refactor; production reads it via
+  // getToolOwner(name) rather than a field on the Tool object. Mirror that by
+  // surfacing the optional `owner`-shaped field from the override-produced
+  // tool so existing tests can encode owner inline.
+  getToolOwner: (name: string) => {
+    const t = getToolOverride?.(name) as
+      | { owner?: { kind: "skill" | "mcp" | "plugin"; id: string } }
+      | undefined;
+    return t?.owner;
+  },
 }));
 
 mock.module("../tools/shared/filesystem/path-policy.js", () => ({
@@ -224,6 +234,48 @@ describe("ToolExecutor allowedToolNames gating", () => {
     expect(result.content).toBe("ok");
   });
 
+  test("canonicalizes legacy computer_use_press_key alias before active-tool gating", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["computer_use_key"]);
+    const result = await executor.execute(
+      "computer_use_press_key",
+      {
+        key: "Space",
+        modifiers: ["Command"],
+        reasoning: "Open Spotlight",
+      },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ok");
+    expect(lastCheckArgs?.toolName).toBe("computer_use_key");
+    expect(lastCheckArgs?.input).toEqual({
+      key: "cmd+space",
+      reasoning: "Open Spotlight",
+    });
+  });
+
+  test("lowercases legacy computer_use_press_key key-only input", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["computer_use_key"]);
+    const result = await executor.execute(
+      "computer_use_press_key",
+      {
+        key: "Space",
+        reasoning: "Pause media",
+      },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(lastCheckArgs?.toolName).toBe("computer_use_key");
+    expect(lastCheckArgs?.input).toEqual({
+      key: "space",
+      reasoning: "Pause media",
+    });
+  });
+
   test("preserves exact active create_app tool before applying compatibility aliases", async () => {
     const executor = new ToolExecutor(makePrompter());
     const allowed = new Set(["create_app", "app_create"]);
@@ -334,8 +386,7 @@ describe("ToolExecutor allowedToolNames gating", () => {
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
         executionTarget: "sandbox" as const,
-        origin: "skill" as const,
-        ownerSkillId: "my-skill",
+        owner: { kind: "skill", id: "my-skill" },
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
       };
@@ -371,9 +422,7 @@ describe("ToolExecutor policy context plumbing", () => {
         description: "skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "my-skill-123",
-        ownerSkillVersionHash: "abc123hash",
+        owner: { kind: "skill", id: "my-skill-123" },
         executionTarget: "sandbox" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
@@ -424,7 +473,6 @@ describe("ToolExecutor policy context plumbing", () => {
         category: "core",
         defaultRiskLevel: RiskLevel.Low,
         executionTarget: "sandbox" as const,
-        origin: "core" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
       };
@@ -453,9 +501,7 @@ describe("ToolExecutor policy context plumbing", () => {
         description: "host skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "host-skill",
-        ownerSkillVersionHash: "host-hash",
+        owner: { kind: "skill", id: "host-skill" },
         executionTarget: "host" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
@@ -477,7 +523,6 @@ describe("ToolExecutor policy context plumbing", () => {
       executionTarget: "host",
     });
   });
-
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -45,6 +45,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -44,6 +44,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({

package/src/__tests__/twilio-routes.test.ts

@@ -337,7 +337,7 @@ import {
   handleVoiceWebhook,
 } from "../calls/twilio-routes.js";
 import { DEFAULT_ELEVENLABS_VOICE_ID } from "../config/schemas/elevenlabs.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import {
@@ -347,6 +347,7 @@ import {
   handleSetTwilioCredentials,
 } from "../runtime/routes/integrations/twilio.js";
 import { credentialKey } from "../security/credential-key.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -487,7 +488,7 @@ describe("twilio webhook routes", () => {
 
   afterAll(() => {
     globalThis.fetch = originalFetch;
-    resetDb();
+    resetDbForTesting();
   });
 
   // ── Callback idempotency / replay tests ───────────────────────────