pi-shorthand 0.3.2 → 0.5.0

package/README.md

@@ -20,14 +20,14 @@ xcode-select --install
 curl -fsSL https://agentfs.ai/install | bash
 ```
 
-On Linux, install bubblewrap 0.9 or later. For Debian and Ubuntu:
+On Linux, install bubblewrap 0.9 or later, a C compiler, and `lsof`. For Debian and Ubuntu:
 
 ```sh
-sudo apt install bubblewrap
+sudo apt install bubblewrap build-essential lsof
 ```
 
 ## Technical choices
 
 pi-shorthand gives Pi a programming environment instead of a patch format. This makes multi-file and structural edits possible in one call, but does not guarantee that Pi will find it easier or more reliable than its built-in edit tool. Which works better depends on the model and the task.
 
-Programs edit an isolated snapshot, with host files outside the repository kept read-only. By default, a failure keeps completed files and rolls back files involved in failed or interrupted edits; changes are applied only if their destination files have not changed. Progress is reported while a program runs, but no run history is written to disk.
+Programs edit a private workspace, with host files outside the repository kept read-only. By default, a failure keeps completed files and rolls back failed or interrupted edits. Concurrent edits can cause a run to be rejected; conflict detection is best-effort, not an atomic commit.

package/agentfs-database.ts

@@ -0,0 +1,141 @@
+/** Reuse only pristine, never-mounted AgentFS databases; each run gets independent copies. */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+import { $ } from "bun";
+import { Database } from "bun:sqlite";
+
+async function ownedDirectory(directory: string): Promise<void> {
+	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+	const stat = await fs.lstat(directory);
+	if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 0o077)
+		throw new Error(`Unsafe AgentFS template directory: ${directory}`);
+}
+
+async function templateKey(agentfs: string, repo: string): Promise<string> {
+	const executable = await fs.stat(agentfs, { bigint: true });
+	const repository = await fs.stat(repo, { bigint: true });
+	// Do not tie the template to checkout contents: it contains schema and the base
+	// path, not source files. Replacing either the executable or root invalidates it.
+	return createHash("sha256")
+		.update(
+			JSON.stringify(
+				[
+					1,
+					process.getuid?.(),
+					process.getgid?.(),
+					agentfs,
+					executable.dev,
+					executable.ino,
+					executable.size,
+					executable.mtimeNs,
+					executable.ctimeNs,
+					repo,
+					repository.dev,
+					repository.ino,
+				],
+				(_, value) => (typeof value === "bigint" ? String(value) : value),
+			),
+		)
+		.digest("hex");
+}
+
+async function copyTemplate(template: string, destination: string): Promise<void> {
+	const directory = await fs.lstat(template);
+	if (
+		!directory.isDirectory() ||
+		directory.isSymbolicLink() ||
+		directory.uid !== process.getuid?.() ||
+		directory.mode & 0o077
+	)
+		throw new Error("Unsafe AgentFS database template");
+	const names = await fs.readdir(template);
+	if (!names.includes("run.db")) throw new Error("Incomplete AgentFS database template");
+	await fs.mkdir(destination, { recursive: true, mode: 0o700 });
+	for (const name of names) {
+		const source = path.join(template, name);
+		const stat = await fs.lstat(source);
+		if (
+			!(name === "run.db" || name === "run.db-wal") ||
+			!stat.isFile() ||
+			stat.uid !== process.getuid?.() ||
+			stat.mode & 0o077 ||
+			stat.nlink !== 1
+		)
+			throw new Error("Unsafe AgentFS database template entry");
+		// No hardlinks: serving a transaction must never mutate the template.
+		await fs.copyFile(source, path.join(destination, name), constants.COPYFILE_EXCL);
+	}
+}
+
+/** Inspect the private copy, so SQLite never opens or modifies the shared template. */
+function validateEmptyDatabase(file: string, repo: string): void {
+	const db = new Database(file, { readonly: true, strict: true });
+	try {
+		const base = db.query("SELECT value FROM fs_overlay_config WHERE key = 'base_path'").get() as
+			| { value: string }
+			| undefined;
+		const root = db.query("SELECT mode, uid, gid FROM fs_inode WHERE ino = 1").get() as
+			| { mode: number; uid: number; gid: number }
+			| undefined;
+		if (
+			base?.value !== repo ||
+			!root ||
+			(root.mode & 0o170000) !== 0o040000 ||
+			root.uid !== process.getuid?.() ||
+			root.gid !== process.getgid?.()
+		)
+			throw new Error("AgentFS template has the wrong base or root identity");
+		for (const table of ["fs_dentry", "fs_whiteout", "fs_origin", "fs_data", "fs_symlink", "kv_store", "tool_calls"]) {
+			const count = db.query(`SELECT COUNT(*) AS count FROM ${table}`).get() as { count: number };
+			if (count.count !== 0) throw new Error(`AgentFS template contains private ${table} state`);
+		}
+		const inodes = db.query("SELECT COUNT(*) AS count FROM fs_inode").get() as { count: number };
+		if (inodes.count !== 1) throw new Error("AgentFS template contains private inode state");
+	} finally {
+		db.close();
+	}
+}
+
+export async function createAgentFsDatabase(
+	agentfs: string,
+	base: string,
+	tempDir: string,
+	cache = path.join(homedir(), ".cache", "pi-shorthand", "agentfs-templates"),
+): Promise<string> {
+	const executable = await fs.realpath(Bun.which(agentfs) ?? agentfs);
+	const repo = await fs.realpath(base);
+	await ownedDirectory(cache);
+	const key = await templateKey(executable, repo);
+	const template = path.join(cache, key);
+	const existing = await fs.lstat(template).catch((error: NodeJS.ErrnoException) => {
+		if (error.code !== "ENOENT") throw error;
+		return null;
+	});
+	if (!existing) {
+		const staging = await fs.mkdtemp(path.join(cache, ".initializing-"));
+		try {
+			await $`${executable} init run --base ${repo}`.cwd(staging).quiet();
+			if (key !== (await templateKey(executable, repo)))
+				throw new Error("AgentFS or repository changed during initialization");
+			const database = path.join(staging, ".agentfs");
+			await fs.chmod(database, 0o700);
+			for (const name of await fs.readdir(database)) await fs.chmod(path.join(database, name), 0o600);
+			// Publish only after the initializing process has exited, including its
+			// database sidecars. Concurrent creators can safely use the winner.
+			await fs.rename(database, template).catch((error: NodeJS.ErrnoException) => {
+				if (error.code !== "EEXIST" && error.code !== "ENOTEMPTY") throw error;
+			});
+		} finally {
+			await fs.rm(staging, { recursive: true, force: true });
+		}
+	}
+	const destination = path.join(tempDir, ".agentfs");
+	await copyTemplate(template, destination);
+	validateEmptyDatabase(path.join(destination, "run.db"), repo);
+	if (key !== (await templateKey(executable, repo)))
+		throw new Error("AgentFS or repository changed while preparing the transaction database");
+	return path.join(destination, "run.db");
+}

package/api.d.ts

@@ -8,6 +8,7 @@ declare global {
 	const grep: ShorthandGlobals["grep"];
 	const sg: ShorthandGlobals["sg"];
 	const grit: ShorthandGlobals["grit"];
+	const ts: ShorthandGlobals["ts"];
 }
 
 export type { RewriteResult } from "./prelude.ts";

package/diagnostics.ts

@@ -0,0 +1,142 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export interface DiagnosticSpan {
+	name: string;
+	startMs: number;
+	durationMs?: number;
+	failed?: boolean;
+}
+
+export interface Diagnostics {
+	spans: DiagnosticSpan[];
+	counters: Record<string, number>;
+	phase?: string;
+	failurePhase?: string;
+	runnerMs?: number;
+	startupMs?: number;
+	responseMs?: number;
+	wallMs?: number;
+	incomplete?: boolean;
+}
+
+const context = new AsyncLocalStorage<{
+	startedAt: number;
+	diagnostics: Diagnostics;
+	publish: (diagnostics: Diagnostics) => void;
+	phaseSpan?: DiagnosticSpan;
+}>();
+
+/** Run-local, bounded metadata only: never record source text, filenames or command output. */
+export async function withDiagnostics<T>(
+	operation: () => Promise<T>,
+	publish: (diagnostics: Diagnostics) => void,
+): Promise<{ value: T; diagnostics: Diagnostics }> {
+	const state = {
+		startedAt: performance.now(),
+		diagnostics: { spans: [], counters: {} } as Diagnostics,
+		publish: (diagnostics: Diagnostics) => {
+			try {
+				publish(diagnostics);
+			} catch {
+				/* Diagnostics must not change the operation's outcome. */
+			}
+		},
+	};
+	return context.run(state, async () => {
+		state.publish(state.diagnostics);
+		try {
+			return { value: await operation(), diagnostics: state.diagnostics };
+		} catch (error) {
+			diagnosticFailure();
+			throw error;
+		} finally {
+			const active = context.getStore()!;
+			if (active.phaseSpan)
+				active.phaseSpan.durationMs = Math.round(performance.now() - state.startedAt - active.phaseSpan.startMs);
+			state.diagnostics.runnerMs = Math.round(performance.now() - state.startedAt);
+			state.publish(state.diagnostics);
+		}
+	});
+}
+
+export async function measure<T>(name: string, operation: () => Promise<T>): Promise<T> {
+	const state = context.getStore();
+	if (!state) return operation();
+	const start = performance.now();
+	const span: DiagnosticSpan = { name, startMs: Math.round(start - state.startedAt) };
+	state.diagnostics.spans.push(span);
+	state.publish(state.diagnostics);
+	try {
+		return await operation();
+	} catch (error) {
+		span.failed = true;
+		throw error;
+	} finally {
+		span.durationMs = Math.round(performance.now() - start);
+		state.publish(state.diagnostics);
+	}
+}
+
+export function diagnosticCounter(name: string, value: number, add = false) {
+	const state = context.getStore();
+	if (!state) return;
+	state.diagnostics.counters[name] = value + (add ? (state.diagnostics.counters[name] ?? 0) : 0);
+	state.publish(state.diagnostics);
+}
+
+export function diagnosticPhase(phase: string) {
+	const state = context.getStore();
+	if (!state) return;
+	const now = Math.round(performance.now() - state.startedAt);
+	if (state.phaseSpan) state.phaseSpan.durationMs = now - state.phaseSpan.startMs;
+	state.phaseSpan = { name: phase, startMs: now };
+	state.diagnostics.spans.push(state.phaseSpan);
+	state.diagnostics.phase = phase;
+	state.publish(state.diagnostics);
+}
+
+export function diagnosticFailure() {
+	const state = context.getStore();
+	if (!state || state.diagnostics.failurePhase) return;
+	state.diagnostics.failurePhase = state.diagnostics.phase;
+	if (state.phaseSpan) state.phaseSpan.failed = true;
+}
+
+/** Spans are nested within runner phases; these figures must not be added to the phase total. */
+const duration = (ms: number) => `${ms}ms`;
+
+/** Parent-observed startup includes event delivery; a missing final event means execution is incomplete. */
+export function completeDiagnostics(diagnostics: Diagnostics, wallMs: number, startupMs: number): Diagnostics {
+	diagnostics.wallMs = Math.round(wallMs);
+	diagnostics.startupMs = Math.round(startupMs);
+	if (diagnostics.runnerMs === undefined) {
+		diagnostics.incomplete = true;
+		diagnostics.runnerMs = Math.max(0, diagnostics.wallMs - diagnostics.startupMs);
+	}
+	diagnostics.responseMs = Math.max(0, diagnostics.wallMs - diagnostics.startupMs - diagnostics.runnerMs);
+	return diagnostics;
+}
+
+export function diagnosticLines(diagnostics: Diagnostics): string[] {
+	const lines: string[] = [];
+	if (diagnostics.wallMs !== undefined) {
+		lines.push(
+			`wall ${duration(diagnostics.wallMs)} · runner startup/IPC ${duration(diagnostics.startupMs ?? 0)} · runner${diagnostics.incomplete ? " (observed, incomplete)" : ""} ${duration(diagnostics.runnerMs ?? 0)} · response/exit ${duration(diagnostics.responseMs ?? 0)}`,
+		);
+	}
+	if (diagnostics.spans.length) {
+		lines.push("phase detail (nested measurements overlap):");
+		lines.push(
+			...diagnostics.spans
+				.filter((span) => span.durationMs !== 0)
+				.map(
+					(span) =>
+						`  ${span.name}: ${span.durationMs === undefined ? "incomplete" : duration(span.durationMs)}${span.failed ? " (failed)" : ""}`,
+				),
+		);
+	}
+	const counters = Object.entries(diagnostics.counters);
+	if (counters.length) lines.push(counters.map(([name, value]) => `${name}: ${value}`).join(" · "));
+	if (diagnostics.failurePhase) lines.push(`failed during: ${diagnostics.failurePhase}`);
+	return lines;
+}

package/display.ts

@@ -8,7 +8,8 @@
  */
 
 import { getLanguageFromPath, highlightCode, keyHint, renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
-import type { FileChange, RunResult } from "./runner.ts";
+import type { FileChange, RunResult, RunTimings } from "./runner.ts";
+import { diagnosticLines } from "./diagnostics.ts";
 
 type ToolBackground = "toolSuccessBg" | "toolErrorBg";
 
@@ -21,7 +22,7 @@ const LISTED_FILES = 8; // …showing this many, then "and N more files"
 const EXPANDED_DIFF_LINES = 2000; // even expanded, a diff of hundreds of files stops here
 
 export function callLine(args: { title?: string; timeout?: number; rollback?: string }, theme: Theme): string {
-	const settings = [args.rollback === "all" && "rollback all", args.timeout && `timeout ${args.timeout}s`];
+	const settings = [args.rollback === "all" && "rollback all", args.timeout && `program timeout ${args.timeout}s`];
 	const suffix = settings.filter(Boolean).join(", ");
 	return `${theme.fg("toolTitle", theme.bold("code"))} ${args.title ?? ""}${suffix ? theme.fg("muted", ` (${suffix})`) : ""}`;
 }
@@ -83,14 +84,51 @@ export function resultLines(run: RunResult, expanded: boolean, theme: Theme): st
 	if (output && (expanded || !error)) sections.push(outputLines(output, expanded, run.changes.length > 0, theme));
 	if (notApplied.length > 0) sections.push(notAppliedLines(notApplied, expanded, theme, background));
 	for (const section of sections) lines.push("", ...section);
+	const timing = timingBreakdown(run);
+	if (timing) lines.push("", theme.fg("muted", `timing: ${timing}`));
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0)) {
+		lines.push(...diagnosticLines(run.diagnostics).map((line) => theme.fg("muted", line)));
+	}
 	return lines;
 }
 
+const TIMING_LABELS: Record<keyof RunTimings, string> = {
+	resolveRepositoryMs: "repository",
+	waitForLockMs: "lock wait",
+	workspaceSetupMs: "workspace setup",
+	programMs: "program",
+	scanChangesMs: "change scan",
+	formatMs: "formatter",
+	workspaceCloseMs: "workspace cleanup",
+	checkConflictsMs: "conflict check",
+	applyMs: "apply",
+	renderDiffMs: "diff",
+	unattributedMs: "other",
+};
+
+/** Explain calls exceeding the configured program budget, even when no individual phase does. */
+export function timingBreakdown(run: RunResult): string | undefined {
+	if (!run.timings || (run.diagnostics?.wallMs ?? run.durationMs) < run.timeoutMs) return undefined;
+	const significant = Object.entries(run.timings)
+		.map(([phase, milliseconds]) => ({
+			label: TIMING_LABELS[phase as keyof RunTimings],
+			milliseconds,
+		}))
+		.filter(({ milliseconds }) => milliseconds > 0)
+		.toSorted((a, b) => b.milliseconds - a.milliseconds);
+	if (significant.length === 0) return undefined;
+	return significant.map(({ label, milliseconds }) => `${label} ${formatDuration(milliseconds)}`).join(" · ");
+}
+
+function formatDuration(milliseconds: number): string {
+	return milliseconds < 1_000 ? `${milliseconds}ms` : `${(milliseconds / 1_000).toFixed(1)}s`;
+}
+
 /** e.g. "✓ Applied 3 files · +6 −6 · 0.6s" or "✕ Failed · rolled back all changes · exit 1 · 0.2s" */
 function verdict(run: RunResult, applied: FileChange[], theme: Theme): string {
 	const muted = (text: string) => theme.fg("muted", text);
 	const took = muted(` · ${(run.durationMs / 1000).toFixed(1)}s`);
-	const failure = run.timedOut ? `Timed out after ${run.timeoutMs / 1000}s` : "Failed";
+	const failure = run.timedOut ? `Program timed out after ${run.timeoutMs / 1000}s` : "Failed";
 	const exit = run.timedOut ? "" : muted(` · exit ${run.exitCode}`);
 
 	if (run.conflicts.length > 0) {

package/file-outcomes.ts

@@ -11,6 +11,7 @@ export type FileOutcomeEvent =
 
 const descriptor = process.env.PI_SHORTHAND_OUTCOMES_FD;
 const root = process.env.PI_SHORTHAND_EXECUTION_ROOT;
+export { root as executionRoot };
 const forceInspectionFailure = process.env.PI_SHORTHAND_INSPECTION_FAILURE === "1";
 // Subprocesses do not inherit descriptor 3 by default, so do not advertise it to them.
 delete process.env.PI_SHORTHAND_OUTCOMES_FD;

package/format.ts

@@ -4,6 +4,14 @@ import { dirname, extname, join, relative, resolve } from "node:path";
 
 type Command = { name: string; executable: string; args: string[]; cwd: string };
 
+/** A conservative filter: configuration and executable discovery still happen inside the sandbox. */
+export function supportsFormatting(file: string): boolean {
+	return (
+		/\.(?:[cm]?[jt]sx?|jsonc?|css|scss|less|html|vue|svelte|mdx?|ya?ml|graphql)$/i.test(file) ||
+		[".py", ".pyi", ".go", ".rs"].includes(extname(file))
+	);
+}
+
 function text(file: string): string {
 	try {
 		return readFileSync(file, "utf8");

package/index.ts

@@ -12,8 +12,25 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type Theme, truncateHead, truncateTail } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { callLine, countLines, fileMetadataSummary, resultLines, unstructuredResultText } from "./display.ts";
+import {
+	callLine,
+	countLines,
+	fileMetadataSummary,
+	resultLines,
+	timingBreakdown,
+	unstructuredResultText,
+} from "./display.ts";
 import type { FileChange, RunOptions, RunResult } from "./runner.ts";
+import { type Diagnostics, completeDiagnostics, diagnosticLines } from "./diagnostics.ts";
+
+class RunnerError extends Error {
+	constructor(
+		message: string,
+		readonly diagnostics: Diagnostics,
+	) {
+		super(message);
+	}
+}
 
 // Runs typically take well under a second. Longer transformations can request more time.
 const DEFAULT_TIMEOUT_SECONDS = 2;
@@ -26,6 +43,8 @@ Common operations:
 - sg.rewrite(pattern, replacement, files?) discovers and rewrites matching code; omit files for the working directory. $X captures one node; $$$X captures a sequence.
 - sg.one(pattern, files?) selects exactly one match; sg.find returns an array. sg.rewrite also accepts a selected match or array without a file scope.
 - A rewrite callback receives a match and returns text, a native node.replace(text) edit, or null to skip. Return native edits to apply them. Pass selected arrays together for independent edits; select again after changing their file.
+- await ts.rename({ file, symbol, to }) renames one resolved TypeScript symbol across the project without changing unrelated names.
+- await ts.renameFile({ from, to }) moves a TypeScript file and updates module paths that resolve to it.
 
 See the shorthand skill for common writes. For extraction, complex rewrites or other languages, read its advanced-refactors.md guide. The default timeout is two seconds; request more for longer programs.`;
 
