gentle-pi 3.2.1 → 3.3.0

package/tests/shell-todo.test.ts

@@ -231,6 +231,42 @@ test("completed titles strike only title cells across wrapped lines, never paddi
 	}
 });
 
+test("renderTodoCard paints the sidebar rail and the bottom widget with the same rose INFO frame", () => {
+	const taggedTheme = {
+		fg(color: string, text: string) {
+			return `<${color}>${text}</${color}>`;
+		},
+		strikethrough(text: string) {
+			return text;
+		},
+	};
+	const sidebar = renderTodoCard(seeded(), taggedTheme, 60, { scrollable: true, collapsed: false, staleTurns: 0 });
+	assert.match(sidebar[0], /<border>╭<\/border>/);
+	assert.match(sidebar[0], /<accent>❀ Todos/);
+
+	const bottom = renderTodoCard(seeded(), taggedTheme, 60, { collapsed: false, staleTurns: 0 });
+	assert.match(bottom[0], /<border>╭<\/border>/);
+	assert.match(bottom[0], /<accent>❀ Todos/);
+});
+
+// H1 (odd/tasks/usage-click-and-changes-attribution.md): the same shared
+// hover role every other clickable surface uses.
+test("renderTodoCard paints its clickable header control in the shared hover role when hovered", () => {
+	const taggedTheme = {
+		fg(color: string, text: string) {
+			return `<${color}>${text}</${color}>`;
+		},
+		strikethrough(text: string) {
+			return text;
+		},
+	};
+	const idle = renderTodoCard(seeded(), taggedTheme, 70, { collapsed: false, staleTurns: 0 });
+	assert.match(idle[0], /<accent>▾ Collapse<\/accent>/, "idle keeps its ordinary accent role");
+	const hovered = renderTodoCard(seeded(), taggedTheme, 70, { collapsed: false, staleTurns: 0, hovered: true });
+	assert.match(hovered[0], /<warning>▾ Collapse<\/warning>/, "hovering paints the shared hover role");
+	assert.doesNotMatch(hovered[0], /<accent>▾ Collapse/);
+});
+
 test("renderTodoCard keeps stale indicators and collapse hints in scrollable lists", () => {
 	const tasks = Array.from({ length: 40 }, (_, index) => ({ title: `Task ${index + 1}`, status: index < 25 ? "done" : "pending" }));
 	const state = applyTodo(emptyTodo(), { action: "write", tasks }, 1).state;

package/tests/shell-usage-view.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { visibleWidth } from "@earendil-works/pi-tui";
+import { visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 import { parseCodexUsage, UsageStore } from "../lib/shell-usage.ts";
 import { UsageView } from "../lib/shell-usage-view.ts";
@@ -61,3 +61,122 @@ test("UsageView refetches on r and closes on escape or q", async () => {
 	view.handleInput("q");
 	assert.equal(events.filter((event) => event === "close").length, 2);
 });
+
+function click(x: number, y: number, width: number, height: number): TuiMouseEvent {
+	return { type: "click", button: "left", x, y, screenX: x, screenY: y, width, height, shift: false, alt: false, ctrl: false };
+}
+
+test("UsageView.handleMouse clicks the footer hints like the matching key", async () => {
+	const store = new UsageStore();
+	const events: string[] = [];
+	let resolveRefresh: (() => void) | undefined;
+	const view = new UsageView(store, {
+		theme: plainTheme,
+		now: () => NOW,
+		active: () => undefined,
+		onRefresh: () =>
+			new Promise<void>((resolve) => {
+				events.push("refresh");
+				resolveRefresh = resolve;
+			}),
+		onClose: () => events.push("close"),
+		requestRender: () => events.push("render"),
+	});
+	const width = 90;
+	const lines = view.render(width);
+	const rowIndex = lines.findIndex((line) => stripAnsi(line).includes("r refresh"));
+	assert.ok(rowIndex > 0, "the footer hints row must be present");
+	const plain = stripAnsi(lines[rowIndex]);
+	const refreshStart = plain.indexOf("r refresh");
+	const closeStart = plain.indexOf("esc close");
+	assert.ok(refreshStart >= 0 && closeStart >= 0);
+
+	// A click outside any hint span is ignored, like a click on an empty part of the frame.
+	assert.equal(view.handleMouse(click(0, rowIndex, width, lines.length)), undefined);
+	assert.deepEqual(events, []);
+
+	// A click on "r refresh" triggers the same refresh as the r key.
+	assert.deepEqual(view.handleMouse(click(refreshStart + 1, rowIndex, width, lines.length)), { handled: true, render: true });
+	assert.deepEqual(events, ["render", "refresh"]);
+
+	// A second click while the refresh is still in flight must not re-enter it.
+	assert.deepEqual(view.handleMouse(click(refreshStart + 1, rowIndex, width, lines.length)), { handled: true, render: true });
+	assert.deepEqual(events, ["render", "refresh"]);
+	resolveRefresh?.();
+	await new Promise((resolve) => setTimeout(resolve, 0));
+	assert.deepEqual(events, ["render", "refresh", "render"]);
+
+	// A click on "esc close" closes the overlay, like the esc/q keys.
+	assert.deepEqual(view.handleMouse(click(closeStart + 1, rowIndex, width, lines.length)), { handled: true, render: true });
+	assert.equal(events.filter((event) => event === "close").length, 1);
+});
+
+function move(x: number, y: number, width: number, height: number): TuiMouseEvent {
+	return { type: "move", button: "none", x, y, screenX: x, screenY: y, width, height, shift: false, alt: false, ctrl: false };
+}
+
+// H1 (odd/tasks/usage-click-and-changes-attribution.md): the same shared
+// hover role every other clickable surface uses.
+test("UsageView.handleMouse paints the shared hover role over a footer hint, and clears it on leave", () => {
+	const store = new UsageStore();
+	const taggedTheme = { fg: (role: string, text: string) => `<${role}>${text}</${role}>` };
+	const view = new UsageView(store, {
+		theme: taggedTheme,
+		now: () => NOW,
+		active: () => undefined,
+		onRefresh: async () => {},
+		onClose: () => {},
+		requestRender: () => {},
+	});
+	const width = 90;
+	const lines = view.render(width);
+	// The frame draws "│ " (2 columns) before the fitted footer content, and
+	// hints are laid out as plain "key label" text joined by 3 spaces -- these
+	// column offsets are computed purely from that plain text, independent of
+	// the theme, so they hold under taggedTheme exactly as under plainTheme.
+	const rowIndex = lines.length - 2;
+	const refreshStart = 2;
+	const closeStart = refreshStart + "r refresh".length + 3;
+	const height = lines.length;
+
+	assert.equal(view.handleMouse(move(0, rowIndex, width, height)), undefined, "a move outside any hint is not this component's gesture");
+	assert.doesNotMatch(view.render(width).join("\n"), /<warning>/, "idle: nothing painted yet");
+
+	const entered = view.handleMouse(move(refreshStart + 1, rowIndex, width, height));
+	assert.deepEqual(entered, { handled: true, render: true });
+	assert.match(view.render(width).join("\n"), /<warning>r refresh<\/warning>/, "hovering the refresh hint paints it, key and label together");
+	assert.doesNotMatch(view.render(width).join("\n"), new RegExp(`<warning>esc close`), "the other hint stays unpainted");
+
+	// Moving straight to the other hint switches which one is painted.
+	const switched = view.handleMouse(move(closeStart + 1, rowIndex, width, height));
+	assert.deepEqual(switched, { handled: true, render: true });
+	assert.match(view.render(width).join("\n"), /<warning>esc close<\/warning>/);
+	assert.doesNotMatch(view.render(width).join("\n"), /<warning>r refresh/);
+
+	const left = view.handleMouse(move(0, rowIndex, width, height));
+	assert.deepEqual(left, { handled: true, render: true }, "leaving the last hovered hint still requests a repaint");
+	assert.doesNotMatch(view.render(width).join("\n"), /<warning>/, "nothing stays painted once the pointer leaves");
+});
+
+test("a rejected refresh from a click or key never escapes as an unhandled rejection", async () => {
+	const store = new UsageStore();
+	const events: string[] = [];
+	const unhandled: unknown[] = [];
+	const onUnhandled = (reason: unknown) => unhandled.push(reason);
+	process.on("unhandledRejection", onUnhandled);
+	try {
+		const view = new UsageView(store, { theme: plainTheme, now: () => NOW, active: () => undefined, onRefresh: async () => { throw new Error("provider down"); }, onClose: () => events.push("close"), requestRender: () => events.push("render") });
+		const lines = view.render(80);
+		const row = lines.length - 2;
+		const column = lines[row]!.indexOf("r refresh") + 1;
+		view.handleMouse({ type: "click", button: "left", x: column, y: row, width: 80, height: lines.length, screenX: column, screenY: row, shift: false, alt: false, ctrl: false } as never);
+		await new Promise((resolve) => setImmediate(resolve));
+		view.handleInput("r");
+		await new Promise((resolve) => setImmediate(resolve));
+		await new Promise((resolve) => setImmediate(resolve));
+		assert.deepEqual(unhandled, [], "a failing usage fetch is reported by the panel, never thrown at the process");
+		assert.match(view.render(80).join("\n"), /r refresh/, "the refresh hint is back after the failure");
+	} finally {
+		process.off("unhandledRejection", onUnhandled);
+	}
+});

package/lib/opaque-pi-reviewer-adapter.ts

@@ -1,404 +0,0 @@
-import { spawn } from "node:child_process";
-import { chmod, mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, posix, win32 } from "node:path";
-
-export const OPAQUE_PI_REVIEWER_ARGV = Object.freeze([
-	"--print",
-	// #1140: text mode turns a run that spent its turn on a tool call into zero
-	// bytes and exit 0. JSON mode emits pi's own event stream, so the transport
-	// can always tell a silent child from an assistant answer, and can recover
-	// the answer text even when tool calls interleaved with it.
-	"--mode", "json",
-	"--no-session",
-	"--no-tools",
-	"--no-extensions",
-	"--no-skills",
-	"--no-prompt-templates",
-	"--no-themes",
-	"--no-context-files",
-	"--no-approve",
-] as const);
-
-export const OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE = {
-	SCRATCH_FAILED: "scratch-failed",
-	LAUNCH_FAILED: "launch-failed",
-	CANCELLED: "cancelled",
-	TIMED_OUT: "timed-out",
-	NONZERO_EXIT: "nonzero-exit",
-	EMPTY_OUTPUT: "empty-output",
-	CLEANUP_FAILED: "cleanup-failed",
-} as const;
-export type OpaquePiReviewerTransportFailureKind = (typeof OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE)[keyof typeof OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE];
-
-export interface OpaquePiReviewerOptions {
-	readonly piExecutable?: string;
-	readonly environment?: NodeJS.ProcessEnv;
-	readonly timeoutMs?: number;
-	readonly signal?: AbortSignal;
-	/**
-	 * Caller-owned tokens appended verbatim after the frozen argv (spawn keeps
-	 * shell:false, so every token is one argv entry). The adapter never
-	 * interprets them; its caller owns their meaning and validation.
-	 */
-	readonly extraArguments?: readonly string[];
-}
-
-export interface OpaquePiReviewerResult {
-	readonly stdout: Buffer;
-	readonly promptByteLength: number;
-	readonly stdoutByteLength: number;
-}
-
-export interface OpaquePiReviewerTransportDetails {
-	readonly exitCode?: number | null;
-	readonly stderr?: Buffer;
-	readonly timedOut?: boolean;
-	readonly cancelled?: boolean;
-	/** Wall time for a launched Pi process; absent when no process was launched. */
-	readonly elapsedMs?: number;
-	/** The bound applied to a launched Pi process; absent when no process was launched. */
-	readonly timeoutMs?: number;
-	/** What the child's output stream revealed when no assistant answer could be recovered. */
-	readonly evidence?: PiReviewOutputEvidence;
-}
-
-export class OpaquePiReviewerTransportError extends Error {
-	readonly kind: OpaquePiReviewerTransportFailureKind;
-	readonly exitCode: number | null;
-	readonly stderr: Buffer;
-	readonly timedOut: boolean;
-	readonly cancelled: boolean;
-	readonly elapsedMs: number | null;
-	readonly timeoutMs: number | null;
-	readonly evidence: PiReviewOutputEvidence | undefined;
-
-	constructor(kind: OpaquePiReviewerTransportFailureKind, message: string, details: OpaquePiReviewerTransportDetails = {}) {
-		super(message);
-		this.name = "OpaquePiReviewerTransportError";
-		this.kind = kind;
-		this.exitCode = details.exitCode ?? null;
-		this.stderr = details.stderr ?? Buffer.alloc(0);
-		this.timedOut = details.timedOut ?? false;
-		this.cancelled = details.cancelled ?? false;
-		this.elapsedMs = details.elapsedMs ?? null;
-		this.timeoutMs = details.timeoutMs ?? null;
-		this.evidence = details.evidence;
-	}
-}
-
-interface OpaquePiProcessResult {
-	readonly stdout: Buffer;
-	readonly stderr: Buffer;
-	readonly exitCode: number | null;
-	readonly timedOut: boolean;
-	readonly cancelled: boolean;
-	readonly elapsedMs: number;
-	readonly timeoutMs: number;
-}
-
-const DEFAULT_OPAQUE_PI_TIMEOUT_MS = 600_000;
-
-export interface PiLaunch {
-	readonly file: string;
-	readonly arguments: readonly string[];
-}
-
-interface PiHostProcess {
-	readonly execPath: string;
-	readonly entry: string | undefined;
-}
-
-/**
- * The exact spawn shape for the fresh Pi process. A bare `pi` on Windows
- * resolves to pi.cmd, pi.ps1, or a POSIX shim, none of which Node can spawn
- * with shell:false (EINVAL or ENOENT). This adapter already runs inside Pi, so
- * on win32 the host's own JavaScript entry is spawned through the host's
- * process.execPath instead; a shell is never enabled. Every other platform,
- * and every explicit launcher, keeps the exact shape it always had.
- */
-export function resolvePiLaunch(
-	piExecutable: string | undefined,
-	platform: NodeJS.Platform = process.platform,
-	host: PiHostProcess = { execPath: process.execPath, entry: process.argv[1] },
-	extraArguments: readonly string[] = [],
-): PiLaunch {
-	const arguments_ = [...OPAQUE_PI_REVIEWER_ARGV, ...extraArguments];
-	if (piExecutable !== undefined) return { file: piExecutable, arguments: arguments_ };
-	if (platform !== "win32") return { file: "pi", arguments: arguments_ };
-	if (typeof host.entry !== "string" || host.entry.length === 0 || !(platform === "win32" ? win32 : posix).isAbsolute(host.entry)) {
-		throw new Error(`Pi host entry could not be resolved from the running process (received ${JSON.stringify(host.entry ?? null)}); a bare pi launcher cannot be spawned on Windows without a shell`);
-	}
-	return { file: host.execPath, arguments: [host.entry, ...arguments_] };
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-// ---------------------------------------------------------------------------
-// The child runs `pi --mode json`, so its stdout is a newline-delimited pi
-// event stream. The transport's output is the assistant text of that stream —
-// the same bytes an interactive run would have rendered — and everything else
-// about the stream becomes typed evidence. A run whose turn was spent on a
-// tool call therefore reports what happened (which reviewer selection ran,
-// that a tool call was attempted) instead of exiting 0 in silence (#1140).
-// ---------------------------------------------------------------------------
-
-export interface PiReviewOutputEvidence {
-	readonly stdoutKind: "no-output" | "not-a-pi-event-stream" | "no-assistant-text";
-	/** The reviewer selection the child itself reported in its events, when it named one. */
-	readonly reviewerModel?: string;
-	readonly toolCallAttempted?: boolean;
-}
-
-export type PiReviewExtraction =
-	| { readonly kind: "text"; readonly text: string }
-	| { readonly kind: "none"; readonly evidence: PiReviewOutputEvidence };
-
-interface PiEventMessagePart {
-	type?: unknown;
-	text?: unknown;
-}
-
-interface PiEventMessage {
-	role?: unknown;
-	content?: unknown;
-}
-
-interface PiEventEnvelope {
-	type?: unknown;
-	message?: unknown;
-}
-
-function parsePiEventLines(stdout: Buffer): PiEventEnvelope[] | undefined {
-	const lines = stdout.toString("utf8").split("\n").filter((line) => line.trim().length > 0);
-	if (lines.length === 0) return undefined;
-	const events: PiEventEnvelope[] = [];
-	for (const line of lines) {
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			return undefined;
-		}
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-		events.push(parsed as PiEventEnvelope);
-	}
-	return events;
-}
-
-export function extractPiAssistantText(stdout: Buffer): PiReviewExtraction {
-	if (stdout.length === 0) return { kind: "none", evidence: { stdoutKind: "no-output" } };
-	const events = parsePiEventLines(stdout);
-	if (events === undefined) return { kind: "none", evidence: { stdoutKind: "not-a-pi-event-stream" } };
-	const parts: string[] = [];
-	let reviewerModel: string | undefined;
-	let toolCallAttempted = false;
-	for (const event of events) {
-		// The final content of one assistant message lives in its end event;
-		// start and update events repeat or stream the same parts.
-		if (event.type !== "message_end") continue;
-		const message = event.message;
-		if (!message || typeof message !== "object" || Array.isArray(message)) continue;
-		const candidate = message as PiEventMessage;
-		if (candidate.role !== "assistant") continue;
-		// The event envelope names the selection the child itself ran with the wire
-		// key pi uses for it; read as quoted data, never as an identifier.
-		const reported = (candidate as Record<string, unknown>)["model"];
-		if (typeof reported === "string" && reported.length > 0 && reviewerModel === undefined) reviewerModel = reported;
-		if (!Array.isArray(candidate.content)) continue;
-		for (const part of candidate.content as PiEventMessagePart[]) {
-			if (!part || typeof part !== "object") continue;
-			if (typeof part.type === "string" && part.type.startsWith("tool")) toolCallAttempted = true;
-			if (part.type === "text" && typeof part.text === "string") parts.push(part.text);
-		}
-	}
-	const text = parts.join("");
-	if (text.length === 0) {
-		return {
-			kind: "none",
-			evidence: {
-				stdoutKind: "no-assistant-text",
-				...(reviewerModel === undefined ? {} : { reviewerModel }),
-				...(toolCallAttempted ? { toolCallAttempted } : {}),
-			},
-		};
-	}
-	return { kind: "text", text };
-}
-
-function emptyOutputMessage(evidence: PiReviewOutputEvidence): string {
-	const details = [`stdout kind: ${evidence.stdoutKind}`];
-	if (evidence.reviewerModel !== undefined) details.push(`reviewer selection: ${evidence.reviewerModel}`);
-	if (evidence.toolCallAttempted) details.push("a tool call was attempted");
-	return `Pi process produced no assistant text (${details.join("; ")})`;
-}
-
-function runPiProcess(prompt: Buffer, scratchDirectory: string, options: OpaquePiReviewerOptions): Promise<OpaquePiProcessResult> {
-	return new Promise((resolve, reject) => {
-		const startedAt = Date.now();
-		let launch: PiLaunch;
-		try {
-			launch = resolvePiLaunch(options.piExecutable, process.platform, { execPath: process.execPath, entry: process.argv[1] }, options.extraArguments ?? []);
-		} catch (error) {
-			reject(error);
-			return;
-		}
-		const child = spawn(launch.file, [...launch.arguments], {
-			cwd: scratchDirectory,
-			env: options.environment ?? process.env,
-			stdio: ["pipe", "pipe", "pipe"],
-			shell: false,
-			windowsHide: true,
-		});
-		const stdout: Buffer[] = [];
-		const stderr: Buffer[] = [];
-		const timeoutMs = options.timeoutMs ?? DEFAULT_OPAQUE_PI_TIMEOUT_MS;
-		let timedOut = false;
-		let cancelled = false;
-		let settled = false;
-		const timer = timeoutMs > 0
-			? setTimeout(() => {
-				timedOut = true;
-				child.kill("SIGKILL");
-			}, timeoutMs)
-			: undefined;
-		timer?.unref();
-		const cancel = () => {
-			cancelled = true;
-			child.kill("SIGKILL");
-		};
-		const clear = () => {
-			if (timer !== undefined) clearTimeout(timer);
-			options.signal?.removeEventListener("abort", cancel);
-		};
-
-		child.stdout.on("data", (chunk: Buffer) => stdout.push(chunk));
-		child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk));
-		child.on("error", (error) => {
-			if (settled) return;
-			settled = true;
-			clear();
-			reject(error);
-		});
-		child.on("close", (code) => {
-			if (settled) return;
-			settled = true;
-			clear();
-			resolve({
-				stdout: Buffer.concat(stdout),
-				stderr: Buffer.concat(stderr),
-				exitCode: code,
-				timedOut,
-				cancelled,
-				elapsedMs: Date.now() - startedAt,
-				timeoutMs,
-			});
-		});
-		if (options.signal?.aborted) cancel();
-		else options.signal?.addEventListener("abort", cancel, { once: true });
-		child.stdin.on("error", () => undefined);
-		child.stdin.end(prompt);
-	});
-}
-
-/** Runs raw prompt bytes through one fixed, isolated Pi process. */
-export async function runOpaquePiReviewer(prompt: Buffer, options: OpaquePiReviewerOptions = {}): Promise<OpaquePiReviewerResult> {
-	if (options.signal?.aborted) {
-		throw new OpaquePiReviewerTransportError(
-			OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.CANCELLED,
-			"Pi process was cancelled before launch",
-			{ cancelled: true },
-		);
-	}
-	if (options.extraArguments !== undefined && options.extraArguments.some((token) => typeof token !== "string" || token.length === 0)) {
-		throw new TypeError("Pi reviewer launch arguments must all be non-empty strings");
-	}
-
-	let scratchDirectory: string | undefined;
-	let primaryFailure = false;
-	try {
-		try {
-			scratchDirectory = await mkdtemp(join(tmpdir(), "gentle-pi-opaque-reviewer-"));
-			await chmod(scratchDirectory, 0o700);
-		} catch (error) {
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.SCRATCH_FAILED,
-				`Pi scratch directory could not be prepared: ${errorMessage(error)}`,
-			);
-		}
-
-		let processResult: OpaquePiProcessResult;
-		try {
-			processResult = await runPiProcess(prompt, scratchDirectory, options);
-		} catch (error) {
-			if (options.signal?.aborted) {
-				throw new OpaquePiReviewerTransportError(
-					OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.CANCELLED,
-					"Pi process was cancelled",
-					{ cancelled: true },
-				);
-			}
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.LAUNCH_FAILED,
-				`Pi process could not start: ${errorMessage(error)}`,
-			);
-		}
-		const timing = {
-			elapsedMs: processResult.elapsedMs,
-			timeoutMs: processResult.timeoutMs,
-		};
-		if (processResult.timedOut) {
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.TIMED_OUT,
-				"Pi process timed out",
-				{ exitCode: processResult.exitCode, stderr: processResult.stderr, timedOut: true, ...timing },
-			);
-		}
-		if (processResult.cancelled) {
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.CANCELLED,
-				"Pi process was cancelled",
-				{ exitCode: processResult.exitCode, stderr: processResult.stderr, cancelled: true, ...timing },
-			);
-		}
-		if (processResult.exitCode !== 0) {
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.NONZERO_EXIT,
-				"Pi process failed",
-				{ exitCode: processResult.exitCode, stderr: processResult.stderr, ...timing },
-			);
-		}
-		const extraction = extractPiAssistantText(processResult.stdout);
-		if (extraction.kind === "none") {
-			throw new OpaquePiReviewerTransportError(
-				OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.EMPTY_OUTPUT,
-				emptyOutputMessage(extraction.evidence),
-				{ exitCode: 0, stderr: processResult.stderr, evidence: extraction.evidence, ...timing },
-			);
-		}
-		const stdout = Buffer.from(extraction.text, "utf8");
-		return {
-			stdout,
-			promptByteLength: prompt.length,
-			stdoutByteLength: stdout.length,
-		};
-	} catch (error) {
-		primaryFailure = true;
-		throw error;
-	} finally {
-		if (scratchDirectory !== undefined) {
-			try {
-				await rm(scratchDirectory, { recursive: true, force: true });
-			} catch (error) {
-				if (!primaryFailure) {
-					throw new OpaquePiReviewerTransportError(
-						OPAQUE_PI_REVIEWER_TRANSPORT_FAILURE.CLEANUP_FAILED,
-						`Pi scratch directory cleanup failed: ${errorMessage(error)}`,
-					);
-				}
-			}
-		}
-	}
-}