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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.2.0",
+	"version": "14.2.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "14.2.0",
-		"@oh-my-pi/pi-agent-core": "14.2.0",
-		"@oh-my-pi/pi-ai": "14.2.0",
-		"@oh-my-pi/pi-natives": "14.2.0",
-		"@oh-my-pi/pi-tui": "14.2.0",
-		"@oh-my-pi/pi-utils": "14.2.0",
+		"@oh-my-pi/omp-stats": "14.2.1",
+		"@oh-my-pi/pi-agent-core": "14.2.1",
+		"@oh-my-pi/pi-ai": "14.2.1",
+		"@oh-my-pi/pi-natives": "14.2.1",
+		"@oh-my-pi/pi-tui": "14.2.1",
+		"@oh-my-pi/pi-utils": "14.2.1",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/dap/session.ts

@@ -1075,11 +1075,17 @@ export class DapSessionManager {
 	 * MUST be called before the command that triggers the event.
 	 */
 	#prepareStopOutcome(session: DapSession, signal?: AbortSignal, timeoutMs: number = 30_000): Promise<unknown> {
-		return Promise.race([
+		const promises = [
 			session.client.waitForEvent("stopped", undefined, signal, timeoutMs),
 			session.client.waitForEvent("terminated", undefined, signal, timeoutMs),
 			session.client.waitForEvent("exited", undefined, signal, timeoutMs),
-		]);
+		];
+		// Promise.race leaves the losing waiters pending; their timeouts would
+		// otherwise surface as unhandled rejections once they fire.
+		for (const p of promises) {
+			p.catch(() => {});
+		}
+		return Promise.race(promises);
 	}
 
 	/**

package/src/edit/index.ts

@@ -322,7 +322,8 @@ export class EditTool implements AgentTool<TInput> {
 						chunkAutoIndent: resolveChunkAutoIndent(),
 					}),
 				parameters: chunkEditParamsSchema,
-				invalidParamsMessage: "Invalid edit parameters for chunk mode.",
+				invalidParamsMessage:
+					"Invalid edit parameters for chunk mode. Expected `{ edits: [{ path: 'file:selector', ...op }, ...] }` with at least one edit. Each edit needs a `path`; supply one of `write` (string content; pass an empty string or omit it together with `replace`/`insert` to delete the chunk), `replace: { old, new }`, or `insert: { loc, body }`.",
 				validate: isChunkParams,
 				execute: (
 					tool: EditTool,

package/src/edit/modes/chunk.ts

@@ -549,8 +549,12 @@ export function isChunkParams(params: unknown): params is ChunkParams {
 		return false;
 	}
 	const first = params.edits[0];
-	if (typeof first !== "object" || first === null || !("path" in first)) return false;
-	return "write" in first || "replace" in first || "insert" in first;
+	// Accept a bare `{ path }` entry: it is interpreted downstream as a chunk
+	// delete. Some providers strip `null` values from tool-call JSON, so a
+	// documented `{ path, write: null }` delete can arrive here as just
+	// `{ path }`. Rejecting that surfaced as a misleading
+	// "Invalid edit parameters for chunk mode." error.
+	return typeof first === "object" && first !== null && "path" in first;
 }
 
 /** Auto-correct indentation for content targeting a body region (`~`) when autoIndent is on.

package/src/lsp/client.ts

@@ -211,11 +211,19 @@ async function writeMessage(
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
 ): Promise<void> {
 	const content = JSON.stringify(message);
-	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
-	sink.write(content);
+	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
 	await sink.flush();
 }
 
+function queueWriteMessage(
+	client: LspClient,
+	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
+): Promise<void> {
+	const write = client.writeQueue.catch(() => {}).then(() => writeMessage(client.proc.stdin, message));
+	client.writeQueue = write.catch(() => {});
+	return write;
+}
+
 // =============================================================================
 // Message Reader
 // =============================================================================
@@ -382,7 +390,7 @@ async function sendResponse(
 	};
 
 	try {
-		await writeMessage(client.proc.stdin, response);
+		await queueWriteMessage(client, response);
 	} catch (err) {
 		logger.error("LSP failed to respond.", { method, error: String(err) });
 	}
@@ -461,6 +469,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			messageBuffer: new Uint8Array(0),
 			isReading: false,
 			lastActivity: Date.now(),
+			writeQueue: Promise.resolve(),
 			activeProgressTokens: new Set(),
 			projectLoaded,
 			resolveProjectLoaded,
@@ -848,7 +857,7 @@ export async function sendRequest(
 	});
 
 	// Write request
-	writeMessage(client.proc.stdin, request).catch(err => {
+	queueWriteMessage(client, request).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -868,7 +877,7 @@ export async function sendNotification(client: LspClient, method: string, params
 	};
 
 	client.lastActivity = Date.now();
-	await writeMessage(client.proc.stdin, notification);
+	await queueWriteMessage(client, notification);
 }
 
 /**

package/src/lsp/index.ts

@@ -40,6 +40,7 @@ import {
 	type LspParams,
 	type LspToolDetails,
 	lspSchema,
+	type Position,
 	type PublishedDiagnostics,
 	type ServerConfig,
 	type SymbolInformation,
@@ -262,6 +263,10 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 	return servers.length > 0 ? servers[0] : null;
 }
 
+function isProjectAwareLspServer(serverConfig: ServerConfig): boolean {
+	return !serverConfig.createClient && !serverConfig.isLinter;
+}
+
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
@@ -278,6 +283,21 @@ function limitDiagnosticMessages(messages: string[]): string[] {
 const LOCATION_CONTEXT_LINES = 1;
 const REFERENCE_CONTEXT_LIMIT = 50;
 
+const REFERENCES_RETRY_COUNT = 2;
+const REFERENCES_RETRY_DELAY_MS = 250;
+
+function comparePosition(a: Position, b: Position): number {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+
+function rangeContainsPosition(range: Location["range"], position: Position): boolean {
+	return comparePosition(range.start, position) <= 0 && comparePosition(position, range.end) <= 0;
+}
+
+function isOnlyQueriedDeclaration(locations: Location[], uri: string, position: Position): boolean {
+	return locations.length === 1 && locations[0]?.uri === uri && rangeContainsPosition(locations[0].range, position);
+}
+
 function normalizeLocationResult(result: Location | Location[] | LocationLink | LocationLink[] | null): Location[] {
 	if (!result) return [];
 	const raw = Array.isArray(result) ? result : [result];
@@ -560,6 +580,10 @@ async function getDiagnosticsForFile(
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 			throwIfAborted(signal);
+			if (isProjectAwareLspServer(serverConfig)) {
+				await waitForProjectLoaded(client, signal);
+				throwIfAborted(signal);
+			}
 			// Content already synced + didSave sent, wait for fresh diagnostics
 			const minVersion = minVersions?.get(serverName);
 			const expectedDocumentVersion = expectedDocumentVersions?.get(serverName);
@@ -1220,6 +1244,10 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 							continue;
 						}
 						const client = await getOrCreateClient(serverConfig, this.session.cwd);
+						if (isProjectAwareLspServer(serverConfig)) {
+							await waitForProjectLoaded(client, signal);
+							throwIfAborted(signal);
+						}
 						const minVersion = client.diagnosticsVersion;
 						await refreshFile(client, resolved, signal);
 						const expectedDocumentVersion = client.openFiles.get(uri)?.version;
@@ -1512,16 +1540,31 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					break;
 				}
 				case "references": {
-					const result = (await sendRequest(
-						client,
-						"textDocument/references",
-						{
-							textDocument: { uri },
-							position,
-							context: { includeDeclaration: true },
-						},
-						signal,
-					)) as Location[] | null;
+					let result: Location[] | null = null;
+					for (let attempt = 0; attempt <= REFERENCES_RETRY_COUNT; attempt++) {
+						result = (await sendRequest(
+							client,
+							"textDocument/references",
+							{
+								textDocument: { uri },
+								position,
+								context: { includeDeclaration: true },
+							},
+							signal,
+						)) as Location[] | null;
+
+						const locations = result ?? [];
+						if (!isProjectAwareLspServer(serverConfig) || attempt === REFERENCES_RETRY_COUNT) {
+							break;
+						}
+						if (locations.length > 0 && !isOnlyQueriedDeclaration(locations, uri, position)) {
+							break;
+						}
+
+						await waitForProjectLoaded(client, signal);
+						throwIfAborted(signal);
+						await untilAborted(signal, () => Bun.sleep(REFERENCES_RETRY_DELAY_MS));
+					}
 
 					if (!result || result.length === 0) {
 						output = "No references found";

package/src/lsp/types.ts

@@ -411,6 +411,8 @@ export interface LspClient {
 	isReading: boolean;
 	serverCapabilities?: LspServerCapabilities;
 	lastActivity: number;
+	/** Serializes outbound JSON-RPC writes to the server process. */
+	writeQueue: Promise<void>;
 	/** Tracks active work-done progress tokens from the server */
 	activeProgressTokens: Set<string | number>;
 	/** Resolves when the server's initial project loading completes (or after timeout) */

