@geoqiao/pi-ask 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.2.2](https://github.com/geoqiao/pi-ask/compare/v1.2.1...v1.2.2) (2026-08-16)
+
+
+### Bug Fixes
+
+* simplify RPC question flow ([68a0f29](https://github.com/geoqiao/pi-ask/commit/68a0f29cc88dae906fe4a105714eb71d45654776))
+
 ## [1.2.1](https://github.com/geoqiao/pi-ask/compare/v1.2.0...v1.2.1) (2026-08-16)
 
 

package/README.md

@@ -201,16 +201,15 @@ Agents can auto-discover and call `ask_user` when they need clarification instea
 
 When Pi runs in RPC mode with portable extension UI support, `ask_user` keeps the same normalized result contract but uses sequential dialogs:
 
-- single choices, including Yes/No pairs, use cancellable `select` dialogs
-- short custom answers use `input`; multiline answers use `editor`
-- each question offers explicit Skip and Cancel actions, followed by optional question/selected-option note actions
-- multi-select repeats `select` with `[ ]` / `[x]` markers until `Finish selection` is chosen
+- each question card contains only its real options plus `Type something…`
+- selecting a real option and submitting advances directly to the next question or completes the flow
+- `Type something…` opens one `input` dialog; on multi questions it is the fallback for entering multiple choices
+- dismissing a question or its input skips that question instead of cancelling the flow
 - descriptions and preview content are flattened into readable option strings
 - multiple questions include `[current/total]` progress in each dialog title
-- dismissing a question or notes-menu `select` cancels the flow, while dismissing a nested answer/note editor returns to its parent dialog
-- tool abort signals close portable `select`/`input` dialogs; Pi's portable `editor` cannot be interrupted until it resolves
+- tool abort signals close portable `select`/`input` dialogs and return `cancelled: true`
 
-RPC intentionally does not reproduce the tabbed same-screen form, native checkbox cards, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. The fallback completes in `submit` mode after the sequential questions. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
+RPC intentionally does not reproduce the tabbed same-screen form, native checkbox cards, repeated multi-select cards, notes, Skip/Cancel option rows, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. The fallback completes in `submit` mode after the sequential questions. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
 
 ### Answer and replay commands
 

package/docs/architecture.md

@@ -69,6 +69,9 @@ The codebase is split so the implementation reads through file boundaries and na
 - submit is never blocked by unanswered questions
 - TUI state and controller behavior stay isolated from the RPC portable-dialog controller
 - RPC answers are written through shared answer helpers and serialized through the shared result builder
+- each RPC question card contains only real options plus one `Type something…` fallback; submitting a choice advances without a second confirmation card
+- RPC dismissal skips the current question, while an actual tool abort cancels the flow
+- RPC multi questions accept one scalar option or free-form text containing multiple choices; they do not emulate checkbox state with repeated dialogs
 - single-select answers serialize as arrays
 - when `behaviour.presentSingleAsMulti` is enabled, future single-select questions are handled with multi-select state semantics while result metadata preserves the requested `type` and adds `presentedType`
 - active-flow question type changes are per-question runtime overrides handled in state/controller logic; they do not mutate the stored source payload or global config

package/docs/contract.md

@@ -259,18 +259,17 @@ Dirty dismiss:
 
 The rich ask flow uses `ctx.ui.custom()` only in TUI mode. RPC mode never calls `custom()`; when portable extension dialogs are available it asks questions sequentially and serializes answers through the same state/result helpers:
 
-- single choices, including Yes/No pairs, use `select` so dismissal remains distinct from choosing `No`
-- short and multiline custom answers use `input` and `editor`
-- every question exposes Skip explicitly; required remains advisory and its Skip label says so
-- after each question, a portable action dialog can add/edit a short or multiline question note, or an editor note for a selected option
-- multi-select repeatedly calls `select`, showing `[ ]` / `[x]` option markers and a `Finish selection` action; selections are collected locally in the user's selection order
+- every question uses one `select` card containing the real options followed by `Type something…`
+- selecting and submitting a real option advances directly; no confirmation, notes, review, or continuation card follows it
+- `Type something…` opens one `input` dialog and serializes the entered text through the existing `customText`, `values`, `labels`, and `indices` result fields
+- RPC does not emulate native multi-select: choosing one real option records that option, while `Type something…` lets the user enter multiple choices as free-form text
 - descriptions and preview content are flattened into option strings instead of using a custom preview pane
 - multiple questions are sequential and every title includes `[current/total]` progress
-- dismissing a question or optional-notes action `select`, choosing Cancel, or aborting the tool returns `cancelled: true`
-- dismissing a nested custom-answer or note `input`/`editor` abandons that edit and returns to its parent action dialog without changing the answer
-- `select` and `input` observe the tool abort signal; Pi's portable `editor` API has no signal or timeout option, so an abort is observed only after an open editor resolves
+- dismissing a question card or its custom input skips that question; a dismissed required question is also left unanswered because required remains advisory
+- RPC does not add Skip or Cancel rows because the portable client's native Dismiss control already provides the skip behavior
+- `select` and `input` observe the tool abort signal; an actual tool abort returns `cancelled: true`
 
-RPC does not provide the tabbed same-screen form, native checkbox cards, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. RPC completion uses `mode: "submit"`. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
+RPC does not provide the tabbed same-screen form, native checkbox cards, repeated multi-select cards, notes, custom preview pane, question-type hotkeys, settings overlay, or final Submit/Elaborate review tab. RPC completion uses `mode: "submit"`. `/answer`, `/answer:again`, `/ask:replay`, and `/ask-settings` remain TUI-only.
 
 In print, JSON, other non-TUI modes, or RPC without portable UI availability, the tool returns a `Needs user input: ask_user requires interactive TUI mode.` message in `content` and a cancelled result in `details` instead of opening UI.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoqiao/pi-ask",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Pi package that adds an interactive ask_user clarification tool.",
   "license": "MIT",
   "type": "module",

package/src/ask-tool-helpers.ts

@@ -13,7 +13,7 @@ import type {
 } from "./types.ts";
 
 export const ASK_TOOL_DESCRIPTION =
-	"Interactive clarification tool for cases where the next step depends on user preferences, missing requirements, or choosing between multiple valid directions. Ask a short structured interview, collect normalized answers, and continue using those answers explicitly instead of guessing. TUI mode supports single-select, multi-select, and preview-pane questions; RPC mode presents questions sequentially, implements multi-select with repeated portable dialogs, and flattens preview details into option text. Always include a machine-readable `value` for every option. Use `preview` only when every option includes `preview` text; descriptions alone are not enough.";
+	"Interactive clarification tool for cases where the next step depends on user preferences, missing requirements, or choosing between multiple valid directions. Ask a short structured interview, collect normalized answers, and continue using those answers explicitly instead of guessing. TUI mode supports single-select, multi-select, and preview-pane questions; RPC mode presents questions sequentially, offers one portable choice per question plus a typed-answer fallback, and flattens preview details into option text. Always include a machine-readable `value` for every option. Use `preview` only when every option includes `preview` text; descriptions alone are not enough.";
 
 export const ASK_TOOL_PROMPT_GUIDELINES = [
 	"Use `ask_user` before making preference-sensitive decisions about scope, tone, UX, naming, architecture, docs, or implementation direction.",
@@ -25,7 +25,7 @@ export const ASK_TOOL_PROMPT_GUIDELINES = [
 	"After an `ask_user` elaboration or follow-up note, prefer another structured `ask_user` follow-up if a choice is still needed instead of switching to plain-text multiple choice in chat.",
 	"When prior `ask_user` answers narrow the branch, bundle the next 2-3 related unresolved decisions into one follow-up `ask_user` call when possible.",
 	"Use one-at-a-time `ask_user` follow-up calls only when the next question materially depends on the previous answer.",
-	"Do not promise same-screen forms, native checkbox cards, or a custom preview pane when `ask_user` is rendered through RPC; the portable fallback asks questions sequentially and uses a repeated-select loop for multi-select.",
+	"Do not promise same-screen forms, native checkbox cards, or a custom preview pane when `ask_user` is rendered through RPC; the portable fallback asks questions sequentially, and users type multiple choices through `Type something…` when one scalar selection is insufficient.",
 ] as const;
 
 interface ValidateParamsOptions {

package/src/rpc/controller.ts

@@ -2,12 +2,8 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	emptyAnswer,
 	isAnswerEmpty,
-	isOptionSelected,
 	saveCustomText,
-	saveOptionNote,
-	saveQuestionNote,
 	setSingleSelection,
-	toggleSelection,
 } from "../state/answers.ts";
 import { toAskResult } from "../state/result.ts";
 import type {
@@ -18,51 +14,29 @@ import type {
 	AskStateAnswer,
 } from "../types.ts";
 
-type RpcUi = Pick<ExtensionContext["ui"], "editor" | "input" | "select">;
+type RpcUi = Pick<ExtensionContext["ui"], "input" | "select">;
 
 interface RpcFlowOptions {
 	signal?: AbortSignal;
 }
 
-type RpcCompletionResult =
+type RpcQuestionResult =
 	| { kind: "cancelled"; state: AskState }
 	| { kind: "completed"; state: AskState };
 
-type RpcActionResult = RpcCompletionResult | { kind: "back"; state: AskState };
-
-type RpcEditResult =
-	| { kind: "back"; state: AskState }
-	| { kind: "cancelled"; state: AskState }
-	| { kind: "saved"; state: AskState };
-
 interface SelectAction {
-	kind:
-		| "cancel"
-		| "custom-editor"
-		| "custom-input"
-		| "finish"
-		| "option"
-		| "skip";
+	kind: "custom" | "option";
 	label: string;
 	optionIndex?: number;
 }
 
-interface NoteAction {
-	kind:
-		| "cancel"
-		| "continue"
-		| "option-note"
-		| "question-editor"
-		| "question-input";
-	label: string;
-	optionValue?: string;
-}
+type SelectResult =
+	| { kind: "aborted" }
+	| { kind: "dismissed" }
+	| { kind: "invalid" }
+	| { action: SelectAction; kind: "selected" };
 
-const CANCEL_LABEL = "Cancel ask";
-const CONTINUE_LABEL = "Continue";
-const CUSTOM_EDITOR_LABEL = "Write or edit a multiline answer…";
-const CUSTOM_INPUT_LABEL = "Type or edit a short answer…";
-const FINISH_SELECTION_LABEL = "Finish selection";
+const TYPE_SOMETHING_LABEL = "Type something…";
 
 export async function runRpcAskFlow(
 	ctx: { ui: RpcUi },
@@ -75,28 +49,19 @@ export async function runRpcAskFlow(
 		if (options.signal?.aborted) {
 			return cancelledResult(state);
 		}
-		const answerStep = await askQuestion(
-			ctx.ui,
-			state,
-			questionIndex,
-			options.signal
-		);
-		state = answerStep.state;
-		if (answerStep.kind === "cancelled") {
-			return cancelledResult(state);
-		}
 
-		const noteStep = await askForOptionalNotes(
+		const step = await askQuestion(
 			ctx.ui,
 			state,
 			questionIndex,
 			options.signal
 		);
-		state = noteStep.state;
-		if (noteStep.kind === "cancelled") {
+		state = step.state;
+		if (step.kind === "cancelled") {
 			return cancelledResult(state);
 		}
 	}
+
 	if (options.signal?.aborted) {
 		return cancelledResult(state);
 	}
@@ -113,107 +78,60 @@ async function askQuestion(
 	state: AskState,
 	questionIndex: number,
 	signal?: AbortSignal
-): Promise<RpcCompletionResult> {
+): Promise<RpcQuestionResult> {
 	const question = state.questions[questionIndex];
 	if (!question) {
 		return { kind: "completed", state };
 	}
-	if (question.type === "multi") {
-		return await askMultiQuestion(ui, state, question, questionIndex, signal);
-	}
-	return await askSingleQuestion(ui, state, question, questionIndex, signal);
-}
-
-async function askSingleQuestion(
-	ui: RpcUi,
-	initialState: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	signal?: AbortSignal
-): Promise<RpcCompletionResult> {
-	let state = initialState;
-	while (true) {
-		if (signal?.aborted) {
-			return { kind: "cancelled", state };
-		}
-		const actions: SelectAction[] = [...question.options.entries()]
-			.filter(([, option]) => !option.freeform)
-			.map(([optionIndex, option]) => ({
-				kind: "option" as const,
-				label: formatOption(option, optionIndex),
-				optionIndex,
-			}));
-		appendCommonActions(actions, question);
 
-		const action = await selectAction(
-			ui,
-			formatTitle(state, question, questionIndex),
-			actions,
-			signal
-		);
-		const result = await applySingleAction({
-			action,
-			question,
-			questionIndex,
-			signal,
-			state,
-			ui,
-		});
-		if (result.kind !== "back") {
-			return result;
-		}
-		state = result.state;
-	}
-}
+	const actions = createQuestionActions(question);
+	const selection = await selectAction(
+		ui,
+		formatTitle(state, question, questionIndex),
+		actions,
+		signal
+	);
 
-async function applySingleAction(args: {
-	action: SelectAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	signal?: AbortSignal;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<RpcActionResult> {
-	const { action, question, questionIndex, signal, state, ui } = args;
-	if (!action || action.kind === "cancel") {
+	if (selection.kind === "aborted" || selection.kind === "invalid") {
 		return { kind: "cancelled", state };
 	}
-	if (action.kind === "skip") {
+	if (selection.kind === "dismissed") {
 		return {
 			kind: "completed",
 			state: clearAnswer(state, question.id),
 		};
 	}
-	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		const editResult = await askForCustomAnswer(
-			ui,
-			state,
-			question,
-			questionIndex,
-			action.kind === "custom-editor",
-			signal
-		);
-		return editResult.kind === "saved"
-			? { kind: "completed", state: editResult.state }
-			: editResult;
-	}
-	if (action.kind !== "option") {
-		return { kind: "cancelled", state };
+	if (selection.action.kind === "custom") {
+		return await askForCustomAnswer(ui, state, question, questionIndex, signal);
 	}
 
-	return selectSingleOption(state, question, action.optionIndex);
+	return selectOption(state, question, selection.action.optionIndex);
 }
 
-function selectSingleOption(
+function createQuestionActions(question: AskQuestion): SelectAction[] {
+	return [
+		...[...question.options.entries()]
+			.filter(([, option]) => !option.freeform)
+			.map(([optionIndex, option]) => ({
+				kind: "option" as const,
+				label: formatOption(option, optionIndex),
+				optionIndex,
+			})),
+		{ kind: "custom", label: TYPE_SOMETHING_LABEL },
+	];
+}
+
+function selectOption(
 	state: AskState,
 	question: AskQuestion,
 	optionIndex: number | undefined
-): RpcCompletionResult {
+): RpcQuestionResult {
 	const option =
 		optionIndex === undefined ? undefined : question.options[optionIndex];
 	if (!option || optionIndex === undefined) {
 		return { kind: "cancelled", state };
 	}
+
 	return {
 		kind: "completed",
 		state: updateAnswer(state, question.id, (answer) =>
@@ -222,341 +140,38 @@ function selectSingleOption(
 	};
 }
 
-async function askMultiQuestion(
-	ui: RpcUi,
-	initialState: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	signal?: AbortSignal
-): Promise<RpcCompletionResult> {
-	let state = initialState;
-	while (true) {
-		if (signal?.aborted) {
-			return { kind: "cancelled", state };
-		}
-		const actions = createMultiActions(question, state.answers[question.id]);
-		const action = await selectAction(
-			ui,
-			formatTitle(state, question, questionIndex, "Select all that apply"),
-			actions,
-			signal
-		);
-		const actionResult = await applyMultiAction({
-			action,
-			question,
-			questionIndex,
-			signal,
-			state,
-			ui,
-		});
-		if (actionResult.kind !== "back") {
-			return actionResult;
-		}
-		state = actionResult.state;
-	}
-}
-
-function createMultiActions(
-	question: AskQuestion,
-	answer: AskStateAnswer | undefined
-): SelectAction[] {
-	const actions: SelectAction[] = [...question.options.entries()]
-		.filter(([, option]) => !option.freeform)
-		.map(([optionIndex, option]) => ({
-			kind: "option" as const,
-			label: formatOption(option, optionIndex, {
-				selected: isOptionSelected(answer, option.value),
-			}),
-			optionIndex,
-		}));
-	actions.push({ kind: "finish", label: FINISH_SELECTION_LABEL });
-	actions.push({
-		kind: "custom-input",
-		label: formatCustomAction(CUSTOM_INPUT_LABEL, answer),
-	});
-	actions.push({
-		kind: "custom-editor",
-		label: formatCustomAction(CUSTOM_EDITOR_LABEL, answer),
-	});
-	actions.push({ kind: "skip", label: formatSkipLabel(question) });
-	actions.push({ kind: "cancel", label: CANCEL_LABEL });
-	return actions;
-}
-
-async function applyMultiAction(args: {
-	action: SelectAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	signal?: AbortSignal;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<RpcActionResult> {
-	const { action, question, questionIndex, signal, state, ui } = args;
-	if (!action || action.kind === "cancel") {
-		return { kind: "cancelled", state };
-	}
-	if (action.kind === "finish") {
-		return { kind: "completed", state };
-	}
-	if (action.kind === "skip") {
-		return {
-			kind: "completed",
-			state: clearAnswer(state, question.id),
-		};
-	}
-	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		const editResult = await askForCustomAnswer(
-			ui,
-			state,
-			question,
-			questionIndex,
-			action.kind === "custom-editor",
-			signal
-		);
-		return editResult.kind === "cancelled"
-			? editResult
-			: { kind: "back", state: editResult.state };
-	}
-	return applyMultiOptionAction(state, question, action);
-}
-
-function applyMultiOptionAction(
-	state: AskState,
-	question: AskQuestion,
-	action: SelectAction
-): RpcActionResult {
-	const optionIndex = action.optionIndex;
-	const option =
-		optionIndex === undefined ? undefined : question.options[optionIndex];
-	if (!option || optionIndex === undefined) {
-		return { kind: "cancelled", state };
-	}
-	return {
-		kind: "back",
-		state: updateAnswer(state, question.id, (currentAnswer) =>
-			toggleSelection(currentAnswer, option, optionIndex)
-		),
-	};
-}
-
 async function askForCustomAnswer(
 	ui: RpcUi,
 	state: AskState,
 	question: AskQuestion,
 	questionIndex: number,
-	multiline: boolean,
 	signal?: AbortSignal
-): Promise<RpcEditResult> {
-	if (signal?.aborted) {
-		return { kind: "cancelled", state };
-	}
-	const currentText = state.answers[question.id]?.customText;
-	const title = formatTitle(
-		state,
-		question,
-		questionIndex,
-		multiline ? "Multiline answer" : "Short answer"
-	);
-	const value = multiline
-		? await ui.editor(title, currentText ?? "")
-		: await ui.input(title, formatInputPlaceholder(currentText), { signal });
+): Promise<RpcQuestionResult> {
 	if (signal?.aborted) {
 		return { kind: "cancelled", state };
 	}
-	if (value === undefined) {
-		return { kind: "back", state };
-	}
-
-	return {
-		kind: "saved",
-		state: updateAnswer(state, question.id, (answer) =>
-			saveCustomText(
-				answer,
-				value,
-				question.type === "multi" ? "multi" : "single"
-			)
-		),
-	};
-}
-
-async function askForOptionalNotes(
-	ui: RpcUi,
-	initialState: AskState,
-	questionIndex: number,
-	signal?: AbortSignal
-): Promise<RpcCompletionResult> {
-	let state = initialState;
-	const question = state.questions[questionIndex];
-	if (!question) {
-		return { kind: "completed", state };
-	}
-
-	while (true) {
-		if (signal?.aborted) {
-			return { kind: "cancelled", state };
-		}
-		const answer = state.answers[question.id];
-		const actions = createNoteActions(answer);
-		const action = await selectNoteAction(
-			ui,
-			formatTitle(state, question, questionIndex, "Optional notes"),
-			actions,
-			signal
-		);
-		const actionResult = await applyNoteAction({
-			action,
-			question,
-			questionIndex,
-			signal,
-			state,
-			ui,
-		});
-		if (actionResult.kind !== "back") {
-			return actionResult;
-		}
-		state = actionResult.state;
-	}
-}
-
-function appendCommonActions(
-	actions: SelectAction[],
-	question: AskQuestion
-): void {
-	actions.push({ kind: "custom-input", label: CUSTOM_INPUT_LABEL });
-	actions.push({ kind: "custom-editor", label: CUSTOM_EDITOR_LABEL });
-	actions.push({ kind: "skip", label: formatSkipLabel(question) });
-	actions.push({ kind: "cancel", label: CANCEL_LABEL });
-}
-
-function createNoteActions(answer: AskStateAnswer | undefined): NoteAction[] {
-	return [
-		{ kind: "continue", label: CONTINUE_LABEL },
-		{
-			kind: "question-input",
-			label: answer?.note
-				? "Replace or clear the short question note…"
-				: "Add a short question note…",
-		},
-		{
-			kind: "question-editor",
-			label: answer?.note
-				? "Edit the question note in a multiline editor…"
-				: "Add a multiline question note…",
-		},
-		...(answer?.selected ?? []).map((selection) => ({
-			kind: "option-note" as const,
-			optionValue: selection.value,
-			label: answer?.optionNotes?.[selection.value]
-				? `Edit note for selected option: ${selection.index}. ${compactText(selection.label)}…`
-				: `Add note for selected option: ${selection.index}. ${compactText(selection.label)}…`,
-		})),
-		{ kind: "cancel", label: CANCEL_LABEL },
-	];
-}
 
-async function applyNoteAction(args: {
-	action: NoteAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	signal?: AbortSignal;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<RpcActionResult> {
-	const { action, question, questionIndex, signal, state, ui } = args;
-	if (!action || action.kind === "cancel") {
-		return { kind: "cancelled", state };
-	}
-	if (action.kind === "continue") {
-		return { kind: "completed", state };
-	}
-	if (action.kind === "question-input") {
-		return noteEditActionResult(
-			await editQuestionNote(ui, state, question, questionIndex, false, signal)
-		);
-	}
-	if (action.kind === "question-editor") {
-		return noteEditActionResult(
-			await editQuestionNote(ui, state, question, questionIndex, true, signal)
-		);
-	}
-	return noteEditActionResult(
-		await editOptionNote(ui, state, question, questionIndex, action, signal)
+	const value = await ui.input(
+		formatTitle(state, question, questionIndex, TYPE_SOMETHING_LABEL),
+		question.type === "multi"
+			? "Enter one or more answers"
+			: "Enter your answer",
+		{ signal }
 	);
-}
-
-function noteEditActionResult(result: RpcEditResult): RpcActionResult {
-	return result.kind === "cancelled"
-		? result
-		: { kind: "back", state: result.state };
-}
-
-async function editQuestionNote(
-	ui: RpcUi,
-	state: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	multiline: boolean,
-	signal?: AbortSignal
-): Promise<RpcEditResult> {
-	if (signal?.aborted) {
-		return { kind: "cancelled", state };
-	}
-	const currentNote = state.answers[question.id]?.note;
-	const title = formatTitle(state, question, questionIndex, "Question note");
-	const value = multiline
-		? await ui.editor(title, currentNote ?? "")
-		: await ui.input(title, formatNotePlaceholder(currentNote), { signal });
 	if (signal?.aborted) {
 		return { kind: "cancelled", state };
 	}
 	if (value === undefined) {
-		return { kind: "back", state };
+		return {
+			kind: "completed",
+			state: clearAnswer(state, question.id),
+		};
 	}
-	return {
-		kind: "saved",
-		state: updateAnswer(state, question.id, (answer) =>
-			saveQuestionNote(answer, value)
-		),
-	};
-}
 
-async function editOptionNote(
-	ui: RpcUi,
-	state: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	action: NoteAction,
-	signal?: AbortSignal
-): Promise<RpcEditResult> {
-	if (signal?.aborted) {
-		return { kind: "cancelled", state };
-	}
-	const optionValue = action.optionValue;
-	const option = question.options.find(
-		(candidate) => candidate.value === optionValue
-	);
-	if (!(optionValue && option)) {
-		return { kind: "cancelled", state };
-	}
-	const value = await ui.editor(
-		formatTitle(
-			state,
-			question,
-			questionIndex,
-			`Note for ${compactText(option.label)}`
-		),
-		state.answers[question.id]?.optionNotes?.[optionValue] ?? ""
-	);
-	if (signal?.aborted) {
-		return { kind: "cancelled", state };
-	}
-	if (value === undefined) {
-		return { kind: "back", state };
-	}
 	return {
-		kind: "saved",
+		kind: "completed",
 		state: updateAnswer(state, question.id, (answer) =>
-			saveOptionNote(answer, optionValue, value)
+			saveCustomText(answer, value, "single")
 		),
 	};
 }
@@ -566,39 +181,25 @@ async function selectAction(
 	title: string,
 	actions: SelectAction[],
 	signal?: AbortSignal
-): Promise<SelectAction | undefined> {
-	if (signal?.aborted) {
-		return;
-	}
-	const selected = await ui.select(
-		title,
-		actions.map((action) => action.label),
-		{ signal }
-	);
+): Promise<SelectResult> {
 	if (signal?.aborted) {
-		return;
+		return { kind: "aborted" };
 	}
-	return actions.find((action) => action.label === selected);
-}
 
-async function selectNoteAction(
-	ui: RpcUi,
-	title: string,
-	actions: NoteAction[],
-	signal?: AbortSignal
-): Promise<NoteAction | undefined> {
-	if (signal?.aborted) {
-		return;
-	}
 	const selected = await ui.select(
 		title,
 		actions.map((action) => action.label),
 		{ signal }
 	);
 	if (signal?.aborted) {
-		return;
+		return { kind: "aborted" };
 	}
-	return actions.find((action) => action.label === selected);
+	if (selected === undefined) {
+		return { kind: "dismissed" };
+	}
+
+	const action = actions.find((candidate) => candidate.label === selected);
+	return action ? { action, kind: "selected" } : { kind: "invalid" };
 }
 
 function updateAnswer(
@@ -645,57 +246,16 @@ function formatTitle(
 	return `${progress} ${flowTitle}${compactText(question.label)}: ${compactText(question.prompt)}${detail}`;
 }
 
-function formatOption(
-	option: AskDisplayOption,
-	optionIndex: number,
-	options: { selected?: boolean } = {}
-): string {
-	let marker = "";
-	if (options.selected !== undefined) {
-		marker = options.selected ? "[x] " : "[ ] ";
-	}
+function formatOption(option: AskDisplayOption, optionIndex: number): string {
 	const description = option.description
 		? ` — ${compactText(option.description)}`
 		: "";
 	const preview = option.preview
 		? ` — Preview: ${compactText(option.preview)}`
 		: "";
-	return `${marker}${optionIndex + 1}. ${compactText(option.label)}${description}${preview}`;
-}
-
-function formatCustomAction(
-	baseLabel: string,
-	answer: AskStateAnswer | undefined
-): string {
-	if (!(answer?.customSelected && answer.customText?.trim())) {
-		return `[ ] ${baseLabel}`;
-	}
-	return `[x] ${baseLabel} — Current: ${truncateText(answer.customText)}`;
-}
-
-function formatSkipLabel(question: AskQuestion): string {
-	return question.required
-		? "Skip this question (required is advisory)"
-		: "Skip this question (optional)";
-}
-
-function formatInputPlaceholder(currentText: string | undefined): string {
-	return currentText?.trim()
-		? `Current: ${truncateText(currentText)}. Enter a replacement or leave blank to clear.`
-		: "Enter a short free-form answer";
-}
-
-function formatNotePlaceholder(currentNote: string | undefined): string {
-	return currentNote?.trim()
-		? `Current: ${truncateText(currentNote)}. Enter a replacement or leave blank to clear.`
-		: "Add an optional note or comment";
+	return `${optionIndex + 1}. ${compactText(option.label)}${description}${preview}`;
 }
 
 function compactText(value: string): string {
 	return value.replace(/\s+/g, " ").trim();
 }
-
-function truncateText(value: string): string {
-	const compact = compactText(value);
-	return compact.length > 80 ? `${compact.slice(0, 77)}…` : compact;
-}