@gavin-hu/my-pi-agent 0.17.0 → 0.19.0

package/extensions/plan/web.ts

@@ -6,38 +6,45 @@
  * for one plan, opens the default browser at a tokenized URL, and resolves
  * `done` when the user saves feedback, cancels, closes the tab (detected by the
  * event stream dropping), or aborts the turn. The route logic lives in the pure
- * `web-router.ts`; this module is the only part that owns a socket and timers,
- * and it takes injected seams so tests can run one on `127.0.0.1:0`.
+ * `web-router.ts`; this module owns the routes and the timers, `lib/http` owns
+ * the socket, and it takes injected seams so tests can run one on `127.0.0.1:0`.
  */
 
-import { randomBytes } from "node:crypto";
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { networkInterfaces } from "node:os";
 import { basename } from "node:path";
 import { openInBrowser } from "../../lib/browser.ts";
 import {
-	bindLoopback,
-	createCloser,
 	jsonHeaders,
-	openEventStream,
-	respond,
+	type LoopbackRequest,
+	type LoopbackReply,
+	type LoopbackServer,
+	parseRequestUrl,
+	serveLoopback,
 	type ServeResponse,
 } from "../../lib/http/index.ts";
 import { fenceLanguage, highlightLines } from "../../lib/highlight.ts";
-import { type ArmTimer, defaultTimer } from "../../lib/timer.ts";
-import { codeBody, fenceInfo, planBlocks } from "./blocks.ts";
+import { type ArmTimer, defaultInterval, defaultTimer, type RepeatTimer } from "../../lib/timer.ts";
+import { codeBody, fenceInfo } from "./blocks.ts";
 import {
+	claimAuthor,
 	MAX_ANNOTATIONS,
 	MAX_COMMENT_LENGTH,
 	MAX_QUOTE_LENGTH,
-	parseFeedback,
+	normalizeAuthor,
+	readFeedback,
 	stripFeedback,
 	type PlanAnnotation,
 } from "./feedback.ts";
 import { planTitle, type PlanStore, type StoredPlan } from "./plans.ts";
-import { changedSections, type SectionDigest } from "./plan-text.ts";
-import { extractPlanSections, extractPlanSteps } from "./steps.ts";
+import { changedSections, planDigest, type SectionDigest } from "./plan-text.ts";
+import { extractPlanSteps } from "./steps.ts";
+import type { ReviewCaller } from "./types.ts";
 import { handleReviewRequest, type ReviewContext, type SaveResult } from "./web-router.ts";
 import type { ReviewPageData } from "./web-page.ts";
+import { createShareSession, type ShareSession } from "./web-share-session.ts";
+import { createStreams } from "./web-streams.ts";
+import { createTokens } from "./web-tokens.ts";
+import type { NetworkInterfaces, ShareResult, ShareState } from "./web-share.ts";
 
 /** How a browser review ended. */
 export type PlanReviewResult =
@@ -47,13 +54,13 @@ export type PlanReviewResult =
 
 /** A running review the caller awaits and then closes. */
 export interface PlanReviewSession {
-	/** Tokenized URL to open or print. */
+	/** Tokenized URL to open or print; the owner's own page. */
 	url: string;
 	/** Bound loopback port. */
 	port: number;
 	/** Resolves once, when the review ends. */
 	done: Promise<PlanReviewResult>;
-	/** Stop the server. Safe to call more than once. */
+	/** Stop the server(s). Safe to call more than once. */
 	close(): Promise<void>;
 }
 
@@ -65,11 +72,25 @@ export interface PlanReviewOptions {
 	canApprove?: boolean;
 	/** The section digests the previous review showed, so this page can mark changed sections. */
 	baseline?: SectionDigest[];
+	/**
+	 * Called when a shared reviewer's post lands, so the owner's terminal can say so:
+	 * an open page updates itself, and whoever is waiting in the TUI is told nothing
+	 * until this fires.
+	 */
+	onReviewerComment?: (author: string, count: number) => void;
 }
 
 /** Starts and tracks review sessions. */
 export interface PlanWebReview {
 	start(cwd: string, plan: StoredPlan, options?: PlanReviewOptions): Promise<PlanReviewSession | undefined>;
+	/** The session currently serving a review, if any. */
+	current(): PlanReviewSession | undefined;
+	/** Start (or re-read) the share link for the running review, if one is open. */
+	share(): Promise<ShareResult | undefined>;
+	/** Revoke every reviewer token and stop accepting reviewers. */
+	stopSharing(): Promise<ShareResult | undefined>;
+	/** The running review's share state, without changing it. */
+	shareState(): ShareState | undefined;
 	/** Stop every running session (session shutdown). */
 	closeAll(): Promise<void>;
 }
