@selesai/code 0.8.4 → 0.8.6

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

@@ -1,5 +1,4 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import questionExtension from "../index.ts";
 
@@ -44,59 +43,781 @@ function type(component: any, text: string) {
 	for (const character of text) component.handleInput(character);
 }
 
-test("wizard submits typed selections and text without review comments", async () => {
-	const { component, execution } = await runWizard({
-		questions: [
-			{ id: "choice", type: "select", question: "Choose", options: [{ value: "one", label: "One" }] },
-			{ id: "many", type: "multiselect", question: "Choose many", options: [{ value: "a", label: "A" }, { value: "b", label: "B" }] },
-			{ id: "note", type: "text", question: "Explain" },
-		],
-	});
-	component().handleInput(ENTER); // choice commits and advances
-	component().handleInput(" ");
-	component().handleInput(DOWN);
-	component().handleInput(" ");
-	component().handleInput(ENTER); // multi-select commits and advances
-	type(component(), "details");
-	component().handleInput(ENTER); // text commits and advances to review
-	assert.doesNotMatch(component().render(120).join("\n"), /Optional comment/);
-	component().handleInput(ENTER);
-
-	const result = await execution;
-	assert.deepEqual(result.details, {
-		status: "submitted",
-		answers: [
-			{ id: "choice", status: "answered", response: { kind: "selection", values: ["one"] } },
-			{ id: "many", status: "answered", response: { kind: "selection", values: ["a", "b"] } },
-			{ id: "note", status: "answered", response: { kind: "text", text: "details" } },
-		],
+describe("question wizard", () => {
+	it("submits typed selections and text without review comments", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ id: "choice", type: "select", question: "Choose", options: [{ value: "one", label: "One" }] },
+				{ id: "many", type: "multiselect", question: "Choose many", options: [{ value: "a", label: "A" }, { value: "b", label: "B" }] },
+				{ id: "note", type: "text", question: "Explain" },
+			],
+		});
+		component().handleInput(ENTER); // choice commits and advances
+		component().handleInput(" ");
+		component().handleInput(DOWN);
+		component().handleInput(" ");
+		component().handleInput(ENTER); // multi-select commits and advances
+		type(component(), "details");
+		component().handleInput(ENTER); // text commits and advances to review
+		expect(component().render(120).join("\n")).not.toMatch(/Optional comment/);
+		component().handleInput(ENTER);
+
+		const result = await execution;
+		expect(result.details).toEqual({
+			status: "submitted",
+			answers: [
+				{ id: "choice", status: "answered", response: { kind: "selection", values: ["one"] } },
+				{ id: "many", status: "answered", response: { kind: "selection", values: ["a", "b"] } },
+				{ id: "note", status: "answered", response: { kind: "text", text: "details" } },
+			],
+		});
+	});
+
+	it("preserves skipped, Other, and cancelled outcomes", async () => {
+		const skipped = await runWizard({ questions: [{ type: "select", question: "Skip", options: [{ value: "x", label: "X" }] }] });
+		skipped.component().handleInput(TAB);
+		skipped.component().handleInput(ENTER);
+		expect((await skipped.execution).details).toEqual({ status: "submitted", answers: [{ id: "q1", status: "skipped" }] });
+
+		const other = await runWizard({ questions: [{ type: "select", question: "Other", options: [{ value: "x", label: "X" }], allowOther: true }] });
+		other.component().handleInput(DOWN);
+		other.component().handleInput(ENTER);
+		type(other.component(), "custom");
+		other.component().handleInput(ENTER); // one answered question submits immediately
+		expect((await other.execution).details).toEqual({
+			status: "submitted",
+			answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: [], otherText: "custom" } }],
+		});
+
+		const selected = await runWizard({ questions: [{ type: "select", question: "Select", options: [{ value: "x", label: "X" }] }] });
+		selected.component().handleInput(ENTER);
+		expect((await selected.execution).details).toEqual({
+			status: "submitted",
+			answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: ["x"] } }],
+		});
+
+		const cancelled = await runWizard({ questions: [{ type: "select", question: "Cancel", options: [{ value: "x", label: "X" }] }] });
+		cancelled.component().handleInput(ESC);
+		expect((await cancelled.execution).details).toEqual({ status: "cancelled", reason: "user" });
+	});
+
+	it("navigates back to edit answers and re-submits", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }, { value: "b", label: "B" }] },
+				{ type: "text", question: "Two" },
+			],
+		});
+		component().handleInput(ENTER); // select "a", advance
+		type(component(), "answer");
+		component().handleInput(ENTER); // text commits, advance to review
+		component().handleInput("\x1b[D"); // left = back to q2 (text)
+		component().handleInput(ESC); // blur the text editor
+		component().handleInput(SHIFT_TAB); // back to q1
+		component().handleInput(DOWN); // move to "b"
+		component().handleInput(ENTER); // commit "b", advance to q2
+		component().handleInput(ENTER); // commit q2 text (restored "answer"), advance to review
+		component().handleInput(ENTER); // submit
+
+		const result = await execution;
+		expect(result.details).toEqual({
+			status: "submitted",
+			answers: [
+				{ id: "q1", status: "answered", response: { kind: "selection", values: ["b"] } },
+				{ id: "q2", status: "answered", response: { kind: "text", text: "answer" } },
+			],
+		});
+	});
+
+	it("text question escape blurs, enter re-focuses, escape again cancels", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().handleInput(ESC); // blur editor
+		component().handleInput(ENTER); // re-focus
+		type(component(), "typed");
+		component().handleInput(ENTER); // commit + submit (single question)
+		const result = await execution;
+		expect(result.details).toEqual({
+			status: "submitted",
+			answers: [{ id: "q1", status: "answered", response: { kind: "text", text: "typed" } }],
+		});
+	});
+
+	it("cancels from a text question via escape when not editing", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().handleInput(ESC); // blur editor
+		component().handleInput(ESC); // cancel
+		expect((await execution).details).toEqual({ status: "cancelled", reason: "user" });
+	});
+
+	it("emits question:cancelled and question:submitted events", async () => {
+		const emitted: string[] = [];
+		let tool: any;
+		let component: any;
+		let done!: (value: unknown) => void;
+		questionExtension({
+			registerTool: (entry: unknown) => (tool = entry),
+			events: { emit: (name: string) => emitted.push(name) },
+		} as any);
+		const execution = tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, undefined, undefined, {
+			mode: "tui",
+			ui: {
+				custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+					done = resolve;
+					component = factory(tui, theme, keybindings, done);
+				}),
+			},
+		} as any);
+		component.handleInput(ESC);
+		await execution;
+		expect(emitted).toEqual(["question:cancelled"]);
+
+		const emitted2: string[] = [];
+		let tool2: any;
+		let component2: any;
+		let done2!: (value: unknown) => void;
+		questionExtension({
+			registerTool: (entry: unknown) => (tool2 = entry),
+			events: { emit: (name: string) => emitted2.push(name) },
+		} as any);
+		const execution2 = tool2.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, undefined, undefined, {
+			mode: "tui",
+			ui: {
+				custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+					done2 = resolve;
+					component2 = factory(tui, theme, keybindings, done2);
+				}),
+			},
+		} as any);
+		component2.handleInput(ENTER);
+		await execution2;
+		expect(emitted2).toEqual(["question:submitted"]);
+	});
+
+	it("rejects non-TUI modes and invalid params", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+
+		await expect(tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, undefined, undefined, {
+			mode: "rpc",
+		} as any)).rejects.toThrow("Question requires terminal TUI mode.");
+
+		await expect(tool.execute("call", { questions: [] }, undefined, undefined, {
+			mode: "tui",
+		} as any)).rejects.toThrow("questions must contain at least one question.");
+	});
+
+	it("returns cancelled when the signal is already aborted", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const signal = { aborted: true, reason: new Error("cancelled") };
+		const result = await tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, signal, undefined, {
+			mode: "tui",
+		} as any);
+		expect(result.details).toEqual({ status: "cancelled", reason: "user" });
+	});
+
+	it("throws when the TUI custom factory returns no result", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		await expect(tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, undefined, undefined, {
+			mode: "tui",
+			ui: { custom: async () => undefined },
+		} as any)).rejects.toThrow("Question TUI did not return a result.");
 	});
