@mrclrchtr/supi-ask-user 0.1.0 → 0.2.0

package/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,226 @@
+// Generic settings overlay for SuPi extensions.
+//
+// Uses pi-tui's SettingsList with scope toggle (Tab), extension grouping,
+// and search. Each extension declares its settings via registerSettings().
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+} from "@earendil-works/pi-tui";
+import {
+  getRegisteredSettings,
+  type SettingsScope,
+  type SettingsSection,
+} from "./settings-registry.ts";
+
+// ── Input submenu component ──────────────────────────────────
+
+/**
+ * Creates a pi-tui Input-backed submenu component with enter-to-confirm
+ * and escape-to-cancel handling.
+ *
+ * @param currentValue - Initial value for the text input.
+ * @param label - Label text displayed above the input.
+ * @param done - Callback invoked with the confirmed value, or undefined on cancel.
+ */
+export function createInputSubmenu(
+  currentValue: string,
+  label: string,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const input = new Input();
+  input.setValue(currentValue);
+
+  return {
+    render: (_width: number) => {
+      const lines = [`  ${label}`];
+      lines.push(...input.render(_width));
+      lines.push("  enter confirm • esc cancel");
+      return lines;
+    },
+    invalidate: () => {
+      input.invalidate();
+    },
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        done();
+        return true;
+      }
+      if (matchesKey(data, Key.enter)) {
+        done(input.getValue());
+        return true;
+      }
+      input.handleInput(data);
+      return true;
+    },
+  };
+}
+
+// ── Types ────────────────────────────────────────────────────
+
+interface OverlayState {
+  scope: SettingsScope;
+  cwd: string;
+}
+
+// ── Pure helpers ─────────────────────────────────────────────
+
+function getScopeLabel(scope: SettingsScope): string {
+  return scope === "project" ? "Project" : "Global";
+}
+
+function buildFlatItems(
+  sections: SettingsSection[],
+  scope: SettingsScope,
+  cwd: string,
+): SettingItem[] {
+  const items: SettingItem[] = [];
+  for (const section of sections) {
+    const sectionItems = section.loadValues(scope, cwd);
+    for (const item of sectionItems) {
+      items.push({
+        ...item,
+        id: `${section.id}.${item.id}`,
+        label: `${section.label}: ${item.label}`,
+      });
+    }
+  }
+  return items;
+}
+
+function findSectionAndId(
+  sections: SettingsSection[],
+  flatId: string,
+): { section: SettingsSection; itemId: string } | null {
+  const dotIndex = flatId.indexOf(".");
+  if (dotIndex === -1) return null;
+  const sectionId = flatId.slice(0, dotIndex);
+  const itemId = flatId.slice(dotIndex + 1);
+  const section = sections.find((s) => s.id === sectionId);
+  if (!section) return null;
+  return { section, itemId };
+}
+
+// ── Component ────────────────────────────────────────────────
+
+interface SettingsOverlayDeps {
+  state: OverlayState;
+  container: Container;
+  settingsList: SettingsList | null;
+  tui: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[0];
+  theme: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[1];
+  done: () => void;
+}
+
+function createSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const sections = getRegisteredSettings();
+  const items = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+  const onChange = (flatId: string, newValue: string) => {
+    const found = findSectionAndId(sections, flatId);
+    if (found) {
+      found.section.persistChange(deps.state.scope, deps.state.cwd, found.itemId, newValue);
+    }
+    // Re-read all values to reflect persisted changes, but keep the list
+    // instance (and its selectedIndex) intact.
+    const updatedItems = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+    for (const updated of updatedItems) {
+      const existing = items.find((i) => i.id === updated.id);
+      if (existing && existing.currentValue !== updated.currentValue) {
+        settingsList.updateValue(updated.id, updated.currentValue);
+      }
+    }
+    deps.tui.requestRender();
+  };
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 4, 20),
+    getSettingsListTheme(),
+    onChange,
+    () => deps.done(),
+    { enableSearch: true },
+  );
+  return settingsList;
+}
+
+function rebuildSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const settingsList = createSettingsList(deps);
+  deps.settingsList = settingsList;
+
+  deps.container.clear();
+  deps.container.addChild(createHeaderComponent(deps));
+  deps.container.addChild(settingsList);
+
+  return settingsList;
+}
+
+function createHeaderComponent(deps: SettingsOverlayDeps): Text {
+  const { theme, state } = deps;
+  const scopeLabel = getScopeLabel(state.scope);
+  const otherScope = state.scope === "project" ? "Global" : "Project";
+  const headerText = new Text(
+    `${theme.fg("accent", theme.bold("SuPi Settings"))}  ${theme.fg("text", `Scope: ${scopeLabel}`)} ${theme.fg("dim", `(tab → ${otherScope})`)}`,
+    0,
+    0,
+  );
+  return headerText;
+}
+
+function handleScopeToggle(deps: SettingsOverlayDeps): void {
+  deps.state.scope = deps.state.scope === "project" ? "global" : "project";
+  rebuildSettingsList(deps);
+  deps.tui.requestRender();
+}
+
+// ── Entry point ──────────────────────────────────────────────
+
+export function openSettingsOverlay(ctx: ExtensionContext): void {
+  const sections = getRegisteredSettings();
+  if (sections.length === 0) {
+    ctx.ui.notify("No settings registered by SuPi extensions", "info");
+    return;
+  }
+
+  void ctx.ui.custom<void>((tui, theme, _kb, done) => {
+    const state: OverlayState = { scope: "project", cwd: ctx.cwd };
+    const container = new Container();
+
+    const deps: SettingsOverlayDeps = {
+      state,
+      container,
+      settingsList: null,
+      tui,
+      theme,
+      done,
+    };
+
+    rebuildSettingsList(deps);
+
+    const component = {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.tab)) {
+          handleScopeToggle(deps);
+          return true;
+        }
+        // Delegate input to the settings list (always set after rebuildSettingsList)
+        deps.settingsList?.handleInput?.(data);
+        deps.tui.requestRender();
+        return true;
+      },
+    };
+
+    return component;
+  });
+}