@@ -72,16 +91,28 @@ export default function (pi: ExtensionAPI) {
 				});
 			}, 500);
 
-			const result = await runWithBun(
-				{
-					cwd: ctx.cwd,
-					program: params.program,
-					timeoutMs: (params.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
-					rollback: params.rollback ?? "file",
-				},
-				signal,
-				(step) => (latest = step),
-			).finally(() => clearInterval(progress));
+			let result: RunResult;
+			try {
+				result = await runWithBun(
+					{
+						cwd: ctx.cwd,
+						program: params.program,
+						timeoutMs: (params.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
+						rollback: params.rollback ?? "file",
+					},
+					signal,
+					(step) => (latest = step),
+				);
+			} catch (error) {
+				if (!(error instanceof RunnerError)) throw error;
+				return {
+					isError: true,
+					content: [{ type: "text" as const, text: [error.message, ...diagnosticLines(error.diagnostics)].join("\n") }],
+					details: { infrastructureError: error.message, diagnostics: error.diagnostics },
+				};
+			} finally {
+				clearInterval(progress);
+			}
 			return {
 				content: [{ type: "text", text: textForModel(result, toolCallId) }],
 				details: result,
@@ -107,6 +138,18 @@ export function renderCodeResult(
 		const progress = (result.details as { progress?: string } | undefined)?.progress;
 		return new Text(theme.fg("muted", progress ? `running… ${progress}` : "running…"), 0, 0);
 	}
+	if (result.details && typeof result.details === "object" && "infrastructureError" in result.details) {
+		const failure = result.details as { infrastructureError: string; diagnostics: Diagnostics };
+		return new Text(
+			[
+				theme.fg("error", failure.infrastructureError),
+				"",
+				...diagnosticLines(failure.diagnostics).map((line) => theme.fg("muted", line)),
+			].join("\n"),
+			0,
+			0,
+		);
+	}
 	const run = result.details as RunResult | undefined;
 	if (!run) return new Text(theme.fg("error", unstructuredResultText(result.content)), 0, 0);
 	return new Text(resultLines(run, expanded, theme).join("\n"), 0, 0);
@@ -122,6 +165,13 @@ export function runWithBun(
 	signal?: AbortSignal,
 	onProgress?: (step: string) => void,
 ): Promise<RunResult> {
+	const startedAt = performance.now();
+	let firstEventAt: number | undefined;
+	let diagnostics: Diagnostics = { spans: [], counters: {} };
+	const finishDiagnostics = () => {
+		const now = performance.now();
+		return completeDiagnostics(diagnostics, now - startedAt, (firstEventAt ?? now) - startedAt);
+	};
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) return reject(new Error("Aborted"));
 		const runner = spawn("bun", [path.join(import.meta.dirname, "runner.ts")], {
@@ -146,14 +196,23 @@ export function runWithBun(
 			progressBuffer = lines.pop() ?? "";
 			for (const line of lines) {
 				try {
-					const event = JSON.parse(line) as { step?: unknown };
+					const event = JSON.parse(line) as { step?: unknown; diagnostics?: Diagnostics };
+					firstEventAt ??= performance.now();
+					if (event.diagnostics) {
+						diagnostics = event.diagnostics;
+						const active = diagnostics.spans.findLast((span) => span.durationMs === undefined);
+						if (active) onProgress?.(active.name);
+					}
 					if (typeof event.step === "string") onProgress?.(event.step);
 				} catch {
 					// Progress is advisory; malformed events do not affect the run.
 				}
 			}
 		});
-		runner.on("error", reject);
+		runner.on("error", (error) => {
+			signal?.removeEventListener("abort", stop);
+			reject(new RunnerError(error.message, finishDiagnostics()));
+		});
 		runner.on("close", (code) => {
 			signal?.removeEventListener("abort", stop);
 			try {
@@ -162,10 +221,24 @@ export function runWithBun(
 				// nothing left
 			}
 			if (code === 0) {
-				const result: RunResult = JSON.parse(stdout);
+				let result: RunResult;
+				try {
+					result = JSON.parse(stdout);
+				} catch {
+					reject(new RunnerError("Runner returned invalid JSON", finishDiagnostics()));
+					return;
+				}
+				diagnostics = result.diagnostics ?? diagnostics;
+				result.diagnostics = finishDiagnostics();
 				if (!signal?.aborted || result.applied.length > 0 || result.cleanupWarnings.length > 0) resolve(result);
 				else reject(new Error("Aborted"));
-			} else reject(new Error(stderr.trim() || (signal?.aborted ? "Aborted" : `runner exited with ${code}`)));
+			} else
+				reject(
+					new RunnerError(
+						stderr.trim() || (signal?.aborted ? "Aborted" : `runner exited with ${code}`),
+						finishDiagnostics(),
+					),
+				);
 		});
 
 		runner.stdin.end(JSON.stringify(options));
@@ -205,6 +278,8 @@ function fileLine(change: FileChange): string {
 
 function textForModel(run: RunResult, toolCallId: string): string {
 	const lines = [summaryLine(run)];
+	const timing = timingBreakdown(run);
+	if (timing) lines.push(`Timing: ${timing}`);
 
 	if (run.applied.length === 0 && run.changes.length > 0) {
 		lines.push("The real workspace is unchanged. Below is the candidate diff.");
@@ -232,6 +307,8 @@ function textForModel(run: RunResult, toolCallId: string): string {
 	// On failure the error goes last, where it's easiest to find; on success, the diff does.
 	if (run.exitCode === 0 && run.conflicts.length === 0) lines.push(...output, ...diff);
 	else lines.push(...diff, ...output);
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0))
+		lines.push("", ...diagnosticLines(run.diagnostics));
 	return lines.join("\n");
 }