package/src/prompts/tools/ast-grep.md

@@ -10,6 +10,7 @@ Performs structural code search using AST matching via native ast-grep.
 - Metavariable names are UPPERCASE and must be the whole AST node — partial-text like `prefix$VAR`, `"hello $NAME"`, or `a $OP b` does NOT work; match the whole node instead
 - When the same metavariable appears twice, both occurrences **MUST** match identical code (`$A == $A` matches `x == x`, not `x == y`)
 - Patterns **MUST** parse as a single valid AST node for the target language. For method fragments or body snippets that don't parse standalone, wrap in valid context (e.g. `class $_ { … }`) and set `sel` to target the inner node — results return for the selected node, not the outer wrapper. If ast-grep reports `Multiple AST nodes are detected`, the pattern isn't a single parseable node — wrap and use `sel`
+- C++ qualified calls used as expression statements need the statement semicolon in the pattern: use `ns::doThing($ARG);`, `$CALLEE($ARG)`, or wrap a statement snippet and select `call_expression`. Without `;`, tree-sitter-cpp may parse `ns::doThing($ARG)` as declaration-like syntax and return no matches
 - For TS declarations/methods, tolerate unknown annotations: `async function $NAME($$$ARGS): $_ { $$$BODY }` or `class $_ { method($ARG: $_): $_ { $$$BODY } }`
 - Declaration forms are structurally distinct — top-level `function foo`, class method `foo()`, and `const foo = () => {}` are different AST shapes; search the right form before concluding absence
 - Loosest existence check: `pat: ["executeBash"]` with `sel: "identifier"`

