@herbertgao/sol-pi 0.1.0

package/scripts/check-sol-pi-config.mjs

@@ -0,0 +1,120 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const FEATURE_KEYS = [
+	"actionFusion",
+	"observationPack",
+	"evidencePreservingReducer",
+	"onlineContextCompact",
+];
+const DEFAULT_CACHE_WRITE_READ_RATIO = 12.5;
+const DEFAULT_EPR_REDUCER_PROVIDER = ["openai", "codex"].join("-");
+const DEFAULT_EPR_REDUCER_MODEL = ["gpt-5.6", "luna"].join("-");
+const STRING_KEYS = ["evidencePreservingReducerModel", "evidencePreservingReducerProvider"];
+const CONFIG_KEYS = new Set(["version", ...FEATURE_KEYS, ...STRING_KEYS, "cacheWriteReadRatio"]);
+
+function fail(message) {
+	throw new Error(message);
+}
+
+function parseArguments(argv) {
+	const options = { config: undefined, requireAllEnabled: false };
+	const seen = new Set();
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (seen.has(argument)) fail(`duplicate option: ${argument}`);
+		if (argument === "--require-all-enabled") {
+			seen.add(argument);
+			options.requireAllEnabled = true;
+			continue;
+		}
+		if (argument !== "--config") fail(`unknown option: ${argument}`);
+		seen.add(argument);
+		const value = argv[index + 1];
+		if (!value || value.startsWith("--")) fail("missing value for --config");
+		options.config = value;
+		index += 1;
+	}
+	if (!options.config) fail("--config is required");
+	return options;
+}
+
+function readConfig(path) {
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch (error) {
+		fail(`unable to read config ${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		fail(`invalid JSON in config ${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+function validateConfig(value, requireAllEnabled) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		fail("config must be a JSON object");
+	}
+	for (const key of Object.keys(value)) {
+		if (!CONFIG_KEYS.has(key)) fail(`unknown key: ${key}`);
+	}
+	if (value.version !== 1) fail("version must be 1");
+
+	const effective = { version: 1 };
+	for (const key of FEATURE_KEYS) {
+		const configured = value[key];
+		if (configured !== undefined && typeof configured !== "boolean") fail(`${key} must be boolean`);
+		effective[key] = configured ?? false;
+		if (requireAllEnabled && effective[key] !== true) fail(`${key} must be true`);
+	}
+	const cacheWriteReadRatio = Object.hasOwn(value, "cacheWriteReadRatio")
+		? value.cacheWriteReadRatio
+		: DEFAULT_CACHE_WRITE_READ_RATIO;
+	if (
+		typeof cacheWriteReadRatio !== "number" ||
+		!Number.isFinite(cacheWriteReadRatio) ||
+		cacheWriteReadRatio < 0
+	) {
+		fail("cacheWriteReadRatio must be a finite non-negative number");
+	}
+	effective.cacheWriteReadRatio = cacheWriteReadRatio;
+	effective.evidencePreservingReducerModel = stringConfigValue(
+		value,
+		"evidencePreservingReducerModel",
+		DEFAULT_EPR_REDUCER_MODEL,
+	);
+	effective.evidencePreservingReducerProvider = stringConfigValue(
+		value,
+		"evidencePreservingReducerProvider",
+		DEFAULT_EPR_REDUCER_PROVIDER,
+	);
+
+	return {
+		ok: true,
+		all_enabled: FEATURE_KEYS.every((key) => effective[key] === true),
+		effective_config: effective,
+	};
+}
+
+function stringConfigValue(value, key, defaultValue) {
+	const configured = Object.hasOwn(value, key) ? value[key] : defaultValue;
+	if (typeof configured !== "string" || configured.trim().length === 0) fail(`${key} must be a non-empty string`);
+	return configured;
+}
+
+try {
+	const options = parseArguments(process.argv.slice(2));
+	const configPath = resolve(options.config);
+	const result = validateConfig(readConfig(configPath), options.requireAllEnabled);
+	console.log(JSON.stringify({ ...result, config: configPath }, null, 2));
+} catch (error) {
+	console.error(`SoL-Pi configuration preflight failed: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 1;
+}

package/sol-pi.example.json

@@ -0,0 +1,10 @@
+{
+	"version": 1,
+	"actionFusion": false,
+	"observationPack": false,
+	"evidencePreservingReducer": false,
+	"evidencePreservingReducerProvider": "provider-id",
+	"evidencePreservingReducerModel": "model-id",
+	"onlineContextCompact": false,
+	"cacheWriteReadRatio": 12.5
+}

package/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/src/sol-pi/extensions/action-fusion/file-queue.ts

@@ -0,0 +1,71 @@
+/*
+ * 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";
+
+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 expanded = stripToolPathPrefix(filePath);
+	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/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/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 });
+		}
+	});
+}