@geoqiao/pi-ask 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [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)
+
+
+### Bug Fixes
+
+* harden RPC fallback interactions ([4cceb3b](https://github.com/geoqiao/pi-ask/commit/4cceb3b2ab8d19b46f4688a53f8b7ae52e2b06ae))
+
 # [1.2.0](https://github.com/geoqiao/pi-ask/compare/v1.1.0...v1.2.0) (2026-08-16)
 
 

package/README.md

@@ -3,6 +3,7 @@
 # @geoqiao/pi-ask
 
 [![npm downloads](https://badgen.net/npm/dm/@geoqiao/pi-ask)](https://www.npmjs.com/package/@geoqiao/pi-ask)
+[![CI](https://github.com/geoqiao/pi-ask/actions/workflows/ci.yml/badge.svg)](https://github.com/geoqiao/pi-ask/actions/workflows/ci.yml)
 [![last commit](https://badgen.net/github/last-commit/geoqiao/pi-ask)](https://github.com/geoqiao/pi-ask/commits/main)
 [![stars](https://badgen.net/github/stars/geoqiao/pi-ask)](https://github.com/geoqiao/pi-ask/stargazers)
 
@@ -200,14 +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
+- 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

@@ -160,7 +160,7 @@ This document defines the stable external behavior. It does not explain internal
 
 ## Output rules
 
-- `cancelled: true` means the user dismissed the flow, UI was unavailable, or the payload was invalid before UI opened
+- `cancelled: true` means the user dismissed a flow-level selection, chose Cancel, aborted the flow, UI was unavailable, or the payload was invalid before UI opened
 - invalid payloads return `error.kind === "invalid_input"` with structured `issues` and a transcript-friendly `Invalid ask_user payload:` message
 - `mode: "submit"` is normal completion; `mode: "elaborate"` means the user asked the agent to continue with follow-up clarification based on notes
 - unanswered questions are omitted from `answers`
@@ -175,7 +175,7 @@ This document defines the stable external behavior. It does not explain internal
 - `customText` stores the free-form answer
 - on single-select questions, saving free-form text clears selected options for that question
 - on multi-select questions, `values` and `labels` include both selected options and `customText` when both are present
-- on multi-select questions, selected options keep their original order and `customText` is appended last
+- on multi-select questions, selected options keep the user's selection order and `customText` is appended last
 - submitting free-form text on a multi-select question stays on the same question tab and marks the custom row selected
 - on multi-select questions, toggling an empty custom row opens the free-form editor, while toggling a custom row with saved free-form text selects or deselects it without opening the editor or clearing the text
 - saving or clearing free-form text on a multi-select question does not clear other selected options
@@ -259,16 +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 original option 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 value dialog or choosing Cancel returns `cancelled: true`
+- 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/docs/remote-events.md

@@ -18,7 +18,7 @@ Remote submit:
 
 ## Started
 
-Emitted after a validated ask UI flow opens.
+Emitted after a validated TUI ask flow opens. The RPC portable-dialog fallback does not start the remote event bridge or emit lifecycle events.
 
 ```ts
 type PiAskStartedEvent = {
@@ -104,7 +104,7 @@ Correlate by `requestId` and `flowId`. Do not depend on strict ordering between
 
 ## Completed
 
-Emitted when the flow resolves.
+Emitted when the TUI flow resolves. RPC portable-dialog completion is returned through the normal tool result instead.
 
 ```ts
 type PiAskCompletedEvent = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoqiao/pi-ask",
-  "version": "1.2.0",
+  "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/ask-tool.ts

@@ -51,7 +51,7 @@ async function executeAskTool(
 	pi: Pick<ExtensionAPI, "appendEntry">,
 	toolCallId: string,
 	params: AskParams,
-	_signal: AbortSignal | undefined,
+	signal: AbortSignal | undefined,
 	_onUpdate: unknown,
 	ctx: ExtensionContext,
 	remoteAsk?: RemoteAskRuntime
@@ -70,7 +70,9 @@ async function executeAskTool(
 	});
 	if (ctx.mode !== "tui") {
 		if (ctx.mode === "rpc" && ctx.hasUI) {
-			return successfulResponse(await runRpcAskFlow(ctx, validation.state));
+			return successfulResponse(
+				await runRpcAskFlow(ctx, validation.state, { signal })
+			);
 		}
 		return nonInteractiveResponse(validation.state);
 	}

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,62 +14,58 @@ import type {
 	AskStateAnswer,
 } from "../types.ts";
 
-type RpcUi = Pick<ExtensionContext["ui"], "editor" | "input" | "select">;
+type RpcUi = Pick<ExtensionContext["ui"], "input" | "select">;
 
-interface RpcStepResult {
-	cancelled: boolean;
-	state: AskState;
+interface RpcFlowOptions {
+	signal?: AbortSignal;
 }
 
+type RpcQuestionResult =
+	| { kind: "cancelled"; state: AskState }
+	| { kind: "completed"; 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 },
-	initialState: AskState
+	initialState: AskState,
+	options: RpcFlowOptions = {}
 ): Promise<AskResult> {
 	let state = initialState;
 
 	for (const [questionIndex] of state.questions.entries()) {
-		const answerStep = await askQuestion(ctx.ui, state, questionIndex);
-		state = answerStep.state;
-		if (answerStep.cancelled) {
+		if (options.signal?.aborted) {
 			return cancelledResult(state);
 		}
 
-		const noteStep = await askForOptionalNotes(ctx.ui, state, questionIndex);
-		state = noteStep.state;
-		if (noteStep.cancelled) {
+		const step = await askQuestion(
+			ctx.ui,
+			state,
+			questionIndex,
+			options.signal
+		);
+		state = step.state;
+		if (step.kind === "cancelled") {
 			return cancelledResult(state);
 		}
 	}
 
+	if (options.signal?.aborted) {
+		return cancelledResult(state);
+	}
+
 	return toAskResult({
 		...state,
 		activeTabIndex: state.questions.length,
@@ -84,396 +76,102 @@ export async function runRpcAskFlow(
 async function askQuestion(
 	ui: RpcUi,
 	state: AskState,
-	questionIndex: number
-): Promise<RpcStepResult> {
+	questionIndex: number,
+	signal?: AbortSignal
+): Promise<RpcQuestionResult> {
 	const question = state.questions[questionIndex];
 	if (!question) {
-		return { cancelled: false, state };
+		return { kind: "completed", state };
 	}
-	if (question.type === "multi") {
-		return await askMultiQuestion(ui, state, question, questionIndex);
-	}
-	return await askSingleQuestion(ui, state, question, questionIndex);
-}
 
-async function askSingleQuestion(
-	ui: RpcUi,
-	state: AskState,
-	question: AskQuestion,
-	questionIndex: number
-): Promise<RpcStepResult> {
-	const actions: SelectAction[] = question.options
-		.filter((option) => !option.freeform)
-		.map((option, optionIndex) => ({
-			kind: "option" as const,
-			label: formatOption(option, optionIndex),
-			optionIndex,
-		}));
-	appendCommonActions(actions, question);
-
-	const action = await selectAction(
+	const actions = createQuestionActions(question);
+	const selection = await selectAction(
 		ui,
 		formatTitle(state, question, questionIndex),
-		actions
+		actions,
+		signal
 	);
-	return applySingleAction({
-		action,
-		question,
-		questionIndex,
-		state,
-		ui,
-	});
-}
 
-async function applySingleAction(args: {
-	action: SelectAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<RpcStepResult> {
-	const { action, question, questionIndex, state, ui } = args;
-	if (!action || action.kind === "cancel") {
-		return { cancelled: true, state };
+	if (selection.kind === "aborted" || selection.kind === "invalid") {
+		return { kind: "cancelled", state };
 	}
-	if (action.kind === "skip") {
-		return { cancelled: false, state: clearAnswer(state, question.id) };
-	}
-	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		return await askForCustomAnswer(
-			ui,
-			state,
-			question,
-			questionIndex,
-			action.kind === "custom-editor"
-		);
-	}
-	if (action.kind !== "option") {
-		return { cancelled: true, state };
-	}
-
-	return selectSingleOption(state, question, action.optionIndex);
-}
-
-function selectSingleOption(
-	state: AskState,
-	question: AskQuestion,
-	optionIndex: number | undefined
-): RpcStepResult {
-	const option =
-		optionIndex === undefined ? undefined : question.options[optionIndex];
-	if (!option || optionIndex === undefined) {
-		return { cancelled: true, state };
+	if (selection.kind === "dismissed") {
+		return {
+			kind: "completed",
+			state: clearAnswer(state, question.id),
+		};
 	}
-	return {
-		cancelled: false,
-		state: updateAnswer(state, question.id, (answer) =>
-			setSingleSelection(answer, option, optionIndex)
-		),
-	};
-}
-
-async function askMultiQuestion(
-	ui: RpcUi,
-	initialState: AskState,
-	question: AskQuestion,
-	questionIndex: number
-): Promise<RpcStepResult> {
-	let state = initialState;
-	while (true) {
-		const actions = createMultiActions(question, state.answers[question.id]);
-		const action = await selectAction(
-			ui,
-			formatTitle(state, question, questionIndex, "Select all that apply"),
-			actions
-		);
-		const actionResult = await applyMultiAction({
-			action,
-			question,
-			questionIndex,
-			state,
-			ui,
-		});
-		if (actionResult.done) {
-			return actionResult.step;
-		}
-		state = actionResult.state;
+	if (selection.action.kind === "custom") {
+		return await askForCustomAnswer(ui, state, question, questionIndex, signal);
 	}
-}
 
-function createMultiActions(
-	question: AskQuestion,
-	answer: AskStateAnswer | undefined
-): SelectAction[] {
-	const actions: SelectAction[] = question.options
-		.filter((option) => !option.freeform)
-		.map((option, optionIndex) => ({
-			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;
+	return selectOption(state, question, selection.action.optionIndex);
 }
 
-type MultiActionResult =
-	| { done: false; state: AskState }
-	| { done: true; step: RpcStepResult };
-
-async function applyMultiAction(args: {
-	action: SelectAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<MultiActionResult> {
-	const { action, question, questionIndex, state, ui } = args;
-	if (!action || action.kind === "cancel") {
-		return { done: true, step: { cancelled: true, state } };
-	}
-	if (action.kind === "finish") {
-		return { done: true, step: { cancelled: false, state } };
-	}
-	if (action.kind === "skip") {
-		return {
-			done: true,
-			step: { cancelled: false, state: clearAnswer(state, question.id) },
-		};
-	}
-	if (action.kind === "custom-input" || action.kind === "custom-editor") {
-		const step = await askForCustomAnswer(
-			ui,
-			state,
-			question,
-			questionIndex,
-			action.kind === "custom-editor"
-		);
-		return step.cancelled
-			? { done: true, step }
-			: { done: false, state: step.state };
-	}
-	return applyMultiOptionAction(state, question, action);
+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 applyMultiOptionAction(
+function selectOption(
 	state: AskState,
 	question: AskQuestion,
-	action: SelectAction
-): MultiActionResult {
-	const optionIndex = action.optionIndex;
+	optionIndex: number | undefined
+): RpcQuestionResult {
 	const option =
 		optionIndex === undefined ? undefined : question.options[optionIndex];
 	if (!option || optionIndex === undefined) {
-		return { done: true, step: { cancelled: true, state } };
-	}
-	return {
-		done: false,
-		state: updateAnswer(state, question.id, (currentAnswer) => {
-			const nextAnswer = toggleSelection(currentAnswer, option, optionIndex);
-			return {
-				...nextAnswer,
-				selected: [...nextAnswer.selected].sort(
-					(left, right) => left.index - right.index
-				),
-			};
-		}),
-	};
-}
-
-async function askForCustomAnswer(
-	ui: RpcUi,
-	state: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	multiline: boolean
-): Promise<RpcStepResult> {
-	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));
-	if (value === undefined) {
-		return { cancelled: true, state };
+		return { kind: "cancelled", state };
 	}
 
 	return {
-		cancelled: false,
+		kind: "completed",
 		state: updateAnswer(state, question.id, (answer) =>
-			saveCustomText(
-				answer,
-				value,
-				question.type === "multi" ? "multi" : "single"
-			)
+			setSingleSelection(answer, option, optionIndex)
 		),
 	};
 }
 
-async function askForOptionalNotes(
-	ui: RpcUi,
-	initialState: AskState,
-	questionIndex: number
-): Promise<RpcStepResult> {
-	let state = initialState;
-	const question = state.questions[questionIndex];
-	if (!question) {
-		return { cancelled: false, state };
-	}
-
-	while (true) {
-		const answer = state.answers[question.id];
-		const actions = createNoteActions(answer);
-		const action = await selectNoteAction(
-			ui,
-			formatTitle(state, question, questionIndex, "Optional notes"),
-			actions
-		);
-		const actionResult = await applyNoteAction({
-			action,
-			question,
-			questionIndex,
-			state,
-			ui,
-		});
-		if (actionResult.done) {
-			return actionResult.step;
-		}
-		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: ${compactText(selection.label)}…`
-				: `Add note for selected option: ${compactText(selection.label)}…`,
-		})),
-		{ kind: "cancel", label: CANCEL_LABEL },
-	];
-}
-
-type NoteActionResult =
-	| { done: false; state: AskState }
-	| { done: true; step: RpcStepResult };
-
-async function applyNoteAction(args: {
-	action: NoteAction | undefined;
-	question: AskQuestion;
-	questionIndex: number;
-	state: AskState;
-	ui: RpcUi;
-}): Promise<NoteActionResult> {
-	const { action, question, questionIndex, state, ui } = args;
-	if (!action || action.kind === "cancel") {
-		return { done: true, step: { cancelled: true, state } };
-	}
-	if (action.kind === "continue") {
-		return { done: true, step: { cancelled: false, state } };
-	}
-	if (action.kind === "question-input") {
-		return await editQuestionNote(ui, state, question, questionIndex, false);
-	}
-	if (action.kind === "question-editor") {
-		return await editQuestionNote(ui, state, question, questionIndex, true);
-	}
-	return await editOptionNote(ui, state, question, questionIndex, action);
-}
-
-async function editQuestionNote(
+async function askForCustomAnswer(
 	ui: RpcUi,
 	state: AskState,
 	question: AskQuestion,
 	questionIndex: number,
-	multiline: boolean
-): Promise<NoteActionResult> {
-	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));
-	if (value === undefined) {
-		return { done: true, step: { cancelled: true, state } };
+	signal?: AbortSignal
+): Promise<RpcQuestionResult> {
+	if (signal?.aborted) {
+		return { kind: "cancelled", state };
 	}
-	return {
-		done: false,
-		state: updateAnswer(state, question.id, (answer) =>
-			saveQuestionNote(answer, value)
-		),
-	};
-}
 
-async function editOptionNote(
-	ui: RpcUi,
-	state: AskState,
-	question: AskQuestion,
-	questionIndex: number,
-	action: NoteAction
-): Promise<NoteActionResult> {
-	const optionValue = action.optionValue;
-	const option = question.options.find(
-		(candidate) => candidate.value === optionValue
+	const value = await ui.input(
+		formatTitle(state, question, questionIndex, TYPE_SOMETHING_LABEL),
+		question.type === "multi"
+			? "Enter one or more answers"
+			: "Enter your answer",
+		{ signal }
 	);
-	if (!(optionValue && option)) {
-		return { done: true, step: { cancelled: true, state } };
+	if (signal?.aborted) {
+		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 (value === undefined) {
-		return { done: true, step: { cancelled: true, state } };
+		return {
+			kind: "completed",
+			state: clearAnswer(state, question.id),
+		};
 	}
+
 	return {
-		done: false,
+		kind: "completed",
 		state: updateAnswer(state, question.id, (answer) =>
-			saveOptionNote(answer, optionValue, value)
+			saveCustomText(answer, value, "single")
 		),
 	};
 }
@@ -481,25 +179,27 @@ async function editOptionNote(
 async function selectAction(
 	ui: RpcUi,
 	title: string,
-	actions: SelectAction[]
-): Promise<SelectAction | undefined> {
-	const selected = await ui.select(
-		title,
-		actions.map((action) => action.label)
-	);
-	return actions.find((action) => action.label === selected);
-}
+	actions: SelectAction[],
+	signal?: AbortSignal
+): Promise<SelectResult> {
+	if (signal?.aborted) {
+		return { kind: "aborted" };
+	}
 
-async function selectNoteAction(
-	ui: RpcUi,
-	title: string,
-	actions: NoteAction[]
-): Promise<NoteAction | undefined> {
 	const selected = await ui.select(
 		title,
-		actions.map((action) => action.label)
+		actions.map((action) => action.label),
+		{ signal }
 	);
-	return actions.find((action) => action.label === selected);
+	if (signal?.aborted) {
+		return { kind: "aborted" };
+	}
+	if (selected === undefined) {
+		return { kind: "dismissed" };
+	}
+
+	const action = actions.find((candidate) => candidate.label === selected);
+	return action ? { action, kind: "selected" } : { kind: "invalid" };
 }
 
 function updateAnswer(
@@ -546,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;
-}