@selesai/code 0.5.20 → 0.5.22

package/dist/extensions/question/package.json

@@ -9,10 +9,11 @@
 	},
 	"peerDependencies": {
 		"@selesai/code": "*",
+		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	},
 	"scripts": {
-		"test": "node --experimental-strip-types --test tests/**/*.test.ts"
+		"test": "tsx --test tests/**/*.test.ts"
 	}
 }

package/dist/extensions/question/question-list.ts

@@ -7,14 +7,12 @@ import {
 	type Component,
 	fuzzyFilter,
 	Key,
-	Markdown,
 	matchesKey,
 	truncateToWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 
 import { COMMENT_TOGGLE_LABEL, SPLIT_PANE_LEFT_MIN_WIDTH, SPLIT_PANE_MIN_WIDTH, SPLIT_PANE_RIGHT_MIN_WIDTH, SPLIT_PANE_SEPARATOR } from "./constants.ts";
-import { safeMarkdownTheme } from "./helpers.ts";
 import { matchesDown, matchesUp } from "./navigation.ts";
 import { renderSingleSelectRows } from "./row-layout.ts";
 import type { QuestionOption, ResolvedShortcut } from "./types.ts";
@@ -67,6 +65,22 @@ export class QuestionList implements Component {
 		return this.commentEnabled;
 	}
 
+	restoreSelection(values: readonly string[], comment?: string): void {
+		const indexes = values
+			.map((value) => this.options.findIndex((option) => option.value === value))
+			.filter((index) => index >= 0);
+		this.checked = new Set(indexes);
+		this.selectedIndex = indexes[0] ?? 0;
+		this.commentEnabled = Boolean(comment);
+		this.searchQuery = "";
+		this.invalidate();
+	}
+
+	getCheckedValues(): string[] {
+		if (!this.selectionMode.multi) return [];
+		return this.selectionMode.buildResult({ selectedIndex: this.selectedIndex, checked: this.checked, options: this.options });
+	}
+
 	setMaxVisibleRows(rows: number): void {
 		if (this.selectionMode.multi) return; // ponytail: multi-select uses fixed max 10, no-op here
 		const next = Math.max(1, Math.floor(rows));
@@ -201,7 +215,6 @@ export class QuestionList implements Component {
 
 	private buildPreviewLines(width: number, filtered: QuestionOption[], maxLines: number): string[] {
 		if (maxLines <= 0) return [];
-		const mdTheme = safeMarkdownTheme();
 		let md = "";
 
 		if (this.isCommentToggleRow(this.selectedIndex, filtered)) {
@@ -223,14 +236,9 @@ export class QuestionList implements Component {
 			}
 		}
 
-		let lines: string[];
-		if (mdTheme) {
-			lines = new Markdown(md.trim(), 0, 0, mdTheme).render(width);
-		} else {
-			lines = [];
-			for (const line of wrapTextWithAnsi(md.trim(), Math.max(10, width))) {
-				lines.push(truncateToWidth(line, width, ""));
-			}
+		const lines: string[] = [];
+		for (const line of wrapTextWithAnsi(md.trim(), Math.max(10, width))) {
+			lines.push(truncateToWidth(line, width, ""));
 		}
 		while (lines.length > 0 && lines[lines.length - 1]?.trim() === "") lines.pop();
 		if (lines.length <= maxLines) return lines;
@@ -306,7 +314,7 @@ export class QuestionList implements Component {
 				this.onEnterFreeform?.();
 				return;
 			}
-			const result = filtered[this.selectedIndex]?.label;
+			const result = filtered[this.selectedIndex]?.value;
 			if (result) this.onSubmit?.([result], this.commentEnabled);
 			else this.onCancel?.();
 			return;
@@ -393,8 +401,7 @@ export class QuestionList implements Component {
 				checked: this.checked,
 				options: this.options,
 			});
-			if (result.length > 0) this.onSubmit?.(result, this.commentEnabled);
-			else this.onCancel?.();
+			this.onSubmit?.(result, this.commentEnabled);
 		}
 	}
 

package/dist/extensions/question/row-layout.ts

@@ -60,11 +60,11 @@ export function buildItemBlocks(
 	if (allowComment) {
 		allItems.push({
 			type: "comment-toggle",
-			option: { label: `${commentEnabled ? "[✓]" : "[ ]"} ${COMMENT_TOGGLE_LABEL}` },
+			option: { value: "__comment__", label: `${commentEnabled ? "[✓]" : "[ ]"} ${COMMENT_TOGGLE_LABEL}` },
 		});
 	}
 	if (allowFreeform) {
-		allItems.push({ type: "freeform", option: { label: FREEFORM_LABEL } });
+		allItems.push({ type: "freeform", option: { value: "__other__", label: FREEFORM_LABEL } });
 	}
 
 	return allItems.map((item, itemIndex) => {

package/dist/extensions/question/schemas.ts

@@ -1,44 +1,43 @@
-// Typebox schemas for the question tool parameters.
+// Strict, batch-first TypeBox schema for the question tool.
 
+import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 
-const OptionSchema = Type.Union([
-	Type.String({ description: "Option label" }),
-	Type.Object({
-		label: Type.String({ description: "Option label shown to the user" }),
-		description: Type.Optional(Type.String({ description: "Optional help text shown under the option" })),
-	}),
-]);
+const OptionSchema = Type.Object({
+	value: Type.String({ description: "Stable machine value returned when selected" }),
+	label: Type.String({ description: "Human-readable option label" }),
+	description: Type.Optional(Type.String({ description: "Optional help text shown under the option" })),
+}, { additionalProperties: false });
+
+const QuestionBase = {
+	id: Type.Optional(Type.String({ description: "Unique answer id. Missing ids become q1, q2, and so on." })),
+	label: Type.Optional(Type.String({ description: "Short page label. Defaults to Q1, Q2, and so on." })),
+	question: Type.String({ description: "Question shown to the user" }),
+	context: Type.Optional(Type.String({ description: "Optional plain-text context shown before the question" })),
+};
+
+const SelectQuestionSchema = Type.Object({
+	...QuestionBase,
+	type: StringEnum(["select"] as const),
+	options: Type.Array(OptionSchema, { minItems: 1, description: "Available choices" }),
+	allowOther: Type.Optional(Type.Boolean({ description: "Allow a custom Other text answer" })),
+}, { additionalProperties: false });
+
+const MultiSelectQuestionSchema = Type.Object({
+	...QuestionBase,
+	type: StringEnum(["multiselect"] as const),
+	options: Type.Array(OptionSchema, { minItems: 1, description: "Available choices" }),
+	allowOther: Type.Optional(Type.Boolean({ description: "Allow custom Other text alongside selected values" })),
+}, { additionalProperties: false });
+
+const TextQuestionSchema = Type.Object({
+	...QuestionBase,
+	type: StringEnum(["text"] as const),
+}, { additionalProperties: false });
 
 export const QuestionParamsSchema = Type.Object({
-	question: Type.String({ description: "Question to ask the user before continuing" }),
-	title: Type.Optional(Type.String({ description: "Short title for the question UI (deprecated alias of context summary)" })),
-	context: Type.Optional(
-		Type.String({ description: "Relevant context summary shown before the question" }),
-	),
-	options: Type.Optional(
-		Type.Array(OptionSchema, {
-			description: "Optional multiple-choice options. Each option may be a string or { label, description }.",
-		}),
-	),
-	allowMultiple: Type.Optional(
-		Type.Boolean({ description: "Allow selecting multiple options. Default: false" }),
-	),
-	allowFreeform: Type.Optional(
-		Type.Boolean({
-			description: "Allow a custom freeform answer. Defaults to true when no options are provided, false when options exist.",
-		}),
-	),
-	allowComment: Type.Optional(
-		Type.Boolean({ description: "Collect an optional comment after selecting one or more options. Default: false" }),
-	),
-	commentToggleKey: Type.Optional(
-		Type.String({
-			description:
-				"Shortcut for toggling the optional comment/extra-context row when allowComment is true, e.g. 'ctrl+g'. Pass 'off' to disable. Default: PI_QUESTION_COMMENT_TOGGLE_KEY env var if set, otherwise 'ctrl+g'.",
-		}),
-	),
-	timeout: Type.Optional(
-		Type.Number({ description: "Auto-dismiss after N milliseconds. Returns null (cancelled) when expired." }),
-	),
-});
+	questions: Type.Array(Type.Union([SelectQuestionSchema, MultiSelectQuestionSchema, TextQuestionSchema]), {
+		minItems: 1,
+		description: "One or more typed questions shown as a paged wizard followed by atomic review and submission.",
+	}),
+}, { additionalProperties: false });

package/dist/extensions/question/selection-mode.ts

@@ -20,8 +20,8 @@ export const SingleSelect: SelectionMode = {
 	multi: false,
 	toggle() {},
 	buildResult(state) {
-		const label = state.options[state.selectedIndex]?.label;
-		return label ? [label] : [];
+		const value = state.options[state.selectedIndex]?.value;
+		return value ? [value] : [];
 	},
 	handleNumberKey(idx, count) {
 		return { toggle: false, selectIndex: Math.min(idx, count - 1) };
@@ -36,12 +36,10 @@ export const MultiSelect: SelectionMode = {
 		else checked.add(index);
 	},
 	buildResult(state) {
-		const selectedTitles = Array.from(state.checked)
+		return Array.from(state.checked)
 			.sort((a, b) => a - b)
-			.map((i) => state.options[i]?.label)
-			.filter((t): t is string => !!t);
-		const fallback = state.options[state.selectedIndex]?.label;
-		return selectedTitles.length > 0 ? selectedTitles : fallback ? [fallback] : [];
+			.map((i) => state.options[i]?.value)
+			.filter((value): value is string => !!value);
 	},
 	handleNumberKey(idx, count) {
 		return { toggle: true, selectIndex: Math.min(idx, count - 1) };

package/dist/extensions/question/tests/batch.test.ts

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildQuestionAnswers, prepareQuestions, saveDraftQuestion } from "../batch.ts";
+import type { DraftQuestionState } from "../types.ts";
+
+test("prepareQuestions: normalizes typed questions and generated ids", () => {
+	const result = prepareQuestions([
+		{ type: "select", question: "Pick a color", options: [{ value: "red", label: "Red" }, { value: "blue", label: "Blue" }] },
+		{ type: "text", id: "notes", label: "Notes", question: "Anything else?" },
+	]);
+	assert.ok("questions" in result);
+	if (!("questions" in result)) return;
+	assert.deepEqual(result.questions, [
+		{
+			id: "q1",
+			label: "Q1",
+			question: "Pick a color",
+			context: undefined,
+			type: "select",
+			options: [
+				{ value: "red", label: "Red", description: undefined },
+				{ value: "blue", label: "Blue", description: undefined },
+			],
+			allowOther: false,
+		},
+		{
+			id: "notes",
+			label: "Notes",
+			question: "Anything else?",
+			context: undefined,
+			type: "text",
+			options: [],
+			allowOther: false,
+		},
+	]);
+});
+
+test("prepareQuestions: rejects empty batches, generated-id collisions, and duplicate option values", () => {
+	assert.deepEqual(prepareQuestions([]), { error: "questions must contain at least one question." });
+	assert.match((prepareQuestions([
+		{ type: "text", id: "q2", question: "One" },
+		{ type: "text", question: "Two" },
+	]) as { error: string }).error, /duplicate id: q2/);
+	assert.match((prepareQuestions([{
+		type: "select",
+		question: "Choose",
+		options: [{ value: "same", label: "A" }, { value: "same", label: "B" }],
+	}]) as { error: string }).error, /duplicate value: same/);
+});
+
+test("saveDraftQuestion: clearing an answer while navigating back leaves it unanswered", () => {
+	const states = new Map<string, DraftQuestionState>([["q1", { status: "answered", response: { kind: "text", text: "old" } }]]);
+	saveDraftQuestion(states, "q1", null, false);
+	assert.equal(states.has("q1"), false);
+});
+
+test("buildQuestionAnswers: preserves answered, skipped, and unvisited states", () => {
+	const prepared = prepareQuestions([
+		{ type: "text", id: "a", question: "A" },
+		{ type: "text", id: "b", question: "B" },
+		{ type: "text", id: "c", question: "C" },
+	]);
+	assert.ok("questions" in prepared);
+	if (!("questions" in prepared)) return;
+	const states = new Map<string, DraftQuestionState>([
+		["a", { status: "answered", response: { kind: "text", text: "answer" } }],
+		["b", { status: "skipped" }],
+	]);
+	assert.deepEqual(buildQuestionAnswers(prepared.questions, states), [
+		{ id: "a", status: "answered", response: { kind: "text", text: "answer" } },
+		{ id: "b", status: "skipped" },
+		{ id: "c", status: "unanswered" },
+	]);
+});

package/dist/extensions/question/tests/helpers.test.ts

@@ -2,177 +2,52 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
-	normalizeOptions,
-	getOptionsFormatError,
-	createFreeformResponse,
 	createSelectionResponse,
+	createTextResponse,
+	formatQuestionResponse,
 	formatResponseSummary,
-	formatOptionsForMessage,
-	parseDialogSelections,
-	isCancelled,
 	oneLine,
+	previewText,
 } from "../helpers.ts";
+import type { PreparedQuestion } from "../types.ts";
 
-test("normalizeOptions: string array", () => {
-	assert.deepEqual(normalizeOptions(["a", "b"]), [
-		{ label: "a" },
-		{ label: "b" },
-	]);
+test("createTextResponse trims edges and rejects blank text", () => {
+	assert.equal(createTextResponse("  "), null);
+	assert.deepEqual(createTextResponse("  hello\nworld  "), { kind: "text", text: "hello\nworld" });
 });
 
-test("normalizeOptions: object array", () => {
-	assert.deepEqual(
-		normalizeOptions([{ label: "a", description: "desc" }]),
-		[{ label: "a", description: "desc" }],
-	);
-});
-
-test("normalizeOptions: mixed string and object", () => {
-	assert.deepEqual(normalizeOptions(["a", { label: "b", description: "d" }]), [
-		{ label: "a" },
-		{ label: "b", description: "d" },
-	]);
-});
-
-test("normalizeOptions: empty/undefined", () => {
-	assert.deepEqual(normalizeOptions(undefined), []);
-	assert.deepEqual(normalizeOptions([]), []);
-});
-
-test("normalizeOptions: whitespace-only labels filtered", () => {
-	assert.deepEqual(normalizeOptions(["  ", "a", ""]), [{ label: "a" }]);
-});
-
-test("getOptionsFormatError: rejects JSON-encoded option arrays", () => {
-	assert.match(getOptionsFormatError(['[{"label":"Yes","description":"desc"}]']) ?? "", /JSON-encoded string/);
-});
-
-test("getOptionsFormatError: allows normal string labels", () => {
-	assert.equal(getOptionsFormatError(["Yes", "No"]), null);
-});
-
-test("createFreeformResponse: null/undefined/empty → null", () => {
-	assert.equal(createFreeformResponse(null), null);
-	assert.equal(createFreeformResponse(undefined), null);
-	assert.equal(createFreeformResponse(""), null);
-	assert.equal(createFreeformResponse("   "), null);
-});
-
-test("createFreeformResponse: non-empty → { kind: freeform }", () => {
-	assert.deepEqual(createFreeformResponse("hello"), { kind: "freeform", text: "hello" });
-	assert.deepEqual(createFreeformResponse("  trim  "), { kind: "freeform", text: "trim" });
-});
-
-test("createSelectionResponse: empty → null", () => {
-	assert.equal(createSelectionResponse([]), null);
-	assert.equal(createSelectionResponse(["", "  "]), null);
-});
-
-test("createSelectionResponse: single", () => {
-	assert.deepEqual(createSelectionResponse(["a"]), { kind: "selection", selections: ["a"] });
-});
-
-test("createSelectionResponse: multiple with trim", () => {
-	assert.deepEqual(createSelectionResponse(["  a  ", "b"]), { kind: "selection", selections: ["a", "b"] });
-});
-
-test("createSelectionResponse: with comment", () => {
-	assert.deepEqual(createSelectionResponse(["a"], "note"), {
+test("createSelectionResponse supports values plus Other and rejects empty", () => {
+	assert.equal(createSelectionResponse([], "  "), null);
+	assert.deepEqual(createSelectionResponse([" a ", "b"], " other "), {
 		kind: "selection",
-		selections: ["a"],
-		comment: "note",
+		values: ["a", "b"],
+		otherText: "other",
 	});
 });
 
-test("createSelectionResponse: comment whitespace trimmed", () => {
-	assert.deepEqual(createSelectionResponse(["a"], "  note  "), {
-		kind: "selection",
-		selections: ["a"],
-		comment: "note",
-	});
-});
-
-test("createSelectionResponse: empty comment → no comment field", () => {
-	assert.deepEqual(createSelectionResponse(["a"], "   "), { kind: "selection", selections: ["a"] });
-});
-
-test("formatResponseSummary: freeform → text", () => {
-	assert.equal(formatResponseSummary({ kind: "freeform", text: "hello" }), "hello");
+test("formatResponseSummary returns machine values", () => {
+	assert.equal(formatResponseSummary({ kind: "selection", values: ["a", "b"], otherText: "c" }), "a, b, c");
+	assert.equal(formatResponseSummary({ kind: "text", text: "hello" }), "hello");
 });
 
-test("formatResponseSummary: selection without comment", () => {
-	assert.equal(formatResponseSummary({ kind: "selection", selections: ["a", "b"] }), "a, b");
+test("formatQuestionResponse maps stable values to labels", () => {
+	const question: PreparedQuestion = {
+		id: "q1",
+		label: "Q1",
+		question: "Pick",
+		type: "multiselect",
+		options: [{ value: "a", label: "Alpha" }, { value: "b", label: "Beta" }],
+		allowOther: true,
+	};
+	assert.equal(formatQuestionResponse(question, { kind: "selection", values: ["b"], otherText: "Gamma" }), "Beta, Other: Gamma");
 });
 
-test("formatResponseSummary: selection with comment", () => {
-	assert.equal(
-		formatResponseSummary({ kind: "selection", selections: ["a", "b"], comment: "note" }),
-		"a, b — note",
-	);
+test("previewText bounds multiline summaries", () => {
+	assert.equal(previewText("one\ntwo\nthree", 160, 2), "one\ntwo…");
+	assert.equal(previewText("a".repeat(200), 10, 2), `${"a".repeat(9)}…`);
 });
 
-test("formatOptionsForMessage: 0 options → empty string", () => {
-	assert.equal(formatOptionsForMessage([]), "");
-});
-
-test("formatOptionsForMessage: 1 option", () => {
-	assert.equal(formatOptionsForMessage([{ label: "a" }]), "1. a");
-});
-
-test("formatOptionsForMessage: with description", () => {
-	assert.equal(formatOptionsForMessage([{ label: "a", description: "desc" }]), "1. a — desc");
-});
-
-test("formatOptionsForMessage: multiple", () => {
-	assert.equal(
-		formatOptionsForMessage([{ label: "a" }, { label: "b", description: "d" }]),
-		"1. a\n2. b — d",
-	);
-});
-
-test("parseDialogSelections: basic CSV", () => {
-	assert.deepEqual(parseDialogSelections("a,b,c"), ["a", "b", "c"]);
-});
-
-test("parseDialogSelections: whitespace trimmed", () => {
-	assert.deepEqual(parseDialogSelections(" a , b "), ["a", "b"]);
-});
-
-test("parseDialogSelections: empty → []", () => {
-	assert.deepEqual(parseDialogSelections(""), []);
-});
-
-test("parseDialogSelections: empty entries filtered", () => {
-	assert.deepEqual(parseDialogSelections("a,,b"), ["a", "b"]);
-});
-
-test("isCancelled: null/undefined → true", () => {
-	assert.equal(isCancelled(null), true);
-	assert.equal(isCancelled(undefined), true);
-});
-
-test("isCancelled: falsy non-null → false", () => {
-	assert.equal(isCancelled(""), false);
-	assert.equal(isCancelled(0), false);
-	assert.equal(isCancelled(false), false);
-});
-
-test("oneLine: undefined → empty string", () => {
-	assert.equal(oneLine(undefined), "");
-	assert.equal(oneLine(null), "");
-});
-
-test("oneLine: short → unchanged", () => {
-	assert.equal(oneLine("hello"), "hello");
-});
-
-test("oneLine: long → truncated with …", () => {
-	const long = "a".repeat(120);
-	const result = oneLine(long, 10);
-	assert.equal(result.length, 10);
-	assert.equal(result.endsWith("…"), true);
-});
-
-test("oneLine: whitespace collapsed", () => {
+test("oneLine collapses whitespace and truncates", () => {
 	assert.equal(oneLine("  hello   world  "), "hello world");
-});
+	assert.equal(oneLine("a".repeat(20), 10), `${"a".repeat(9)}…`);
+});

package/dist/extensions/question/tests/question-list.test.ts

@@ -36,7 +36,7 @@ const disabledShortcut: ResolvedShortcut = {
 	matches: ((_data: string) => false) as (data: string) => false,
 };
 
-const opts = (labels: string[]) => labels.map((label) => ({ label }));
+const opts = (labels: string[]) => labels.map((label) => ({ value: label, label }));
 
 // Terminal data bytes
 const ESC = "\x1b";
@@ -163,12 +163,26 @@ test("MultiSelect: confirm with checked items → onSubmit with sorted labels",
 	assert.deepEqual(submitted, [["a", "b"], false]); // sorted by index
 });
 
-test("MultiSelect: confirm with nothing checked → fallback to highlighted label", () => {
+test("QuestionList: restores saved multi-select choices and comment state", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), MultiSelect, false, true, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.restoreSelection(["a", "c"], "reason");
+	assert.deepEqual([...((list as any).checked)], [0, 2]);
+	assert.equal((list as any).selectedIndex, 0);
+	assert.equal(list.isCommentEnabled(), true);
+});
+
+test("QuestionList: restores saved single-select cursor", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.restoreSelection(["b"]);
+	assert.equal((list as any).selectedIndex, 1);
+});
+
+test("MultiSelect: confirm with nothing checked → empty selection", () => {
 	const list = new QuestionList(opts(["a", "b"]), MultiSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
 	let submitted: [string[], boolean] | null = null;
 	list.onSubmit = (selections, commentEnabled) => (submitted = [selections, commentEnabled]);
 	list.handleInput(ENTER);
-	assert.deepEqual(submitted, [["a"], false]); // highlighted fallback
+	assert.deepEqual(submitted, [[], false]);
 });
 
 test("MultiSelect: confirm with no options → onCancel", () => {

package/dist/extensions/question/tests/row-layout.test.ts

@@ -4,7 +4,7 @@ import assert from "node:assert/strict";
 import { wrapPlain, buildItemBlocks, flattenBlocks, renderSingleSelectRows } from "../row-layout.ts";
 import type { ItemBlock, QuestionOption } from "../types.ts";
 
-const opts = (labels: string[]): QuestionOption[] => labels.map((label) => ({ label }));
+const opts = (labels: string[]): QuestionOption[] => labels.map((label) => ({ value: label, label }));
 
 test("wrapPlain: empty → ['']", () => {
 	assert.deepEqual(wrapPlain("", 20), [""]);
@@ -45,7 +45,7 @@ test("buildItemBlocks: selected=1 → arrow pointer on block 1", () => {
 
 test("buildItemBlocks: with description → description lines included", () => {
 	const blocks = buildItemBlocks(
-		[{ label: "a", description: "some desc" }],
+		[{ value: "a", label: "a", description: "some desc" }],
 		80,
 		false,
 		false,
@@ -58,7 +58,7 @@ test("buildItemBlocks: with description → description lines included", () => {
 
 test("buildItemBlocks: hideDescriptions=true → no description lines", () => {
 	const blocks = buildItemBlocks(
-		[{ label: "a", description: "some desc" }],
+		[{ value: "a", label: "a", description: "some desc" }],
 		80,
 		false,
 		false,
@@ -125,7 +125,7 @@ test("renderSingleSelectRows: maxRows truncation with indicator", () => {
 
 test("renderSingleSelectRows: selected block larger than available → only selected + indicator", () => {
 	const rows = renderSingleSelectRows({
-		options: [{ label: "a".repeat(100) }],
+		options: [{ value: "a", label: "a".repeat(100) }],
 		selectedIndex: 0,
 		width: 10,
 		allowFreeform: false,

package/dist/extensions/question/tests/schemas.test.ts

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Value } from "typebox/value";
+
+import { QuestionParamsSchema } from "../schemas.ts";
+
+const valid = {
+	questions: [{ type: "select", question: "Pick", options: [{ value: "yes", label: "Yes" }] }],
+};
+
+test("QuestionParamsSchema accepts typed batch requests", () => {
+	assert.equal(Value.Check(QuestionParamsSchema, valid), true);
+});
+
+test("QuestionParamsSchema rejects legacy and mistyped fields", () => {
+	assert.equal(Value.Check(QuestionParamsSchema, { ...valid, timeout: 1000 }), false);
+	assert.equal(Value.Check(QuestionParamsSchema, {
+		questions: [{ ...valid.questions[0], allowMultiple: true }],
+	}), false);
+	assert.equal(Value.Check(QuestionParamsSchema, {
+		questions: [{ ...valid.questions[0], allowComment: true }],
+	}), false);
+	assert.equal(Value.Check(QuestionParamsSchema, {
+		questions: [{ type: "text", question: "Explain", options: [] }],
+	}), false);
+	assert.equal(Value.Check(QuestionParamsSchema, {
+		questions: [{ ...valid.questions[0], options: [{ value: "yes", label: "Yes", extra: true }] }],
+	}), false);
+});

package/dist/extensions/question/tests/ui-protocol.test.ts

@@ -1,8 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { DialogFallback } from "../dialog-adapter.ts";
-import type { QuestionResponse, ResolvedQuestionParams } from "../types.ts";
+import { askBatchViaDialogs, DialogFallback } from "../dialog-adapter.ts";
+import type { BatchedQuestion, QuestionResponse, ResolvedQuestionParams } from "../types.ts";
 import type { UIProtocol } from "../ui-protocol.ts";
 
 // ---------------------------------------------------------------------------
@@ -134,4 +134,24 @@ test("DialogFallback: freeform cancel (input returns undefined after selecting c
 	});
 	const result = await DialogFallback.ask(makeParams({ allowFreeform: true }), protocol);
 	assert.equal(result, null);
-});
+});
+test("askBatchViaDialogs: returns identified answers and passes remaining timeout", async () => {
+	const timeouts: Array<number | undefined> = [];
+	const protocol = fakeProtocol({
+		select: async (_prompt, _options, opts) => {
+			timeouts.push(opts?.timeout);
+			return "Option A";
+		},
+	});
+	const questions: BatchedQuestion[] = [
+		{ ...makeParams(), id: "first", label: "First" },
+		{ ...makeParams({ question: "Pick again" }), id: "second", label: "Second" },
+	];
+	const result = await askBatchViaDialogs(questions, protocol, 1_000);
+	assert.deepEqual(result, [
+		{ id: "first", question: "Pick one", response: { kind: "selection", selections: ["Option A"] } },
+		{ id: "second", question: "Pick again", response: { kind: "selection", selections: ["Option A"] } },
+	]);
+	assert.equal(timeouts.length, 2);
+	assert.ok(timeouts.every((timeout) => timeout !== undefined && timeout > 0 && timeout <= 1_000));
+});