@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.1

package/src/tools/bash.ts

@@ -17,7 +17,7 @@ import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { highlightCode, type Theme } from "../modes/theme/theme";
 import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
 import type { ClientBridgeTerminalExitStatus, ClientBridgeTerminalOutput } from "../session/client-bridge";
-import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
+import { DEFAULT_MAX_BYTES, enforceInlineByteCap, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
@@ -429,7 +429,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 	}
 
-	#buildCompletedResult(
+	async #buildCompletedResult(
 		result: BashResult | BashInteractiveResult,
 		timeoutSec: number,
 		options: {
@@ -438,7 +438,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			terminalId?: string;
 			wallTimeMs?: number;
 		} = {},
-	): AgentToolResult<BashToolDetails> {
+	): Promise<AgentToolResult<BashToolDetails>> {
 		const exitCode = result.exitCode;
 		const failedExit = exitCode !== undefined && exitCode !== 0;
 
@@ -472,7 +472,17 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		if (failedExit) {
 			details.exitCode = exitCode;
 		}
-		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
+		// Final defense at the tool-result boundary: no bash path (client bridge,
+		// head-retention spill, minimizer miss) may emit more than
+		// ~DEFAULT_MAX_BYTES inline. No-op for already-bounded output.
+		const cappedOutputText = await enforceInlineByteCap(outputText, {
+			label: "bash output",
+			saveArtifact: full => saveBashOriginalArtifact(this.session, full),
+		});
+
+		const resultBuilder = toolResult(details)
+			.text(cappedOutputText)
+			.truncationFromSummary(result, { direction: "tail" });
 		if (failedExit) resultBuilder.error();
 		return resultBuilder.done();
 	}
@@ -560,7 +570,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 						onMinimizedSave: originalText => saveBashOriginalArtifact(this.session, originalText),
 					});
 					const wallTimeMs = performance.now() - wallTimeStart;
-					const finalResult = this.#buildCompletedResult(result, options.timeoutSec, {
+					const finalResult = await this.#buildCompletedResult(result, options.timeoutSec, {
 						requestedTimeoutSec: options.requestedTimeoutSec,
 						notices: options.notices ?? [],
 						wallTimeMs,

package/src/tools/browser/tab-worker.ts

