@vellumai/assistant 0.8.11 → 0.8.12-staging.1

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

@@ -1364,6 +1364,40 @@ describe("custom baseURL initialization", () => {
       timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
+
+  test("MinimaxProvider sends reasoning_split so reasoning never leaks into content as <think> tags", async () => {
+    fakeChunks = [textChunk("hello", "stop"), usageChunk(10, 5)];
+    const provider = new MinimaxProvider("mm-user-key", "MiniMax-M3");
+
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(lastCreateParams!.reasoning_split).toBe(true);
+  });
+
+  test("MinimaxProvider replays prior assistant thinking via reasoning_content", async () => {
+    fakeChunks = [textChunk("done", "stop"), usageChunk(10, 5)];
+    const provider = new MinimaxProvider("mm-user-key", "MiniMax-M3");
+
+    await provider.sendMessage([
+      userMsg("question"),
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "prior reasoning", signature: "" },
+          { type: "text", text: "prior answer" },
+        ],
+      },
+      userMsg("follow-up"),
+    ]);
+
+    const sent = lastCreateParams!.messages as Array<Record<string, unknown>>;
+    const assistantTurn = sent.find((m) => m.role === "assistant");
+    expect(assistantTurn).toEqual({
+      role: "assistant",
+      content: "prior answer",
+      reasoning_content: "prior reasoning",
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -107,7 +107,6 @@ describe("pre-chat onboarding contract", () => {
       "USER.md",
       "BOOTSTRAP.md",
       "BOOTSTRAP-REFERENCE.md",
-      "UPDATES.md",
       "users",
       "channels",
     ]) {

package/src/__tests__/recurrence-engine.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import {
   computeNextRunAt,
+  describeRRuleExpression,
+  isSingleFireRRule,
   isValidScheduleExpression,
 } from "../schedule/recurrence-engine.js";
 
@@ -117,3 +119,46 @@ describe("recurrence engine — rrule", () => {
     expect(next).toBe(jan2);
   });
 });
+
+describe("recurrence engine — rrule display helpers", () => {
+  const SINGLE_FIRE = "DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=1";
+  const WEEKLY = "DTSTART:20990612T080000\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE";
+
+  test("isSingleFireRRule detects COUNT=1 rules", () => {
+    expect(isSingleFireRRule(SINGLE_FIRE)).toBe(true);
+    expect(isSingleFireRRule(WEEKLY)).toBe(false);
+    expect(
+      isSingleFireRRule("DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=2"),
+    ).toBe(false);
+    expect(isSingleFireRRule("not an rrule")).toBe(false);
+  });
+
+  test("isSingleFireRRule is false for set constructs", () => {
+    expect(
+      isSingleFireRRule(
+        "DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=1\nRDATE:20990613T080000",
+      ),
+    ).toBe(false);
+  });
+
+  test("describeRRuleExpression humanizes rules", () => {
+    expect(describeRRuleExpression(SINGLE_FIRE)).toBe("One-time");
+    expect(describeRRuleExpression(WEEKLY)).toBe(
+      "Every week on Monday, Wednesday",
+    );
+    expect(
+      describeRRuleExpression(
+        "DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=3",
+      ),
+    ).toBe("Every day for 3 times");
+  });
+
+  test("describeRRuleExpression falls back instead of leaking raw text", () => {
+    expect(
+      describeRRuleExpression(
+        "DTSTART:20990612T080000\nRRULE:FREQ=DAILY\nEXDATE:20990613T080000",
+      ),
+    ).toBe("Custom recurrence");
+    expect(describeRRuleExpression("garbage")).toBe("Custom recurrence");
+  });
+});

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

@@ -492,6 +492,40 @@ describe("GET /schedules — default defer exclusion", () => {
     });
   });
 