package/src/tools/ast-edit.ts

@@ -294,6 +294,23 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 							failOnParseError: false,
 						});
 						const dedupedApplyParseErrors = dedupeParseErrors(applyResult.parseErrors);
+						const { record: recordAppliedFile, list: appliedFileList } = createFileRecorder();
+						const appliedFileReplacementCounts = new Map<string, number>();
+						for (const fileChange of applyResult.fileChanges) {
+							const relativePath = formatPath(fileChange.path);
+							recordAppliedFile(relativePath);
+							appliedFileReplacementCounts.set(
+								relativePath,
+								(appliedFileReplacementCounts.get(relativePath) ?? 0) + fileChange.count,
+							);
+						}
+						for (const change of applyResult.changes) {
+							recordAppliedFile(formatPath(change.path));
+						}
+						const appliedFileReplacements = appliedFileList.map(filePath => ({
+							path: filePath,
+							count: appliedFileReplacementCounts.get(filePath) ?? 0,
+						}));
 						const appliedDetails: AstEditToolDetails = {
 							totalReplacements: applyResult.totalReplacements,
 							filesTouched: applyResult.filesTouched,
@@ -302,9 +319,27 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 							limitReached: applyResult.limitReached,
 							...(dedupedApplyParseErrors.length > 0 ? { parseErrors: dedupedApplyParseErrors } : {}),
 							scopePath,
-							files: fileList,
-							fileReplacements,
+							files: appliedFileList,
+							fileReplacements: appliedFileReplacements,
 						};