-});
 
-test("wizard preserves skipped, Other, and cancelled outcomes", async () => {
-	const skipped = await runWizard({ questions: [{ type: "select", question: "Skip", options: [{ value: "x", label: "X" }] }] });
-	skipped.component().handleInput(TAB);
-	skipped.component().handleInput(ENTER);
-	assert.deepEqual((await skipped.execution).details, { status: "submitted", answers: [{ id: "q1", status: "skipped" }] });
+	it("renderCall and renderResult produce summary text", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
 
-	const other = await runWizard({ questions: [{ type: "select", question: "Other", options: [{ value: "x", label: "X" }], allowOther: true }] });
-	other.component().handleInput(DOWN);
-	other.component().handleInput(ENTER);
-	type(other.component(), "custom");
-	other.component().handleInput(ENTER); // one answered question submits immediately
-	assert.deepEqual((await other.execution).details, {
-		status: "submitted",
-		answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: [], otherText: "custom" } }],
+		const call = tool.renderCall({ questions: [{ id: "a", label: "Alpha", type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] }, theme);
+		expect(call.render(80).join("\n")).toContain("QUESTION");
+		expect(call.render(80).join("\n")).toContain("Alpha");
+
+		const result = {
+			content: [{ type: "text", text: "waiting" }],
+			details: {
+				status: "submitted",
+				answers: [
+					{ id: "a", status: "answered", response: { kind: "selection", values: ["x"] } },
+					{ id: "b", status: "skipped" },
+					{ id: "c", status: "unanswered" },
+				],
+			},
+		};
+		const partial = tool.renderResult(result, { isPartial: true }, theme, {});
+		expect(partial.render(80).join("\n")).toContain("waiting");
+
+		const full = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {
+			args: { questions: [{ id: "a", label: "Alpha", type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] },
+		});
+		const fullText = full.render(80).join("\n");
+		expect(fullText).toContain("submitted");
+		expect(fullText).toContain("1 answered");
+		expect(fullText).toContain("X"); // option label from the expanded answer row
+
+		const cancelled = tool.renderResult({ content: [], details: { status: "cancelled", reason: "user" } }, { isPartial: false }, theme, {});
+		expect(cancelled.render(80).join("\n")).toContain("question cancelled");
+	});
+
+	it("renderResult expanded maps unknown ids to raw values", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [
+					{ id: "q1", status: "answered", response: { kind: "selection", values: ["x"] } },
+				],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, { args: { questions: [] } });
+		expect(rendered.render(80).join("\n")).toContain("q1");
+	});
+
+	it("navigates with Tab/Shift+Tab and skips blank answers", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(TAB); // skip q1
+		component().handleInput(ENTER); // answer q2
+		component().handleInput("\x1b[D"); // left: back to q2 from review
+		component().handleInput(SHIFT_TAB); // back to q1
+		component().handleInput(ENTER); // answer q1
+		component().handleInput(ENTER); // advance to review
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details).toEqual({
+			status: "submitted",
+			answers: [
+				{ id: "q1", status: "answered", response: { kind: "selection", values: ["a"] } },
+				{ id: "q2", status: "answered", response: { kind: "selection", values: ["b"] } },
+			],
+		});
+	});
+
+	it("renders narrow borders and context text", async () => {
+		const { component } = await runWizard({
+			questions: [
+				{ type: "select", question: "Q", context: "Some context", options: [{ value: "a", label: "A" }] },
+			],
+		});
+		const lines = component().render(4);
+		expect(lines.length).toBeGreaterThan(0);
+		expect(lines.join("\n")).toContain("╭");
+		expect(lines.join("\n")).toContain("╰");
+	});
+
+	it("restores a previous selection response with otherText", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "Q", options: [{ value: "a", label: "A" }], allowOther: true },
+			],
+		});
+		// Answer with Other, then navigate back and verify the draft is restored.
+		component().handleInput(DOWN); // to freeform
+		component().handleInput(ENTER); // open other editor
+		type(component(), "custom answer");
+		component().handleInput(ENTER); // commit + submit (single question)
+		const result = await execution;
+		expect(result.details).toEqual({
+			status: "submitted",
+			answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: [], otherText: "custom answer" } }],
+		});
+	});
+
+	it("review page renders answered, skipped, and unanswered states", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+				{ type: "select", question: "Three", options: [{ value: "c", label: "C" }] },
+			],
+		});
+		component().handleInput(ENTER); // answer q1
+		component().handleInput(TAB); // skip q2
+		component().handleInput(ENTER); // answer q3 → review
+		const lines = component().render(120).join("\n");
+		expect(lines).toContain("✓");
+		expect(lines).toContain("−");
+		expect(lines).toContain("Submit");
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers).toHaveLength(3);
 	});
 
