@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/anthropic-provider.test.ts

@@ -102,12 +102,13 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
+import { cachedTextBlock } from "../plugins/defaults/memory-v3-shadow/provider-blocks.js";
+import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
-  AnthropicProvider,
   isPlaceholderSentinelText,
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
-} from "../providers/anthropic/client.js";
+} from "../providers/placeholder-sentinels.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -180,7 +181,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // System prompt cache control
   // -----------------------------------------------------------------------
   test("system prompt has cache_control ephemeral with 1h TTL", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -198,7 +201,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("sends disabled thinking config natively", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       config: { thinking: { type: "disabled" } },
     });
 
@@ -230,7 +233,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   test("renders the system prompt as a single 1h-cached block", async () => {
     const prompt = "You are a helpful assistant.";
 
-    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
+    await provider.sendMessage([userMsg("Hi")], { systemPrompt: prompt });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -251,7 +254,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       toolUseMsg("tu_1", "bash"),
       toolResultMsg("tu_1", "output"),
     ];
-    await provider.sendMessage(messages, sampleTools, prompt);
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: prompt,
+    });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -291,7 +297,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // Tool cache control
   // -----------------------------------------------------------------------
   test("only last tool definition includes cache_control", async () => {
-    await provider.sendMessage([userMsg("Hi")], sampleTools);
+    await provider.sendMessage([userMsg("Hi")], { tools: sampleTools });
 
     const tools = lastStreamParams!.tools as Array<{
       name: string;
@@ -308,7 +314,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("single tool gets cache_control", async () => {
-    await provider.sendMessage([userMsg("Hi")], [sampleTools[0]]);
+    await provider.sendMessage([userMsg("Hi")], { tools: [sampleTools[0]] });
 
     const tools = lastStreamParams!.tools as Array<{
       name: string;
@@ -318,6 +324,98 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(tools[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("preserves a caller's 1h block cache_control and sends the extended-cache beta (non-Haiku)", async () => {
+    // v3's `cachedTextBlock` stamps a stable prefix block with a 1h TTL; the
+    // non-Haiku path must forward it unchanged and send the beta header.
+    await provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          cachedTextBlock("stable pages block"),
+          { type: "text", text: "volatile current message" },
+        ],
+      },
+    ]);
+
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    expect(messages[0].content[0].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+    expect(lastStreamParams!.betas).toContain("extended-cache-ttl-2025-04-11");
+  });
+
+  test("strips ttl from a caller's block cache_control and omits the beta for Haiku", async () => {
+    // Haiku doesn't support the extended-cache-ttl beta, so a caller-stamped
+    // 1h ttl (e.g. from `cachedTextBlock`) must be stripped before sending.
+    const haiku = new AnthropicProvider(
+      "sk-ant-test",
+      "claude-haiku-4-5-20251001",
+    );
+    await haiku.sendMessage([
+      {
+        role: "user",
+        content: [
+          cachedTextBlock("stable pages block"),
+          { type: "text", text: "volatile current message" },
+        ],
+      },
+    ]);
+
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    expect(messages[0].content[0].cache_control).toEqual({ type: "ephemeral" });
+    expect(messages[0].content[0].cache_control).not.toHaveProperty("ttl");
+    expect(
+      (lastStreamParams!.betas as string[] | undefined) ?? [],
+    ).not.toContain("extended-cache-ttl-2025-04-11");
+  });
+
+  test("v3-shape call (system + tools + cached prefix block) stays within the 4-breakpoint cap", async () => {
+    // Mirrors a v3 L2 selector call: a system prompt, a forced tool, and a user
+    // message whose stable <pages> block carries a cache_control breakpoint
+    // followed by the volatile current-message block. The preserved prefix
+    // breakpoint plus the client's system/tools/turn-start anchors must total
+    // exactly Anthropic's max of 4.
+    await provider.sendMessage(
+      [
+        {
+          role: "user",
+          content: [
+            cachedTextBlock("stable pages block"),
+            { type: "text", text: "volatile current message" },
+          ],
+        },
+      ],
+      { systemPrompt: "Select relevant pages.", tools: [sampleTools[0]] },
+    );
+
+    let breakpoints = 0;
+    const system = lastStreamParams!.system as
+      | Array<{ cache_control?: unknown }>
+      | undefined;
+    for (const b of system ?? []) if (b.cache_control) breakpoints++;
+    const tools = lastStreamParams!.tools as
+      | Array<{ cache_control?: unknown }>
+      | undefined;
+    for (const t of tools ?? []) if (t.cache_control) breakpoints++;
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    for (const m of messages)
+      for (const b of m.content) if (b.cache_control) breakpoints++;
+
+    expect(breakpoints).toBe(4);
+    // The stable pages block specifically must hold the preserved breakpoint.
+    expect(messages[0].content[0].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+  });
+
   test("no tools param when tools are omitted", async () => {
     await provider.sendMessage([userMsg("Hi")]);
 
@@ -409,14 +507,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // per call with content that changes every time. Caching the turn-start
     // block would create unused entries — `disableTurnStartCache: true`
     // opts out.
-    await provider.sendMessage(
-      [userMsg("Pick relevant pages")],
-      undefined,
-      undefined,
-      {
-        config: { disableTurnStartCache: true },
-      },
-    );
+    await provider.sendMessage([userMsg("Pick relevant pages")], {
+      config: { disableTurnStartCache: true },
+    });
 
     const sent = lastStreamParams!.messages as Array<{
       role: string;
@@ -458,6 +551,128 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }
   });
 
+  // -----------------------------------------------------------------------
+  // mutableLatestUserMessage — volatile trailing user message cache anchor
+  // -----------------------------------------------------------------------
+  test("mutableLatestUserMessage: first-of-turn skips the volatile turn-start anchor and anchors the previous stable user message", async () => {
+    // The latest user message carries per-turn-volatile content (e.g. an
+    // injected memory block). The long-TTL anchor must move off it onto the
+    // most recent stable user message so the cached prefix stays reusable.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2 (volatile)"),
+    ];
+    await provider.sendMessage(messages, {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        text: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const userMessages = sent.filter((m) => m.role === "user");
+
+    // Latest (turn-start) user message gets NO long-TTL breakpoint — it's volatile.
+    const latest = userMessages[userMessages.length - 1];
+    for (const block of latest.content) {
+      expect(block.cache_control).toBeUndefined();
+    }
+
+    // Previous stable user message (Turn 1) becomes the primary anchor.
+    const prev = userMessages[userMessages.length - 2];
+    const prevLast = prev.content[prev.content.length - 1];
+    expect(prevLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage absent: breakpoint placement is byte-identical to default behavior (v2 regression guard)", async () => {
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const userMessages = sent.filter((m) => m.role === "user");
+
+    // Current-turn (latest) anchor keeps 1h.
+    const latest = userMessages[userMessages.length - 1];
+    const latestLast = latest.content[latest.content.length - 1];
+    expect(latestLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    // Previous-turn anchor keeps 1h.
+    const prev = userMessages[userMessages.length - 2];
+    const prevLast = prev.content[prev.content.length - 1];
+    expect(prevLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage: during a tool-use loop placement is unchanged (block is fixed within the turn)", async () => {
+    // Turn-start is not the last message (tool_result follows), so the
+    // turn-start block is fixed for the rest of the turn — the flag must not
+    // move the anchor.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages, {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+
+    // Turn-start (Turn 2, index 2) still gets the 1h anchor — within a tool-use
+    // loop the block is fixed, so the volatile-latest flag must not move it.
+    const turn2 = sent[2];
+    const turn2Last = turn2.content[turn2.content.length - 1];
+    expect(turn2Last.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage: first turn with no previous user message does not throw and applies no long-TTL anchor", async () => {
+    await provider.sendMessage([userMsg("First ever turn (volatile)")], {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    // Only user message is volatile and there is no prior stable one, so no
+    // long-TTL breakpoint lands on any user message — graceful, no throw.
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toBeUndefined();
+  });
+
+  test("mutableLatestUserMessage is not forwarded to the Anthropic API", async () => {
+    await provider.sendMessage([userMsg("Hi")], {
+      config: { mutableLatestUserMessage: true },
+    });
+    expect(
+      (lastStreamParams as Record<string, unknown>).mutableLatestUserMessage,
+    ).toBeUndefined();
+  });
+
   // -----------------------------------------------------------------------
   // Negative: assistant messages never get cache_control
   // -----------------------------------------------------------------------
@@ -1537,7 +1752,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1554,7 +1769,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1569,7 +1784,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1586,7 +1801,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1605,7 +1820,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1622,7 +1837,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1640,7 +1855,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -2120,11 +2335,10 @@ describe("AnthropicProvider — Managed Proxy Fallback", () => {
       baseURL: "https://platform.example.com/v1/runtime-proxy/anthropic",
     });
 
-    await provider.sendMessage(
-      [userMsg("Hi")],
-      sampleTools,
-      "You are helpful.",
-    );
+    await provider.sendMessage([userMsg("Hi")], {
+      tools: sampleTools,
+      systemPrompt: "You are helpful.",
+    });
 
     // System prompt cache control
     const system = lastStreamParams!.system as Array<{
@@ -2224,13 +2438,16 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("max_tokens defaults to 8192 for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     expect(lastStreamParams!.max_tokens).toBe(8192);
   });
 
   test("caller max_tokens is clamped to 8192 for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { max_tokens: 64000 },
     });
 
@@ -2238,7 +2455,8 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("caller max_tokens below 8192 is preserved for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { max_tokens: 128 },
     });
 
@@ -2250,18 +2468,18 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
       "sk-ant-test",
       "claude-sonnet-4-6",
     );
-    await sonnetProvider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      "You are helpful.",
-      { config: { max_tokens: 200 } },
-    );
+    await sonnetProvider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { max_tokens: 200 },
+    });
 
     expect(lastStreamParams!.max_tokens).toBe(200);
   });
 
   test("cache_control omits ttl for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     const system = lastStreamParams!.system as Array<{
       cache_control?: { type: string; ttl?: string };
@@ -2271,7 +2489,9 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("betas array is empty for Haiku (no extended cache TTL)", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     // When betas is empty, the non-beta stream path is used, so no betas
     // field should appear in lastStreamParams.
@@ -2279,7 +2499,8 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("effort is stripped for Haiku even when provided in config", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { effort: "high" },
     });
 
@@ -2291,12 +2512,10 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
       "sk-ant-test",
       "claude-sonnet-4-6",
     );
-    await sonnetProvider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      "You are helpful.",
-      { config: { effort: "none" } },
-    );
+    await sonnetProvider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { effort: "none" },
+    });
 
     // mergedOutputConfig is empty when effort is "none" and no other
     // output_config fields were supplied, so output_config is not attached
@@ -2323,7 +2542,9 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     expect(lastConstructorArgs).toMatchObject({
       apiKey: null,
@@ -2358,7 +2579,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "adaptive" } },
     });
 
