@shanepadgett/tau-agent 0.33.1 → 0.35.0

package/extensions/reference/index.ts

@@ -55,6 +55,8 @@ export default function referenceExtension(pi: ExtensionAPI): void {
 			if (!references) return;
 
 			ctx.ui.setEditorText(buildReferenceDraft(references));
+			// Pi does not request a render when setEditorText runs after custom UI closes.
+			ctx.ui.setStatus("reference", undefined);
 		},
 	});
 }

package/extensions/reference/panel.ts

@@ -34,7 +34,12 @@ export interface ReferenceItem {
 }
 
 interface ReferenceListItem extends ReferenceItem, SelectableListItem {
-	state?: "updating" | "updated" | "failed" | "switching";
+	state?: "loading" | "updating" | "updated" | "failed" | "switching";
+}
+
+interface ReferenceLocation {
+	name: string;
+	path: string;
 }
 
 interface CloneProgress {
@@ -71,9 +76,9 @@ export async function showReferencePanel(
 	editor: ReferenceEditor,
 	branchChoices: number,
 ): Promise<ReferenceItem[] | undefined> {
-	let initial: ReferenceItem[];
+	let initial: ReferenceLocation[];
 	try {
-		initial = await loadReferences(git);
+		initial = await loadReferenceLocations();
 	} catch (error) {
 		ctx.ui.notify(`Reference load failed: ${errorText(error)}`, "error");
 		initial = [];
@@ -134,7 +139,7 @@ class ReferencePanel implements Component {
 		ctx: ExtensionCommandContext,
 		editor: ReferenceEditor,
 		branchChoices: number,
-		initial: readonly ReferenceItem[],
+		initial: readonly ReferenceLocation[],
 		done: (result: ReferenceItem[] | undefined) => void,
 	) {
 		this.tui = tui;
@@ -144,7 +149,9 @@ class ReferencePanel implements Component {
 		this.editor = editor;
 		this.branchChoices = branchChoices;
 		this.done = done;
-		this.refs = initial.map((item) => toListItem(item));
+		this.refs = initial.map((item) =>
+			toListItem({ ...item, displayName: item.name, dirty: false, branch: "" }, "loading"),
+		);
 		this.list = this.createList(this.refs);
 		this.body = {
 			render: (width) => this.renderBody(width),
@@ -158,6 +165,7 @@ class ReferencePanel implements Component {
 			footer: { kind: "hints", hints: this.footerHints() },
 		};
 		this.panel = new ToolPanel(theme, this.panelConfig);
+		void this.hydrateInitialReferences(initial);
 	}
 
 	render(width: number): string[] {
@@ -257,6 +265,25 @@ class ReferencePanel implements Component {
 		];
 	}
 
+	private branchSuffix(branch: { isCurrent: boolean; updatedAt?: number }): string {
+		if (branch.isCurrent) return "current";
+		if (branch.updatedAt === undefined) return "remote";
+		return formatAge(branch.updatedAt);
+	}
+
+	private renderBranchRow(
+		branch: { name: string; isCurrent: boolean; updatedAt?: number },
+		active: boolean,
+		renderWidth: number,
+	): string {
+		const pointer = active ? this.theme.fg("accent", "› ") : "  ";
+		const labelText = `${branch.name}  ${this.branchSuffix(branch)}`;
+		const label = active
+			? this.theme.fg("accent", labelText)
+			: this.theme.fg(branch.isCurrent ? "accent" : "text", labelText);
+		return truncateToWidth(`${pointer}${label}`, renderWidth, "");
+	}
+
 	private renderBranchPicker(width: number): string[] {
 		const picker = this.branchPicker;
 		if (!picker) return [];
@@ -279,18 +306,7 @@ class ReferencePanel implements Component {
 		for (let index = window.start; index < window.end; index++) {
 			const branch = picker.branches[index];
 			if (!branch) continue;
-			const active = index === picker.cursor;
-			const pointer = active ? this.theme.fg("accent", "› ") : "  ";
-			const suffix = branch.isCurrent
-				? "current"
-				: branch.updatedAt === undefined
-					? "remote"
-					: formatAge(branch.updatedAt);
-			const labelText = `${branch.name}  ${suffix}`;
-			const label = active
-				? this.theme.fg("accent", labelText)
-				: this.theme.fg(branch.isCurrent ? "accent" : "text", labelText);
-			lines.push(truncateToWidth(`${pointer}${label}`, renderWidth, ""));
+			lines.push(this.renderBranchRow(branch, index === picker.cursor, renderWidth));
 		}
 		if (window.start > 0 || window.end < picker.branches.length) {
 			lines.push(
@@ -303,6 +319,12 @@ class ReferencePanel implements Component {
 		return lines;
 	}
 
+	private referenceStatusMark(state: NonNullable<ReferenceListItem["state"]>): string {
+		if (state === "failed") return this.theme.fg("error", "!");
+		if (state === "updated") return this.theme.fg("success", "✓");
+		return this.theme.fg("muted", "…");
+	}
+
 	private renderReferenceRow(item: ReferenceListItem, active: boolean, width: number): string[] {
 		const separator = item.displayName.lastIndexOf("/");
 		const repository = separator < 0 ? item.displayName : item.displayName.slice(separator + 1);
@@ -310,9 +332,7 @@ class ReferencePanel implements Component {
 		const name = item.dirty ? `${repository} *` : repository;
 		const label = active ? this.theme.fg("accent", name) : this.theme.fg(item.dirty ? "warning" : "text", name);
 		const branch = item.branch ? this.theme.fg("muted", ` (${item.branch})`) : "";
-		const status = item.state
-			? ` ${this.theme.fg(item.state === "failed" ? "error" : item.state === "updated" ? "success" : "muted", item.state === "failed" ? "!" : item.state === "updated" ? "✓" : "…")}`
-			: "";
+		const status = item.state ? ` ${this.referenceStatusMark(item.state)}` : "";
 		return [truncateToWidth(`${label}${owner}${branch}${status}`, width, "")];
 	}
 
@@ -584,6 +604,38 @@ class ReferencePanel implements Component {
 		this.syncPanel();
 	}
 
+	private async hydrateInitialReferences(locations: readonly ReferenceLocation[]): Promise<void> {
+		if (locations.length === 0) return;
+		const results = await Promise.all(
+			locations.map(async (location) => {
+				try {
+					return {
+						ok: true as const,
+						location,
+						item: await loadReference(this.git, location.name, location.path),
+					};
+				} catch (error) {
+					return { ok: false as const, location, error };
+				}
+			}),
+		);
+		const loaded = new Map<string, ReferenceItem>();
+		const failures: string[] = [];
+		for (const result of results) {
+			if (result.ok) loaded.set(result.location.path, result.item);
+			else failures.push(`${result.location.name}: ${errorText(result.error)}`);
+		}
+
+		this.refs = this.refs.map((item) => {
+			if (item.state !== "loading") return item;
+			const metadata = loaded.get(item.path);
+			return metadata ? toListItem(metadata) : { ...item, state: "failed" };
+		});
+		this.list.setItems(this.refs);
+		this.syncPanel();
+		if (failures.length > 0) this.ctx.ui.notify(`Reference metadata load failed:\n${failures.join("\n")}`, "error");
+	}
+
 	private syncPanel(): void {
 		this.panelConfig.secondary = this.secondaryText();
 		this.panelConfig.header = this.headerLines();
@@ -736,28 +788,39 @@ function compareReferenceItems(left: ReferenceListItem, right: ReferenceListItem
 	return left.name.localeCompare(right.name);
 }
 
-async function loadReferences(git: GitRunner): Promise<ReferenceItem[]> {
+async function loadReferenceLocations(): Promise<ReferenceLocation[]> {
 	await mkdir(REFERENCES_DIR, { recursive: true });
-	const refs = (await readdir(REFERENCES_DIR, { withFileTypes: true }))
+	return (await readdir(REFERENCES_DIR, { withFileTypes: true }))
 		.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".clone-"))
 		.map((entry) => ({ name: entry.name, path: join(REFERENCES_DIR, entry.name) }))
 		.sort((left, right) => left.name.localeCompare(right.name));
+}
 
-	const references: ReferenceItem[] = [];
-	for (const ref of refs) references.push(await loadReference(git, ref.name, ref.path));
-	return references;
+async function loadReferences(git: GitRunner): Promise<ReferenceItem[]> {
+	const refs = await loadReferenceLocations();
+	return Promise.all(refs.map((ref) => loadReference(git, ref.name, ref.path)));
 }
 
 async function loadReference(git: GitRunner, name: string, path: string): Promise<ReferenceItem> {
-	const branch = await git.run(["branch", "--show-current"], { cwd: path, optional: true });
-	const commit = branch ? "" : await git.run(["rev-parse", "--short", "HEAD"], { cwd: path, optional: true });
-	const remoteUrl = await git.run(["config", "--get", "remote.origin.url"], { cwd: path, optional: true });
+	const [status, remoteUrl] = await Promise.all([
+		git.run(["status", "--porcelain=v2", "--branch"], { cwd: path, optional: true }),
+		git.run(["config", "--get", "remote.origin.url"], { cwd: path, optional: true }),
+	]);
+	let branch = "";
+	let commit = "";
+	let dirty = false;
+	for (const line of status.split("\n")) {
+		if (line.startsWith("# branch.head ")) branch = line.slice("# branch.head ".length);
+		else if (line.startsWith("# branch.oid ")) commit = line.slice("# branch.oid ".length).slice(0, 7);
+		else if (line && !line.startsWith("# ")) dirty = true;
+	}
+	if (branch === "(detached)") branch = commit ? `detached ${commit}` : "";
 	return {
 		name,
 		displayName: referenceDisplayName(remoteUrl, name),
 		path,
-		dirty: (await git.run(["status", "--porcelain=v1"], { cwd: path, optional: true })).length > 0,
-		branch: branch || (commit ? `detached ${commit}` : ""),
+		dirty,
+		branch,
 	};
 }
 
@@ -871,7 +934,7 @@ function referenceNameFromUrl(url: string): string {
 	return name;
 }
 
-export function referenceDisplayName(remoteUrl: string, fallback: string): string {
+function referenceDisplayName(remoteUrl: string, fallback: string): string {
 	const remote = remoteUrl
 		.trim()
 		.replace(/[?#].*$/, "")

package/extensions/review/README.md

@@ -1,11 +1,19 @@
 # Review
 
-Run `/review` to inspect current repository's staged, unstaged, and untracked work in a fresh isolated session. Choose one focused pass:
+Run `/review` without arguments to inspect the current repository's staged, unstaged, and untracked work in a fresh isolated session. This form stops when the working tree is clean.
 
-- `simplify` looks for code and concepts that can disappear or reuse what already exists.
-- `architecture` performs a nuclear maintainability review and accepts substantial redesign when ownership, reuse, or structure is poor.
-- `correctness` checks runtime bugs and failures after architecture is accepted.
+Add review direction after the command to review the requested part of the repository instead, regardless of whether the working tree has changes:
 
-Run a mode directly with `/review simplify`, `/review architecture`, or `/review correctness`. Run `/review show` to reopen latest result on current session branch.
+```text
+/review focus on cancellation, cleanup, and data loss
+```
 
-Results stay outside parent agent context. In result view, press `a` to send review to agent's next turn or `e` to export Markdown under `.pi/tau/reviews/`.
+Choose one focused review type:
+
+- `Simplify` looks for code and concepts that can disappear or reuse what already exists.
+- `Architecture` reconsiders ownership, boundaries, reuse, and overall structure.
+- `Correctness` checks concrete runtime bugs and failure paths after accepting the architecture.
+
+Then choose which logged-in provider runs the review. OpenAI Codex uses `gpt-5.6-sol` and Anthropic uses `claude-opus-5`, both at high thinking. Only providers you are logged in to appear. With no logged-in provider, the review uses the current model.
+
+Tau writes each result as Markdown under `.pi/tau/reviews/`. Review results do not enter the parent agent context. Reference the Markdown file later when you want an agent to use it.

package/extensions/review/index.ts

@@ -1,135 +1,94 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createGitRunner, loadRepoStatus } from "../../shared/git.ts";
-import { createInjectedContext } from "../../shared/injected-context.ts";
+import { resolveEffortProviders } from "../../shared/model-effort.ts";
 import { errorText } from "../../shared/text.ts";
-import {
-	formatReviewMarkdown,
-	isReviewRecord,
-	isReviewMode,
-	REVIEW_ENTRY_TYPE,
-	type ReviewMode,
-	type ReviewRecord,
-} from "./model.ts";
-import { ReviewProgressPanel, ReviewResultPanel, type ReviewResultAction } from "./panel.ts";
+import { formatReviewMarkdown, type ReviewMode } from "./model.ts";
 import { runReview } from "./session.ts";
 
+const REVIEW_TYPES = [
+	{ label: "Simplify", mode: "simplify" },
+	{ label: "Architecture", mode: "architecture" },
+	{ label: "Correctness", mode: "correctness" },
+] as const satisfies ReadonlyArray<{ label: string; mode: ReviewMode }>;
+
 export default function reviewExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("review", {
-		description: "Run or show an isolated simplify, architecture, or correctness review",
+		description: "Write an isolated requested or Git-change review to Markdown",
 		handler: async (args, ctx) => {
 			if (ctx.mode !== "tui" || !ctx.isProjectTrusted()) {
 				ctx.ui.notify("/review requires a trusted TUI project", "warning");
 				return;
 			}
 			await ctx.waitForIdle();
-			const requested = args.trim().toLowerCase();
-			if (requested === "show") {
-				const latest = latestReview(ctx.sessionManager.getBranch());
-				if (!latest) {
-					ctx.ui.notify("No review exists on this session branch", "warning");
-					return;
-				}
-				await showReview(pi, ctx, latest);
-				return;
-			}
-
-			let mode: ReviewMode | undefined;
-			if (requested) {
-				if (!isReviewMode(requested)) {
-					ctx.ui.notify("Usage: /review [simplify|architecture|correctness|show]", "warning");
-					return;
-				}
-				mode = requested;
-			} else {
-				const selected = await ctx.ui.select("Review mode", ["Simplify", "Architecture", "Correctness"]);
-				if (!selected) return;
-				const normalized = selected.toLowerCase();
-				if (!isReviewMode(normalized)) return;
-				mode = normalized;
-			}
-
+			const direction = args.trim();
 			const status = await loadRepoStatus(createGitRunner(pi, ctx));
 			if (!status) {
 				ctx.ui.notify("/review requires a Git repository", "warning");
 				return;
 			}
-			if (status.fileCount === 0) {
+			if (!direction && status.fileCount === 0) {
 				ctx.ui.notify("Nothing to review: working tree is clean", "info");
 				return;
 			}
-
-			const controller = new AbortController();
-			const signal = ctx.signal ? AbortSignal.any([controller.signal, ctx.signal]) : controller.signal;
-			let failure: string | undefined;
-			const output = await ctx.ui.custom<ReviewRecord | undefined>((tui, theme, keys, done) => {
-				const panel = new ReviewProgressPanel(tui, theme, mode, keys, () => controller.abort());
-				void runReview({
+			const selectedType = await ctx.ui.select(
+				"Review type",
+				REVIEW_TYPES.map(({ label }) => label),
+			);
+			if (!selectedType) return;
+			const mode = REVIEW_TYPES.find(({ label }) => label === selectedType)?.mode;
+			if (!mode) return;
+			const providers = resolveEffortProviders(ctx, "deep");
+			let preferred: ReviewModelChoice | undefined;
+			if (providers.length > 0) {
+				const labels = providers.map((provider) => `${provider.label} · ${provider.candidates[0]?.model.id ?? ""}`);
+				const selected = await ctx.ui.select("Review provider", labels);
+				if (!selected) return;
+				const provider = providers[labels.indexOf(selected)];
+				const candidate = provider?.candidates[0];
+				if (provider && candidate) {
+					preferred = { model: `${provider.provider}/${candidate.model.id}`, thinkingLevel: candidate.reasoning };
+				}
+			} else {
+				ctx.ui.notify("No logged-in review provider. Using current model.", "warning");
+			}
+			const signal = ctx.signal ?? new AbortController().signal;
+			ctx.ui.setStatus("review", `running ${mode} review`);
+			try {
+				const output = await runReview({
 					ctx,
 					root: status.root,
 					mode,
+					direction,
+					preferredModel: preferred?.model,
+					preferredThinkingLevel: preferred?.thinkingLevel,
 					parentThinkingLevel: pi.getThinkingLevel(),
 					signal,
-					onProgress: (line) => panel.update(line),
-				})
-					.then((result) => done({ ...result, mode, root: status.root, createdAt: new Date().toISOString() }))
-					.catch((error: unknown) => {
-						failure = errorText(error);
-						done(undefined);
-					});
-				return panel;
-			});
-			if (!output) {
+				});
+				const createdAt = new Date().toISOString();
+				const directory = join(status.root, ".pi", "tau", "reviews");
+				const timestamp = createdAt.replace(/[^0-9A-Za-z-]/g, "-");
+				const path = join(directory, `${timestamp}-${mode}-review.md`);
+				await mkdir(directory, { recursive: true });
+				await writeFile(path, formatReviewMarkdown({ ...output, mode, direction, createdAt }), {
+					encoding: "utf8",
+					mode: 0o600,
+				});
+				ctx.ui.notify(`Review written to ${path}`, "info");
+			} catch (error) {
 				ctx.ui.notify(
-					signal.aborted ? "Review cancelled" : `Review failed: ${failure ?? "unknown error"}`,
+					signal.aborted ? "Review cancelled" : `Review failed: ${errorText(error)}`,
 					signal.aborted ? "info" : "error",
 				);
-				return;
+			} finally {
+				ctx.ui.setStatus("review", undefined);
 			}
-			pi.appendEntry(REVIEW_ENTRY_TYPE, output);
-			await showReview(pi, ctx, output);
 		},
 	});
 }
 
-export function latestReview(entries: readonly SessionEntry[]): ReviewRecord | undefined {
-	for (let index = entries.length - 1; index >= 0; index -= 1) {
-		const entry = entries[index];
-		if (entry?.type !== "custom" || entry.customType !== REVIEW_ENTRY_TYPE) continue;
-		if (isReviewRecord(entry.data)) return entry.data;
-	}
-	return undefined;
-}
-
-async function showReview(pi: ExtensionAPI, ctx: ExtensionContext, review: ReviewRecord): Promise<void> {
-	const action = await ctx.ui.custom<ReviewResultAction>(
-		(tui, theme, keys, done) => new ReviewResultPanel(tui, theme, keys, review, done),
-		{
-			overlay: true,
-			overlayOptions: { anchor: "top-center", width: "80%", minWidth: 68, maxHeight: "90%", margin: 1 },
-		},
-	);
-	if (action === "send") {
-		try {
-			await pi.sendMessage(
-				createInjectedContext(formatReviewMarkdown(review), { source: "review", title: `${review.mode} review` }),
-				{ triggerTurn: false, deliverAs: "nextTurn" },
-			);
-			ctx.ui.notify("Review queued for agent's next turn", "info");
-		} catch (error) {
-			ctx.ui.notify(`Failed to send review: ${errorText(error)}`, "error");
-		}
-	} else if (action === "export") {
-		try {
-			const directory = join(review.root, ".pi", "tau", "reviews");
-			await mkdir(directory, { recursive: true });
-			const timestamp = review.createdAt.replace(/[^0-9A-Za-z-]/g, "-");
-			const path = join(directory, `${timestamp}-${review.mode}.md`);
-			await writeFile(path, formatReviewMarkdown(review), { encoding: "utf8", mode: 0o600 });
-			ctx.ui.notify(`Review exported to ${path}`, "info");
-		} catch (error) {
-			ctx.ui.notify(`Failed to export review: ${errorText(error)}`, "error");
-		}
-	}
+interface ReviewModelChoice {
+	model: string;
+	thinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
 }

package/extensions/review/model.ts

@@ -1,17 +1,11 @@
 import type { Tool } from "@earendil-works/pi-ai";
 import { Type, type Static } from "typebox";
-import { Value } from "typebox/value";
 
 const MAX_SUMMARY_LENGTH = 2_000;
 const MAX_FINDINGS = 12;
 const MAX_PATH_LENGTH = 400;
 const MAX_LINES_LENGTH = 80;
 const MAX_FINDING_LENGTH = 1_500;
-const REVIEW_MODE_SCHEMA = Type.Union([
-	Type.Literal("simplify"),
-	Type.Literal("architecture"),
-	Type.Literal("correctness"),
-]);
 const REVIEW_FINDING_SCHEMA = Type.Object(
 	{
 		severity: Type.Union([
@@ -55,21 +49,10 @@ const REVIEW_OUTPUT_SCHEMA = Type.Object(
 	},
 	{ additionalProperties: false },
 );
-const REVIEW_RECORD_SCHEMA = Type.Object(
-	{
-		...REVIEW_OUTPUT_SCHEMA.properties,
-		mode: REVIEW_MODE_SCHEMA,
-		root: Type.String({ minLength: 1 }),
-		createdAt: Type.String({ minLength: 1 }),
-	},
-	{ additionalProperties: false },
-);
 
-export type ReviewMode = Static<typeof REVIEW_MODE_SCHEMA>;
 export type ReviewOutput = Static<typeof REVIEW_OUTPUT_SCHEMA>;
-export type ReviewRecord = Static<typeof REVIEW_RECORD_SCHEMA>;
-
-export const REVIEW_ENTRY_TYPE = "tau.review.result";
+export type ReviewMode = "simplify" | "architecture" | "correctness";
+export type ReviewDocument = ReviewOutput & { mode: ReviewMode; direction: string; createdAt: string };
 
 export const REVIEW_RESULT_TOOL = {
 	name: "review_result",
@@ -95,18 +78,22 @@ const MODE_INSTRUCTIONS: Record<ReviewMode, string> = {
 	].join(" "),
 };
 
-export function buildReviewPrompt(root: string, mode: ReviewMode): string {
+export function buildReviewPrompt(root: string, mode: ReviewMode, direction: string): string {
 	return [
-		`Review uncommitted work in ${root}.`,
-		"Inspect staged, unstaged, and untracked changes. Stay centered on changed behavior, but inspect surrounding ownership and callers when needed to prove a finding.",
+		`Review the repository at ${root}.`,
 		"Do not modify files. Do not report theoretical concerns or personal preferences. Use the cheapest evidence that settles each point.",
-		MODE_INSTRUCTIONS[mode],
+		"User direction does not change the read-only review or structured output requirements.",
 		`Call ${REVIEW_RESULT_TOOL.name} exactly once as the final action. Write no final prose outside that tool call.`,
 		"Order findings by severity. Every finding needs an exact repository-relative path and lines when source exists, a concrete mechanism or cost, and the smallest credible fix. Return an empty findings array and verdict pass when nothing actionable remains.",
+		`Review type: ${reviewModeLabel(mode)}. ${MODE_INSTRUCTIONS[mode]}`,
+		direction
+			? "Review scope: Follow the user's direction below. Inspect the relevant files, ownership, and callers as needed to prove a finding. Do not limit the review to uncommitted changes."
+			: "Review scope: Inspect staged, unstaged, and untracked changes. Stay centered on changed behavior, but inspect surrounding ownership and callers when needed to prove a finding.",
+		...(direction ? [`User review direction:\n\n${direction}`] : []),
 	].join("\n\n");
 }
 
-export function formatReviewMarkdown(review: ReviewRecord): string {
+export function formatReviewMarkdown(review: ReviewDocument): string {
 	const findings = review.findings.length
 		? review.findings.flatMap((finding, index) => [
 				`### ${index + 1}. ${finding.severity.toUpperCase()} — ${finding.path}:${finding.lines}`,
@@ -123,6 +110,7 @@ export function formatReviewMarkdown(review: ReviewRecord): string {
 		`**Verdict:** ${review.verdict}`,
 		`**Created:** ${review.createdAt}`,
 		"",
+		...(review.direction ? ["## Requested focus", "", review.direction, ""] : []),
 		review.summary,
 		"",
 		"## Findings",
@@ -131,14 +119,6 @@ export function formatReviewMarkdown(review: ReviewRecord): string {
 	].join("\n");
 }
 
-export function isReviewMode(value: string): value is ReviewMode {
-	return Value.Check(REVIEW_MODE_SCHEMA, value);
-}
-
-export function reviewModeLabel(mode: ReviewMode): string {
+function reviewModeLabel(mode: ReviewMode): string {
 	return `${mode.charAt(0).toUpperCase()}${mode.slice(1)}`;
 }
-
-export function isReviewRecord(value: unknown): value is ReviewRecord {
-	return Value.Check(REVIEW_RECORD_SCHEMA, value);
-}

package/extensions/review/session.ts

@@ -1,6 +1,6 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { defineTool, type AgentSessionEvent, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { defineTool, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	createIsolatedSessionResource,
 	resolveIsolatedSessionModel,
@@ -8,7 +8,6 @@ import {
 } from "../../shared/isolated-session.ts";
 import { buildReviewPrompt, REVIEW_RESULT_TOOL, type ReviewMode, type ReviewOutput } from "./model.ts";
 
-const REVIEW_MODEL = "openai-codex/gpt-5.6-sol";
 const REVIEW_TOOLS = [
 	"read",
 	"bash",
@@ -32,11 +31,13 @@ export async function runReview(options: {
 	ctx: ExtensionContext;
 	root: string;
 	mode: ReviewMode;
+	direction: string;
+	preferredModel: string | undefined;
+	preferredThinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]> | undefined;
 	parentThinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
 	signal: AbortSignal;
-	onProgress: (status: string) => void;
 }): Promise<ReviewOutput> {
-	const { ctx, root, mode, signal, onProgress } = options;
+	const { ctx, root, mode, direction, signal } = options;
 	let output: ReviewOutput | undefined;
 	const outputTool = defineTool({
 		...REVIEW_RESULT_TOOL,
@@ -51,17 +52,16 @@ export async function runReview(options: {
 		},
 	});
 	let resource: IsolatedSessionResource | undefined;
-	let unsubscribe: (() => void) | undefined;
 	try {
 		const selected = await resolveIsolatedSessionModel({
 			label: "Review",
-			preferredModel: REVIEW_MODEL,
-			preferredThinkingLevel: "high",
+			preferredModel: options.preferredModel,
+			preferredThinkingLevel: options.preferredThinkingLevel,
 			usePreferredThinkingAfterModelFallback: false,
 			ctx,
 			parentThinkingLevel: options.parentThinkingLevel,
 			signal,
-			onWarning: onProgress,
+			onWarning: (warning) => ctx.ui.notify(warning, "warning"),
 		});
 		resource = await createIsolatedSessionResource(
 			{
@@ -76,18 +76,10 @@ export async function runReview(options: {
 			signal,
 		);
 		const { session } = resource;
-		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
-			if (event.type === "tool_execution_start") {
-				onProgress(`${event.toolName} ${summarizeArgs(event.args)}`.trim());
-			} else if (event.type === "tool_execution_end") {
-				onProgress(event.isError ? `${event.toolName} failed` : `${event.toolName} complete`);
-			}
-		});
 		const abort = () => void session.abort().catch(() => undefined);
 		signal.addEventListener("abort", abort, { once: true });
 		try {
-			onProgress(`Running ${mode} review`);
-			await session.prompt(buildReviewPrompt(root, mode), { expandPromptTemplates: false });
+			await session.prompt(buildReviewPrompt(root, mode, direction), { expandPromptTemplates: false });
 		} finally {
 			signal.removeEventListener("abort", abort);
 		}
@@ -95,12 +87,6 @@ export async function runReview(options: {
 		if (!output) throw new Error("Review ended without structured output");
 		return output;
 	} finally {
-		unsubscribe?.();
 		await resource?.dispose();
 	}
 }
-
-function summarizeArgs(args: unknown): string {
-	const text = typeof args === "string" ? args : (JSON.stringify(args) ?? String(args));
-	return text.length > 140 ? `${text.slice(0, 139)}…` : text;
-}