@oh-my-pi/pi-coding-agent 14.1.2 → 14.2.1

package/src/tools/grep.ts

@@ -6,7 +6,6 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { computeLineHash } from "../edit/line-hash";
 import { type ChunkedGrepMatch, describeChunkedGrepMatch } from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
@@ -16,6 +15,8 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
+import { createFileRecorder } from "./file-recorder";
+import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
 	combineSearchGlobs,
@@ -34,13 +35,13 @@ const grepSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "File or directory to search (default: cwd)" })),
 	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern (e.g., '*.js')" })),
 	type: Type.Optional(Type.String({ description: "Filter by file type (e.g., js, py, rust)" })),
-	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search", default: false })),
 	pre: Type.Optional(Type.Number({ description: "Lines of context before matches" })),
 	post: Type.Optional(Type.Number({ description: "Lines of context after matches" })),
 	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching" })),
-	gitignore: Type.Optional(Type.Boolean({ description: "Respect .gitignore files during search (default: true)" })),
-	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 20)" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit (default: 0)" })),
+	gitignore: Type.Optional(Type.Boolean({ description: "Respect .gitignore files during search", default: true })),
+	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches", default: 20 })),
+	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit", default: 0 })),
 });
 
 export type GrepToolInput = Static<typeof grepSchema>;
@@ -123,6 +124,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			};
 			let searchPath: string;
 			let scopePath: string;
