@oh-my-pi/pi-coding-agent 5.1.1 → 5.2.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [5.2.1] - 2026-01-14
+### Fixed
+
+- Fixed stale diagnostic results by tracking diagnostic versions before file sync operations
+- Fixed race condition where LSP diagnostics could return outdated results after file modifications
+
+## [5.2.0] - 2026-01-14
+
+### Added
+
+- Added `withLines` parameter to read tool for optional line number output (default: true, cat -n format)
+
+### Changed
+
+- Changed find/grep/ls tool output to render inline without background box for cleaner visual flow
+
+### Fixed
+
+- Fixed task tool abort to return partial results instead of failing (completed tasks preserved, cancelled tasks shown as skipped)
+- Fixed TUI crash when bash output metadata lines exceed terminal width on narrow terminals
+- Fixed find tool not matching `**/filename` patterns (was incorrectly using `--full-path` for glob depth wildcards)
+
 ## [5.1.1] - 2026-01-14
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "5.1.1",
+	"version": "5.2.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "5.1.1",
-		"@oh-my-pi/pi-ai": "5.1.1",
-		"@oh-my-pi/pi-git-tool": "5.1.1",
-		"@oh-my-pi/pi-tui": "5.1.1",
+		"@oh-my-pi/pi-agent-core": "5.2.1",
+		"@oh-my-pi/pi-ai": "5.2.1",
+		"@oh-my-pi/pi-git-tool": "5.2.1",
+		"@oh-my-pi/pi-tui": "5.2.1",
 		"@openai/agents": "^0.3.7",
 		"@silvia-odwyer/photon-node": "^0.3.4",
 		"@sinclair/typebox": "^0.34.46",

package/src/core/tools/bash.ts