+						const stalePreview =
+							applyResult.totalReplacements !== result.totalReplacements ||
+							applyResult.filesTouched !== result.filesTouched ||
+							fileList.some(
+								filePath => appliedFileReplacementCounts.get(filePath) !== fileReplacementCounts.get(filePath),
+							) ||
+							appliedFileList.some(
+								filePath => fileReplacementCounts.get(filePath) !== appliedFileReplacementCounts.get(filePath),
+							);
+						if (stalePreview) {
+							const text =
+								applyResult.totalReplacements === 0
+									? `Preview is stale / no longer matches; no replacements were applied. Preview expected ${result.totalReplacements} replacement${previewReplacementPlural} in ${result.filesTouched} file${previewFilePlural}.`
+									: applyResult.totalReplacements < result.totalReplacements
+										? `Preview is stale / no longer matches; only ${applyResult.totalReplacements} of ${result.totalReplacements} replacements were applied in ${applyResult.filesTouched} of ${result.filesTouched} files.`
+										: `Preview is stale / no longer matches; applied ${applyResult.totalReplacements} replacements but preview expected ${result.totalReplacements}.`;
+							return { ...toolResult(appliedDetails).text(text).done(), isError: true };
+						}
 						const appliedReplacementPlural = applyResult.totalReplacements !== 1 ? "s" : "";
 						const appliedFilePlural = applyResult.filesTouched !== 1 ? "s" : "";
 						const text = `Applied ${applyResult.totalReplacements} replacement${appliedReplacementPlural} in ${applyResult.filesTouched} file${appliedFilePlural}.`;

package/src/tools/bash.ts

