@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -6,9 +6,11 @@
  *
  * - Registering a plugin with `tools: Tool[]`, running `bootstrapPlugins`,
  *   and observing the contributed tool via `getAllTools()` / `getTool()`.
- * - Tool ownership metadata (`origin: "plugin"`, `ownerPluginId: <plugin>`)
- *   stamped authoritatively by `registerPluginTools` regardless of what the
- *   plugin author set on the incoming object.
+ * - Tool ownership (`owner: { kind: "plugin", id: <plugin> }`) recorded
+ *   authoritatively by `registerPluginTools` into the registry's
+ *   `ownersByName` map (queried via `getToolOwner(name)`), regardless of
+ *   what the plugin author set on the incoming object. The `Tool` itself
+ *   carries no ownership field — the bootstrap is the only writer.
  * - Shutdown hook unregistering the contributed tools so the registry is
  *   clean again after teardown.
  * - Direct `registerPluginTools` / `unregisterPluginTools` semantics,
@@ -55,11 +57,12 @@ import {
   getAllTools,
   getPluginRefCount,
   getTool,
+  getToolOwner,
   registerPluginTools,
   unregisterPluginTools,
 } from "../tools/registry.js";
 import type {
-  LoadedPluginTool,
+  LoadedTool,
   ToolContext,
   ToolExecutionResult,
 } from "../tools/types.js";
