@oh-my-pi/pi-coding-agent 16.2.12 → 16.3.0

package/src/task/index.ts

@@ -60,7 +60,7 @@ import {
 } from "./isolation-runner";
 import { generateTaskName } from "./name-generator";
 import { AgentOutputManager } from "./output-manager";
-import { mapWithConcurrencyLimit, Semaphore } from "./parallel";
+import { mapWithConcurrencyLimit, normalizeConcurrencyLimit, Semaphore } from "./parallel";
 import { renderResult, renderCall as renderTaskCall } from "./render";
 import { repairTaskParams } from "./repair-args";
 import { parseIsolationMode } from "./worktree";
@@ -208,7 +208,7 @@ function renderDescription(
 		defaultAgent: spawnPolicy.defaultAgent,
 		defaultAgentIsGeneric: spawnPolicy.defaultAgent === DEFAULT_SPAWN_AGENT,
 		allowedAgentsText: spawnPolicy.allowedPromptText,
-		MAX_CONCURRENCY: maxConcurrency,
+		MAX_CONCURRENCY: normalizeConcurrencyLimit(maxConcurrency),
 		isolationEnabled,
 		batchEnabled,
 		asyncEnabled,
@@ -501,8 +501,10 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	readonly #blockedAgent: string | undefined;
 	/**
 	 * One semaphore per TaskTool instance (i.e. per session): bounds concurrent
-	 * subagents across parallel `task` calls within the session. Sized from
-	 * `task.maxConcurrency` at first use; later setting changes do not resize it.
+	 * subagents across parallel `task` calls within the session. Resized in
+	 * place from `task.maxConcurrency` before every acquire/release so a
+	 * mid-session settings change (UI toggle, `/settings`) applies to both new
+	 * spawns and work already parked in the semaphore queue.
 	 */
 	#spawnSemaphore: Semaphore | undefined;
 
@@ -545,10 +547,19 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	}
 
 	#getSpawnSemaphore(): Semaphore {
-		this.#spawnSemaphore ??= new Semaphore(this.session.settings.get("task.maxConcurrency"));
+		const max = this.session.settings.get("task.maxConcurrency");
+		if (this.#spawnSemaphore) {
+			this.#spawnSemaphore.resize(max);
+		} else {
+			this.#spawnSemaphore = new Semaphore(max);
+		}
 		return this.#spawnSemaphore;
 	}
 
+	#releaseSpawnSemaphore(): void {
+		this.#getSpawnSemaphore().release();
+	}
+
 	/**
 	 * Create a TaskTool instance with async agent discovery.
 	 */
@@ -803,6 +814,17 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				const startedAt = Date.now();
 				const semaphore = this.#getSpawnSemaphore();
 				let semaphoreHeld = false;
+				// Every release funnels through here: the flag flips before the
+				// release so no path — acquire-time abort, executor failure, or a
+				// future refactor that reorders the branches — can return a permit
+				// twice. Releasing a permit this job never acquired would steal one
+				// from a running job and let a later spawn start past
+				// task.maxConcurrency.
+				const releasePermit = () => {
+					if (!semaphoreHeld) return;
+					semaphoreHeld = false;
+					this.#releaseSpawnSemaphore();
+				};
 				try {
 					await semaphore.acquire(runSignal);
 					semaphoreHeld = true;
@@ -814,7 +836,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				}
 				const acquiredAt = Date.now();
 				if (!semaphoreHeld || runSignal.aborted) {
-					if (semaphoreHeld) semaphore.release();
+					releasePermit();
 					progress.status = "aborted";
 					onSettled?.(true);
 					throw new Error("Aborted before execution");
@@ -886,7 +908,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 					const hint = AgentRegistry.global().get(agentId) ? buildFollowUpHint(false) : "";
 					throw new TaskJobError(`${message}${hint}`);
 				} finally {
-					semaphore.release();
+					releasePermit();
 				}
 			},
 			{
@@ -931,7 +953,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 					{ invokedAt, acquiredAt },
 				);
 			} finally {
-				semaphore.release();
+				this.#releaseSpawnSemaphore();
 			}
 		}
 