-	const selected = await runWizard({ questions: [{ type: "select", question: "Select", options: [{ value: "x", label: "X" }] }] });
-	selected.component().handleInput(ENTER);
-	assert.deepEqual((await selected.execution).details, {
-		status: "submitted",
-		answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: ["x"] } }],
+	it("review page truncates long answer lists", async () => {
+		const questions = Array.from({ length: 30 }, (_, i) => ({
+			type: "select" as const,
+			question: `Question ${i}`,
+			options: [{ value: `v${i}`, label: `V${i}` }],
+		}));
+		const { component, execution } = await runWizard({ questions });
+		for (let i = 0; i < 30; i++) {
+			component().handleInput(ENTER);
+		}
+		const lines = component().render(120).join("\n");
+		expect(lines).toContain("↑ earlier answers");
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers).toHaveLength(30);
 	});
 
-	const cancelled = await runWizard({ questions: [{ type: "select", question: "Cancel", options: [{ value: "x", label: "X" }] }] });
-	cancelled.component().handleInput(ESC);
-	assert.deepEqual((await cancelled.execution).details, { status: "cancelled", reason: "user" });
+	it("review page cancels on escape and goes back on left", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER);
+		component().handleInput(ENTER); // → review
+		component().handleInput(ESC); // cancel
+		expect((await execution).details).toEqual({ status: "cancelled", reason: "user" });
+
+		const w2 = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		w2.component().handleInput(ENTER);
+		w2.component().handleInput(ENTER); // → review
+		w2.component().handleInput("\x1b[D"); // left → back to q2
+		w2.component().handleInput(ENTER); // commit q2
+		w2.component().handleInput(ENTER); // → review
+		w2.component().handleInput(ENTER); // submit
+		expect((await w2.execution).details.answers).toHaveLength(2);
+	});
+
+	it("focused setter propagates to the question component", async () => {
+		const { component } = await runWizard({
+			questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }],
+		});
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("onUpdate reports waiting for answers", async () => {
+		let tool: any;
+		let component: any;
+		let done!: (value: unknown) => void;
+		const updates: any[] = [];
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const execution = tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }] }, undefined, (u: any) => updates.push(u), {
+			mode: "tui",
+			ui: {
+				custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+					done = resolve;
+					component = factory(tui, theme, keybindings, done);
+				}),
+			},
+		} as any);
+		expect(updates).toHaveLength(1);
+		expect(updates[0].content[0].text).toContain("Waiting for answers to 1 question");
+		component.handleInput(ENTER);
+		await execution;
+	});
+
+	it("signal abort during the wizard resolves cancelled", async () => {
+		let tool: any;
+		let component: any;
+		let done!: (value: unknown) => void;
+		const controller = new AbortController();
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const execution = tool.execute("call", { questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }] }, controller.signal, undefined, {
+			mode: "tui",
+			ui: {
+				custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+					done = resolve;
+					component = factory(tui, theme, keybindings, done);
+				}),
+			},
+		} as any);
+		controller.abort();
+		const result = await execution;
+		expect(result.details).toEqual({ status: "cancelled", reason: "user" });
+	});
+
+	it("restores a text response draft when navigating back", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "text", question: "One" },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		type(component(), "draft answer");
+		component().handleInput(ENTER); // commit q1
+		component().handleInput(ENTER); // answer q2 → review
+		component().handleInput("\x1b[D"); // left → back to q2
+		component().handleInput(SHIFT_TAB); // back to q1
+		// The text draft should be restored.
+		component().handleInput(ENTER); // commit q1 (restored draft)
+		component().handleInput(ENTER); // commit q2
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers[0]).toEqual({ id: "q1", status: "answered", response: { kind: "text", text: "draft answer" } });
+	});
+
+	it("restores a selection response with otherText when navigating back", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }], allowOther: true },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(DOWN); // to freeform
+		component().handleInput(ENTER); // open other editor
+		type(component(), "custom");
+		component().handleInput(ENTER); // commit q1 → q2
+		component().handleInput(ENTER); // answer q2 → review
+		component().handleInput("\x1b[D"); // left → back to q2
+		component().handleInput(SHIFT_TAB); // back to q1
+		// The other draft should be restored in the editor.
+		component().handleInput(ENTER); // commit q1 (restored other)
+		component().handleInput(ENTER); // commit q2
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers[0]).toEqual({ id: "q1", status: "answered", response: { kind: "selection", values: [], otherText: "custom" } });
+	});
+
+	it("focused setter propagates to the review component", async () => {
+		const { component } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER);
+		component().handleInput(ENTER); // → review
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("renderResult expanded maps unknown ids to raw values", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [
+					{ id: "q1", status: "answered", response: { kind: "selection", values: ["x"] } },
+				],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, { args: { questions: [] } });
+		expect(rendered.render(80).join("\n")).toContain("q1");
+	});
+
+	it("renderResult expanded maps known ids to labels and Other", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [
+					{ id: "a", status: "answered", response: { kind: "selection", values: ["x"], otherText: "extra" } },
+					{ id: "b", status: "skipped" },
+					{ id: "c", status: "unanswered" },
+				],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {
+			args: { questions: [{ id: "a", label: "Alpha", type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] },
+		});
+		const text = rendered.render(80).join("\n");
+		expect(text).toContain("X"); // option label mapped from the question
+		expect(text).toContain("Other: extra");
+		expect(text).toContain("skipped");
+		expect(text).toContain("unanswered");
+	});
+
+	it("renderResult expanded maps unknown option values to raw values", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [
+					{ id: "a", status: "answered", response: { kind: "selection", values: ["unknown-value"] } },
+				],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {
+			args: { questions: [{ id: "a", label: "Alpha", type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] },
+		});
+		expect(rendered.render(80).join("\n")).toContain("unknown-value");
+	});
+
+	it("renders wide borders with the full label", async () => {
+		const { component } = await runWizard({
+			questions: [
+				{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] },
+			],
+		});
+		const lines = component().render(120).join("\n");
+		expect(lines).toContain("╭─ question");
+		expect(lines).toContain("v2");
+	});
+
+	it("renders the text editor theme when answering a text question", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		// Render the text editor to exercise editorTheme.
+		component().render(120);
+		type(component(), "answer");
+		component().handleInput(ENTER);
+		const result = await execution;
+		expect(result.details.answers[0].response).toEqual({ kind: "text", text: "answer" });
+	});
+
+	it("escape from other mode returns to select and preserves the draft", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }], allowOther: true },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(DOWN); // to freeform
+		component().handleInput(ENTER); // open other editor
+		type(component(), "draft");
+		component().handleInput(ESC); // escape back to select mode
+		component().handleInput("\x0b"); // ctrl+k = vim up to the option row
+		component().handleInput(ENTER); // commit q1 (selection)
+		component().handleInput(ENTER); // answer q2 → review
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers[0]).toEqual({ id: "q1", status: "answered", response: { kind: "selection", values: ["a"] } });
+	});
+
+	it("reads the review component focused state", async () => {
+		const { component } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER);
+		component().handleInput(ENTER); // → review
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("reads the question component focused state", async () => {
+		const { component } = await runWizard({
+			questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }],
+		});
+		expect(component().focused).toBe(false);
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("renderCall handles missing labels and ids", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+
+		const withId = tool.renderCall({ questions: [{ id: "q1", type: "select", question: "Q", options: [{ value: "a", label: "A" }] }] }, theme);
+		expect(withId.render(80).join("\n")).toContain("q1");
+
+		const withIndex = tool.renderCall({ questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }] }, theme);
+		expect(withIndex.render(80).join("\n")).toContain("Q1");
+
+		const noQuestions = tool.renderCall({}, theme);
+		expect(noQuestions.render(80).join("\n")).toContain("0 questions");
+	});
+
+	it("renderResult partial with no text content falls back", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const rendered = tool.renderResult({ content: [] }, { isPartial: true }, theme, {});
+		expect(rendered.render(80).join("\n")).toContain("Waiting for user input");
+	});
+
+	it("renderResult non-expanded omits answer details", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [{ id: "a", status: "answered", response: { kind: "text", text: "x" } }],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false }, theme, {});
+		expect(rendered.render(80).join("\n")).toContain("submitted");
+	});
+
+	it("renderResult expanded with text answers uses raw text", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [{ id: "a", status: "answered", response: { kind: "text", text: "plain text" } }],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {
+			args: { questions: [{ id: "a", label: "Alpha", type: "text", question: "Q" }] },
+		});
+		expect(rendered.render(80).join("\n")).toContain("plain text");
+	});
+
+	it("renderResult expanded with missing question falls back to raw answer", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [{ id: "a", status: "answered", response: { kind: "selection", values: ["x"] } }],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, { args: {} });
+		expect(rendered.render(80).join("\n")).toContain("x");
+	});
+
+	it("renderResult expanded matches questions by generated ids", async () => {
+		let tool: any;
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const result = {
+			content: [],
+			details: {
+				status: "submitted",
+				answers: [{ id: "q1", status: "answered", response: { kind: "selection", values: ["x"] } }],
+			},
+		};
+		const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {
+			args: { questions: [{ type: "select", question: "Q", options: [{ value: "x", label: "X" }] }] },
+		});
+		expect(rendered.render(80).join("\n")).toContain("X");
+	});
+
+	it("reads the question component focused getter", async () => {
+		const { component } = await runWizard({
+			questions: [{ type: "select", question: "Q", options: [{ value: "a", label: "A" }] }],
+		});
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("reads the review component focused getter", async () => {
+		const { component } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER);
+		component().handleInput(ENTER); // → review
+		component().focused = true;
+		expect(component().focused).toBe(true);
+	});
+
+	it("renders the text editor to exercise the editor theme", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		// Render at a wide width so the editor renders and uses the theme.
+		component().render(120);
+		type(component(), "answer");
+		component().handleInput(ENTER);
+		const result = await execution;
+		expect(result.details.answers[0].response).toEqual({ kind: "text", text: "answer" });
+	});
+
+	it("re-focuses a blurred text editor with enter", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().handleInput(ESC); // blur editor
+		component().handleInput(ENTER); // re-focus
+		type(component(), "typed");
+		component().handleInput(ENTER); // commit + submit
+		const result = await execution;
+		expect(result.details.answers[0].response).toEqual({ kind: "text", text: "typed" });
+	});
+
+	it("saveCurrent is a no-op on the review page", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER);
+		component().handleInput(ENTER); // → review
+		// Tab on the review page does nothing (no crash).
+		component().handleInput(TAB);
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers).toHaveLength(2);
+	});
+
+	it("goPrevious from the first question stays put", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(SHIFT_TAB); // back from q1 → stays on q1
+		component().handleInput(ENTER); // answer q1
+		component().handleInput(ENTER); // answer q2 → review
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers).toHaveLength(2);
+	});
+
+	it("commitCurrent from the last question advances to review", async () => {
+		const { component, execution } = await runWizard({
+			questions: [
+				{ type: "select", question: "One", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Two", options: [{ value: "b", label: "B" }] },
+			],
+		});
+		component().handleInput(ENTER); // answer q1 → q2
+		component().handleInput(ENTER); // answer q2 → review
+		component().handleInput(ENTER); // submit
+		const result = await execution;
+		expect(result.details.answers).toHaveLength(2);
+	});
+
+	it("onUpdate reports waiting for multiple questions", async () => {
+		let tool: any;
+		let component: any;
+		let done!: (value: unknown) => void;
+		const updates: any[] = [];
+		questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+		const execution = tool.execute("call", {
+			questions: [
+				{ type: "select", question: "Q1", options: [{ value: "a", label: "A" }] },
+				{ type: "select", question: "Q2", options: [{ value: "b", label: "B" }] },
+			],
+		}, undefined, (u: any) => updates.push(u), {
+			mode: "tui",
+			ui: {
+				custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+					done = resolve;
+					component = factory(tui, theme, keybindings, done);
+				}),
+			},
+		} as any);
+		expect(updates[0].content[0].text).toContain("Waiting for answers to 2 questions");
+		component.handleInput(ENTER);
+		component.handleInput(ENTER);
+		component.handleInput(ENTER);
+		await execution;
+	});
 });