@@ -93,49 +114,37 @@ export interface PlanWebReviewDeps {
 	schedule?: ArmTimer;
 	/** Override the accepted body size; a test keeps it small. */
 	maxBodyBytes?: number;
+	/**
+	 * Override the repeating timer that polls the plan file.
+	 *
+	 * A poll is a race against an edit made elsewhere, so a test drives it by hand
+	 * rather than waiting for a tick that makes a busy machine fail.
+	 */
+	tick?: RepeatTimer;
+	/** How often to check the plan file for an edit this review did not make. */
+	pollMs?: number;
+	/** Override the machine's network interfaces (tests), never read live in a test. */
+	networkInterfaces?: () => NetworkInterfaces;
 }
 
 /** Largest feedback body accepted, in bytes. */
 const MAX_BODY_BYTES = 1024 * 1024;
 /** Grace period before an empty client set counts as a closed tab. */
 const DROP_GRACE_MS = 1500;
-
-/** A request body, or the fact that it was too large to read. */
-type BodyResult = { ok: true; body: string } | { ok: false };
-
 /**
- * Read a request body, stopping at {@link MAX_BODY_BYTES}. An oversize body is
- * reported rather than destroyed here, so the handler can still answer 413 over
- * the open socket instead of the client seeing a dropped connection.
+ * How often a running review checks the plan file.
+ *
+ * One stat and one read of a small markdown file, only while a page is open: a
+ * second is fast enough that an edit under an open page reaches it while the
+ * reader is still looking, and slow enough to be free.
  */
