pi-plans 0.2.0 → 0.3.0

package/src/subagent.ts

@@ -9,16 +9,21 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
+export type SubagentTranscriptEntryType = "assistant-text" | "thinking" | "tool-call" | "tool-result";
+
 export type SubagentProgressEvent =
 	| { type: "process"; phase: "started" | "exited"; code?: number }
-	| { type: "turn"; phase: "start" | "end" }
-	| { type: "message"; phase: "start" | "update" | "end"; role: string; text: string }
+	| { type: "turn"; phase: "start" | "end"; turnIndex?: number }
 	| {
-			type: "tool";
+			type: "transcript";
 			phase: "start" | "update" | "end";
-			toolCallId: string;
-			toolName: string;
-			detail: string;
+			entryType: SubagentTranscriptEntryType;
+			key: string;
+			text: string;
+			update: "append" | "replace";
+			streaming: boolean;
+			toolCallId?: string;
+			toolName?: string;
 			isError?: boolean;
 	  }
 	| { type: "stderr"; text: string };
@@ -72,12 +77,13 @@ export function getPiInvocation(args: string[]): { command: string; args: string
 
 interface MessageLike {
 	role: string;
-	content?: Array<{ type: string; text?: string; thinking?: string }> | string;
+	content?: unknown;
 	model?: string;
 }
 
 interface RawSubagentEvent {
 	type?: unknown;
+	turnIndex?: unknown;
 	message?: MessageLike;
 	toolCallId?: unknown;
 	toolName?: unknown;
@@ -88,6 +94,42 @@ interface RawSubagentEvent {
 	assistantMessageEvent?: unknown;
 }
 
+function formatValue(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (value === undefined) return "";
+	if (value && typeof value === "object") {
+		const content = (value as { content?: unknown }).content;
+		if (Array.isArray(content)) {
+			const text = content
+				.map((part) => {
+					if (part && typeof part === "object" && typeof (part as { text?: unknown }).text === "string") {
+						return (part as { text: string }).text;
+					}
+					return formatValue(part);
+				})
+				.filter(Boolean)
+				.join("\n");
+			if (text) return text;
+		}
+	}
+	try {
+		return JSON.stringify(value, null, 2) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+function messageText(message: MessageLike | undefined, kind: "text" | "thinking" = "text"): string {
+	if (!Array.isArray(message?.content)) return typeof message?.content === "string" && kind === "text" ? message.content : "";
+	return message.content
+		.filter((part) => part && typeof part === "object" && (part as { type?: unknown }).type === kind)
+		.map((part) => {
+			const value = part as { text?: unknown; thinking?: unknown };
+			return typeof value.text === "string" ? value.text : typeof value.thinking === "string" ? value.thinking : "";
+		})
+		.join("\n");
+}
+
 function finalOutput(messages: MessageLike[]): string {
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const message = messages[i];
@@ -99,29 +141,91 @@ function finalOutput(messages: MessageLike[]): string {
 	return "";
 }
 
-function messageText(message: MessageLike | undefined, kind: "text" | "thinking" = "text"): string {
-	if (!message?.content) return "";
-	if (typeof message.content === "string") return kind === "text" ? message.content : "";
-	return message.content
-		.filter((part) => part.type === kind)
-		.map((part) => (kind === "thinking" ? part.thinking ?? part.text ?? "" : part.text ?? ""))
-		.join("\n");
+interface TranscriptEventOptions {
+	toolCallId?: string;
+	toolName?: string;
+	isError?: boolean;
 }
 
-function messageEventText(value: unknown): string {
-	if (!value || typeof value !== "object") return "";
-	const event = value as { delta?: unknown; content?: unknown };
-	return typeof event.delta === "string" ? event.delta : typeof event.content === "string" ? event.content : "";
+function transcriptEvent(
+	phase: "start" | "update" | "end",
+	entryType: SubagentTranscriptEntryType,
+	key: string,
+	text: string,
+	update: "append" | "replace",
+	streaming: boolean,
+	options: TranscriptEventOptions = {},
+): SubagentProgressEvent {
+	return { type: "transcript", phase, entryType, key, text, update, streaming, ...options };
 }
 
-function preview(value: unknown, maxLength = 240): string {
-	if (typeof value === "string") return value.slice(0, maxLength);
-	if (value === undefined) return "";
-	try {
-		const text = JSON.stringify(value);
-		return text ? text.slice(0, maxLength) : "";
-	} catch {
-		return String(value).slice(0, maxLength);
+function messageContentEvents(message: MessageLike | undefined, phase: "start" | "end"): SubagentProgressEvent[] {
+	if (message?.role !== "assistant" || !Array.isArray(message.content)) return [];
+	return message.content.flatMap((part, index) => {
+		if (!part || typeof part !== "object") return [];
+		const value = part as { type?: unknown; text?: unknown; thinking?: unknown; id?: unknown; name?: unknown; arguments?: unknown };
+		if (value.type === "text" && typeof value.text === "string") {
+			return [transcriptEvent(phase, "assistant-text", `content:${index}`, value.text, "replace", phase !== "end")];
+		}
+		if (value.type === "thinking") {
+			const text = typeof value.thinking === "string" ? value.thinking : typeof value.text === "string" ? value.text : "";
+			return [transcriptEvent(phase, "thinking", `content:${index}`, text, "replace", phase !== "end")];
+		}
+		if (value.type === "toolCall") {
+			return [transcriptEvent(phase, "tool-call", `content:${index}`, formatValue(value.arguments), "replace", phase !== "end", {
+				toolCallId: typeof value.id === "string" ? value.id : undefined,
+				toolName: typeof value.name === "string" ? value.name : undefined,
+			})];
+		}
+		return [];
+	});
+}
+
+function assistantUpdateEvents(event: RawSubagentEvent): SubagentProgressEvent[] {
+	const update = event.assistantMessageEvent;
+	if (!update || typeof update !== "object") return messageContentEvents(event.message, "end");
+	const value = update as {
+		type?: unknown;
+		contentIndex?: unknown;
+		delta?: unknown;
+		content?: unknown;
+		id?: unknown;
+		toolName?: unknown;
+		toolCall?: { id?: unknown; name?: unknown; arguments?: unknown };
+	};
+	const type = typeof value.type === "string" ? value.type : "";
+	const index = typeof value.contentIndex === "number" ? value.contentIndex : 0;
+	const key = `content:${index}`;
+	switch (type) {
+		case "text_start":
+			return [transcriptEvent("start", "assistant-text", key, "", "replace", true)];
+		case "text_delta":
+			return [transcriptEvent("update", "assistant-text", key, typeof value.delta === "string" ? value.delta : "", "append", true)];
+		case "text_end":
+			return [transcriptEvent("end", "assistant-text", key, typeof value.content === "string" ? value.content : "", "replace", false)];
+		case "thinking_start":
+			return [transcriptEvent("start", "thinking", key, "", "replace", true)];
+		case "thinking_delta":
+			return [transcriptEvent("update", "thinking", key, typeof value.delta === "string" ? value.delta : "", "append", true)];
+		case "thinking_end":
+			return [transcriptEvent("end", "thinking", key, typeof value.content === "string" ? value.content : "", "replace", false)];
+		case "toolcall_start":
+			return [transcriptEvent("start", "tool-call", key, "", "replace", true, {
+				toolCallId: typeof value.id === "string" ? value.id : undefined,
+				toolName: typeof value.toolName === "string" ? value.toolName : undefined,
+			})];
+		case "toolcall_delta":
+			return [transcriptEvent("update", "tool-call", key, typeof value.delta === "string" ? value.delta : "", "append", true, {
+				toolCallId: typeof value.id === "string" ? value.id : undefined,
+				toolName: typeof value.toolName === "string" ? value.toolName : undefined,
+			})];
+		case "toolcall_end":
+			return [transcriptEvent("end", "tool-call", key, formatValue(value.toolCall?.arguments), "replace", false, {
+				toolCallId: typeof value.toolCall?.id === "string" ? value.toolCall.id : typeof value.id === "string" ? value.id : undefined,
+				toolName: typeof value.toolCall?.name === "string" ? value.toolCall.name : typeof value.toolName === "string" ? value.toolName : undefined,
+			})];
+		default:
+			return [];
 	}
 }
 
@@ -130,45 +234,43 @@ function preview(value: unknown, maxLength = 240): string {
  * protocol consumed by the refinement overlay. Unknown events are ignored so
  * adding progress support cannot make result parsing version-fragile.
  */
-export function normalizeSubagentEvent(value: unknown): SubagentProgressEvent | undefined {
-	if (!value || typeof value !== "object") return undefined;
+export function normalizeSubagentEvent(value: unknown): SubagentProgressEvent[] {
+	if (!value || typeof value !== "object") return [];
 	const event = value as RawSubagentEvent;
-	if (typeof event.type !== "string") return undefined;
-
-	if (event.type === "turn_start") return { type: "turn", phase: "start" };
-	if (event.type === "turn_end") return { type: "turn", phase: "end" };
+	if (typeof event.type !== "string") return [];
 
-	if (event.type === "message_start" || event.type === "message_update" || event.type === "message_end") {
-		if (!event.message && !event.assistantMessageEvent) return undefined;
-		const role = event.message?.role ?? "assistant";
-		return {
-			type: "message",
-			phase: event.type.slice("message_".length) as "start" | "update" | "end",
-			role,
-			text: messageText(event.message) || messageEventText(event.assistantMessageEvent),
-		};
+	if (event.type === "turn_start") {
+		return [{ type: "turn", phase: "start", ...(typeof event.turnIndex === "number" ? { turnIndex: event.turnIndex } : {}) }];
+	}
+	if (event.type === "turn_end") {
+		return [{ type: "turn", phase: "end", ...(typeof event.turnIndex === "number" ? { turnIndex: event.turnIndex } : {}) }];
 	}
 
-	const toolEvent =
-		event.type === "tool_execution_start"
-			? "start"
-			: event.type === "tool_execution_update"
-				? "update"
-				: event.type === "tool_execution_end" || event.type === "tool_result_end"
-					? "end"
-					: null;
-	if (toolEvent) {
-		return {
-			type: "tool",
-			phase: toolEvent,
-			toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : "unknown",
-			toolName: typeof event.toolName === "string" ? event.toolName : "tool",
-			detail: preview(event.args ?? event.partialResult ?? event.result),
-			...(typeof event.isError === "boolean" ? { isError: event.isError } : {}),
-		};
+	if (event.type === "message_start") return messageContentEvents(event.message, "start");
+	if (event.type === "message_update") return assistantUpdateEvents(event);
+	if (event.type === "message_end") return messageContentEvents(event.message, "end");
+
+	if (event.type === "tool_execution_start") {
+		return [transcriptEvent("start", "tool-call", `tool:${String(event.toolCallId ?? "unknown")}`, formatValue(event.args), "replace", true, {
+			toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : undefined,
+			toolName: typeof event.toolName === "string" ? event.toolName : undefined,
+		})];
+	}
+	if (event.type === "tool_execution_update") {
+		return [transcriptEvent("update", "tool-result", `tool:${String(event.toolCallId ?? "unknown")}`, formatValue(event.partialResult), "replace", true, {
+			toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : undefined,
+			toolName: typeof event.toolName === "string" ? event.toolName : undefined,
+		})];
+	}
+	if (event.type === "tool_execution_end") {
+		return [transcriptEvent("end", "tool-result", `tool:${String(event.toolCallId ?? "unknown")}`, formatValue(event.result), "replace", false, {
+			toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : undefined,
+			toolName: typeof event.toolName === "string" ? event.toolName : undefined,
+			isError: typeof event.isError === "boolean" ? event.isError : undefined,
+		})];
 	}
 
-	return undefined;
+	return [];
 }
 
 function emitProgress(options: SubagentOptions, event: SubagentProgressEvent): void {
@@ -179,7 +281,7 @@ function emitProgress(options: SubagentOptions, event: SubagentProgressEvent): v
 	}
 }
 
-const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
 
 export async function runPiSubagent(options: SubagentOptions): Promise<SubagentResult> {
 	const tools = options.tools ?? ["read", "grep", "find", "ls"];
@@ -240,7 +342,7 @@ export async function runPiSubagent(options: SubagentOptions): Promise<SubagentR
 					return;
 				}
 				const progress = normalizeSubagentEvent(event);
-				if (progress) emitProgress(options, progress);
+				for (const progressEvent of progress) emitProgress(options, progressEvent);
 				if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
 					messages.push(event.message);
 				}

package/tests/ask-choice.test.ts

@@ -0,0 +1,263 @@
+/** Behavior tests for the ask_choice trailing option (post-execution
+ * amelioration prompt): Auto-refine loop replaces Auto-complete, the
+ * auto-answer mode is suppressed, and headless sessions stop instead of
+ * auto-answering. */
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, before, describe, it } from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { fitAskChoicePanel, OPTION_MAX_LINES, PANEL_CHROME_LINES, PANEL_SAFETY_MARGIN, SELECTOR_WIDTH_OVERHEAD, STATUS_BAR_HEIGHT, registerAskChoiceTool } from "../tools/ask-choice.ts";
+import { visibleWidth } from "../src/refine-ui-helpers.ts";
+
+type ToolDef = {
+	execute: (id: string, params: any, signal: undefined, update: undefined, ctx: any) => Promise<any>;
+};
+
+let root: string;
+
+before(() => {
+	root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-ask-choice-"));
+});
+
+after(() => {
+	fs.rmSync(root, { recursive: true, force: true });
+});
+
+function loadTool(): ToolDef {
+	let tool: ToolDef | undefined;
+	const pi = {
+		registerTool: (definition: ToolDef) => {
+			tool = definition;
+		},
+	} as unknown as ExtensionAPI;
+	registerAskChoiceTool(pi);
+	if (!tool) throw new Error("ask_choice tool not registered");
+	return tool;
+}
+
+let notifyCalls: Array<{ message: string; severity?: string }> = [];
+
+function makeCtx(opts: {
+	hasUI?: boolean;
+	select: (question: string, labels: string[]) => Promise<string | undefined>;
+}) {
+	notifyCalls = [];
+	return {
+		cwd: root,
+		hasUI: opts.hasUI ?? true,
+		sessionManager: {},
+		ui: {
+			select: opts.select,
+			input: async () => "typed",
+			notify: (message: string, severity?: string) => {
+				notifyCalls.push({ message, severity });
+			},
+		},
+	};
+}
+
+const OPTIONS = [
+	{ label: "Run one Reviewer round", recommended: true },
+	{ label: "Run a Criticizer round" },
+	{ label: "Finish here" },
+];
+
+describe("ask_choice trailing option", () => {
+	it("renders Auto-refine loop as the trailing option and suppresses Auto-complete", async () => {
+		const tool = loadTool();
+		let seenLabels: string[] = [];
+		const ctx = makeCtx({
+			select: async (_question, labels) => {
+				seenLabels = labels;
+				return labels.find((label) => label.startsWith("Auto-refine loop"));
+			},
+		});
+		const result = await tool.execute("t1", {
+			question: "Ameliorate?",
+			options: OPTIONS,
+			autoComplete: true, // deliberately erroneous: trailing must suppress it
+			trailing: "auto-refine-loop",
+		}, undefined, undefined, ctx);
+
+		assert.equal(seenLabels.at(-1)?.startsWith("Auto-refine loop"), true, "Auto-refine loop must be last");
+		assert.equal(seenLabels.some((label) => label.startsWith("Auto-complete")), false, "Auto-complete must be absent");
+		const text = result.content[0].text as string;
+		assert.match(text, /User selected Auto-refine loop/);
+		assert.match(text, /until no high-severity finding \(hard cap 5 rounds\)/);
+		assert.match(text, /refine \(role: "reviewer", target: "implementation"\)/);
+		assert.equal(result.details.source, "user");
+		assert.equal(result.details.answer, "Auto-refine loop");
+	});
+
+	it("keeps Auto-complete as the trailing option without the trailing param", async () => {
+		const tool = loadTool();
+		let seenLabels: string[] = [];
+		const ctx = makeCtx({
+			select: async (_question, labels) => {
+				seenLabels = labels;
+				return labels[0];
+			},
+		});
+		await tool.execute("t2", {
+			question: "Planning question?",
+			options: OPTIONS,
+			autoComplete: true,
+		}, undefined, undefined, ctx);
+		assert.equal(seenLabels.at(-1)?.startsWith("Auto-complete"), true);
+		assert.equal(seenLabels.some((label) => label.startsWith("Auto-refine loop")), false);
+	});
+
+	it("never auto-answers a trailing question in headless sessions", async () => {
+		const tool = loadTool();
+		const ctx = makeCtx({ hasUI: false, select: async () => undefined });
+		await assert.rejects(
+			tool.execute("t3", {
+				question: "Ameliorate?",
+				options: OPTIONS,
+				autoComplete: true,
+				trailing: "auto-refine-loop",
+			}, undefined, undefined, ctx),
+			/No UI available/,
+		);
+	});
+});
+
+describe("ask_choice panel fitting", () => {
+	it("sanitizes newlines in the question and labels", () => {
+		const fitted = fitAskChoicePanel("Q line1\nQ line2", [{ core: "1. a\nb", display: "1. a\nb — desc" }], 100, 30);
+		assert.doesNotMatch(fitted.question, /\r?\n/);
+		for (const label of fitted.labels) assert.doesNotMatch(label, /\r?\n/);
+	});
+
+	it("caps each label at the 3-line budget with a .. marker (CJK included)", () => {
+		const columns = 100;
+		const budget = OPTION_MAX_LINES * Math.max(20, columns - SELECTOR_WIDTH_OVERHEAD);
+		const cjkLabel = `1. ${"选项".repeat(200)}`; // 800 visible columns, far over the budget
+		const fitted = fitAskChoicePanel("q", [{ core: cjkLabel, display: cjkLabel }], columns, 60);
+		assert.equal(fitted.labels.length, 1);
+		assert.ok(visibleWidth(fitted.labels[0]) <= budget, `label exceeds 3-line budget: ${visibleWidth(fitted.labels[0])}`);
+		assert.match(fitted.labels[0], /\.\.$/);
+	});
+
+	it("degrades: stage 1 strips descriptions before touching labels", () => {
+		const columns = 100;
+		const rows = 30; // rowBudget = 27 → content budget 17 lines after chrome
+		const items = Array.from({ length: 12 }, (_, i) => ({
+			core: `${i + 1}. option-${i}`,
+			display: `${i + 1}. option-${i} — ${"detail ".repeat(40)}`,
+		}));
+		const fitted = fitAskChoicePanel("q", items, columns, rows);
+		for (const label of fitted.labels) assert.doesNotMatch(label, /detail/);
+		assert.match(fitted.labels[0] ?? "", /^1\. option-0/);
+	});
+
+	it("degrades: stage 2 collapses labels to one line before truncating the question", () => {
+		const columns = 100;
+		const rows = 30;
+		const items = Array.from({ length: 15 }, (_, i) => ({
+			core: `${i + 1}. ${"x".repeat(170)}`,
+			display: `${i + 1}. ${"x".repeat(170)} — description`,
+		}));
+		const fitted = fitAskChoicePanel("the question", items, columns, rows);
+		for (const label of fitted.labels) assert.ok(visibleWidth(label) <= Math.max(20, columns - SELECTOR_WIDTH_OVERHEAD));
+		assert.equal(fitted.question, "the question"); // question untouched at stage 2
+	});
+
+	it("warns once when even the minimal form exceeds a tiny terminal", () => {
+		const columns = 60;
+		const rows = 12; // rowBudget = 9; 30 options can never fit
+		const items = Array.from({ length: 30 }, (_, i) => ({ core: `${i + 1}. opt-${i}`, display: `${i + 1}. opt-${i}` }));
+		const fitted = fitAskChoicePanel("q", items, columns, rows);
+		assert.equal(fitted.overflowWarned, true);
+		for (const label of fitted.labels) assert.ok(visibleWidth(label) <= 20);
+	});
+
+	it("degrades: stage 3 truncates the question only after labels are single-lined", () => {
+		const columns = 100;
+		const rows = 32; // rowBudget = 29; chrome 9 → content budget 20 lines
+		const longQuestion = "q".repeat(300);
+		const items = Array.from({ length: 18 }, (_, i) => ({ core: `${i + 1}. opt-${i}`, display: `${i + 1}. opt-${i}` }));
+		const fitted = fitAskChoicePanel(longQuestion, items, columns, rows);
+		assert.equal(fitted.overflowWarned, false); // stops at stage 3, not the minimal form
+		assert.ok(visibleWidth(fitted.question) <= Math.max(20, columns - SELECTOR_WIDTH_OVERHEAD));
+		assert.match(fitted.question, /\.\.$/);
+		assert.match(fitted.labels[0] ?? "", /^1\. opt-0$/); // labels stay single-line and untruncated
+	});
+
+	it("keeps Other/Auto-complete/Auto-refine prefixes alive even on tiny terminals", () => {
+		const columns = 26;
+		const rows = 12; // minimal form: 20-column floor
+		const items = [
+			{ core: "1. keep-current", display: "1. keep-current" },
+			{ core: "Other…  (type your own answer)", display: "Other…  (type your own answer)", fixed: true },
+			{ core: "Auto-complete  (take the recommended option)", display: "Auto-complete  (take the recommended option)", fixed: true },
+			{ core: "Auto-refine loop  (run refinement rounds until no high-severity finding or the 5-round cap)", display: "Auto-refine loop  (run refinement rounds until no high-severity finding or the 5-round cap)", fixed: true },
+		];
+		const fitted = fitAskChoicePanel("q", items, columns, rows);
+		assert.match(fitted.labels[1] ?? "", /^Other…/);
+		assert.match(fitted.labels[2] ?? "", /^Auto-complete/);
+		assert.match(fitted.labels[3] ?? "", /^Auto-refine loop/);
+	});
+
+	it("execute notifies once when the minimal form still overflows a tiny terminal", async () => {
+		const tool = loadTool();
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-ask-choice-overflow-"));
+		const rowsDesc = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+		const colsDesc = Object.getOwnPropertyDescriptor(process.stdout, "columns");
+		Object.defineProperty(process.stdout, "rows", { value: 12, configurable: true });
+		Object.defineProperty(process.stdout, "columns", { value: 60, configurable: true });
+		try {
+			const ctx = makeCtx({
+				select: async (_question, labels) => labels[0],
+			});
+			// makeCtx binds cwd at construction; point it at the temp dir via workdir param instead.
+			await tool.execute(
+				"id",
+				{
+					question: "Pick one",
+					options: Array.from({ length: 30 }, (_, i) => ({ label: `opt-${i}`, description: `${"detail ".repeat(20)}` })),
+					autoComplete: false,
+					allowOther: false,
+					workdir: dir,
+				},
+				undefined,
+				undefined,
+				ctx,
+			);
+			assert.equal(notifyCalls.length, 1);
+			assert.match(notifyCalls[0]!.message, /Terminal too small/);
+		} finally {
+			if (rowsDesc) Object.defineProperty(process.stdout, "rows", rowsDesc);
+			if (colsDesc) Object.defineProperty(process.stdout, "columns", colsDesc);
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("pi-tui Text renders every fitted label within 3 lines at real panel width", async () => {
+		let Text: any;
+		try {
+			({ Text } = await import("@earendil-works/pi-tui"));
+		} catch {
+			return; // D-007 sanctioned fallback: pi-tui not resolvable in this layout
+		}
+		const columns = 100;
+		const rows = 60;
+		const realWidth = columns - 4; // border + padding + marker, per extension-selector.js
+		const items = Array.from({ length: 8 }, (_, i) => ({
+			core: `${i + 1}. option-${i}`,
+			display: `${i + 1}. option-${i} — ${"中文描述 " .repeat(30)}mixed ascii tail ${"x".repeat(60)}`,
+		}));
+		const fitted = fitAskChoicePanel("q", items, columns, rows);
+		let totalLines = PANEL_CHROME_LINES + 1; // chrome + question line
+		for (const label of fitted.labels) {
+			const component = new Text(label, 1, 0);
+			const rendered = component.render(realWidth);
+			assert.ok(rendered.length <= OPTION_MAX_LINES, `label renders ${rendered.length} lines: ${JSON.stringify(label.slice(0, 60))}`);
+			totalLines += rendered.length;
+		}
+		assert.ok(totalLines < rows - STATUS_BAR_HEIGHT - PANEL_SAFETY_MARGIN);
+	});
+});

package/tests/autocomplete.test.ts

@@ -132,11 +132,16 @@ describe("ask_choice Auto-complete wiring", () => {
 		assert.match(source, /isAutoCompleteEnabled/);
 		assert.match(source, /recordAskChoice\(ctx, true\)/);
 		assert.match(source, /autoComplete && selected\.startsWith\("Auto-complete"\)/);
+		// Trailing option: Auto-refine loop replaces Auto-complete and is suppressed in headless sessions.
+		assert.match(source, /trailing === undefined/);
+		assert.match(source, /AUTO_REFINE_LOOP_LABEL/);
+		assert.match(source, /trailing && selected\.startsWith\("Auto-refine loop"\)/);
 		const indexSource = fs.readFileSync(path.join(process.cwd(), "index.ts"), "utf8");
 		assert.match(indexSource, /plans-autocomplete-stop/);
 		assert.match(indexSource, /autoCompleteStatus\(ctx\)/);
 		assert.match(indexSource, /restoreAutoCompleteFromSession/);
 		const execSource = fs.readFileSync(path.join(process.cwd(), "src", "exec.ts"), "utf8");
-		assert.match(execSource, /customType === AUTOCOMPLETE_ENTRY/);
+		assert.doesNotMatch(execSource, /customType === AUTOCOMPLETE_ENTRY/);
+		assert.match(execSource, /shouldTriggerPlanningCompaction\(_ctx: ExtensionContext\): boolean \{\n\s+return false;/);
 	});
 });