@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/question/dialog-adapter.ts

@@ -8,7 +8,7 @@ import {
 	isCancelled,
 	parseDialogSelections,
 } from "./helpers.ts";
-import type { QuestionOption, QuestionResponse, ResolvedQuestionParams } from "./types.ts";
+import type { BatchAnswer, BatchedQuestion, QuestionOption, QuestionResponse, ResolvedQuestionParams } from "./types.ts";
 import type { FallbackProtocol, UIProtocol } from "./ui-protocol.ts";
 
 const FREEFORM_DIALOG_OPTION = "✏️ Type custom response...";
@@ -58,6 +58,28 @@ async function askViaDialogs(
 	return createSelectionResponse([selected], comment);
 }
 
+export async function askBatchViaDialogs(questions: BatchedQuestion[], protocol: UIProtocol, timeout?: number): Promise<BatchAnswer[] | null> {
+	const deadline = timeout && timeout > 0 ? Date.now() + timeout : undefined;
+	const answers: BatchAnswer[] = [];
+	for (const question of questions) {
+		const remaining = deadline === undefined ? undefined : deadline - Date.now();
+		if (remaining !== undefined && remaining <= 0) return null;
+		const response = await askViaDialogs(
+			protocol,
+			question.question,
+			question.context,
+			question.options,
+			question.allowMultiple,
+			question.allowFreeform,
+			question.allowComment,
+			remaining,
+		);
+		if (response === null) return null;
+		answers.push({ id: question.id, question: question.question, response });
+	}
+	return answers;
+}
+
 export const DialogFallback: FallbackProtocol = {
 	async ask(params, protocol) {
 		return askViaDialogs(

package/dist/extensions/question/index.ts

@@ -17,14 +17,15 @@ import {
 	truncateToWidth,
 } from "@earendil-works/pi-tui";
 
+import { prepareBatchQuestions } from "./batch.ts";
 import { BOX_BORDER_LEFT, BOX_BORDER_OVERHEAD, BOX_BORDER_RIGHT, QUESTION_VERSION } from "./constants.ts";
-import { DialogFallback } from "./dialog-adapter.ts";
+import { askBatchViaDialogs, DialogFallback } from "./dialog-adapter.ts";
 import { createFreeformResponse, createSelectionResponse, formatOptionsForMessage, formatResponseSummary, getOptionsFormatError, normalizeOptions, oneLine, safeMarkdownTheme } from "./helpers.ts";
 import { QuestionList } from "./question-list.ts";
 import { MultiSelect, SingleSelect } from "./selection-mode.ts";
 import { resolveShortcuts } from "./shortcuts.ts";
 import { QuestionParamsSchema } from "./schemas.ts";
-import type { QuestionDetails, QuestionMode, QuestionOption, QuestionResponse, RawOption, ResolvedShortcuts } from "./types.ts";
+import type { BatchAnswer, BatchQuestionDetails, BatchedQuestion, QuestionDetails, QuestionMode, QuestionOption, QuestionResponse, RawOption, ResolvedShortcuts } from "./types.ts";
 import { createTUIProtocol } from "./tui-adapter.ts";
 import type { CustomFactory, UIProtocol } from "./ui-protocol.ts";
 
@@ -165,6 +166,10 @@ class QuestionComponent extends Container implements Component {
 	get focused(): boolean {
 		return this._focused;
 	}
+
+	get isEditing(): boolean {
+		return this.mode === "freeform" || this.mode === "comment";
+	}
 	set focused(value: boolean) {
 		this._focused = value;
 		if (this.editor && (this.mode === "freeform" || this.mode === "comment")) {
@@ -360,6 +365,171 @@ class QuestionComponent extends Container implements Component {
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Batched-question component
+// ---------------------------------------------------------------------------
+
+class BatchQuestionComponent extends Container implements Component {
+	private currentPage = 0;
+	private readonly answers = new Map<string, QuestionResponse>();
+	private questionComponent?: QuestionComponent;
+	private focusedState = false;
+	private header = new Text("", 1, 0);
+	private content = new Container();
+	private legend = new Text("", 1, 0);
+
+	constructor(
+		private questions: BatchedQuestion[],
+		private tui: TUI,
+		private theme: Theme,
+		private keybindings: KeybindingsManager,
+		private onDone: (answers: BatchAnswer[] | null) => void,
+	) {
+		super();
+		this.addChild(this.header);
+		this.addChild(new Spacer(1));
+		this.addChild(this.content);
+		this.addChild(new Spacer(1));
+		this.addChild(this.legend);
+		this.showPage();
+	}
+
+	get focused(): boolean {
+		return this.focusedState;
+	}
+	set focused(value: boolean) {
+		this.focusedState = value;
+		if (this.questionComponent) this.questionComponent.focused = value;
+	}
+
+	override invalidate(): void {
+		super.invalidate();
+		this.updateChrome();
+	}
+
+	private get isReviewPage(): boolean {
+		return this.currentPage === this.questions.length;
+	}
+
+	private allAnswered(): boolean {
+		return this.questions.every((question) => this.answers.has(question.id));
+	}
+
+	private updateChrome(): void {
+		const answered = this.answers.size;
+		if (this.isReviewPage) {
+			this.header.setText(this.theme.fg("accent", this.theme.bold(`Review answers · ${answered}/${this.questions.length} answered`)));
+			this.legend.setText(
+				this.theme.fg(
+					"dim",
+					this.allAnswered()
+						? "Shift+Tab/← previous • Enter submit all answers • Esc cancel"
+						: "Shift+Tab/← previous • Answer every question before submitting • Esc cancel",
+				),
+			);
+			return;
+		}
+		const question = this.questions[this.currentPage];
+		this.header.setText(
+			this.theme.fg(
+				"accent",
+				this.theme.bold(`${question.label} · ${this.currentPage + 1}/${this.questions.length}${this.answers.has(question.id) ? " · answered" : ""}`),
+			),
+		);
+		this.legend.setText(this.theme.fg("dim", "Tab next • Shift+Tab previous • ←→ navigate outside text entry • Answers save when selected"));
+	}
+
+	private showPage(): void {
+		this.content.clear();
+		this.questionComponent = undefined;
+		this.updateChrome();
+
+		if (this.isReviewPage) {
+			this.content.addChild(new Text(this.theme.fg("accent", this.theme.bold("Ready to submit")), 1, 0));
+			this.content.addChild(new Spacer(1));
+			for (const question of this.questions) {
+				const response = this.answers.get(question.id);
+				const marker = response ? this.theme.fg("success", "✓") : this.theme.fg("warning", "○");
+				const answer = response ? formatResponseSummary(response) : "Unanswered";
+				this.content.addChild(new Text(`${marker} ${this.theme.fg("accent", question.label)} ${this.theme.fg("dim", "—")} ${this.theme.fg(response ? "text" : "warning", answer)}`, 1, 0));
+			}
+		} else {
+			const question = this.questions[this.currentPage];
+			this.questionComponent = new QuestionComponent(
+				question.question,
+				question.context,
+				question.options,
+				question.allowMultiple,
+				question.allowFreeform,
+				question.allowComment,
+				this.tui,
+				this.theme,
+				this.keybindings,
+				question.shortcuts,
+				(response) => this.saveAnswer(question, response),
+			);
+			this.questionComponent.focused = this.focusedState;
+			this.content.addChild(this.questionComponent);
+		}
+		this.invalidate();
+		this.tui.requestRender();
+	}
+
+	private saveAnswer(question: BatchedQuestion, response: QuestionResponse | null): void {
+		if (response === null) {
+			this.onDone(null);
+			return;
+		}
+		this.answers.set(question.id, response);
+		this.goNext();
+	}
+
+	private goNext(): void {
+		if (this.currentPage < this.questions.length) this.currentPage++;
+		this.showPage();
+	}
+
+	private goPrevious(): void {
+		if (this.currentPage > 0) this.currentPage--;
+		this.showPage();
+	}
+
+	handleInput(data: string): void {
+		if (this.isReviewPage) {
+			if (matchesKey(data, Key.enter) && this.allAnswered()) {
+				this.onDone(this.questions.map((question) => ({ id: question.id, question: question.question, response: this.answers.get(question.id)! })));
+				return;
+			}
+			if (matchesKey(data, Key.escape) || this.keybindings.matches(data, "tui.select.cancel")) {
+				this.onDone(null);
+				return;
+			}
+			if (matchesKey(data, Key.shift("tab")) || matchesKey(data, Key.left)) this.goPrevious();
+			return;
+		}
+
+		if (matchesKey(data, Key.tab)) {
+			this.goNext();
+			return;
+		}
+		if (matchesKey(data, Key.shift("tab"))) {
+			this.goPrevious();
+			return;
+		}
+		if (!this.questionComponent?.isEditing) {
+			if (matchesKey(data, Key.right)) {
+				this.goNext();
+				return;
+			}
+			if (matchesKey(data, Key.left)) {
+				this.goPrevious();
+				return;
+			}
+		}
+		this.questionComponent?.handleInput(data);
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Tool registration
 // ---------------------------------------------------------------------------
@@ -369,7 +539,7 @@ export default function questionExtension(pi: ExtensionAPI) {
 		name: "question",
 		label: "Question",
 		description:
-			"Ask the user a question in the Pi UI and return the answer. Supports multiple-choice options, multi-select, freeform answers, optional context, and an optional comment. Use when you need user input to proceed.",
+			"Ask the user one question or a paged batch through the Pi UI and return the answer(s). Supports multiple-choice options, multi-select, freeform answers, optional context, comments, and a final batch review/submit page. Use when you need user input to proceed.",
 		promptSnippet: "Ask the user a question when required information is missing.",
 		promptGuidelines: [
 			"Use question only when you cannot proceed safely or accurately without user input.",
@@ -379,6 +549,7 @@ export default function questionExtension(pi: ExtensionAPI) {
 			"Pass a short summary via context when the question depends on prior findings.",
 			"After the user answers, continue the task immediately using that answer; do not stop and ask the user to type continue unless the task is complete.",
 			"Do not use question for information you can infer, inspect, or compute with other tools.",
+			"For independent related decisions, send one question call with a questions array. The user can use Tab/Shift+Tab or Left/Right to revisit pages, then presses Enter on the review page to submit all answers.",
 		],
 		// Block other tool calls in the same turn until the user answers, so the
 		// model can't batch question with side-effecting tools and run them first.
@@ -386,6 +557,53 @@ export default function questionExtension(pi: ExtensionAPI) {
 		parameters: QuestionParamsSchema,
 
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			if (Array.isArray(params.questions)) {
+				const prepared = prepareBatchQuestions(params.questions);
+				if ("error" in prepared) {
+					return { content: [{ type: "text", text: prepared.error }], isError: true, details: { questions: [], answers: [], cancelled: true } satisfies BatchQuestionDetails };
+				}
+				const questions = prepared.questions;
+				const detailsBase = {
+					questions: questions.map(({ id, label, question, context, options }) => ({ id, label, question, context, options })),
+				};
+				if (signal?.aborted) {
+					return { content: [{ type: "text", text: "Question batch cancelled" }], details: { ...detailsBase, answers: [], cancelled: true } satisfies BatchQuestionDetails };
+				}
+
+				const protocol = createTUIProtocol(ctx);
+				if (!protocol.hasUI) {
+					return {
+						content: [{ type: "text", text: "Question batch requires interactive mode." }],
+						isError: true,
+						details: { ...detailsBase, answers: [], cancelled: true } satisfies BatchQuestionDetails,
+					};
+				}
+				onUpdate?.({ content: [{ type: "text", text: "Waiting for answers to question batch..." }], details: { ...detailsBase, answers: [], cancelled: false } satisfies BatchQuestionDetails });
+
+				let answers: BatchAnswer[] | null | undefined;
+				try {
+					const customFactory: CustomFactory<BatchAnswer[] | null> = (tui, theme, keybindings, done) => {
+						if (signal) signal.addEventListener("abort", () => done(null), { once: true });
+						const timeout = params.timeout as number | undefined;
+						if (timeout && timeout > 0) setTimeout(() => done(null), timeout);
+						return new BatchQuestionComponent(questions, tui, theme, keybindings, done);
+					};
+					answers = await protocol.custom(customFactory);
+					if (answers === undefined) answers = await askBatchViaDialogs(questions, protocol, params.timeout as number | undefined);
+				} catch (error) {
+					const message = error instanceof Error ? `${error.message}\n${error.stack ?? ""}` : String(error);
+					return { content: [{ type: "text", text: `Question batch failed: ${message}` }], isError: true, details: { ...detailsBase, answers: [], cancelled: true } satisfies BatchQuestionDetails };
+				}
+
+				if (!answers) {
+					return { content: [{ type: "text", text: "User cancelled the question batch" }], details: { ...detailsBase, answers: [], cancelled: true } satisfies BatchQuestionDetails };
+				}
+				return {
+					content: [{ type: "text", text: answers.map((answer) => `${answer.id}: ${formatResponseSummary(answer.response)}`).join("\n") }],
+					details: { ...detailsBase, answers, cancelled: false } satisfies BatchQuestionDetails,
+				};
+			}
+
 			if (signal?.aborted) {
 				return {
 					content: [{ type: "text", text: "Question cancelled" }],
@@ -451,7 +669,7 @@ export default function questionExtension(pi: ExtensionAPI) {
 			let result: QuestionResponse | null;
 
 			try {
-				const customFactory: CustomFactory = (
+				const customFactory: CustomFactory<QuestionResponse | null> = (
 					tui: TUI,
 					theme: Theme,
 					keybindings: KeybindingsManager,
@@ -514,6 +732,15 @@ export default function questionExtension(pi: ExtensionAPI) {
 		},
 
 		renderCall(args, theme, _context) {
+			const batch = Array.isArray(args.questions) ? args.questions : undefined;
+			if (batch) {
+				const labels = batch.map((item: { label?: string; id?: string }, index: number) => item.label || item.id || `Q${index + 1}`).join(", ");
+				return new Text(
+					`${theme.fg("toolTitle", theme.bold("QUESTION"))} ${theme.fg("accent", theme.bold(`${batch.length} question${batch.length === 1 ? "" : "s"}`))}${labels ? theme.fg("dim", ` · ${oneLine(labels, 100)}`) : ""}`,
+					0,
+					0,
+				);
+			}
 			const question = (args.question as string) || "";
 			const rawOptions = Array.isArray(args.options) ? args.options : [];
 			const title = args.context ? `${args.context}: ` : args.title ? `${args.title}: ` : "";
@@ -532,7 +759,7 @@ export default function questionExtension(pi: ExtensionAPI) {
 		},
 
 		renderResult(result, options, theme, _context) {
-			const details = result.details as (QuestionDetails & { error?: string }) | undefined;
+			const details = result.details as (QuestionDetails | BatchQuestionDetails) & { error?: string } | undefined;
 
 			if (details?.error) return new Text(theme.fg("error", details.error), 0, 0);
 
@@ -546,9 +773,12 @@ export default function questionExtension(pi: ExtensionAPI) {
 				return new Text(theme.fg("muted", waitingText), 0, 0);
 			}
 
-			if (!details || details.cancelled || !details.response) {
-				return new Text(theme.fg("warning", "question cancelled"), 0, 0);
+			if (!details || details.cancelled) return new Text(theme.fg("warning", "question cancelled"), 0, 0);
+
+			if ("answers" in details) {
+				return new Text(details.answers.map((answer) => `${theme.fg("success", "✓")} ${theme.fg("accent", answer.id)}: ${theme.fg("text", oneLine(formatResponseSummary(answer.response), 120))}`).join("\n"), 0, 0);
 			}
+			if (!details.response) return new Text(theme.fg("warning", "question cancelled"), 0, 0);
 
 			const response = details.response;
 			let text = theme.fg("success", theme.bold("answered: "));

package/dist/extensions/question/schemas.ts

@@ -10,35 +10,48 @@ const OptionSchema = Type.Union([
 	}),
 ]);
 
-export const QuestionParamsSchema = Type.Object({
+const QuestionFields = {
 	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" }),
-	),
+	title: Type.Optional(Type.String({ description: "Short title for the question UI (deprecated alias for 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" }),
-	),
+	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" }),
-	),
+	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." }),
-	),
-});
+};
+
+const SingleQuestionParamsSchema = Type.Object({
+	...QuestionFields,
+	timeout: Type.Optional(Type.Number({ description: "Auto-dismiss after N milliseconds. Returns null (cancelled) when expired." })),
+});
+
+const BatchQuestionSchema = Type.Object({
+	id: Type.Optional(Type.String({ description: "Unique answer id. Defaults to q1, q2, and so on." })),
+	label: Type.Optional(Type.String({ description: "Short page label. Defaults to Q1, Q2, and so on." })),
+	...QuestionFields,
+});
+
+const BatchQuestionParamsSchema = Type.Object({
+	questions: Type.Array(BatchQuestionSchema, {
+		minItems: 1,
+		description:
+			"Questions to answer in one paged form. User can move between pages with Tab/Shift+Tab or Left/Right, then press Enter on the final review page to submit all answers.",
+	}),
+	timeout: Type.Optional(Type.Number({ description: "Auto-dismiss the whole batch after N milliseconds." })),
+});
+
+export const QuestionParamsSchema = Type.Union([SingleQuestionParamsSchema, BatchQuestionParamsSchema]);

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

@@ -0,0 +1,26 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { prepareBatchQuestions } from "../batch.ts";
+
+test("prepareBatchQuestions: normalizes defaults and generated ids", () => {
+	const result = prepareBatchQuestions([
+		{ question: "Pick a color", options: ["Red", "Blue"] },
+		{ id: "notes", label: "Notes", question: "Anything else?" },
+	]);
+	assert.ok("questions" in result);
+	if (!("questions" in result)) return;
+	assert.deepEqual(
+		result.questions.map(({ id, label, question, options, allowFreeform }) => ({ id, label, question, options, allowFreeform })),
+		[
+			{ id: "q1", label: "Q1", question: "Pick a color", options: [{ label: "Red" }, { label: "Blue" }], allowFreeform: false },
+			{ id: "notes", label: "Notes", question: "Anything else?", options: [], allowFreeform: true },
+		],
+	);
+});
+
+test("prepareBatchQuestions: rejects empty batches, duplicate ids, and impossible questions", () => {
+	assert.deepEqual(prepareBatchQuestions([]), { error: "questions must contain at least one question." });
+	assert.match((prepareBatchQuestions([{ id: "same", question: "One" }, { id: "same", question: "Two" }]) as { error: string }).error, /duplicate id/);
+	assert.match((prepareBatchQuestions([{ question: "Choose", allowFreeform: false }]) as { error: string }).error, /options are empty/);
+});

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));
+});

package/dist/extensions/question/tui-adapter.ts

@@ -2,14 +2,13 @@
 
 import type { ExtensionContext } from "@selesai/code";
 
-import type { QuestionResponse } from "./types.ts";
-import type { UIProtocol } from "./ui-protocol.ts";
+import type { CustomFactory, UIProtocol } from "./ui-protocol.ts";
 
 export function createTUIProtocol(ctx: ExtensionContext): UIProtocol {
 	return {
 		hasUI: ctx.hasUI,
 		theme: ctx.ui.theme,
-		custom: (factory) => ctx.ui.custom(factory as any) as Promise<QuestionResponse | null | undefined>,
+		custom: <T>(factory: CustomFactory<T>) => ctx.ui.custom(factory as any) as Promise<T | undefined>,
 		select: (prompt, options, opts) => ctx.ui.select(prompt, options, opts),
 		input: (prompt, placeholder, opts) => ctx.ui.input(prompt, placeholder, opts),
 	};

package/dist/extensions/question/types.ts

@@ -32,6 +32,43 @@ export interface QuestionParams {
 	timeout?: number;
 }
 
+export interface RawBatchQuestion {
+	id?: string;
+	label?: string;
+	question: string;
+	title?: string;
+	context?: string;
+	options?: RawOption[];
+	allowMultiple?: boolean;
+	allowFreeform?: boolean;
+	allowComment?: boolean;
+	commentToggleKey?: string | null;
+}
+
+export interface BatchedQuestion {
+	id: string;
+	label: string;
+	question: string;
+	context: string | undefined;
+	options: QuestionOption[];
+	allowMultiple: boolean;
+	allowFreeform: boolean;
+	allowComment: boolean;
+	shortcuts: ResolvedShortcuts;
+}
+
+export interface BatchAnswer {
+	id: string;
+	question: string;
+	response: QuestionResponse;
+}
+
+export interface BatchQuestionDetails {
+	questions: Array<Pick<BatchedQuestion, "id" | "label" | "question" | "context" | "options">>;
+	answers: BatchAnswer[];
+	cancelled: boolean;
+}
+
 // ---------------------------------------------------------------------------
 // Shortcut resolution
 // ---------------------------------------------------------------------------

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

@@ -11,17 +11,17 @@ export interface CustomFactoryResult {
 	focused: boolean;
 }
 
-export type CustomFactory = (
+export type CustomFactory<T> = (
 	tui: TUI,
 	theme: Theme,
 	keybindings: KeybindingsManager,
-	done: (result: QuestionResponse | null) => void,
+	done: (result: T) => void,
 ) => CustomFactoryResult;
 
 export interface UIProtocol {
 	readonly hasUI: boolean;
 	readonly theme: Theme;
-	custom(factory: CustomFactory): Promise<QuestionResponse | null | undefined>;
+	custom<T>(factory: CustomFactory<T>): Promise<T | undefined>;
 	select(prompt: string, options: string[], opts?: { timeout?: number }): Promise<string | undefined>;
 	input(prompt: string, placeholder?: string, opts?: { timeout?: number }): Promise<string | undefined>;
 }

package/dist/skills/batch-grill-me/SKILL.md

@@ -6,7 +6,9 @@ disable-model-invocation: true
 
 Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it.
 
-Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled — the questions you can ask *now* without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round.
+Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled — the questions you can ask *now* without guessing at answers you haven't heard yet.
+
+For every non-empty frontier, call the `question` tool **exactly once** with its `questions` array; never print frontier questions as plain chat text. Give every item a stable `id`, short `label`, concise `question`, and `context` containing the recommended answer and why. Provide options when known and set `allowFreeform: true` when the user may need another answer. The batch UI lets the user revisit pages before pressing Enter on its final review page to submit all answers. Wait for that tool result, map returned `answers` by `id`, then recompute the next frontier.
 
 Each round the user answers reshapes the tree — settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a *later* round, not this one.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@selesai/code",
-	"version": "0.5.20",
+	"version": "0.5.21",
 	"description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
 	"type": "module",
 	"repository": {