@@ -23,7 +23,7 @@ import { resolveToCwd } from "./path-utils";
 import { formatToolWorkingDirectory, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
-import { clampTimeout } from "./tool-timeouts";
+import { clampTimeout, TOOL_TIMEOUTS } from "./tool-timeouts";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
@@ -74,6 +74,7 @@ export interface BashToolInput {
 export interface BashToolDetails {
 	meta?: OutputMeta;
 	timeoutSeconds?: number;
+	requestedTimeoutSeconds?: number;
 	async?: {
 		state: "running" | "completed" | "failed";
 		jobId: string;
@@ -219,6 +220,13 @@ function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | un
 	if (partialEnv && args.env) return { ...partialEnv, ...args.env };
 	return args.env ?? partialEnv;
 }
+
+function formatTimeoutClampNotice(requestedTimeoutSec: number, effectiveTimeoutSec: number): string | undefined {
+	return requestedTimeoutSec !== effectiveTimeoutSec
+		? `Timeout clamped to ${effectiveTimeoutSec}s (requested ${requestedTimeoutSec}s; allowed range ${TOOL_TIMEOUTS.bash.min}-${TOOL_TIMEOUTS.bash.max}s).`
+		: undefined;
+}
+
 /**
  * Bash tool implementation.
  *
@@ -289,9 +297,16 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		timeoutSec: number,
 		headLines?: number,
 		tailLines?: number,
+		options: { requestedTimeoutSec?: number; notices?: string[] } = {},
 	): AgentToolResult<BashToolDetails> {
-		const outputText = this.#formatResultOutput(result, headLines, tailLines);
+		const outputLines = [this.#formatResultOutput(result, headLines, tailLines)];
+		const notices = options.notices?.filter(Boolean) ?? [];
+		if (notices.length > 0) outputLines.push("", ...notices);
+		const outputText = outputLines.join("\n");
 		const details: BashToolDetails = { timeoutSeconds: timeoutSec };
+		if (options.requestedTimeoutSec !== undefined && options.requestedTimeoutSec !== timeoutSec) {
+			details.requestedTimeoutSeconds = options.requestedTimeoutSec;
+		}
 		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
 		this.#buildResultText(result, timeoutSec, outputText);
 		return resultBuilder.done();
@@ -302,16 +317,23 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		label: string,
 		previewText: string,
 		timeoutSec: number,
+		options: { requestedTimeoutSec?: number; notices?: string[] } = {},
 	): AgentToolResult<BashToolDetails> {
 		const details: BashToolDetails = {
 			timeoutSeconds: timeoutSec,
 			async: { state: "running", jobId, type: "bash" },
 		};
+		if (options.requestedTimeoutSec !== undefined && options.requestedTimeoutSec !== timeoutSec) {
+			details.requestedTimeoutSeconds = options.requestedTimeoutSec;
+		}
 		const lines: string[] = [];
 		const trimmedPreview = previewText.trimEnd();
 		if (trimmedPreview.length > 0) {
 			lines.push(trimmedPreview, "");
 		}
+		if (options.notices?.length) {
+			lines.push(...options.notices, "");
+		}
 		lines.push(`Background job ${jobId} started: ${label}`);
 		lines.push("Result will be delivered automatically when complete.");
 		lines.push(`Use \`poll\`, \`read jobs://${jobId}\`, or \`cancel_job\` if needed.`);
@@ -330,6 +352,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		commandCwd: string;
 		timeoutMs: number;
 		timeoutSec: number;
+		requestedTimeoutSec?: number;
+		timeoutClampNotice?: string;
 		headLines?: number;
 		tailLines?: number;
 		resolvedEnv?: Record<string, string>;
@@ -372,6 +396,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 						options.timeoutSec,
 						options.headLines,
 						options.tailLines,
+						{
+							requestedTimeoutSec: options.requestedTimeoutSec,
+							notices: [options.timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+						},
 					);
 					const finalText = this.#extractTextResult(finalResult);
 					latestText = finalText;
@@ -531,8 +559,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 
 		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		const timeoutSec = clampTimeout("bash", rawTimeout);
+		const requestedTimeoutSec = rawTimeout;
+		const timeoutSec = clampTimeout("bash", requestedTimeoutSec);
 		const timeoutMs = timeoutSec * 1000;
+		const timeoutClampNotice = formatTimeoutClampNotice(requestedTimeoutSec, timeoutSec);
 
 		if (asyncRequested) {
 			if (!this.session.asyncJobManager) {
@@ -543,13 +573,18 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				commandCwd,
 				timeoutMs,
 				timeoutSec,
+				requestedTimeoutSec,
+				timeoutClampNotice,
 				headLines,
 				tailLines,
 				resolvedEnv,
 				onUpdate,
 				startBackgrounded: true,
 			});
-			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
+			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
+				requestedTimeoutSec,
+				notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+			});
 		}
 
 		if (this.#autoBackgroundEnabled && !pty && this.session.asyncJobManager) {
@@ -560,6 +595,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				commandCwd,
 				timeoutMs,
 				timeoutSec,
+				requestedTimeoutSec,
+				timeoutClampNotice,
 				headLines,
 				tailLines,
 				resolvedEnv,
@@ -567,7 +604,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				startBackgrounded,
 			});
 			if (startBackgrounded) {
-				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
+				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
+					requestedTimeoutSec,
+					notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+				});
 			}
 			const waitResult = await this.#waitForManagedBashJob(job, autoBackgroundWaitMs, signal);
 			if (waitResult.kind === "completed") {
@@ -584,7 +624,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				throw new ToolAbortError(job.getLatestText() || "Command aborted");
 			}
 			job.setBackgrounded(true);
-			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec);
+			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec, {
+				requestedTimeoutSec,
+				notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+			});
 		}
 
 		// Track output for streaming updates (tail only)
@@ -623,7 +666,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		if (isInteractiveResult(result) && result.timedOut) {
 			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
 		}
-		return this.#buildCompletedResult(result, timeoutSec, headLines, tailLines);
+		return this.#buildCompletedResult(result, timeoutSec, headLines, tailLines, {
+			requestedTimeoutSec,
+			notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+		});
 	}
 }
 
@@ -700,12 +746,16 @@ export const bashToolRenderer = {
 
 				// Build truncation warning
 				const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
-				const timeoutLine =
+				const requestedTimeoutSeconds = details?.requestedTimeoutSeconds;
+				const timeoutLabel =
 					typeof timeoutSeconds === "number"
-						? uiTheme.fg(
-								"dim",
-								`${uiTheme.format.bracketLeft}Timeout: ${timeoutSeconds}s${uiTheme.format.bracketRight}`,
-							)
+						? requestedTimeoutSeconds !== undefined && requestedTimeoutSeconds !== timeoutSeconds
+							? `Timeout: ${timeoutSeconds}s (requested ${requestedTimeoutSeconds}s clamped)`
+							: `Timeout: ${timeoutSeconds}s`
+						: undefined;
+				const timeoutLine =
+					timeoutLabel !== undefined
+						? uiTheme.fg("dim", `${uiTheme.format.bracketLeft}${timeoutLabel}${uiTheme.format.bracketRight}`)
 						: undefined;
 				let warningLine: string | undefined;
 				if (details?.meta?.truncation && !showingFullOutput) {

package/src/tools/find.ts

@@ -129,6 +129,19 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const includeHidden = hidden ?? true;
 			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+			const formatMatchPath = (matchPath: string, fileType?: natives.FileType): string => {
+				const hadTrailingSlash = matchPath.endsWith("/") || matchPath.endsWith("\\");
+				const absolutePath = path.isAbsolute(matchPath) ? matchPath : path.resolve(searchPath, matchPath);
+				let relativePath = path.relative(this.session.cwd, absolutePath).replace(/\\/g, "/");
+				if (relativePath.length === 0) {
+					relativePath = ".";
+				}
+				if ((fileType === natives.FileType.Dir || hadTrailingSlash) && !relativePath.endsWith("/")) {
+					relativePath += "/";
+				}
+				return relativePath;
+			};
+
 			const buildResult = (files: string[]): AgentToolResult<FindToolDetails> => {
 				if (files.length === 0) {
 					const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
@@ -176,12 +189,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					ignore: ["**/node_modules/**", "**/.git/**"],
 					limit: effectiveLimit,
 				});
-				const relativized = results.map(p => {
-					if (p.startsWith(searchPath)) {
-						return p.slice(searchPath.length + 1);
-					}
-					return path.relative(searchPath, p);
-				});
+				const relativized = results.map(p => formatMatchPath(p));
 
 				return buildResult(relativized);
 			}
@@ -225,12 +233,8 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			};
 			const onMatch = onUpdate
 				? (err: Error | null, match: natives.GlobMatch | null) => {
-						if (err || signal?.aborted || !match) return;
-						let relativePath = match.path;
-						if (!relativePath) return;
-						if (match.fileType === natives.FileType.Dir && !relativePath.endsWith("/")) {
-							relativePath += "/";
-						}
+						if (err || signal?.aborted || !match?.path) return;
+						const relativePath = formatMatchPath(match.path, match.fileType);
 						onUpdateMatches.push(relativePath);
 						emitUpdate();
 					}
@@ -254,10 +258,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				);
 
 			try {
-				let result = await doGlob(true);
-				if (result.matches.length === 0 && !timeoutSignal.aborted) {
-					result = await doGlob(false);
-				}
+				const result = await doGlob(true);
 				// Sort by mtime descending (most recent first) in JS instead of native.
 				// This allows native glob to early-terminate at maxResults.
 				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
@@ -276,19 +277,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const relativized: string[] = [];
 			for (const match of matches) {
 				throwIfAborted(signal);
-				const line = match.path;
-				if (!line) {
+				if (!match.path) {
 					continue;
 				}
 
-				const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-				let relativePath = line;
-				const isDirectory = match.fileType === natives.FileType.Dir;
-				if ((isDirectory || hadTrailingSlash) && !relativePath.endsWith("/")) {
-					relativePath += "/";
-				}
-
-				relativized.push(relativePath);
+				relativized.push(formatMatchPath(match.path, match.fileType));
 			}
 
 			return buildResult(relativized);

package/src/tools/grep.ts

@@ -124,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()) {
@@ -142,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);
@@ -174,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);
@@ -258,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);
@@ -289,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[]>();
@@ -310,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[]>();
@@ -330,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");
@@ -380,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];
@@ -399,20 +446,21 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						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[]>();
@@ -426,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/path-utils.ts

@@ -193,6 +193,7 @@ export interface ResolvedMultiSearchPath {
 	basePath: string;
 	glob?: string;
 	scopePath: string;
+	exactFilePaths?: string[];
 }
 
 export interface ResolvedMultiFindPattern {
@@ -438,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,
@@ -452,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");
@@ -473,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;
 	}
 
@@ -486,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)) || ".";
@@ -507,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/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;

package/src/tools/vim.ts

@@ -639,7 +639,7 @@ export class VimTool implements AgentTool<typeof vimSchema, VimToolDetails> {
 
 				await executeVimSteps(engine, steps, {
 					pauseLastStep: params.pause === true,
-					onKbdStep: emitUpdate ? () => emitUpdate() : undefined,
+					onKbdStep: emitUpdate ? () => emitUpdate(true) : undefined,
 					onInsertStep: emitUpdate ? () => emitUpdate(true) : undefined,
 				});