package/node_modules/@mrclrchtr/supi-core/src/terminal.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared terminal title formatting and signaling utilities.
+ *
+ * Centralized place for pi title convention (π prefix), completion (✓)
+ * and waiting (●) indicators, and the audible terminal bell.
+ */
+import path from "node:path";
+
+/** Unicode checkmark shown when the agent finishes a turn. */
+export const DONE_SYMBOL = "\u2713";
+/** Unicode dot shown when waiting for user input. */
+export const WAITING_SYMBOL = "\u25CF";
+
+/** Minimal UI surface needed for title operations. */
+export interface TitleTarget {
+  ui: {
+    setTitle?(title: string): void;
+  };
+}
+
+/**
+ * Format pi's canonical terminal title from session name and cwd.
+ * Falls back gracefully when either is missing.
+ *
+ * @example
+ *   formatTitle("my-session", "/home/projects/foo")  // "π - my-session - foo"
+ *   formatTitle(undefined, "/home/projects/foo")      // "π - foo"
+ *   formatTitle("my-session")                         // "π - my-session"
+ *   formatTitle()                                     // "π"
+ */
+export function formatTitle(sessionName?: string, cwd?: string): string {
+  const base = cwd ? path.basename(cwd) : undefined;
+  if (sessionName && base) return `π - ${sessionName} - ${base}`;
+  if (sessionName) return `π - ${sessionName}`;
+  if (base) return `π - ${base}`;
+  return "π";
+}
+
+/** Sound the audible terminal bell (ASCII BEL). */
+export function signalBell(): void {
+  process.stdout.write("\x07");
+}
+
+/**
+ * Set the terminal title to indicate the agent is waiting for user input.
+ * Prefixes with ● and sounds the terminal bell.
+ */
+export function signalWaiting(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${WAITING_SYMBOL}  ${title}`);
+  signalBell();
+}
+
+/**
+ * Set the terminal title to indicate the agent turn has completed.
+ * Prefixes with ✓ and sounds the terminal bell.
+ */
+export function signalDone(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${DONE_SYMBOL} ${title}`);
+  signalBell();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-ask-user",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "SuPi ask-user extension — rich questionnaire UI for structured agent-user decisions",
   "license": "MIT",
   "repository": {
@@ -16,20 +16,27 @@
     "pi-coding-agent"
   ],
   "files": [
-    "*.ts",
+    "src/**/*.ts",
     "!__tests__"
   ],