+			let exactFilePaths: string[] | undefined;
 			let globFilter = glob ? normalizePathLikeInput(glob) || undefined : undefined;
 			const internalRouter = this.session.internalRouter;
 			if (searchDir?.trim()) {
@@ -141,7 +143,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
 					if (multiSearchPath) {
 						searchPath = multiSearchPath.basePath;
-						globFilter = multiSearchPath.glob;
+						globFilter = multiSearchPath.exactFilePaths ? undefined : multiSearchPath.glob;
+						exactFilePaths = multiSearchPath.exactFilePaths;
 						scopePath = multiSearchPath.scopePath;
 					} else {
 						const parsedPath = parseSearchPath(rawPath);
@@ -173,26 +176,61 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			// Run grep
 			let result: GrepResult;
 			try {
-				result = await grep(
-					{
-						pattern: normalizedPattern,
-						path: searchPath,
-						glob: globFilter,
-						type: type?.trim() || undefined,
-						ignoreCase,
-						multiline: effectiveMultiline,
-						hidden: true,
-						gitignore: useGitignore,
-						cache: false,
-						maxCount: internalLimit,
-						offset: normalizedOffset > 0 ? normalizedOffset : undefined,
-						contextBefore: normalizedContextBefore,
-						contextAfter: normalizedContextAfter,
-						maxColumns: DEFAULT_MAX_COLUMN,
-						mode: effectiveOutputMode,
-					},
-					undefined,
-				);
+				if (exactFilePaths) {
+					const matches: GrepMatch[] = [];
+					let limitReached = false;
+					for (const exactFilePath of exactFilePaths) {
+						const fileResult = await grep(
+							{
+								pattern: normalizedPattern,
+								path: exactFilePath,
+								type: type?.trim() || undefined,
+								ignoreCase,
+								multiline: effectiveMultiline,
+								hidden: true,
+								gitignore: useGitignore,
+								cache: false,
+								contextBefore: normalizedContextBefore,
+								contextAfter: normalizedContextAfter,
+								maxColumns: DEFAULT_MAX_COLUMN,
+								mode: effectiveOutputMode,
+							},
+							undefined,
+						);
+						limitReached = limitReached || Boolean(fileResult.limitReached);
+						const relativeFilePath = path.relative(searchPath, exactFilePath).replace(/\\/g, "/");
+						matches.push(...fileResult.matches.map(match => ({ ...match, path: relativeFilePath })));
+					}
+					const offsetMatches = matches.slice(normalizedOffset);
+					result = {
+						matches: offsetMatches,
+						totalMatches: offsetMatches.length,
+						filesWithMatches: new Set(offsetMatches.map(match => match.path)).size,
+						filesSearched: exactFilePaths.length,
+						limitReached,
+					};
+				} else {
+					result = await grep(
+						{
+							pattern: normalizedPattern,
+							path: searchPath,
+							glob: globFilter,
+							type: type?.trim() || undefined,
+							ignoreCase,
+							multiline: effectiveMultiline,
+							hidden: true,
+							gitignore: useGitignore,
+							cache: false,
+							maxCount: internalLimit,
+							offset: normalizedOffset > 0 ? normalizedOffset : undefined,
+							contextBefore: normalizedContextBefore,
+							contextAfter: normalizedContextAfter,
+							maxColumns: DEFAULT_MAX_COLUMN,
+							mode: effectiveOutputMode,
+						},
+						undefined,
+					);
+				}
 			} catch (err) {
 				if (err instanceof Error && err.message.startsWith("regex parse error")) {
 					throw new ToolError(err.message);
@@ -243,15 +281,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				? roundRobinSelect(result.matches, effectiveLimit)
 				: result.matches.slice(0, effectiveLimit);
 			const matchLimitReached = result.matches.length > effectiveLimit;
-			const files = new Set<string>();
-			const fileList: string[] = [];
+			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
-			const recordFile = (relativePath: string) => {
-				if (!files.has(relativePath)) {
-					files.add(relativePath);
-					fileList.push(relativePath);
-				}
-			};
 			if (selectedMatches.length === 0) {
 				const details: GrepToolDetails = {
 					scopePath,
@@ -264,6 +295,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 			const outputLines: string[] = [];
 			let linesTruncated = false;
+			const hasContextLines = normalizedContextBefore > 0 || normalizedContextAfter > 0;
 			const matchesByFile = new Map<string, GrepMatch[]>();
 			for (const match of selectedMatches) {
 				const relativePath = formatPath(match.path);
@@ -295,10 +327,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					}
 					chunkMatchesByFile.get(match.displayPath)!.push(match);
 				}
-				const renderChunkedMatchesForFile = (relativePath: string) => {
+				const renderChunkedMatchesForFile = (relativePath: string): string[] => {
+					const renderedLines: string[] = [];
 					const fileMatches = chunkMatchesByFile.get(relativePath) ?? [];
 					if (fileMatches.length === 0) {
-						return;
+						return renderedLines;
 					}
 					const lineWidth = fileMatches[0]?.fileLineCount.toString().length ?? 1;
 					const matchesByChunk = new Map<string, ChunkedGrepMatch[]>();
@@ -316,13 +349,14 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 							const anchor = chunkChecksum
 								? `${dashes}@${chunkPath}#${chunkChecksum}`
 								: `${dashes}@${chunkPath}`;
-							outputLines.push(anchor);
+							renderedLines.push(anchor);
 						}
 						for (const match of chunkMatches) {
-							outputLines.push(`    ${match.lineNumber.toString().padStart(lineWidth, " ")} |${match.line}`);
+							renderedLines.push(`    ${match.lineNumber.toString().padStart(lineWidth, " ")} |${match.line}`);
 							fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 						}
 					}
+					return renderedLines;
 				};
 				if (isDirectory) {
 					const filesByDirectory = new Map<string, string[]>();
@@ -336,26 +370,32 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					for (const [directory, directoryFiles] of filesByDirectory) {
 						if (directory === ".") {
 							for (const relativePath of directoryFiles) {
+								const renderedLines = renderChunkedMatchesForFile(relativePath);
+								if (renderedLines.length === 0) continue;
 								if (outputLines.length > 0) {
 									outputLines.push("");
 								}
 								outputLines.push(`# ${path.basename(relativePath)}`);
-								renderChunkedMatchesForFile(relativePath);
+								outputLines.push(...renderedLines);
 							}
 							continue;
 						}
+						const renderedFiles = directoryFiles
+							.map(relativePath => ({ relativePath, lines: renderChunkedMatchesForFile(relativePath) }))
+							.filter(file => file.lines.length > 0);
+						if (renderedFiles.length === 0) continue;
 						if (outputLines.length > 0) {
 							outputLines.push("");
 						}
 						outputLines.push(`# ${directory}`);
-						for (const relativePath of directoryFiles) {
+						for (const { relativePath, lines } of renderedFiles) {
 							outputLines.push(`## └─ ${path.basename(relativePath)}`);
-							renderChunkedMatchesForFile(relativePath);
+							outputLines.push(...lines);
 						}
 					}
 				} else {
 					for (const relativePath of fileList) {
-						renderChunkedMatchesForFile(relativePath);
+						outputLines.push(...renderChunkedMatchesForFile(relativePath));
 					}
 				}
 				const rawOutput = outputLines.join("\n");
@@ -386,7 +426,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 				return resultBuilder.done();
 			}
-			const renderMatchesForFile = (relativePath: string) => {
+			const renderMatchesForFile = (relativePath: string): string[] => {
+				const renderedLines: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
 				for (const match of fileMatches) {
 					const lineNumbers: number[] = [match.lineNumber];
@@ -401,31 +442,25 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						}
 					}
 					const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
-					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
-						const separator = isMatch ? ":" : "-";
-						if (useHashLines) {
-							const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
-							return `${ref}${separator}${line}`;
-						}
-						const padded = lineNumber.toString().padStart(lineWidth, " ");
-						return `${padded}${separator}${line}`;
-					};
+					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string =>
+						formatMatchLine(lineNumber, line, isMatch, { useHashLines, lineWidth });
 					if (match.contextBefore) {
 						for (const ctx of match.contextBefore) {
-							outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
+							renderedLines.push(formatLine(ctx.lineNumber, ctx.line, false));
 						}
 					}
-					outputLines.push(formatLine(match.lineNumber, match.line, true));
+					renderedLines.push(formatLine(match.lineNumber, match.line, true));
 					if (match.truncated) {
 						linesTruncated = true;
 					}
 					if (match.contextAfter) {
 						for (const ctx of match.contextAfter) {
-							outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
+							renderedLines.push(formatLine(ctx.lineNumber, ctx.line, false));
 						}
 					}
 					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 				}
+				return renderedLines;
 			};
 			if (isDirectory) {
 				const filesByDirectory = new Map<string, string[]>();
@@ -439,28 +474,37 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				for (const [directory, directoryFiles] of filesByDirectory) {
 					if (directory === ".") {
 						for (const relativePath of directoryFiles) {
+							const renderedLines = renderMatchesForFile(relativePath);
+							if (renderedLines.length === 0) continue;
 							if (outputLines.length > 0) {
 								outputLines.push("");
 							}
 							outputLines.push(`# ${path.basename(relativePath)}`);
-							renderMatchesForFile(relativePath);
+							outputLines.push(...renderedLines);
 						}
 						continue;
 					}
+					const renderedFiles = directoryFiles
+						.map(relativePath => ({ relativePath, lines: renderMatchesForFile(relativePath) }))
+						.filter(file => file.lines.length > 0);
+					if (renderedFiles.length === 0) continue;
 					if (outputLines.length > 0) {
 						outputLines.push("");
 					}
 					outputLines.push(`# ${directory}`);
-					for (const relativePath of directoryFiles) {
+					for (const { relativePath, lines } of renderedFiles) {
 						outputLines.push(`## └─ ${path.basename(relativePath)}`);
-						renderMatchesForFile(relativePath);
+						outputLines.push(...lines);
 					}
 				}
 			} else {
 				for (const relativePath of fileList) {
-					renderMatchesForFile(relativePath);
+					outputLines.push(...renderMatchesForFile(relativePath));
 				}
 			}
+			if (hasContextLines && outputLines.length > 0) {
+				outputLines.unshift("[grep] match lines use ':'; context lines use '-'.");
+			}
 			const rawOutput = outputLines.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 			const output = truncation.content;

package/src/tools/jtd-to-json-schema.ts

@@ -197,3 +197,19 @@ function normalizeMixedSchemaNode(schema: unknown): unknown {
 export function jtdToJsonSchema(schema: unknown): unknown {
 	return normalizeMixedSchemaNode(schema);
 }
+
+/**
+ * Normalize a schema input that may be a JSON string, object, or null/undefined.
+ * Returns { normalized } on success, or { error } if JSON parsing fails.
+ */
+export function normalizeSchema(schema: unknown): { normalized?: unknown; error?: string } {
+	if (schema === undefined || schema === null) return {};
+	if (typeof schema === "string") {
+		try {
+			return { normalized: JSON.parse(schema) };
+		} catch (err) {
+			return { error: err instanceof Error ? err.message : String(err) };
+		}
+	}
+	return { normalized: schema };
+}

package/src/tools/match-line-format.ts

@@ -0,0 +1,20 @@
+import { computeLineHash } from "../edit/line-hash";
+
+/**
+ * Format a single line of match output for grep/ast-grep style results.
+ * Uses hashline refs when hashlines are enabled, otherwise pads the number.
+ */
+export function formatMatchLine(
+	lineNumber: number,
+	line: string,
+	isMatch: boolean,
+	options: { useHashLines: boolean; lineWidth: number },
+): string {
+	const separator = isMatch ? ":" : "-";
+	if (options.useHashLines) {
+		const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
+		return `${ref}${separator}${line}`;
+	}
+	const padded = lineNumber.toString().padStart(options.lineWidth, " ");
+	return `${padded}${separator}${line}`;
+}

package/src/tools/path-utils.ts

@@ -74,7 +74,7 @@ function normalizeAtPrefix(filePath: string): string {
 		withoutAt.startsWith("artifact://") ||
 		withoutAt.startsWith("skill://") ||
 		withoutAt.startsWith("rule://") ||
-		withoutAt.startsWith("local://") ||
+		withoutAt.startsWith("local:") ||
 		withoutAt.startsWith("mcp://")
 	) {
 		return withoutAt;
@@ -110,6 +110,29 @@ export function expandPath(filePath: string): string {
 	return expandTilde(normalized);
 }
 
+function assertNotInternalUrl(expanded: string, original: string): void {
+	for (const prefix of TOP_LEVEL_INTERNAL_URL_PREFIXES) {
+		if (expanded.startsWith(prefix)) {
+			throw new Error(
+				`Path "${original}" uses internal scheme "${prefix}" and must be resolved through the proper protocol handler, not as a filesystem path.`,
+			);
+		}
+	}
+}
+
+export function normalizeLocalScheme(filePath: string): string {
+	return filePath.replace(/^(local:)\/(?!\/)/, "$1//");
+}
+
+export function isInternalUrlPath(filePath: string): boolean {
+	const normalized = normalizeLocalScheme(filePath);
+	const expandedAndNormalized = normalizeLocalScheme(expandPath(normalized));
+	for (const prefix of TOP_LEVEL_INTERNAL_URL_PREFIXES) {
+		if (expandedAndNormalized.startsWith(prefix)) return true;
+	}
+	return false;
+}
+
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
@@ -119,7 +142,12 @@ export function expandPath(filePath: string): string {
  * filesystem root is almost never what they intended.
  */
 export function resolveToCwd(filePath: string, cwd: string): string {
-	const expanded = expandPath(filePath);
+	const normalized = normalizeLocalScheme(filePath);
+	const expanded = expandPath(normalized);
+	const expandedAndNormalized = normalizeLocalScheme(expanded);
+
+	assertNotInternalUrl(expandedAndNormalized, normalized);
+
 	if (/^\/+$/.test(expanded)) {
 		return cwd;
 	}
@@ -165,6 +193,7 @@ export interface ResolvedMultiSearchPath {
 	basePath: string;
 	glob?: string;
 	scopePath: string;
+	exactFilePaths?: string[];
 }
 
 export interface ResolvedMultiFindPattern {
@@ -410,6 +439,28 @@ async function areDelimitedTokensResolvable(
 	return true;
 }
 
+async function filterResolvableTokens(
+	tokens: string[],
+	cwd: string,
+	parseBasePath: (value: string) => string,
+): Promise<string[]> {
+	const out: string[] = [];
+	for (const token of tokens) {
+		if (TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix))) continue;
+		const basePath = parseBasePath(token);
+		const resolvedBasePath = resolveToCwd(basePath, cwd);
+		if (await pathExists(resolvedBasePath)) {
+			out.push(token);
+			continue;
+		}
+		const resolvedExactPath = resolveToCwd(token, cwd);
+		if (await pathExists(resolvedExactPath)) {
+			out.push(token);
+		}
+	}
+	return out;
+}
+
 async function splitDelimitedSearchInput(
 	rawInput: string,
 	cwd: string,
@@ -424,8 +475,11 @@ async function splitDelimitedSearchInput(
 	}
 
 	const commaSeparated = splitTopLevel(trimmed, "comma");
-	if (commaSeparated.length > 1 && (await areDelimitedTokensResolvable(commaSeparated, cwd, parseBasePath, true))) {
-		return [...new Set(commaSeparated)];
+	if (commaSeparated.length > 1) {
+		const resolvable = await filterResolvableTokens(commaSeparated, cwd, parseBasePath);
+		if (resolvable.length >= 1) {
+			return [...new Set(resolvable)];
+		}
 	}
 
 	const whitespaceSeparated = splitTopLevel(trimmed, "whitespace");
@@ -445,7 +499,7 @@ export async function resolveMultiSearchPath(
 	suffixGlob?: string,
 ): Promise<ResolvedMultiSearchPath | undefined> {
 	const pathItems = await splitDelimitedSearchInput(rawPath, cwd, value => parseSearchPath(value).basePath);
-	if (!pathItems || pathItems.length <= 1) {
+	if (!pathItems || pathItems.length < 1) {
 		return undefined;
 	}
 
@@ -458,6 +512,7 @@ export async function resolveMultiSearchPath(
 		}),
 	);
 
+	const allExactFiles = !suffixGlob && parsedItems.every(item => !item.parsedPath.glob && item.stat.isFile());
 	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
 	const combinedPatterns = parsedItems.map(item => {
 		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
@@ -479,6 +534,7 @@ export async function resolveMultiSearchPath(
 		basePath: commonBasePath,
 		glob: buildBraceUnion(combinedPatterns),
 		scopePath: toScopeDisplay(pathItems),
+		exactFilePaths: allExactFiles ? parsedItems.map(item => item.absoluteBasePath) : undefined,
 	};
 }
 

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

@@ -1,19 +1,20 @@
 import { resolveLocalUrlToPath } from "../internal-urls";
 import type { ToolSession } from ".";
-import { resolveToCwd } from "./path-utils";
+import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
 import { ToolError } from "./tool-errors";
 
-const LOCAL_URL_PREFIX = "local://";
+const LOCAL_SCHEME_PREFIX = "local:";
 
 export function resolvePlanPath(session: ToolSession, targetPath: string): string {
-	if (targetPath.startsWith(LOCAL_URL_PREFIX)) {
-		return resolveLocalUrlToPath(targetPath, {
+	const normalized = normalizeLocalScheme(targetPath);
+	if (normalized.startsWith(LOCAL_SCHEME_PREFIX)) {
+		return resolveLocalUrlToPath(normalized, {
 			getArtifactsDir: session.getArtifactsDir,
 			getSessionId: session.getSessionId,
 		});
 	}
 
-	return resolveToCwd(targetPath, session.cwd);
+	return resolveToCwd(normalized, session.cwd);
 }
 
 export function enforcePlanModeWrite(

package/src/tools/python.ts

@@ -52,7 +52,7 @@ export const pythonSchema = Type.Object({
 		}),
 		{ description: "Cells to execute sequentially in persistent kernel" },
 	),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 30)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 30 })),
 	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
 	reset: Type.Optional(Type.Boolean({ description: "Restart kernel before execution" })),
 });

package/src/tools/read.ts

@@ -371,7 +371,7 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 const readSchema = Type.Object({
 	path: Type.String({ description: "Path or URL to read" }),
 	sel: Type.Optional(Type.String({ description: "Selector: chunk path, L10-L50, or raw" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 20)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 20 })),
 });
 
 export type ReadToolInput = Static<typeof readSchema>;

package/src/tools/render-utils.ts

@@ -4,8 +4,10 @@
  * Provides consistent formatting, truncation, and display patterns across all
  * tool renderers to ensure a unified TUI experience.
  */
+
 import * as os from "node:os";
 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 { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { pluralize } from "@oh-my-pi/pi-utils";
@@ -210,6 +212,10 @@ interface ParsedDiagnostic {
 	code?: string;
 }
 
+function sanitizeDiagnosticDisplayText(text: string): string {
+	return replaceTabs(text);
+}
+
 function getSeverityRank(severity: ParsedDiagnostic["severity"]): number {
 	switch (severity) {
 		case "error":
@@ -227,13 +233,13 @@ function parseDiagnosticMessage(msg: string): ParsedDiagnostic | null {
 	const match = msg.match(/^(.+?):(\d+):(\d+)\s+\[(\w+)\]\s+(?:\[([^\]]+)\]\s+)?(.+?)(?:\s+\(([^)]+)\))?$/);
 	if (!match) return null;
 	return {
-		filePath: match[1],
+		filePath: sanitizeDiagnosticDisplayText(match[1]),
 		line: parseInt(match[2], 10),
 		col: parseInt(match[3], 10),
 		severity: match[4] as ParsedDiagnostic["severity"],
-		source: match[5],
-		message: match[6],
-		code: match[7],
+		source: match[5] ? sanitizeDiagnosticDisplayText(match[5]) : undefined,
+		message: sanitizeDiagnosticDisplayText(match[6]),
+		code: match[7] ? sanitizeDiagnosticDisplayText(match[7]) : undefined,
 	};
 }
 
@@ -255,7 +261,7 @@ export function formatDiagnostics(
 			existing.push(parsed);
 			byFile.set(parsed.filePath, existing);
 		} else {
-			unparsed.push(msg);
+			unparsed.push(sanitizeDiagnosticDisplayText(msg));
 		}
 	}
 
@@ -272,7 +278,8 @@ export function formatDiagnostics(
 	const headerIcon = diag.errored
 		? theme.styledSymbol("status.error", "error")
 		: theme.styledSymbol("status.warning", "warning");
-	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${diag.summary})`)}`;
+	const summary = sanitizeDiagnosticDisplayText(diag.summary);
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${summary})`)}`;
 
 	const maxDiags = expanded ? diag.messages.length : 5;
 	let diagsShown = 0;
@@ -616,3 +623,28 @@ export function formatParseErrors(errors: string[]): string[] {
 			: "Parse issues:";
 	return [header, ...capped.map(err => `- ${err}`)];
 }
+
+// =============================================================================
+// LSP Batching
+// =============================================================================
+
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+export interface LspBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some(call => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}

package/src/tools/renderers.ts

@@ -51,6 +51,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
+	apply_patch: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
 	grep: grepToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,

package/src/tools/resolve.ts

@@ -23,6 +23,7 @@ export interface ResolveToolDetails {
 	reason: string;
 	sourceToolName?: string;
 	label?: string;
+	sourceResultDetails?: unknown;
 }
 
 function resolveReasonPreview(reason?: string): string | undefined {
@@ -67,14 +68,21 @@ export function queueResolveHandler(
 		onRejected: () => "requeue",
 		onInvoked: async (input: unknown) => {
 			const params = input as ResolveParams;
+			const withResolveDetails = (result: AgentToolResult<unknown>): AgentToolResult<ResolveToolDetails> => ({
+				...result,
+				details: {
+					...detailsFor(params),
+					...(result.details != null ? { sourceResultDetails: result.details } : {}),
+				},
+			});
 			if (params.action === "apply") {
 				const result = await options.apply(params.reason);
-				return { ...result, details: detailsFor(params) };
+				return withResolveDetails(result);
 			}
 			if (params.action === "discard" && options.reject != null) {
 				const result = await options.reject(params.reason);
 				if (result != null) {
-					return { ...result, details: detailsFor(params) };
+					return withResolveDetails(result);
 				}
 			}
 			return {
@@ -154,9 +162,10 @@ export const resolveToolRenderer = {
 		const reason = replaceTabs(details?.reason?.trim() || "No reason provided");
 		const action = details?.action ?? "apply";
 		const isApply = action === "apply" && !result.isError;
+		const isFailedApply = action === "apply" && result.isError;
 		const bgColor = result.isError ? "error" : isApply ? "success" : "warning";
 		const icon = isApply ? uiTheme.status.success : uiTheme.status.error;
-		const verb = isApply ? "Accept" : "Discard";
+		const verb = isApply ? "Accept" : isFailedApply ? "Failed" : "Discard";
 		const separator = ": ";
 		const separatorIndex = label.indexOf(separator);
 		const sourceLabel = separatorIndex > 0 ? label.slice(0, separatorIndex).trim() : undefined;