@vellumai/assistant 0.10.0-dev.202606200318.c052d10 → 0.10.0-dev.202606201453.1417592

package/src/runtime/agent-wake.ts

@@ -597,13 +597,14 @@ export async function wakeAgentForOpportunity(
     });
 
     // Apply the caller's persona override for the duration of the run. The
-    // wake's agent loop builds the system prompt through the conversation's
-    // resolveSystemPrompt callback, which reads this field; cleared (below,
-    // before drainQueue) so a queued user turn never builds its prompt under
-    // the wake's override. Assigned only AFTER the profile/config reads above
-    // — those can throw, and they run before the try/finally that clears the
-    // override, so an earlier assignment would strand the override on the
-    // cached Conversation and corrupt every later prompt build on it.
+    // prompt is built once before `agentLoop.run()` (via
+    // `conversation.buildCurrentSystemPrompt()`), which reads this field;
+    // cleared (below, before drainQueue) so a queued user turn never builds
+    // its prompt under the wake's override. Assigned only AFTER the
+    // profile/config reads above — those can throw, and they run before the
+    // try/finally that clears the override, so an earlier assignment would
+    // strand the override on the cached Conversation and corrupt every later
+    // prompt build on it.
     if (opts.personaOverride) {
       conversation.wakePersonaOverride = opts.personaOverride;
     }
@@ -1146,6 +1147,13 @@ export async function wakeAgentForOpportunity(
             maxInputTokens: effectiveContextWindow.maxInputTokens,
             overflowRecovery: { enabled: false, safetyMarginRatio: 0 },
           }),
