@oh-my-pi/pi-coding-agent 16.1.14 → 16.1.16

package/src/task/worktree.ts

@@ -194,6 +194,19 @@ export async function captureDeltaPatch(isolationDir: string, baseline: Worktree
 
 /**
  * Apply nested repo patches directly to their working directories after parent merge.
+ *
+ * Pre-existing dirty state in a nested repo is stashed before the patch is
+ * applied and popped back (with `--index` so staged WIP stays staged) after
+ * the commit, so unrelated user edits never get folded into the agent's
+ * commit. A failing `git stash pop` (e.g. user edits collide with the patched
+ * lines) leaves the stash entry intact, emits a `logger.warn`, and is
+ * returned to the caller as a human-readable warning string — the agent
+ * commit already landed, so this is a partial success the workflow needs to
+ * see, not a thrown failure.
+ *
+ * Returns the collected stash-restore warnings (empty when every nested repo
+ * was restored cleanly). Throws when the patch apply itself fails.
+ *
  * @param commitMessage Optional async function to generate a commit message from the combined diff.
  *                      If omitted or returns null, falls back to a generic message.
  */
@@ -201,7 +214,8 @@ export async function applyNestedPatches(
 	repoRoot: string,
 	patches: NestedRepoPatch[],
 	commitMessage?: (diff: string) => Promise<string | null>,
-): Promise<void> {
+): Promise<string[]> {
+	const warnings: string[] = [];
 	// Group patches by target repo to apply all at once and commit
 	const byRepo = new Map<string, NestedRepoPatch[]>();
 	for (const p of patches) {
@@ -220,17 +234,40 @@ export async function applyNestedPatches(
 		}
 
 		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
-		for (const { patch } of repoPatches) {
-			await git.patch.applyText(nestedDir, patch);
-		}
 
-		// Commit so nested repo history reflects the task changes
-		if ((await git.status(nestedDir)).trim().length > 0) {
-			const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-			await git.stage.files(nestedDir);
-			await git.commit(nestedDir, msg);
+		// Preserve any pre-existing dirty state (tracked + untracked) so we
+		// commit only the agent delta, not the user's in-flight work.
+		const stashed =
+			(await git.status(nestedDir)).trim().length > 0
+				? await git.stash.push(nestedDir, `omp-isolation-${Snowflake.next()}`)
+				: false;
+		try {
+			for (const { patch } of repoPatches) {
+				await git.patch.applyText(nestedDir, patch);
+			}
+			if ((await git.status(nestedDir)).trim().length > 0) {
+				const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
+				await git.stage.files(nestedDir);
+				await git.commit(nestedDir, msg);
+			}
+		} finally {
+			if (stashed) {
+				try {
+					await git.stash.pop(nestedDir, { index: true });
+				} catch (popErr) {
+					const message = popErr instanceof Error ? popErr.message : String(popErr);
+					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}).`,
+					);
+				}
+			}
 		}
 	}
+	return warnings;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/thinking.ts

@@ -153,6 +153,26 @@ export function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLeve
 	return level === AUTO_THINKING ? AUTO_THINKING_METADATA : getThinkingLevelMetadata(level);
 }
 
+/**
+ * Thinking selectors accepted by the `--thinking` CLI flag, in display order:
+ * `off`, every concrete effort (`minimal`..`xhigh`), then `auto`. Single source
+ * for the flag's `options` list, shell completions, and the "invalid level"
+ * warning so all three stay in sync.
+ */
+export const CLI_THINKING_LEVELS: readonly string[] = [ThinkingLevel.Off, ...THINKING_EFFORTS, AUTO_THINKING];
+
+/**
+ * Parses a `--thinking` CLI value. Accepts every {@link parseConfiguredThinkingLevel}
+ * selector (`off`, `auto`, `minimal`..`xhigh`, plus the `max` alias) but rejects
+ * `inherit`: an explicit `inherit` on the command line would suppress the
+ * settings/scoped-model fallback during startup resolution only to resolve back
+ * to the provider default, which is never what the user means.
+ */
+export function parseCliThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined {
+	const level = parseConfiguredThinkingLevel(value);
+	return level === ThinkingLevel.Inherit ? undefined : level;
+}
+
 /**
  * Resolves an auto-classified effort against the active model's supported
  * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below

package/src/tools/ask.ts

@@ -308,7 +308,7 @@ async function askSingleQuestion(
 				}
 				const customResult = await promptForCustomInput();
 				if (customResult.input === undefined) {
-					break;
+					continue;
 				}
 				customInput = customResult.input;
 				break;
@@ -332,51 +332,57 @@ async function askSingleQuestion(
 		}
 		selectedOptions = Array.from(selected);
 	} else {
-		const displayOptions = addRecommendedSuffix(questionOptions, recommended);
-		const optionsWithNavigation: ExtensionUISelectItem[] = [...displayOptions, OTHER_OPTION];
-
-		let initialIndex = recommended;
-		const previouslySelected = selectedOptions[0];
-		if (previouslySelected) {
-			const selectedIndex = questionOptions.findIndex(option => option.label === previouslySelected);
-			if (selectedIndex >= 0) initialIndex = selectedIndex;
-		} else if (customInput !== undefined) {
-			initialIndex = displayOptions.length;
-		}
-		if (initialIndex !== undefined) {
-			const maxIndex = Math.max(optionsWithNavigation.length - 1, 0);
-			initialIndex = Math.max(0, Math.min(initialIndex, maxIndex));
-		}
+		while (true) {
+			const displayOptions = addRecommendedSuffix(questionOptions, recommended);
+			const optionsWithNavigation: ExtensionUISelectItem[] = [...displayOptions, OTHER_OPTION];
+
+			let initialIndex = recommended;
+			const previouslySelected = selectedOptions[0];
+			if (previouslySelected) {
+				const selectedIndex = questionOptions.findIndex(option => option.label === previouslySelected);
+				if (selectedIndex >= 0) initialIndex = selectedIndex;
+			} else if (customInput !== undefined) {
+				initialIndex = displayOptions.length;
+			}
+			if (initialIndex !== undefined) {
+				const maxIndex = Math.max(optionsWithNavigation.length - 1, 0);
+				initialIndex = Math.max(0, Math.min(initialIndex, maxIndex));
+			}
 
-		const {
-			choice,
-			timedOut: selectTimedOut,
-			navigation: arrowNavigation,
-		} = await selectOption(promptWithProgress, optionsWithNavigation, initialIndex, {
-			selectionMarker: "radio",
-			markableCount: displayOptions.length,
-		});
-		timedOut = selectTimedOut;
+			const {
+				choice,
+				timedOut: selectTimedOut,
+				navigation: arrowNavigation,
+			} = await selectOption(promptWithProgress, optionsWithNavigation, initialIndex, {
+				selectionMarker: "radio",
+				markableCount: displayOptions.length,
+			});
+			timedOut = selectTimedOut;
 
-		if (arrowNavigation) {
-			return { selectedOptions, customInput, timedOut, navigation: arrowNavigation };
-		}
-		if (choice === undefined) {
-			if (!timedOut) {
-				return { selectedOptions, customInput, timedOut, cancelled: true };
+			if (arrowNavigation) {
+				return { selectedOptions, customInput, timedOut, navigation: arrowNavigation };
+			}
+			if (choice === undefined) {
+				if (!timedOut) {
+					return { selectedOptions, customInput, timedOut, cancelled: true };
+				}
+				break;
 			}
-		} else if (choice === OTHER_OPTION) {
-			if (!selectTimedOut) {
+			if (choice === OTHER_OPTION) {
+				if (selectTimedOut) {
+					break;
+				}
 				const customResult = await promptForCustomInput();
-				if (customResult.input !== undefined) {
-					customInput = customResult.input;
-					selectedOptions = [];
+				if (customResult.input === undefined) {
+					continue;
 				}
-				// If editor was dismissed (undefined), keep prior selectedOptions/customInput intact
+				customInput = customResult.input;
+				selectedOptions = [];
+				break;
 			}
-		} else {
 			selectedOptions = [stripRecommendedSuffix(choice)];
 			customInput = undefined;
+			break;
 		}
 		if (navigation?.allowForward) {
 			return { selectedOptions, customInput, timedOut, navigation: "forward" };

package/src/tools/bash.ts

@@ -19,7 +19,7 @@ import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
 import type { ClientBridgeTerminalExitStatus, ClientBridgeTerminalOutput } from "../session/client-bridge";
 import { DEFAULT_MAX_BYTES, enforceInlineByteCap, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent, outputBlockContentWidth } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
@@ -1334,7 +1334,14 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 								.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
 								.join("\n");
 							const textContent = styledOutput;
-							const result = truncateToVisualLines(textContent, previewLines, width);
+							// Cap the collapsed/streaming output to a viewport-sized tail and
+							// measure it at the box's INNER width. Otherwise a growing tail
+							// window scrolls its (mutating) rows above the live-region window
+							// and the engine re-commits a fresh snapshot every frame —
+							// spraying duplicate "… ctrl+o to expand" banners into native
+							// scrollback (the box never overflows the viewport now).
+							const previewBudget = Math.min(previewLines, previewWindow);
+							const result = truncateToVisualLines(textContent, previewBudget, outputBlockContentWidth(width));
 							if (result.skippedCount > 0) {
 								outputLines.push(
 									uiTheme.fg(

package/src/tools/browser/tab-worker.ts

@@ -800,7 +800,7 @@ export class WorkerCore {
 			displays.push({ type: "text", text: safeJsonStringify(output.data) });
 			return;
 		}
-		// status — surface as compact JSON so helper side effects (read/write/tree) appear in
+		// status — surface as compact JSON so helper side effects (read/write/env) appear in
 		// the cell result alongside explicit display() output.
 		displays.push({ type: "text", text: safeJsonStringify(output.event) });
 	}

package/src/tools/eval-render.ts

@@ -18,7 +18,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { formatContextUsage } from "../modes/components/status-line/context-thresholds";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
-import { markFramedBlockComponent, renderCodeCell } from "../tui";
+import { markFramedBlockComponent, outputBlockContentWidth, renderCodeCell } from "../tui";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -56,6 +56,9 @@ interface EvalRenderCellArg {
 }
 
 interface EvalRenderArgs {
+	language?: string;
+	code?: string;
+	title?: string;
 	cells?: EvalRenderCellArg[];
 	__partialJson?: string;
 }
@@ -81,8 +84,8 @@ function normalizeRenderLanguage(value: string | undefined): EvalLanguage {
 }
 
 function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
-	const raw = args?.cells;
-	if (!Array.isArray(raw)) return [];
+	if (!args) return [];
+	const raw = Array.isArray(args.cells) ? args.cells : typeof args.code === "string" ? [args] : [];
 	const out: EvalRenderCell[] = [];
 	for (const cell of raw) {
 		if (!cell || typeof cell !== "object") continue;
@@ -238,14 +241,12 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 	const opIcons: Record<string, AvailableIcon> = {
 		read: "icon.file",
 		write: "icon.file",
-		append: "icon.file",
 		cat: "icon.file",
 		touch: "icon.file",
 		ls: "icon.folder",
 		cd: "icon.folder",
 		pwd: "icon.folder",
 		mkdir: "icon.folder",
-		tree: "icon.folder",
 		git_status: "icon.git",
 		git_diff: "icon.git",
 		git_log: "icon.git",
@@ -277,7 +278,6 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 			if (data.path) parts.push(`from ${shortenPath(String(data.path))}`);
 			break;
 		case "write":
-		case "append":
 			parts.push(`${data.chars ?? data.bytes ?? 0} chars`);
 			if (data.path) parts.push(`to ${shortenPath(String(data.path))}`);
 			break;
@@ -316,13 +316,6 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 			parts.push(`${data.lines} line${(data.lines as number) !== 1 ? "s" : ""}`);
 			if (data.staged) parts.push("(staged)");
 			break;
-		case "diff":
-			if (data.identical) {
-				parts.push("files identical");
-			} else {
-				parts.push("files differ");
-			}
-			break;
 		case "batch":
 			parts.push(`${data.files} file${(data.files as number) !== 1 ? "s" : ""} processed`);
 			break;
@@ -412,8 +405,6 @@ function formatStatusEventExpanded(event: EvalStatusEvent, theme: Theme): string
 		case "cat":
 		case "head":
 		case "tail":
-		case "tree":
-		case "diff":
 		case "git_diff":
 		case "sh":
 			if (data.preview) addPreview(String(data.preview));
@@ -468,23 +459,33 @@ function formatCellOutputLines(
 		return { lines: [], hiddenCount: 0 };
 	}
 
+	// Cell output lands in renderCodeCell → renderOutputBlock, which re-wraps it
+	// at the box's inner content width. Bound the collapsed tail by VISUAL rows
+	// at that width so a long-line tail can't wrap into more rows than budgeted
+	// and scroll its mutating preview above the live-region window — the
+	// duplicate "ctrl+o to expand" scrollback spray.
+	const innerWidth = outputBlockContentWidth(width);
+
 	if (cell.hasMarkdown && cell.status !== "error") {
 		const md = new Markdown(cell.output, 0, 0, getMarkdownTheme());
-		const allLines = md.render(width);
+		const allLines = md.render(innerWidth);
 		const displayLines = expanded ? allLines : allLines.slice(-previewLines);
 		const hiddenCount = allLines.length - displayLines.length;
 		return { lines: displayLines, hiddenCount };
 	}
 
-	const rawLines = cell.output.split("\n");
-	const displayLines = expanded ? rawLines : rawLines.slice(-previewLines);
-	const hiddenCount = rawLines.length - displayLines.length;
-	const outputLines = displayLines.map(line => {
-		const cleaned = replaceTabs(line);
-		return cell.status === "error" ? theme.fg("error", cleaned) : theme.fg("toolOutput", cleaned);
-	});
-
-	return { lines: outputLines, hiddenCount };
+	const styledOutput = cell.output
+		.split("\n")
+		.map(line => {
+			const cleaned = replaceTabs(line);
+			return cell.status === "error" ? theme.fg("error", cleaned) : theme.fg("toolOutput", cleaned);
+		})
+		.join("\n");
+	if (expanded) {
+		return { lines: styledOutput.split("\n"), hiddenCount: 0 };
+	}
+	const { visualLines, skippedCount } = truncateToVisualLines(styledOutput, previewLines, innerWidth);
+	return { lines: visualLines, hiddenCount: skippedCount };
 }
 
 export const evalToolRenderer = {
@@ -586,7 +587,10 @@ export const evalToolRenderer = {
 			return markFramedBlockComponent({
 				render: (width: number): readonly string[] => {
 					const expanded = options.renderContext?.expanded ?? options.expanded;
-					const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
+					const previewLines = Math.min(
+						options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES,
+						previewWindowRows(),
+					);
 					const key = `${expanded}|${previewLines}|${options.spinnerFrame}|${previewWindowRows()}`;
 					if (cached && cached.key === key && cached.width === width) {
 						return cached.result;
@@ -717,7 +721,10 @@ export const evalToolRenderer = {
 
 		return {
 			render: (width: number): readonly string[] => {
-				const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
+				const previewLines = Math.min(
+					options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES,
+					previewWindowRows(),
+				);
 				if (cachedLines === undefined || cachedWidth !== width || cachedPreviewLines !== previewLines) {
 					const result = truncateToVisualLines(textContent, previewLines, width);
 					cachedLines = result.visualLines;