pi-ask-popup 0.1.0 → 0.2.0

package/src/ask-user-question.ts

@@ -74,7 +74,9 @@ export const BEL = "\x07";
  */
 function emitTerminalAttention(): void {
   try {
-    if (process.stdout.isTTY) process.stdout.write(BEL);
+    if (process.stdout.isTTY) {
+      process.stdout.write(BEL);
+    }
   } catch {
     // Best effort. Failing to get someone's attention must not stop the
     // questionnaire from being asked.
@@ -127,6 +129,8 @@ type SessionLoad =
       message: string;
     };
 
+type LoadConfigInput = { agentDir: string; projectDir?: string };
+
 /**
  * Load the render graph on first use, guarding its two failure shapes.
  *
@@ -158,6 +162,9 @@ export async function loadQuestionnaireSession(
       message: `${ERROR_SESSION_LOAD_FAILED} (cause: ${cause})`,
     };
   }
+  // jiti hands back a namespace built in its own realm, so this class can fail
+  // an `instanceof Function` here while being perfectly constructible. `typeof`
+  // asks the question that actually matters: is there something to call.
   if (typeof mod.QuestionnaireSession !== "function") {
     const keys = JSON.stringify(Object.keys(mod));
     return {
@@ -189,16 +196,25 @@ function registerCollapseKeyListener(
   let hasAnnouncedHide = false;
   return ctx.ui.onTerminalInput((data) => {
     const handle = overlayHandleRef.current;
-    if (!handle) return undefined;
+    if (!handle) {
+      return undefined;
+    }
     // Act only while this questionnaire is hidden (its own input is
     // unreachable) or actually focused. With another overlay on top, the key
     // belongs to that one; toggling from underneath it would be baffling.
-    if (!handle.isHidden() && !handle.isFocused()) return undefined;
-    if (!matchesKey(data, collapseKey as Parameters<typeof matchesKey>[1])) return undefined;
+    if (!handle.isHidden() && !handle.isFocused()) {
+      return undefined;
+    }
+    // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
+    if (!matchesKey(data, collapseKey as Parameters<typeof matchesKey>[1])) {
+      return undefined;
+    }
     // Kitty-protocol terminals report press, repeat and release separately.
     // Toggling on all three would make a tap reopen what it just closed, and a
     // held key flicker.
-    if (isKeyRelease(data) || isKeyRepeat(data)) return { consume: true };
+    if (isKeyRelease(data) || isKeyRepeat(data)) {
+      return { consume: true };
+    }
     sessionRef.current?.toggleCollapsedExternal();
     if (handle.isHidden() && !hasAnnouncedHide) {
       // Once only. The dialog has just vanished, so say how to get it back —
@@ -251,7 +267,9 @@ function makeSessionFactory(config: {
           const editorCommand = SettingsManager.create(ctx.cwd, undefined, {
             projectTrusted: ctx.isProjectTrusted(),
           }).getExternalEditorCommand();
-          if (!editorCommand) throw new Error("No external editor command is configured");
+          if (!editorCommand) {
+            throw new Error("No external editor command is configured");
+          }
           return await editWithExternalEditor(tui, editorCommand, value);
         } catch (error) {
           // Reported, then undefined, which the session reads as "keep the
@@ -341,12 +359,13 @@ Preview content is rendered as markdown in a monospace box. Multi-line text with
  * exists to prevent. The collapse key, a local UI preference, does read both
  * layers.
  */
-function loadGuidance(): {
-  guidance: ReturnType<typeof validateGuidanceFields>;
-  warnings: readonly string[];
-} {
+function loadGuidance() {
   const { config, warnings } = loadConfig({ agentDir: getAgentDir() });
-  return { guidance: validateGuidanceFields(config.guidance), warnings };
+  const result = {
+    guidance: validateGuidanceFields(config.guidance),
+    warnings,
+  };
+  return result;
 }
 
 export function registerAskPopupTool(pi: ExtensionAPI): void {
@@ -365,10 +384,15 @@ export function registerAskPopupTool(pi: ExtensionAPI): void {
     parameters: QuestionParamsSchema,
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const typed = params as unknown as QuestionParams;
-      if (!ctx.hasUI) return rejectWithoutUi();
+      // SAFETY: params is validated by QuestionParamsSchema via validateQuestionnaire immediately after narrowing.
+      const typed = params as QuestionParams;
+      if (!ctx.hasUI) {
+        return rejectWithoutUi();
+      }
 
-      for (const warning of pendingWarnings) ctx.ui.notify?.(warning, "warning");
+      for (const warning of pendingWarnings) {
+        ctx.ui.notify?.(warning, "warning");
+      }
       pendingWarnings = [];
 
       const validation = validateQuestionnaire(typed);
@@ -385,6 +409,7 @@ export function registerAskPopupTool(pi: ExtensionAPI): void {
       // Hosts that advertise their mode go straight to the walker and never
       // import the render graph at all. Older RPC builds fall through to the
       // undefined-result backstop below.
+      // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
       if ((ctx as { mode?: string }).mode === "rpc" && hasDialogUI(ctx.ui)) {
         return runRpcPath(pi, ctx.ui, typed);
       }
@@ -393,6 +418,11 @@ export function registerAskPopupTool(pi: ExtensionAPI): void {
       // primitives is malformed, and calling `custom` on it throws a bare
       // TypeError that reaches the model as a broken tool rather than an
       // unsupported one. Answer honestly instead: nobody saw the questions.
+      //
+      // `typeof` rather than `instanceof Function`, for the same reason as
+      // `hasDialogUI`: a cross-realm `custom` is callable and must not be
+      // mistaken for a missing one.
+      // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
       if (typeof (ctx.ui as { custom?: unknown }).custom !== "function") {
         return resolveUndefinedResult(ctx, typed);
       }
@@ -414,12 +444,13 @@ export function registerAskPopupTool(pi: ExtensionAPI): void {
       // Both layers here: unlike guidance, this only binds a key in the user's
       // own terminal, and a project pinning a shortcut that suits its docs is
       // reasonable. `resolveCollapseKey` refuses anything malformed.
-      const collapseKey = resolveCollapseKey(
-        loadConfig({
-          agentDir: getAgentDir(),
-          ...(ctx.isProjectTrusted() ? { projectDir: ctx.cwd } : {}),
-        }).config,
-      );
+      const configInput: LoadConfigInput = {
+        agentDir: getAgentDir(),
+      };
+      if (ctx.isProjectTrusted()) {
+        configInput.projectDir = ctx.cwd;
+      }
+      const collapseKey = resolveCollapseKey(loadConfig(configInput).config);
 
       const sessionRef: SessionRef = { current: null };
       const overlayHandleRef: OverlayHandleRef = { current: undefined };
@@ -461,7 +492,9 @@ export function registerAskPopupTool(pi: ExtensionAPI): void {
           },
         );
 
-        if (result === undefined) return resolveUndefinedResult(ctx, typed);
+        if (result === undefined) {
+          return resolveUndefinedResult(ctx, typed);
+        }
         return buildQuestionnaireResponse(result, typed);
       } finally {
         removeOverlayInputListener?.();

package/src/config.ts

@@ -1,7 +1,26 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
 
+type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { readonly [key: string]: JsonValue };
+type JsonRecord = Record<string, JsonValue>;
+
+function isRecord(value: unknown): value is JsonRecord;
+function isRecord(value: JsonValue | undefined): value is JsonRecord;
+function isRecord(value: unknown): value is JsonRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
 /** Key spec for the overlay collapse/expand shortcut, e.g. `"ctrl+]"` or `"alt+o"`. */
 export type CollapseKeySpec = string;
 
@@ -62,6 +81,35 @@ export function configPaths(sources: ConfigSources): string[] {
   return paths;
 }
 
+/** What one layer parsed to, and the stamp of the file it parsed from. */
+interface CachedLayer {
+  /** `mtimeMs:size`, or undefined when the file could not be stat'd (usually absent). */
+  stamp: string | undefined;
+  value: JsonRecord;
+  /** Replayed on every hit, so a malformed file keeps complaining. */
+  warnings: readonly string[];
+}
+
+const layerCache = new Map<string, CachedLayer>();
+
+/**
+ * Drop the memo. Tests rewrite the same path within a millisecond, which is
+ * finer than the stamp can see; production has no reason to call it.
+ */
+export function clearConfigCache(): void {
+  layerCache.clear();
+}
+
+/** Undefined for a file that cannot be stat'd — absent, or gone behind a bad mount. */
+function layerStamp(path: string): string | undefined {
+  try {
+    const stat = statSync(path);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Read one layer. An absent file means "no overrides" and is not a warning —
  * having no config is the normal case, not a degraded one. Anything else that
@@ -71,33 +119,57 @@ export function configPaths(sources: ConfigSources): string[] {
  * Deliberately `readFileSync` + catch rather than `existsSync` then read: the
  * check-then-read pair races, and this keeps the no-write guarantee obvious —
  * nothing here can create a file or a parent directory.
+ *
+ * Memoized on `mtimeMs:size`, because this sits on the tool-call hot path: the
+ * user has just triggered a questionnaire and the overlay is about to paint.
+ * An unchanged layer then costs one `stat` instead of a read and a JSON parse,
+ * and the usual case — no config file at all — costs the failed `stat` alone.
+ * The stamp is the same race the read already had: a file rewritten inside one
+ * millisecond at the same size is read as unchanged until it changes again.
  */
-function readLayer(path: string, warnings: string[]): Record<string, unknown> {
+function readLayer(path: string, warnings: string[]): JsonRecord {
+  const stamp = layerStamp(path);
+  const cached = layerCache.get(path);
+  if (cached && cached.stamp === stamp) {
+    warnings.push(...cached.warnings);
+    return cached.value;
+  }
+  const layerWarnings: string[] = [];
+  const value = parseLayer(path, layerWarnings);
+  layerCache.set(path, { stamp, value, warnings: layerWarnings });
+  warnings.push(...layerWarnings);
+  return value;
+}
+
+/** The read itself. Separated so the memo above stays about caching. */
+function parseLayer(path: string, warnings: string[]): JsonRecord {
   let text: string;
   try {
     text = readFileSync(path, "utf8");
   } catch (err) {
+    // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
     if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
       warnings.push(`pi-ask-popup: cannot read ${path} — ${(err as Error).message}`);
     }
     return {};
   }
   try {
     const parsed: unknown = JSON.parse(text);
-    // `typeof null === "object"` and so is an array; a config file is neither.
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    if (!isRecord(parsed)) {
       warnings.push(`pi-ask-popup: ${path} is not a JSON object, ignoring it`);
       return {};
     }
-    return parsed as Record<string, unknown>;
+    return parsed;
   } catch (err) {
+    // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
     warnings.push(`pi-ask-popup: invalid JSON in ${path}, ignoring it — ${(err as Error).message}`);
     return {};
   }
 }
 
 function nonEmptyString(value: unknown): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
+  return isNonEmptyString(value) ? value : undefined;
 }
 
 /**
@@ -106,19 +178,26 @@ function nonEmptyString(value: unknown): string | undefined {
  * the tool still registers.
  */
 export function validateGuidanceFields(fields: unknown): GuidanceFields {
-  if (fields === null || typeof fields !== "object") return {};
-  const g = fields as Record<string, unknown>;
+  if (!isRecord(fields)) {
+    return {};
+  }
+  const g = fields;
   const out: GuidanceFields = {};
   const description = nonEmptyString(g.description);
-  if (description !== undefined) out.description = description;
+  if (description !== undefined) {
+    out.description = description;
+  }
   const promptSnippet = nonEmptyString(g.promptSnippet);
-  if (promptSnippet !== undefined) out.promptSnippet = promptSnippet;
+  if (promptSnippet !== undefined) {
+    out.promptSnippet = promptSnippet;
+  }
   const guidelines = g.promptGuidelines;
   if (
     Array.isArray(guidelines) &&
     guidelines.length > 0 &&
     guidelines.every((s) => nonEmptyString(s) !== undefined)
   ) {
+    // SAFETY: guidelines elements are validated as non-empty strings above; preserving string array type is safe.
     out.promptGuidelines = guidelines as string[];
   }
   return out;
@@ -135,7 +214,9 @@ export function loadConfig(sources: ConfigSources): ConfigLoadResult {
   for (const path of configPaths(sources)) {
     const raw = readLayer(path, warnings);
     const collapseKey = nonEmptyString(raw.collapseKey);
-    if (collapseKey !== undefined) config.collapseKey = collapseKey;
+    if (collapseKey !== undefined) {
+      config.collapseKey = collapseKey;
+    }
     const guidance = validateGuidanceFields(raw.guidance);
     if (Object.keys(guidance).length > 0) {
       config.guidance = { ...config.guidance, ...guidance };
@@ -183,7 +264,9 @@ const SPECIAL_KEYS = new Set([
 const MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
 
 function isBaseKey(key: string): boolean {
-  if (key.length !== 1) return SPECIAL_KEYS.has(key);
+  if (key.length !== 1) {
+    return SPECIAL_KEYS.has(key);
+  }
   return (key >= "a" && key <= "z") || (key >= "0" && key <= "9") || SYMBOL_KEYS.has(key);
 }
 
@@ -199,12 +282,18 @@ function isBaseKey(key: string): boolean {
  * user types, anywhere.
  */
 function isValidCollapseKeySpec(spec: string): boolean {
-  if (!spec || spec.startsWith("+") || spec.endsWith("+") || spec.includes("++")) return false;
+  if (!spec || spec.startsWith("+") || spec.endsWith("+") || spec.includes("++")) {
+    return false;
+  }
   const parts = spec.split("+");
   const base = parts[parts.length - 1] ?? "";
   const modifiers = parts.slice(0, -1);
-  if (modifiers.length !== new Set(modifiers).size) return false;
-  if (!modifiers.every((m) => MODIFIERS.has(m))) return false;
+  if (modifiers.length !== new Set(modifiers).size) {
+    return false;
+  }
+  if (!modifiers.every((m) => MODIFIERS.has(m))) {
+    return false;
+  }
   return isBaseKey(base);
 }
 
@@ -220,17 +309,21 @@ export function resolveCollapseKey(config: {
   collapseKey?: CollapseKeySpec | undefined;
 }): CollapseKeySpec {
   const raw = config.collapseKey?.trim().toLowerCase();
-  if (raw === undefined || raw === "") return DEFAULT_COLLAPSE_KEY;
-  if (raw === COLLAPSE_KEY_OFF) return COLLAPSE_KEY_OFF;
+  if (raw === undefined || raw === "") {
+    return DEFAULT_COLLAPSE_KEY;
+  }
+  if (raw === COLLAPSE_KEY_OFF) {
+    return COLLAPSE_KEY_OFF;
+  }
   return isValidCollapseKeySpec(raw) ? raw : DEFAULT_COLLAPSE_KEY;
 }
 
 // The only compound-word names in SPECIAL_KEYS — capitalizing the first letter
 // alone would render them "Pageup" and "Pagedown".
-const COMPOUND_KEY_DISPLAY: Record<string, string> = {
+const COMPOUND_KEY_DISPLAY = {
   pageup: "PageUp",
   pagedown: "PageDown",
-};
+} satisfies Record<string, string>;
 
 /**
  * Pretty-print a resolved spec for UI copy: `"ctrl+]"` → `"Ctrl+]"`, `"alt+o"` →
@@ -241,10 +334,11 @@ const COMPOUND_KEY_DISPLAY: Record<string, string> = {
 export function formatKeySpecForDisplay(spec: CollapseKeySpec): string {
   return spec
     .split("+")
-    .map(
-      (part) =>
-        COMPOUND_KEY_DISPLAY[part] ??
-        (part.length <= 1 ? part.toUpperCase() : part.charAt(0).toUpperCase() + part.slice(1)),
-    )
+    .map((part) => {
+      if (part === "pageup" || part === "pagedown") {
+        return COMPOUND_KEY_DISPLAY[part];
+      }
+      return part.length <= 1 ? part.toUpperCase() : part.charAt(0).toUpperCase() + part.slice(1);
+    })
     .join("+");
 }

package/src/rpc-fallback.ts

@@ -56,12 +56,35 @@ export type DialogUI = {
   ) => Promise<string | undefined>;
 };
 
-/** Whether the host implements the select and input primitives. */
+/**
+ * Whether the host implements the select and input primitives.
+ *
+ * `typeof`, not `instanceof Function`: a method that arrives from another realm
+ * — an Electron context bridge, a VM context, a proxy around a host object — is
+ * callable but fails an `instanceof` against this realm's `Function`, and the
+ * walker would then decline a host that works.
+ */
 export function hasDialogUI(ui: unknown): ui is DialogUI {
-  const u = ui as Partial<Record<"select" | "input", unknown>> | null | undefined;
+  // SAFETY: safe cast — value is validated at boundary or test fixture with known shape.
+  const u = ui as Partial<DialogUI> | null | undefined;
   return typeof u?.select === "function" && typeof u?.input === "function";
 }
 
+/**
+ * What one native dialog produced.
+ *
+ * `dismissed` is the user pressing Esc, which cancels the questionnaire.
+ * `host_error` is the host replying with something it was never offered —
+ * neither a decision nor an answer, and the two must not collapse into one
+ * result, because a decline tells the model the user said no.
+ */
+type AskOutcome =
+  | { kind: "answer"; answer: QuestionAnswer }
+  | { kind: "dismissed" }
+  | { kind: "host_error"; detail: string };
+
+const DISMISSED: AskOutcome = { kind: "dismissed" };
+
 type Option = QuestionData["options"][number];
 
 function formatOptionLine(option: Option, index: number): string {
@@ -105,69 +128,92 @@ export async function runRpcQuestionnaire(
   const dialogOpts = params.timeout === undefined ? undefined : { timeout: params.timeout };
   for (let qi = 0; qi < params.questions.length; qi++) {
     const q = params.questions[qi];
-    if (!q) continue;
+    if (!q) {
+      continue;
+    }
     const header = q.header ? `[${q.header}] ` : "";
-    const answer = q.multiSelect
+    const outcome = q.multiSelect
       ? await askMultiSelect(ui, q, qi, header, dialogOpts)
       : await askSingleSelect(ui, q, qi, header, dialogOpts);
-    if (answer === undefined) return { answers, cancelled: true };
-    answers.push(answer);
+    if (outcome.kind === "dismissed") {
+      return { answers, cancelled: true };
+    }
+    if (outcome.kind === "host_error") {
+      return { answers, cancelled: true, error: "host_error", hostErrorDetail: outcome.detail };
+    }
+    answers.push(outcome.answer);
   }
   return { answers, cancelled: false };
 }
 
-/** Undefined means the user dismissed the dialog, which cancels everything. */
+/** Dismissal cancels everything; a reply outside the offered list is the host's fault. */
 async function askSingleSelect(
   ui: DialogUI,
   q: QuestionData,
   questionIndex: number,
   header: string,
   opts?: { timeout?: number; signal?: AbortSignal },
-): Promise<QuestionAnswer | undefined> {
+): Promise<AskOutcome> {
   const options = q.options.map(formatOptionLine);
   options.push(`${q.options.length + 1}. ${ROW_INTENT_META.other.label}`);
   const chosen = await ui.select(`${header}${q.question}${buildPreviewBlock(q)}`, options, opts);
-  if (chosen === undefined || chosen === null) return undefined;
+  if (chosen === undefined || chosen === null) {
+    return DISMISSED;
+  }
   const idx = parseIndex(chosen, options.length);
-  // A host that returns something outside the list it was given is
-  // indistinguishable from a dismissal. Treating it as one beats fabricating
-  // an answer the user never gave.
-  if (idx === null) return undefined;
+  // A host returning something outside the list it was given used to read as a
+  // dismissal, which told the model the user had declined. Nobody declined
+  // anything: the host is broken, or is rewriting the option text (a localising
+  // client will), and the model needs to hear which.
+  if (idx === null) {
+    return { kind: "host_error", detail: `selection not in the offered list: "${chosen}"` };
+  }
   const option = q.options[idx];
   if (option) {
-    return {
+    const answer: QuestionAnswer = {
       questionIndex,
       question: q.question,
       kind: "option",
       answer: option.label,
-      // Spread rather than assigned: the envelope's contract is that the key is
-      // absent when there was no preview, not present and undefined.
-      ...(option.preview !== undefined && option.preview.length > 0
-        ? { preview: option.preview }
-        : {}),
     };
+    if (option.preview !== undefined && option.preview.length > 0) {
+      // SAFETY: preview is an optional string; present only when non-empty per contract.
+      (answer as QuestionAnswer & { preview: string }).preview = option.preview;
+    }
+    return { kind: "answer", answer };
   }
   // The "Type something." row, which is the one index past the authored options.
   const typed = await ui.input(`${header}${q.question}\n\n${CUSTOM_ANSWER_TITLE}`, "", opts);
-  if (typed === undefined || typed === null) return undefined;
-  return { questionIndex, question: q.question, kind: "custom", answer: typed };
+  if (typed === undefined || typed === null) {
+    return DISMISSED;
+  }
+  return {
+    kind: "answer",
+    answer: { questionIndex, question: q.question, kind: "custom", answer: typed },
+  };
 }
 
-/** Undefined means the user dismissed the dialog, which cancels everything. */
+/**
+ * Dismissal cancels everything. Nothing else here can be a host error: the text
+ * comes from the user's own keyboard, so an out-of-range number like "13" on a
+ * three-option question is a typed answer, not a host returning garbage.
+ */
 async function askMultiSelect(
   ui: DialogUI,
   q: QuestionData,
   questionIndex: number,
   header: string,
   opts?: { timeout?: number; signal?: AbortSignal },
-): Promise<QuestionAnswer | undefined> {
+): Promise<AskOutcome> {
   const list = q.options.map(formatOptionLine).join("\n");
   const value = await ui.input(
     `${header}${q.question}\n\n${list}\n\n${MULTI_SELECT_INSTRUCTIONS}`,
     MULTI_SELECT_PLACEHOLDER,
     opts,
   );
-  if (value === undefined || value === null) return undefined;
+  if (value === undefined || value === null) {
+    return DISMISSED;
+  }
   const trimmed = value.trim();
   if (trimmed.length === 0) {
     // A deliberate empty commit, the same as pressing Next with nothing ticked.
@@ -176,7 +222,10 @@ async function askMultiSelect(
     // no tokens the `every` below is vacuously true and produces an empty
     // selection anyway. Removing this would leave an important behaviour
     // resting on that, and no test could tell the two apart.
-    return { questionIndex, question: q.question, kind: "multi", answer: null, selected: [] };
+    return {
+      kind: "answer",
+      answer: { questionIndex, question: q.question, kind: "multi", answer: null, selected: [] },
+    };
   }
   const tokens = trimmed.split(/[,\s]+/).filter((tok) => tok.length > 0);
   const indices = tokens.map((tok) =>
@@ -186,13 +235,21 @@ async function askMultiSelect(
     const selected: string[] = [];
     for (const i of indices) {
       const label = q.options[i]?.label;
-      if (label !== undefined && !selected.includes(label)) selected.push(label);
+      if (label !== undefined && !selected.includes(label)) {
+        selected.push(label);
+      }
     }
-    return { questionIndex, question: q.question, kind: "multi", answer: null, selected };
+    return {
+      kind: "answer",
+      answer: { questionIndex, question: q.question, kind: "multi", answer: null, selected },
+    };
   }
   // Any token that is not an index -- a word, or a number like "13" when there
   // are three options -- means the user typed an answer rather than picking
   // from the list. Keeping it verbatim is both the honest reading and the
   // multi-select half of the "Type something." escape.
-  return { questionIndex, question: q.question, kind: "custom", answer: trimmed };
+  return {
+    kind: "answer",
+    answer: { questionIndex, question: q.question, kind: "custom", answer: trimmed },
+  };
 }