+  "main": "src/index.ts",
+  "dependencies": {
+    "@mrclrchtr/supi-core": "workspace:*"
+  },
+  "bundledDependencies": [
+    "@mrclrchtr/supi-core"
+  ],
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "~0.66.0",
-    "@mariozechner/pi-tui": "~0.66.0",
-    "@sinclair/typebox": ">=0.34.0"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "devDependencies": {
-    "vitest": "^4.1.4"
+    "vitest": "4.1.5"
   },
   "pi": {
     "extensions": [
-      "./ask-user.ts"
+      "./src/ask-user.ts"
     ]
   }
 }

package/src/ask-user.ts

@@ -0,0 +1,191 @@
+// `ask_user` extension entry point. Registers a single model-callable tool
+// for focused interactive decisions during an agent run. Holds the per-session
+// single-active-questionnaire lock and drives the rich overlay UI.
+//
+// Implementation modules:
+//   schema.ts           — external (LLM-facing) parameter schema
+//   normalize.ts        — validation + normalization into the shared internal model
+//   flow.ts             — shared questionnaire flow + concurrency lock
+//   ui-rich.ts          — overlay UI via ctx.ui.custom()
+//   ui-rich-render.ts   — overlay rendering helpers
+//   result.ts           — hybrid (content + details) result formatting
+//   render.ts           — custom renderCall / renderResult for the transcript
+
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { formatTitle, signalWaiting } from "@mrclrchtr/supi-core";
+import { ActiveQuestionnaireLock } from "./flow.ts";
+import { AskUserValidationError, normalizeQuestionnaire } from "./normalize.ts";
+import { renderAskUserCall, renderAskUserResult } from "./render.ts";
+import { buildErrorResult, buildResult, type HybridResult } from "./result.ts";
+import { type AskUserParams, AskUserParamsSchema } from "./schema.ts";
+import type { NormalizedQuestionnaire } from "./types.ts";
+import { type RichUiHost, runRichQuestionnaire } from "./ui/ui-rich.ts";
+
+const TOOL_NAME = "ask_user";
+const TOOL_LABEL = "Ask User";
+
+const TOOL_DESCRIPTION =
+  "Ask the user a focused decision question (or up to 4 grouped questions) when explicit user input is required to proceed safely. Use for clarifying intent, picking between options, prioritizing a short set of features, or confirming a destructive action — not for surveys or open-ended discovery. Questions are `choice` (with options; set `multi: true` for multi-select) or `text` (freeform input). Structured questions can add `recommendation`, `default`, `allowOther`, `allowDiscuss`, and option `preview` content.";
+
+const PROMPT_SNIPPET =
+  "ask_user — pause and request a focused decision (1-4 typed questions) when explicit user input is required to proceed, including rich choice and discuss flows";
+
+const PROMPT_GUIDELINES = [
+  "Use ask_user only for decisions that require explicit user input — never as a substitute for reading code or thinking through a problem.",
+  "Keep questionnaires bounded: 1-4 focused questions with short headers; prefer one decision per call when possible.",
+  'There are two question types: `choice` for picking from options (single-select by default; set `multi: true` for multi-select — use this instead of the now-removed `multichoice`) and `text` for freeform input. For yes/no questions, use `choice` with options `{value: "yes", label: "Yes"}` and `{value: "no", label: "No"}`.',
+  "Set `recommendation` when one option or a small set of options is clearly preferable, so the UI can surface that guidance.",
+  "Set `default` to pre-select a starting value or option; the user can accept it with a single keystroke. Use it for safe/common defaults, distinct from `recommendation` which highlights what you think is best.",
+  "Enable `allowOther` only when a custom answer is genuinely useful, and `allowDiscuss` only when the user may need to talk through the choice instead of deciding immediately.",
+  "Use `description` to explain what each option means — it wraps naturally and a few sentences is fine. Reserve `preview` for code, config, or diagrams that need dedicated rendering space in a side pane.",
+  "Do not call ask_user while another ask_user interaction is in flight — wait for the previous result before issuing another.",
+];
+
+/** Minimal ui subset needed by executeAskUser — extended with setTitle/notify from ExtensionUIContext. */
+interface ExtensionUi {
+  ui: {
+    custom?: RichUiHost["custom"];
+    setWorkingVisible?(visible: boolean): void;
+    /** Set the terminal window/tab title. */
+    setTitle?(title: string): void;
+    /** Show a notification to the user. */
+    notify?(message: string, type?: "info" | "warning" | "error"): void;
+  };
+  /**
+   * Absolute path to the current working directory, available on the full
+   * ExtensionContext. Marked optional here to tolerate partial mocks.
+   */
+  cwd?: string;
+  hasUI: boolean;
+  abort(): void;
+}
+
+export default function askUserExtension(pi: ExtensionAPI): void {
+  const lock = new ActiveQuestionnaireLock();
+
+  pi.registerTool({
+    name: TOOL_NAME,
+    label: TOOL_LABEL,
+    description: TOOL_DESCRIPTION,
+    promptSnippet: PROMPT_SNIPPET,
+    promptGuidelines: PROMPT_GUIDELINES,
+    parameters: AskUserParamsSchema,
+    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      return executeAskUser(
+        params as AskUserParams,
+        signal,
+        ctx as unknown as ExtensionUi,
+        lock,
+        pi,
+      );
+    },
+    renderCall: (args, theme) => renderAskUserCall(args, theme as Theme),
+    renderResult: (result, _options, theme) =>
+      renderAskUserResult(
+        result as { details?: unknown; content: { type: string; text?: string }[] },
+        theme as Theme,
+      ) as unknown as Component,
+  });
+}
+
+// biome-ignore lint/complexity/useMaxParams: pi context + pi reference for appendEntry
+async function executeAskUser(
+  params: AskUserParams,
+  signal: AbortSignal | undefined,
+  ctx: ExtensionUi,
+  lock: ActiveQuestionnaireLock,
+  pi: ExtensionAPI,
+): Promise<HybridResult> {
+  let normalized: NormalizedQuestionnaire;
+  try {
+    normalized = normalizeQuestionnaire(params);
+  } catch (err) {
+    if (err instanceof AskUserValidationError) return buildErrorResult(`Error: ${err.message}`);
+    throw err;
+  }
+  if (!ctx.hasUI) {
+    return buildErrorResult(
+      "Error: ask_user requires interactive UI but the current session has none.",
+    );
+  }
+  if (!lock.acquire()) {
+    return buildErrorResult(
+      "Error: another ask_user interaction is already in flight. Wait for it to complete before calling ask_user again.",
+    );
+  }
+  signalAttention(ctx);
+  pi.events.emit("supi:ask-user:start", { source: "supi-ask-user" });
+  try {
+    // Hide the built-in working loader so it doesn't compete with the overlay.
+    ctx.ui.setWorkingVisible?.(false);
+    const result = await driveQuestionnaire(normalized, signal, ctx);
+    if (
+      result.details.terminalState !== "submitted" &&
+      result.details.terminalState !== "skipped"
+    ) {
+      ctx.abort();
+    }
+    // Append a tree-friendly custom entry so /tree shows a readable
+    // summary (question headers) instead of raw JSON tool-call arguments.
+    // Custom entries are hidden in the default tree filter, visible in
+    // "all" mode (Ctrl+O).
+    pi.appendEntry(treeSummaryLabel(normalized));
+    return result;
+  } finally {
+    // Restore the working loader regardless of how the overlay closed.
+    ctx.ui.setWorkingVisible?.(true);
+    pi.events.emit("supi:ask-user:end", { source: "supi-ask-user" });
+    restoreTerminalTitle(ctx, pi);
+    lock.release();
+  }
+}
+
+/** Set terminal title and play alert bell to signal the user needs to respond. */
+function signalAttention(ctx: ExtensionUi): void {
+  signalWaiting(ctx, `pi — waiting for your input`);
+}
+
+/** Restore the terminal title to pi's native format (session name + cwd). */
+function restoreTerminalTitle(ctx: ExtensionUi, pi: ExtensionAPI): void {
+  ctx.ui.setTitle?.(formatTitle(pi.getSessionName(), ctx.cwd));
+}
+
+/** Build a concise custom-entry label readable in the /tree "all" filter. */
+function treeSummaryLabel(q: NormalizedQuestionnaire): string {
+  const count = q.questions.length;
+  const s = count === 1 ? "" : "s";
+  const headers = q.questions.map((q) => q.header).join(", ");
+  if (headers.length > 70) {
+    return `ask_user · ${count} question${s} · ${headers.slice(0, 67)}...`;
+  }
+  return `ask_user · ${count} question${s} · ${headers}`;
+}
+
+async function driveQuestionnaire(
+  questionnaire: NormalizedQuestionnaire,
+  signal: AbortSignal | undefined,
+  ctx: ExtensionUi,
+): Promise<HybridResult> {
+  const questions = questionnaire.questions;
+  if (typeof ctx.ui.custom !== "function") {
+    return buildErrorResult(
+      "Error: ask_user requires a TUI with custom overlay support. Do not use ask_user in non-interactive or degraded UI sessions.",
+    );
+  }
+  const richHost: RichUiHost = { custom: ctx.ui.custom.bind(ctx.ui) };
+  const outcome = await runRichQuestionnaire(questionnaire, { ui: richHost, signal });
+  if (outcome === "unsupported") {
+    return buildErrorResult(
+      "Error: ask_user requires a TUI with custom overlay support. Do not use ask_user in non-interactive or degraded UI sessions.",
+    );
+  }
+  return buildResult(questions, outcome);
+}
+
+export { ActiveQuestionnaireLock, QuestionnaireFlow } from "./flow.ts";
+// Re-exports used by tests.
+export { AskUserValidationError, normalizeQuestionnaire } from "./normalize.ts";
+export { buildResult } from "./result.ts";
+export { PROMPT_GUIDELINES as askUserPromptGuidelines, PROMPT_SNIPPET as askUserPromptSnippet };

