pi-pier 0.2.7 → 0.3.1

package/src/ask-dialog.ts

@@ -0,0 +1,308 @@
+/**
+ * ask_user_question dialog: one pier-owned selector for single- and multi-select questions, rendered
+ * through `ctx.ui.custom`. Both modes share it so the chrome — border rules, accent+bold title,
+ * `→ ` cursor, dim descriptions, keyHint footer — cannot diverge; only the checkbox column, the
+ * hints and the selection counter are mode-specific.
+ */
+import { styledWidth, truncateStyled, wrapStyled } from './ansi-text.ts';
+
+/** Label of the trailing free-text row; ask-user reuses it for the typed fallback list. */
+export const OTHER_ROW_LABEL = 'Other (type your own)';
+
+/** Marker the UI appends to the recommended row; the typed fallback list uses the same one. */
+export const RECOMMENDED_SUFFIX = ' (Recommended)';
+
+interface DialogOption {
+  label: string;
+  description?: string;
+}
+
+export interface DialogConfig {
+  options: readonly DialogOption[];
+  allowOther: boolean;
+  /** 0-based recommended option: the cursor starts on it, and multi mode also starts with it
+   *  checked so a bare enter agrees with single mode in both modes. */
+  recommended?: number;
+  /** true = toggle list (space toggles, enter confirms the set); false = pick-one (enter/space takes the cursor row). */
+  multi: boolean;
+}
+
+export interface DialogState {
+  /** Cursor row: 0..options.length-1 are choices, options.length is the Other row. */
+  cursor: number;
+  /** Toggle state per authored option (never includes the Other row). */
+  selected: readonly boolean[];
+}
+
+type DialogKey = 'up' | 'down' | 'toggle' | 'confirm' | 'cancel' | 'all' | 'ignore';
+
+export type DialogOutcome =
+  | { kind: 'selected'; labels: string[] }
+  | { kind: 'other' }
+  | { kind: 'cancel' };
+
+export interface DialogStep {
+  state: DialogState;
+  outcome?: DialogOutcome;
+}
+
+export function createDialogState(config: DialogConfig): DialogState {
+  const hasRecommended =
+    config.recommended !== undefined
+    && config.recommended >= 0
+    && config.recommended < config.options.length;
+  const start = hasRecommended ? config.recommended! : 0;
+  return {
+    cursor: start,
+    selected: config.options.map((_, i) => config.multi && hasRecommended && i === start),
+  };
+}
+
+export function rowCount(config: DialogConfig): number {
+  return config.options.length + (config.allowOther ? 1 : 0);
+}
+
+export function isOtherRow(state: DialogState, config: DialogConfig): boolean {
+  return config.allowOther && state.cursor === config.options.length;
+}
+
+export function selectedLabels(state: DialogState, config: DialogConfig): string[] {
+  const labels: string[] = [];
+  config.options.forEach((option, i) => {
+    if (state.selected[i]) labels.push(option.label);
+  });
+  return labels;
+}
+
+/** Apply one key. A returned outcome ends the interaction. */
+export function stepDialog(state: DialogState, key: DialogKey, config: DialogConfig): DialogStep {
+  const rows = rowCount(config);
+  if (rows === 0) return key === 'cancel' ? { state, outcome: { kind: 'cancel' } } : { state };
+  switch (key) {
+    case 'cancel':
+      return { state, outcome: { kind: 'cancel' } };
+    case 'up':
+    case 'down': {
+      const delta = key === 'up' ? -1 : 1;
+      const cursor = (state.cursor + delta + rows) % rows;
+      return { state: { ...state, cursor } };
+    }
+    case 'all': {
+      if (!config.multi) return { state };
+      const anyUnselected = state.selected.some((v) => !v);
+      return { state: { ...state, selected: state.selected.map(() => anyUnselected) } };
+    }
+    case 'toggle':
+    case 'confirm': {
+      if (isOtherRow(state, config)) return { state, outcome: { kind: 'other' } };
+      if (!config.multi) {
+        // Pick-one: enter and space both take the cursor row.
+        return { state, outcome: { kind: 'selected', labels: [config.options[state.cursor]!.label] } };
+      }
+      if (key === 'toggle') {
+        const selected = state.selected.map((v, i) => (i === state.cursor ? !v : v));
+        return { state: { ...state, selected } };
+      }
+      // Enter on a choice row confirms the current toggles; a single-choice
+      // question needs no separate space press.
+      if (config.options.length === 1) {
+        return { state, outcome: { kind: 'selected', labels: [config.options[0]!.label] } };
+      }
+      return { state, outcome: { kind: 'selected', labels: selectedLabels(state, config) } };
+    }
+    default:
+      return { state };
+  }
+}
+
+/** The slice of pi's KeybindingsManager custom factories receive as 3rd arg. */
+export interface KeybindingsLike {
+  matches(data: string, keybinding: string): boolean;
+  getKeys(keybinding: string): string[];
+}
+
+/** Key resolution, in order (first match wins). `binding` is the host action id consulted when the
+ *  factory received a keybindings manager; `sequences` are the raw fallbacks used when it did not
+ *  (older hosts, tests). Mirrors pi's defaults, plus j/k for vim keys; `toggle` has no pi action. */
+const KEY_RESOLUTION: ReadonlyArray<{ key: DialogKey; binding?: string; sequences: readonly string[] }> = [
+  { key: 'up', binding: 'tui.select.up', sequences: ['\x1b[A', '\x1bOA', 'k'] },
+  { key: 'down', binding: 'tui.select.down', sequences: ['\x1b[B', '\x1bOB', 'j'] },
+  { key: 'toggle', sequences: [' '] },
+  { key: 'confirm', binding: 'tui.select.confirm', sequences: ['\r', '\n'] },
+  { key: 'cancel', binding: 'tui.select.cancel', sequences: ['\x1b', '\x03'] },
+];
+
+export function resolveDialogKey(data: string, keybindings?: KeybindingsLike): DialogKey {
+  for (const entry of KEY_RESOLUTION) {
+    if (entry.binding !== undefined && keybindings?.matches?.(data, entry.binding) === true) return entry.key;
+    if (entry.sequences.includes(data)) return entry.key;
+  }
+  return data === 'a' || data === 'A' ? 'all' : 'ignore';
+}
+
+export interface MinimalTheme {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+}
+
+interface DialogComponent {
+  render(width: number): string[];
+  handleInput(data: string): void;
+  invalidate(): void;
+}
+
+interface DialogUiOptions {
+  title: string;
+  config: DialogConfig;
+  theme: MinimalTheme;
+  keybindings?: KeybindingsLike;
+  /** Aborting cancels the dialog so the ask tool result and herdr gate settle. */
+  signal?: AbortSignal;
+  /** pi's ctrl+o tool-output expansion, when the host exposes it. */
+  toggleToolsExpanded?: () => void;
+  done(outcome: DialogOutcome): void;
+  requestRender?: () => void;
+}
+
+/** Numbered line for the typed-prompt fallback list (`1. Label (Recommended) — description`); the dialog
+ *  itself renders unnumbered rows. */
+export function numberedOptionLine(option: DialogOption, index: number, recommended?: number): string {
+  const marker = recommended === index ? RECOMMENDED_SUFFIX : '';
+  const description = option.description ? ` — ${option.description}` : '';
+  return `${index + 1}. ${option.label}${marker}${description}`;
+}
+
+export function dialogLines(state: DialogState, config: DialogConfig, theme: MinimalTheme): string[] {
+  const lines: string[] = [];
+  config.options.forEach((option, i) => {
+    const onCursor = i === state.cursor;
+    const cursor = onCursor ? theme.fg('accent', '→ ') : '  ';
+    const label = `${option.label}${config.recommended === i ? RECOMMENDED_SUFFIX : ''}`;
+    const desc = option.description ? theme.fg('dim', ` — ${option.description}`) : '';
+    if (config.multi) {
+      const box = state.selected[i] ? theme.fg('success', '[x]') : '[ ]';
+      const styled = state.selected[i] ? theme.bold(label) : label;
+      lines.push(`${cursor}${box} ${styled}${desc}`);
+    } else {
+      // Pick-one highlights the whole row — enter takes exactly what is lit.
+      const styled = onCursor ? theme.fg('accent', label) : label;
+      lines.push(`${cursor}${styled}${desc}`);
+    }
+  });
+  if (config.allowOther) {
+    const cursor = isOtherRow(state, config) ? theme.fg('accent', '→ ') : '  ';
+    const row = config.multi ? `[ ] ${OTHER_ROW_LABEL}` : OTHER_ROW_LABEL;
+    lines.push(`${cursor}${theme.fg('dim', row)}`);
+  }
+  return lines;
+}
+
+/** keyHint style shared with pi's selector: dim key + muted verb. */
+function hint(theme: MinimalTheme, key: string, verb: string): string {
+  return theme.fg('dim', key) + theme.fg('muted', ` ${verb}`);
+}
+
+function displayKeys(keybindings: KeybindingsLike | undefined, id: 'confirm' | 'cancel', fallback: string): string {
+  const keys = keybindings?.getKeys?.(`tui.select.${id}`);
+  return keys && keys.length > 0 ? keys.join('/') : fallback;
+}
+
+export function dialogFooter(
+  state: DialogState,
+  config: DialogConfig,
+  theme: MinimalTheme,
+  keybindings?: KeybindingsLike,
+  width?: number,
+): string {
+  const confirm = displayKeys(keybindings, 'confirm', 'enter');
+  const cancel = displayKeys(keybindings, 'cancel', 'escape/ctrl+c');
+  const picked = selectedLabels(state, config).length;
+  const chip = config.multi && picked > 0 ? theme.fg('success', ` · ${picked} selected`) : '';
+  const navigate = hint(theme, '↑↓', 'navigate');
+  const toggle = hint(theme, 'space', 'toggle');
+  const all = hint(theme, 'a', 'all');
+  const action = hint(theme, confirm, config.multi ? 'confirm' : 'select');
+  const cancelHint = hint(theme, cancel, 'cancel');
+  const parts = config.multi ? [navigate, toggle, all, action, cancelHint] : [navigate, action, cancelHint];
+  const fits = (segs: string[]): boolean => styledWidth(segs.join('  ') + chip) <= (width ?? Infinity);
+  // Narrow panes shed the most guessable extras first; the action keys and the live count are the floor.
+  for (const droppable of config.multi ? [all, navigate, cancelHint] : [navigate]) {
+    if (fits(parts)) break;
+    parts.splice(parts.indexOf(droppable), 1);
+  }
+  return parts.join('  ') + chip;
+}
+
+export function createDialogComponent(opts: DialogUiOptions): DialogComponent {
+  let state = createDialogState(opts.config);
+  let finished = false;
+  const onAbort = (): void => finish({ kind: 'cancel' });
+  function finish(outcome: DialogOutcome): void {
+    if (finished) return;
+    finished = true;
+    opts.signal?.removeEventListener('abort', onAbort);
+    opts.done(outcome);
+  }
+  if (opts.signal) opts.signal.addEventListener('abort', onAbort, { once: true });
+  return {
+    render(width: number): string[] {
+      const border = opts.theme.fg('border', '─'.repeat(Math.max(1, width)));
+      // Content wraps inside a 1-col margin each side (like pi's Text(text, 1, 0)) instead of clipping.
+      const inner = Math.max(1, width - 2);
+      const pad = (line: string): string => ` ${line}`;
+      return [
+        border,
+        '',
+        ...wrapStyled(opts.theme.fg('accent', opts.theme.bold(opts.title)), inner).map(pad),
+        '',
+        ...dialogLines(state, opts.config, opts.theme)
+          .flatMap((row) => wrapStyled(row, inner))
+          .map(pad),
+        '',
+        truncateStyled(` ${dialogFooter(state, opts.config, opts.theme, opts.keybindings, inner)}`, width),
+        '',
+        border,
+      ];
+    },
+    handleInput(data: string): void {
+      if (finished) return;
+      if (opts.keybindings?.matches?.(data, 'app.tools.expand') === true) {
+        opts.toggleToolsExpanded?.();
+        return;
+      }
+      const key = resolveDialogKey(data, opts.keybindings);
+      if (key === 'ignore') return;
+      const next = stepDialog(state, key, opts.config);
+      state = next.state;
+      opts.requestRender?.();
+      if (next.outcome) finish(next.outcome);
+    },
+    invalidate(): void { /* No cached lines. */ },
+  };
+}
+
+/** Run the dialog through `ctx.ui.custom`. Returns null when the host cannot render custom components
+ *  (RPC mode / older pi), so the caller can fall back to the select dialog or the typed prompt. */
+export async function runSelectDialog(
+  custom: (factory: unknown) => Promise<unknown>,
+  title: string,
+  config: DialogConfig,
+  options?: { signal?: AbortSignal; toggleToolsExpanded?: () => void },
+): Promise<DialogOutcome | null> {
+  if (options?.signal?.aborted) return { kind: 'cancel' };
+  const result = await custom((tui: unknown, theme: unknown, keybindings: unknown, done: (value: unknown) => void) =>
+    createDialogComponent({
+      title,
+      config,
+      theme: theme as MinimalTheme,
+      keybindings: keybindings as KeybindingsLike | undefined,
+      signal: options?.signal,
+      toggleToolsExpanded: options?.toggleToolsExpanded,
+      done: (outcome) => done(outcome),
+      requestRender: () => (tui as { requestRender?: () => void } | undefined)?.requestRender?.(),
+    }));
+  if (result === undefined || result === null) return null;
+  const outcome = result as DialogOutcome;
+  if (outcome.kind === 'cancel' || outcome.kind === 'other' || outcome.kind === 'selected') return outcome;
+  return null;
+}

