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

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,
 				),

package/src/tools/todo.ts

@@ -927,6 +927,7 @@ export const todoToolRenderer = {
 				sections: bodyLines.length > 0 ? [{ lines: bodyLines }] : [],
 				state: options.isPartial ? "pending" : "success",
 				borderColor: "borderMuted",
+				applyBg: false,
 				width,
 			};
 		});

package/src/tools/write.ts

@@ -277,7 +277,6 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	readonly label = "Write";
 	readonly description: string;
 	readonly parameters = writeSchema;
-	readonly nonAbortable = true;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
 	readonly loadMode = "discoverable";
@@ -582,6 +581,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		const batchRequest = getLspBatchRequest(context?.toolCall);
 		const diagnostics = await this.#writethrough(absolutePath, newContent, signal, undefined, batchRequest);
 		invalidateFsScanAfterWrite(absolutePath);
+		this.session.bumpFileMutationVersion?.(absolutePath);
 		this.session.fileSnapshotStore?.invalidate(absolutePath);
 		this.session.conflictHistory?.invalidate(entry.id);
 
@@ -707,6 +707,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			const diagnostics = await this.#writethrough(absolutePath, text, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
+			this.session.bumpFileMutationVersion?.(absolutePath);
 			this.session.fileSnapshotStore?.invalidate(absolutePath);
 			for (const entry of fileEntries) history.invalidate(entry.id);
 			const header = maybeWriteSnapshotHeader(this.session, absolutePath, text);
@@ -886,6 +887,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
+			this.session.bumpFileMutationVersion?.(absolutePath);
 			const madeExecutable = await maybeMarkExecutableForShebang(absolutePath, cleanContent);
 
 			const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
@@ -1039,17 +1041,6 @@ export const writeToolRenderer = {
 		});
 	},
 
-	// Only the expanded (Ctrl+O) preview is append-only: it renders the whole
-	// content top-anchored, so streamed chunks only append rows at the bottom.
-	// The collapsed preview slides a bounded tail window (`formatStreamingContent`
-	// with `WRITE_STREAMING_PREVIEW_LINES`) whose visible rows re-layout as the
-	// window moves — not append-only, but it never overflows the viewport, so its
-	// head is never at risk of being dropped regardless. `write` has no partial
-	// result (content streams as args), so `result` is ignored here.
-	isStreamingPreviewAppendOnly(args: WriteRenderArgs, options: RenderResultOptions, _result?: unknown): boolean {
-		return Boolean(options?.expanded && args.content);
-	},
-
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
 		options: RenderResultOptions,

package/src/tui/code-cell.ts

@@ -32,8 +32,6 @@ export interface CodeCellOptions {
 	 */
 	codeTail?: boolean;
 	expanded?: boolean;
-	/** Animate the cell border with a sweeping segment while pending/running. */
-	animate?: boolean;
 	width: number;
 }
 
@@ -147,10 +145,7 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
 	}
 
-	return renderOutputBlock(
-		{ header: title, headerMeta: meta, state, sections, width, animate: options.animate },
-		theme,
-	);
+	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
 }
 
 export interface MarkdownCellOptions {