@@ -979,7 +1001,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						{ invokedAt, acquiredAt },
 					);
 				} finally {
-					semaphore.release();
+					this.#releaseSpawnSemaphore();
 				}
 			},
 			signal,

package/src/task/isolation-runner.ts

@@ -291,15 +291,31 @@ export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise
 				hadAnyChanges = false;
 			} else {
 				const normalized = patchText.endsWith("\n") ? patchText : `${patchText}\n`;
-				changesApplied = await git.patch.canApplyText(repoRoot, normalized);
+				// Idempotence: declare a no-op only when the reverse patch applies AND
+				// the forward patch does not. `--reverse --check` alone can theoretically
+				// succeed if the file happens to carry the postimage at another location
+				// via git-apply's fuzz factor; requiring the forward check to fail
+				// removes that ambiguity while still catching true already-applied
+				// runs. Reads only — neither call touches the worktree, unlike
+				// `--3way --check`, which exits 0 even when the real apply would
+				// leave conflict markers and unmerged index entries.
+				const [alreadyApplied, forwardApplies] = await Promise.all([
+					git.patch.canApplyText(repoRoot, normalized, { reverse: true }),
+					git.patch.canApplyText(repoRoot, normalized),
+				]);
 				hadAnyChanges = false;
-				if (changesApplied) {
+				if (alreadyApplied && !forwardApplies) {
+					changesApplied = true;
+				} else if (forwardApplies) {
+					changesApplied = true;
 					try {
 						await git.patch.applyText(repoRoot, normalized);
 						hadAnyChanges = true;
 					} catch {
 						changesApplied = false;
 					}
+				} else {
+					changesApplied = false;
 				}
 			}
 		}

package/src/task/parallel.ts