+  test("humanizes rrule cadences and flags single-fire rrules as one-shot", () => {
+    createSchedule({
+      name: "RRule single fire",
+      cronExpression: "DTSTART:20990612T080000\nRRULE:FREQ=DAILY;COUNT=1",
+      syntax: "rrule",
+      message: "brush teeth",
+    });
+    createSchedule({
+      name: "RRule weekly",
+      cronExpression: "DTSTART:20990612T080000\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE",
+      syntax: "rrule",
+      message: "standup",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{
+        name: string;
+        cadenceDescription: string;
+        isOneShot: boolean;
+      }>;
+    };
+    const byName = new Map(result.schedules.map((s) => [s.name, s]));
+
+    expect(byName.get("RRule single fire")).toMatchObject({
+      cadenceDescription: "One-time",
+      isOneShot: true,
+    });
+    expect(byName.get("RRule weekly")).toMatchObject({
+      cadenceDescription: "Every week on Monday, Wednesday",
+      isOneShot: false,
+    });
+  });
+
   test("mutation responses also exclude deferred wakes", () => {
     createSchedule({
       name: "Agent schedule",

package/src/__tests__/scheduler-disk-pressure.test.ts

@@ -28,7 +28,7 @@ mock.module("../config/loader.js", () => ({
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   API_KEY_PROVIDERS: [],
-  _appendQuarantineBulletin: () => {},
+  _writeQuarantineNotice: () => {},
   invalidateConfigCache: () => {},
 }));
 

package/src/__tests__/script-proxy-conversation-manager.test.ts

@@ -247,13 +247,18 @@ describe("session-manager", () => {
       await startSession(session.id);
       expect(getActiveSession(CONV_ID)).toBeDefined();
 
-      // Wait for the idle timeout to fire
-      await new Promise((r) => setTimeout(r, 200));
+      // Wait for the idle timeout to fire and the async stop to finish.
+      // The session passes through "stopping" while the server closes, so
+      // poll for the terminal state rather than sleeping a fixed interval.
+      const deadline = Date.now() + 5000;
+      const findSession = () =>
+        getSessionsForConversation(CONV_ID).find((x) => x.id === session.id);
+      while (findSession()?.status !== "stopped" && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 20));
+      }
 
       expect(getActiveSession(CONV_ID)).toBeUndefined();
-      const all = getSessionsForConversation(CONV_ID);
-      const s = all.find((x) => x.id === session.id);
-      expect(s?.status).toBe("stopped");
+      expect(findSession()?.status).toBe("stopped");
     });
   });
 

package/src/__tests__/skill-tool-factory.test.ts

@@ -347,6 +347,55 @@ describe("createSkillTool — required/type/enum validation", () => {
     expect(result.content).toContain('mode must be one of "a", "b"');
   });
 
+  test("coerces string booleans before validation and passes the coerced value to the executor", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: {
+            auto_open: { type: "boolean" },
+            name: { type: "string" },
+          },
+        },
+      }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute(
+      { auto_open: "false", name: "x" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.input).toEqual({ auto_open: false, name: "x" });
+  });
+
+  test("rejects non-coercible boolean strings with a self-correcting message", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { auto_open: { type: "boolean" } },
+        },
+      }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute({ auto_open: "yes" }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      "auto_open must be a boolean — pass true or false as a JSON boolean, not a string",
+    );
+  });
+
   test("passes valid input through to the executor unchanged", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(

package/src/__tests__/subagent-role-registry.test.ts

@@ -7,7 +7,13 @@ import {
 } from "../subagent/index.js";
 
 /** All roles defined in the SubagentRole union. */
-const ALL_ROLES: SubagentRole[] = ["general", "researcher", "coder", "planner"];
+const ALL_ROLES: SubagentRole[] = [
+  "general",
+  "researcher",
+  "coder",
+  "planner",
+  "investigator",
+];
 
 describe("SUBAGENT_ROLE_REGISTRY", () => {
   test("covers all values in the SubagentRole union", () => {
@@ -64,6 +70,23 @@ describe("SUBAGENT_ROLE_REGISTRY", () => {
     expect(SUBAGENT_ROLE_REGISTRY.planner.allowedTools!).toContain("recall");
   });
 
+  test('investigator includes "bash" for grep/find-based code and log investigation', () => {
+    expect(SUBAGENT_ROLE_REGISTRY.investigator.allowedTools!).toContain("bash");
+  });
+
+  test("investigator excludes file write tools (read-only investigation)", () => {
+    const tools = SUBAGENT_ROLE_REGISTRY.investigator.allowedTools!;
+    expect(tools).not.toContain("file_write");
+    expect(tools).not.toContain("file_edit");
+  });
+
+  test("investigator preamble defines the root-cause report contract", () => {
+    const preamble = SUBAGENT_ROLE_REGISTRY.investigator.systemPromptPreamble;
+    expect(preamble).toContain("Root cause");
+    expect(preamble).toContain("Evidence");
+    expect(preamble).toContain("notify_parent");
+  });
+
   test("no role references the old memory_recall tool name", () => {
     for (const [_role, config] of Object.entries(SUBAGENT_ROLE_REGISTRY)) {
       if (config.allowedTools !== undefined) {

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

@@ -1325,6 +1325,7 @@ describe("Subagent role-based spawn", () => {
       "researcher",
       "coder",
       "planner",
+      "investigator",
     ]);
     // role is not required
     expect(def.input_schema.required).not.toContain("role");

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

@@ -110,6 +110,8 @@ mock.module("../credential-execution/managed-catalog.js", () => ({
 // Import after mock
 const { buildSystemPrompt, ensurePromptFiles, stripCommentLines } =
   await import("../prompts/system-prompt.js");
+const { SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../prompts/cache-boundary.js");
 
 describe("buildSystemPrompt", () => {
   beforeEach(() => {
@@ -128,7 +130,6 @@ describe("buildSystemPrompt", () => {
       "SOUL.md",
       "USER.md",
       "BOOTSTRAP.md",
-      "UPDATES.md",
       "VOICE.md",
       "skills",
       "users",
@@ -603,16 +604,6 @@ describe("buildSystemPrompt", () => {
     });
   });
 
-  test("never includes UPDATES.md content in system prompt", () => {
-    const updatesBody = "# v1.2\n\nNew feature added. UNIQUE_UPDATES_MARKER.";
-    writeFileSync(join(TEST_DIR, "UPDATES.md"), updatesBody);
-    const result = buildSystemPrompt();
-    expect(result).not.toContain("## Recent Updates");
-    expect(result).not.toContain(updatesBody);
-    expect(result).not.toContain("UNIQUE_UPDATES_MARKER");
-    expect(result).not.toContain("Update Handling");
-  });
-
   test("strips comment lines starting with _ from prompt files", () => {
     writeFileSync(
       join(TEST_DIR, "IDENTITY.md"),
@@ -879,6 +870,113 @@ describe("buildSystemPrompt", () => {
       expect(orgIdx).toBeGreaterThan(parallelIdx);
     });
 
+    describe("cache breakpoints", () => {
+      test("default breakpoint splits the prompt after 11-channel-persona", () => {
+        /**
+         * Tests that the bundled `cacheBreakpoint` on 11-channel-persona
+         * places the boundary marker between the stable sections and the
+         * volatile 12-voice section.
+         */
+        // GIVEN a workspace where a volatile section (12-voice) renders
+        writeFileSync(join(TEST_DIR, "VOICE.md"), "- Prefers lowercase.");
+
+        // WHEN the system prompt is built
+        const result = buildSystemPrompt();
+
+        // THEN the boundary marker sits before the voice content and
+        // after the stable instruction sections
+        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+        expect(boundaryIdx).toBeGreaterThan(-1);
+        expect(result.indexOf("## Communication")).toBeLessThan(boundaryIdx);
+        expect(result.indexOf("# Voice Profile")).toBeGreaterThan(boundaryIdx);
+      });
+
+      test("breakpoint splits even when the declaring section gates off", () => {
+        /**
+         * Tests that the split is resolved against the section ordering,
+         * not the rendered output — an absent channel persona must not
+         * merge the blocks around it.
+         */
+        // GIVEN no channel persona file exists but a volatile section renders
+        writeFileSync(join(TEST_DIR, "VOICE.md"), "- Prefers lowercase.");
+
+        // WHEN the system prompt is built
+        const result = buildSystemPrompt();
+
+        // THEN the boundary marker is still present
+        expect(result).toContain(SYSTEM_PROMPT_CACHE_BOUNDARY);
+      });
+
+      test("no boundary marker when nothing renders after the breakpoint", () => {
+        /**
+         * Tests that empty trailing blocks are dropped so the marker
+         * never dangles at the end of the prompt.
+         */
+        // GIVEN a fresh workspace with no volatile sections (no VOICE.md,
+        // no BOOTSTRAP.md, no connections)
+        // WHEN the system prompt is built
+        const result = buildSystemPrompt();
+
+        // THEN no boundary marker appears
+        expect(result).not.toContain(SYSTEM_PROMPT_CACHE_BOUNDARY);
+      });
+
+      test("workspace override of 11-channel-persona without cache_breakpoint clears the default", () => {
+        /**
+         * Tests that a workspace override takes full control of the
+         * section, including its breakpoint declaration.
+         */
+        // GIVEN a workspace override of 11-channel-persona with no
+        // cache_breakpoint frontmatter, and a volatile section that renders
+        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
+        writeFileSync(
+          join(SYSTEM_PROMPTS_DIR, "11-channel-persona.md"),
+          "Override channel persona.\n",
+        );
+        writeFileSync(join(TEST_DIR, "VOICE.md"), "- Prefers lowercase.");
+
+        // WHEN the system prompt is built
+        const result = buildSystemPrompt();
+
+        // THEN the override body renders but no boundary marker appears
+        expect(result).toContain("Override channel persona.");
+        expect(result).not.toContain(SYSTEM_PROMPT_CACHE_BOUNDARY);
+      });
+
+      test("frontmatter cache_breakpoint on a workspace section places the boundary there", () => {
+        /**
+         * Tests that users can declare the breakpoint position via
+         * `cache_breakpoint: true` frontmatter, and that only the first
+         * declaration (in id-sort order) is honored.
+         */
+        // GIVEN a custom workspace section declaring a cache breakpoint
+        // ahead of the bundled default on 11-channel-persona
+        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
+        writeFileSync(
+          join(SYSTEM_PROMPTS_DIR, "00-aaa-custom.md"),
+          "---\ncache_breakpoint: true\n---\nCustom head section.\n",
+        );
+        writeFileSync(join(TEST_DIR, "VOICE.md"), "- Prefers lowercase.");
+
+        // WHEN the system prompt is built
+        const result = buildSystemPrompt();
+
+        // THEN exactly one boundary appears, right after the custom section
+        const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+        expect(boundaryIdx).toBeGreaterThan(-1);
+        expect(result.indexOf("Custom head section.")).toBeLessThan(
+          boundaryIdx,
+        );
+        expect(result.indexOf("## Communication")).toBeGreaterThan(boundaryIdx);
+
+        // AND the bundled default declaration on 11-channel-persona is
+        // ignored — no second marker
+        expect(
+          result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY, boundaryIdx + 1),
+        ).toBe(-1);
+      });
+    });
+
     describe("containerized section (slot 02)", () => {
       const CONTAINERIZED_FILE = join(
         SYSTEM_PROMPTS_DIR,

package/src/__tests__/tool-error-hook.test.ts

@@ -79,6 +79,7 @@ function makeCtx(
     toolResponse,
     messages,
     additionalContext: null,
+    model: "claude-test-model",
     maxInputTokens: 10_000,
     logger: noopLogger,
   };