@@ -1,7 +1,7 @@
 import { relative, resolve, sep } from "node:path";
 import type { AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
+import { Text, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate";
 import type { Theme } from "../../modes/interactive/theme/theme";
@@ -293,16 +293,15 @@ export const bashToolRenderer = {
 				const outputLines: string[] = [];
 				if (cachedSkipped && cachedSkipped > 0) {
 					outputLines.push("");
-					outputLines.push(
-						uiTheme.fg(
-							"dim",
-							`${uiTheme.format.ellipsis} (${cachedSkipped} earlier lines, showing ${cachedLines.length} of ${cachedSkipped + cachedLines.length}) (ctrl+o to expand)`,
-						),
+					const skippedLine = uiTheme.fg(
+						"dim",
+						`${uiTheme.format.ellipsis} (${cachedSkipped} earlier lines, showing ${cachedLines.length} of ${cachedSkipped + cachedLines.length}) (ctrl+o to expand)`,
 					);
+					outputLines.push(truncateToWidth(skippedLine, width, uiTheme.fg("dim", uiTheme.format.ellipsis)));
 				}
 				outputLines.push(...cachedLines);
 				if (warningLine) {
-					outputLines.push(warningLine);
+					outputLines.push(truncateToWidth(warningLine, width, uiTheme.fg("warning", uiTheme.format.ellipsis)));
 				}
 				return outputLines;
 			},

package/src/core/tools/find.ts

@@ -218,7 +218,11 @@ export function createFindTool(session: ToolSession, options?: FindToolOptions):
 				// When pattern contains path separators (e.g. "reports/**"), use --full-path
 				// so fd matches against the full path, not just the filename.
 				// Also prepend **/ to anchor the pattern at any depth in the search path.
-				const hasPathSeparator = pattern.includes("/") || pattern.includes("\\");
+				// Note: "**/foo.rs" is a glob construct (filename at any depth), not a path.
+				// Only patterns with real path components like "foo/bar" or "foo/**/bar" need --full-path.
+				const patternWithoutLeadingStarStar = pattern.replace(/^\*\*\//, "");
+				const hasPathSeparator =
+					patternWithoutLeadingStarStar.includes("/") || patternWithoutLeadingStarStar.includes("\\");
 				const effectivePattern = hasPathSeparator && !pattern.startsWith("**/") ? `**/${pattern}` : pattern;
 				const args: string[] = [
 					"--glob", // Use glob pattern
@@ -418,10 +422,11 @@ interface FindRenderArgs {
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
 export const findToolRenderer = {
+	inline: true,
 	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
 		const ui = createToolUIKit(uiTheme);
 		const label = ui.title("Find");
-		let text = `${label} ${uiTheme.fg("accent", args.pattern || "*")}`;
+		let text = `${uiTheme.format.bullet} ${label} ${uiTheme.fg("accent", args.pattern || "*")}`;
 
 		const meta: string[] = [];
 		if (args.path) meta.push(`in ${args.path}`);
@@ -436,15 +441,16 @@ export const findToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: FindToolDetails },
+		result: { content: Array<{ type: string; text?: string }>; details?: FindToolDetails; isError?: boolean },
 		{ expanded }: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
 		const ui = createToolUIKit(uiTheme);
 		const details = result.details;
 
-		if (details?.error) {
-			return new Text(ui.errorMessage(details.error), 0, 0);
+		if (result.isError || details?.error) {
+			const errorText = details?.error || result.content?.find((c) => c.type === "text")?.text || "Unknown error";
+			return new Text(`  ${ui.errorMessage(errorText)}`, 0, 0);
 		}
 
 		const hasDetailedData = details?.fileCount !== undefined;
@@ -452,7 +458,7 @@ export const findToolRenderer = {
 
 		if (!hasDetailedData) {
 			if (!textContent || textContent.includes("No files matching") || textContent.trim() === "") {
-				return new Text(ui.emptyMessage("No files found"), 0, 0);
+				return new Text(`  ${ui.emptyMessage("No files found")}`, 0, 0);
 			}
 
 			const lines = textContent.split("\n").filter((l) => l.trim());
@@ -464,15 +470,15 @@ export const findToolRenderer = {
 			const icon = uiTheme.styledSymbol("status.success", "success");
 			const summary = ui.count("file", lines.length);
 			const expandHint = ui.expandHint(expanded, hasMore);
-			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+			let text = `  ${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
 
 			for (let i = 0; i < displayLines.length; i++) {
 				const isLast = i === displayLines.length - 1 && remaining === 0;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", displayLines[i])}`;
+				text += `\n  ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", displayLines[i])}`;
 			}
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", ui.moreItems(remaining, "file"))}`;
+				text += `\n  ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", ui.moreItems(remaining, "file"))}`;
 			}
 			return new Text(text, 0, 0);
 		}
@@ -482,7 +488,7 @@ export const findToolRenderer = {
 		const files = details?.files ?? [];
 
 		if (fileCount === 0) {
-			return new Text(ui.emptyMessage("No files found"), 0, 0);
+			return new Text(`  ${ui.emptyMessage("No files found")}`, 0, 0);
 		}
 
 		const icon = uiTheme.styledSymbol("status.success", "success");
@@ -492,7 +498,7 @@ export const findToolRenderer = {
 		const hasMoreFiles = files.length > maxFiles;
 		const expandHint = ui.expandHint(expanded, hasMoreFiles);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
+		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.resultLimitReached) {
@@ -515,12 +521,12 @@ export const findToolRenderer = {
 				const entryIcon = isDir
 					? uiTheme.fg("accent", uiTheme.icon.folder)
 					: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
-				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry)}`;
+				text += `\n  ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry)}`;
 			}
 
 			if (hasMoreFiles) {
 				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
-				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+				text += `\n  ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
 					"muted",
 					ui.moreItems(files.length - maxFiles, "file"),
 				)}`;
@@ -528,7 +534,7 @@ export const findToolRenderer = {
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
+			text += `\n  ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/grep.ts

@@ -621,10 +621,11 @@ const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
 export const grepToolRenderer = {
+	inline: true,
 	renderCall(args: GrepRenderArgs, uiTheme: Theme): Component {
 		const ui = createToolUIKit(uiTheme);
 		const label = ui.title("Grep");
-		let text = `${label} ${uiTheme.fg("accent", args.pattern || "?")}`;
+		let text = `${uiTheme.format.bullet} ${label} ${uiTheme.fg("accent", args.pattern || "?")}`;
 
 		const meta: string[] = [];
 		if (args.path) meta.push(`in ${args.path}`);
@@ -647,15 +648,16 @@ export const grepToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails },
+		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails; isError?: boolean },
 		{ expanded }: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
 		const ui = createToolUIKit(uiTheme);
 		const details = result.details;
 
-		if (details?.error) {
-			return new Text(ui.errorMessage(details.error), 0, 0);
+		if (result.isError || details?.error) {
+			const errorText = details?.error || result.content?.find((c) => c.type === "text")?.text || "Unknown error";
+			return new Text(`  ${ui.errorMessage(errorText)}`, 0, 0);
 		}
 
 		const hasDetailedData = details?.matchCount !== undefined || details?.fileCount !== undefined;
@@ -663,7 +665,7 @@ export const grepToolRenderer = {
 		if (!hasDetailedData) {
 			const textContent = result.content?.find((c) => c.type === "text")?.text;
 			if (!textContent || textContent === "No matches found") {
-				return new Text(ui.emptyMessage("No matches found"), 0, 0);
+				return new Text(`  ${ui.emptyMessage("No matches found")}`, 0, 0);
 			}
 
 			const lines = textContent.split("\n").filter((line) => line.trim() !== "");
@@ -675,16 +677,16 @@ export const grepToolRenderer = {
 			const icon = uiTheme.styledSymbol("status.success", "success");
 			const summary = ui.count("item", lines.length);
 			const expandHint = ui.expandHint(expanded, hasMore);
-			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+			let text = `  ${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
 
 			for (let i = 0; i < displayLines.length; i++) {
 				const isLast = i === displayLines.length - 1 && remaining === 0;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", displayLines[i])}`;
+				text += `\n  ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", displayLines[i])}`;
 			}
 
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", ui.moreItems(remaining, "item"))}`;
+				text += `\n  ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", ui.moreItems(remaining, "item"))}`;
 			}
 
 			return new Text(text, 0, 0);
@@ -697,7 +699,7 @@ export const grepToolRenderer = {
 		const files = details?.files ?? [];
 
 		if (matchCount === 0) {
-			return new Text(ui.emptyMessage("No matches found"), 0, 0);
+			return new Text(`  ${ui.emptyMessage("No matches found")}`, 0, 0);
 		}
 
 		const icon = uiTheme.styledSymbol("status.success", "success");
@@ -715,7 +717,7 @@ export const grepToolRenderer = {
 		const hasMoreFiles = fileEntries.length > maxFiles;
 		const expandHint = ui.expandHint(expanded, hasMoreFiles);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
+		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.matchLimitReached) {
@@ -748,12 +750,12 @@ export const grepToolRenderer = {
 					entry.count !== undefined
 						? ` ${uiTheme.fg("dim", `(${entry.count} match${entry.count !== 1 ? "es" : ""})`)}`
 						: "";
-				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry.path)}${countLabel}`;
+				text += `\n  ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry.path)}${countLabel}`;
 			}
 
 			if (hasMoreFiles) {
 				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
-				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+				text += `\n  ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
 					"muted",
 					ui.moreItems(fileEntries.length - maxFiles, "file"),
 				)}`;
@@ -761,7 +763,7 @@ export const grepToolRenderer = {
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
+			text += `\n  ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/ls.ts

@@ -13,6 +13,7 @@ import {
 	formatBytes,
 	formatCount,
 	formatEmptyMessage,
+	formatErrorMessage,
 	formatExpandHint,
 	formatMeta,
 	formatMoreItems,
@@ -205,9 +206,10 @@ interface LsRenderArgs {
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
 export const lsToolRenderer = {
+	inline: true,
 	renderCall(args: LsRenderArgs, uiTheme: Theme): Component {
 		const label = uiTheme.fg("toolTitle", uiTheme.bold("Ls"));
-		let text = `${label} ${uiTheme.fg("accent", args.path || ".")}`;
+		let text = `${uiTheme.format.bullet} ${label} ${uiTheme.fg("accent", args.path || ".")}`;
 
 		const meta: string[] = [];
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
@@ -217,18 +219,22 @@ export const lsToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: LsToolDetails },
+		result: { content: Array<{ type: string; text?: string }>; details?: LsToolDetails; isError?: boolean },
 		{ expanded }: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
 		const details = result.details;
 		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
 
+		if (result.isError) {
+			return new Text(`  ${formatErrorMessage(textContent, uiTheme)}`, 0, 0);
+		}
+
 		if (
 			(!textContent || textContent.trim() === "" || textContent.trim() === "(empty directory)") &&
 			(!details?.entries || details.entries.length === 0)
 		) {
-			return new Text(formatEmptyMessage("Empty directory", uiTheme), 0, 0);
+			return new Text(`  ${formatEmptyMessage("Empty directory", uiTheme)}`, 0, 0);
 		}
 
 		let entries: string[] = details?.entries ? [...details.entries] : [];
@@ -238,7 +244,7 @@ export const lsToolRenderer = {
 		}
 
 		if (entries.length === 0) {
-			return new Text(formatEmptyMessage("Empty directory", uiTheme), 0, 0);
+			return new Text(`  ${formatEmptyMessage("Empty directory", uiTheme)}`, 0, 0);
 		}
 
 		let dirCount = details?.dirCount;
@@ -267,7 +273,7 @@ export const lsToolRenderer = {
 		const hasMoreEntries = entries.length > maxEntries;
 		const expandHint = formatExpandHint(uiTheme, expanded, hasMoreEntries);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${expandHint}`;
+		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.entryLimitReached) {
@@ -290,19 +296,19 @@ export const lsToolRenderer = {
 				? uiTheme.fg("accent", uiTheme.icon.folder)
 				: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 			const entryColor = isDir ? "accent" : "toolOutput";
-			text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg(entryColor, entry)}`;
+			text += `\n  ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg(entryColor, entry)}`;
 		}
 
 		if (hasMoreEntries) {
 			const moreEntriesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
-			text += `\n ${uiTheme.fg("dim", moreEntriesBranch)} ${uiTheme.fg(
+			text += `\n  ${uiTheme.fg("dim", moreEntriesBranch)} ${uiTheme.fg(
 				"muted",
 				formatMoreItems(entries.length - maxEntries, "entry", uiTheme),
 			)}`;
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+			text += `\n  ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
 				"warning",
 				`truncated: ${truncationReasons.join(", ")}`,
 			)}`;

package/src/core/tools/lsp/index.ts

@@ -331,12 +331,14 @@ async function waitForDiagnostics(
 	uri: string,
 	timeoutMs = 3000,
 	signal?: AbortSignal,
+	minVersion?: number,
 ): Promise<Diagnostic[]> {
 	const start = Date.now();
 	while (Date.now() - start < timeoutMs) {
 		signal?.throwIfAborted();
 		const diagnostics = client.diagnostics.get(uri);
-		if (diagnostics !== undefined) return diagnostics;
+		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
+		if (diagnostics !== undefined && versionOk) return diagnostics;
 		await sleep(100);
 	}
 	return client.diagnostics.get(uri) ?? [];
@@ -462,12 +464,35 @@ export interface FileDiagnosticsResult {
 	formatter?: FileFormatResult;
 }
 
+/** Captured diagnostic versions per server (before sync) */
+type DiagnosticVersions = Map<string, number>;
+
+/**
+ * Capture current diagnostic versions for all LSP servers.
+ * Call this BEFORE syncing content to detect stale diagnostics later.
+ */
+async function captureDiagnosticVersions(
+	cwd: string,
+	servers: Array<[string, ServerConfig]>,
+): Promise<DiagnosticVersions> {
+	const versions = new Map<string, number>();
+	await Promise.allSettled(
+		servers.map(async ([serverName, serverConfig]) => {
+			if (serverConfig.createClient) return;
+			const client = await getOrCreateClient(serverConfig, cwd);
+			versions.set(serverName, client.diagnosticsVersion);
+		}),
+	);
+	return versions;
+}
+
 /**
  * Get diagnostics for a file using LSP or custom linter client.
  *
  * @param absolutePath - Absolute path to the file
  * @param cwd - Working directory for LSP config resolution
  * @param servers - Servers to query diagnostics for
+ * @param minVersions - Minimum diagnostic versions per server (to detect stale results)
  * @returns Diagnostic results or undefined if no servers
  */
 async function getDiagnosticsForFile(
@@ -475,6 +500,7 @@ async function getDiagnosticsForFile(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
 	signal?: AbortSignal,
+	minVersions?: DiagnosticVersions,
 ): Promise<FileDiagnosticsResult | undefined> {
 	if (servers.length === 0) {
 		return undefined;
@@ -499,8 +525,9 @@ async function getDiagnosticsForFile(
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 			signal?.throwIfAborted();
-			// Content already synced + didSave sent, just wait for diagnostics
-			const diagnostics = await waitForDiagnostics(client, uri, 3000, signal);
+			// Content already synced + didSave sent, wait for fresh diagnostics
+			const minVersion = minVersions?.get(serverName);
+			const diagnostics = await waitForDiagnostics(client, uri, 3000, signal, minVersion);
 			return { serverName, diagnostics };
 		}),
 	);
@@ -675,6 +702,9 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		const getWritePromise = once(() => writeContent(finalContent));
 		const useCustomFormatter = enableFormat && customLinterServers.length > 0;
 
+		// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
+		const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+
 		let formatter: FileFormatResult | undefined;
 		let diagnostics: FileDiagnosticsResult | undefined;
 		try {
@@ -710,9 +740,9 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 				// 5. Notify saved to LSP servers
 				await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
-				// 6. Get diagnostics from all servers
+				// 6. Get diagnostics from all servers (wait for fresh results)
 				if (enableDiagnostics) {
-					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal);
+					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
 				}
 			});
 		} catch {
@@ -829,8 +859,9 @@ export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema,
 								continue;
 							}
 							const client = await getOrCreateClient(serverConfig, session.cwd);
+							const minVersion = client.diagnosticsVersion;
 							await refreshFile(client, resolved);
-							const diagnostics = await waitForDiagnostics(client, uri);
+							const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, minVersion);
 							allDiagnostics.push(...diagnostics);
 						} catch {
 							// Server failed, continue with others
@@ -1091,8 +1122,9 @@ export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema,
 							};
 						}
 
+						const actionsMinVersion = client.diagnosticsVersion;
 						await refreshFile(client, targetFile);
-						const diagnostics = await waitForDiagnostics(client, uri);
+						const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, actionsMinVersion);
 						const endLine = (end_line ?? line ?? 1) - 1;
 						const endCharacter = (end_character ?? column ?? 1) - 1;
 						const range = { start: position, end: { line: endLine, character: endCharacter } };

package/src/core/tools/read.ts

@@ -417,6 +417,7 @@ const readSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
 	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
 	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+	lines: Type.Optional(Type.Boolean({ description: "Prepend line numbers to output (default: true)" })),
 });
 
 export interface ReadToolDetails {
@@ -436,7 +437,7 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 		parameters: readSchema,
 		execute: async (
 			toolCallId: string,
-			{ path: readPath, offset, limit }: { path: string; offset?: number; limit?: number },
+			{ path: readPath, offset, limit, lines }: { path: string; offset?: number; limit?: number; lines?: boolean },
 			signal?: AbortSignal,
 		) => {
 			const absolutePath = resolveReadPath(readPath, session.cwd);
@@ -599,6 +600,20 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 					// Apply truncation (respects both line and byte limits)
 					const truncation = truncateHead(selectedContent);
 
+					// Add line numbers if requested (default: true)
+					const shouldAddLineNumbers = lines !== false;
+					const prependLineNumbers = (text: string, startNum: number): string => {
+						const lines = text.split("\n");
+						const lastLineNum = startNum + lines.length - 1;
+						const padWidth = String(lastLineNum).length;
+						return lines
+							.map((line, i) => {
+								const lineNum = String(startNum + i).padStart(padWidth, " ");
+								return `${lineNum}\t${line}`;
+							})
+							.join("\n");
+					};
+
 					let outputText: string;
 
 					if (truncation.firstLineExceedsLimit) {
@@ -607,8 +622,8 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 						const snippet = truncateStringToBytesFromStart(firstLine, DEFAULT_MAX_BYTES);
 						const shownSize = formatSize(snippet.bytes);
 
-						outputText = snippet.text;
-						if (outputText.length > 0) {
+						outputText = shouldAddLineNumbers ? prependLineNumbers(snippet.text, startLineDisplay) : snippet.text;
+						if (snippet.text.length > 0) {
 							outputText += `\n\n[Line ${startLineDisplay} is ${formatSize(
 								firstLineBytes,
 							)}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Showing first ${shownSize} of the line.]`;
@@ -623,7 +638,9 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 						const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
 						const nextOffset = endLineDisplay + 1;
 
-						outputText = truncation.content;
+						outputText = shouldAddLineNumbers
+							? prependLineNumbers(truncation.content, startLineDisplay)
+							: truncation.content;
 
 						if (truncation.truncatedBy === "lines") {
 							outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
@@ -638,11 +655,15 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 						const remaining = allLines.length - (startLine + userLimitedLines);
 						const nextOffset = startLine + userLimitedLines + 1;
 
-						outputText = truncation.content;
+						outputText = shouldAddLineNumbers
+							? prependLineNumbers(truncation.content, startLineDisplay)
+							: truncation.content;
 						outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue]`;
 					} else {
 						// No truncation, no user limit exceeded
-						outputText = truncation.content;
+						outputText = shouldAddLineNumbers
+							? prependLineNumbers(truncation.content, startLineDisplay)
+							: truncation.content;
 					}
 
 					content = [{ type: "text", text: outputText }];

package/src/core/tools/renderers.ts

@@ -34,6 +34,8 @@ type ToolRenderer = {
 		args?: unknown,
 	) => Component;
 	mergeCallAndResult?: boolean;
+	/** Render without background box, inline in the response flow */
+	inline?: boolean;
 };
 
 export const toolRenderers: Record<string, ToolRenderer> = {

package/src/core/tools/task/index.ts

@@ -29,6 +29,7 @@ import {
 	MAX_AGENTS_IN_DESCRIPTION,
 	MAX_CONCURRENCY,
 	MAX_PARALLEL_TASKS,
+	type SingleResult,
 	type TaskToolDetails,
 	taskSchema,
 } from "./types";
@@ -337,7 +338,7 @@ export async function createTaskTool(
 				emitProgress();
 
 				// Execute in parallel with concurrency limit
-				const results = await mapWithConcurrencyLimit(
+				const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
 					tasksWithContext,
 					MAX_CONCURRENCY,
 					async (task, index) => {
@@ -371,6 +372,29 @@ export async function createTaskTool(
 					signal,
 				);
 
+				// Fill in skipped tasks (undefined entries from abort) with placeholder results
+				const results: SingleResult[] = partialResults.map((result, index) => {
+					if (result !== undefined) return result;
+					const task = tasksWithContext[index];
+					return {
+						index,
+						taskId: task.taskId,
+						agent: agentName,
+						agentSource: agent.source,
+						task: task.task,
+						description: task.description,
+						exitCode: 1,
+						output: "",
+						stderr: "Skipped (cancelled before start)",
+						truncated: false,
+						durationMs: 0,
+						tokens: 0,
+						modelOverride,
+						error: "Skipped",
+						aborted: true,
+					};
+				});
+
 				// Aggregate usage from executor results (already accumulated incrementally)
 				const aggregatedUsage = createUsageTotals();
 				let hasAggregatedUsage = false;
@@ -391,10 +415,11 @@ export async function createTaskTool(
 
 				// Build final output - match plugin format
 				const successCount = results.filter((r) => r.exitCode === 0).length;
+				const cancelledCount = results.filter((r) => r.aborted).length;
 				const totalDuration = Date.now() - startTime;
 
 				const summaries = results.map((r) => {
-					const status = r.exitCode === 0 ? "completed" : `failed (exit ${r.exitCode})`;
+					const status = r.aborted ? "cancelled" : r.exitCode === 0 ? "completed" : `failed (exit ${r.exitCode})`;
 					const output = r.output.trim() || r.stderr.trim() || "(no output)";
 					const preview = output.split("\n").slice(0, 5).join("\n");
 					const meta = r.outputMeta
@@ -403,13 +428,14 @@ export async function createTaskTool(
 					return `[${r.agent}] ${status}${meta} ${r.taskId}\n${preview}`;
 				});
 
-				const outputIds = results.map((r) => r.taskId);
+				const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.taskId);
 				const outputHint =
 					outputIds.length > 0 ? `\n\nUse output tool for full logs: output ids ${outputIds.join(", ")}` : "";
 				const schemaNote = schemaOverridden
 					? `\n\nNote: Agent '${agentName}' has a fixed output schema; your 'output' parameter was ignored.\nRequired schema: ${JSON.stringify(agent.output)}`
 					: "";
-				const summary = `${successCount}/${results.length} succeeded [${formatDuration(
+				const cancelledNote = aborted && cancelledCount > 0 ? ` (${cancelledCount} cancelled)` : "";
+				const summary = `${successCount}/${results.length} succeeded${cancelledNote} [${formatDuration(
 					totalDuration,
 				)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}${schemaNote}`;
 

package/src/core/tools/task/parallel.ts

@@ -4,31 +4,43 @@
 
 import { MAX_CONCURRENCY } from "./types";
 
+/** Result of parallel execution */
+export interface ParallelResult<R> {
+	/** Results array - undefined entries indicate tasks that were skipped due to abort */
+	results: (R | undefined)[];
+	/** Whether execution was aborted before all tasks completed */
+	aborted: boolean;
+}
+
 /**
  * Execute items with a concurrency limit using a worker pool pattern.
  * Results are returned in the same order as input items.
- * Fails fast on first error - does not wait for other workers to complete.
+ *
+ * On abort: returns partial results with `aborted: true`. Completed tasks are preserved,
+ * in-progress tasks will complete with their abort handling, skipped tasks are `undefined`.
+ *
+ * On error: fails fast - does not wait for other workers to complete.
  *
  * @param items - Items to process
  * @param concurrency - Maximum concurrent operations
  * @param fn - Async function to execute for each item
- * @param signal - Optional abort signal to stop scheduling work
+ * @param signal - Optional abort signal to stop scheduling new work
  */
 export async function mapWithConcurrencyLimit<T, R>(
 	items: T[],
 	concurrency: number,
 	fn: (item: T, index: number) => Promise<R>,
 	signal?: AbortSignal,
-): Promise<R[]> {
+): Promise<ParallelResult<R>> {
 	const limit = Math.max(1, Math.min(concurrency, items.length, MAX_CONCURRENCY));
-	const results: R[] = new Array(items.length);
+	const results: (R | undefined)[] = new Array(items.length);
 	let nextIndex = 0;
 
 	// Create internal abort controller to cancel workers on any rejection
 	const abortController = new AbortController();
 	const workerSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
 
-	// Promise that rejects on first error - used to fail fast
+	// Promise that rejects on first error - used to fail fast (not for abort)
 	let rejectFirst: (error: unknown) => void;
 	const firstErrorPromise = new Promise<never>((_, reject) => {
 		rejectFirst = reject;
@@ -36,15 +48,20 @@ export async function mapWithConcurrencyLimit<T, R>(
 
 	const worker = async (): Promise<void> => {
 		while (true) {
-			workerSignal.throwIfAborted();
+			// On abort, stop picking up new work - but don't throw
+			if (workerSignal.aborted) return;
 			const index = nextIndex++;
 			if (index >= items.length) return;
 			try {
 				results[index] = await fn(items[index], index);
 			} catch (error) {
-				abortController.abort();
-				rejectFirst(error);
-				throw error;
+				// On abort, the fn itself handles it and returns a result
+				// Only propagate non-abort errors
+				if (!workerSignal.aborted) {
+					abortController.abort();
+					rejectFirst(error);
+					throw error;
+				}
 			}
 		}
 	};
@@ -53,13 +70,16 @@ export async function mapWithConcurrencyLimit<T, R>(
 	const workers = Array(limit)
 		.fill(null)
 		.map(() => worker());
-	await Promise.race([Promise.all(workers), firstErrorPromise]);
 
-	// Check external abort
-	if (signal?.aborted) {
-		const reason = signal.reason instanceof Error ? signal.reason : new Error("Aborted");
-		throw reason;
+	try {
+		await Promise.race([Promise.all(workers), firstErrorPromise]);
+	} catch (error) {
+		// If aborted, don't rethrow - return partial results
+		if (signal?.aborted) {
+			return { results, aborted: true };
+		}
+		throw error;
 	}
 
-	return results;
+	return { results, aborted: signal?.aborted ?? false };
 }

package/src/modes/interactive/components/tool-execution.ts

@@ -390,7 +390,8 @@ export class ToolExecutionComponent extends Container {
 		} else if (this.toolName in toolRenderers) {
 			// Built-in tools with renderers
 			const renderer = toolRenderers[this.toolName];
-			this.contentBox.setBgFn(bgFn);
+			// Inline renderers skip background styling
+			this.contentBox.setBgFn(renderer.inline ? undefined : bgFn);
 			this.contentBox.clear();
 
 			const shouldRenderCall = !this.result || !renderer.mergeCallAndResult;

package/src/modes/interactive/interactive-mode.ts

@@ -345,9 +345,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.start();
 		this.isInitialized = true;
 
-		// Set terminal title
-		const cwdBasename = path.basename(process.cwd());
-		this.ui.terminal.setTitle(`pi - ${cwdBasename}`);
+		// Set initial terminal title (will be updated when session title is generated)
+		this.ui.terminal.setTitle("π");
 
 		// Initialize hooks with TUI-based UI context
 		await this.initHooksAndCustomTools();

package/src/prompts/tools/read.md

@@ -5,7 +5,7 @@ Usage:
 - By default, it reads up to {{DEFAULT_MAX_LINES}} lines starting from the beginning of the file
 - You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
 - Any lines longer than 500 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
+- By default, results include line numbers (cat -n format). Use `lines: false` to omit them
 - This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
 - This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.
 - This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.