@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -69,50 +69,37 @@ mock.module("../prompts/user-reference.js", () => ({
   resolveUserPronouns: () => null,
 }));
 
+// Stub persona-resolver so tests can dictate the slug `buildSystemPrompt`
+// sees without needing to write contact rows to the test DB. The user
+// and channel persona files themselves now flow through bundled sections
+// (`10-user-persona` / `11-channel-persona`) that read from disk, so
+// persona *content* is exercised by writing the file under TEST_DIR
+// rather than mocking it here. Tests mutate `mockPersona` in place;
+// the default (all-null) matches a fresh workspace with no contacts
+// and no `users/default.md`.
+const mockPersona: {
+  userSlug: string | null;
+  guardianPersona: string | null;
+} = { userSlug: null, guardianPersona: null };
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realPersonaResolver = require("../prompts/persona-resolver.js");
+mock.module("../prompts/persona-resolver.js", () => ({
+  ...realPersonaResolver,
+  resolveUserSlug: () => mockPersona.userSlug,
+  resolveGuardianPersona: () => mockPersona.guardianPersona,
+}));
+
 // Import after mock
-const {
-  buildSystemPrompt,
-  ensurePromptFiles,
-  stripCommentLines,
-  SYSTEM_PROMPT_CACHE_BOUNDARY,
-} = await import("../prompts/system-prompt.js");
-
-/**
- * Extract IDENTITY.md / BOOTSTRAP.md content + the user persona from the
- * dynamic block of the system prompt, stripping configuration, skills
- * catalog, and connected services.
- *
- * SOUL.md no longer flows through this helper — it renders as the
- * `09-soul` workspace-backed section in the static (cached) prefix.
- * Tests that assert on SOUL.md content slice the static block directly.
- */
-function basePrompt(result: string): string {
-  // The workspace files are in the dynamic block after the cache boundary.
-  const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-  let s =
-    boundaryIdx >= 0
-      ? result.slice(boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length)
-      : result;
-  for (const heading of [
-    "## Configuration",
-    "## Skills Catalog",
-    "## External Communications Identity",
-    "# Connected Services",
-    "## Dynamic Skill Authoring Workflow",
-  ]) {
-    if (s.startsWith(heading)) {
-      s = "";
-      break;
-    }
-    const idx = s.indexOf(`\n\n${heading}`);
-    if (idx !== -1) s = s.slice(0, idx);
-  }
-  return s;
-}
+const { buildSystemPrompt, ensurePromptFiles, stripCommentLines } =
+  await import("../prompts/system-prompt.js");
 
 describe("buildSystemPrompt", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
+    // Reset persona stub so each test starts from a fresh
+    // no-guardian baseline.
+    mockPersona.userSlug = null;
+    mockPersona.guardianPersona = null;
   });
 
   afterEach(() => {
@@ -122,8 +109,10 @@ describe("buildSystemPrompt", () => {
       "USER.md",
       "BOOTSTRAP.md",
       "UPDATES.md",
+      "VOICE.md",
       "skills",
       "users",
+      "channels",
     ]) {
       const p = join(TEST_DIR, name);
       if (existsSync(p)) rmSync(p, { recursive: true, force: true });
@@ -133,19 +122,11 @@ describe("buildSystemPrompt", () => {
     }
   });
 
-  test("returns empty string when no files exist", () => {
-    const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("");
-  });
-
   test("uses SOUL.md when it exists", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "# My Soul\n\nBe awesome.");
     const result = buildSystemPrompt();
-    // SOUL.md renders as the `09-soul` workspace-backed section in the
-    // static (cached) prefix before SYSTEM_PROMPT_CACHE_BOUNDARY.
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(boundaryIdx).toBeGreaterThan(-1);
-    expect(result.slice(0, boundaryIdx)).toContain("# My Soul\n\nBe awesome.");
+    // SOUL.md renders as the `09-soul` workspace-backed section.
+    expect(result).toContain("# My Soul\n\nBe awesome.");
   });
 
   test("uses IDENTITY.md when it exists", () => {
@@ -154,30 +135,40 @@ describe("buildSystemPrompt", () => {
       "# My Identity\n\nI am Vellum.",
     );
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("# My Identity\n\nI am Vellum.");
+    // IDENTITY.md renders as the `08-identity` workspace-backed section.
+    expect(result).toContain("# My Identity\n\nI am Vellum.");
   });
 
   test("composes IDENTITY.md + SOUL.md when both exist", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
     const result = buildSystemPrompt();
-    // SOUL renders as the workspace-backed section in the static prefix;
-    // IDENTITY renders in the dynamic suffix.
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(result.slice(0, boundaryIdx)).toContain("# Soul\n\nBe thoughtful.");
-    expect(basePrompt(result)).toBe("# Identity\n\nI am Vellum.");
+    // IDENTITY renders before SOUL (sections `08-identity` then
+    // `09-soul`).
+    expect(result).toContain("# Identity\n\nI am Vellum.");
+    expect(result).toContain("# Soul\n\nBe thoughtful.");
+    const identityIdx = result.indexOf("# Identity\n\nI am Vellum.");
+    const soulIdx = result.indexOf("# Soul\n\nBe thoughtful.");
+    expect(identityIdx).toBeLessThan(soulIdx);
   });
 
   test("ignores empty SOUL.md", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "   \n  \n  ");
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("");
+    // IDENTITY renders but SOUL is gated off by the renderer's
+    // empty-body check; no SOUL content should appear.
+    expect(result).toContain("# Identity\n\nI am Vellum.");
+    expect(result).not.toContain("   \n  \n  ");
   });
 
   test("ignores empty IDENTITY.md", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("");
+    // SOUL renders but IDENTITY's empty file is gated off by the
+    // renderer's empty-body check.
+    expect(result).toContain("# Soul\n\nBe thoughtful.");
   });
 
   test("trims whitespace from file content", () => {
@@ -185,10 +176,8 @@ describe("buildSystemPrompt", () => {
     const result = buildSystemPrompt();
     // SOUL.md renders via the `09-soul` workspace-backed section;
     // stripCommentLines + trim run inside the section renderer.
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    const staticBlock = result.slice(0, boundaryIdx);
-    expect(staticBlock).toContain("Be kind");
-    expect(staticBlock).not.toContain("\n  Be kind  \n");
+    expect(result).toContain("Be kind");
+    expect(result).not.toContain("\n  Be kind  \n");
   });
 
   test("does not include skills catalog in system prompt", () => {
@@ -217,10 +206,9 @@ describe("buildSystemPrompt", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul content");
 
     const result = buildSystemPrompt();
-    // After SOUL.md became the `09-soul` workspace-backed section, it
-    // renders in the static prefix while IDENTITY stays in the dynamic
-    // suffix — the two are no longer adjacent.  Verify both are present
-    // and the skills catalog is still suppressed.
+    // Both files render in the static prefix via `08-identity` /
+    // `09-soul`.  Verify both are present and the skills catalog is
+    // still suppressed.
     expect(result).toContain("Identity content");
     expect(result).toContain("Soul content");
     expect(result).not.toContain("## Available Skills");
@@ -262,11 +250,7 @@ describe("buildSystemPrompt", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
     const result = buildSystemPrompt();
-    // SOUL.md now renders in the static (cached) prefix via the 09-soul
-    // section, so it doesn't flow through basePrompt.  Assert that
-    // IDENTITY is the only dynamic content and that SOUL is still in the
-    // full prompt.
-    expect(basePrompt(result)).toBe("Identity");
+    expect(result).toContain("Identity");
     expect(result).toContain("Soul");
   });
 
@@ -280,55 +264,118 @@ describe("buildSystemPrompt", () => {
     );
     const result = buildSystemPrompt();
     expect(result).not.toContain("stale user content");
-    expect(basePrompt(result)).toBe("Identity");
+    expect(result).toContain("Identity");
   });
 
-  test("uses options.userPersona instead of USER.md", () => {
+  test("includes resolved user persona in the static prefix", () => {
+    // User persona flows through the `10-user-persona` bundled section,
+    // which reads from `users/<userSlug>.md` (or `users/default.md` as
+    // a fallback).  Set the slug + write the file to exercise both.
+    mockPersona.userSlug = "alice";
+    mkdirSync(join(TEST_DIR, "users"), { recursive: true });
+    writeFileSync(
+      join(TEST_DIR, "users", "alice.md"),
+      "# User persona\n\nName: Alice",
+    );
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
-    const result = buildSystemPrompt({
-      userPersona: "# User persona\n\nName: Alice",
-    });
-    // SOUL.md renders in the static (cached) prefix via the 09-soul section
-    // and is no longer part of the dynamic block sliced by basePrompt.
-    expect(basePrompt(result)).toBe(
-      "Identity\n\n# User persona\n\nName: Alice",
-    );
+    const result = buildSystemPrompt();
+    // IDENTITY, SOUL, and the user persona all render as workspace-backed
+    // bundled sections in the assembled prompt.
+    expect(result).toContain("Identity");
     expect(result).toContain("Soul");
+    expect(result).toContain("# User persona");
+    expect(result).toContain("Name: Alice");
+  });
+
+  test("user persona falls back to users/default.md when the slug's file is missing", () => {
+    // The `10-user-persona` section's workspacePath is
+    // `["users/{{userSlug}}.md", "users/default.md"]` — when the
+    // primary file doesn't exist the renderer falls through to default.
+    mockPersona.userSlug = "alice";
+    mkdirSync(join(TEST_DIR, "users"), { recursive: true });
+    writeFileSync(
+      join(TEST_DIR, "users", "default.md"),
+      "# Default persona\n\nNo contact bound.",
+    );
+    const result = buildSystemPrompt();
+    expect(result).toContain("# Default persona");
+    expect(result).toContain("No contact bound.");
+  });
+
+  test("includes channel persona from channels/<channelSlug>.md", () => {
+    // Channel persona flows through the `11-channel-persona` section.
+    // Default channel is "vellum" when no channelCapabilities passed.
+    mkdirSync(join(TEST_DIR, "channels"), { recursive: true });
+    writeFileSync(
+      join(TEST_DIR, "channels", "vellum.md"),
+      "# Channel persona\n\nThis is the Vellum channel.",
+    );
+    const result = buildSystemPrompt();
+    expect(result).toContain("# Channel persona");
+    expect(result).toContain("This is the Vellum channel.");
+  });
+
+  test("includes VOICE.md as the 12-voice section with prepended heading", () => {
+    // VOICE.md flows through the `12-voice` bundled section.  The
+    // section transform prepends `# Voice Profile` so the file itself
+    // stays heading-free; the model writes voice markers as plain
+    // bullets / lines.
+    writeFileSync(
+      join(TEST_DIR, "VOICE.md"),
+      "- Prefers lowercase. Replies tightly. Skips greetings.",
+    );
+    const result = buildSystemPrompt();
+    expect(result).toContain("# Voice Profile");
+    expect(result).toContain("Prefers lowercase");
+  });
+
+  test("omits the 12-voice section when VOICE.md is missing", () => {
+    const result = buildSystemPrompt();
+    expect(result).not.toContain("# Voice Profile");
+  });
+
+  test("omits the 12-voice section when VOICE.md is empty / whitespace-only", () => {
+    writeFileSync(join(TEST_DIR, "VOICE.md"), "   \n\n  \n");
+    const result = buildSystemPrompt();
+    expect(result).not.toContain("# Voice Profile");
   });
 
   describe("BOOTSTRAP.md user persona placeholder", () => {
-    test("substitutes {{USER_PERSONA_FILE}} with users/<slug>.md when userSlug is provided", () => {
+    test("substitutes {{userSlug}} with the resolved slug when a guardian slug is resolvable", () => {
+      // Simulate a guardian contact whose userFile resolves to alice.md.
+      mockPersona.userSlug = "alice";
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
-        "# First run\n\nSave facts to users/{{USER_PERSONA_FILE}} immediately.",
+        "# First run\n\nSave facts to users/{{userSlug}}.md immediately.",
       );
-      const result = buildSystemPrompt({ userSlug: "alice" });
+      const result = buildSystemPrompt();
       expect(result).toContain("users/alice.md");
-      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+      expect(result).not.toContain("{{userSlug}}");
     });
 
-    test("falls back to users/default.md when userSlug is omitted", () => {
+    test("falls back to users/default.md when no slug is resolvable", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
-        "# First run\n\nSave facts to users/{{USER_PERSONA_FILE}} immediately.",
+        "# First run\n\nSave facts to users/{{userSlug}}.md immediately.",
       );
       const result = buildSystemPrompt();
       expect(result).toContain("users/default.md");
-      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+      expect(result).not.toContain("{{userSlug}}");
     });
 
     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.
+      mockPersona.userSlug = "alice";
       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" });
+      const result = buildSystemPrompt();
       expect(result).toContain("users/alice.md");
-      expect(result).not.toContain("{{USER_PERSONA_FILE}}");
+      expect(result).not.toContain("{{userSlug}}");
     });
   });
 
@@ -480,7 +527,11 @@ describe("buildSystemPrompt", () => {
       "# Identity\n_ This is a comment\nI am Vellum.\n_ Another comment",
     );
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("# Identity\nI am Vellum.");
+    // IDENTITY.md renders in the static prefix via the 08-identity section,
+    // so we assert against the full prompt rather than basePrompt.
+    expect(result).toContain("# Identity\nI am Vellum.");
+    expect(result).not.toContain("_ This is a comment");
+    expect(result).not.toContain("_ Another comment");
   });
 
   test("collapses whitespace around stripped comment lines", () => {
@@ -498,8 +549,14 @@ describe("buildSystemPrompt", () => {
 
   test("file with only comment lines is treated as empty", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "_ All comments\n_ Nothing else");
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("");
+    // Comment-only SOUL.md gets stripped down to "" by
+    // `stripCommentLines` and is then gated off by the renderer's
+    // empty-body check; only IDENTITY contributes content here.
+    expect(result).toContain("# Identity\n\nI am Vellum.");
+    expect(result).not.toContain("_ All comments");
+    expect(result).not.toContain("_ Nothing else");
   });
 
   describe("workspace system prompt sections", () => {
@@ -532,11 +589,7 @@ describe("buildSystemPrompt", () => {
       );
       const result = buildSystemPrompt();
       expect(result.startsWith("You are operating in demo mode.")).toBe(true);
-      // Prefix lives in the static (cached) block.
-      const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-      expect(boundaryIdx).toBeGreaterThan(-1);
-      const staticBlock = result.slice(0, boundaryIdx);
-      expect(staticBlock).toContain("You are operating in demo mode.");
+      expect(result).toContain("You are operating in demo mode.");
     });
 
     test("workspace file without frontmatter is rendered as-is (always-on)", () => {
@@ -610,7 +663,12 @@ describe("buildSystemPrompt", () => {
       writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
       const result = buildSystemPrompt();
       expect(result.startsWith("Custom prefix")).toBe(true);
-      expect(basePrompt(result)).toBe("I am Vellum.");
+      // IDENTITY.md renders via 08-identity in the static prefix after
+      // the 00-prefix slot.
+      const prefixIdx = result.indexOf("Custom prefix");
+      const identityIdx = result.indexOf("I am Vellum.");
+      expect(prefixIdx).toBeGreaterThan(-1);
+      expect(identityIdx).toBeGreaterThan(prefixIdx);
     });
 
     test("parallel tool calls section is sourced from workspace when present", () => {
@@ -786,11 +844,7 @@ describe("buildSystemPrompt", () => {
         expect(result).toContain(
           "Run `assistant --help` to discover commands.",
         );
-        // Section lives in the static (cached) block.
-        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        expect(boundaryIdx).toBeGreaterThan(-1);
-        const staticBlock = result.slice(0, boundaryIdx);
-        expect(staticBlock).toContain("## Assistant CLI");
+        expect(result).toContain("## Assistant CLI");
       });
 
       test("bundled cli-reference default renders when no workspace override", () => {
@@ -831,11 +885,7 @@ describe("buildSystemPrompt", () => {
         // The no-client body (em-dash separator after sandbox `bash`) must
         // not leak when the with-client variant is active.
         expect(result).not.toContain("install tools yourself; (2) browser");
-        // Section lives in the static (cached) block.
-        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        expect(boundaryIdx).toBeGreaterThan(-1);
-        const staticBlock = result.slice(0, boundaryIdx);
-        expect(staticBlock).toContain("## External Service Access");
+        expect(result).toContain("## External Service Access");
       });
 
       test("hasNoClient=true renders the two-tier (no host_bash) priority list", () => {
@@ -944,8 +994,7 @@ describe("buildSystemPrompt", () => {
 
       test("paired {{#flag}} + {{^flag}} acts as if/else", () => {
         // Use long unique markers — single letters collide with substrings
-        // in the rest of the system prompt (e.g. "B" lives inside
-        // SYSTEM_PROMPT_CACHE_BOUNDARY, "A" inside "API keys").
+        // in the rest of the system prompt (e.g. "A" inside "API keys").
         mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
         writeFileSync(
           SECTION_FILE,
@@ -1010,11 +1059,7 @@ describe("buildSystemPrompt", () => {
         const result = buildSystemPrompt();
         expect(result).toContain("## Sending Files to the User");
         expect(result).toContain("Use the `<vellum-attachment />` tag.");
-        // Section lives in the static (cached) block.
-        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        expect(boundaryIdx).toBeGreaterThan(-1);
-        const staticBlock = result.slice(0, boundaryIdx);
-        expect(staticBlock).toContain("## Sending Files to the User");
+        expect(result).toContain("## Sending Files to the User");
       });
 
       test("renders after the cli-reference section to preserve original order", () => {
@@ -1060,11 +1105,7 @@ describe("buildSystemPrompt", () => {
         const result = buildSystemPrompt();
         expect(result).toContain("## Credential Security");
         expect(result).toContain("Workspace override marker BRAVO_TANGO_7.");
-        // Section lives in the static (cached) block.
-        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        expect(boundaryIdx).toBeGreaterThan(-1);
-        const staticBlock = result.slice(0, boundaryIdx);
-        expect(staticBlock).toContain("## Credential Security");
+        expect(result).toContain("## Credential Security");
       });
 
       test("bundled credential-security default renders when no workspace override", () => {
@@ -1104,11 +1145,7 @@ describe("buildSystemPrompt", () => {
         const result = buildSystemPrompt();
         expect(result).toContain("## External Content");
         expect(result).toContain("Workspace override marker NEBULA_9X.");
-        // Section lives in the static (cached) block.
-        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        expect(boundaryIdx).toBeGreaterThan(-1);
-        const staticBlock = result.slice(0, boundaryIdx);
-        expect(staticBlock).toContain("## External Content");
+        expect(result).toContain("## External Content");
       });
 
       test("bundled external-content default renders when no workspace override", () => {

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

@@ -67,6 +67,7 @@ mock.module("../tools/network/script-proxy/index.js", () => ({
 import {
   ALWAYS_INJECTED_ENV_VARS,
   buildSanitizedEnv,
+  KATA_INJECTED_ENV_VARS,
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
@@ -145,7 +146,7 @@ describe("buildSanitizedEnv", () => {
     process.env.VELLUM_SANDBOX_RUNTIME = "gvisor";
     process.env.PATH = "/usr/bin";
     process.env.VELLUM_APT_DATA_ROOT = "/data/system";
-    process.env.LD_LIBRARY_PATH = "/data/system/usr/lib";
+    process.env.LD_LIBRARY_PATH = "/host/lib";
 
     let env = buildSanitizedEnv();
     expect(env.VELLUM_APT_DATA_ROOT).toBeUndefined();
@@ -161,6 +162,7 @@ describe("buildSanitizedEnv", () => {
     expect(env.LD_LIBRARY_PATH.split(":")).toContain(
       "/data/system/usr/local/lib",
     );
+    expect(env.LD_LIBRARY_PATH.split(":")).not.toContain("/host/lib");
   });
 
   test("defaults LANG and LC_ALL to UTF-8 when unset", () => {
@@ -181,12 +183,20 @@ describe("buildSanitizedEnv", () => {
     delete process.env.GATEWAY_PORT;
   });
 
+  test("Kata entrypoint initializes apt root without inheriting apt loader paths", () => {
+    const entrypoint = readFileSync("docker-entrypoint.sh", "utf8");
+
+    expect(entrypoint).toContain("/app/assistant/docker-init-apt-root.sh");
+    expect(entrypoint).not.toContain(". /app/assistant/docker-kata-apt-env.sh");
+  });
+
   test("result is a plain object with no prototype-inherited secrets", () => {
     const env = buildSanitizedEnv();
     const keys = Object.keys(env);
     const safeKeys: string[] = [
       ...SAFE_ENV_VARS,
       ...KATA_SAFE_ENV_VARS,
+      ...KATA_INJECTED_ENV_VARS,
       ...ALWAYS_INJECTED_ENV_VARS,
     ];
     for (const key of keys) {
@@ -278,7 +288,7 @@ describe("Shell tool input validation", () => {
   });
 
   test("tool definition includes required schema fields", () => {
-    const def = shellTool.getDefinition();
+    const def = shellTool;
     const schema = def.input_schema as {
       required: string[];
       properties: Record<string, unknown>;

package/src/__tests__/thinking-block-replay.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Reproduction & regression tests for the thinking-block provider-switch bug.
+ *
+ * Phase 1 (real API): proves that replaying a thinking block with a tampered
+ *   signature causes Anthropic to reject the request with a 400.
+ * Phase 2 (mocked): verifies the send-time filtering fix strips historical
+ *   thinking blocks while preserving active tool-use continuation blocks.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import Anthropic from "@anthropic-ai/sdk";
+
+// ---------------------------------------------------------------------------
+// Phase 1 — Real API reproduction
+// ---------------------------------------------------------------------------
+
+const apiKey = process.env.ANTHROPIC_API_KEY;
+
+describe.skipIf(!apiKey)(
+  "Thinking block replay — real API reproduction",
+  () => {
+    test("Anthropic rejects a tampered thinking signature with 400", async () => {
+      const client = new Anthropic({ apiKey });
+
+      // Step 1: Get a real thinking block from the API
+      const initialResponse = await client.messages.create({
+        model: "claude-sonnet-4-6",
+        max_tokens: 4096,
+        thinking: { type: "enabled", budget_tokens: 1024 },
+        messages: [{ role: "user", content: "What is 2 + 2?" }],
+      });
+
+      const thinkingBlock = initialResponse.content.find(
+        (b) => b.type === "thinking",
+      ) as Anthropic.ThinkingBlock | undefined;
+
+      expect(thinkingBlock).toBeDefined();
+      expect(thinkingBlock!.signature).toBeTruthy();
+
+      // Step 2: Tamper with the signature to simulate a stale/cross-provider block
+      const tamperedSignature =
+        thinkingBlock!.signature.slice(0, -4) + "XXXX";
+
+      // Step 3: Replay the tampered block as historical context
+      const historicalAssistantContent: Anthropic.ContentBlockParam[] = [
+        {
+          type: "thinking",
+          thinking: thinkingBlock!.thinking,
+          signature: tamperedSignature,
+        },
+        { type: "text", text: "4" },
+      ];
+
+      // Step 4: Confirm Anthropic rejects with 400
+      try {
+        await client.messages.create({
+          model: "claude-sonnet-4-6",
+          max_tokens: 4096,
+          thinking: { type: "enabled", budget_tokens: 1024 },
+          messages: [
+            { role: "user", content: "What is 2 + 2?" },
+            { role: "assistant", content: historicalAssistantContent },
+            { role: "user", content: "And what is 3 + 3?" },
+          ],
+        });
+        expect.unreachable("API should have rejected the tampered signature");
+      } catch (err: unknown) {
+        const apiErr = err as { status?: number; message?: string };
+        expect(apiErr.status).toBe(400);
+        expect(apiErr.message).toContain("signature");
+      }
+    }, 30_000);
+
+    test("Anthropic accepts the request when thinking blocks are stripped from historical turns", async () => {
+      const client = new Anthropic({ apiKey });
+
+      // Step 1: Get a real thinking block
+      const initialResponse = await client.messages.create({
+        model: "claude-sonnet-4-6",
+        max_tokens: 4096,
+        thinking: { type: "enabled", budget_tokens: 1024 },
+        messages: [{ role: "user", content: "What is 2 + 2?" }],
+      });
+
+      const thinkingBlock = initialResponse.content.find(
+        (b) => b.type === "thinking",
+      ) as Anthropic.ThinkingBlock | undefined;
+
+      expect(thinkingBlock).toBeDefined();
+
+      // Step 2: Build history WITHOUT thinking blocks (the fix)
+      const cleanAssistantContent: Anthropic.ContentBlockParam[] = [
+        { type: "text", text: "4" },
+      ];
+
+      // Step 3: Confirm request succeeds
+      const followUp = await client.messages.create({
+        model: "claude-sonnet-4-6",
+        max_tokens: 4096,
+        thinking: { type: "enabled", budget_tokens: 1024 },
+        messages: [
+          { role: "user", content: "What is 2 + 2?" },
+          { role: "assistant", content: cleanAssistantContent },
+          { role: "user", content: "And what is 3 + 3?" },
+        ],
+      });
+
+      expect(followUp.content).toBeDefined();
+      expect(followUp.stop_reason).toBe("end_turn");
+    }, 30_000);
+  },
+);