package/src/ask-user.ts

@@ -1,29 +1,31 @@
 /**
- * ask_user_question I/O: normalize params, select+Other dialog, result envelope.
- *
- * Why: the herdr gate (blocked / pi-ask / widget collapse) stays in index.ts.
- * This module is the questionnaire — authored options plus a runtime Other row —
- * so the model cannot forget a free-text escape and Esc is a real decline.
+ * ask_user_question I/O: normalize params, select+Other dialog, result envelope. The herdr gate
+ * (blocked / pi-ask / widget collapse) stays in index.ts; this module owns the questionnaire — authored
+ * options plus a runtime Other row, so the model cannot forget a free-text escape and Esc is a real decline.
  */
 import { Type } from 'typebox';
+import { OTHER_ROW_LABEL, numberedOptionLine, runSelectDialog } from './ask-dialog.ts';
 
 export const ASK_TOOL_NAME = 'ask_user_question';
-export const OTHER_OPTION = 'Other (type your own)';
-export const OTHER_ANSWER = 'Other';
-export const RECOMMENDED_SUFFIX = ' (Recommended)';
-export const MIN_OPTIONS = 2;
-export const MAX_OPTIONS = 5;
-export const MAX_QUESTIONS = 4;
-export const MAX_LABEL_CHARS = 60;
+export const OTHER_OPTION = OTHER_ROW_LABEL;
 
 export const DECLINE_TEXT =
   'User declined to answer the questions. Continue with your best judgment, or ask different questions.';
 export const NO_UI_TEXT =
   'Error: UI not available (running in non-interactive mode). The user never saw the questions — do NOT treat this as a decline. Ask the questions as plain chat text instead, without using this tool.';
 