@@ -90,13 +90,18 @@ export async function mapWithConcurrencyLimit<T, R>(
  * immediately — matching `task.maxConcurrency = 0`'s "Unlimited" semantics in the
  * settings UI ([#3305](https://github.com/can1357/oh-my-pi/issues/3305)).
  */
+export function normalizeConcurrencyLimit(max: number): number {
+	const normalizedMax = Number.isFinite(max) ? Math.trunc(max) : 0;
+	return normalizedMax > 0 ? normalizedMax : 0;
+}
+
 export class Semaphore {
 	#max: number;
 	#current = 0;
 	#queue: Array<() => void> = [];
 
 	constructor(max: number) {
-		const normalizedMax = Number.isFinite(max) ? Math.trunc(max) : 0;
+		const normalizedMax = normalizeConcurrencyLimit(max);
 		this.#max = normalizedMax > 0 ? normalizedMax : Number.POSITIVE_INFINITY;
 	}
 
@@ -155,7 +160,7 @@ export class Semaphore {
 	 * never push concurrency past the cap (issue #3464 review feedback).
 	 */
 	resize(max: number): void {
-		const normalizedMax = Number.isFinite(max) ? Math.trunc(max) : 0;
+		const normalizedMax = normalizeConcurrencyLimit(max);
 		this.#max = normalizedMax > 0 ? normalizedMax : Number.POSITIVE_INFINITY;
 		while (this.#current < this.#max) {
 			const next = this.#queue.shift();

package/src/task/render.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, beforeAll, describe, expect, it } from "bun:test";
+import { Settings } from "../config/settings";
+import { getThemeByName, setThemeInstance, type Theme } from "../modes/theme/theme";
+import { renderResult } from "./render";
+import type { AgentProgress, TaskToolDetails } from "./types";
+
+const strip = (lines: readonly string[]): string =>
+	lines
+		.join("\n")
+		.replace(/\x1b\]8;[^\x1b\x07]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b\[[0-9;]*m/g, "");
+
+const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+
+function setViewportRows(rows: number): void {
+	Object.defineProperty(process.stdout, "rows", { configurable: true, value: rows });
+}
+
+function restoreViewportRows(): void {
+	if (originalRowsDescriptor) {
+		Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+		return;
+	}
+	Reflect.deleteProperty(process.stdout, "rows");
+}
+
+function makeProgress(recentOutput: string[]): AgentProgress {
+	return {
+		index: 0,
+		id: "NoisySubagent",
+		agent: "task",
+		agentSource: "bundled",
+		status: "running",
+		task: "produce noisy output",
+		recentTools: [],
+		recentOutput,
+		toolCount: 1,
+		requests: 1,
+		tokens: 0,
+		cost: 0,
+		durationMs: 0,
+	};
+}
+
+function renderProgressText(progress: AgentProgress, expanded: boolean, uiTheme: Theme): string {
+	const details: TaskToolDetails = {
+		projectAgentsDir: null,
+		results: [],
+		totalDurationMs: 1,
+		progress: [progress],
+	};
+	const component = renderResult(
+		{ content: [{ type: "text", text: "Running 1 agent..." }], details },
+		{ expanded, isPartial: true },
+		uiTheme,
+	);
+	return strip(component.render(120));
+}
+
+describe("task live progress rendering", () => {
+	let uiTheme: Theme;
+
+	beforeAll(async () => {
+		await Settings.init({ inMemory: true });
+		const loaded = await getThemeByName("dark");
+		if (!loaded) throw new Error("theme unavailable");
+		uiTheme = loaded;
+		setThemeInstance(uiTheme);
+	});
+
+	afterEach(() => {
+		restoreViewportRows();
+	});
+
+	it("caps subagent recent output with the viewport budget instead of a fixed six lines", () => {
+		setViewportRows(40);
+		const chronological = Array.from({ length: 8 }, (_, index) => `line ${index + 1}`);
+		const text = renderProgressText(makeProgress([...chronological].reverse()), true, uiTheme);
+
+		expect(text).toContain("line 1");
+		expect(text).toContain("line 8");
+		expect(text).not.toContain("more lines");
+	});
+
+	it("keeps the newest subagent output when the viewport cap truncates", () => {
+		setViewportRows(24);
+		const chronological = Array.from({ length: 8 }, (_, index) => `line ${index + 1}`);
+		const text = renderProgressText(makeProgress([...chronological].reverse()), true, uiTheme);
+
+		expect(text).toContain("… 3 earlier lines");
+		expect(text).not.toContain("line 1");
+		expect(text).not.toContain("line 3");
+		expect(text).toContain("line 4");
+		expect(text).toContain("line 8");
+	});
+
+	it("strips bash footer notices from expanded subagent recent output", () => {
+		setViewportRows(40);
+		const chronological = [
+			"line 1",
+			"line 2",
+			"line 3",
+			"line 4",
+			"line 5",
+			"line 6",
+			"Wall time: 0.03 seconds",
+			"[raw output: artifact://123]",
+		];
+		const progress = makeProgress([...chronological].reverse());
+
+		const expandedText = renderProgressText(progress, true, uiTheme);
+		expect(expandedText).toContain("line 1");
+		expect(expandedText).toContain("line 6");
+		expect(expandedText).not.toContain("Wall time:");
+		expect(expandedText).not.toContain("raw output:");
+
+		const collapsedText = renderProgressText(progress, false, uiTheme);
+		expect(collapsedText).not.toContain("line 1");
+		expect(collapsedText).not.toContain("raw output:");
+	});
+});

package/src/task/render.ts

@@ -12,13 +12,16 @@ import { settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { formatContextUsage } from "../modes/components/status-line/context-thresholds";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
+import { stripGeneratedOutputNotice, stripRawOutputArtifactNotice } from "../tools/output-meta";
 import {
+	capPreviewLines,
 	formatBadge,
 	formatDuration,
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
 	previewLine,
+	previewWindowRows,
 	replaceTabs,
 	type ToolUIStatus,
 	truncateToWidth,
@@ -450,6 +453,41 @@ function renderJsonTreeLines(
 	return { lines, truncated };
 }
 
+const BASH_WALL_TIME_NOTICE_RE = /^Wall time: \d+(?:\.\d+)? seconds$/u;
+const BASH_EXIT_CODE_NOTICE_RE = /^Command exited with code -?\d+$/u;
+
+function stripRecentOutputNoticeLine(text: string): string {
+	const trimmed = text.trimEnd();
+	const lineStart = trimmed.lastIndexOf("\n");
+	const candidateStart = lineStart === -1 ? 0 : lineStart + 1;
+	const line = trimmed.slice(candidateStart);
+	if (!BASH_WALL_TIME_NOTICE_RE.test(line) && !BASH_EXIT_CODE_NOTICE_RE.test(line)) return text;
+	return trimmed.slice(0, lineStart === -1 ? 0 : lineStart).trimEnd();
+}
+
+function sanitizeRecentOutput(output: string): string {
+	let text = output.trimEnd();
+	while (text) {
+		const withoutArtifactNotice = stripRawOutputArtifactNotice(text).text;
+		if (withoutArtifactNotice !== text) {
+			text = withoutArtifactNotice;
+			continue;
+		}
+		const withoutOutputNotice = stripGeneratedOutputNotice(text);
+		if (withoutOutputNotice !== text) {
+			text = withoutOutputNotice;
+			continue;
+		}
+		const withoutRuntimeNotice = stripRecentOutputNoticeLine(text);
+		if (withoutRuntimeNotice !== text) {
+			text = withoutRuntimeNotice;
+			continue;
+		}
+		break;
+	}
+	return text;
+}
+
 function renderOutputSection(
 	output: string,
 	continuePrefix: string,
@@ -1016,8 +1054,16 @@ function renderAgentProgress(
 
 	// Expanded view: recent output and tools
 	if (expanded && progress.status === "running") {
-		const output = progress.recentOutput.join("\n");
-		lines.push(...renderOutputSection(output, continuePrefix, true, theme, 2, 6));
+		const previewRows = previewWindowRows();
+		const output = capPreviewLines(
+			sanitizeRecentOutput([...progress.recentOutput].reverse().join("\n")).split("\n"),
+			theme,
+			{
+				max: previewRows,
+				expandHint: false,
+			},
+		).join("\n");
+		lines.push(...renderOutputSection(output, continuePrefix, expanded, theme, 2, previewRows));
 	}
 
 	return lines;

package/src/task/worktree.ts

@@ -305,16 +305,13 @@ export async function applyNestedPatches(
 			}
 		} finally {
 			if (stashed) {
-				try {
-					await git.stash.pop(nestedDir, { index: true });
-				} catch (popErr) {
-					const message = popErr instanceof Error ? popErr.message : String(popErr);
+				const restored = await git.stash.tryPop(nestedDir, { index: true });
+				if (!restored) {
 					logger.warn("Pre-existing nested-repo dirty state could not be auto-restored", {
 						nestedDir,
-						error: message,
 					});
 					warnings.push(
-						`Pre-existing dirty state in nested repo \`${relativePath}\` could not be auto-restored after the agent commit; stash entry preserved (${message}).`,
+						`Pre-existing dirty state in nested repo \`${relativePath}\` could not be auto-restored after the agent commit; stash entry preserved.`,
 					);
 				}
 			}
@@ -755,13 +752,15 @@ export async function mergeTaskBranches(
 			}
 		} finally {
 			if (didStash) {
-				try {
-					await git.stash.pop(repoRoot, { index: true });
-				} catch {
-					// Stash-pop conflicts mean the replayed changes clash with the user's
-					// uncommitted edits. The cherry-picked commits are already on HEAD, so
-					// the merged branches DID land — report them as merged and surface the
-					// stash conflict separately instead of claiming they are unmerged.
+				const restored = await git.stash.tryPop(repoRoot, { index: true });
+				if (!restored) {
+					// Stash pop would leave stage 1/2/3 unmerged entries in `.git/index`
+					// that overlay-isolated subsequent tasks inherit through the lower
+					// layer, corrupting every downstream `captureRepoDeltaPatch`. `tryPop`
+					// short-circuits the pop when the WIP would conflict with the
+					// cherry-picked HEAD (and reset-cleans up if a rarer conflict slips
+					// past). The merged branches DID land — surface a stash-restore
+					// warning without claiming the merge failed.
 					logger.warn("Failed to restore stashed changes after task merge; stash entry preserved");
 					const stashConflict =
 						"stash pop: cherry-picked changes conflict with uncommitted edits. The merged commits are on HEAD; run `git stash pop` and resolve manually.";

package/src/task/yield-assembly.ts

@@ -8,6 +8,8 @@
  * `session-manager`, the TUI tool renderers). It has no side effects and
  * depends only on the yield type and the output-schema validator.
  */
+import { dereferenceJsonSchema } from "@oh-my-pi/pi-ai/utils/schema";
+import { isRecord } from "@oh-my-pi/pi-utils";
 import { buildOutputValidator } from "../tools/output-schema-validator";
 import type { YieldItem } from "./types";
 
@@ -105,11 +107,12 @@ export function arrayValuedLabels(outputSchema: unknown): ReadonlySet<string> {
 	// with `type: "array"`, which raw `normalizeSchema` would not expose.
 	const { jsonSchema } = buildOutputValidator(outputSchema);
 	if (jsonSchema === undefined) return labels;
-	const properties = jsonSchema.properties;
-	if (properties === null || typeof properties !== "object") return labels;
-	const propRecord = properties as Record<string, unknown>;
-	for (const key in propRecord) {
-		if (isArrayTypedSchema(propRecord[key])) labels.add(key);
+	const dereferenced = dereferenceJsonSchema(jsonSchema);
+	const labelSchema = isRecord(dereferenced) ? dereferenced : jsonSchema;
+	const properties = labelSchema.properties;
+	if (!isRecord(properties)) return labels;
+	for (const key in properties) {
+		if (isArrayTypedSchema(properties[key])) labels.add(key);
 	}
 	return labels;
 }

package/src/thinking.ts

@@ -124,6 +124,11 @@ export const AUTO_THINKING = "auto" as const;
 /** A thinking selector as configured by the user — a concrete level or `auto`. */
 export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
 
+/** Maps the session-level `auto` sentinel to `undefined`; concrete levels pass through. */
+export function concreteThinkingLevel(level: ConfiguredThinkingLevel | undefined): ThinkingLevel | undefined {
+	return level === AUTO_THINKING ? undefined : level;
+}
+
 /** Metadata used to render the `auto` selector value alongside concrete levels. */
 export interface ConfiguredThinkingLevelMetadata {
 	value: ConfiguredThinkingLevel;

package/src/tools/ask.ts

@@ -17,7 +17,17 @@
 
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
-import { type Component, Markdown, type MarkdownTheme, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
+import {
+	type Component,
+	Ellipsis,
+	Markdown,
+	type MarkdownTheme,
+	renderInlineMarkdown,
+	TERMINAL,
+	Text,
+	truncateToWidth,
+	visibleWidth,
+} from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type as arkType } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -142,19 +152,146 @@ interface CustomInputContext {
 	markableCount: number;
 }
 
+/** Hard caps for the editor title rendered while the user types an `Other`
+ *  custom answer. {@link HookEditorComponent} renders the title via a single
+ *  `Text` child stacked above the prompt editor with no `maxVisible` windowing,
+ *  so the title MUST fit a normal terminal:
+ *  - {@link MAX_CUSTOM_INPUT_OPTION_ROWS}: at most this many option-row entries
+ *    survive {@link pickCustomInputOptionWindow}, regardless of total options.
+ *  - {@link MAX_CUSTOM_INPUT_TITLE_ROWS}: hard cap on rendered title rows after
+ *    every line is pre-truncated to one row at the live terminal width. Sized
+ *    so a 24-row terminal still has space for the input row, hint, and chrome.
+ */
+const MAX_CUSTOM_INPUT_OPTION_ROWS = 8;
+const MAX_CUSTOM_INPUT_TITLE_ROWS = 16;
+const MIN_CUSTOM_INPUT_CONTENT_WIDTH = 20;
+/** Subtracted from the terminal width to leave room for the surrounding
+ *  `Text(... padX=1)` padding + DynamicBorder vertical chrome. */
+const CUSTOM_INPUT_CHROME_COLUMNS = 4;
+const CUSTOM_INPUT_DESCRIPTION_INDENT = "    ";
+
+function customInputContentWidth(): number {
+	const cols = process.stdout.columns ?? 80;
+	return Math.max(MIN_CUSTOM_INPUT_CONTENT_WIDTH, cols - CUSTOM_INPUT_CHROME_COLUMNS);
+}
+
+function clampLineToWidth(line: string, width: number): string {
+	if (visibleWidth(line) <= width) return line;
+	return truncateToWidth(line, width, Ellipsis.Unicode);
+}
+
+function flattenDescription(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
 function getSelectOptionDescription(option: ExtensionUISelectItem): string | undefined {
 	return typeof option === "string" ? undefined : option.description;
 }
 
-function formatCustomInputTitle(
+interface CustomInputOptionGap {
+	total: number;
+	checked: number;
+}
+
+interface CustomInputOptionWindow {
+	indices: number[];
+	gapBefore: Map<number, CustomInputOptionGap>;
+}
+
+/** Window the option list so the title stays bounded. Required rows are the
+ *  selected `Other` row and the first option as an anchor; checked rows fill
+ *  the remaining budget before unselected leading rows. Hidden checked options
+ *  are summarized in gap markers so the rendered option-row count still never
+ *  exceeds {@link MAX_CUSTOM_INPUT_OPTION_ROWS}. */
+function pickCustomInputOptionWindow(
+	total: number,
+	selectedIndex: number,
+	checked: ReadonlySet<number>,
+): CustomInputOptionWindow {
+	if (total === 0) return { indices: [], gapBefore: new Map() };
+	if (total <= MAX_CUSTOM_INPUT_OPTION_ROWS) {
+		return {
+			indices: Array.from({ length: total }, (_, i) => i),
+			gapBefore: new Map(),
+		};
+	}
+	const keep = new Set<number>();
+	const addIfRoom = (index: number) => {
+		if (index >= 0 && index < total && keep.size < MAX_CUSTOM_INPUT_OPTION_ROWS) {
+			keep.add(index);
+		}
+	};
+	addIfRoom(selectedIndex);
+	addIfRoom(0);
+	for (const i of [...checked].sort((a, b) => a - b)) {
+		addIfRoom(i);
+	}
+	for (let i = 0; i < total && keep.size < MAX_CUSTOM_INPUT_OPTION_ROWS; i++) {
+		addIfRoom(i);
+	}
+	const indices = [...keep].sort((a, b) => a - b);
+	const gapBefore = new Map<number, CustomInputOptionGap>();
+	const countCheckedBetween = (startInclusive: number, endExclusive: number): number => {
+		let count = 0;
+		for (const i of checked) {
+			if (i >= startInclusive && i < endExclusive) count++;
+		}
+		return count;
+	};
+	let prev = -1;
+	for (const idx of indices) {
+		if (idx > prev + 1) {
+			gapBefore.set(idx, {
+				total: idx - prev - 1,
+				checked: countCheckedBetween(prev + 1, idx),
+			});
+		}
+		prev = idx;
+	}
+	if (prev < total - 1) {
+		gapBefore.set(total, {
+			total: total - 1 - prev,
+			checked: countCheckedBetween(prev + 1, total),
+		});
+	}
+	return { indices, gapBefore };
+}
+
+interface CustomInputRow {
+	text: string;
+	/** Lower priority drops first when over budget; negative values are pinned.
+	 *  Gap markers are budgeted rows too so sparse checked selections cannot
+	 *  push the editor input off-screen. */
+	priority: number;
+}
+
+function buildCustomInputRows(
 	question: string,
 	options: ExtensionUISelectItem[],
 	context: CustomInputContext,
-): string {
+	contentWidth: number,
+): CustomInputRow[] {
 	const selectedIndex = options.findIndex(option => getSelectOptionLabel(option) === OTHER_OPTION);
-	const lines = [question, ""];
 	const checked = new Set(context.checkedIndices ?? []);
-	for (let index = 0; index < options.length; index++) {
+	const window = pickCustomInputOptionWindow(options.length, selectedIndex, checked);
+	const rows: CustomInputRow[] = [];
+	rows.push({ text: clampLineToWidth(question, contentWidth), priority: -1 });
+	rows.push({ text: "", priority: -1 });
+
+	const emitGap = (gap: CustomInputOptionGap) => {
+		const checkedSuffix = gap.checked > 0 ? `, ${gap.checked} checked` : "";
+		rows.push({
+			text: clampLineToWidth(
+				`    … ${gap.total} more option${gap.total === 1 ? "" : "s"}${checkedSuffix} …`,
+				contentWidth,
+			),
+			priority: 2,
+		});
+	};
+
+	for (const index of window.indices) {
+		const gap = window.gapBefore.get(index);
+		if (gap !== undefined) emitGap(gap);
 		const option = options[index]!;
 		const label = getSelectOptionLabel(option);
 		const isSelected = index === selectedIndex;
@@ -167,12 +304,54 @@ function formatCustomInputTitle(
 					: isSelected
 						? `${theme.nav.cursor} `
 						: "  ";
-		lines.push(prefix + label);
+		rows.push({ text: clampLineToWidth(prefix + label, contentWidth), priority: -1 });
 		const description = getSelectOptionDescription(option);
-		if (description) lines.push(`    ${description}`);
+		if (description) {
+			const flat = flattenDescription(description);
+			if (flat) {
+				rows.push({
+					text: clampLineToWidth(`${CUSTOM_INPUT_DESCRIPTION_INDENT}${flat}`, contentWidth),
+					// Selected (Other) carries no description; favor checked rows
+					// when budget pressure forces description rows to be dropped.
+					priority: isSelected ? 2 : checked.has(index) ? 1 : 0,
+				});
+			}
+		}
 	}
-	lines.push("", "Enter your response:");
-	return lines.join("\n");
+
+	const trailingGap = window.gapBefore.get(options.length);
+	if (trailingGap !== undefined) emitGap(trailingGap);
+	rows.push({ text: "", priority: -1 });
+	rows.push({ text: "Enter your response:", priority: -1 });
+	return rows;
+}
+
+function applyCustomInputRowBudget(rows: CustomInputRow[], budget: number): CustomInputRow[] {
+	if (rows.length <= budget) return rows;
+	// Drop droppable rows lowest priority first; on ties, drop later rows first
+	// so the user still sees the earliest options' descriptions.
+	const droppable = rows
+		.map((row, index) => ({ row, index }))
+		.filter(entry => entry.row.priority >= 0)
+		.sort((a, b) => a.row.priority - b.row.priority || b.index - a.index);
+	const removed = new Set<number>();
+	for (const { index } of droppable) {
+		if (rows.length - removed.size <= budget) break;
+		removed.add(index);
+	}
+	return rows.filter((_, i) => !removed.has(i));
+}
+
+function formatCustomInputTitle(
+	question: string,
+	options: ExtensionUISelectItem[],
+	context: CustomInputContext,
+): string {
+	const contentWidth = customInputContentWidth();
+	const rows = buildCustomInputRows(question, options, context, contentWidth);
+	return applyCustomInputRowBudget(rows, MAX_CUSTOM_INPUT_TITLE_ROWS)
+		.map(row => row.text)
+		.join("\n");
 }
 
 // =============================================================================