@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

package/node_modules/@herbertgao/sol-pi/src/sol-pi/config.ts

@@ -0,0 +1,135 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+	DEFAULT_REDUCER_MODEL,
+	DEFAULT_REDUCER_PROVIDER,
+} from "./extensions/evidence-preserving-reducer/config.ts";
+
+export const DEFAULT_CACHE_WRITE_READ_RATIO = 12.5;
+
+export interface SolPiConfig {
+	readonly version: 1;
+	readonly actionFusion: boolean;
+	readonly observationPack: boolean;
+	readonly evidencePreservingReducer: boolean;
+	readonly evidencePreservingReducerModel: string;
+	readonly evidencePreservingReducerProvider: string;
+	readonly onlineContextCompact: boolean;
+	readonly cacheWriteReadRatio: number;
+}
+
+export const DEFAULT_CONFIG: SolPiConfig = Object.freeze({
+	version: 1,
+	actionFusion: false,
+	observationPack: false,
+	evidencePreservingReducer: false,
+	evidencePreservingReducerModel: DEFAULT_REDUCER_MODEL,
+	evidencePreservingReducerProvider: DEFAULT_REDUCER_PROVIDER,
+	onlineContextCompact: false,
+	cacheWriteReadRatio: DEFAULT_CACHE_WRITE_READ_RATIO,
+});
+
+const FEATURE_KEYS = [
+	"actionFusion",
+	"observationPack",
+	"evidencePreservingReducer",
+	"onlineContextCompact",
+] as const;
+const STRING_KEYS = ["evidencePreservingReducerModel", "evidencePreservingReducerProvider"] as const;
+const CONFIG_KEYS = new Set<string>(["version", ...FEATURE_KEYS, ...STRING_KEYS, "cacheWriteReadRatio"]);
+
+export function findConfigPath(
+	cwd = process.cwd(),
+	agentDir = getAgentDir(),
+	allowProjectConfig = false,
+): string | undefined {
+	if (allowProjectConfig) {
+		const projectPath = join(cwd, CONFIG_DIR_NAME, "sol-pi.json");
+		if (existsSync(projectPath)) return projectPath;
+	}
+
+	const globalPath = join(agentDir, "sol-pi.json");
+	return existsSync(globalPath) ? globalPath : undefined;
+}
+
+export function loadSolPiConfig(
+	cwd = process.cwd(),
+	agentDir = getAgentDir(),
+	allowProjectConfig = false,
+): SolPiConfig {
+	const path = findConfigPath(cwd, agentDir, allowProjectConfig);
+	if (!path) return DEFAULT_CONFIG;
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new Error(`Unable to read SoL-Pi config ${path}: ${reason}`, { cause: error });
+	}
+
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		throw new Error(`SoL-Pi config must be a JSON object: ${path}`);
+	}
+
+	const record = parsed as Record<string, unknown>;
+	for (const key of Object.keys(record)) {
+		if (!CONFIG_KEYS.has(key)) throw new Error(`Unknown SoL-Pi config key: ${key}`);
+	}
+	if (record.version !== 1) throw new Error(`SoL-Pi config version must be 1: ${path}`);
+
+	for (const key of FEATURE_KEYS) {
+		if (record[key] !== undefined && typeof record[key] !== "boolean") {
+			throw new Error(`SoL-Pi config ${key} must be boolean: ${path}`);
+		}
+	}
+	const cacheWriteReadRatio = Object.hasOwn(record, "cacheWriteReadRatio")
+		? record.cacheWriteReadRatio
+		: DEFAULT_CACHE_WRITE_READ_RATIO;
+	if (
+		typeof cacheWriteReadRatio !== "number" ||
+		!Number.isFinite(cacheWriteReadRatio) ||
+		cacheWriteReadRatio < 0
+	) {
+		throw new Error(`SoL-Pi config cacheWriteReadRatio must be a finite non-negative number: ${path}`);
+	}
+	const evidencePreservingReducerModel = stringConfigValue(
+		record,
+		"evidencePreservingReducerModel",
+		DEFAULT_REDUCER_MODEL,
+		path,
+	);
+	const evidencePreservingReducerProvider = stringConfigValue(
+		record,
+		"evidencePreservingReducerProvider",
+		DEFAULT_REDUCER_PROVIDER,
+		path,
+	);
+
+	return Object.freeze({
+		...DEFAULT_CONFIG,
+		...record,
+		cacheWriteReadRatio,
+		evidencePreservingReducerModel,
+		evidencePreservingReducerProvider,
+	}) as SolPiConfig;
+}
+
+function stringConfigValue(
+	record: Record<string, unknown>,
+	key: (typeof STRING_KEYS)[number],
+	defaultValue: string,
+	path: string,
+): string {
+	const value = Object.hasOwn(record, key) ? record[key] : defaultValue;
+	if (typeof value !== "string" || value.trim().length === 0) {
+		throw new Error(`SoL-Pi config ${key} must be a non-empty string: ${path}`);
+	}
+	return value;
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/action-fusion/file-queue.ts

@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const queueTails = new Map<string, Promise<void>>();
+
+function stripToolPathPrefix(filePath: string): string {
+	return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+
+export function resolveToolPath(cwd: string, filePath: string): string {
+	const stripped = stripToolPathPrefix(filePath);
+	// Pi accepts file URLs; the queue and hash guard must use the same target.
+	const expanded = stripped.startsWith("file://") ? fileURLToPath(stripped) : stripped;
+	if (expanded === "~") return homedir();
+	if (expanded.startsWith("~/")) return resolve(homedir(), expanded.slice(2));
+	return resolve(cwd, expanded);
+}
+
+function isMissingPathError(error: unknown): boolean {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		(error.code === "ENOENT" || error.code === "ENOTDIR")
+	);
+}
+
+async function canonicalQueueKey(filePath: string): Promise<string> {
+	const resolvedPath = resolve(filePath);
+	let current = resolvedPath;
+	const missingSegments: string[] = [];
+
+	while (true) {
+		try {
+			return resolve(await realpath(current), ...missingSegments);
+		} catch (error) {
+			if (!isMissingPathError(error)) throw error;
+			const parent = dirname(current);
+			if (parent === current) return resolvedPath;
+			missingSegments.unshift(basename(current));
+			current = parent;
+		}
+	}
+}
+
+/**
+ * Serialize fused operations for one canonical file path. This queue belongs
+ * to SoL-Pi and intentionally does not nest Pi's built-in mutation queue.
+ */
+export async function withFusedFileQueue<T>(filePath: string, work: () => Promise<T>): Promise<T> {
+	const key = await canonicalQueueKey(filePath);
+	const previous = queueTails.get(key) ?? Promise.resolve();
+	let release!: () => void;
+	const owned = new Promise<void>((resolveOwned) => {
+		release = resolveOwned;
+	});
+	const tail = previous.then(() => owned);
+	queueTails.set(key, tail);
+
+	await previous;
+	try {
+		return await work();
+	} finally {
+		release();
+		if (queueTails.get(key) === tail) queueTails.delete(key);
+	}
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/action-fusion/index.ts

@@ -0,0 +1,185 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Action Fusion - fuse a file mutation and its follow-up command into one turn.
+ *
+ * Base pi rollouts repeatedly showed the same pair of turns: edit or write a
+ * file, then run a command to test, build, or start it. This extension replaces
+ * the built-in `edit` and `write` tools with versions that take an optional
+ * `then_run` object, apply the mutation, run the command, and return one
+ * combined observation. The model decision between the two turns disappears.
+ *
+ * Everything else about `edit` and `write` is inherited from the built-in
+ * definitions: their schemas, prompt text, argument shims, and renderers.
+ *
+ * This standalone version composes only Pi's public tool definitions.
+ */
+
+import {
+	type BashToolOptions,
+	createEditToolDefinition,
+	createWriteToolDefinition,
+	type EditToolDetails,
+	type EditToolOptions,
+	type ExtensionAPI,
+	type ExtensionFactory,
+	type WriteToolOptions,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { resolveToolPath } from "./file-queue.ts";
+import { renderSolPiTool, showSolPiSavings } from "../../tui.ts";
+import {
+	createThenRunSchema,
+	executeMutationThenRun,
+	THEN_RUN_SUCCEEDED,
+	type ThenRunInput,
+} from "./then-run.ts";
+
+const EDIT_THEN_RUN_DESCRIPTION =
+	"Command to run next on this file after the edit succeeds — e.g. run, build, start/restart, install, or check it; optional timeout in seconds. Skipped if the edit fails; a non-zero exit is reported but keeps the edit.";
+const WRITE_THEN_RUN_DESCRIPTION =
+	"Command to run next on this file after the write succeeds — e.g. run, build, start/restart, install, or check it; optional timeout in seconds. Skipped if the write fails; a non-zero exit is reported but keeps the write.";
+
+export interface ActionFusionOptions {
+	/** Optional programmatic bash overrides, primarily for tests and embedded runtimes. */
+	readonly bashOptions?: BashToolOptions;
+	/** Overrides for the underlying built-in `edit` tool. */
+	readonly editOptions?: EditToolOptions;
+	/** Overrides for the underlying built-in `write` tool. */
+	readonly writeOptions?: WriteToolOptions;
+}
+
+/**
+ * Built-in tool definitions capture their cwd in closures, so keep one per
+ * working directory instead of rebuilding them on every call and every redraw.
+ */
+function memoizeByCwd<T>(create: (cwd: string) => T): (cwd: string) => T {
+	const cache = new Map<string, T>();
+	return (cwd) => {
+		const cached = cache.get(cwd);
+		if (cached) return cached;
+		const created = create(cwd);
+		cache.set(cwd, created);
+		return created;
+	};
+}
+
+function hasExternalToolOwner(pi: ExtensionAPI, name: string): boolean {
+	try {
+		const tool = pi.getAllTools().find((candidate) => candidate.name === name);
+		return Boolean(tool && tool.sourceInfo.source !== "builtin");
+	} catch {
+		return false;
+	}
+}
+
+export function createActionFusionExtension(options: ActionFusionOptions = {}): ExtensionFactory {
+	const baseEdit = memoizeByCwd((cwd: string) => createEditToolDefinition(cwd, options.editOptions));
+	const baseWrite = memoizeByCwd((cwd: string) => createWriteToolDefinition(cwd, options.writeOptions));
+
+	return (pi: ExtensionAPI) => {
+		// then_run executes Bash inside the mutation tool, so it cannot pass through
+		// Pi's public tool_call permission handlers. Leave it to automode instead of
+		// creating a nested shell escape hatch.
+		if (hasExternalToolOwner(pi, "automode_inspect")) return;
+
+		const editTemplate = baseEdit(process.cwd());
+		const writeTemplate = baseWrite(process.cwd());
+
+		const editParameters = Type.Object({
+			...editTemplate.parameters.properties,
+			then_run: createThenRunSchema(EDIT_THEN_RUN_DESCRIPTION),
+		});
+		const writeParameters = Type.Object({
+			...writeTemplate.parameters.properties,
+			then_run: createThenRunSchema(WRITE_THEN_RUN_DESCRIPTION),
+		});
+
+		pi.registerTool<typeof editParameters, EditToolDetails | undefined>({
+			...editTemplate,
+			parameters: editParameters,
+			async execute(toolCallId, input, signal, onUpdate, ctx) {
+				const { then_run, ...editInput } = input as typeof input & { then_run?: ThenRunInput };
+				const result = await executeMutationThenRun({
+					toolCallId,
+					absolutePath: resolveToolPath(ctx.cwd, input.path),
+					thenRun: then_run,
+					bashOptions: options.bashOptions,
+					signal,
+					ctx,
+					mutate: () => baseEdit(ctx.cwd).execute(toolCallId, editInput, signal, onUpdate, ctx),
+				});
+				if (
+					then_run &&
+					result.content.some((block) => block.type === "text" && block.text.includes(THEN_RUN_SUCCEEDED))
+				) {
+					showSolPiSavings(ctx, "Action Fusion", "1 model round-trip avoided");
+				}
+				return result;
+			},
+			renderCall: (args, theme, context) => {
+				const base = baseEdit(context.cwd).renderCall!(args, theme, context);
+				return args.then_run ? renderSolPiTool(theme, "Action Fusion", "1 model round-trip avoided", base) : base;
+			},
+			renderResult: (result, resultOptions, theme, context) => {
+				const base = baseEdit(context.cwd).renderResult!(result, resultOptions, theme, context);
+				return context.args.then_run
+					? renderSolPiTool(theme, "Action Fusion", "1 model round-trip avoided", base)
+					: base;
+			},
+		});
+
+		if (hasExternalToolOwner(pi, "write")) return;
+
+		pi.registerTool<typeof writeParameters, undefined>({
+			...writeTemplate,
+			parameters: writeParameters,
+			async execute(toolCallId, input, signal, onUpdate, ctx) {
+				const { then_run, ...writeInput } = input as typeof input & { then_run?: ThenRunInput };
+				const result = await executeMutationThenRun({
+					toolCallId,
+					absolutePath: resolveToolPath(ctx.cwd, input.path),
+					thenRun: then_run,
+					bashOptions: options.bashOptions,
+					signal,
+					ctx,
+					mutate: () => baseWrite(ctx.cwd).execute(toolCallId, writeInput, signal, onUpdate, ctx),
+				});
+				if (
+					then_run &&
+					result.content.some((block) => block.type === "text" && block.text.includes(THEN_RUN_SUCCEEDED))
+				) {
+					showSolPiSavings(ctx, "Action Fusion", "1 model round-trip avoided");
+				}
+				return result;
+			},
+			renderCall: (args, theme, context) => {
+				const base = baseWrite(context.cwd).renderCall!(args, theme, context);
+				return args.then_run ? renderSolPiTool(theme, "Action Fusion", "1 model round-trip avoided", base) : base;
+			},
+			renderResult: (result, resultOptions, theme, context) => {
+				const base = baseWrite(context.cwd).renderResult!(result, resultOptions, theme, context);
+				return context.args.then_run
+					? renderSolPiTool(theme, "Action Fusion", "1 model round-trip avoided", base)
+					: base;
+			},
+		});
+	};
+}
+
+export type { ThenRunInput } from "./then-run.ts";
+export {
+	assertUnchangedBeforeCommand,
+	executeMutationThenRun,
+	THEN_RUN_FAILED,
+	THEN_RUN_SKIPPED,
+	THEN_RUN_SUCCEEDED,
+} from "./then-run.ts";
+
+export function registerActionFusion(pi: ExtensionAPI): void {
+	createActionFusionExtension()(pi);
+}
+
+export default registerActionFusion;

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/action-fusion/then-run.ts

@@ -0,0 +1,128 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { type BashToolOptions, createBashToolDefinition, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { withFusedFileQueue } from "./file-queue.ts";
+
+export const THEN_RUN_SUCCEEDED = "[then_run:succeeded]";
+export const THEN_RUN_FAILED = "[then_run:failed]";
+export const THEN_RUN_SKIPPED = "[then_run:skipped]";
+
+export interface ThenRunInput {
+	command: string;
+	timeout?: number;
+}
+
+export function createThenRunSchema(description: string) {
+	return Type.Optional(
+		Type.Object(
+			{
+				command: Type.String({ description: "Bash command to run" }),
+				timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+			},
+			{ description },
+		),
+	);
+}
+
+function errorText(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function resultText(result: AgentToolResult<unknown>): string {
+	return result.content
+		.filter((block) => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+}
+
+function thenRunSkippedError(error: unknown): Error {
+	return new Error(
+		`${errorText(error)}\n\n${THEN_RUN_SKIPPED} The file mutation did not complete successfully; the command was not run.`,
+	);
+}
+
+async function fileSha256(path: string): Promise<string> {
+	return createHash("sha256").update(await readFile(path)).digest("hex");
+}
+
+export async function assertUnchangedBeforeCommand(
+	path: string,
+	yieldForInterference: () => Promise<void> = () => new Promise<void>((resolve) => setImmediate(resolve)),
+): Promise<void> {
+	try {
+		const mutationHash = await fileSha256(path);
+		await yieldForInterference();
+		const commandHash = await fileSha256(path);
+		if (mutationHash !== commandHash) {
+			throw new Error("target content changed after the fused mutation");
+		}
+	} catch (error) {
+		throw new Error(`${THEN_RUN_SKIPPED} ${errorText(error)}; the command was not run.`, { cause: error });
+	}
+}
+
+/**
+ * Apply a file mutation and, when the model asked for one, run its follow-up
+ * command before returning a single observation.
+ *
+ * Both steps run inside one SoL-Pi queue slot for `absolutePath`, so another
+ * fused mutation of the same file cannot interleave. Pi's built-in mutation
+ * tool keeps its own queue; the two queues are not nested.
+ */
+export async function executeMutationThenRun<TDetails>({
+	toolCallId,
+	absolutePath,
+	thenRun,
+	mutate,
+	bashOptions,
+	signal,
+	ctx,
+}: {
+	toolCallId: string;
+	absolutePath: string;
+	thenRun: ThenRunInput | undefined;
+	mutate: () => Promise<AgentToolResult<TDetails>>;
+	bashOptions: BashToolOptions | undefined;
+	signal: AbortSignal | undefined;
+	ctx: ExtensionContext;
+}): Promise<AgentToolResult<TDetails>> {
+	return withFusedFileQueue(absolutePath, async () => {
+		let mutationResult: AgentToolResult<TDetails>;
+		try {
+			mutationResult = await mutate();
+		} catch (error) {
+			if (thenRun !== undefined) {
+				throw thenRunSkippedError(error);
+			}
+			throw error;
+		}
+
+		if (thenRun === undefined) {
+			return mutationResult;
+		}
+
+		await assertUnchangedBeforeCommand(absolutePath);
+		const bash = createBashToolDefinition(ctx.cwd, bashOptions);
+		try {
+			// pi-lens-ignore: sql-injection
+			const bashResult = await bash.execute(`${toolCallId}:then_run`, thenRun, signal, undefined, ctx);
+			const output = resultText(bashResult);
+			return {
+				...mutationResult,
+				content: [
+					...mutationResult.content,
+					{ type: "text", text: output ? `${THEN_RUN_SUCCEEDED}\n${output}` : THEN_RUN_SUCCEEDED },
+				],
+			};
+		} catch (error) {
+			const mutationOutput = resultText(mutationResult);
+			throw new Error([mutationOutput, THEN_RUN_FAILED, errorText(error)].filter(Boolean).join("\n\n"), { cause: error });
+		}
+	});
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/evidence-preserving-reducer/archive.ts

@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isRecord, type ReducerConfig, sha256 } from "./config.ts";
+
+export interface ArchiveObject {
+	readonly hash: string;
+	readonly bytes: number;
+	readonly chars: number;
+	readonly lines: number;
+	readonly path: string;
+}
+
+/**
+ * Archived logs live under SoL-Pi's session-derived runtime directory.
+ */
+export function archiveRoot(config: ReducerConfig): string {
+	return config.storeRoot;
+}
+
+/**
+ * Store the raw log under its own content hash.
+ *
+ * Every quote in a receipt is checked against this archive, and the receipt
+ * points the frontier agent back at this path for exact readback. An existing
+ * object with the same name but different bytes is an integrity failure, not a
+ * cache hit.
+ */
+export async function archiveBody(root: string, body: string): Promise<ArchiveObject> {
+	const hash = sha256(body);
+	const objectDir = join(root, "objects", hash.slice(0, 2));
+	const path = join(objectDir, `${hash}.txt`);
+	await mkdir(objectDir, { recursive: true, mode: 0o700 });
+	try {
+		await writeFile(path, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
+	} catch (error) {
+		if (!isRecord(error) || error.code !== "EEXIST") throw error;
+		const existing = await readFile(path, "utf8");
+		if (existing !== body || sha256(existing) !== hash) {
+			throw new Error(`Reducer archive integrity failure: ${path}`, { cause: error });
+		}
+	}
+	return {
+		hash,
+		bytes: Buffer.byteLength(body, "utf8"),
+		chars: body.length,
+		lines: body.length === 0 ? 0 : body.split("\n").length,
+		path,
+	};
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/evidence-preserving-reducer/candidate.ts

@@ -0,0 +1,101 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname } from "node:path";
+import type { ToolResultEvent } from "@earendil-works/pi-coding-agent";
+import { recordValue } from "./config.ts";
+
+/** Markers written by the action-fusion extension around a fused command's output. */
+const THEN_RUN_SUCCEEDED = "[then_run:succeeded]";
+const THEN_RUN_FAILED = "[then_run:failed]";
+
+export interface ReducibleToolResult {
+	readonly command: string;
+	readonly body: string;
+	/** Put the receipt back where the raw output was, leaving the rest of the result alone. */
+	readonly projectReceipt: (receipt: string) => ToolResultEvent["content"];
+}
+
+function textContent(event: ToolResultEvent): string {
+	return event.content
+		.filter((item): item is { type: "text"; text: string } => item.type === "text")
+		.map((item) => item.text)
+		.join("\n");
+}
+
+export function detailsFullOutputPath(details: unknown): string | undefined {
+	const value = recordValue(details, "fullOutputPath");
+	return typeof value === "string" ? value : undefined;
+}
+
+async function safePiBashTempPath(path: string | undefined): Promise<boolean> {
+	if (!path || !/^pi-bash-[^/\\]+\.log$/u.test(basename(path))) return false;
+	try {
+		const [candidate, root, status] = await Promise.all([realpath(path), realpath(tmpdir()), lstat(path)]);
+		return status.isFile() && !status.isSymbolicLink() && dirname(candidate) === root;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Prefer the untruncated file pi wrote for a large bash result, so evidence is
+ * checked against the exact bytes the command produced rather than a preview.
+ */
+async function exactBodyFromInline(inline: string, details: unknown): Promise<string> {
+	const detailsPath = detailsFullOutputPath(details);
+	const inlineMatch = inline.match(/Full output:\s*([^\]\r\n]+)/u);
+	const candidate = detailsPath ?? inlineMatch?.[1]?.trim();
+	if (!candidate || !(await safePiBashTempPath(candidate))) return inline;
+	try {
+		return await readFile(candidate, "utf8");
+	} catch {
+		return inline;
+	}
+}
+
+/**
+ * Identify the log inside a tool result: either a plain bash result, or the
+ * command output appended by a fused `edit`/`write` call.
+ */
+export async function reducibleToolResult(event: ToolResultEvent): Promise<ReducibleToolResult | undefined> {
+	if (event.toolName === "bash") {
+		const command = typeof event.input.command === "string" ? event.input.command : "";
+		if (!command) return undefined;
+		const inline = textContent(event);
+		return {
+			command,
+			body: await exactBodyFromInline(inline, event.details),
+			projectReceipt: (receipt) => [{ type: "text", text: receipt }],
+		};
+	}
+	if (event.toolName !== "write" && event.toolName !== "edit") return undefined;
+	const thenRun = recordValue(event.input, "then_run");
+	const commandValue = recordValue(thenRun, "command");
+	if (typeof commandValue !== "string" || !commandValue) return undefined;
+	const marker = event.isError ? THEN_RUN_FAILED : THEN_RUN_SUCCEEDED;
+	for (let index = 0; index < event.content.length; index++) {
+		const block = event.content[index];
+		if (!block || block.type !== "text") continue;
+		const markerIndex = block.text.indexOf(marker);
+		if (markerIndex < 0) continue;
+		const suffixStart = markerIndex + marker.length;
+		const suffix = block.text.slice(suffixStart);
+		const separator = suffix.match(/^(?:\r?\n)+/u)?.[0] ?? "\n";
+		const inline = suffix.slice(separator === "\n" && !suffix.startsWith("\n") ? 0 : separator.length);
+		return {
+			command: commandValue,
+			body: await exactBodyFromInline(inline, event.details),
+			projectReceipt: (receipt) =>
+				event.content.map((content, contentIndex) =>
+					contentIndex === index && content.type === "text"
+						? { ...content, text: `${content.text.slice(0, suffixStart)}${separator}${receipt}` }
+						: content,
+				),
+		};
+	}
+	return undefined;
+}