@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

package/src/tools/inspect-image-renderer.ts

@@ -2,8 +2,8 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import { renderStatusLine } from "../tui";
-import { formatExpandHint, replaceTabs, shortenPath, truncateToWidth } from "./render-utils";
+import { framedBlock, renderStatusLine } from "../tui";
+import { formatErrorDetail, formatExpandHint, replaceTabs, shortenPath, truncateToWidth } from "./render-utils";
 
 interface InspectImageRenderArgs {
 	path?: string;
@@ -27,17 +27,21 @@ const INSPECT_OUTPUT_COLLAPSED_LINES = 4;
 const INSPECT_OUTPUT_EXPANDED_LINES = 16;
 const INSPECT_OUTPUT_LINE_WIDTH = 120;
 
+function questionLine(question: string, uiTheme: Theme): string {
+	return `${uiTheme.fg("dim", "Question:")} ${uiTheme.fg("accent", truncateToWidth(replaceTabs(question), INSPECT_QUESTION_PREVIEW_WIDTH))}`;
+}
+
 export const inspectImageToolRenderer = {
 	renderCall(args: InspectImageRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const rawPath = args.path ?? "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "…";
-		const header = renderStatusLine({ icon: "pending", title: "Inspect Image", description: pathDisplay }, uiTheme);
+		const header = renderStatusLine({ icon: "pending", title: "Inspect", description: pathDisplay }, uiTheme);
 		const question = args.question?.trim();
-		if (!question) {
-			return new Text(header, 0, 0);
-		}
-		const questionLine = ` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("dim", "Question:")} ${uiTheme.fg("accent", truncateToWidth(replaceTabs(question), INSPECT_QUESTION_PREVIEW_WIDTH))}`;
-		return new Text(`${header}\n${questionLine}`, 0, 0);
+		// Call is at most a status line plus a one-line question — too small to box.
+		// The container renders a lone Text cleanly with no chrome.
+		if (!question) return new Text(header, 0, 0);
+		const tree = ` ${uiTheme.fg("dim", uiTheme.tree.last)} ${questionLine(question, uiTheme)}`;
+		return new Text(`${header}\n${tree}`, 0, 0);
 	},
 
 	renderResult(
@@ -49,55 +53,73 @@ export const inspectImageToolRenderer = {
 		const details = result.details;
 		const rawPath = details?.imagePath ?? args?.path ?? "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "image";
-		const metaParts: string[] = [];
-		if (details?.model) metaParts.push(details.model);
-		if (details?.mimeType) metaParts.push(details.mimeType);
 		const header = renderStatusLine(
 			{
 				icon: result.isError ? "error" : "success",
-				title: "Inspect Image",
+				title: "Inspect",
 				description: pathDisplay,
 			},
 			uiTheme,
 		);
 
-		const lines: string[] = [header];
 		const question = args?.question?.trim();
-		if (question) {
-			lines.push(
-				` ${uiTheme.fg("dim", uiTheme.tree.branch)} ${uiTheme.fg("dim", "Question:")} ${uiTheme.fg("accent", truncateToWidth(replaceTabs(question), INSPECT_QUESTION_PREVIEW_WIDTH))}`,
-			);
-		}
-
 		const outputText = result.content.find(content => content.type === "text")?.text?.trimEnd() ?? "";
-		if (!outputText) {
-			lines.push(uiTheme.fg("dim", "(no output)"));
-			if (metaParts.length > 0) {
-				lines.push("");
-				lines.push(uiTheme.fg("dim", metaParts.join(" · ")));
-			}
-			return new Text(lines.join("\n"), 0, 0);
-		}
 
-		lines.push("");
-		const outputLines = replaceTabs(outputText).split("\n");
-		const maxLines = options.expanded ? INSPECT_OUTPUT_EXPANDED_LINES : INSPECT_OUTPUT_COLLAPSED_LINES;
-		for (const line of outputLines.slice(0, maxLines)) {
-			lines.push(uiTheme.fg("toolOutput", truncateToWidth(line, INSPECT_OUTPUT_LINE_WIDTH)));
+		if (result.isError) {
+			return framedBlock(uiTheme, width => {
+				const bodyLines: string[] = [];
+				if (question) bodyLines.push(questionLine(question, uiTheme));
+				bodyLines.push(formatErrorDetail(outputText || "inspection failed", uiTheme));
+				return {
+					header,
+					sections: [{ lines: bodyLines }],
+					state: "error",
+					borderColor: "error",
+					applyBg: false,
+					width,
+				};
+			});
 		}
 
-		if (outputLines.length > maxLines) {
-			const remaining = outputLines.length - maxLines;
-			const hint = formatExpandHint(uiTheme, options.expanded, true);
-			lines.push(`${uiTheme.fg("dim", `… ${remaining} more lines`)}${hint ? ` ${hint}` : ""}`);
-		}
+		const metaParts: string[] = [];
+		if (details?.model) metaParts.push(details.model);
+		if (details?.mimeType) metaParts.push(details.mimeType);
+		const metaLine = metaParts.length > 0 ? uiTheme.fg("dim", metaParts.join(" · ")) : "";
 
-		if (metaParts.length > 0) {
-			lines.push("");
-			lines.push(uiTheme.fg("dim", metaParts.join(" · ")));
+		// No answer text: nothing worth boxing — keep it to a clean status line
+		// (plus a trailing meta line, when present).
+		if (!outputText) {
+			return new Text(metaLine ? `${header}\n${metaLine}` : header, 0, 0);
 		}
 
-		return new Text(lines.join("\n"), 0, 0);
+		return framedBlock(uiTheme, width => {
+			const bodyLines: string[] = [];
+			if (question) {
+				bodyLines.push(questionLine(question, uiTheme));
+				bodyLines.push("");
+			}
+
+			const outputLines = replaceTabs(outputText).split("\n");
+			const maxLines = options.expanded ? INSPECT_OUTPUT_EXPANDED_LINES : INSPECT_OUTPUT_COLLAPSED_LINES;
+			for (const line of outputLines.slice(0, maxLines)) {
+				bodyLines.push(uiTheme.fg("toolOutput", truncateToWidth(line, INSPECT_OUTPUT_LINE_WIDTH)));
+			}
+			if (outputLines.length > maxLines) {
+				const remaining = outputLines.length - maxLines;
+				const hint = formatExpandHint(uiTheme, options.expanded, true);
+				bodyLines.push(`${uiTheme.fg("dim", `… ${remaining} more lines`)}${hint ? ` ${hint}` : ""}`);
+			}
+
+			return {
+				header,
+				headerMeta: metaLine || undefined,
+				sections: [{ lines: bodyLines }],
+				state: "success",
+				borderColor: "borderMuted",
+				applyBg: false,
+				width,
+			};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/inspect-image.ts

@@ -4,6 +4,7 @@ import { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import { extractTextContent } from "../commit/utils";
+
 import { expandRoleAlias, resolveModelFromString } from "../config/model-resolver";
 import inspectImageDescription from "../prompts/tools/inspect-image.md" with { type: "text" };
 import inspectImageSystemPromptTemplate from "../prompts/tools/inspect-image-system.md" with { type: "text" };
@@ -136,7 +137,13 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 					},
 				],
 			},
-			{ apiKey, signal },
+			{
+				apiKey: modelRegistry.resolver(model.provider, {
+					sessionId: this.session.getSessionId?.() ?? undefined,
+					baseUrl: model.baseUrl,
+				}),
+				signal,
+			},
 			{ telemetry, oneshotKind: "inspect_image", completeImpl: this.completeImageRequest },
 		);
 

package/src/tools/job.ts

@@ -396,7 +396,7 @@ export const jobToolRenderer = {
 	inline: true,
 
 	renderCall(args: JobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const text = renderStatusLine({ icon: "pending", title: "Job", description: describeTarget(args) }, uiTheme);
+		const text = renderStatusLine({ icon: "pending", title: describeTarget(args) || "Job" }, uiTheme);
 		return new Text(text, 0, 0);
 	},
 
@@ -410,7 +410,7 @@ export const jobToolRenderer = {
 
 		if (jobs.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text || "No jobs to process";
-			const header = renderStatusLine({ icon: "warning", title: "Job", description: describeTarget(args) }, uiTheme);
+			const header = renderStatusLine({ icon: "warning", title: describeTarget(args) || "Job" }, uiTheme);
 			return new Text([header, formatEmptyMessage(fallback, uiTheme)].join("\n"), 0, 0);
 		}
 
@@ -433,8 +433,7 @@ export const jobToolRenderer = {
 			{
 				icon: headerIcon,
 				spinnerFrame: counts.running > 0 ? options.spinnerFrame : undefined,
-				title: "Job",
-				description,
+				title: description,
 				meta,
 			},
 			uiTheme,

package/src/tools/memory-render.ts

@@ -4,7 +4,10 @@
  *
  * These keep the transcript terse — one status line plus, for `retain`, one
  * `Remember: …` line per stored item — instead of the generic JSON arg tree,
- * which exploded multi-line memory blobs into an unreadable wall.
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";

package/src/tools/plan-mode-guard.ts

@@ -1,4 +1,3 @@
-import * as path from "node:path";
 import { resolveLocalUrlToPath, resolveVaultUrlToPath } from "../internal-urls";
 import type { ToolSession } from ".";
 import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
@@ -6,10 +5,19 @@ import { ToolError } from "./tool-errors";
 
 const VAULT_SCHEME_PREFIX = "vault:";
 const LOCAL_SCHEME_PREFIX = "local:";
-const PLAN_ALIAS_FILE = "PLAN.md";
-const LOCAL_PLAN_ALIAS = "local://PLAN.md";
 
-function resolveRawPath(session: ToolSession, targetPath: string): string {
+/** True when `targetPath` addresses the session-local artifact sandbox
+ *  (`local://…`). Those files are not part of the working tree, so plan mode
+ *  treats them as freely writable scratch/plan space. */
+function targetsLocalSandbox(targetPath: string): boolean {
+	return normalizeLocalScheme(targetPath).startsWith(LOCAL_SCHEME_PREFIX);
+}
+
+/**
+ * Resolve a write/edit target to its absolute filesystem path, honoring the
+ * `local://` and `vault://` schemes. Plain paths resolve against the session cwd.
+ */
+export function resolvePlanPath(session: ToolSession, targetPath: string): string {
 	const normalized = normalizeLocalScheme(targetPath);
 	if (normalized.startsWith(LOCAL_SCHEME_PREFIX)) {
 		return resolveLocalUrlToPath(normalized, {
@@ -25,37 +33,12 @@ function resolveRawPath(session: ToolSession, targetPath: string): string {
 	return resolveToCwd(normalized, session.cwd);
 }
 
-function isPlanAliasTarget(session: ToolSession, targetPath: string, resolved: string): boolean {
-	const normalized = normalizeLocalScheme(targetPath);
-	if (normalized === LOCAL_PLAN_ALIAS) return true;
-	return resolved === resolveToCwd(PLAN_ALIAS_FILE, session.cwd);
-}
-
 /**
- * Resolve a write/edit target to its absolute filesystem path.
- *
- * In plan mode, transparently redirects `PLAN.md` aliases and targets whose
- * basename matches the plan file's basename to the canonical plan file
- * location at `state.planFilePath`. This lets `write` and `edit` accept the
- * habitual plan filename after approval even when the active artifact has a
- * titled path such as `local://APPROVED.md`.
- *
- * Outside plan mode (or when the basename does not match) this is a no-op.
+ * Plan mode keeps the working tree read-only while letting the agent draft its
+ * plan. Writes and edits to the `local://` artifact sandbox are allowed (that is
+ * where the plan and any scratch notes live); anything that would touch the
+ * working tree — or rename/delete a file — is rejected.
  */
-export function resolvePlanPath(session: ToolSession, targetPath: string): string {
-	const resolved = resolveRawPath(session, targetPath);
-
-	const state = session.getPlanModeState?.();
-	if (!state?.enabled) return resolved;
-
-	const planResolved = resolveRawPath(session, state.planFilePath);
-	if (resolved === planResolved) return resolved;
-	if (isPlanAliasTarget(session, targetPath, resolved)) return planResolved;
-	if (path.basename(resolved) !== path.basename(planResolved)) return resolved;
-
-	return planResolved;
-}
-
 export function enforcePlanModeWrite(
 	session: ToolSession,
 	targetPath: string,
@@ -64,9 +47,6 @@ export function enforcePlanModeWrite(
 	const state = session.getPlanModeState?.();
 	if (!state?.enabled) return;
 
-	const resolvedTarget = resolvePlanPath(session, targetPath);
-	const resolvedPlan = resolvePlanPath(session, state.planFilePath);
-
 	if (options?.move) {
 		throw new ToolError("Plan mode: renaming files is not allowed.");
 	}
@@ -75,7 +55,9 @@ export function enforcePlanModeWrite(
 		throw new ToolError("Plan mode: deleting files is not allowed.");
 	}
 
-	if (resolvedTarget !== resolvedPlan) {
-		throw new ToolError(`Plan mode: only the plan file may be modified (${state.planFilePath}).`);
-	}
+	if (targetsLocalSandbox(targetPath)) return;
+
+	throw new ToolError(
+		"Plan mode: the working tree is read-only. Write your plan to a local://<slug>-plan.md file instead.",
+	);
 }

package/src/tools/read.ts

@@ -34,7 +34,7 @@ import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "../utils/image-loading";
 import { convertFileWithMarkit } from "../utils/markit";
 import { buildDirectoryTree, type DirectoryTree } from "../workspace-tree";
-import { type ArchiveReader, openArchive, parseArchivePathCandidates } from "./archive-reader";
+import { type ArchiveReader, formatArchiveEntryLines, openArchive, parseArchivePathCandidates } from "./archive-reader";
 import {
 	type ConflictEntry,
 	type ConflictScope,
@@ -1154,17 +1154,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const limitedEntries = listLimit.items;
 		const limitMeta = listLimit.meta;
 
-		const results: string[] = [];
-		for (const entry of limitedEntries) {
+		for (let index = 0; index < limitedEntries.length; index++) {
 			throwIfAborted(signal);
-			if (entry.isDirectory) {
-				results.push(`${entry.name}/`);
-				continue;
-			}
-
-			const sizeSuffix = entry.size > 0 ? ` (${formatBytes(entry.size)})` : "";
-			results.push(`${entry.name}${sizeSuffix}`);
 		}
+		const results = formatArchiveEntryLines(limitedEntries);
 
 		const output = results.length > 0 ? results.join("\n") : "(empty archive directory)";
 		const text = prependSuffixResolutionNotice(output, details.suffixResolution);
@@ -2337,10 +2330,20 @@ function firstReadSelectorLine(sel: string | undefined): number | undefined {
 	}
 }
 
+/** Absolute fs path the read result actually resolved to, used as the OSC 8 link
+ * target when the structured `resolvedPath` isn't set (the common plain-file and
+ * image reads only record the path in `meta.source`). URL/internal sources are
+ * not fs paths, so only `type: "path"` qualifies. */
+function readSourceFsPath(details: ReadToolDetails | undefined): string | undefined {
+	const source = details?.meta?.source;
+	return source?.type === "path" ? source.value : undefined;
+}
+
 function formatReadPathLink(
 	rawPath: string,
 	options: {
 		resolvedPath?: string;
+		sourcePath?: string;
 		suffixResolution?: { from: string; to: string };
 		offset?: number;
 		fallbackLabel?: string;
@@ -2352,7 +2355,7 @@ function formatReadPathLink(
 	const plainDisplayPath = options.suffixResolution
 		? shortenPath(options.suffixResolution.to)
 		: shortenPath(basePath || options.resolvedPath || options.fallbackLabel || rawPath);
-	const target = options.resolvedPath ?? tryResolveInternalUrlSync(basePath);
+	const target = options.resolvedPath ?? options.sourcePath ?? tryResolveInternalUrlSync(basePath);
 	const line = firstReadSelectorLine(split.sel) ?? options.offset;
 	const linkOptions = line !== undefined ? { line } : undefined;
 	const displayPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
@@ -2403,7 +2406,9 @@ export const readToolRenderer = {
 			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
 			const rawPath = args?.file_path || args?.path || "";
-			const filePath = formatReadPathLink(rawPath, { offset: args?.offset }) || shortenPath(rawPath);
+			const filePath =
+				formatReadPathLink(rawPath, { offset: args?.offset, sourcePath: readSourceFsPath(result.details) }) ||
+				shortenPath(rawPath);
 			let title = filePath ? `Read ${filePath}` : "Read";
 			if (args?.offset !== undefined || args?.limit !== undefined) {
 				const startLine = args.offset ?? 1;
@@ -2454,6 +2459,7 @@ export const readToolRenderer = {
 			const suffix = details?.suffixResolution;
 			const displayPath = formatReadPathLink(rawPath, {
 				resolvedPath: details?.resolvedPath,
+				sourcePath: readSourceFsPath(details),
 				suffixResolution: suffix,
 				fallbackLabel: "image",
 			});
@@ -2486,12 +2492,13 @@ export const readToolRenderer = {
 		}
 
 		const suffix = details?.suffixResolution;
-		// resolvedPath is the absolute fs path for fs-backed reads (regular files plus
-		// local:// / memory:// / skill:// / artifact:// resources). Fall back to a sync
-		// resolver for fs-backed internal URLs so the title is clickable even before the
-		// result lands or if the handler didn't populate resolvedPath.
+		// resolvedPath is the absolute fs path when a read resolved/corrected the
+		// input (suffix match, internal URL, archive/sqlite/notebook); plain file
+		// reads only record the absolute path in meta.source, so fall back to that
+		// (and then to a sync internal-URL resolver) to keep the title clickable.
 		const displayPath = formatReadPathLink(rawPath, {
 			resolvedPath: details?.resolvedPath,
+			sourcePath: readSourceFsPath(details),
 			suffixResolution: suffix,
 			offset: args?.offset,
 		});

package/src/tools/render-utils.ts

@@ -10,8 +10,9 @@ import * as path from "node:path";
 import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Ellipsis } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
+import { getKeybindings, replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { pluralize } from "@oh-my-pi/pi-utils";
+import { formatKeyHints, type KeyId } from "../config/keybindings";
 import { settings } from "../config/settings";
 import type { Theme } from "../modes/theme/theme";
 import { Hasher } from "../tui/utils";
@@ -75,8 +76,16 @@ export const TRUNCATE_LENGTHS = {
 	SHORT: 40,
 } as const;
 
-/** Standard expand hint text */
-export const EXPAND_HINT = "(Ctrl+O for more)";
+/** Keybinding action that toggles tool-output expansion. */
+const EXPAND_ACTION = "app.tools.expand";
+/** Fallback key when no binding is resolvable (e.g. outside an interactive session). */
+const DEFAULT_EXPAND_KEY: KeyId = "ctrl+o";
+
+/** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
+export function expandKeyHint(): string {
+	const keys = getKeybindings().getKeys(EXPAND_ACTION);
+	return formatKeyHints(keys.length > 0 ? keys : [DEFAULT_EXPAND_KEY]);
+}
 
 // =============================================================================
 // Text Truncation Utilities
@@ -150,7 +159,7 @@ export function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFram
 export function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string {
 	if (expanded) return "";
 	if (hasMore === false) return "";
-	return theme.fg("dim", wrapBrackets(EXPAND_HINT, theme));
+	return theme.fg("dim", wrapBrackets(`${expandKeyHint()}: Expand`, theme));
 }
 
 /**
@@ -221,10 +230,24 @@ export function formatMeta(meta: string[], theme: Theme): string {
 	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
 }
 
-export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+function sanitizeErrorText(message: string | undefined): string {
 	const clean = (message ?? "").replace(/^Error:\s*/, "").trim();
-	const safe = clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
-	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${safe}`)}`;
+	return clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
+}
+
+export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${sanitizeErrorText(message)}`)}`;
+}
+
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export function formatErrorDetail(message: string | undefined, theme: Theme): string {
+	return `  ${theme.fg("error", sanitizeErrorText(message))}`;
 }
 
 export function formatEmptyMessage(message: string, theme: Theme): string {
@@ -722,36 +745,6 @@ export function capParseErrors(
 // Renderer helpers shared by search / find / ast tools
 // =============================================================================
 
-/**
- * Group `rawLines` by blank-line separators, mirroring the historical search /
- * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
- * runs of blank lines; otherwise collapses non-empty lines into a single group.
- */
-export function splitGroupsByBlankLine(rawLines: string[]): string[][] {
-	const hasSeparators = rawLines.some(line => line.trim().length === 0);
-	const groups: string[][] = [];
-	if (hasSeparators) {
-		let current: string[] = [];
-		for (const line of rawLines) {
-			if (line.trim().length === 0) {
-				if (current.length > 0) {
-					groups.push(current);
-					current = [];
-				}
-				continue;
-			}
-			current.push(line);
-		}
-		if (current.length > 0) groups.push(current);
-	} else {
-		const nonEmpty = rawLines.filter(line => line.trim().length > 0);
-		if (nonEmpty.length > 0) {
-			groups.push(nonEmpty);
-		}
-	}
-	return groups;
-}
-
 /**
  * Standard width+expand keyed render cache used by every search-style tool
  * renderer. `compute` re-runs only when the cache key changes; the returned
@@ -760,6 +753,7 @@ export function splitGroupsByBlankLine(rawLines: string[]): string[][] {
 export function createCachedComponent(
 	getExpanded: () => boolean,
 	compute: (width: number, expanded: boolean) => string[],
+	options: { paddingX?: number } = {},
 ): Component {
 	let cached: { key: bigint; lines: string[] } | undefined;
 	return {
@@ -767,9 +761,13 @@ export function createCachedComponent(
 			const expanded = getExpanded();
 			const key = new Hasher().bool(expanded).u32(width).digest();
 			if (cached?.key === key) return cached.lines;
-			const lines = compute(width, expanded);
-			cached = { key, lines };
-			return lines;
+			const paddingX = Math.max(0, options.paddingX ?? 0);
+			const innerWidth = Math.max(1, width - paddingX * 2);
+			const lines = compute(innerWidth, expanded);
+			const pad = paddingX === 0 ? "" : " ".repeat(paddingX);
+			const paddedLines = paddingX === 0 ? lines : lines.map(line => `${pad}${line}${pad}`);
+			cached = { key, lines: paddedLines };
+			return paddedLines;
 		},
 		invalidate() {
 			cached = undefined;

package/src/tools/renderers.ts

@@ -31,7 +31,7 @@ import { sshToolRenderer } from "./ssh";
 import { todoToolRenderer } from "./todo";
 import { writeToolRenderer } from "./write";
 
-type ToolRenderer = {
+export type ToolRenderer = {
 	renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
 	renderResult: (
 		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
@@ -40,6 +40,21 @@ type ToolRenderer = {
 		args?: unknown,
 	) => Component;
 	mergeCallAndResult?: boolean;
+	/**
+	 * While a tool's preview is still streaming, report whether the
+	 * currently-rendered preview is append-only: its rows only grow at the bottom
+	 * and never re-layout above the bottom live region (a full, top-anchored
+	 * content/code preview). The transcript reports this up to the TUI so a
+	 * streaming preview taller than the viewport commits its scrolled-off head to
+	 * native scrollback instead of dropping it (see
+	 * `ToolExecutionComponent.isTranscriptBlockAppendOnly`). `result` is the
+	 * latest (possibly partial) tool result, or `undefined` before one exists —
+	 * `eval`/`bash` use its presence to defer committing until the streamed input
+	 * (code) has finalized. Omit (or return `false`) for previews that slide a
+	 * tail window or later collapse to a compact result — committing their head
+	 * would strand stale rows.
+	 */
+	isStreamingPreviewAppendOnly?: (args: unknown, options: RenderResultOptions, result?: unknown) => boolean;
 	/** Render without background box, inline in the response flow */
 	inline?: boolean;
 };

package/src/tools/report-tool-issue.ts

@@ -41,7 +41,7 @@ function buildReportToolIssueParams(activeBuiltinNames: readonly string[]) {
 }
 
 export function isAutoQaEnabled(settings?: Settings): boolean {
-	return $flag("PI_AUTO_QA") || !!settings?.get("dev.autoqa");
+	return $flag("PI_AUTO_QA", !!settings?.get("dev.autoqa"));
 }
 
 // ───────────────────────────────────────────────────────────────────────────

package/src/tools/resolve.ts

@@ -187,6 +187,20 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 		return untilAborted(signal, async () => {
 			const invoker = this.session.peekQueueInvoker?.() ?? this.session.peekStandingResolveHandler?.();
 			if (!invoker) {
+				// `discard` is a request to cancel/abort a staged action. When nothing is
+				// pending, the desired end-state (no staged change) already holds, so honor
+				// it as a successful cancellation instead of surfacing a hard error to the
+				// model. `apply` still errors — there is nothing to apply.
+				if (params.action === "discard") {
+					return {
+						content: [{ type: "text" as const, text: "Nothing to discard; no pending action remains." }],
+						details: {
+							action: "discard",
+							reason: params.reason,
+							...(params.extra != null ? { extra: params.extra } : {}),
+						},
+					};
+				}
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
 			const result = (await invoker(params)) as AgentToolResult<ResolveToolDetails>;