@@ -81,12 +84,13 @@ const fakeCtx: DaemonContext = {
 
 function makeFakeTool(
   name: string,
-  extras: Partial<LoadedPluginTool> = {},
-): LoadedPluginTool {
+  extras: Partial<LoadedTool> = {},
+): LoadedTool {
   return {
     name,
     description: `Fake ${name}`,
     defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "sandbox",
     input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,
@@ -163,13 +167,17 @@ describe("plugin tool contributions", () => {
 
     const retrieved = getTool("plugin-contrib-tool");
     expect(retrieved).toBeDefined();
-    // Ownership metadata must be stamped authoritatively by the bootstrap —
-    // the registry uses it to drive ref-counting and conflict detection when
-    // the plugin shuts down or is hot-reloaded. Plugin tools live in their
-    // own `origin: "plugin"` namespace, disjoint from real skills, so a
-    // plugin name that happens to match a skill id cannot collide.
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("alpha-contributor");
+    // Ownership is recorded authoritatively by the bootstrap into the
+    // registry's `ownersByName` map (keyed by tool name, accessed via
+    // `getToolOwner(name)`) — the registry uses it to drive ref-counting
+    // and conflict detection when the plugin shuts down or is hot-reloaded.
+    // Plugin tools live in their own namespace, disjoint from real skills,
+    // so a plugin name that happens to match a skill id cannot collide.
+    // Ownership is not stamped on the `Tool` object itself.
+    expect(getToolOwner("plugin-contrib-tool")).toEqual({
+      kind: "plugin",
+      id: "alpha-contributor",
+    });
 
     // The tool surfaces in the global `getAllTools()` snapshot, which is
     // what downstream consumers (tool-manifest, session projection) read.
@@ -247,22 +255,23 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     __resetRegistryForTesting();
   });
 
-  test("registerPluginTools stamps category, origin, and ownerPluginId from the plugin name", () => {
-    // Even if the plugin author hands in a tool with no category or ownership
-    // metadata, the helper fills it in so the tool can be registered and
-    // unregistered consistently.
+  test("registerPluginTools stamps category and records ownership in the registry", () => {
+    // Even if the plugin author hands in a tool with no category, the
+    // helper fills it in and records ownership in the registry's
+    // `ownersByName` map — the tool itself never carries an `owner` field,
+    // so plugin authors can't spoof ownership by forging one.
     const accepted = registerPluginTools("my-plugin", [
       makeFakeTool("pt_stamped"),
     ]);
     expect(accepted).toHaveLength(1);
     expect(accepted[0]?.category).toBe("plugin");
-    expect(accepted[0]?.origin).toBe("plugin");
-    expect(accepted[0]?.ownerPluginId).toBe("my-plugin");
+    expect(getToolOwner("pt_stamped")).toEqual({
+      kind: "plugin",
+      id: "my-plugin",
+    });
 
     const retrieved = getTool("pt_stamped");
     expect(retrieved?.category).toBe("plugin");
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("my-plugin");
   });
 
   test("registerPluginTools exposes provider-safe aliases for unsafe plugin tool names", async () => {
@@ -281,7 +290,7 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     expect(alias).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
     expect(alias.startsWith("Stripe_Link_CLI__")).toBe(true);
     expect(getTool(alias)).toBeDefined();
-    expect(accepted[0]!.getDefinition().name).toBe(alias);
+    expect(accepted[0]!.name).toBe(alias);
 
     await accepted[0]!.execute(
       {},
@@ -312,27 +321,28 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     expect(getTool(paddedAlias!)).toBeDefined();
   });
 
-  test("registerPluginTools overwrites any pre-existing ownership metadata", () => {
+  test("registerPluginTools ignores forged ownership fields on the incoming tool", () => {
     // A plugin author could (maliciously or mistakenly) hand in a tool
-    // pre-tagged with another skill's or plugin's ID. The helper must
-    // overwrite it so the bootstrap is always the source of truth for
-    // ownership — and it must clear cross-origin fields (ownerSkillId /
-    // ownerMcpServerId / ownerSkillBundled / ownerSkillVersionHash) so the
-    // stamped tool cannot leak across namespaces or spoof bundled-skill
-    // auto-allow.
-    const spoofed = makeFakeTool("pt_spoof", {
+    // pre-tagged with another skill's or plugin's ID. The `Tool` type now
+    // carries no ownership field at all, so any such forgery is purely
+    // inert extra data — the registry only populates `ownersByName` from
+    // the first argument to `register*Tools`, which is the single source
+    // of truth for ownership and cannot be spoofed by forging fields on
+    // the manifest.
+    //
+    // Cast through `unknown` to simulate a hostile or transpiled artifact
+    // arriving with extra fields baked in.
+    const spoofed = {
+      ...makeFakeTool("pt_spoof"),
       origin: "skill",
-      ownerSkillId: "some-other-skill",
-      ownerSkillBundled: true,
-      ownerSkillVersionHash: "deadbeef",
-    });
+      owner: { kind: "skill", id: "some-other-skill" },
+    } as unknown as LoadedTool;
     registerPluginTools("my-plugin", [spoofed]);
-    const retrieved = getTool("pt_spoof");
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("my-plugin");
-    expect(retrieved?.ownerSkillId).toBeUndefined();
-    expect(retrieved?.ownerSkillBundled).toBeUndefined();
-    expect(retrieved?.ownerSkillVersionHash).toBeUndefined();
+    expect(getTool("pt_spoof")).toBeDefined();
+    expect(getToolOwner("pt_spoof")).toEqual({
+      kind: "plugin",
+      id: "my-plugin",
+    });
   });
 
   test("unregisterPluginTools removes the plugin's tools", () => {

package/src/__tests__/plugin-types.test.ts

@@ -46,7 +46,7 @@ import {
   type ToolResultTruncateResult,
   type TurnContext,
 } from "../plugins/types.js";
-import type { LoadedPluginTool } from "../tools/types.js";
+import type { LoadedTool } from "../tools/types.js";
 
 const sampleTrust: TrustContext = {
   sourceChannel: "vellum",
@@ -207,10 +207,11 @@ describe("plugin core types", () => {
       },
     };
 
-    const sampleTool: LoadedPluginTool = {
+    const sampleTool: LoadedTool = {
       name: "sample-tool",
       description: "Sample plugin tool",
       defaultRiskLevel: RiskLevel.Low,
+      executionTarget: "sandbox",
       input_schema: { type: "object", properties: {}, required: [] },
       async execute() {
         return { content: "ok", isError: false };

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -61,22 +61,43 @@ mock.module("../prompts/user-reference.js", () => ({
   resolveUserPronouns: () => null,
 }));
 
-const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
-  await import("../prompts/system-prompt.js");
+// Stub persona-resolver so tests can dictate the slug `buildSystemPrompt`
+// sees without writing contact rows to the test DB. User and channel
+// persona content now flows through bundled sections that read files
+// directly, so tests write the persona file under TEST_DIR rather than
+// stubbing the content here.
+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,
+}));
+
+const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
 
 /**
- * Extract the dynamic block (workspace-file content) from the full system prompt.
+ * Slice the assembled system prompt from the `# First-Run Ritual`
+ * marker through the end of the prompt, returning just the
+ * `13-bootstrap` section's rendered payload.  Returns "" when the
+ * section isn't rendered (no BOOTSTRAP.md, `excludeBootstrap: true`,
+ * etc.).
  */
-function dynamicBlock(result: string): string {
-  const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-  return boundaryIdx >= 0
-    ? result.slice(boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length)
-    : result;
+function bootstrapBlock(result: string): string {
+  const ritualIdx = result.indexOf("# First-Run Ritual");
+  if (ritualIdx < 0) return "";
+  return result.slice(ritualIdx);
 }
 
 describe("pre-chat onboarding contract", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
+    mockPersona.userSlug = null;
+    mockPersona.guardianPersona = null;
   });
 
   afterEach(() => {
@@ -87,6 +108,8 @@ describe("pre-chat onboarding contract", () => {
       "BOOTSTRAP.md",
       "BOOTSTRAP-REFERENCE.md",
       "UPDATES.md",
+      "users",
+      "channels",
     ]) {
       const p = join(TEST_DIR, name);
       if (existsSync(p)) rmSync(p, { recursive: true, force: true });
@@ -151,20 +174,20 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
-      expect(dynamic).toContain("## First-Run User Context");
-      expect(dynamic).toContain(
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).toContain(
         "The user completed setup before this conversation.",
       );
-      expect(dynamic).toContain("- Daily tools: Slack, Linear");
-      expect(dynamic).toContain("- Common work: builds code, apps, or tools");
-      expect(dynamic).toContain("- Name: Alex");
-      expect(dynamic).toContain("- Chosen assistant name: Nova");
-      expect(dynamic).toContain("Apply this context quietly.");
+      expect(bootstrap).toContain("- Daily tools: Slack, Linear");
+      expect(bootstrap).toContain("- Common work: builds code, apps, or tools");
+      expect(bootstrap).toContain("- Name: Alex");
+      expect(bootstrap).toContain("- Chosen assistant name: Nova");
+      expect(bootstrap).toContain("Apply this context quietly.");
 
       // Raw JSON must NOT be present
-      expect(dynamic).not.toContain("```json");
+      expect(bootstrap).not.toContain("```json");
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {
@@ -177,11 +200,11 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
-      expect(dynamic).not.toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("First-Run User Context");
-      expect(dynamic).not.toContain("- Daily tools:");
+      expect(bootstrap).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("First-Run User Context");
+      expect(bootstrap).not.toContain("- Daily tools:");
     });
 
     test("does NOT inject onboarding context when excludeBootstrap is true", () => {
@@ -200,10 +223,10 @@ describe("pre-chat onboarding contract", () => {
         onboardingContext: context,
         excludeBootstrap: true,
       });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
-      expect(dynamic).not.toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(bootstrap).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("First-Run Ritual");
     });
 
     test("omits onboarding section when context is undefined", () => {
@@ -213,12 +236,12 @@ describe("pre-chat onboarding contract", () => {
       );
 
       const result = buildSystemPrompt({ onboardingContext: undefined });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
       // Bootstrap should still be present
-      expect(dynamic).toContain("First-Run Ritual");
+      expect(bootstrap).toContain("First-Run Ritual");
       // But no onboarding context section
-      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("## First-Run User Context");
     });
 
     test("accepts all four personality tones", () => {
@@ -238,10 +261,10 @@ describe("pre-chat onboarding contract", () => {
         };
 
         const result = buildSystemPrompt({ onboardingContext: context });
-        const dynamic = dynamicBlock(result);
+        const bootstrap = bootstrapBlock(result);
 
-        expect(dynamic).toContain("## First-Run User Context");
-        expect(dynamic).toContain(`- Preferred initial voice: ${tone}`);
+        expect(bootstrap).toContain("## First-Run User Context");
+        expect(bootstrap).toContain(`- Preferred initial voice: ${tone}`);
       }
     });
 
@@ -260,20 +283,20 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
       // Should contain compact markdown lines
-      expect(dynamic).toContain("## First-Run User Context");
-      expect(dynamic).toContain("- Name: Jane");
-      expect(dynamic).toContain("- Common work: plans and coordinates work");
-      expect(dynamic).toContain("- Daily tools: Notion");
-      expect(dynamic).toContain("- Chosen assistant name: Kit");
-      expect(dynamic).toContain("- Preferred initial voice: warm");
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).toContain("- Name: Jane");
+      expect(bootstrap).toContain("- Common work: plans and coordinates work");
+      expect(bootstrap).toContain("- Daily tools: Notion");
+      expect(bootstrap).toContain("- Chosen assistant name: Kit");
+      expect(bootstrap).toContain("- Preferred initial voice: warm");
 
       // Must NOT contain JSON output
-      expect(dynamic).not.toContain("```json");
+      expect(bootstrap).not.toContain("```json");
       const expectedJson = JSON.stringify(context, null, 2);
-      expect(dynamic).not.toContain(expectedJson);
+      expect(bootstrap).not.toContain(expectedJson);
     });
 
     test("empty tools/tasks arrays result in no Daily tools / Common work lines", () => {
@@ -290,12 +313,12 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
-      expect(dynamic).toContain("## First-Run User Context");
-      expect(dynamic).toContain("- Name: Alex");
-      expect(dynamic).not.toContain("- Daily tools:");
-      expect(dynamic).not.toContain("- Common work:");
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).toContain("- Name: Alex");
+      expect(bootstrap).not.toContain("- Daily tools:");
+      expect(bootstrap).not.toContain("- Common work:");
     });
 
     test("absent userName results in no Name line", () => {
@@ -311,16 +334,16 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
-      expect(dynamic).toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("- Name:");
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("- Name:");
       // Other fields should still be present
-      expect(dynamic).toContain("- Daily tools: Slack");
-      expect(dynamic).toContain(
+      expect(bootstrap).toContain("- Daily tools: Slack");
+      expect(bootstrap).toContain(
         "- Common work: writes docs, emails, or content",
       );
-      expect(dynamic).toContain("- Preferred initial voice: warm");
+      expect(bootstrap).toContain("- Preferred initial voice: warm");
     });
   });
 
@@ -356,26 +379,26 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
       // Heading is present
-      expect(dynamic).toContain("## First-Run User Context");
+      expect(bootstrap).toContain("## First-Run User Context");
 
       // Normalized labels appear (capitalised tool names, human-readable task descriptions)
-      expect(dynamic).toContain("- Daily tools: Slack, Notion, Linear");
-      expect(dynamic).toContain("- Name: Alice");
-      expect(dynamic).toContain("- Chosen assistant name: Pax");
-      expect(dynamic).toContain("- Preferred initial voice: grounded");
+      expect(bootstrap).toContain("- Daily tools: Slack, Notion, Linear");
+      expect(bootstrap).toContain("- Name: Alice");
+      expect(bootstrap).toContain("- Chosen assistant name: Pax");
+      expect(bootstrap).toContain("- Preferred initial voice: grounded");
       // Common work descriptions are normalised from task IDs
-      expect(dynamic).toContain("- Common work:");
-
-      // No raw JSON anywhere in the dynamic block
-      expect(dynamic).not.toContain("```json");
-      expect(dynamic).not.toContain('"tools"');
-      expect(dynamic).not.toContain('"tasks"');
-      expect(dynamic).not.toContain('"tone"');
-      expect(dynamic).not.toContain('"userName"');
-      expect(dynamic).not.toContain('"assistantName"');
+      expect(bootstrap).toContain("- Common work:");
+
+      // No raw JSON anywhere in the bootstrap block
+      expect(bootstrap).not.toContain("```json");
+      expect(bootstrap).not.toContain('"tools"');
+      expect(bootstrap).not.toContain('"tasks"');
+      expect(bootstrap).not.toContain('"tone"');
+      expect(bootstrap).not.toContain('"userName"');
+      expect(bootstrap).not.toContain('"assistantName"');
     });
 
     test("without BOOTSTRAP.md, onboarding context does NOT appear in system prompt", () => {
@@ -389,15 +412,15 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({ onboardingContext: context });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
       // Onboarding section must be absent
-      expect(dynamic).not.toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("First-Run Ritual");
-      expect(dynamic).not.toContain("- Daily tools:");
-      expect(dynamic).not.toContain("- Name: Bob");
-      expect(dynamic).not.toContain("- Chosen assistant name:");
-      expect(dynamic).not.toContain("Apply this context quietly.");
+      expect(bootstrap).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("First-Run Ritual");
+      expect(bootstrap).not.toContain("- Daily tools:");
+      expect(bootstrap).not.toContain("- Name: Bob");
+      expect(bootstrap).not.toContain("- Chosen assistant name:");
+      expect(bootstrap).not.toContain("Apply this context quietly.");
     });
 
     test("excludeBootstrap suppresses both bootstrap and onboarding sections", () => {
@@ -418,34 +441,38 @@ describe("pre-chat onboarding contract", () => {
         onboardingContext: context,
         excludeBootstrap: true,
       });
-      const dynamic = dynamicBlock(result);
+      const bootstrap = bootstrapBlock(result);
 
       // Both bootstrap and onboarding must be suppressed
-      expect(dynamic).not.toContain("First-Run Ritual");
-      expect(dynamic).not.toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("- Daily tools:");
-      expect(dynamic).not.toContain("- Name: Charlie");
-      expect(dynamic).not.toContain("Apply this context quietly.");
+      expect(bootstrap).not.toContain("First-Run Ritual");
+      expect(bootstrap).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("- Daily tools:");
+      expect(bootstrap).not.toContain("- Name: Charlie");
+      expect(bootstrap).not.toContain("Apply this context quietly.");
     });
 
     test("userPersona is included independently of onboarding context", () => {
-      // No BOOTSTRAP.md — the durable persona path after bootstrap is deleted
-      const personaContent =
-        "# User Persona\n\nPrefers concise answers. Works in fintech.";
+      // No BOOTSTRAP.md — the durable persona path after bootstrap is deleted.
+      // User persona content now lives in `users/<slug>.md` and renders
+      // via the `10-user-persona` bundled section in the static prefix.
+      mkdirSync(join(TEST_DIR, "users"), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, "users", "default.md"),
+        "# User Persona\n\nPrefers concise answers. Works in fintech.",
+      );
 
       const result = buildSystemPrompt({
-        userPersona: personaContent,
         // No onboardingContext — simulates post-onboarding conversation
       });
-      const dynamic = dynamicBlock(result);
 
       // Persona content appears in prompt even without bootstrap or onboarding
-      expect(dynamic).toContain("# User Persona");
-      expect(dynamic).toContain("Prefers concise answers. Works in fintech.");
+      expect(result).toContain("# User Persona");
+      expect(result).toContain("Prefers concise answers. Works in fintech.");
 
       // No onboarding section should be present
-      expect(dynamic).not.toContain("## First-Run User Context");
-      expect(dynamic).not.toContain("First-Run Ritual");
+      const bootstrap = bootstrapBlock(result);
+      expect(bootstrap).not.toContain("## First-Run User Context");
+      expect(bootstrap).not.toContain("First-Run Ritual");
     });
 
     test("userPersona appears alongside onboarding context during first run", () => {
@@ -454,8 +481,14 @@ describe("pre-chat onboarding contract", () => {
         "# Bootstrap\n\nOnboarding flow.",
       );
 
-      const personaContent =
-        "# User Persona\n\nEarly-stage startup founder. Likes bullet points.";
+      // User persona file renders via the `10-user-persona` section
+      // and the First-Run Ritual + onboarding context render via the
+      // `13-bootstrap` section — both in the static prefix.
+      mkdirSync(join(TEST_DIR, "users"), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, "users", "default.md"),
+        "# User Persona\n\nEarly-stage startup founder. Likes bullet points.",
+      );
       const context: OnboardingContext = {
         tools: ["slack"],
         tasks: ["writing"],
@@ -464,17 +497,17 @@ describe("pre-chat onboarding contract", () => {
       };
 
       const result = buildSystemPrompt({
-        userPersona: personaContent,
         onboardingContext: context,
       });
-      const dynamic = dynamicBlock(result);
-
-      // Both persona and onboarding context appear
-      expect(dynamic).toContain("# User Persona");
-      expect(dynamic).toContain("Likes bullet points.");
-      expect(dynamic).toContain("## First-Run User Context");
-      expect(dynamic).toContain("- Name: Dana");
-      expect(dynamic).toContain("- Daily tools: Slack");
+      const bootstrap = bootstrapBlock(result);
+
+      // Both persona and onboarding context appear in the static prefix
+      // (`10-user-persona` and `13-bootstrap` respectively)
+      expect(result).toContain("# User Persona");
+      expect(result).toContain("Likes bullet points.");
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).toContain("- Name: Dana");
+      expect(bootstrap).toContain("- Daily tools: Slack");
     });
   });
 });

package/src/__tests__/pricing.test.ts

@@ -216,6 +216,17 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBe(0.25 + 1.5);
     });
 
+    test("returns priced for gemini-3.1-flash-lite", () => {
+      const result = resolvePricing(
+        "gemini",
+        "gemini-3.1-flash-lite",
+        1_000_000,
+        1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(0.25 + 1.5);
+    });
+
     test("prices gemini-2.5-pro at the low-context tier through 200k input tokens", () => {
       const result = resolvePricing(
         "gemini",
@@ -489,6 +500,7 @@ describe("resolvePricingForUsage", () => {
     const cases = [
       ["gemini-3-flash-preview", 0.05],
       ["gemini-3.1-flash-lite-preview", 0.025],
+      ["gemini-3.1-flash-lite", 0.025],
       ["gemini-2.5-flash", 0.03],
       ["gemini-2.5-flash-lite", 0.01],
       ["gemini-2.5-pro", 0.625],