package/{flow.ts → src/flow.ts}

@@ -1,7 +1,7 @@
-// Shared questionnaire flow state used by both UI paths and the
+// Shared questionnaire flow state used by the overlay UI and the
 // single-active-questionnaire concurrency guard. The flow owns terminal-state
-// transitions (`submitted`, `cancelled`, `aborted`) so overlay and fallback
-// cannot drift apart on cancellation/abort semantics.
+// transitions (`submitted`, `cancelled`, `aborted`) to keep cancellation/abort
+// semantics consistent.
 
 import type { Answer, NormalizedQuestion, QuestionnaireOutcome, TerminalState } from "./types.ts";
 import { needsReview } from "./types.ts";
@@ -14,12 +14,23 @@ export class QuestionnaireFlow {
   private mode: FlowMode = "answering";
   private terminalState: TerminalState | null = null;
 
-  constructor(public readonly questions: NormalizedQuestion[]) {
+  constructor(
+    public readonly questions: NormalizedQuestion[],
+    public readonly allowSkip = false,
+  ) {
     if (questions.length === 0) {
       throw new Error("QuestionnaireFlow requires at least one question.");
     }
   }
 
+  get hasOptionalQuestions(): boolean {
+    return this.questions.some((q) => !q.required);
+  }
+
+  get showSkip(): boolean {
+    return this.allowSkip || this.hasOptionalQuestions;
+  }
+
   get currentIndex(): number {
     return this.index;
   }
@@ -48,6 +59,10 @@ export class QuestionnaireFlow {
     return this.questions.every((q) => this.answers.has(q.id));
   }
 
+  allRequiredAnswered(): boolean {
+    return this.questions.every((q) => !q.required || this.answers.has(q.id));
+  }
+
   setAnswer(answer: Answer): void {
     this.answers.set(answer.questionId, normalizeAnswer(answer));
   }
@@ -55,7 +70,7 @@ export class QuestionnaireFlow {
   advance(): boolean {
     if (this.mode !== "answering") return false;
     const current = this.currentQuestion;
-    if (current && !this.answers.has(current.id)) return false;
+    if (current?.required && !this.answers.has(current.id)) return false;
     if (this.index < this.questions.length - 1) {
       this.index += 1;
       return true;
@@ -69,7 +84,7 @@ export class QuestionnaireFlow {
   }
 
   goBack(): boolean {
-    if (this.mode === "terminal") return false;
+    if (!this.guardNotTerminal()) return false;
     if (this.mode === "reviewing") {
       this.mode = "answering";
       this.index = this.questions.length - 1;
@@ -83,28 +98,35 @@ export class QuestionnaireFlow {
   }
 
   enterReview(): boolean {
-    if (this.mode === "terminal") return false;
+    if (!this.guardNotTerminal()) return false;
     if (!needsReview(this.questions)) return false;
-    if (!this.allAnswered()) return false;
+    if (!this.allRequiredAnswered()) return false;
     this.mode = "reviewing";
     return true;
   }
 
   submit(): boolean {
-    if (this.mode === "terminal") return false;
-    if (!this.allAnswered()) return false;
+    if (!this.guardNotTerminal()) return false;
+    if (!this.allRequiredAnswered()) return false;
     this.markSubmitted();
     return true;
   }
 
+  skip(): boolean {
+    if (!this.guardNotTerminal()) return false;
+    this.mode = "terminal";
+    this.terminalState = "skipped";
+    return true;
+  }
+
   cancel(): void {
-    if (this.mode === "terminal") return;
+    if (!this.guardNotTerminal()) return;
     this.mode = "terminal";
     this.terminalState = "cancelled";
   }
 
   abort(): void {
-    if (this.mode === "terminal") return;
+    if (!this.guardNotTerminal()) return;
     this.mode = "terminal";
     this.terminalState = "aborted";
   }
@@ -117,10 +139,18 @@ export class QuestionnaireFlow {
     const state = this.terminalState ?? "cancelled";
     return {
       terminalState: state,
-      answers: state === "submitted" ? this.collectAnswers() : [...this.answers.values()],
+      answers:
+        state === "submitted" || state === "skipped"
+          ? this.collectAnswers()
+          : [...this.answers.values()],
+      ...(state === "skipped" ? { skipped: true } : {}),
     };
   }
 
+  private guardNotTerminal(): boolean {
+    return this.mode !== "terminal";
+  }
+
   private markSubmitted(): void {
     this.mode = "terminal";
     this.terminalState = "submitted";
@@ -136,20 +166,10 @@ export class QuestionnaireFlow {
 
 function normalizeAnswer(answer: Answer): Answer {
   switch (answer.source) {
-    case "option":
+    case "choice":
       return {
         questionId: answer.questionId,
-        source: "option",
-        value: answer.value.trim(),
-        optionIndex: answer.optionIndex,
-        note: trimOptional(answer.note),
-      };
-    case "options":
-      return {
-        questionId: answer.questionId,
-        source: "options",
-        values: answer.values.map((value) => value.trim()),
-        optionIndexes: [...answer.optionIndexes],
+        source: "choice",
         selections: answer.selections.map((selection) => ({
           value: selection.value.trim(),
           optionIndex: selection.optionIndex,
@@ -174,14 +194,6 @@ function normalizeAnswer(answer: Answer): Answer {
         source: "text",
         value: answer.value.trim(),
       };
-    case "yesno":
-      return {
-        questionId: answer.questionId,
-        source: "yesno",
-        value: answer.value,
-        optionIndex: answer.optionIndex,
-        note: trimOptional(answer.note),
-      };
   }
 }