@@ -2375,7 +2596,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "disabled" } },
     });
 
@@ -2390,7 +2611,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: {
         usageAttributionHeaders: {
           "Vellum-Organization-Id": "org-123",
@@ -2418,7 +2639,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
     // Default model is non-Anthropic, but the request overrides with an
     // Anthropic model — dispatch must honour the request-level model.
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { model: "anthropic/claude-haiku-4.5" },
     });
 
@@ -2488,7 +2709,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("And what is 3+3?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2514,7 +2738,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("And what is 3+3?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2540,7 +2767,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-1", "file contents here"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2573,7 +2803,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-2", "file contents"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2610,7 +2843,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("What did you conclude?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2648,7 +2884,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-b", "result b"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];

package/src/__tests__/app-builder-skill-instructions.test.ts

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises";
+import { describe, expect, test } from "bun:test";
+
+describe("app-builder skill instructions", () => {
+  test("uses non-CLI UI confirmation for optional profile switch", async () => {
+    const skillText = await readFile(
+      new URL("../config/bundled-skills/app-builder/SKILL.md", import.meta.url),
+      "utf8",
+    );
+    const preflightStart = skillText.indexOf("### 0. Preflight");
+    const preflightEnd = skillText.indexOf("### 1. Gather Requirements");
+    const preflight = skillText.slice(preflightStart, preflightEnd);
+
+    expect(preflight).not.toContain("assistant ui confirm --message");
+    expect(preflight).toContain("Use the `ui_show` tool");
+    expect(preflight).toContain('surface_type: "confirmation"');
+    expect(preflight).toContain("await_action: true");
+    expect(preflight).toContain(
+      "Do not call the shell command `assistant ui confirm`",
+    );
+  });
+});

package/src/__tests__/app-control-flow.test.ts

@@ -103,7 +103,7 @@ const { ROUTES } = await import("../runtime/routes/host-app-control-routes.js");
 const { surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
 const { setConversation, clearConversations } =
-  await import("../daemon/conversation-store.js");
+  await import("../daemon/conversation-registry.js");
 type SurfaceConversationContext =
   import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
@@ -131,6 +131,11 @@ function buildContext(
 ): SurfaceConversationContext {
   return {
     conversationId,
+    trustContext: {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+      guardianPrincipalId: "user-1",
+    },
     traceEmitter: { emit: () => {} },
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),

package/src/__tests__/app-dir-path-guard.test.ts

@@ -19,6 +19,7 @@ const ALLOWLIST = new Set([
   "assistant/src/memory/app-store.ts", // defines getAppsDir
   "assistant/src/memory/app-git-service.ts", // uses getAppsDir for git repo root, not per-app paths
   "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
+  "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
 ]);
 
 function isTestFile(filePath: string): boolean {