@@ -10,6 +10,7 @@ import type {
 	ElementHandle,
 	ElementScreenshotOptions,
 	HTTPResponse,
+	ImageFormat,
 	KeyInput,
 	Page,
 	SerializedAXNode,
@@ -436,6 +437,19 @@ export function describeScreenshot(opts?: ScreenshotOptions): string {
 	return "tab.screenshot()";
 }
 
+/** Map an explicit save path's extension to a puppeteer capture format (default png). */
+export function imageFormatForPath(filePath: string): ImageFormat {
+	switch (path.extname(filePath).toLowerCase()) {
+		case ".webp":
+			return "webp";
+		case ".jpg":
+		case ".jpeg":
+			return "jpeg";
+		default:
+			return "png";
+	}
+}
+
 /** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
 export function describeInflight(inflight: Map<number, InflightOp>): string {
 	const now = Date.now();
@@ -931,6 +945,12 @@ export class WorkerCore {
 	): Promise<ScreenshotResult> {
 		const page = this.#requirePage();
 		const fullPage = opts.selector ? false : (opts.fullPage ?? false);
+		// An explicit save path picks the full-res capture format: puppeteer encodes
+		// png/jpeg/webp natively, so `save: "shot.webp"` gets real WebP bytes instead
+		// of PNG bytes hiding behind a .webp name. Unknown/missing extensions stay PNG.
+		const explicitPath = opts.save ? resolveToCwd(opts.save, session.cwd) : undefined;
+		const captureType = explicitPath ? imageFormatForPath(explicitPath) : "png";
+		const captureMime = `image/${captureType}` as const;
 		let buffer: Buffer;
 		if (opts.selector) {
 			const handle = (await untilAborted(signal, () =>
@@ -951,24 +971,23 @@ export class WorkerCore {
 				).catch(() => undefined);
 				// scrollIntoView:false skips the same IntersectionObserver check inside screenshot();
 				// captureBeyondViewport (puppeteer's default) still renders the clipped region.
-				const shotOpts: ElementScreenshotOptions = { type: "png", scrollIntoView: false };
+				const shotOpts: ElementScreenshotOptions = { type: captureType, scrollIntoView: false };
 				buffer = (await untilAborted(signal, () => handle.screenshot(shotOpts))) as Buffer;
 			} finally {
 				await handle.dispose().catch(() => undefined);
 			}
 		} else {
-			buffer = (await untilAborted(signal, () => page.screenshot({ type: "png", fullPage }))) as Buffer;
+			buffer = (await untilAborted(signal, () => page.screenshot({ type: captureType, fullPage }))) as Buffer;
 		}
 		const resized = await resizeImage(
-			{ type: "image", data: buffer.toBase64(), mimeType: "image/png" },
+			{ type: "image", data: buffer.toBase64(), mimeType: captureMime },
 			{ maxWidth: 1024, maxHeight: 1024, maxBytes: 150 * 1024, jpegQuality: 70 },
 		);
-		const explicitPath = opts.save ? resolveToCwd(opts.save, session.cwd) : undefined;
 		const saveFullRes = !!(explicitPath || session.browserScreenshotDir);
 		const savedBuffer = saveFullRes ? buffer : resized.buffer;
-		const savedMimeType = saveFullRes ? "image/png" : resized.mimeType;
-		// Auto-generated names must match the bytes we actually write: full-res is always
-		// PNG, but the resized buffer is whichever of PNG/JPEG/WebP encoded smallest.
+		const savedMimeType = saveFullRes ? captureMime : resized.mimeType;
+		// Names must match the bytes we actually write: full-res follows the capture
+		// format, the resized buffer is whichever of PNG/JPEG/WebP encoded smallest.
 		const ext = savedMimeType === "image/webp" ? "webp" : savedMimeType === "image/jpeg" ? "jpg" : "png";
 		const dest =
 			explicitPath ??

package/src/tools/browser.ts

@@ -3,6 +3,7 @@ import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
+import { enforceInlineByteCap } from "../session/streaming-output";
 import { truncateForPrompt } from "./approval";
 import { acquireBrowser, type BrowserHandle, type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
@@ -271,11 +272,37 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 			.filter((c): c is { type: "text"; text: string } => c.type === "text")
 			.map(c => c.text)
 			.join("\n");
-		details.result = textOnly;
+		// Final defense at the tool-result boundary: a single run can display
+		// tens of KB (large JSON returns, dumped observations). Cap the combined
+		// text inline; the full text stays recoverable via the artifact footer
+		// when allocation succeeds.
+		const cappedText = await enforceInlineByteCap(textOnly, {
+			label: "browser output",
+			saveArtifact: full => saveBrowserOutputArtifact(this.session, full),
+		});
+		details.result = cappedText;
+		if (cappedText !== textOnly) {
+			const nonText = content.filter(c => c.type !== "text");
+			return toolResult(details)
+				.content([...nonText, { type: "text", text: cappedText }])
+				.done();
+		}
 		return toolResult(details).content(content).done();
 	}
 }
 
+/** Persist over-cap browser run output as a session artifact; mirrors the bash minimizer's save path. */
+async function saveBrowserOutputArtifact(session: ToolSession, fullText: string): Promise<string | undefined> {
+	try {
+		const alloc = await session.allocateOutputArtifact?.("browser-original");
+		if (!alloc?.path || !alloc.id) return undefined;
+		await Bun.write(alloc.path, fullText);
+		return alloc.id;
+	} catch {
+		return undefined;
+	}
+}
+
 function describeBrowser(handle: BrowserHandle): string {
 	switch (handle.kind.kind) {
 		case "headless":

package/src/tools/find.ts

@@ -4,7 +4,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import * as natives from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
+import { formatGroupedPaths, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
@@ -13,7 +13,6 @@ import findDescription from "../prompts/tools/find.md" with { type: "text" };
 import { type TruncationResult, truncateHead } from "../session/streaming-output";
 import { Ellipsis, fileHyperlink, renderFileList, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
-import { buildPathTree, walkPathTree } from "./grouped-file-output";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
@@ -54,30 +53,6 @@ const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
 
-/**
- * Group find matches into a multi-level directory tree so the model doesn't pay
- * repeated tokens for shared path prefixes. Single-child directory chains fold
- * into one header (`# a/b/c/`), so a common prefix — including an absolute root
- * for out-of-cwd results — collapses to a single line. Each level adds one `#`;
- * files are listed bare under the deepest directory header that owns them.
- *
- * Order follows the input (mtime-desc for native glob): a directory appears when
- * its first member is emitted, and a node's own files precede its subdirectories.
- */
-export function formatFindGroupedOutput(paths: readonly string[]): string {
-	if (paths.length === 0) return "";
-	const tree = buildPathTree(paths.map(entry => ({ path: entry, isDir: entry.endsWith("/") })));
-	const lines: string[] = [];
-	for (const event of walkPathTree(tree)) {
-		if (event.kind === "dir") {
-			lines.push(`${"#".repeat(event.depth + 1)} ${event.name}/`);
-		} else {
-			lines.push(event.name);
-		}
-	}
-	return lines.join("\n");
-}
-
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -270,7 +245,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const listLimit = applyListLimit(files, { limit: effectiveLimit });
 				const limited = listLimit.items;
 				const limitMeta = listLimit.meta;
-				const baseOutput = formatFindGroupedOutput(limited);
+				const baseOutput = formatGroupedPaths(limited);
 				const trailingNotes: string[] = [];
 				if (notice) trailingNotes.push(notice);
 				if (missingPathsNote) trailingNotes.push(missingPathsNote);

package/src/tools/grouped-file-output.ts

@@ -1,123 +1,6 @@
 import path from "node:path";
 
-const URL_LIKE_PATH_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
-
-function isUrlLikePath(filePath: string): boolean {
-	return URL_LIKE_PATH_RE.test(filePath);
-}
-
-// =============================================================================
-// Multi-level path tree
-// =============================================================================
-//
-// File listings (grep / ast-grep / ast-edit / lsp diagnostics / find) used to
-// group by the *immediate* parent directory and print the full directory path in
-// every header. For results spread across a deep tree — or rooted outside cwd,
-// where paths stay absolute — that repeated the shared prefix on every line. The
-// tree below folds single-child directory chains (so the common prefix collapses
-// into one header) and nests the rest, charging the model one token per path
-// segment instead of one per file.
-
-interface PathTreeNode {
-	/** Direct file leaves, in first-seen order. */
-	files: Array<{ name: string; key: string }>;
-	/** Dedup set for `files` (a glob can surface the same path twice on retry). */
-	fileNames: Set<string>;
-	/** Child directories, in first-seen order. */
-	subdirs: Array<{ name: string; node: PathTreeNode }>;
-	/** Dedup index for `subdirs`. */
-	dirIndex: Map<string, PathTreeNode>;
-}
-
-export interface PathTreeInput {
-	/** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
-	path: string;
-	/** Whether the leaf itself is a directory (trailing-slash match from find). */
-	isDir: boolean;
-	/** Opaque key carried onto file events for section lookup. Defaults to `path`. */
-	key?: string;
-}
-
-/** One node emitted while walking the tree: a folded directory or a file leaf. */
-export interface GroupedTreeEvent {
-	kind: "dir" | "file";
-	/** 0-based nesting depth (root children are depth 0). */
-	depth: number;
-	/** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
-	name: string;
-	/** File key for `kind === "file"`; empty string for directories. */
-	key: string;
-}
-
-function createNode(): PathTreeNode {
-	return { files: [], fileNames: new Set(), subdirs: [], dirIndex: new Map() };
-}
-
-function addFile(node: PathTreeNode, name: string, key: string): void {
-	if (node.fileNames.has(name)) return;
-	node.fileNames.add(name);
-	node.files.push({ name, key });
-}
-
-/**
- * Build a directory tree from a flat list of paths. URL-like entries are kept
- * whole as root-level file leaves (they have no meaningful directory structure).
- * Absolute paths carry a leading empty segment so they share a common `/` root
- * and fold like any other prefix.
- */
-export function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode {
-	const root = createNode();
-	for (const { path: rawPath, isDir, key } of entries) {
-		const normalized = rawPath.replace(/\\/g, "/");
-		const fileKey = key ?? rawPath;
-		if (isUrlLikePath(normalized)) {
-			addFile(root, normalized, fileKey);
-			continue;
-		}
-		const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-		if (trimmed.length === 0) continue;
-		const segments = trimmed.split("/");
-		const dirCount = isDir ? segments.length : segments.length - 1;
-		let node = root;
-		for (let i = 0; i < dirCount; i++) {
-			const segment = segments[i]!;
-			let child = node.dirIndex.get(segment);
-			if (!child) {
-				child = createNode();
-				node.dirIndex.set(segment, child);
-				node.subdirs.push({ name: segment, node: child });
-			}
-			node = child;
-		}
-		if (!isDir) {
-			addFile(node, segments[segments.length - 1]!, fileKey);
-		}
-	}
-	return root;
-}
-
-/**
- * Depth-first walk yielding directory and file events. Directories collapse their
- * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
- * header. Each node's direct files are emitted before its subdirectories, keeping
- * a file unambiguously attached to the header above it.
- */
-export function* walkPathTree(node: PathTreeNode, depth = 0): Generator<GroupedTreeEvent> {
-	for (const file of node.files) {
-		yield { kind: "file", depth, name: file.name, key: file.key };
-	}
-	for (const subdir of node.subdirs) {
-		let dirNode = subdir.node;
-		const parts = [subdir.name];
-		while (dirNode.files.length === 0 && dirNode.subdirs.length === 1) {
-			const only = dirNode.subdirs[0]!;
-			parts.push(only.name);
-			dirNode = only.node;
-		}
-		yield { kind: "dir", depth, name: parts.join("/"), key: "" };
-		yield* walkPathTree(dirNode, depth + 1);
-	}
-}
+import { buildPathTree, isUrlLikePath, type PathTreeInput, walkPathTree } from "@oh-my-pi/pi-utils";
 
 // =============================================================================
 // Grouped file output (grep / ast-grep / ast-edit / lsp diagnostics)

package/src/tools/index.ts

@@ -18,7 +18,7 @@ import { LspTool } from "../lsp";
 import type { MCPManager } from "../mcp";
 import type { MnemopiSessionState } from "../mnemopi/state";
 import type { PlanModeState } from "../plan-mode/state";
-import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
+import type { AgentRegistry } from "../registry/agent-registry";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
@@ -42,7 +42,7 @@ import { resolveEvalBackends } from "./eval-backends";
 import { FindTool } from "./find";
 import { GithubTool } from "./gh";
 import { InspectImageTool } from "./inspect-image";
-import { IrcTool } from "./irc";
+import { IrcTool, isIrcEnabled } from "./irc";
 import { JobTool } from "./job";
 import { MemoryEditTool } from "./memory-edit";
 import { MemoryRecallTool } from "./memory-recall";
@@ -260,8 +260,6 @@ export interface ToolSession {
 	recordEvalSubagentUsage?: (output: number) => void;
 	/** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
 	getClientBridge?: () => ClientBridge | undefined;
-	/** Get compact conversation context for subagents (excludes tool results, system prompts) */
-	getCompactContext?: () => string;
 	/** Get cached todo phases for this session. */
 	getTodoPhases?: () => TodoPhase[];
 	/** Replace cached todo phases for this session. */
@@ -420,7 +418,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	checkpoint: CheckpointTool.createIf,
 	rewind: RewindTool.createIf,
 	task: s => TaskTool.create(s),
-	job: JobTool.createIf,
+	job: s => new JobTool(s),
 	irc: IrcTool.createIf,
 	todo: s => new TodoTool(s),
 	web_search: s => new WebSearchTool(s),
@@ -539,13 +537,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "search_tool_bm25") return discoveryActive;
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
-		if (name === "irc") {
-			if (!session.settings.get("irc.enabled")) return false;
-			// Main agent only needs `irc` when subagents may run concurrently (async).
-			// In sync mode main blocks on `task`, so peer messaging from main is dead weight.
-			if (!session.settings.get("async.enabled") && session.getAgentId?.() === MAIN_AGENT_ID) return false;
-			return true;
-		}
+		if (name === "irc") return isIrcEnabled(session.settings, session.taskDepth ?? 0);
 		if (name === "retain" || name === "recall" || name === "reflect") {
 			return ["hindsight", "mnemopi"].includes(session.settings.get("memory.backend") ?? "");
 		}