@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -59,7 +59,9 @@ beforeEach(() => {
   };
 });
 
-const validInput = {
+// A single question used to build batches. The tool only accepts the
+// batched `{ questions: [...] }` shape.
+const singleQ = {
   question: "Which fruit?",
   description: "Pick one to add to the smoothie.",
   options: [
@@ -69,12 +71,7 @@ const validInput = {
   freeTextPlaceholder: "Type a fruit",
 };
 
-const singleQ = {
-  question: validInput.question,
-  description: validInput.description,
-  options: validInput.options,
-  freeTextPlaceholder: validInput.freeTextPlaceholder,
-};
+const validInput = { questions: [singleQ] };
 
 describe("askQuestionTool definition", () => {
   test("exposes the expected schema shape and description language", () => {
@@ -91,7 +88,6 @@ describe("askQuestionTool definition", () => {
     expect(def.description).toContain("remove guessing");
     expect(def.description).toContain("a question is skipped");
     expect(def.description).toContain("every question in the batch is skipped");
-    // Batching language is back now that the prompter handles batches.
     expect(def.description).toContain("Batch related clarifications");
     expect(def.description).toContain("up to 5");
     expect(def.description).toContain("Skip button");
@@ -99,13 +95,23 @@ describe("askQuestionTool definition", () => {
     const schema = def.input_schema as {
       properties: Record<
         string,
-        { type?: string; minItems?: number; maxItems?: number }
+        {
+          type?: string;
+          items?: {
+            properties?: Record<
+              string,
+              { type?: string; minItems?: number; maxItems?: number }
+            >;
+          };
+        }
       >;
       required?: string[];
     };
-    expect(schema.properties.options?.type).toBe("array");
-    expect(schema.properties.options?.minItems).toBe(2);
-    expect(schema.properties.options?.maxItems).toBe(4);
+    const optionsSchema =
+      schema.properties.questions?.items?.properties?.options;
+    expect(optionsSchema?.type).toBe("array");
+    expect(optionsSchema?.minItems).toBe(2);
+    expect(optionsSchema?.maxItems).toBe(4);
   });
 });
 
@@ -132,17 +138,17 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(1);
     expect(calls[0]?.conversationId).toBe("conv-1");
     expect(calls[0]?.questions).toHaveLength(1);
-    expect(calls[0]?.questions[0]?.question).toBe(validInput.question);
-    expect(calls[0]?.questions[0]?.description).toBe(validInput.description);
-    expect(calls[0]?.questions[0]?.options).toEqual(validInput.options);
+    expect(calls[0]?.questions[0]?.question).toBe(singleQ.question);
+    expect(calls[0]?.questions[0]?.description).toBe(singleQ.description);
+    expect(calls[0]?.questions[0]?.options).toEqual(singleQ.options);
     expect(calls[0]?.questions[0]?.freeTextPlaceholder).toBe(
-      validInput.freeTextPlaceholder,
+      singleQ.freeTextPlaceholder,
     );
     expect(calls[0]?.toolUseId).toBe("tu-1");
 
     expect(result.isError).toBe(false);
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: a (Apple)`,
+      `Question "${singleQ.question}" → Option: a (Apple)`,
     );
   });
 
@@ -150,7 +156,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "b" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: b (Banana)`,
+      `Question "${singleQ.question}" → Option: b (Banana)`,
     );
     expect(result.isError).toBe(false);
   });
@@ -159,7 +165,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "ghost" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: ghost ((unknown))`,
+      `Question "${singleQ.question}" → Option: ghost ((unknown))`,
     );
     expect(result.isError).toBe(false);
   });
@@ -168,7 +174,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "free_text", text: "Cherry" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Free text: Cherry`,
+      `Question "${singleQ.question}" → Free text: Cherry`,
     );
     expect(result.isError).toBe(false);
   });
@@ -176,7 +182,7 @@ describe("AskQuestionTool.execute", () => {
   test("formats skipped result", async () => {
     setNextResult(singleCompleted({ decision: "skipped" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
-    expect(result.content).toBe(`Question "${validInput.question}" → Skipped`);
+    expect(result.content).toBe(`Question "${singleQ.question}" → Skipped`);
     expect(result.isError).toBe(false);
   });
 
@@ -200,10 +206,39 @@ describe("AskQuestionTool.execute", () => {
     expect(result.content).toBe("Question aborted");
   });
 
-  test("rejects input with fewer than 2 options", async () => {
+  test("short-circuits without prompting when no interactive user is present", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
+
     const result = await askQuestionTool.execute(
-      { ...validInput, options: [{ id: "a", label: "Apple" }] },
+      validInput,
+      makeContext({ isInteractive: false }),
+    );
+
+    // The prompter must never be invoked — there is no one to answer, so the
+    // turn proceeds with defaults instead of parking on the response backstop.
+    expect(calls).toHaveLength(0);
+    expect(result.isError).toBe(false);
+    expect(result.content.toLowerCase()).toContain("no interactive user");
+  });
+
+  test("still prompts when isInteractive is true or unset", async () => {
+    setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
+
+    // The short-circuit keys off an explicit `false`, not a missing flag, so an
+    // interactive turn (or one that never set the flag) still prompts.
+    await askQuestionTool.execute(
+      validInput,
+      makeContext({ isInteractive: true }),
+    );
+    await askQuestionTool.execute(validInput, makeContext());
+
+    expect(calls).toHaveLength(2);
+  });
+
+  test("rejects a question with fewer than 2 options", async () => {
+    setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
+    const result = await askQuestionTool.execute(
+      { questions: [{ ...singleQ, options: [{ id: "a", label: "Apple" }] }] },
       makeContext(),
     );
     expect(result.isError).toBe(true);
@@ -211,17 +246,21 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input with more than 4 options", async () => {
+  test("rejects a question with more than 4 options", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
       {
-        ...validInput,
-        options: [
-          { id: "a", label: "A" },
-          { id: "b", label: "B" },
-          { id: "c", label: "C" },
-          { id: "d", label: "D" },
-          { id: "e", label: "E" },
+        questions: [
+          {
+            ...singleQ,
+            options: [
+              { id: "a", label: "A" },
+              { id: "b", label: "B" },
+              { id: "c", label: "C" },
+              { id: "d", label: "D" },
+              { id: "e", label: "E" },
+            ],
+          },
         ],
       },
       makeContext(),
@@ -230,10 +269,10 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input with empty question", async () => {
+  test("rejects a question with empty text", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
-      { ...validInput, question: "" },
+      { questions: [{ ...singleQ, question: "" }] },
       makeContext(),
     );
     expect(result.isError).toBe(true);
@@ -254,18 +293,6 @@ describe("AskQuestionTool.execute", () => {
 // ── Batched input ───────────────────────────────────────────────────
 
 describe("AskQuestionTool batched input", () => {
-  test("normalizes legacy flat input into a one-element batch forwarded to the prompter", async () => {
-    setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
-
-    const result = await askQuestionTool.execute(validInput, makeContext());
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.questions).toHaveLength(1);
-    expect(calls[0]?.questions[0]?.question).toBe(validInput.question);
-    expect(calls[0]?.questions[0]?.options).toEqual(validInput.options);
-    expect(result.isError).toBe(false);
-  });
-
   test("accepts a single-element `questions` batch", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
@@ -454,7 +481,7 @@ describe("AskQuestionTool batched input", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input missing both `questions` and flat fields", async () => {
+  test("rejects input missing `questions`", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
     const result = await askQuestionTool.execute({}, makeContext());
@@ -464,11 +491,17 @@ describe("AskQuestionTool batched input", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects legacy `question` without `options`", async () => {
+  test("rejects the dropped flat single-question shape", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
     const result = await askQuestionTool.execute(
-      { question: "Hi?" },
+      {
+        question: "Hi?",
+        options: [
+          { id: "a", label: "A" },
+          { id: "b", label: "B" },
+        ],
+      },
       makeContext(),
     );
 
@@ -479,7 +512,7 @@ describe("AskQuestionTool batched input", () => {
 });
 
 describe("askQuestionTool definition (batched schema)", () => {
-  test("exposes `questions[]` shape, keeps legacy fields, omits per-question id", () => {
+  test("exposes `questions[]` shape, requires it, and drops the flat fields", () => {
     const def = askQuestionTool;
     const schema = def.input_schema as unknown as {
       properties: Record<
@@ -517,8 +550,12 @@ describe("askQuestionTool definition (batched schema)", () => {
 
     expect(questions?.items?.required).toEqual(["question", "options"]);
 
-    // Legacy fields still present.
-    expect(schema.properties.question).toBeDefined();
-    expect(schema.properties.options).toBeDefined();
+    // `questions` is the only top-level input now.
+    expect(schema.required).toEqual(["questions"]);
+    expect(Object.keys(schema.properties)).toEqual(["questions"]);
+
+    // The legacy flat fields are gone.
+    expect(schema.properties.question).toBeUndefined();
+    expect(schema.properties.options).toBeUndefined();
   });
 });

package/src/tools/ask-question/ask-question-tool.ts

@@ -40,35 +40,16 @@ const SingleQuestionSchema = z.object({
 // input with ≥6 entries is rejected with a clear Zod error.
 const MAX_QUESTIONS_PER_BATCH = 5;
 
-// Both the new batched shape (`questions[]`) and the legacy flat shape are
-// accepted. `execute()` normalizes legacy callers into a one-element
-// `questions` array before forwarding to the prompter.
-const InputSchema = z
-  .object({
-    questions: z
-      .array(SingleQuestionSchema)
-      .min(1)
-      .max(MAX_QUESTIONS_PER_BATCH, {
-        message: `At most ${MAX_QUESTIONS_PER_BATCH} questions per batch; split into multiple turns if you need more.`,
-      })
-      .optional(),
-    // Legacy flat fields. Optional so batched callers can omit them; when
-    // present and `questions` is absent, they are normalized into a
-    // one-element batch in `execute()`.
-    question: z.string().min(1).optional(),
-    description: z.string().optional(),
-    options: z.array(OptionSchema).min(2).max(4).optional(),
-    freeTextPlaceholder: z.string().optional(),
-  })
-  .refine(
-    (v) =>
-      v.questions !== undefined ||
-      (v.question !== undefined && v.options !== undefined),
-    {
-      message:
-        "Provide `questions` (preferred) or the legacy flat fields (`question` + `options`).",
-    },
-  );
+// Callers pass a (possibly single-element) batch of questions. `execute()`
+// forwards them straight to the prompter.
+const InputSchema = z.object({
+  questions: z
+    .array(SingleQuestionSchema)
+    .min(1)
+    .max(MAX_QUESTIONS_PER_BATCH, {
+      message: `At most ${MAX_QUESTIONS_PER_BATCH} questions per batch; split into multiple turns if you need more.`,
+    }),
+});
 
 export type SingleQuestion = z.infer<typeof SingleQuestionSchema>;
 export type AskQuestionInput = z.infer<typeof InputSchema>;
@@ -111,8 +92,7 @@ const DESCRIPTION = [
   "context shown beneath the label.",
 ].join("\n");
 
-// Shared option-schema fragment used by both the batched `questions[]`
-// shape and the legacy flat `options` field.
+// Option-schema fragment for the items in `questions[].options`.
 const OPTION_ITEMS_SCHEMA = {
   type: "object",
   properties: {
@@ -150,12 +130,11 @@ export const askQuestionTool = {
   input_schema: {
     type: "object",
     properties: {
-      // ── Recommended shape ─────────────────────────────────────
       questions: {
         type: "array",
         minItems: 1,
         maxItems: MAX_QUESTIONS_PER_BATCH,
-        description: `Recommended shape. 1–${MAX_QUESTIONS_PER_BATCH} clarifying questions to ask in a single turn. Use a batch when several independent ambiguities block progress; ask one at a time when they're sequentially dependent. Past ${MAX_QUESTIONS_PER_BATCH} questions you should be implementing, not asking.`,
+        description: `1–${MAX_QUESTIONS_PER_BATCH} clarifying questions to ask in a single turn. Use a batch when several independent ambiguities block progress; ask one at a time when they're sequentially dependent. Past ${MAX_QUESTIONS_PER_BATCH} questions you should be implementing, not asking.`,
         items: {
           type: "object",
           properties: {
@@ -185,35 +164,8 @@ export const askQuestionTool = {
           required: ["question", "options"],
         },
       },
-      // ── Legacy single-question fields ─────────────────────────
-      // Kept optional so existing prompt caches and any single-question
-      // callers continue to work. New callers should use `questions`.
-      question: {
-        type: "string",
-        description:
-          "Legacy: the single clarifying question. Prefer `questions[]` for new code.",
-      },
-      description: {
-        type: "string",
-        description:
-          "Legacy: optional one-line context shown beneath the question. Prefer `questions[].description`.",
-      },
-      options: {
-        type: "array",
-        minItems: 2,
-        maxItems: 4,
-        description:
-          "Legacy: 2–4 structured options. Prefer `questions[].options`. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-        items: OPTION_ITEMS_SCHEMA,
-      },
-      freeTextPlaceholder: {
-        type: "string",
-        description:
-          "Legacy: optional placeholder text for the free-text fallback input. Prefer `questions[].freeTextPlaceholder`.",
-      },
     },
-    // No top-level `required` — caller must supply either `questions`
-    // or the legacy flat trio (`question` + `options`). Enforced in Zod.
+    required: ["questions"],
   },
 
   async execute(
@@ -228,18 +180,20 @@ export const askQuestionTool = {
       };
     }
 
-    // Normalize legacy flat input into a one-element `questions` batch so
-    // downstream code only has to deal with the batched shape. The refine
-    // above guarantees `question` and `options` are present whenever
-    // `questions` is absent.
-    const questions: SingleQuestion[] = parsed.data.questions ?? [
-      {
-        question: parsed.data.question!,
-        description: parsed.data.description,
-        options: parsed.data.options!,
-        freeTextPlaceholder: parsed.data.freeTextPlaceholder,
-      },
-    ];
+    const questions: SingleQuestion[] = parsed.data.questions;
+
+    // No interactive user is present to answer (scheduled/headless/background
+    // turn). Don't park the turn on a prompt no one can resolve — proceed with
+    // defaults immediately. Non-interactive turns are already instructed not to
+    // ask (NON_INTERACTIVE_CONTEXT_BLOCK); this is the backstop for when the
+    // model asks anyway, so it doesn't wait out the full response timeout.
+    if (context.isInteractive === false) {
+      return {
+        content:
+          "No interactive user is present to answer; proceeding with reasonable defaults.",
+        isError: false,
+      };
+    }
 
     const prompter = new QuestionPrompter();
     const result = await prompter.prompt({

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -296,4 +296,24 @@ describe("executeBrowserStatus", () => {
     expect(extension.available).toBe(true);
     expect(extension.details.transport).toBe("extension-ws");
   });
+
+  test("reports extension as connected when probe fails on the Chrome Web Store / extensions gallery", async () => {
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
+    probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
+    probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
+      "cdp_error",
+      "The extensions gallery cannot be scripted.",
+    );
+
+    const result = await executeBrowserStatus({}, makeContext());
+    expect(result.isError).toBe(false);
+    const payload = JSON.parse(result.content);
+    const extension = payload.modes.find(
+      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
+    );
+    expect(extension).toBeDefined();
+    expect(extension.available).toBe(true);
+    expect(extension.verified).toBe("active_probe");
+    expect(extension.details.restrictedActiveTab).toBe(true);
+  });
 });

package/src/tools/browser/browser-execution.ts

@@ -345,10 +345,22 @@ function collectRemediationHints(
 
 /**
  * Detect the common extension CDP failure where the active tab is a
- * restricted Chrome internal page (e.g. `chrome://newtab`).
+ * page Chrome forbids extensions from scripting — either a privileged
+ * `chrome://` internal page (e.g. `chrome://newtab`) or the Chrome Web
+ * Store / extensions gallery (which yields "The extensions gallery
+ * cannot be scripted."). The latter is especially common right after
+ * install, when the Web Store page is still the active tab.
+ *
+ * Keep this restricted-error match in sync with the Page.navigate
+ * recovery in the chrome-extension dispatcher (host-browser-dispatcher.ts,
+ * separate package, duplicated by necessity): the status side reports the
+ * tab as recoverable, and the navigate side must actually recover it.
  */
 function isRestrictedChromePageProbeError(error: CdpError): boolean {
-  return error.message.toLowerCase().includes("chrome://");
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("chrome://") || message.includes("cannot be scripted")
+  );
 }
 
 /**
@@ -2450,9 +2462,9 @@ async function checkExtensionModeStatus(
       verified: "active_probe",
       autoCandidate,
       summary:
-        "Extension mode transport is connected, but the active Chrome tab is a restricted chrome:// page. Switch to a regular website tab if browser actions fail.",
+        "Extension mode transport is connected, but the active Chrome tab is a page Chrome won't let extensions script (a chrome:// page or the Chrome Web Store / extensions gallery). Switch to a regular website tab if browser actions fail.",
       userActions: [
-        "Switch Chrome to a regular http(s) tab (not chrome://...) and retry.",
+        "Switch Chrome to a regular http(s) tab — not a chrome:// page or the Chrome Web Store / extensions gallery — and retry.",
       ],
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: {

package/src/tools/document/document-comment-tool.test.ts

@@ -20,7 +20,7 @@ import {
   executeCommentResolve,
 } from "./document-comment-tool.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/tools/executor.ts

@@ -525,13 +525,21 @@ export { isSideEffectTool } from "./side-effects.js";
  *
  * Shell tools (`bash`, `host_bash`) manage their own timeouts with SIGKILL
  * on expiry. We add a 5s buffer so the shell's own deadline fires first and
- * handles cleanup before the executor wrapper trips. Non-shell tools use
- * the generic `toolExecutionTimeoutSec` configuration value.
+ * handles cleanup before the executor wrapper trips.
+ *
+ * `ask_question` blocks on user input inside `execute()` via `QuestionPrompter`,
+ * which waits up to `questionResponseTimeoutSec`. We give the wrapper the same
+ * 5s buffer over that deadline so the prompter's own timeout fires first and
+ * returns its clean "User did not respond within timeout" result — otherwise
+ * the shorter generic budget trips first, orphaning the still-pending prompt
+ * behind the confusing "may still be running in the background" error.
+ *
+ * All other tools use the generic `toolExecutionTimeoutSec` configuration value.
  *
  * Consumed by `executeInternal` via `executeWithTimeout`, which is the
  * sole enforcer of the per-tool budget.
  */
-function computePerToolTimeoutMs(
+export function computePerToolTimeoutMs(
   name: string,
   input: Record<string, unknown>,
 ): number {
@@ -547,6 +555,10 @@ function computePerToolTimeoutMs(
     );
     return (shellTimeoutSec + 5) * 1000;
   }
+  if (name === "ask_question") {
+    const { questionResponseTimeoutSec } = getConfig().timeouts;
+    return (questionResponseTimeoutSec + 5) * 1000;
+  }
   const rawTimeoutSec = getConfig().timeouts.toolExecutionTimeoutSec;
   return safeTimeoutMs(rawTimeoutSec);
 }

package/src/tools/host-terminal/host-shell.ts

@@ -35,7 +35,10 @@ import {
   registerBackgroundTool,
   removeBackgroundTool,
 } from "../background-tool-registry.js";
-import { formatShellOutput } from "../shared/shell-output.js";
+import {
+  formatShellOutput,
+  MAX_OUTPUT_LENGTH,
+} from "../shared/shell-output.js";
 import { buildSanitizedEnv } from "../terminal/safe-env.js";
 import type {
   ToolContext,
@@ -296,13 +299,20 @@ export const hostShellTool = {
 
         proxyPromise
           .then((result) => {
-            const hint = result.isError
-              ? `Background host command failed (id=${bgId}):\n${result.content}`
-              : `Background host command completed (id=${bgId}):\n${result.content || "(no output)"}`;
+            const framing = result.isError
+              ? `Background host command failed (id=${bgId}):`
+              : `Background host command completed (id=${bgId}):`;
             void wakeAgentForOpportunity({
               conversationId: context.conversationId,
-              hint,
+              hint: framing,
               source: "background-tool",
+              persistTriggerAsEvent: true,
+              untrustedOutput: {
+                content: result.content || "(no output)",
+                source: "tool_result",
+                // Preserve formatShellOutput's recovery marker (see shell.ts).
+                maxChars: MAX_OUTPUT_LENGTH * 2,
+              },
             });
           })
           .catch((err) => {
@@ -310,6 +320,7 @@ export const hostShellTool = {
               conversationId: context.conversationId,
               hint: `Background host command failed (id=${bgId}): ${err instanceof Error ? err.message : String(err)}`,
               source: "background-tool",
+              persistTriggerAsEvent: true,
             });
           })
           .finally(() => removeBackgroundTool(bgId));
@@ -440,13 +451,20 @@ export const hostShellTool = {
           timedOut,
           timeoutSec,
         );
-        const hint = result.isError
-          ? `Background host command failed (id=${bgId}):\n${result.content}`
-          : `Background host command completed (id=${bgId}):\n${result.content || "(no output)"}`;
+        const framing = result.isError
+          ? `Background host command failed (id=${bgId}):`
+          : `Background host command completed (id=${bgId}):`;
         void wakeAgentForOpportunity({
           conversationId: context.conversationId,
-          hint,
+          hint: framing,
           source: "background-tool",
+          persistTriggerAsEvent: true,
+          untrustedOutput: {
+            content: result.content || "(no output)",
+            source: "tool_result",
+            // Preserve formatShellOutput's recovery marker (see shell.ts).
+            maxChars: MAX_OUTPUT_LENGTH * 2,
+          },
         });
         removeBackgroundTool(bgId);
       });
@@ -459,6 +477,7 @@ export const hostShellTool = {
           conversationId: context.conversationId,
           hint: `Background host command failed (id=${bgId}): ${err.message}`,
           source: "background-tool",
+          persistTriggerAsEvent: true,
         });
         removeBackgroundTool(bgId);
       });

package/src/tools/memory/register.test.ts

@@ -348,3 +348,35 @@ describe("rememberTool.execute — PKB re-index enqueue", () => {
     expect(archiveContents).toContain("enqueue will throw");
   });
 });
+
+describe("rememberTool.execute — batch (array) content", () => {
+  beforeEach(() => {
+    enqueueCalls.length = 0;
+    enqueueShouldThrow = false;
+  });
+
+  test("records every fact from an array and enqueues per file, not per fact", async () => {
+    const result = await rememberTool.execute(
+      { content: ["batch fact A", "batch fact B"] },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+
+    const pkbRoot = join(tmpWorkspace, "pkb");
+    const bufferContents = readFileSync(join(pkbRoot, "buffer.md"), "utf-8");
+    expect(bufferContents).toContain("batch fact A");
+    expect(bufferContents).toContain("batch fact B");
+
+    // buffer + archive, regardless of how many facts the call carried.
+    expect(enqueueCalls).toHaveLength(2);
+  });
+
+  test("rejects an all-blank array without writing or enqueueing", async () => {
+    const result = await rememberTool.execute(
+      { content: ["  ", ""] },
+      makeContext(),
+    );
+    expect(result.isError).toBe(true);
+    expect(enqueueCalls).toHaveLength(0);
+  });
+});