-function readBody(request: IncomingMessage, limit: number): Promise<BodyResult> {
-	return new Promise((resolve) => {
-		const chunks: Buffer[] = [];
-		let size = 0;
-		let done = false;
-		const settle = (result: BodyResult): void => {
-			if (done) return;
-			done = true;
-			resolve(result);
-		};
-		request.on("data", (chunk: Buffer) => {
-			if (done) return;
-			size += chunk.length;
-			if (size > limit) {
-				chunks.length = 0;
-				request.pause();
-				settle({ ok: false });
-				return;
-			}
-			chunks.push(chunk);
-		});
-		request.on("end", () => settle({ ok: true, body: Buffer.concat(chunks).toString("utf-8") }));
-		request.on("error", () => settle({ ok: false }));
-	});
-}
+const PLAN_POLL_MS = 1000;
 
 export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps = {}): PlanWebReview {
 	const sessions = new Set<PlanReviewSession>();
+	// What each running review can do about sharing; the session itself stays the
+	// four things a caller awaits and closes.
+	const shares = new Map<PlanReviewSession, ShareSession>();
 	// Last bound port per plan path, so the same plan keeps one origin across
 	// review turns (and its saved browser theme with it).
 	const ports = new Map<string, number>();
@@ -147,22 +156,40 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 	): Promise<PlanReviewSession | undefined> => {
 		const { signal } = options;
 		const canApprove = options.canApprove === true;
-		const maxBody = deps.maxBodyBytes ?? MAX_BODY_BYTES;
-		const token = (deps.token ?? (() => randomBytes(16).toString("hex")))();
+		// One cap for both listeners: a reviewer's page posts the same bodies as the
+		// owner's, so the shared one cannot be the stricter or the looser of the two.
+		const bodyLimit = deps.maxBodyBytes ?? MAX_BODY_BYTES;
+		// One token per holder: the owner's is minted here and never shared, and a
+		// reviewer token is minted by `share()`. The table owns the collision rule and
+		// the name each link has bound.
+		const tokens = createTokens(deps.token);
+		const token = tokens.mint("owner");
+		// The owner's bound port, so a shared listener can reuse it for the same URL shape.
+		let currentPort = 0;
 		let settled = false;
 		let resolveDone!: (result: PlanReviewResult) => void;
 		const done = new Promise<PlanReviewResult>((resolve) => {
 			resolveDone = resolve;
 		});
-		let cancelDrop: (() => void) | undefined;
-		const clearDrop = (): void => {
-			cancelDrop?.();
-			cancelDrop = undefined;
-		};
+		// Live event streams, used only to notice a closed owner tab: a reviewer's
+		// tab is not the review's lifetime. The explicit Cancel button and the abort
+		// signal are the deterministic paths.
+		const streams = createStreams({
+			onAbandoned: () => finish({ status: "cancelled" }),
+			graceMs: deps.dropGraceMs ?? DROP_GRACE_MS,
+			schedule: deps.schedule ?? defaultTimer,
+			settled: () => settled,
+		});
+
+		let stopTicker: () => void = () => {};
 		const finish = (result: PlanReviewResult): void => {
 			if (settled) return;
 			settled = true;
-			clearDrop();
+			streams.cancelDrop();
+			stopTicker();
+			// A page still open has no decision to make, so it is told why it stops
+			// updating, and its stream is ended with that frame rather than after it.
+			streams.end("closed");
 			resolveDone(result);
 		};
 
@@ -181,19 +208,52 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 		 */
 		const refreshPageText = async (): Promise<StoredPlan> => {
 			const current = (await store.read(cwd, plan.path)) ?? plan;
-			pageText = stripFeedback(current.content);
+			const next = stripFeedback(current.content);
+			// Someone saved the plan outside this page: the readers must see the new
+			// body, and the next save must anchor against it rather than 409.
+			if (next !== pageText) notifyPlanChange();
+			pageText = next;
 			return current;
 		};
+		// Set below, once the stream set exists; a page load before that has no
+		// reader to notify and nothing to notify it about.
+		let notifyPlanChange: () => void = () => {};
+		notifyPlanChange = () => streams.broadcast("plan");
 
-		const page = async (): Promise<ReviewPageData> => {
+		/**
+		 * Notice a plan file this review did not write.
+		 *
+		 * A review owns the page, not the file: `/plan review` runs in normal mode, and
+		 * the plan is a markdown file a user or another tool can rewrite while the page
+		 * is open. The check compares the stripped text with what the page rendered and
+		 * only announces — it never writes `pageText`, which is the anchor a save is
+		 * validated against. So an edit under an open page reaches every reader, and the
+		 * review's own save, whose text is unchanged, says nothing.
+		 *
+		 * A poll rather than an `fs.watch`: the house rule, and one stat plus one read
+		 * per interval costs less than the watcher's platform-dependent event
+		 * semantics (see `file-browse`'s note). It stops with the session.
+		 */
+		const checkPlanFile = async (): Promise<void> => {
+			const current = await store.read(cwd, plan.path);
+			if (!current) return;
+			if (stripFeedback(current.content) !== pageText) notifyPlanChange();
+		};
+		stopTicker = (deps.tick ?? defaultInterval)(deps.pollMs ?? PLAN_POLL_MS, () => void checkPlanFile());
+
+		const page = async (caller: ReviewCaller): Promise<ReviewPageData> => {
+			const { role } = caller;
 			const stored = await refreshPageText();
-			const current = pageText;
-			const blocks = planBlocks(current);
-			const sections = extractPlanSections(current);
-			// Per-occurrence change flags, aligned with the sections list: the same shape
-			// the terminal review renders, so duplicate headings cannot both light up.
-			const changed = changedSections(options.baseline, current);
-			const outline = sections.flatMap((section, index) =>
+			// The body, its blocks, and the comments out of one read of the file: an
+			// anchor names a block from this same parse, so the island cannot mark a
+			// comment onto a line the page never rendered.
+			const read = readFeedback(stored.content);
+			const current = read.body;
+			const blocks = read.blocks;
+			// Per-section change marks, each carrying its own section: the same shape the
+			// terminal review renders, so a heading and its mark cannot be paired wrongly.
+			const marks = changedSections(options.baseline, current);
+			const outline = marks.flatMap(({ section, changed }) =>
 				section.title === ""
 					? []
 					: [
@@ -202,7 +262,7 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 								line: section.line,
 								level: section.level,
 								text: section.title,
-								...(changed[index] ? { changed: true } : {}),
+								...(changed ? { changed: true } : {}),
 							},
 						],
 			);
@@ -220,9 +280,9 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 			return {
 				// The document's own H1 reads better than the file-name slug, and the
 				// slug is still the fallback for a plan that starts with something else.
-				title: sections.find((section) => section.level === 1)?.title || planTitle(basename(plan.path)),
+				title: marks.find((mark) => mark.section.level === 1)?.section.title || planTitle(basename(plan.path)),
 				blocks,
-				annotations: parseFeedback(stored.content),
+				annotations: read.annotations,
 				outline,
 				steps: {
 					done: stepList.filter((step) => step.status === "completed").length,
@@ -231,29 +291,79 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 				code,
 				limits: { comments: MAX_ANNOTATIONS, comment: MAX_COMMENT_LENGTH, quote: MAX_QUOTE_LENGTH },
 				token,
-				canApprove,
+				role,
+				// What the page keys this tab's unsaved draft on: same plan text, same draft.
+				rev: planDigest(current),
+				...(caller.name === undefined ? {} : { author: caller.name }),
+				canApprove: role === "owner" && canApprove,
+				share: role === "owner" ? shareSession.state() : undefined,
 			};
 		};
 
-		const save = async (annotations: PlanAnnotation[]): Promise<SaveResult> => {
+		/**
+		 * The owner's save decides the review; a reviewer's post only writes.
+		 * Both replace the comments of the writer they carry — the owner's are
+		 * untagged, a reviewer's are tagged with the name bound to that link — so
+		 * neither touches another writer's markers, and both refuse a plan that
+		 * changed since the page was rendered.
+		 */
+		const save = async (annotations: PlanAnnotation[], caller: ReviewCaller): Promise<SaveResult> => {
+			const { role } = caller;
 			const current = await store.read(cwd, plan.path);
 			if (!current) return { ok: false, status: 404, message: "The plan file is gone." };
 			if (stripFeedback(current.content) !== pageText) {
 				return { ok: false, status: 409, message: "The plan changed on disk; reload the page and review again." };
 			}
 			try {
-				savedPlan = await store.saveFeedback(cwd, plan.path, annotations);
-				return { ok: true };
+				if (role === "owner") {
+					savedPlan = await store.saveFeedback(cwd, plan.path, annotations);
+					streams.broadcast("comment");
+					return { ok: true };
+				}
+				// The link, not the payload, decides whose markers this post replaces: the name
+				// is bound to the token on its first write, and a page that signs another one
+				// is a stale tab rather than an authorized writer.
+				const claim = claimAuthor({ bound: caller.name, taken: tokens.namesExcept(caller) }, annotations);
+				if (!("name" in claim)) return { ok: false, status: claim.status, message: claim.message };
+				const own = annotations.filter((annotation) => normalizeAuthor(annotation.author) === claim.name);
+				// The saved plan is deliberately not recorded here: a post is not a result
+				// the session can return, so there is nothing for a later flush to resolve.
+				await store.saveFeedback(cwd, plan.path, own, { author: claim.name });
+				caller.name ??= claim.name;
+				streams.broadcast("comment");
+				if (own.length > 0) options.onReviewerComment?.(claim.name, own.length);
+				return { ok: true, author: claim.name };
 			} catch (error) {
 				return { ok: false, status: 500, message: error instanceof Error ? error.message : String(error) };
 			}
 		};
 
+		// The second listener, its reviewer token, and the state the page and
+		// `/plan share` read. It is handed the request handler, the role map, and the
+		// frame hooks, so sharing stays one concern instead of five fields here.
+		const shareSession = createShareSession({
+			handleRequest,
+			maxBodyBytes: bodyLimit,
+			ownerPort: () => currentPort,
+			networkInterfaces: deps.networkInterfaces ?? networkInterfaces,
+			mintReviewer: () => tokens.mint("reviewer"),
+			revokeReviewer: (value) => tokens.revoke(value),
+			nameOf: (value) => tokens.get(value)?.name,
+			broadcast: (kind, only) => streams.broadcast(kind, only === undefined ? undefined : { role: only }),
+			endStreams: (kind, only) => streams.end(kind, only),
+		});
+		const hosts = (): readonly string[] => shareSession.hosts();
+
 		const context: ReviewContext = {
-			token,
+			caller: (value) => tokens.get(value),
+			hosts,
 			canApprove,
 			page,
 			save,
+			share: () => shareSession.share(),
+			invite: () => shareSession.invite(),
+			revoke: (id) => shareSession.revoke(id),
+			stopShare: () => shareSession.stop(),
 			onSaved: (annotations) => {
 				pendingResult = savedPlan ? { status: "saved", plan: savedPlan, annotations } : { status: "cancelled" };
 			},
@@ -265,90 +375,59 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 			},
 		};
 
-		// Live event streams, used only to notice a closed tab. The explicit Cancel
-		// button and the abort signal are the deterministic paths.
-		const clients = new Set<ServerResponse>();
-		let hadClient = false;
-		const dropGrace = deps.dropGraceMs ?? DROP_GRACE_MS;
-		const schedule = deps.schedule ?? defaultTimer;
-		const scheduleDrop = (): void => {
-			if (clients.size > 0 || !hadClient || settled || cancelDrop) return;
-			cancelDrop = schedule(dropGrace, () => {
-				cancelDrop = undefined;
-				if (clients.size === 0) finish({ status: "cancelled" });
-			});
-		};
-
-		const server = createServer((request, response) => {
-			void (async () => {
-				const method = request.method ?? "GET";
-				const read =
-					method.toUpperCase() === "POST" ? await readBody(request, maxBody) : { ok: true as const, body: "" };
-				if (!read.ok) {
-					response.writeHead(413, { ...jsonHeaders(), Connection: "close" });
-					response.end(JSON.stringify({ error: "The request body is too large." }));
-					return;
-				}
-				const body = read.body;
-				let result: ServeResponse;
-				try {
-					result = await handleReviewRequest(context, method, request.url ?? "/", request.headers, body);
-				} catch {
-					result = {
-						status: 500,
-						headers: jsonHeaders(),
-						body: JSON.stringify({ error: "Internal error" }),
-					};
-				}
-				if (result.stream) {
-					openEventStream(response, result);
-					hadClient = true;
-					clients.add(response);
-					clearDrop();
-					request.on("close", () => {
-						clients.delete(response);
-						scheduleDrop();
-					});
-					return;
-				}
-				// A save or cancel only resolves the session after its response is on the
-				// wire; otherwise `close()` would force-close the socket mid-reply. The
-				// `close` path covers a client that walks away before the flush callback
-				// runs, so a settle cannot be lost with the socket.
-				const settlePending = (): void => {
-					const terminal = pendingResult;
-					if (!terminal) return;
-					pendingResult = undefined;
-					finish(terminal);
+		// Live event streams, used only to notice a closed owner tab: a reviewer's
+		// tab is not the review's lifetime. The explicit Cancel button and the abort
+		// signal are the deterministic paths.
+		/** One request, on either listener: the loopback page or a shared one. */
+		async function handleRequest(request: LoopbackRequest): Promise<LoopbackReply> {
+			let result: ServeResponse;
+			try {
+				result = await handleReviewRequest(context, request.method, request.url, request.headers, request.body);
+			} catch {
+				result = {
+					status: 500,
+					headers: jsonHeaders(),
+					body: JSON.stringify({ error: "Internal error" }),
 				};
-				respond(request, response, result, settlePending);
-				response.on("close", settlePending);
-			})();
-		});
+			}
+			// A save or cancel only resolves the session after its response is on the
+			// wire; otherwise `close()` would force-close the socket mid-reply. The same
+			// hook covers a client that walks away before the flush, so a settle cannot be
+			// lost with the socket.
+			const settlePending = (): void => {
+				const terminal = pendingResult;
+				if (!terminal) return;
+				pendingResult = undefined;
+				finish(terminal);
+			};
+			if (!result.stream) return { result, afterResponse: settlePending };
+			const token = parseRequestUrl(request.url)?.search.get("token") ?? "";
+			const streamCaller = context.caller(token);
+			return {
+				result,
+				openSink: (sink) => {
+					if (streamCaller !== undefined) streams.add(sink, { role: streamCaller.role, token });
+					return () => streams.remove(sink);
+				},
+			};
+		}
 
-		// The accept-level `error` listener lives in `bindLoopback`, so a transient
-		// failure cannot take the host down; the review still ends through its own
-		// paths: cancel, abort, drop, or shutdown.
 		const preferred = deps.port ?? ports.get(plan.path) ?? 0;
-		let port: number | undefined;
+		let server: LoopbackServer;
 		try {
-			port = await bindLoopback(server, preferred);
+			server = await serveLoopback({
+				ports: preferred === 0 ? [0] : [preferred, 0],
+				maxBodyBytes: bodyLimit,
+				handler: handleRequest,
+			});
 		} catch {
-			// The remembered port may have been taken between turns; fall back once.
-			if (preferred !== 0) {
-				try {
-					port = await bindLoopback(server, 0);
-				} catch {
-					port = undefined;
-				}
-			}
-		}
-		if (port === undefined) {
-			server.close();
+			// The remembered port may have been taken between turns; the fallback above
+			// covers that, so reaching here means neither port answered.
 			return undefined;
 		}
+		const port = server.port;
 		ports.set(plan.path, port);
-		const closeServer = createCloser(server);
+		currentPort = port;
 
 		const url = `http://127.0.0.1:${port}/?token=${token}`;
 		let closed = false;
@@ -358,14 +437,19 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 			closed = true;
 			if (signal && abortHandler) signal.removeEventListener("abort", abortHandler);
 			sessions.delete(session);
-			for (const client of clients) client.end();
-			clients.clear();
+			shares.delete(session);
+			// `finish` ends every open stream with its last frame, so it runs before
+			// the set is cleared rather than after it.
 			finish({ status: "cancelled" });
-			await closeServer();
+			stopTicker();
+			streams.clear();
+			await shareSession.close();
+			await server.close();
 		};
 
 		const session: PlanReviewSession = { url, port, done, close };
 		sessions.add(session);
+		shares.set(session, shareSession);
 
 		if (signal) {
 			abortHandler = (): void => void close();
@@ -377,8 +461,18 @@ export function createPlanWebReview(store: PlanStore, deps: PlanWebReviewDeps =
 		return session;
 	};
 
+	const current = (): PlanReviewSession | undefined => [...sessions].at(-1);
+	const controls = () => {
+		const session = current();
+		return session ? shares.get(session) : undefined;
+	};
+
 	return {
 		start,
+		current,
+		share: async () => controls()?.share(),
+		stopSharing: async () => controls()?.stop(),
+		shareState: () => controls()?.state(),
 		closeAll: async () => {
 			await Promise.all([...sessions].map((session) => session.close()));
 		},

package/extensions/question/dialogs.ts

@@ -6,13 +6,15 @@
  * fake and reusable by any host.
  */
 
-import { OTHER_LABEL, cancelledResult, completedResult } from "./answers.ts";
+import { OTHER_LABEL, cancelledResult, collectAnswers, completedResult } from "./answers.ts";
 import type { Answer, AskResult, Question, Selection } from "./types.ts";
 
 export interface QuestionUI {
 	select(title: string, options: string[], opts?: { signal?: AbortSignal }): Promise<string | undefined>;
 	input(title: string, placeholder?: string, opts?: { signal?: AbortSignal }): Promise<string | undefined>;
 	editor(title: string, prefill?: string): Promise<string | undefined>;
+	/** Prompt language, when the host knows it. */
+	language?(): "zh" | "en";
 }
 
 const MULTI_INSTRUCTIONS = "Enter one or more option numbers or labels, separated by commas.";
@@ -56,8 +58,96 @@ export function parseMultiSelect(question: Question, text: string): Selection |
 	return { type: "options", values, labels, indices };
 }
 
+/** The one-message prompt for a multi-question ask. */
+export function batchPrompt(questions: Question[], language: "zh" | "en" = "en"): string {
+	const zh = language === "zh";
+	const lines = [zh ? "请一次性回答所有问题：" : "Answer all questions in one message:", ""];
+	questions.forEach((question, index) => {
+		lines.push(`${index + 1}. ${question.question}`);
+		if (question.options.length === 0) {
+			lines.push(zh ? "   文字" : "   text");
+			return;
+		}
+		const options = question.options.map((option, optionIndex) => `${optionIndex + 1}. ${option.label}`).join("  ");
+		lines.push(`   ${options}${question.multiSelect ? (zh ? "（可多选）" : " (multi)") : ""}`);
+	});
+	lines.push("", zh ? "格式：1: 2；2: A, B；3: 文字" : "Format: 1: 2; 2: A, B; 3: text");
+	return lines.join("\n");
+}
+
+/**
+ * Parse one batch reply. Each line/semicolon chunk starts with the question
+ * number; a chunk with no prefix makes the whole reply ambiguous.
+ */
+export function parseBatchAnswers(questions: Question[], text: string): Map<string, Selection> | undefined {
+	const entries = new Map<number, string>();
+	for (const chunk of text.split(/[\n;]+/)) {
+		const match = /^\s*(\d+)\s*[:.)-]\s*(.*)$/.exec(chunk);
+		if (!match) {
+			if (chunk.trim() !== "") return undefined;
+			continue;
+		}
+		const index = Number.parseInt(match[1] ?? "", 10);
+		if (index < 1 || index > questions.length) return undefined;
+		entries.set(index, (match[2] ?? "").trim());
+	}
+	const selections = new Map<string, Selection>();
+	for (const [index, question] of questions.entries()) {
+		const raw = entries.get(index + 1);
+		if (raw === undefined || raw === "") return undefined;
+		if (question.options.length === 0) {
+			selections.set(question.id, { type: "custom", text: raw });
+			continue;
+		}
+		if (question.multiSelect) {
+			const selection = parseMultiSelect(question, raw);
+			if (!selection) return undefined;
+			selections.set(question.id, selection);
+			continue;
+		}
+		const asNumber = Number.parseInt(raw, 10);
+		const optionIndex =
+			String(asNumber) === raw && asNumber >= 1 && asNumber <= question.options.length
+				? asNumber - 1
+				: question.options.findIndex((option) => option.label.toLowerCase() === raw.toLowerCase());
+		if (optionIndex >= 0) {
+			const option = question.options[optionIndex];
+			if (!option) return undefined;
+			selections.set(question.id, {
+				type: "options",
+				values: [option.label],
+				labels: [option.label],
+				indices: [optionIndex + 1],
+			});
+			continue;
+		}
+		if (!question.allowOther) return undefined;
+		selections.set(question.id, { type: "custom", text: raw });
+	}
+	return selections;
+}
+
+/** One batch editor, with one retry only when the format was not understood. */
+async function askViaBatch(ui: QuestionUI, questions: Question[], signal?: AbortSignal): Promise<AskResult> {
+	const language = ui.language?.() ?? "en";
+	const prompt = batchPrompt(questions, language);
+	const first = await ui.editor(prompt, "");
+	if (first === undefined) return cancelledResult(questions);
+	const parsed = parseBatchAnswers(questions, first);
+	if (parsed) return completedResult(questions, parsed);
+	if (signal?.aborted) return cancelledResult(questions);
+	const retry = await ui.editor(
+		`${prompt}\n\n${language === "zh" ? "格式不对，请按“1: 答案”重发。" : "Please reply again as “1: answer”."}`,
+		"",
+	);
+	if (retry === undefined) return cancelledResult(questions);
+	const again = parseBatchAnswers(questions, retry);
+	return again ? completedResult(questions, again) : cancelledResult(questions, collectAnswers(questions, new Map()));
+}
+
 /** Ask every question through forwarded dialogs, stopping on cancel or abort. */
 export async function askViaDialogs(ui: QuestionUI, questions: Question[], signal?: AbortSignal): Promise<AskResult> {
+	if (questions.length > 1) return askViaBatch(ui, questions, signal);
 	const selections = new Map<string, Selection>();
 	const opts = { signal };