pi-ask-questions 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-10-15
+
+### Fixed
+
+- A background questionnaire (`noWait: true`) that fails to open now reports the failure to the user with an error notification instead of failing silently. The background slot is still released so later calls can open a new questionnaire.
+
+### Documentation
+
+- Documented the `pending` shape of `structuredContent`: while a background questionnaire is open, each `answers[]` entry is a stub with an empty `answers` array, so consumers must branch on `pending` before reading answers.
+
+## [0.2.0] - 2026-10-15
+
+### Changed
+
+- Removed decorative icons from tabs, option rows, the review tab, and tool output. Only the selection markers (`[x]` / `[ ]` / `(•)`) and the cursor remain.
+- Option questions now hold at most one typed answer. The inline editor appears directly under the “Type something…” row with the options still visible, and moving onto that row starts editing immediately instead of opening a separate view.
+- Free-form questions always resolve to a single typed answer; `multiple`, `min`, and `max` no longer apply when a question has no options.
+
+### Added
+
+- `noWait` parameter: open the questionnaire in the background and return immediately, delivering the answers later as a follow-up message. Only one background questionnaire can be open at a time; it is cancelled safely on session shutdown.
+
 ## [0.1.0] - 2026-10-15
 
 ### Added

package/README.md

@@ -8,7 +8,7 @@ Interactive questionnaires for [Pi](https://pi.dev): the model runs an `ask_user
 ```text
 ────────────────────────────────────────────────────────────
  ask_user demo
- ✓ Scope  ◐ Release  · Notes  Submit
+ Scope  Release  Notes  Submit
 ────────────────────────────────────────────────────────────
  Which parts of the project should this change touch?
  Select one or more • Space toggles
@@ -19,7 +19,10 @@ Interactive questionnaires for [Pi](https://pi.dev): the model runs an `ask_user
        The interactive questionnaire renderer
    [ ] 3. Documentation
    [x] 4. Tests
-   ✎ Type something…
+   Type something…
+   ──────────────────────────────────────────────
+    custom answer
+   ──────────────────────────────────────────────
 
  ↑↓ move • Space toggle • A all • C clear • 1-9 jump • Enter confirm
 ────────────────────────────────────────────────────────────
@@ -41,16 +44,18 @@ Once installed, run `/ask-demo` to preview the UI, or just let the model call `a
 
 ## Features
 
-- **Tabs** — every question gets a tab with live status (`○` unanswered, `◐` partially answered, `✓` answered, `·` skipped). Move with `Tab` / `Shift+Tab` or `←` / `→`.
+- **Tabs** — every question gets a tab, with answered state shown by color (green = answered, accent = partially answered, muted = untouched). Move with `Tab` / `Shift+Tab`.
 - **Single-select** radio options with optional descriptions.
 - **Multi-select** checkboxes (`multiple: true`), including `min` / `max` validation, `A` to select all, and `C` to clear.
-- **Free-form typing** — a question without options is a plain text prompt. Typed answers are supported on option questions too via the built-in “Type something…” entry, and multiple-choice questions can collect several typed answers.
-- **Multiple answers** — return any number of selections and typed entries per question.
+- **Free-form typing** — a question without options is a plain text prompt. Option questions can also hold one typed answer unless `allowOther: false`.
+- **Inline editing** — move the cursor onto “Type something…” and type; the editor appears directly under the row with the options still visible. No separate menu, and the answer can be edited again in place.
+- **One typed answer per question** — typed answers are never duplicated; editing replaces the previous text.
 - **Optional questions** (`required: false`) that can be skipped, plus preset answers (`selected: true`) and defaults.
 - **Review tab** — see everything before submitting; jump back to any question to edit it.
 - **Validation** — required answers and `min`/`max` selection counts are enforced before submit.
+- **Background mode** — set `noWait: true` and the tool returns immediately while the questionnaire stays open; the answers arrive later as a follow-up message.
 - **Safe cancel** — `Esc` arms cancellation, a second `Esc` or `Ctrl+C` cancels immediately.
-- **Scrollable option lists** — long lists show `↑ n more` / `↓ n more` indicators.
+- **Scrollable option lists** — long lists show “n more above / below” indicators.
 - **Structured results** — the tool returns text for the model and a machine-readable `structuredContent` payload for codemode scripts.
 
 ## How the model uses it
@@ -125,26 +130,34 @@ Notes: (skipped)
 | `questions[].min` / `max` | integer | Selection bounds for multi-select. |
 | `questions[].placeholder` | string | Placeholder for the free-form editor. |
 | `questions[].otherLabel` | string | Custom label for the typed-answer entry. |
+| `noWait` | boolean | Show the questionnaire in the background and return immediately (interactive TUI only). The answers arrive as a follow-up message. Only one background questionnaire can be open at a time. |
+
+### Structured results
+
+`structuredContent` mirrors the answers for codemode scripts: `cancelled`, an optional `pending`, and `answers[]` with `{ id, question, skipped, answers: [{ value, label, custom }] }`.
+
+While a background questionnaire is open, `pending` is `true` and each `answers[]` entry is a stub with an empty `answers` array. Branch on `pending` before reading them; the real answers arrive as a follow-up message.
 
 ### Keyboard reference
 
 | Keys | Action |
 | --- | --- |
-| `Tab` / `Shift+Tab`, `←` / `→` | Switch tabs |
+| `Tab` / `Shift+Tab` | Switch tabs |
 | `↑` / `↓`, `Home` / `End` | Move the option cursor |
 | `Space` | Toggle a checkbox / select a radio option |
 | `1`–`9` | Jump to an option (toggles it in multi-select) |
 | `A` / `C` | Select all / clear (multi-select) |
-| `Enter` | Confirm the question, open the editor, or submit |
-| `Esc` | Leave the editor, arm cancel; `Esc` twice cancels |
+| `Enter` | Confirm the question, or submit on the review tab |
+| `Esc` | Arm cancel; `Esc` twice cancels |
 | `Ctrl+C` | Cancel immediately |
-| `\` + `Enter` | Newline in the free-form editor |
+| `\` + `Enter` | Newline in a free-form answer |
 
 ## Modes
 
 | Mode | Behavior |
 | --- | --- |
 | Interactive TUI | Full tabbed questionnaire. |
+| Interactive TUI + `noWait` | Tool returns immediately; answers are delivered as a follow-up message. |
 | RPC | Sequential fallback built from the dialog API (`select` / `input`). |
 | Print / JSON | The tool reports that no UI is available and lists the questions so the model can ask them in plain text. |
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-ask-questions",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"description": "Interactive questionnaires for Pi: tabs, multi-select, free-form typing, validation, and structured answers.",
 	"keywords": [
 		"pi-package",

package/src/extension.ts

@@ -14,6 +14,7 @@ import {
 	type NormalizedQuestion,
 	type QuestionAnswer,
 	DEFAULT_SUBMIT_LABEL,
+	buildResult,
 	formatAnswersText,
 	normalizeQuestions,
 	toStructuredOutput,
@@ -27,6 +28,8 @@ import { runQuestionnaire, type QuestionnaireContext } from "./ui/ask-questionna
 /** Structured details stored with the tool result for rendering. */
 export interface AskToolDetails {
 	cancelled: boolean;
+	/** True while a noWait questionnaire is still open in the background. */
+	pending?: boolean;
 	answers: QuestionAnswer[];
 	questions: NormalizedQuestion[];
 }
@@ -36,15 +39,17 @@ const TOOL_DESCRIPTION = `Ask the user one or more questions and wait for their
 The interactive UI supports:
 - Tabs: every question gets its own tab (Tab / Shift+Tab and arrow keys switch).
 - Single-select and multi-select questions (set multiple: true).
-- Free-form typing: the user can always type a custom answer unless allowOther is false; a question with no options is purely free-form.
+- Free-form typing: a question with no options is a text prompt. Option questions can also hold one typed answer unless allowOther is false, and the answer is edited inline.
 - Optional questions (required: false) that can be skipped, preselected options (selected: true), and min/max selection counts.
 - Number keys 1-9 jump to options; A selects all; C clears a multi-select.
+- Set noWait: true to open the questionnaire in the background: the tool returns immediately and the answers arrive later as a follow-up message.
 
 Guidelines:
 - Prefer this tool over asking questions in prose when you actually need the answer to proceed.
 - Group related questions into one call (2-6 questions) instead of asking repeatedly.
 - Provide concrete, labeled options whenever you can; use a free-form question only when the answer space is open.
-- Put recommended options first.`;
+- Put recommended options first.
+- Use noWait only when you can keep working without the answer; otherwise omit it so the answers arrive in the same turn.`;
 
 const HELP_TEXT = `Interactive UI is not available in this mode. Ask the user the following questions directly in your reply instead:
 {{questions}}`;
@@ -87,6 +92,21 @@ function resultContent(result: AskResult): string {
 
 /** Start the questionnaire and wait for the user. */
 export default function askQuestionsExtension(pi: ExtensionAPI): void {
+	// A noWait questionnaire stays open after its tool call returns. It owns a
+	// session-scoped abort controller and reports its answers with a follow-up
+	// message instead of a tool result.
+	let backgroundController: AbortController | undefined;
+	let shuttingDown = false;
+
+	pi.on("session_start", () => {
+		shuttingDown = false;
+	});
+	pi.on("session_shutdown", () => {
+		shuttingDown = true;
+		backgroundController?.abort();
+		backgroundController = undefined;
+	});
+
 	pi.registerTool<typeof AskUserParamsSchema, AskToolDetails>({
 		name: "ask_user",
 		label: "Ask User",
@@ -96,6 +116,7 @@ export default function askQuestionsExtension(pi: ExtensionAPI): void {
 		promptGuidelines: [
 			"Use ask_user when you need a decision or missing detail from the user; batch related questions into one call instead of asking repeatedly.",
 			"Give ask_user questions labeled options where possible, keep them self-contained, and put recommended options first.",
+			"Set noWait only when you can keep working without the answers, for example to ask while investigating something else.",
 		],
 		parameters: AskUserParamsSchema,
 		outputSchema: AskUserOutputSchema,
@@ -118,6 +139,73 @@ export default function askQuestionsExtension(pi: ExtensionAPI): void {
 			}
 
 			const submitLabel = params.submitLabel?.trim() || DEFAULT_SUBMIT_LABEL;
+
+			if (params.noWait === true && ctx.mode === "tui") {
+				if (backgroundController) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: "Another background questionnaire is already open. Wait for the user to answer it before asking again.",
+							},
+						],
+						details: { cancelled: true, pending: true, answers: [], questions },
+						isError: true,
+					};
+				}
+
+				const controller = new AbortController();
+				backgroundController = controller;
+				void runQuestionnaire(ctx as QuestionnaireContext, questions, {
+					title: params.title?.trim() || undefined,
+					submitLabel,
+					signal: controller.signal,
+				})
+					.then((result) => {
+						if (shuttingDown || backgroundController !== controller) {
+							return;
+						}
+						pi.sendMessage(
+							{
+								customType: "ask_user:answers",
+								content: resultContent(result),
+								display: true,
+								details: { cancelled: result.cancelled, answers: result.answers, questions },
+							},
+							{ triggerTurn: true, deliverAs: "followUp" },
+						);
+					})
+					.catch((error: unknown) => {
+						// The questionnaire could not be shown. The tool result already told
+						// the model it was pending, so surface the failure to the user
+						// instead of leaving everyone waiting for answers that never come.
+						const reason = error instanceof Error ? error.message : String(error);
+						try {
+							ctx.ui.notify(
+								`ask_user could not show the background questionnaire: ${reason}`,
+								"error",
+							);
+						} catch {
+							// Reporting is best-effort; the background slot still clears.
+						}
+					})
+					.finally(() => {
+						if (backgroundController === controller) {
+							backgroundController = undefined;
+						}
+					});
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Questionnaire shown to the user in the background. Continue with other work; the answers will arrive as a follow-up message.`,
+						},
+					],
+					details: { cancelled: false, pending: true, answers: [], questions },
+					structuredContent: toStructuredOutput(buildResult(questions, new Map(), false, true)),
+				};
+			}
 			let result: AskResult;
 			try {
 				result = await askQuestions(ctx, questions, {
@@ -173,16 +261,23 @@ export default function askQuestionsExtension(pi: ExtensionAPI): void {
 				const content = result.content[0];
 				return new Text(content?.type === "text" ? content.text : "", 0, 0);
 			}
+			if (details.pending) {
+				if (result.isError) {
+					const content = result.content[0];
+					return new Text(content?.type === "text" ? content.text : "Background questionnaire busy", 0, 0);
+				}
+				return new Text(theme.fg("muted", "Waiting for the user in the background"), 0, 0);
+			}
 			if (details.cancelled) {
 				return new Text(theme.fg("warning", "Cancelled"), 0, 0);
 			}
 			const lines = details.answers.map((answer) => {
 				const label = theme.fg("accent", answer.label);
 				if (answer.skipped) {
-					return `${theme.fg("dim", "⏭ ")}${label}${theme.fg("dim", ": skipped")}`;
+					return `${label}${theme.fg("dim", ": skipped")}`;
 				}
 				if (answer.entries.length === 0) {
-					return `${theme.fg("dim", "· ")}${label}${theme.fg("dim", ": no answer")}`;
+					return `${label}${theme.fg("dim", ": no answer")}`;
 				}
 				const values = answer.entries
 					.map((entry) =>
@@ -191,7 +286,7 @@ export default function askQuestionsExtension(pi: ExtensionAPI): void {
 							: theme.fg("text", entry.label),
 					)
 					.join(theme.fg("dim", ", "));
-				return `${theme.fg("success", "✓ ")}${label}${theme.fg("muted", ": ")}${values}`;
+				return `${label}${theme.fg("muted", ": ")}${values}`;
 			});
 			return new Text(lines.join("\n"), 0, 0);
 		},

package/src/fallback.ts

@@ -134,7 +134,7 @@ async function askMultiple(
 			selected.add(index);
 		}
 	});
-	const custom: AnswerEntry[] = [];
+	let custom: AnswerEntry | undefined;
 	const doneLabel = "Done";
 	const customLabel = `${question.otherLabel} (type an answer)`;
 	const skipLabel = "Skip this question";
@@ -168,14 +168,8 @@ async function askMultiple(
 				ui.notify("Type an answer first.", "warning");
 				continue;
 			}
-			if (
-				custom.some((entry) => entry.value === value) ||
-				question.options.some((option) => option.value === value)
-			) {
-				ui.notify("That answer was already added.", "info");
-				continue;
-			}
-			custom.push({ value, label: value, custom: true });
+			// A question holds at most one typed answer; editing replaces it.
+			custom = { value, label: value, custom: true };
 			continue;
 		}
 		if (choice === doneLabel) {
@@ -183,7 +177,7 @@ async function askMultiple(
 				...question.options
 					.filter((_, index) => selected.has(index))
 					.map((option) => ({ value: option.value, label: option.label, custom: false })),
-				...custom,
+				...(custom ? [custom] : []),
 			];
 			const error = answerError(question, makeAnswer(question, entries));
 			if (error) {

package/src/questions.ts

@@ -50,6 +50,8 @@ export interface QuestionAnswer {
 
 export interface AskResult {
 	cancelled: boolean;
+	/** True when the questionnaire is still open in the background (noWait). */
+	pending?: boolean;
 	answers: QuestionAnswer[];
 }
 
@@ -80,7 +82,9 @@ export function normalizeQuestions(params: AskUserParams): NormalizedQuestion[]
 			selected: option.selected ?? false,
 		}));
 		const freeForm = options.length === 0;
-		const multiple = raw.multiple ?? false;
+		// Free-form questions always hold exactly one typed answer, so
+		// multiple/min/max do not apply to them.
+		const multiple = freeForm ? false : (raw.multiple ?? false);
 
 		return {
 			id,
@@ -177,9 +181,11 @@ export function buildResult(
 	questions: NormalizedQuestion[],
 	answers: ReadonlyMap<string, QuestionAnswer>,
 	cancelled: boolean,
+	pending = false,
 ): AskResult {
 	return {
 		cancelled,
+		pending,
 		answers: questions.map((question) => {
 			const answer = answers.get(question.id) ?? makeAnswer(question, []);
 			const skipped = answer.skipped || (!question.required && answer.entries.length === 0);
@@ -192,6 +198,7 @@ export function buildResult(
 export function toStructuredOutput(result: AskResult): AskUserOutput {
 	return {
 		cancelled: result.cancelled,
+		pending: result.pending ?? false,
 		answers: result.answers.map((answer) => ({
 			id: answer.id,
 			question: answer.question,

package/src/schema.ts

@@ -111,12 +111,24 @@ export const AskUserParamsSchema = Type.Object({
 		description:
 			"Questions to ask, in order. Each question gets its own tab; the user can move between tabs freely.",
 	}),
+	noWait: Type.Optional(
+		Type.Boolean({
+			description:
+				"Show the questionnaire in the background and return immediately instead of waiting for the user (interactive TUI only). The answers arrive later as a follow-up message. Useful when the answers are not needed right now. Only one background questionnaire can be open at a time.",
+		}),
+	),
 });
 
 export const AskUserOutputSchema = Type.Object({
 	cancelled: Type.Boolean({
 		description: "True when the user cancelled the questionnaire before submitting.",
 	}),
+	pending: Type.Optional(
+		Type.Boolean({
+			description:
+				"True when the questionnaire is still open in the background (noWait); answers arrive in a follow-up message.",
+		}),
+	),
 	answers: Type.Array(
 		Type.Object({
 			id: Type.String({ description: "Question id from the request." }),

package/src/ui/ask-questionnaire.ts

@@ -5,7 +5,7 @@
  *
  *   ─────────────────────────────────────────────
  *    Title
- *    ✓ Scope  ◐ Style  · Notes  [ Submit ]
+ *    Scope  Release  Notes  [ Submit ]
  *
  *    The question text
  *    Optional header / hints
@@ -13,21 +13,22 @@
  *    ❯ [x] 1. Option label
  *          description
  *      [ ] 2. Another option
- *      ✎ Type something…
- *      ⏭ Skip this question
+ *      Type something…
+ *      (inline editor for the typed answer, no separate menu)
+ *      Skip this question
  *
  *    ↑↓ move • Space toggle • Enter confirm • Esc cancel
  *   ─────────────────────────────────────────────
  *
  * Keyboard contract:
- * - Tab / Shift+Tab (and ←/→) switch tabs.
+ * - Tab / Shift+Tab switch tabs.
  * - ↑/↓ move the cursor; Home/End jump to the first/last row.
  * - Space toggles a multiple-choice option; Enter confirms the question.
  * - 1-9 jumps to an option; on multiple-choice it toggles it.
  * - A selects all options, C clears the selection (multiple-choice only).
- * - Enter on "Type something…" opens the inline editor.
- * - Esc leaves the editor or arms cancellation; Esc twice cancels.
- * - Ctrl+C cancels immediately.
+ * - Moving the cursor onto "Type something…" starts editing immediately;
+ *   the inline editor is always there, no separate menu.
+ * - Esc arms cancellation; Esc twice cancels. Ctrl+C cancels immediately.
  */
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import {
@@ -110,12 +111,13 @@ export function createQuestionnaireComponent(
 	let tab = 0;
 	let cursor = 0;
 	let submitCursor = questions.length;
-	let mode: "options" | "typing" = "options";
 	let cancelArmed = false;
 	let notice: { text: string; kind: NoticeKind } | undefined;
 	let editorText = "";
 	let cachedLines: string[] | undefined;
 	let finished = false;
+	let componentFocused = false;
+	let suppressEditorEvents = false;
 
 	const answers = new Map<string, QuestionAnswer>();
 
@@ -145,6 +147,10 @@ export function createQuestionnaireComponent(
 		}
 	}
 
+	function currentQuestion(): NormalizedQuestion | undefined {
+		return questions[tab];
+	}
+
 	function rowsFor(question: NormalizedQuestion): QuestionRow[] {
 		const rows: QuestionRow[] = question.options.map((option, index) => ({
 			kind: "option",
@@ -160,6 +166,22 @@ export function createQuestionnaireComponent(
 		return rows;
 	}
 
+	function cursorRow(question: NormalizedQuestion): QuestionRow | undefined {
+		return rowsFor(question)[cursor];
+	}
+
+	/** True when keystrokes belong in the editor (free-form or custom row). */
+	function isEditorActive(): boolean {
+		const question = currentQuestion();
+		if (!question) {
+			return false;
+		}
+		if (question.options.length === 0) {
+			return true;
+		}
+		return cursorRow(question)?.kind === "custom";
+	}
+
 	function isOptionSelected(question: NormalizedQuestion, option: NormalizedOption): boolean {
 		return getAnswer(question).entries.some(
 			(entry) => !entry.custom && entry.value === option.value,
@@ -192,22 +214,67 @@ export function createQuestionnaireComponent(
 	}
 
 	function setText(text: string): void {
+		suppressEditorEvents = true;
 		editor.setText(text);
 		editorText = editor.getText();
+		suppressEditorEvents = false;
+	}
+
+	function syncEditorFocus(): void {
+		editor.focused = componentFocused && isEditorActive();
+	}
+
+	/**
+	 * Keep answers in sync with the editor while the user types. Free-form
+	 * questions store a single typed answer; option questions with a custom
+	 * row store a single custom entry alongside the selected options.
+	 */
+	function applyEditorText(value: string): void {
+		const question = currentQuestion();
+		if (!question) {
+			return;
+		}
+		const trimmed = value.trim();
+		if (question.options.length === 0) {
+			if (trimmed) {
+				setEntries(question, [{ value: trimmed, label: trimmed, custom: true }]);
+			} else if (question.required) {
+				setEntries(question, []);
+			} else {
+				answers.set(question.id, makeAnswer(question, [], true));
+			}
+			return;
+		}
+		if (cursorRow(question)?.kind !== "custom") {
+			return;
+		}
+		const others = getAnswer(question).entries.filter((entry) => !entry.custom);
+		if (trimmed) {
+			setEntries(question, [...others, { value: trimmed, label: trimmed, custom: true }]);
+		} else {
+			setEntries(question, others);
+		}
 	}
 
 	// ── Navigation ───────────────────────────────────────────────────────
 
-	function prepareQuestion(question: NormalizedQuestion | undefined, prefill: boolean): void {
-		cursor = 0;
-		if (!question || question.options.length > 0) {
-			mode = "options";
+	function setEditorForQuestion(question: NormalizedQuestion | undefined): void {
+		if (!question) {
 			setText("");
 			return;
 		}
-		mode = "typing";
-		const existing = prefill && !question.multiple ? getAnswer(question).entries[0]?.value ?? "" : "";
-		setText(existing);
+		const custom = getAnswer(question).entries.find((entry) => entry.custom);
+		if (question.options.length === 0) {
+			setText(getAnswer(question).entries[0]?.value ?? "");
+		} else {
+			setText(custom?.value ?? "");
+		}
+	}
+
+	function prepareQuestion(question: NormalizedQuestion | undefined): void {
+		cursor = 0;
+		setEditorForQuestion(question);
+		syncEditorFocus();
 	}
 
 	function goTab(delta: number): void {
@@ -221,7 +288,7 @@ export function createQuestionnaireComponent(
 		if (tab === submitTabIndex) {
 			submitCursor = submitTabIndex;
 		}
-		prepareQuestion(questions[tab], true);
+		prepareQuestion(questions[tab]);
 		refresh();
 	}
 
@@ -229,7 +296,7 @@ export function createQuestionnaireComponent(
 		tab = index;
 		cancelArmed = false;
 		notice = undefined;
-		prepareQuestion(questions[tab], true);
+		prepareQuestion(questions[tab]);
 		refresh();
 	}
 
@@ -240,7 +307,7 @@ export function createQuestionnaireComponent(
 			return;
 		}
 		tab = tab < questions.length - 1 ? tab + 1 : submitTabIndex;
-		prepareQuestion(questions[tab], true);
+		prepareQuestion(questions[tab]);
 		refresh();
 	}
 
@@ -257,7 +324,7 @@ export function createQuestionnaireComponent(
 				const index = questions.findIndex((question) => question.id === first.id);
 				tab = index >= 0 ? index : 0;
 				cancelArmed = false;
-				prepareQuestion(questions[tab], false);
+				prepareQuestion(questions[tab]);
 				notice = { text: `${first.label}: ${first.message}`, kind: "error" };
 				refresh();
 				return;
@@ -278,29 +345,24 @@ export function createQuestionnaireComponent(
 		refresh();
 	}
 
-	function startTyping(): void {
-		mode = "typing";
-		const question = questions[tab];
-		const existing = question
-			? getAnswer(question).entries.find((entry) => entry.custom)?.value ?? ""
-			: "";
-		setText(existing);
-		notice = undefined;
-		refresh();
-	}
-
 	function activateRow(toggle: boolean): void {
-		const question = questions[tab];
+		const question = currentQuestion();
 		if (!question) {
 			return;
 		}
-		const rows = rowsFor(question);
-		const row = rows[cursor];
+		const row = cursorRow(question);
 		if (!row) {
 			return;
 		}
 		if (row.kind === "custom") {
-			startTyping();
+			// The custom row is edited in place; Enter confirms the question.
+			const error = answerError(question, answers.get(question.id));
+			if (error) {
+				notice = { text: error, kind: "warning" };
+				refresh();
+				return;
+			}
+			advance();
 			return;
 		}
 		if (row.kind === "skip") {
@@ -340,68 +402,6 @@ export function createQuestionnaireComponent(
 		refresh();
 	}
 
-	function submitTyped(rawValue: string): void {
-		const question = questions[tab];
-		if (!question) {
-			return;
-		}
-		const value = rawValue.trim();
-		const answer = getAnswer(question);
-
-		if (!value) {
-			if (!question.required) {
-				answers.set(question.id, makeAnswer(question, [], true));
-				advance();
-				return;
-			}
-			if (question.multiple && question.options.length === 0) {
-				if (answer.entries.length > 0) {
-					advance();
-					return;
-				}
-				notice = { text: "Type an answer first.", kind: "warning" };
-				refresh();
-				return;
-			}
-			if (question.multiple) {
-				mode = "options";
-				notice = undefined;
-				refresh();
-				return;
-			}
-			notice = { text: "Type an answer first.", kind: "warning" };
-			refresh();
-			return;
-		}
-
-		if (question.multiple) {
-			if (answer.entries.some((entry) => entry.custom && entry.value === value)) {
-				notice = { text: "That answer was already added.", kind: "info" };
-				refresh();
-				return;
-			}
-			if (question.max !== undefined && answer.entries.length >= question.max) {
-				notice = {
-					text: `Select at most ${question.max} ${question.max === 1 ? "answer" : "answers"}.`,
-					kind: "warning",
-				};
-				refresh();
-				return;
-			}
-			setEntries(question, [...answer.entries, { value, label: value, custom: true }]);
-			notice = { text: `Added "${value}".`, kind: "success" };
-			setText("");
-			if (question.options.length > 0) {
-				mode = "options";
-			}
-			refresh();
-			return;
-		}
-
-		setEntries(question, [{ value, label: value, custom: true }]);
-		advance();
-	}
-
 	// ── Input handling ───────────────────────────────────────────────────
 
 	function handleSubmitTab(data: string): void {
@@ -443,39 +443,67 @@ export function createQuestionnaireComponent(
 		}
 	}
 
+	function moveCursor(delta: number, question: NormalizedQuestion): void {
+		const rows = rowsFor(question);
+		if (rows.length === 0) {
+			return;
+		}
+		cursor = (cursor + delta + rows.length) % rows.length;
+		syncEditorFocus();
+		refresh();
+	}
+
+	function handleCustomRow(data: string, question: NormalizedQuestion): void {
+		if (matchesKey(data, Key.up)) {
+			moveCursor(-1, question);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			moveCursor(1, question);
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			activateRow(false);
+			return;
+		}
+		// Left/right and everything else edit the inline text.
+		editor.handleInput(data);
+		refresh();
+	}
+
 	function handleQuestionTab(data: string): void {
-		const question = questions[tab];
+		const question = currentQuestion();
 		if (!question) {
 			return;
 		}
 		const rows = rowsFor(question);
 
-		if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+		if (matchesKey(data, Key.right)) {
 			goTab(1);
 			return;
 		}
-		if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) {
+		if (matchesKey(data, Key.left)) {
 			goTab(-1);
 			return;
 		}
 		if (rows.length > 0) {
 			if (matchesKey(data, Key.up)) {
-				cursor = (cursor - 1 + rows.length) % rows.length;
-				refresh();
+				moveCursor(-1, question);
 				return;
 			}
 			if (matchesKey(data, Key.down)) {
-				cursor = (cursor + 1) % rows.length;
-				refresh();
+				moveCursor(1, question);
 				return;
 			}
 			if (matchesKey(data, Key.home)) {
 				cursor = 0;
+				syncEditorFocus();
 				refresh();
 				return;
 			}
 			if (matchesKey(data, Key.end)) {
 				cursor = rows.length - 1;
+				syncEditorFocus();
 				refresh();
 				return;
 			}
@@ -500,6 +528,7 @@ export function createQuestionnaireComponent(
 		}
 		if (question.multiple && lower === "c") {
 			setEntries(question, []);
+			setText("");
 			notice = undefined;
 			refresh();
 			return;
@@ -509,6 +538,7 @@ export function createQuestionnaireComponent(
 			const index = rows.findIndex((row) => row.kind === "option" && row.index === digit - 1);
 			if (index >= 0) {
 				cursor = index;
+				syncEditorFocus();
 				activateRow(question.multiple);
 			}
 		}
@@ -524,36 +554,6 @@ export function createQuestionnaireComponent(
 		}
 
 		const escape = matchesKey(data, Key.escape);
-
-		if (mode === "typing") {
-			if (showTabs && matchesKey(data, Key.tab)) {
-				goTab(1);
-				return;
-			}
-			if (showTabs && matchesKey(data, Key.shift("tab"))) {
-				goTab(-1);
-				return;
-			}
-			if (escape) {
-				const question = questions[tab];
-				if (question && question.options.length > 0) {
-					mode = "options";
-					notice = undefined;
-					refresh();
-				} else {
-					armCancel();
-				}
-				return;
-			}
-			if (cancelArmed) {
-				cancelArmed = false;
-				notice = undefined;
-			}
-			editor.handleInput(data);
-			refresh();
-			return;
-		}
-
 		if (!escape && cancelArmed) {
 			cancelArmed = false;
 			notice = undefined;
@@ -566,10 +566,33 @@ export function createQuestionnaireComponent(
 			}
 			return;
 		}
+
+		if (showTabs && matchesKey(data, Key.tab)) {
+			goTab(1);
+			return;
+		}
+		if (showTabs && matchesKey(data, Key.shift("tab"))) {
+			goTab(-1);
+			return;
+		}
+
+		const question = currentQuestion();
 		if (showTabs && tab === submitTabIndex) {
 			handleSubmitTab(data);
 			return;
 		}
+		if (!question) {
+			return;
+		}
+		if (question.options.length === 0) {
+			editor.handleInput(data);
+			refresh();
+			return;
+		}
+		if (cursorRow(question)?.kind === "custom") {
+			handleCustomRow(data, question);
+			return;
+		}
 		handleQuestionTab(data);
 	}
 
@@ -580,15 +603,7 @@ export function createQuestionnaireComponent(
 		for (let index = 0; index < questions.length; index += 1) {
 			const question = questions[index]!;
 			const status = answerStatus(question, answers.get(question.id));
-			const icon =
-				status === "complete"
-					? "✓"
-					: status === "partial"
-						? "◐"
-						: status === "skipped"
-							? "·"
-							: "○";
-			const text = ` ${icon} ${question.label} `;
+			const text = ` ${question.label} `;
 			if (index === tab) {
 				parts.push(theme.bg("selectedBg", theme.fg("text", text)));
 			} else if (status === "complete") {
@@ -609,7 +624,7 @@ export function createQuestionnaireComponent(
 		add(" ", parts.join(" "));
 	}
 
-	function renderRows(add: AddLine, question: NormalizedQuestion): void {
+	function renderRows(add: AddLine, lines: string[], renderWidth: number, question: NormalizedQuestion): void {
 		const rows = rowsFor(question);
 		const { start, end, hiddenAbove, hiddenBelow } = windowRange(
 			rows.length,
@@ -617,7 +632,7 @@ export function createQuestionnaireComponent(
 			MAX_VISIBLE_ROWS,
 		);
 		if (hiddenAbove > 0) {
-			add("  ", theme.fg("dim", `↑ ${hiddenAbove} more`));
+			add("  ", theme.fg("dim", `${hiddenAbove} more above`));
 		}
 		for (let index = start; index < end; index += 1) {
 			const row = rows[index]!;
@@ -635,23 +650,29 @@ export function createQuestionnaireComponent(
 				continue;
 			}
 			if (row.kind === "custom") {
-				const customEntries = getAnswer(question).entries.filter((entry) => entry.custom);
-				const suffix = customEntries.length > 0 ? ` (${customEntries.length} added)` : "";
-				add(marker, theme.fg(active ? "accent" : "text", `✎ ${question.otherLabel}${suffix}`));
-				for (const entry of customEntries) {
-					add("     ", theme.fg("success", `✎ "${entry.value}"`));
+				add(marker, theme.fg(active ? "accent" : "text", question.otherLabel));
+				const customValue = getAnswer(question).entries.find((entry) => entry.custom)?.value;
+				if (active) {
+					if (!editorText && question.placeholder) {
+						add("  ", theme.fg("dim", question.placeholder));
+					}
+					for (const line of editor.render(Math.max(1, renderWidth - 2))) {
+						lines.push(`  ${line}`);
+					}
+				} else if (customValue) {
+					add("  ", theme.fg("text", customValue));
 				}
 				continue;
 			}
-			add(marker, theme.fg(active ? "accent" : "warning", "⏭ Skip this question"));
+			add(marker, theme.fg(active ? "accent" : "warning", "Skip this question"));
 		}
 		if (hiddenBelow > 0) {
-			add("  ", theme.fg("dim", `↓ ${hiddenBelow} more`));
+			add("  ", theme.fg("dim", `${hiddenBelow} more below`));
 		}
 	}
 
 	function renderQuestion(add: AddLine, lines: string[], renderWidth: number): void {
-		const question = questions[tab];
+		const question = currentQuestion();
 		if (!question) {
 			return;
 		}
@@ -665,11 +686,16 @@ export function createQuestionnaireComponent(
 			add(" ", theme.fg("dim", `Select ${min}${max} • Space toggles`));
 		}
 		add(" ", "");
-		if (question.options.length === 0 || mode === "typing") {
-			renderTyping(add, lines, renderWidth, question);
-		} else {
-			renderRows(add, question);
+		if (question.options.length === 0) {
+			if (question.placeholder && editorText.length === 0) {
+				add(" ", theme.fg("dim", question.placeholder));
+			}
+			for (const line of editor.render(Math.max(1, renderWidth - 2))) {
+				lines.push(` ${line}`);
+			}
+			return;
 		}
+		renderRows(add, lines, renderWidth, question);
 	}
 
 	function renderSubmit(add: AddLine): void {
@@ -682,13 +708,6 @@ export function createQuestionnaireComponent(
 			const answer = getAnswer(question);
 			const active = submitCursor === index;
 			const marker = active ? theme.fg("accent", "❯ ") : "  ";
-			const status = answerStatus(question, answer);
-			const icon =
-				status === "complete"
-					? theme.fg("success", "✓ ")
-					: status === "partial"
-						? theme.fg("accent", "◐ ")
-						: "";
 			let summary: string;
 			if (answer.skipped) {
 				summary = theme.fg("dim", "(skipped)");
@@ -703,7 +722,7 @@ export function createQuestionnaireComponent(
 					)
 					.join(theme.fg("dim", ", "));
 			}
-			add(marker, `${icon}${theme.fg("muted", `${question.label}: `)}${summary}`);
+			add(marker, `${theme.fg("muted", `${question.label}: `)}${summary}`);
 		}
 		add(" ", "");
 		const ready = errors.length === 0;
@@ -728,20 +747,16 @@ export function createQuestionnaireComponent(
 		if (showTabs && tab === submitTabIndex) {
 			return `↑↓ choose • Enter open or ${options.submitLabel} • Tab switch • Esc cancel`;
 		}
-		const question = questions[tab];
+		const question = currentQuestion();
 		if (!question) {
 			return "Tab switch • Esc cancel";
 		}
-		const typing = mode === "typing" || question.options.length === 0;
-		if (typing) {
-			if (question.options.length === 0 && question.multiple) {
-				return "Enter add • empty Enter finish • Esc cancel";
-			}
-			if (question.options.length > 0) {
-				return "Enter submit • Esc back to options";
-			}
+		if (question.options.length === 0) {
 			return "Enter submit • \\+Enter newline • Esc cancel";
 		}
+		if (cursorRow(question)?.kind === "custom") {
+			return "Type your answer • Enter confirm • ↑↓ move • Tab switch • Esc cancel";
+		}
 		if (question.multiple) {
 			return "↑↓ move • Space toggle • A all • C clear • 1-9 jump • Enter confirm • Tab switch";
 		}
@@ -794,29 +809,6 @@ export function createQuestionnaireComponent(
 		return lines;
 	}
 
-	// ── Typing sub-render (declared separately to keep render readable) ──
-
-	function renderTyping(
-		add: AddLine,
-		lines: string[],
-		renderWidth: number,
-		question: NormalizedQuestion,
-	): void {
-		const answer = getAnswer(question);
-		if (question.options.length === 0 && answer.entries.length > 0) {
-			answer.entries.forEach((entry, index) => {
-				add(" ", theme.fg("success", `${index + 1}. ${entry.value}`));
-			});
-			add(" ", "");
-		}
-		if (question.placeholder && editorText.length === 0) {
-			add(" ", theme.fg("dim", question.placeholder));
-		}
-		for (const line of editor.render(Math.max(1, renderWidth - 2))) {
-			lines.push(` ${line}`);
-		}
-	}
-
 	// ── Editor wiring ────────────────────────────────────────────────────
 
 	const editorTheme: EditorTheme = {
@@ -832,13 +824,29 @@ export function createQuestionnaireComponent(
 	const editor = new Editor(tui, editorTheme);
 	editor.onChange = (value) => {
 		editorText = value;
+		if (!suppressEditorEvents) {
+			applyEditorText(value);
+		}
 		cachedLines = undefined;
 	};
 	editor.onSubmit = (value) => {
-		submitTyped(value);
+		const question = currentQuestion();
+		if (!question) {
+			return;
+		}
+		// submitValue() clears the editor and fires onChange("") before calling
+		// onSubmit, so re-apply the submitted text before validating.
+		applyEditorText(value);
+		const error = answerError(question, answers.get(question.id));
+		if (error) {
+			notice = { text: error, kind: "warning" };
+			refresh();
+			return;
+		}
+		advance();
 	};
 
-	prepareQuestion(questions[0], false);
+	prepareQuestion(questions[0]);
 
 	const onAbort = (): void => {
 		finished = true;
@@ -848,10 +856,11 @@ export function createQuestionnaireComponent(
 
 	return {
 		get focused(): boolean {
-			return editor.focused;
+			return componentFocused;
 		},
 		set focused(value: boolean) {
-			editor.focused = value;
+			componentFocused = value;
+			syncEditorFocus();
 		},
 		render,
 		handleInput,