+/** Answer kind reported for the free-text row (the questions themselves are the detail). */
+const OTHER_ANSWER = 'Other';
+const MIN_OPTIONS = 2;
+const MAX_OPTIONS = 5;
+const MAX_QUESTIONS = 4;
+const MAX_LABEL_CHARS = 60;
+
 const CUSTOM_ANSWER_TITLE = 'Type your answer:';
 const MULTI_INSTRUCTIONS =
   'Enter the numbers of all that apply, comma-separated (e.g. "1,3"), or type a custom answer as plain text.';
+const MULTI_NO_OTHER_INSTRUCTIONS =
+  'Enter the numbers of all that apply, comma-separated (e.g. "1,3"). There is no free-text answer for this question.';
 const NUMBERED_HINT = 'Enter a number, or type a custom answer.';
 
 const RESERVED_LOWER: Record<string, true> = {
@@ -44,16 +46,18 @@ export const ASK_PARAMETERS = Type.Object({
   options: Type.Optional(Type.Array(OptionSchema, {
     description: '2-5 authored choices. Do NOT include Other; the UI appends it.',
   })),
-  multi: Type.Optional(Type.Boolean({ description: 'Allow multiple selections (default false)' })),
+  multi: Type.Optional(Type.Boolean({ description: 'Allow multiple selections (default false). In the TUI this opens an interactive toggle list (space toggles, enter confirms, esc declines).' })),
+  allowOther: Type.Optional(Type.Boolean({ description: 'Set false to offer the authored choices only, with no free-text row (default true).' })),
   recommended: Type.Optional(Type.Number({ description: '0-based index of the recommended option; UI adds (Recommended)' })),
   questions: Type.Optional(Type.Array(
     Type.Object({
       id: Type.Optional(Type.String({ description: 'Stable id for mapping answers' })),
       question: Type.String({ description: 'Question text' }),
       options: Type.Array(OptionSchema, {
-        description: '2-5 authored choices. Do NOT include Other; the UI appends it.',
+        description: '2-5 authored choices. Do NOT include Other; the UI appends it unless allowOther is false.',
       }),
-      multi: Type.Optional(Type.Boolean({ description: 'Allow multiple selections (default false)' })),
+      multi: Type.Optional(Type.Boolean({ description: 'Allow multiple selections (default false). In the TUI this opens an interactive toggle list (space toggles, enter confirms).' })),
+      allowOther: Type.Optional(Type.Boolean({ description: 'Set false to offer the authored choices only, with no free-text row (default true).' })),
       recommended: Type.Optional(Type.Number({ description: '0-based recommended option index' })),
     }),
     { description: '1-4 related questions in one call. Wins over top-level question/options when set.' },
@@ -66,14 +70,15 @@ export const ASK_TOOL_DESCRIPTION = [
   'While waiting, the pane shows as blocked in herdr (the human sees it and can step in).',
   'Prefer 2-5 options with short labels; put tradeoffs in description.',
   'Do NOT include an "Other" option — the UI appends "Other (type your own)" automatically.',
-  'Use recommended (0-based) to mark the default; "(Recommended)" is added automatically.',
-  'Use multi: true when several options can apply. Group related questions in questions (max 4) rather than calling this tool repeatedly.',
-  'The answer comes back as the tool result; then continue your work.',
+  'Use recommended (0-based) to mark the default; "(Recommended)" is added automatically — do NOT write it in the label.',
+  'Use multi: true when several options can apply — the TUI opens an interactive toggle list (space toggles a row, a toggles all, enter confirms, esc declines) instead of making the human type numbers.',
+  'Set allowOther: false when the authored choices are exhaustive and a free-text answer would be misleading.',
 ].join(' ');
 
 export const ASK_PROMPT_GUIDELINES = [
   'Default to action. Ask only when options have materially different tradeoffs the user must decide.',
-  'Do NOT include "Other" in options; the UI appends it.',
+  'Do NOT include "Other" in options; the UI appends it unless allowOther is false. Group related questions in questions (max 4) rather than calling this tool repeatedly.',
+  'For multi questions the human toggles rows in a list and confirms with enter — never instruct them to type indices.',
   'Short option labels; explanatory tradeoffs in description.',
 ];
 
@@ -83,6 +88,8 @@ export type AskQuestion = {
   question: string;
   options: AskOption[];
   multi: boolean;
+  /** When false the UI offers the authored choices only (no free-text row). */
+  allowOther: boolean;
   recommended?: number;
 };
 export type AskSpec =
@@ -112,6 +119,11 @@ export type AskToolResult = {
 export type AskUi = {
   select?: (title: string, options: string[], opts?: { signal?: AbortSignal }) => Promise<string | undefined>;
   input: (title: string, placeholder?: string, opts?: { signal?: AbortSignal }) => Promise<string | undefined>;
+  /** TUI-only: full custom components (absent in RPC mode, where it returns undefined). */
+  custom?: (factory: unknown) => Promise<unknown>;
+  /** TUI-only helpers from pi's extension UI context; wired for ctrl+o parity with pi's selector. */
+  getToolsExpanded?: () => boolean;
+  setToolsExpanded?: (expanded: boolean) => void;
 };
 
 export type PrepareAskResult =
@@ -169,8 +181,17 @@ function parseOptions(raw: unknown): { ok: true; options: AskOption[] } | { ok:
   const seen = new Set<string>();
   for (const item of raw) {
     const rec = asRecord(item);
-    const label = typeof rec?.label === 'string' ? rec.label.trim() : '';
-    if (!label) return fail('Error: each option needs a non-empty label', 'empty_options');
+    const rawLabel = typeof rec?.label === 'string' ? rec.label.trim() : '';
+    // B3: models repeat the marker the UI appends ("Redis (Recommended)"); strip only a trailing one.
+    const label = rawLabel.replace(/\s*[([]\s*recommended\s*[)\]]\s*$/i, '').trim();
+    if (!label) {
+      return fail(
+        rawLabel
+          ? `Error: option label "${rawLabel}" is only the marker the UI appends — give the choice a real name and pass "recommended" instead`
+          : 'Error: each option needs a non-empty label',
+        'empty_options',
+      );
+    }
     if (label.length > MAX_LABEL_CHARS) {
       return fail(`Error: option label exceeds ${MAX_LABEL_CHARS} characters`, 'label_too_long');
     }
@@ -205,6 +226,7 @@ function parseQuestion(raw: unknown): { ok: true; question: AskQuestion } | { ok
       question,
       options: parsed.options,
       multi: rec.multi === true,
+      allowOther: rec.allowOther !== false,
       ...(id ? { id } : {}),
       ...(recommended !== undefined ? { recommended } : {}),
     },
@@ -255,6 +277,7 @@ export function prepareAsk(params: unknown): PrepareAskResult {
         question,
         options: parsed.options,
         multi: rec.multi === true,
+        allowOther: rec.allowOther !== false,
         ...(recommended !== undefined ? { recommended } : {}),
       }],
     },
@@ -268,15 +291,10 @@ export function gateLabel(spec: AskSpec): string {
   return extra > 0 ? `${first} (+${extra})` : first;
 }
 
-export function formatAuthoredLine(option: AskOption, index: number, recommended?: number): string {
-  const rec = recommended === index ? RECOMMENDED_SUFFIX : '';
-  const desc = option.description ? ` — ${option.description}` : '';
-  return `${index + 1}. ${option.label}${rec}${desc}`;
-}
-
+/** Typed-prompt list: numbered authored options plus the Other row when it is offered. */
 export function optionLines(question: AskQuestion): string[] {
-  const lines = question.options.map((option, i) => formatAuthoredLine(option, i, question.recommended));
-  lines.push(`${question.options.length + 1}. ${OTHER_OPTION}`);
+  const lines = question.options.map((option, i) => numberedOptionLine(option, i, question.recommended));
+  if (question.allowOther) lines.push(`${question.options.length + 1}. ${OTHER_OPTION}`);
   return lines;
 }
 
@@ -294,63 +312,55 @@ function withId(question: AskQuestion, answer: AskAnswer): AskAnswer {
   return question.id ? { ...answer, id: question.id } : answer;
 }
 
-async function askSingle(ui: AskUi, question: AskQuestion, signal?: AbortSignal): Promise<AskAnswer | undefined> {
-  const lines = optionLines(question);
-  const opts = signal ? { signal } : undefined;
-  const chosen = ui.select
-    ? await ui.select(question.question, lines, opts)
-    : await ui.input(`${question.question}\n\n${lines.join('\n')}\n\n${NUMBERED_HINT}`, '1', opts);
-  if (chosen == null) return undefined;
-  const trimmed = chosen.trim();
-  if (!trimmed) return undefined;
-  const idx = parseChoice(trimmed, lines);
-  if (idx != null && idx < question.options.length) {
-    return withId(question, {
-      question: question.question,
-      kind: 'option',
-      answer: question.options[idx]!.label,
-    });
-  }
-  if (idx === question.options.length) {
-    const typed = await ui.input(`${question.question}\n\n${CUSTOM_ANSWER_TITLE}`, '', opts);
-    if (typed == null || !typed.trim()) return undefined;
-    return withId(question, {
-      question: question.question,
-      kind: 'custom',
-      answer: OTHER_ANSWER,
-      customInput: typed.trim(),
-    });
-  }
-  if (!ui.select) {
-    return withId(question, {
-      question: question.question,
-      kind: 'custom',
-      answer: OTHER_ANSWER,
-      customInput: trimmed,
-    });
-  }
-  return undefined;
+/** Free-text answer behind the Other row; shared by the dialog and the typed-prompt fallback. */
+async function askOtherText(ui: AskUi, question: AskQuestion, signal?: AbortSignal): Promise<AskAnswer | undefined> {
+  const typed = await ui.input(`${question.question}\n\n${CUSTOM_ANSWER_TITLE}`, '', signal ? { signal } : undefined);
+  if (typed == null || !typed.trim()) return undefined;
+  return withId(question, {
+    question: question.question,
+    kind: 'custom',
+    answer: OTHER_ANSWER,
+    customInput: typed.trim(),
+  });
 }
 
-async function askMulti(ui: AskUi, question: AskQuestion, signal?: AbortSignal): Promise<AskAnswer | undefined> {
-  const list = question.options
-    .map((option, i) => formatAuthoredLine(option, i, question.recommended))
-    .join('\n');
-  const value = await ui.input(
-    `${question.question}\n\n${list}\n\n${MULTI_INSTRUCTIONS}`,
-    '1,3',
-    signal ? { signal } : undefined,
-  );
-  if (value == null) return undefined;
-  const trimmed = value.trim();
+/**
+ * Interpret one typed answer. Single-select: a listed line or its number takes that option, the Other
+ * number opens the free-text prompt, anything else is a custom answer — but only on the typed fallback,
+ * since a real select dialog can only return a listed row. Multi-select: comma/space separated numbers,
+ * the Other number alone opens free text, an empty submission is an empty selection. Returns 'other' to
+ * ask for free text, undefined to decline.
+ */
+function parseTypedPicks(
+  question: AskQuestion,
+  lines: readonly string[],
+  raw: string,
+  typedFallback: boolean,
+): AskAnswer[] | 'other' | undefined {
+  const trimmed = raw.trim();
+  const otherIndex = question.options.length;
   if (!trimmed) {
-    return withId(question, { question: question.question, kind: 'multi', answer: null, selected: [] });
+    return question.multi
+      ? [withId(question, { question: question.question, kind: 'multi', answer: null, selected: [] })]
+      : undefined;
+  }
+  if (!question.multi) {
+    const idx = parseChoice(trimmed, lines);
+    if (idx === otherIndex) return 'other';
+    if (idx != null && idx < otherIndex) {
+      return [withId(question, { question: question.question, kind: 'option', answer: question.options[idx]!.label })];
+    }
+    return typedFallback
+      ? [withId(question, { question: question.question, kind: 'custom', answer: OTHER_ANSWER, customInput: trimmed })]
+      : undefined;
   }
+  // The Other row is numbered like the authored options; typing it alone opens the free-text prompt.
+  if (trimmed.split(/[,\s]+/).length === 1 && parseChoice(trimmed, lines) === otherIndex) return 'other';
   const tokens = trimmed.split(/[,\s]+/).filter((tok) => tok.length > 0);
   const indices = tokens.map((tok) => {
     if (!/^\d+\.?$/.test(tok)) return null;
     const idx = Number.parseInt(tok, 10) - 1;
-    return idx >= 0 && idx < question.options.length ? idx : null;
+    return idx >= 0 && idx < otherIndex ? idx : null;
   });
   if (indices.every((i): i is number => i != null)) {
     const selected: string[] = [];
@@ -358,14 +368,57 @@ async function askMulti(ui: AskUi, question: AskQuestion, signal?: AbortSignal):
       const label = question.options[i]!.label;
       if (!selected.includes(label)) selected.push(label);
     }
-    return withId(question, { question: question.question, kind: 'multi', answer: null, selected });
+    return [withId(question, { question: question.question, kind: 'multi', answer: null, selected })];
   }
-  return withId(question, {
-    question: question.question,
-    kind: 'custom',
-    answer: OTHER_ANSWER,
-    customInput: trimmed,
-  });
+  return question.allowOther
+    ? [withId(question, { question: question.question, kind: 'custom', answer: OTHER_ANSWER, customInput: trimmed })]
+    : undefined;
+}
+
+/** Ask one question, both modes: the pier dialog, then the host's select dialog (single only), then
+ *  the typed prompt. `ui.custom` is absent (or resolves undefined) in RPC mode, hence every rung. */
+async function askQuestion(ui: AskUi, question: AskQuestion, signal?: AbortSignal): Promise<AskAnswer | undefined> {
+  const { multi } = question;
+  if (typeof ui.custom === 'function') {
+    const toggleToolsExpanded = ui.getToolsExpanded && ui.setToolsExpanded
+      ? (): void => ui.setToolsExpanded!(!ui.getToolsExpanded!())
+      : undefined;
+    const outcome = await runSelectDialog(
+      ui.custom,
+      question.question,
+      {
+        options: question.options,
+        allowOther: question.allowOther,
+        multi,
+        ...(question.recommended !== undefined ? { recommended: question.recommended } : {}),
+      },
+      { ...(signal ? { signal } : {}), ...(toggleToolsExpanded ? { toggleToolsExpanded } : {}) },
+    );
+    if (outcome?.kind === 'cancel') return undefined;
+    if (outcome?.kind === 'other') return askOtherText(ui, question, signal);
+    if (outcome?.kind === 'selected') {
+      return withId(
+        question,
+        multi
+          ? { question: question.question, kind: 'multi', answer: null, selected: outcome.labels }
+          : { question: question.question, kind: 'option', answer: outcome.labels[0]! },
+      );
+    }
+  }
+  const lines = optionLines(question);
+  const opts = signal ? { signal } : undefined;
+  // A multi question has no single-pick host dialog; its typed prompt is always the fallback.
+  const select = multi ? undefined : ui.select;
+  const hint = multi
+    ? (question.allowOther ? MULTI_INSTRUCTIONS : MULTI_NO_OTHER_INSTRUCTIONS)
+    : NUMBERED_HINT;
+  const raw = select
+    ? await select(question.question, lines, opts)
+    : await ui.input(`${question.question}\n\n${lines.join('\n')}\n\n${hint}`, multi ? '1,3' : '1', opts);
+  if (raw == null) return undefined;
+  const picks = parseTypedPicks(question, lines, raw, select === undefined);
+  if (picks === 'other') return askOtherText(ui, question, signal);
+  return picks?.[0];
 }
 
 export function formatAskContent(details: AskDetails): string {
@@ -398,9 +451,7 @@ export async function runAsk(spec: AskSpec, ui: AskUi, signal?: AbortSignal): Pr
   }
   const answers: AskAnswer[] = [];
   for (const question of spec.questions) {
-    const answer = question.multi
-      ? await askMulti(ui, question, signal)
-      : await askSingle(ui, question, signal);
+    const answer = await askQuestion(ui, question, signal);
     if (!answer) return okResult({ answers, cancelled: true });
     answers.push(answer);
   }