+          // Resolve the system prompt once before the run — the loop does
+          // not re-resolve mid-loop. `wakePersonaOverride` (if set above)
+          // is baked into the prompt at this point.
+          systemPrompt: conversation.buildCurrentSystemPrompt(),
+          ...(conversation.modelOverride
+            ? { model: conversation.modelOverride }
+            : {}),
         }));
       } catch (err) {
         // An over-window throw on a compaction-suppressed wake is the

package/src/runtime/routes/conversation-routes.ts

@@ -10,7 +10,10 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../../agent/message-types.js";
-import { ConversationMessageSchema } from "../../api/responses/conversation-message.js";
+import {
+  type ConversationContentBlock,
+  ConversationMessageSchema,
+} from "../../api/responses/conversation-message.js";
 import {
   CHANNEL_IDS,
   INTERFACE_IDS,
@@ -943,7 +946,25 @@ export function handleListMessages({
         .filter((block) => block.type !== "text" || block.text.length > 0);
     }
 
-    const alignedContentOrder = aligned.rewriteContentOrder(contentOrder);
+  // Ensure every hydrated attachment has a corresponding content block.
+  // renderHistoryContent inlines attachment blocks only when it has
+  // file-block refs with matching DB rows; directives (assistant-authored
+  // <vellum-attachment/> tags) don't leave a file block after stripping,
+  // so their attachments end up in the flat `attachments` array but not in
+  // `contentBlocks`. Append any that are missing so the canonical
+  // projection is complete.
+  const existingAttachmentIds = new Set(
+    contentBlocks
+      .filter((b): b is Extract<ConversationContentBlock, { type: "attachment" }> => b.type === "attachment")
+      .map((b) => b.attachment.id),
+  );
+  for (const att of msgAttachments) {
+    if (!existingAttachmentIds.has(att.id)) {
+      contentBlocks.push({ type: "attachment", attachment: att });
+    }
+  }
+
+  const alignedContentOrder = aligned.rewriteContentOrder(contentOrder);
 
     // Use sentAt (actual event time) for the display timestamp when available,
     // falling back to createdAt (persistence time). Clients use this display
@@ -971,7 +992,7 @@ export function handleListMessages({
       ...(alignedContentOrder.length > 0
         ? { contentOrder: alignedContentOrder }
         : {}),
-      ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+      contentBlocks,
       ...(m.subagentNotification
         ? { subagentNotification: m.subagentNotification }
         : {}),

package/src/runtime/routes/migration-routes.ts

@@ -38,6 +38,7 @@ import {
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
 import { getLogger } from "../../util/logger.js";
+import { getLogsDbPath } from "../../util/logs-db-path.js";
 import { getWorkspaceDir, getWorkspaceHooksDir } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
@@ -151,6 +152,38 @@ export async function reconcileVellumMetadataFromCes(warningSink: {
 
 const log = getLogger("migration-routes");
 
+/**
+ * Flush both database files' WALs before an export copies them. The bundle
+ * walker includes `*.db` but skips `*.db-wal`, so committed frames still sitting
+ * in a WAL would be missing from the bundle.
+ *
+ * Dispatched through `runAsyncSqlite` so the flush runs in a sqlite3 subprocess
+ * where available — a multi-GB WAL flush would otherwise stall the event loop.
+ * The in-process fallback runs on the daemon connection, where one unqualified
+ * checkpoint already covers every attached database; the subprocess opens a
+ * single file, so we issue a second checkpoint targeting the logs file. FULL
+ * (not TRUNCATE) writes committed frames back to the main file, which is all the
+ * copy needs.
+ */
+async function checkpointDbsForExport(): Promise<void> {
+  const targets: Array<{ label: string; dbPath?: string }> = [
+    { label: "main" },
+    { label: "logs", dbPath: getLogsDbPath() },
+  ];
+  for (const { label, dbPath } of targets) {
+    const result = await runAsyncSqlite(
+      "PRAGMA wal_checkpoint(FULL)",
+      dbPath ? { dbPath } : undefined,
+    );
+    if (!result.ok) {
+      log.warn(
+        { error: result.error, backend: result.backend, db: label },
+        "WAL checkpoint failed — exporting without checkpoint",
+      );
+    }
+  }
+}
+
 /**
  * Fields the export pipeline must populate on the v1 manifest.
  *
@@ -353,28 +386,7 @@ export async function handleMigrationExport(
       ...manifestInputs,
       secretsRedacted,
       credentials,
-      checkpoint: async () => {
-        // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
-        // in a sqlite3 subprocess on hosts where it's available. A WAL
-        // flush on a multi-GB WAL file can otherwise stall the daemon's
-        // event loop for the full duration of the flush.
-        //
-        // FULL (not TRUNCATE): FULL blocks until every committed frame is
-        // written back to the main `.db` file, which is all the export
-        // needs since it copies that file. TRUNCATE additionally restarts
-        // the WAL and truncates it to zero bytes — extra work and blocking
-        // this path does not need.
-        const result = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
-        if (!result.ok) {
-          // Best-effort: if the DB can't be checkpointed (e.g. not a valid
-          // SQLite file, missing WAL, etc.) we still proceed with the export
-          // using whatever is on disk.
-          log.warn(
-            { error: result.error, backend: result.backend },
-            "WAL checkpoint failed — exporting without checkpoint",
-          );
-        }
-      },
+      checkpoint: checkpointDbsForExport,
     });
 
     cleanup = result.cleanup;
@@ -582,23 +594,7 @@ export async function handleMigrationExportToGcs({ body }: RouteHandlerArgs) {
           ...manifestInputs,
           secretsRedacted,
           credentials: collected.credentials,
-          checkpoint: async () => {
-            // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
-            // in a sqlite3 subprocess on hosts where it's available. A
-            // WAL flush on a multi-GB WAL file can otherwise stall the
-            // daemon's event loop for the full duration of the flush.
-            //
-            // FULL (not TRUNCATE): see the disk-export checkpoint above
-            // for rationale. assistant/AGENTS.md "SQLite WAL
-            // checkpointing".
-            const result = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
-            if (!result.ok) {
-              log.warn(
-                { error: result.error, backend: result.backend },
-                "WAL checkpoint failed — exporting without checkpoint",
-              );
-            }
-          },
+          checkpoint: checkpointDbsForExport,
         });
 
         cleanup = result.cleanup;

package/src/schedule/scheduler.ts

@@ -1,3 +1,4 @@
+import { getConfig } from "../config/loader.js";
 import {
   checkDiskPressureBackgroundGate,
   diskPressureBackgroundSkipLogFields,
@@ -85,14 +86,6 @@ const TICK_INTERVAL_MS = 15_000;
  */
 const WAKE_MAX_RETRIES = 20;
 
-/**
- * Hard timeout for `talk`-mode scheduled jobs. Schedules can do
- * non-trivial work (research, summarize the day, etc.), so the cap is
- * generous; it exists primarily so a wedged turn cannot block the next
- * scheduler tick indefinitely. Mirrors the heartbeat/filing budgets.
- */
-const SCHEDULE_TALK_TIMEOUT_MS = 30 * 60 * 1000;
-
 /**
  * Apply retry policy on schedule-execution failure. Retries are scheduled by
  * `applyRetryDecision`; once retries are exhausted, the `emitAlert` callback
@@ -718,7 +711,10 @@ export async function runScheduleDueWorkOnce(
         ...(job.inferenceProfile
           ? { overrideProfile: job.inferenceProfile }
           : {}),
-        timeoutMs: SCHEDULE_TALK_TIMEOUT_MS,
+        // Hard timeout for talk-mode scheduled turns: bounds a wedged turn so
+        // it cannot block the next scheduler tick. Configurable via
+        // timeouts.scheduleTurnTimeoutSec (default 1800s).
+        timeoutMs: getConfig().timeouts.scheduleTurnTimeoutSec * 1000,
         origin: "schedule",
         groupId: "system:scheduled",
         conversationType: "scheduled",

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,10 @@ describe("AskQuestionTool.execute", () => {
     expect(result.content).toBe("Question aborted");
   });
 
-  test("rejects input with fewer than 2 options", async () => {
+  test("rejects a question with fewer than 2 options", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
-      { ...validInput, options: [{ id: "a", label: "Apple" }] },
+      { questions: [{ ...singleQ, options: [{ id: "a", label: "Apple" }] }] },
       makeContext(),
     );
     expect(result.isError).toBe(true);
@@ -211,17 +217,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 +240,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 +264,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 +452,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 +462,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 +483,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 +521,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,7 @@ 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;
 
     const prompter = new QuestionPrompter();
     const result = await prompter.prompt({

package/src/util/fs-watcher-error.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared `'error'`-event handler for `fs.watch()` FSWatchers.
+ *
+ * An `FSWatcher` is an EventEmitter. When the underlying inotify/FSEvents
+ * backend fails *after* the watch was established — e.g. ENOSPC when the
+ * kernel's `fs.inotify.max_user_watches` limit is exhausted while walking a
+ * recursive watch into a large subtree (a plugin's `node_modules`), or ENXIO
+ * when a Unix socket file appears in a watched directory — the failure is
+ * delivered asynchronously as an `'error'` event rather than a synchronous
+ * throw from `watch()`. An emitter with no `'error'` listener rethrows, which
+ * surfaces as an `uncaughtException` and takes the whole daemon down (→
+ * CrashLoopBackOff).
+ *
+ * Attaching this handler degrades the failure to "this watcher stops
+ * delivering events", in line with the daemon startup philosophy: a subsystem
+ * failure must never crash the process.
+ */
+
+import type { FSWatcher } from "node:fs";
+
+import type { Logger } from "pino";
+
+/**
+ * Attach a resilient `'error'` listener so async FSWatcher failures are logged
+ * instead of crashing the process. Pass the owning module's logger and the
+ * watched directory for diagnostic context.
+ */
+export function attachFsWatcherErrorHandler(
+  watcher: FSWatcher,
+  log: Logger,
+  dir: string,
+): void {
+  watcher.on("error", (err) => {
+    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
+  });
+}