@oh-my-pi/pi-coding-agent 6.8.3 → 6.8.4

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [6.8.4] - 2026-01-21
+### Changed
+
+- Updated output sink to properly handle large outputs
+- Improved error message formatting in SSH executor
+- Updated web fetch timeout bounds and conversion
+
+### Fixed
+
+- Fixed output truncation handling in streaming output
+- Fixed timeout handling in web fetch tool
+- Fixed async stream dumping in executors
+
 ## [6.8.3] - 2026-01-21
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.8.3",
+	"version": "6.8.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,11 +40,11 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.8.3",
-		"@oh-my-pi/pi-ai": "6.8.3",
-		"@oh-my-pi/pi-git-tool": "6.8.3",
-		"@oh-my-pi/pi-tui": "6.8.3",
-		"@oh-my-pi/pi-utils": "6.8.3",
+		"@oh-my-pi/pi-agent-core": "6.8.4",
+		"@oh-my-pi/pi-ai": "6.8.4",
+		"@oh-my-pi/pi-git-tool": "6.8.4",
+		"@oh-my-pi/pi-tui": "6.8.4",
+		"@oh-my-pi/pi-utils": "6.8.4",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/agent-session.ts

@@ -22,7 +22,7 @@ import type { Rule } from "../capability/rule";
 import { getAgentDbPath } from "../config";
 import { theme } from "../modes/interactive/theme/theme";
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
-import { type BashResult, executeBash as executeBashCommand, executeBashWithOperations } from "./bash-executor";
+import { type BashResult, executeBash as executeBashCommand } from "./bash-executor";
 import {
 	type CompactionResult,
 	calculateContextTokens,
@@ -60,7 +60,6 @@ import type { Skill, SkillWarning } from "./skills";
 import { expandSlashCommand, type FileSlashCommand } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
-import type { BashOperations } from "./tools/bash";
 import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "./tools/patch";
 import { resolveToCwd } from "./tools/path-utils";
 import type { TodoItem } from "./tools/todo-write";
@@ -2546,25 +2545,19 @@ export class AgentSession {
 	 * @param command The bash command to execute
 	 * @param onChunk Optional streaming callback for output
 	 * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
-	 * @param options.operations Custom BashOperations for remote execution
 	 */
 	async executeBash(
 		command: string,
 		onChunk?: (chunk: string) => void,
-		options?: { excludeFromContext?: boolean; operations?: BashOperations },
+		options?: { excludeFromContext?: boolean },
 	): Promise<BashResult> {
 		this._bashAbortController = new AbortController();
 
 		try {
-			const result = options?.operations
-				? await executeBashWithOperations(command, process.cwd(), options.operations, {
-						onChunk,
-						signal: this._bashAbortController.signal,
-					})
-				: await executeBashCommand(command, {
-						onChunk,
-						signal: this._bashAbortController.signal,
-					});
+			const result = await executeBashCommand(command, {
+				onChunk,
+				signal: this._bashAbortController.signal,
+			});
 
 			this.recordBashResult(command, result, options);
 			return result;

package/src/core/bash-executor.ts

@@ -8,7 +8,6 @@ import { cspawn, Exception, ptree } from "@oh-my-pi/pi-utils";
 import { getShellConfig } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
 import { OutputSink } from "./streaming-output";
-import type { BashOperations } from "./tools/bash";
 
 export interface BashExecutorOptions {
 	cwd?: string;
@@ -34,7 +33,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
 	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
 
-	const stream = new OutputSink({ onChunk: options?.onChunk });
+	const sink = new OutputSink({ onChunk: options?.onChunk });
 
 	const child = cspawn([shell, ...args, finalCommand], {
 		cwd: options?.cwd,
@@ -45,12 +44,9 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 
 	// Pump streams - errors during abort/timeout are expected
 	// Use preventClose to avoid closing the shared sink when either stream finishes
-	await Promise.allSettled([
-		child.stdout.pipeTo(stream.createWritable()),
-		child.stderr.pipeTo(stream.createWritable()),
-	])
-		.then(() => stream.close())
-		.catch(() => {});
+	await Promise.allSettled([child.stdout.pipeTo(sink.createInput()), child.stderr.pipeTo(sink.createInput())]).catch(
+		() => {},
+	);
 
 	// Wait for process exit
 	try {
@@ -58,7 +54,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		return {
 			exitCode: child.exitCode ?? 0,
 			cancelled: false,
-			...stream.dump(),
+			...(await sink.dump()),
 		};
 	} catch (err) {
 		// Exception covers NonZeroExitError, AbortError, TimeoutError
@@ -71,7 +67,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 				return {
 					exitCode: undefined,
 					cancelled: true,
-					...stream.dump(annotation),
+					...(await sink.dump(annotation)),
 				};
 			}
 
@@ -79,60 +75,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			return {
 				exitCode: err.exitCode,
 				cancelled: false,
-				...stream.dump(),
-			};
-		}
-
-		throw err;
-	}
-}
-
-export async function executeBashWithOperations(
-	command: string,
-	cwd: string,
-	operations: BashOperations,
-	options?: BashExecutorOptions,
-): Promise<BashResult> {
-	const stream = new OutputSink({ onChunk: options?.onChunk });
-	const writable = stream.createWritable();
-	const writer = writable.getWriter();
-
-	const closeStreams = async () => {
-		try {
-			await writer.close();
-		} catch {}
-		try {
-			await writable.close();
-		} catch {}
-		try {
-			await stream.close();
-		} catch {}
-	};
-
-	try {
-		const result = await operations.exec(command, cwd, {
-			onData: (data) => writer.write(data),
-			signal: options?.signal,
-			timeout: options?.timeout,
-		});
-
-		await closeStreams();
-
-		const cancelled = options?.signal?.aborted ?? false;
-
-		return {
-			exitCode: cancelled ? undefined : (result.exitCode ?? undefined),
-			cancelled,
-			...stream.dump(),
-		};
-	} catch (err) {
-		await closeStreams();
-
-		if (options?.signal?.aborted) {
-			return {
-				exitCode: undefined,
-				cancelled: true,
-				...stream.dump(),
+				...(await sink.dump()),
 			};
 		}
 

package/src/core/extensions/types.ts

@@ -29,7 +29,6 @@ import type {
 	SessionManager,
 } from "../session-manager";
 import type { BashToolDetails, FindToolDetails, GrepToolDetails, LsToolDetails, ReadToolDetails } from "../tools";
-import type { BashOperations } from "../tools/bash";
 import type { EditToolDetails } from "../tools/patch";
 
 export type { ExecOptions, ExecResult } from "../exec";
@@ -551,8 +550,6 @@ export interface InputEventResult {
 
 /** Result from user_bash event handler */
 export interface UserBashEventResult {
-	/** Custom operations to use for execution */
-	operations?: BashOperations;
 	/** Full replacement: extension handled execution, use this result */
 	result?: BashResult;
 }

package/src/core/index.ts

@@ -11,7 +11,7 @@ export {
 	type PromptOptions,
 	type SessionStats,
 } from "./agent-session";
-export { type BashExecutorOptions, type BashResult, executeBash, executeBashWithOperations } from "./bash-executor";
+export { type BashExecutorOptions, type BashResult, executeBash } from "./bash-executor";
 export type { CompactionResult } from "./compaction/index";
 export {
 	discoverAndLoadExtensions,

package/src/core/python-executor.ts

@@ -1,4 +1,4 @@
-import { logger, sanitizeText } from "@oh-my-pi/pi-utils";
+import { logger } from "@oh-my-pi/pi-utils";
 import {
 	checkPythonKernelAvailability,
 	type KernelDisplayOutput,
@@ -210,30 +210,20 @@ async function executeWithKernel(
 	code: string,
 	options: PythonExecutorOptions | undefined,
 ): Promise<PythonResult> {
-	const sink = new OutputSink({ onLine: options?.onChunk });
+	const sink = new OutputSink({ onChunk: options?.onChunk });
 	const displayOutputs: KernelDisplayOutput[] = [];
 
 	try {
-		const writable = sink.createStringWritable();
-		const writer = writable.getWriter();
-		let result: KernelExecuteResult;
-		try {
-			result = await kernel.execute(code, {
-				signal: options?.signal,
-				timeoutMs: options?.timeout,
-				onChunk: (text) => {
-					writer.write(sanitizeText(text));
-				},
-				onDisplay: (output) => {
-					displayOutputs.push(output);
-				},
-			});
-		} catch (err) {
-			await writer.abort(err);
-			throw err;
-		} finally {
-			await writer.close().catch(() => {});
-		}
+		const result = await kernel.execute(code, {
+			signal: options?.signal,
+			timeoutMs: options?.timeout,
+			onChunk: (text) => {
+				sink.push(text);
+			},
+			onDisplay: (output) => {
+				displayOutputs.push(output);
+			},
+		});
 
 		if (result.cancelled) {
 			const secs = options?.timeout ? Math.round(options.timeout / 1000) : undefined;
@@ -244,7 +234,7 @@ async function executeWithKernel(
 				cancelled: true,
 				displayOutputs,
 				stdinRequested: result.stdinRequested,
-				...sink.dump(annotation),
+				...(await sink.dump(annotation)),
 			};
 		}
 
@@ -254,7 +244,7 @@ async function executeWithKernel(
 				cancelled: false,
 				displayOutputs,
 				stdinRequested: true,
-				...sink.dump("Kernel requested stdin; interactive input is not supported."),
+				...(await sink.dump("Kernel requested stdin; interactive input is not supported.")),
 			};
 		}
 
@@ -264,7 +254,7 @@ async function executeWithKernel(
 			cancelled: false,
 			displayOutputs,
 			stdinRequested: false,
-			...sink.dump(),
+			...(await sink.dump()),
 		};
 	} catch (err) {
 		const error = err instanceof Error ? err : new Error(String(err));

package/src/core/ssh/ssh-executor.ts

@@ -70,16 +70,11 @@ export async function executeSSH(
 		timeout: options?.timeout,
 	});
 
-	const sink = new OutputSink({ onLine: options?.onChunk });
+	const sink = new OutputSink({ onChunk: options?.onChunk });
 
-	try {
-		await Promise.allSettled([
-			child.stdout.pipeTo(sink.createWritable()),
-			child.stderr.pipeTo(sink.createWritable()),
-		]);
-	} finally {
-		await sink.close();
-	}
+	await Promise.allSettled([child.stdout.pipeTo(sink.createInput()), child.stderr.pipeTo(sink.createInput())]).catch(
+		() => {},
+	);
 
 	try {
 		await child.exited;
@@ -87,7 +82,7 @@ export async function executeSSH(
 		return {
 			exitCode,
 			cancelled: false,
-			...sink.dump(),
+			...(await sink.dump()),
 		};
 	} catch (err) {
 		if (err instanceof ptree.Exception) {
@@ -95,20 +90,20 @@ export async function executeSSH(
 				return {
 					exitCode: undefined,
 					cancelled: true,
-					...sink.dump(`SSH: ${err.message}`),
+					...(await sink.dump(`SSH: ${err.message}`)),
 				};
 			}
 			if (err.aborted) {
 				return {
 					exitCode: undefined,
 					cancelled: true,
-					...sink.dump(`SSH command aborted: ${err.message}`),
+					...(await sink.dump(`Command aborted: ${err.message}`)),
 				};
 			}
 			return {
 				exitCode: err.exitCode,
 				cancelled: false,
-				...sink.dump(`Unexpected error: ${err.message}`),
+				...(await sink.dump(`Unexpected error: ${err.message}`)),
 			};
 		}
 		throw err;

package/src/core/streaming-output.ts

@@ -2,7 +2,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_COLUMN } from "./tools/truncate";
+import { DEFAULT_MAX_BYTES } from "./tools/truncate";
 
 export interface OutputResult {
 	output: string;
@@ -14,7 +14,6 @@ export interface OutputSinkOptions {
 	allocateFilePath?: () => string;
 	spillThreshold?: number;
 	maxColumn?: number;
-	onLine?: (line: string) => void;
 	onChunk?: (chunk: string) => void;
 }
 
@@ -29,182 +28,97 @@ function defaultFilePathAllocator(): string {
  * When memory limit exceeded, spills ~half to file in one batch operation.
  */
 export class OutputSink {
-	private buffer = "";
-	private lineEnds: number[] = []; // String index after each \n
-
-	private fileSink?: Bun.FileSink;
-	private filePath?: string;
-
-	private readonly allocateFilePath: () => string;
-	private readonly spillThreshold: number;
-	private readonly maxColumn: number;
-	private readonly onLine?: (line: string) => void;
-	private readonly onChunk?: (chunk: string) => void;
+	#buffer = "";
+	#file?: {
+		path: string;
+		sink: Bun.FileSink;
+	};
+	#bytesWritten: number = 0;
+	#pending: Promise<void> = Promise.resolve();
+
+	readonly #allocateFilePath: () => string;
+	readonly #spillThreshold: number;
+	readonly #onChunk?: (chunk: string) => void;
 
 	constructor(options?: OutputSinkOptions) {
 		const {
 			allocateFilePath = defaultFilePathAllocator,
 			spillThreshold = DEFAULT_MAX_BYTES,
-			maxColumn = DEFAULT_MAX_COLUMN,
-			onLine,
 			onChunk,
 		} = options ?? {};
 
-		this.allocateFilePath = allocateFilePath;
-		this.spillThreshold = spillThreshold;
-		this.maxColumn = maxColumn;
-		this.onLine = onLine;
-		this.onChunk = onChunk;
+		this.#allocateFilePath = allocateFilePath;
+		this.#spillThreshold = spillThreshold;
+		this.#onChunk = onChunk;
 	}
 
-	private pushLine(line: string, term?: string): void {
-		while (line.length > this.maxColumn) {
-			this.pushLine(line.slice(0, this.maxColumn), "--\n");
-			line = line.slice(this.maxColumn);
-		}
+	async #pushSanitized(data: string): Promise<void> {
+		this.#onChunk?.(data);
+		const dataBytes = Buffer.byteLength(data);
+		const overflow = dataBytes + this.#bytesWritten > this.#spillThreshold || this.#file != null;
 
-		this.buffer += line;
-		if (term) {
-			this.buffer += term;
-		}
+		const sink = overflow ? await this.#fileSink() : null;
 
-		this.lineEnds.push(this.buffer.length);
-		this.onLine?.(line);
+		this.#buffer += data;
+		await sink?.write(data);
 
-		if (this.buffer.length > this.spillThreshold) {
-			this.spillHalf();
+		if (this.#buffer.length > this.#spillThreshold) {
+			this.#buffer = this.#buffer.slice(-this.#spillThreshold);
 		}
 	}
 
-	private pushChunk(line: string): void {
-		this.onChunk?.(line);
-		this.pushLine(line);
-	}
-
-	private getFileSink(): Bun.FileSink {
-		if (!this.fileSink) {
-			const filePath = this.allocateFilePath();
-			this.filePath = filePath;
-			this.fileSink = Bun.file(filePath).writer();
+	async #fileSink(): Promise<Bun.FileSink> {
+		if (!this.#file) {
+			const filePath = this.#allocateFilePath();
+			this.#file = {
+				path: filePath,
+				sink: Bun.file(filePath).writer(),
+			};
+			await this.#file.sink.write(this.#buffer);
 		}
-		return this.fileSink;
+		return this.#file.sink;
 	}
 
-	private spillHalf(): void {
-		const target = this.buffer.length >>> 1;
-
-		// Binary search: first line ending >= target
-		let lo = 0;
-		let hi = this.lineEnds.length;
-		while (lo < hi) {
-			const mid = (lo + hi) >>> 1;
-			if (this.lineEnds[mid] < target) {
-				lo = mid + 1;
-			} else {
-				hi = mid;
-			}
-		}
-
-		// Clamp: evict at least 1 line, keep at least 1 line
-		const splitIdx = Math.max(1, Math.min(lo, this.lineEnds.length - 1));
-		const splitPos = this.lineEnds[splitIdx - 1];
-
-		// Write evicted portion to file
-		this.getFileSink().write(this.buffer.slice(0, splitPos));
-
-		// Truncate buffer, shift line positions
-		this.buffer = this.buffer.slice(splitPos);
-		const remaining = this.lineEnds.length - splitIdx;
-		for (let i = 0; i < remaining; i++) {
-			this.lineEnds[i] = this.lineEnds[i + splitIdx] - splitPos;
-		}
-		this.lineEnds.length = remaining;
+	async push(chunk: string): Promise<void> {
+		chunk = sanitizeText(chunk);
+		const op = this.#pending.then(() => this.#pushSanitized(chunk));
+		this.#pending = op.catch(() => {});
+		await op;
 	}
 
-	createWritable(): WritableStream<Uint8Array> {
-		const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
-		let buf = "";
-
-		const flushLines = () => {
-			let start = 0;
-			while (true) {
-				const nl = buf.indexOf("\n", start);
-				if (nl === -1) break;
-				this.pushChunk(buf.slice(start, nl + 1));
-				start = nl + 1;
-			}
-			buf = buf.slice(start);
-		};
-
-		const finalize = () => {
-			buf += sanitizeText(decoder.decode());
-			flushLines();
-			buf = buf.trimEnd();
-			if (buf) {
-				this.pushChunk(`${buf}\n`);
-			}
-		};
-
-		return new WritableStream<Uint8Array>({
-			write: (chunk) => {
-				buf += sanitizeText(decoder.decode(chunk, { stream: true }));
-				flushLines();
+	createInput(): WritableStream<Uint8Array | string> {
+		let decoder: TextDecoder | undefined;
+		let finalize = async () => {};
+
+		return new WritableStream<Uint8Array | string>({
+			write: async (chunk) => {
+				if (typeof chunk === "string") {
+					await this.push(chunk);
+				} else {
+					if (!decoder) {
+						const dec = new TextDecoder("utf-8", { ignoreBOM: true });
+						decoder = dec;
+						finalize = async () => {
+							await this.push(dec.decode());
+						};
+					}
+					await this.push(decoder.decode(chunk, { stream: true }));
+				}
 			},
 			close: finalize,
 			abort: finalize,
 		});
 	}
 
-	createStringWritable(): WritableStream<string> {
-		let buf = "";
-
-		const flushLines = () => {
-			let start = 0;
-			while (true) {
-				const nl = buf.indexOf("\n", start);
-				if (nl === -1) break;
-				this.pushChunk(buf.slice(start, nl + 1));
-				start = nl + 1;
-			}
-			buf = buf.slice(start);
-		};
-
-		const finalize = () => {
-			flushLines();
-			buf = buf.trimEnd();
-			if (buf) {
-				this.pushChunk(`${buf}\n`);
-			}
-		};
-
-		return new WritableStream<string>({
-			write: (chunk) => {
-				buf += sanitizeText(chunk);
-				flushLines();
-			},
-			close: finalize,
-			abort: finalize,
-		});
-	}
-
-	async close(): Promise<void> {
-		await this.fileSink?.end();
-	}
+	async dump(notice?: string): Promise<OutputResult> {
+		await this.#pending;
+		const noticeLine = notice ? `[${notice}]\n` : "";
 
-	dump(annotation?: string): OutputResult {
-		let output = this.buffer;
-		if (annotation) {
-			output += `\n${annotation}\n`;
-		}
-		if (!this.filePath) {
-			return { output, truncated: false };
+		if (this.#file) {
+			await this.#file.sink.end();
+			return { output: `${noticeLine}...${this.#buffer}`, truncated: true, fullOutputPath: this.#file.path };
+		} else {
+			return { output: `${noticeLine}${this.#buffer}`, truncated: false };
 		}
-		this.fileSink!.write(this.buffer);
-		this.fileSink!.flush();
-		return {
-			output,
-			truncated: true,
-			fullOutputPath: this.filePath,
-		};
 	}
 }

package/src/core/tools/bash.ts

@@ -6,14 +6,14 @@ import { Type } from "@sinclair/typebox";
 import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
-import { type BashExecutorOptions, executeBash, executeBashWithOperations } from "../bash-executor";
+import { type BashExecutorOptions, executeBash } from "../bash-executor";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import { ToolUIKit } from "./render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+import { formatTailTruncationNotice, type TruncationResult, truncateTail } from "./truncate";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
@@ -31,32 +31,12 @@ export interface BashToolDetails {
 	fullOutput?: string;
 }
 
-/**
- * Pluggable operations for bash execution.
- * Override to delegate command execution to remote systems.
- */
-export interface BashOperations {
-	exec: (
-		command: string,
-		cwd: string,
-		options: {
-			onData: (data: Buffer) => void;
-			signal?: AbortSignal;
-			timeout?: number;
-		},
-	) => Promise<{ exitCode: number | null }>;
-}
-
-export interface BashToolOptions {
-	/** Custom operations for command execution. Default: local shell */
-	operations?: BashOperations;
-}
+export interface BashToolOptions {}
 
 /**
  * Bash tool implementation.
  *
  * Executes bash commands with optional timeout and working directory.
- * Supports custom operations for remote execution.
  */
 export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 	public readonly name = "bash";
@@ -65,11 +45,9 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 	public readonly parameters = bashSchema;
 
 	private readonly session: ToolSession;
-	private readonly options?: BashToolOptions;
 
-	constructor(session: ToolSession, options?: BashToolOptions) {
+	constructor(session: ToolSession) {
 		this.session = session;
-		this.options = options;
 		this.description = renderPromptTemplate(bashDescription);
 	}
 
@@ -125,12 +103,8 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			},
 		};
 
-		// Use custom operations if provided, otherwise use default local executor
-		const result = this.options?.operations
-			? await executeBashWithOperations(command, commandCwd, this.options.operations, executorOptions)
-			: await executeBash(command, executorOptions);
-
 		// Handle errors
+		const result = await executeBash(command, executorOptions);
 		if (result.cancelled) {
 			throw new Error(result.output || "Command aborted");
 		}
@@ -147,18 +121,10 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 				fullOutputPath: result.fullOutputPath,
 				fullOutput: currentOutput,
 			};
-
-			const startLine = truncation.totalLines - truncation.outputLines + 1;
-			const endLine = truncation.totalLines;
-
-			if (truncation.lastLinePartial) {
-				const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
-				outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
-			} else if (truncation.truncatedBy === "lines") {
-				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
-			} else {
-				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
-			}
+			outputText += formatTailTruncationNotice(truncation, {
+				fullOutputPath: result.fullOutputPath,
+				originalContent: result.output,
+			});
 		}
 
 		if (result.exitCode !== 0 && result.exitCode !== undefined) {
@@ -263,7 +229,7 @@ export const bashToolRenderer = {
 					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
 				} else {
 					warnings.push(
-						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes)} limit)`,
 					);
 				}
 			}

package/src/core/tools/index.ts

@@ -1,5 +1,5 @@
 export { AskTool, type AskToolDetails } from "./ask";
-export { type BashOperations, BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
+export { BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
 export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
 export { CompleteTool } from "./complete";
 // Exa MCP tools (22 tools)

package/src/core/tools/python.ts

@@ -14,7 +14,7 @@ import type { PreludeHelper, PythonStatusEvent } from "../python-kernel";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import { getTreeBranch, getTreeContinuePrefix, shortenPath, ToolUIKit, truncate } from "./render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+import { DEFAULT_MAX_BYTES, formatTailTruncationNotice, type TruncationResult, truncateTail } from "./truncate";
 
 export const PYTHON_DEFAULT_PREVIEW_LINES = 10;
 
@@ -234,7 +234,6 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 			let details: PythonToolDetails | undefined;
 
 			if (truncation.truncated) {
-				const fullOutputSuffix = result.fullOutputPath ? ` Full output: ${result.fullOutputPath}` : "";
 				details = {
 					truncation,
 					fullOutputPath: result.fullOutputPath,
@@ -242,18 +241,10 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 					images,
 					statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
 				};
-
-				const startLine = truncation.totalLines - truncation.outputLines + 1;
-				const endLine = truncation.totalLines;
-
-				if (truncation.lastLinePartial) {
-					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
-					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize})${fullOutputSuffix}]`;
-				} else if (truncation.truncatedBy === "lines") {
-					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}${fullOutputSuffix}]`;
-				} else {
-					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit)${fullOutputSuffix}]`;
-				}
+				outputText += formatTailTruncationNotice(truncation, {
+					fullOutputPath: result.fullOutputPath,
+					originalContent: result.output,
+				});
 			}
 
 			if (!details && (jsonOutputs.length > 0 || images.length > 0 || statusEvents.length > 0)) {
@@ -685,7 +676,7 @@ export const pythonToolRenderer = {
 					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
 				} else {
 					warnings.push(
-						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes)} limit)`,
 					);
 				}
 			}

package/src/core/tools/ssh.ts

@@ -14,7 +14,7 @@ import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import type { ToolSession } from "./index";
 import { ToolUIKit } from "./render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+import { formatTailTruncationNotice, type TruncationResult, truncateTail } from "./truncate";
 
 const sshSchema = Type.Object({
 	host: Type.String({ description: "Host name from ssh.json or .ssh.json" }),
@@ -193,18 +193,10 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 				truncation,
 				fullOutputPath: result.fullOutputPath,
 			};
-
-			const startLine = truncation.totalLines - truncation.outputLines + 1;
-			const endLine = truncation.totalLines;
-
-			if (truncation.lastLinePartial) {
-				const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
-				outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
-			} else if (truncation.truncatedBy === "lines") {
-				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
-			} else {
-				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
-			}
+			outputText += formatTailTruncationNotice(truncation, {
+				fullOutputPath: result.fullOutputPath,
+				originalContent: result.output,
+			});
 		}
 
 		if (result.exitCode !== 0 && result.exitCode !== undefined) {
@@ -311,7 +303,7 @@ export const sshToolRenderer = {
 					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
 				} else {
 					warnings.push(
-						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes)} limit)`,
 					);
 				}
 			}

package/src/core/tools/truncate.ts

@@ -289,3 +289,95 @@ export function truncateLine(
 	}
 	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
 }
+
+// =============================================================================
+// Truncation notice formatting
+// =============================================================================
+
+export interface TailTruncationNoticeOptions {
+	/** Path to full output file (e.g., from bash/python executor) */
+	fullOutputPath?: string;
+	/** Original content for computing last line size when lastLinePartial */
+	originalContent?: string;
+	/** Additional suffix to append inside the brackets */
+	suffix?: string;
+}
+
+/**
+ * Format a truncation notice for tail-truncated output (bash, python, ssh).
+ * Returns empty string if not truncated.
+ *
+ * Examples:
+ * - "[Showing last 50KB of line 1000 (line is 2.1MB). Full output: /tmp/out.txt]"
+ * - "[Showing lines 500-1000 of 1000. Full output: /tmp/out.txt]"
+ * - "[Showing lines 500-1000 of 1000 (50KB limit). Full output: /tmp/out.txt]"
+ */
+export function formatTailTruncationNotice(
+	truncation: TruncationResult,
+	options: TailTruncationNoticeOptions = {},
+): string {
+	if (!truncation.truncated) {
+		return "";
+	}
+
+	const { fullOutputPath, originalContent, suffix = "" } = options;
+	const startLine = truncation.totalLines - truncation.outputLines + 1;
+	const endLine = truncation.totalLines;
+	const fullOutputPart = fullOutputPath ? `. Full output: ${fullOutputPath}` : "";
+
+	let notice: string;
+
+	if (truncation.lastLinePartial) {
+		let lastLineSizePart = "";
+		if (originalContent) {
+			const lastLine = originalContent.split("\n").pop() || "";
+			lastLineSizePart = ` (line is ${formatSize(Buffer.byteLength(lastLine, "utf-8"))})`;
+		}
+		notice = `[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}${lastLineSizePart}${fullOutputPart}${suffix}]`;
+	} else if (truncation.truncatedBy === "lines") {
+		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}${fullOutputPart}${suffix}]`;
+	} else {
+		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit)${fullOutputPart}${suffix}]`;
+	}
+
+	return `\n\n${notice}`;
+}
+
+export interface HeadTruncationNoticeOptions {
+	/** 1-indexed start line number (default: 1) */
+	startLine?: number;
+	/** Total lines in the original file (for "of N" display) */
+	totalFileLines?: number;
+}
+
+/**
+ * Format a truncation notice for head-truncated output (read tool).
+ * Returns empty string if not truncated.
+ *
+ * Examples:
+ * - "[Showing lines 1-2000 of 5000. Use offset=2001 to continue]"
+ * - "[Showing lines 100-2099 of 5000 (50KB limit). Use offset=2100 to continue]"
+ */
+export function formatHeadTruncationNotice(
+	truncation: TruncationResult,
+	options: HeadTruncationNoticeOptions = {},
+): string {
+	if (!truncation.truncated) {
+		return "";
+	}
+
+	const startLineDisplay = options.startLine ?? 1;
+	const totalFileLines = options.totalFileLines ?? truncation.totalLines;
+	const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+	const nextOffset = endLineDisplay + 1;
+
+	let notice: string;
+
+	if (truncation.truncatedBy === "lines") {
+		notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
+	} else {
+		notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(truncation.maxBytes)} limit). Use offset=${nextOffset} to continue]`;
+	}
+
+	return `\n\n${notice}`;
+}

package/src/core/tools/web-fetch.ts

@@ -24,7 +24,9 @@ import { convertWithMarkitdown, fetchBinary } from "./web-scrapers/utils";
 // Types and Constants
 // =============================================================================
 
-const DEFAULT_TIMEOUT = 20;
+const MIN_TIMEOUT = 1_000;
+const DEFAULT_TIMEOUT = 20_000;
+const MAX_TIMEOUT = 45_000;
 
 // Convertible document types (markitdown supported)
 const CONVERTIBLE_MIMES = new Set([
@@ -109,7 +111,7 @@ async function exec(
 ): Promise<{ stdout: string; stderr: string; ok: boolean }> {
 	const proc = ptree.cspawn([cmd, ...args], {
 		stdin: options?.input ? "pipe" : null,
-		timeout: options?.timeout,
+		timeout: options?.timeout ? options.timeout * 1000 : undefined,
 	});
 
 	if (options?.input) {
@@ -244,7 +246,7 @@ async function tryMdSuffix(url: string, timeout: number, signal?: AbortSignal):
 		if (signal?.aborted) {
 			return null;
 		}
-		const result = await loadPage(candidate, { timeout: Math.min(timeout, 5), signal });
+		const result = await loadPage(candidate, { timeout: Math.min(timeout, MAX_TIMEOUT), signal });
 		if (result.ok && result.content.trim().length > 100 && !looksLikeHtml(result.content)) {
 			return result.content;
 		}
@@ -910,7 +912,7 @@ export class WebFetchTool implements AgentTool<typeof webFetchSchema, WebFetchTo
 		}
 
 		// Clamp timeout
-		const effectiveTimeout = Math.min(Math.max(timeout, 1), 120);
+		const effectiveTimeout = Math.min(Math.max(timeout, MIN_TIMEOUT), MAX_TIMEOUT);
 
 		const result = await renderUrl(url, effectiveTimeout, raw, signal);
 

package/src/core/tools/web-scrapers/utils.ts

@@ -1,36 +1,13 @@
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
-import { $ } from "bun";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import { createRequestSignal } from "./types";
 
 const MAX_BYTES = 50 * 1024 * 1024; // 50MB for binary files
 
-interface ExecResult {
-	stdout: string;
-	stderr: string;
-	ok: boolean;
-	exitCode: number;
-}
-
-async function exec(
-	cmd: string,
-	args: string[],
-	options?: { timeout?: number; input?: string | Buffer },
-): Promise<ExecResult> {
-	void options;
-	const result = await $`${cmd} ${args}`.quiet().nothrow();
-	const decoder = new TextDecoder();
-	return {
-		stdout: result.stdout ? decoder.decode(result.stdout) : "",
-		stderr: result.stderr ? decoder.decode(result.stderr) : "",
-		ok: result.exitCode === 0,
-		exitCode: result.exitCode ?? -1,
-	};
-}
-
 export interface ConvertResult {
 	content: string;
 	ok: boolean;
@@ -72,16 +49,16 @@ export async function convertWithMarkitdown(
 
 	try {
 		await Bun.write(tmpFile, content);
-		const result = await exec(markitdown, [tmpFile], { timeout });
-		if (!result.ok) {
-			const stderr = result.stderr.trim();
+		const result = await ptree.cspawn([markitdown, tmpFile], { timeout });
+		const [stdout, stderr, exitCode] = await Promise.all([result.stdout.text(), result.stderr.text(), result.exited]);
+		if (exitCode !== 0) {
 			return {
-				content: result.stdout,
+				content: stdout,
 				ok: false,
-				error: stderr.length > 0 ? stderr : `markitdown failed (exit ${result.exitCode})`,
+				error: stderr.length > 0 ? stderr : `markitdown failed (exit ${exitCode})`,
 			};
 		}
-		return { content: result.stdout, ok: true };
+		return { content: stdout, ok: true };
 	} finally {
 		try {
 			await rm(tmpFile, { force: true });

package/src/core/tools/web-search/providers/anthropic.ts

@@ -64,7 +64,6 @@ function buildSystemBlocks(
 
 	return buildAnthropicSystemBlocks(systemPrompt, {
 		includeClaudeCodeInstruction: includeClaudeCode,
-		includeCacheControl: auth.isOAuth,
 		extraInstructions,
 	});
 }

package/src/index.ts

@@ -194,7 +194,6 @@ export {
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./core/slash-commands";
 // Tools (detail types and utilities)
 export {
-	type BashOperations,
 	type BashToolDetails,
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,