@oh-my-pi/pi-coding-agent 15.10.2 → 15.10.4

package/src/tools/eval-render.ts

@@ -16,9 +16,8 @@ import type { EvalCellResult, EvalLanguage, EvalStatusEvent, EvalToolDetails } f
 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 { shimmerEnabled } from "../modes/theme/shimmer";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
-import { borderShimmerTick, markFramedBlockComponent, renderCodeCell } from "../tui";
+import { markFramedBlockComponent, renderCodeCell } from "../tui";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -247,7 +246,7 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		sh: "icon.package",
 		env: "icon.package",
 		batch: "icon.package",
-		llm: "icon.package",
+		completion: "icon.package",
 		log: "icon.package",
 		phase: "icon.package",
 	};
@@ -316,7 +315,7 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		case "batch":
 			parts.push(`${data.files} file${(data.files as number) !== 1 ? "s" : ""} processed`);
 			break;
-		case "llm":
+		case "completion":
 			if (data.model) parts.push(String(data.model));
 			if (data.tier && data.tier !== data.model) parts.push(`(${data.tier})`);
 			parts.push(`${data.chars ?? 0} chars`);
@@ -491,8 +490,7 @@ export const evalToolRenderer = {
 
 		return markFramedBlockComponent({
 			render: (width: number): string[] => {
-				const animate = options.isPartial && shimmerEnabled();
-				const key = `${animate ? borderShimmerTick() : 0}|${options.expanded ? 1 : 0}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
+				const key = `${options.expanded ? 1 : 0}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
 				}
@@ -510,13 +508,9 @@ export const evalToolRenderer = {
 							status: "pending",
 							width,
 							// Always render the full source: the code is fixed input, not the
-							// streaming part, so it is never compacted. While still pending
-							// (args streaming) the block is not yet committed to native
-							// scrollback — its head is only committed once a result exists and
-							// the code has finalized (see `isStreamingPreviewAppendOnly`).
+							// streaming part, so it is never compacted.
 							codeMaxLines: Number.POSITIVE_INFINITY,
 							expanded: options.expanded,
-							animate,
 						},
 						uiTheme,
 					);
@@ -579,8 +573,7 @@ export const evalToolRenderer = {
 				render: (width: number): string[] => {
 					const expanded = options.renderContext?.expanded ?? options.expanded;
 					const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
-					const animate = options.isPartial && shimmerEnabled();
-					const key = `${expanded}|${previewLines}|${options.spinnerFrame}|${animate ? borderShimmerTick() : 0}`;
+					const key = `${expanded}|${previewLines}|${options.spinnerFrame}`;
 					if (cached && cached.key === key && cached.width === width) {
 						return cached.result;
 					}
@@ -622,7 +615,6 @@ export const evalToolRenderer = {
 								codeMaxLines: Number.POSITIVE_INFINITY,
 								expanded,
 								width,
-								animate,
 							},
 							uiTheme,
 						);
@@ -752,17 +744,6 @@ export const evalToolRenderer = {
 		};
 	},
 
-	// Append-only once a result exists (args complete → code finalized). The code
-	// is rendered in full as a fixed top-anchored prefix, and the streamed stdout
-	// below it only appends rows at the bottom, so the scrolled-off head commits
-	// to native scrollback instead of being yanked — collapsed or expanded, since
-	// the collapsed output cap keeps its sliding tail in the bottom live region.
-	// Returns false while still pending: the code is mid-stream (args incomplete)
-	// and its header still reads "pending", so committing it would strand a stale
-	// pending preview in history.
-	isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean {
-		return result != null;
-	},
 	mergeCallAndResult: true,
 	inline: true,
 };

package/src/tools/eval.ts

@@ -326,7 +326,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 					const cell = cells[i];
 					const backend = cell.resolved.backend;
 					// The per-cell `timeout` is a budget on the cell runtime's *own*
-					// work. Host-side `agent()`/`parallel()`/`llm()` bridge calls suspend
+					// work. Host-side `agent()`/`parallel()`/`completion()` bridge calls suspend
 					// that budget entirely and restart a fresh timeout window when control
 					// returns to Python/JS. Compute, stdout, `log()`/`phase()`, and
 					// ordinary tool calls all count against the budget. The watchdog drives

package/src/tools/find.ts

@@ -117,6 +117,12 @@ export interface FindToolOptions {
 	operations?: FindOperations;
 }
 
+interface FindTarget {
+	searchPath: string;
+	globPattern: string;
+	hasGlob: boolean;
+}
+
 export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	readonly name = "find";
 	readonly approval = "read" as const;
@@ -193,15 +199,31 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			const multiPattern = await resolveExplicitFindPatterns(effectivePatterns, this.session.cwd);
-			const parsedPattern = multiPattern ? null : parseFindPattern(effectivePatterns[0] ?? ".");
-			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
-			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
-			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
-			const scopePath = multiPattern?.scopePath ?? formatScopePath(searchPath);
-
-			if (searchPath === "/") {
-				throw new ToolError("Searching from root directory '/' is not allowed");
+			const isSingle = !multiPattern;
+			const targets: FindTarget[] = multiPattern
+				? multiPattern.targets.map(target => ({
+						searchPath: resolveToCwd(target.basePath, this.session.cwd),
+						globPattern: target.globPattern,
+						hasGlob: target.hasGlob,
+					}))
+				: [
+						(() => {
+							const parsed = parseFindPattern(effectivePatterns[0] ?? ".");
+							return {
+								searchPath: resolveToCwd(parsed.basePath, this.session.cwd),
+								globPattern: parsed.globPattern,
+								hasGlob: parsed.hasGlob,
+							};
+						})(),
+					];
+			const scopePath = multiPattern?.scopePath ?? formatScopePath(targets[0].searchPath);
+
+			for (const target of targets) {
+				if (target.searchPath === "/") {
+					throw new ToolError("Searching from root directory '/' is not allowed");
+				}
 			}
+
 			const requestedLimit = limit ?? DEFAULT_LIMIT;
 			if (!Number.isFinite(requestedLimit) || requestedLimit <= 0) {
 				throw new ToolError("Limit must be a positive number");
@@ -213,9 +235,9 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const timeoutMs = Math.min(MAX_GLOB_TIMEOUT_MS, Math.max(MIN_GLOB_TIMEOUT_MS, requestedTimeoutMs));
 			const timeoutSignal = AbortSignal.timeout(timeoutMs);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			const formatMatchPath = (matchPath: string, fileType?: natives.FileType): string => {
+			const formatMatchPath = (matchPath: string, base: string, fileType?: natives.FileType): string => {
 				const hadTrailingSlash = matchPath.endsWith("/") || matchPath.endsWith("\\");
-				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(searchPath, matchPath);
+				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(base, matchPath);
 				return formatPathRelativeToCwd(absolutePath, this.session.cwd, {
 					trailingSlash: fileType === natives.FileType.Dir || hadTrailingSlash,
 				});
@@ -276,45 +298,41 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				return resultBuilder.done();
 			};
 
+			// Walk each user path as its own root and run the globs concurrently.
+			// Collapsing multiple paths to a shared base would force the walker to
+			// traverse and stat every unrelated sibling under that ancestor; per-path
+			// roots keep each scan bounded to exactly what the user asked for.
 			if (this.#customOps?.glob) {
-				if (!(await this.#customOps.exists(searchPath))) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-
-				if (!hasGlob && this.#customOps.stat) {
-					const stat = await this.#customOps.stat(searchPath);
-					if (stat.isFile()) {
-						return buildResult([scopePath]);
+				const customOps = this.#customOps;
+				const perTarget = await Promise.all(
+					targets.map(async target => {
+						if (!(await customOps.exists(target.searchPath))) {
+							if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+							return [] as string[];
+						}
+						if (!target.hasGlob && customOps.stat) {
+							const stat = await customOps.stat(target.searchPath);
+							if (stat.isFile()) return [formatScopePath(target.searchPath)];
+						}
+						const results = await customOps.glob(target.globPattern, target.searchPath, {
+							ignore: ["**/node_modules/**", "**/.git/**"],
+							limit: effectiveLimit,
+						});
+						return results.map(matchPath => formatMatchPath(matchPath, target.searchPath));
+					}),
+				);
+				const seen = new Set<string>();
+				const merged: string[] = [];
+				for (const group of perTarget) {
+					for (const entry of group) {
+						if (seen.has(entry)) continue;
+						seen.add(entry);
+						merged.push(entry);
 					}
 				}
-
-				const results = await this.#customOps.glob(globPattern, searchPath, {
-					ignore: ["**/node_modules/**", "**/.git/**"],
-					limit: effectiveLimit,
-				});
-				const relativized = results.map(p => formatMatchPath(p));
-
-				return buildResult(relativized);
-			}
-
-			let searchStat: fs.Stats;
-			try {
-				searchStat = await fs.promises.stat(searchPath);
-			} catch (err) {
-				if (isEnoent(err)) {
-					throw new ToolError(`Path not found: ${scopePath}`);
-				}
-				throw err;
-			}
-
-			if (!hasGlob && searchStat.isFile()) {
-				return buildResult([scopePath]);
-			}
-			if (!searchStat.isDirectory()) {
-				throw new ToolError(`Path is not a directory: ${searchPath}`);
+				return buildResult(merged);
 			}
 
-			let matches: natives.GlobMatch[];
 			const onUpdateMatches: string[] = [];
 			const onUpdateMtimes: number[] = [];
 			const updateIntervalMs = 200;
@@ -335,87 +353,111 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					details,
 				});
 			};
-			const onMatch = (err: Error | null, match: natives.GlobMatch | null) => {
-				if (err || combinedSignal.aborted || !match?.path) return;
-				const relativePath = formatMatchPath(match.path, match.fileType);
-				onUpdateMatches.push(relativePath);
-				onUpdateMtimes.push(match.mtime ?? 0);
-				emitUpdate();
-			};
-
-			const doGlob = async (useGitignore: boolean) =>
-				untilAborted(combinedSignal, () =>
-					natives.glob(
-						{
-							pattern: globPattern,
-							path: searchPath,
-							hidden: includeHidden,
-							maxResults: effectiveLimit,
-							sortByMtime: true,
-							gitignore: useGitignore,
-							// parseFindPattern explicitly prepends "**/" when the user's
-							// pattern begins with a glob (so `*.ts` becomes `**/*.ts`).
-							// Anything that arrives here without "**/" was scoped to a
-							// single directory by the user (e.g. `dir/*`); disable the
-							// native auto-recursion so `dir/*` does not silently match
-							// `dir/sub/nested.ts`.
-							recursive: false,
-							signal: combinedSignal,
-						},
-						onMatch,
-					),
-				);
+			const streamed = new Set<string>();
+			const makeOnMatch =
+				(base: string) =>
+				(err: Error | null, match: natives.GlobMatch | null): void => {
+					if (err || combinedSignal.aborted || !match?.path) return;
+					const relativePath = formatMatchPath(match.path, base, match.fileType);
+					if (streamed.has(relativePath)) return;
+					streamed.add(relativePath);
+					onUpdateMatches.push(relativePath);
+					onUpdateMtimes.push(match.mtime ?? 0);
+					emitUpdate();
+				};
 
 			let timedOut = false;
-			try {
-				const result = await doGlob(useGitignore);
-				// Native glob returns a bounded mtime-ranked set; keep the JS sort for
-				// deterministic ordering across cached and uncached native paths.
-				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
-				matches = result.matches;
-			} catch (error) {
-				if (error instanceof Error && error.name === "AbortError") {
-					if (timeoutSignal.aborted && !signal?.aborted) {
-						timedOut = true;
-						matches = [];
-					} else {
+			const runTarget = async (target: FindTarget): Promise<Array<{ path: string; mtime: number }>> => {
+				throwIfAborted(signal);
+				let stat: fs.Stats;
+				try {
+					stat = await fs.promises.stat(target.searchPath);
+				} catch (err) {
+					if (isEnoent(err)) {
+						if (isSingle) throw new ToolError(`Path not found: ${scopePath}`);
+						return [];
+					}
+					throw err;
+				}
+				if (!target.hasGlob && stat.isFile()) {
+					return [{ path: formatScopePath(target.searchPath), mtime: stat.mtimeMs }];
+				}
+				if (!stat.isDirectory()) {
+					if (isSingle) throw new ToolError(`Path is not a directory: ${target.searchPath}`);
+					return [];
+				}
+				try {
+					const result = await untilAborted(combinedSignal, () =>
+						natives.glob(
+							{
+								pattern: target.globPattern,
+								path: target.searchPath,
+								hidden: includeHidden,
+								maxResults: effectiveLimit,
+								sortByMtime: true,
+								gitignore: useGitignore,
+								// parseFindPattern explicitly prepends "**/" when the user's
+								// pattern begins with a glob (so `*.ts` becomes `**/*.ts`).
+								// Anything that arrives here without "**/" was scoped to a
+								// single directory by the user (e.g. `dir/*`); disable the
+								// native auto-recursion so `dir/*` does not silently match
+								// `dir/sub/nested.ts`.
+								recursive: false,
+								signal: combinedSignal,
+							},
+							makeOnMatch(target.searchPath),
+						),
+					);
+					throwIfAborted(signal);
+					const out: Array<{ path: string; mtime: number }> = [];
+					for (const match of result.matches) {
+						if (!match.path) continue;
+						out.push({
+							path: formatMatchPath(match.path, target.searchPath, match.fileType),
+							mtime: match.mtime ?? 0,
+						});
+					}
+					return out;
+				} catch (error) {
+					if (error instanceof Error && error.name === "AbortError") {
+						if (timeoutSignal.aborted && !signal?.aborted) {
+							timedOut = true;
+							return [];
+						}
 						throw new ToolAbortError();
 					}
-				} else {
 					throw error;
 				}
-			}
+			};
+
+			const perTarget = await Promise.all(targets.map(runTarget));
 
 			if (timedOut) {
 				// Drain the partial matches accumulated during streaming and return them
 				// instead of throwing — empty results after a multi-second wait force the
 				// caller to retry blind, which is the worst possible outcome.
-				const seen = new Set<string>();
-				const partial: Array<{ p: string; m: number }> = [];
-				for (let i = 0; i < onUpdateMatches.length; i++) {
-					const entry = onUpdateMatches[i];
-					if (seen.has(entry)) continue;
-					seen.add(entry);
-					partial.push({ p: entry, m: onUpdateMtimes[i] ?? 0 });
-				}
+				const partial = onUpdateMatches.map((entry, index) => ({ p: entry, m: onUpdateMtimes[index] ?? 0 }));
 				partial.sort((a, b) => b.m - a.m);
-				const sortedPaths = partial.map(e => e.p);
+				const sortedPaths = partial.map(entry => entry.p);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
 				const notice = `find timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — increase timeout or narrow pattern`;
 				return buildResult(sortedPaths, { notice, forceTruncated: true });
 			}
 
-			const relativized: string[] = [];
-			for (const match of matches) {
-				throwIfAborted(signal);
-				if (!match.path) {
-					continue;
+			// Merge per-target results: native glob already ranks each target's own
+			// matches by mtime and caps them at the limit, so a global mtime re-sort
+			// plus dedup yields the correct top-N across all roots.
+			const seen = new Set<string>();
+			const merged: Array<{ path: string; mtime: number }> = [];
+			for (const group of perTarget) {
+				for (const entry of group) {
+					if (seen.has(entry.path)) continue;
+					seen.add(entry.path);
+					merged.push(entry);
 				}
-
-				relativized.push(formatMatchPath(match.path, match.fileType));
 			}
-
-			return buildResult(relativized);
+			merged.sort((a, b) => b.mtime - a.mtime);
+			return buildResult(merged.map(entry => entry.path));
 		});
 	}
 }

package/src/tools/index.ts

@@ -117,6 +117,29 @@ export type {
 	DiscoverableToolSource,
 } from "../tool-discovery/tool-index";
 
+/**
+ * A late LSP diagnostics result that arrived after the edit/write tool already
+ * returned. Surfaced to the model and the transcript via
+ * {@link ToolSession.queueDeferredDiagnostics}, batched through the session
+ * yield queue like background-job results.
+ */
+export interface DeferredDiagnosticsEntry {
+	/** Absolute path the diagnostics belong to (the renderer shortens it). */
+	path: string;
+	/** One-line severity summary, e.g. "2 errors". */
+	summary: string;
+	/** Formatted, ready-to-display diagnostic lines. */
+	messages: string[];
+	/** True when any message is error severity. */
+	errored: boolean;
+	/**
+	 * Evaluated at injection time (in the dispatcher's stale check): drop the entry
+	 * when a newer mutation to the same file has superseded it, so the model never
+	 * sees diagnostics for stale content.
+	 */
+	isStale(): boolean;
+}
+
 /** Session context for tool factories */
 export interface ToolSession {
 	/** Current working directory */
@@ -284,6 +307,15 @@ export interface ToolSession {
 
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
+	/** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown
+	 *  in the transcript and delivered to the model at the next yield, like background
+	 *  job results. */
+	queueDeferredDiagnostics?(entry: DeferredDiagnosticsEntry): void;
+	/** Bump and return the session-global mutation counter for `path`. Edit/write
+	 *  tools call this on every file mutation so stale late-diagnostics can be dropped. */
+	bumpFileMutationVersion?(path: string): number;
+	/** Read the current session-global mutation counter for `path` (0 if never mutated). */
+	getFileMutationVersion?(path: string): number;
 	/** Get the active OpenTelemetry config so subagent dispatch can forward
 	 *  the parent's tracer/hooks with the subagent's own identity stamped. */
 	getTelemetry?: () => AgentTelemetryConfig | undefined;

package/src/tools/path-utils.ts

@@ -572,9 +572,14 @@ export interface ResolvedMultiSearchPath {
 	targets?: ResolvedSearchTarget[];
 }
 
-export interface ResolvedMultiFindPattern {
+export interface ResolvedFindTarget {
 	basePath: string;
 	globPattern: string;
+	hasGlob: boolean;
+}
+
+export interface ResolvedMultiFindPattern {
+	targets: ResolvedFindTarget[];
 	scopePath: string;
 }
 
@@ -782,30 +787,22 @@ async function resolveFindPatternItems(
 		return undefined;
 	}
 
-	const parsedItems = await Promise.all(
-		patternItems.map(async item => {
-			const parsedPattern = parseFindPattern(item);
-			const absoluteBasePath = resolveToCwd(parsedPattern.basePath, cwd);
-			const stat = await fs.promises.stat(absoluteBasePath);
-			return { raw: item, parsedPattern, absoluteBasePath, stat };
-		}),
-	);
-
-	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
-	const combinedPatterns = parsedItems.map(item => {
-		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
-		if (item.parsedPattern.hasGlob) {
-			return joinRelativeGlob(relativeBasePath, item.parsedPattern.globPattern);
-		}
-		if (item.stat.isDirectory()) {
-			return joinRelativeGlob(relativeBasePath, "**/*");
-		}
-		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
+	// Each path becomes its own walk root. Collapsing to a shared common ancestor
+	// (and filtering with a brace-union glob) would force the walker to traverse
+	// and stat every unrelated sibling under that ancestor — two paths under
+	// $HOME would scan all of $HOME. The find tool fans these targets out in
+	// parallel instead, so every scan stays bounded to exactly one requested path.
+	const targets = patternItems.map(item => {
+		const parsedPattern = parseFindPattern(item);
+		return {
+			basePath: resolveToCwd(parsedPattern.basePath, cwd),
+			globPattern: parsedPattern.globPattern,
+			hasGlob: parsedPattern.hasGlob,
+		};
 	});
 
 	return {
-		basePath: commonBasePath,
-		globPattern: buildBraceUnion(combinedPatterns) ?? "**/*",
+		targets,
 		scopePath: toScopeDisplay(patternItems, cwd),
 	};
 }

package/src/tools/read.ts

@@ -575,6 +575,8 @@ export interface ReadToolDetails {
 	summary?: { lines: number; elidedSpans: number; elidedLines: number };
 	/** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
 	conflictCount?: number;
+	/** Paths recovered from a delimited read argument; used only by the TUI to render one call as multiple read rows. */
+	displayReadTargets?: string[];
 }
 
 type ReadParams = ReadToolInput;
@@ -670,7 +672,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly loadMode = "essential";
 	readonly description: string;
 	readonly parameters = readSchema;
-	readonly nonAbortable = true;
 	readonly strict = true;
 
 	readonly #autoResizeImages: boolean;
@@ -704,6 +705,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const notice = `Note: interpreted as ${parts.length} paths: ${parts.join(", ")}`;
 		const notes = [notice];
 		const content: Array<TextContent | ImageContent> = [];
+		const displayReadTargets: string[] = [];
 		let pendingText = notice;
 		const flushText = () => {
 			if (pendingText.length === 0) return;
@@ -717,6 +719,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		for (const part of parts) {
 			try {
 				const result = await this.execute("read-delimited-part", { path: part }, signal);
+				displayReadTargets.push(result.details?.suffixResolution?.to ?? part);
 				for (const block of result.content) {
 					if (block.type === "text") {
 						appendText(block.text);
@@ -730,12 +733,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				const message = error instanceof Error ? error.message : String(error);
 				const errorNote = `Could not read ${part}: ${message}`;
 				notes.push(errorNote);
+				displayReadTargets.push(part);
 				appendText(`[${errorNote}]`);
 			}
 		}
 		flushText();
 
-		return toolResult<ReadToolDetails>({ notes }).content(content).done();
+		return toolResult<ReadToolDetails>({ notes, displayReadTargets }).content(content).done();
 	}
 
 	async #resolveArchiveReadPath(readPath: string, signal?: AbortSignal): Promise<ResolvedArchiveReadPath | null> {
@@ -1648,7 +1652,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				throw new ToolError("Multi-range line selectors are not supported for directory listings.");
 			}
 			const { offset, limit } = selToOffsetLimit(parsed);
-			const dirResult = await this.#readDirectory(absolutePath, offset, limit, signal);
+			// Directory listings are deterministic and fast; never abort them mid-scan
+			// (an interrupt would otherwise surface a misleading "Operation aborted").
+			const dirResult = await this.#readDirectory(absolutePath, offset, limit, undefined);
 			if (suffixResolution) {
 				dirResult.details ??= {};
 				dirResult.details.suffixResolution = suffixResolution;
@@ -1815,7 +1821,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						parsed,
 						displayMode,
 						suffixResolution,
-						signal,
+						undefined, // plain-file read: deterministic and fast, never abort mid-read
 					);
 					if (multiResult.bridgeResult) return multiResult.bridgeResult;
 					content = [{ type: "text", text: multiResult.outputText }];
@@ -1874,7 +1880,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						maxLinesToCollect,
 						maxBytesForRead,
 						selectedLineLimit,
-						signal,
+						undefined, // plain-file read: deterministic and fast, never abort mid-read
 					);
 
 					const {
@@ -2368,11 +2374,13 @@ function formatReadPathLink(
 	const plainDisplayPath = options.suffixResolution
 		? shortenPath(options.suffixResolution.to)
 		: shortenPath(basePath || options.resolvedPath || options.fallbackLabel || rawPath);
-	const target = options.resolvedPath ?? options.sourcePath ?? tryResolveInternalUrlSync(basePath);
+	const absoluteInputPath = path.isAbsolute(basePath) ? basePath : undefined;
+	const target =
+		options.resolvedPath ?? options.sourcePath ?? tryResolveInternalUrlSync(basePath) ?? absoluteInputPath;
 	const line = firstReadSelectorLine(split.sel) ?? options.offset;
 	const linkOptions = line !== undefined ? { line } : undefined;
-	const displayPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
-	return `${displayPath}${selectorSuffix}`;
+	const linkedPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
+	return `${linkedPath}${selectorSuffix}`;
 }
 
 export const readToolRenderer = {

package/src/tools/render-utils.ts

@@ -338,6 +338,7 @@ export function formatDiagnostics(
 	expanded: boolean,
 	theme: Theme,
 	getLangIcon: (filePath: string) => string,
+	options?: { title?: string },
 ): string {
 	if (diag.messages.length === 0) return "";
 
@@ -369,7 +370,8 @@ export function formatDiagnostics(
 		? theme.styledSymbol("status.error", "error")
 		: theme.styledSymbol("status.warning", "warning");
 	const summary = sanitizeDiagnosticDisplayText(diag.summary);
-	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${summary})`)}`;
+	const summaryTag = summary ? ` ${theme.fg("dim", `(${summary})`)}` : "";
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", options?.title ?? "Diagnostics")}${summaryTag}`;
 
 	const maxDiags = expanded ? diag.messages.length : 5;
 	let diagsShown = 0;

package/src/tools/renderers.ts

@@ -40,21 +40,6 @@ export 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/ssh.ts

@@ -252,7 +252,6 @@ export const sshToolRenderer = {
 						state: "pending",
 						sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: _options.expanded }) }],
 						width,
-						animate: true,
 					},
 					uiTheme,
 				),