@shanepadgett/tau-agent 0.34.0 → 0.36.0

package/extensions/checkpoint/checkpoint-budget.ts

@@ -15,14 +15,12 @@ export function createCheckpointBudget(initialLimit = DEFAULT_CHECKPOINT_TOKEN_L
 	let limit = validateLimit(initialLimit);
 	let highestNoticed: CheckpointBudgetLevel = 0;
 	let forced = false;
-	let baselineTokens: number | null = 0;
 
 	return {
 		configure(nextLimit: number): void {
 			limit = validateLimit(nextLimit);
 			highestNoticed = 0;
 			forced = false;
-			baselineTokens = 0;
 		},
 
 		beginTurn(tokens: number | null): CheckpointBudgetNoticeLevel | undefined {
@@ -40,23 +38,12 @@ export function createCheckpointBudget(initialLimit = DEFAULT_CHECKPOINT_TOKEN_L
 		reset(): void {
 			highestNoticed = 0;
 			forced = false;
-			baselineTokens = null;
 		},
 	};
 
 	function observe(tokens: number | null): CheckpointBudgetNoticeLevel | undefined {
 		if (tokens === null) return undefined;
-		if (baselineTokens === null) {
-			baselineTokens = tokens;
-			return undefined;
-		}
-		if (tokens < baselineTokens) {
-			baselineTokens = tokens;
-			highestNoticed = 0;
-			forced = false;
-			return undefined;
-		}
-		const level = levelFor(tokens - baselineTokens, limit);
+		const level = levelFor(tokens, limit);
 		if (level === 100) forced = true;
 		if (level <= highestNoticed) return undefined;
 		highestNoticed = level;

package/extensions/checkpoint/checkpoint.ts

@@ -105,6 +105,8 @@ function createCheckpointTool(pi: Pick<ExtensionAPI, "events" | "sendMessage">)
 			"Record concrete findings in facts and governing choices in decisions before checkpointing.",
 			"Write continue as the immediate resume directive after wake: first moves, what not to re-explore, traps to avoid. Put the backlog in work.",
 			"Use read or outline for files needed now; use deferred with a condition for files that can wait.",
+			"Preserve important discovery output before it leaves tool context. When shell or other command output is large, expensive to reproduce, or part of unfinished investigation, capture stdout and stderr in a private session-scoped temporary file; report its path, exit status, and a bounded summary instead of relying on the transcript.",
+			"Query preserved output with targeted search or ranged reads. Include artifacts needed after pruning in files, usually with read ranges or deferred with a condition, and record the artifact path and purpose in facts or continue. Do not persist routine bounded output, secrets, or whole large logs unnecessarily.",
 		],
 		parameters: checkpointParams,
 		renderShell: "self",

package/extensions/checkpoint/index.ts

@@ -50,7 +50,7 @@ export default function checkpointExtension(pi: ExtensionAPI): void {
 		if (event.toolName === CHECKPOINT_TOOL && !event.isError) checkpointSucceeded = true;
 	});
 	pi.on("tool_call", (event) => {
-		if (!budget.shouldBlockTool(event.toolName, CHECKPOINT_TOOL)) return;
+		if (checkpointSucceeded || !budget.shouldBlockTool(event.toolName, CHECKPOINT_TOOL)) return;
 		return {
 			block: true,
 			reason: formatCheckpointMessage(

package/extensions/checkpoint/messages.ts

@@ -83,6 +83,7 @@ function keepCheckpointPair(
 
 function expandPairMessages(entry: SessionEntry, message: AgentMessage): AgentMessage[] {
 	if (entry.type === "message" && (entry.message.role === "user" || entry.message.role === "assistant")) {
+		if (message.role === "assistant" && extractConversationText(message) === "") return [message];
 		return [createMessageIdMetadata(entry.id, message), message];
 	}
 	return [message];

package/extensions/commit/commit-plan.ts

@@ -54,7 +54,7 @@ export async function generatePlan(
 	const prompt = buildPlanPrompt(evidence, previousPlan, regenerationNote);
 	return generateToolValidated(
 		ctx,
-		await resolveEffortCandidates(ctx, commitEffort(evidence.files), true),
+		await resolveEffortCandidates(ctx, commitEffort(evidence.files), { includeParentModel: true }),
 		prompt,
 		COMMIT_PLAN_TOOL,
 		(input) => commitGroupsFromToolInput(input, evidence.files),
@@ -84,7 +84,7 @@ export async function regenerateMessage(
 	const prompt = buildMessagePrompt(evidence, selected, previousPlan, selectedGroupId, regenerationNote);
 	return generateValidated(
 		ctx,
-		await resolveEffortCandidates(ctx, commitEffort(selected), true),
+		await resolveEffortCandidates(ctx, commitEffort(selected), { includeParentModel: true }),
 		prompt,
 		requireCommitMessage,
 		undefined,

package/extensions/explore/README.md

@@ -1,6 +1,6 @@
 # Explore
 
-Explore gives Tau 12 structural source tools: outlines, declaration slices, discovery, structural search, graph and relationship queries, impact, and context packs. Targets use path + declaration name, with an optional line to disambiguate.
+Explore gives Tau 12 structural source tools: outlines, declaration slices, discovery, structural search, graph and relationship queries, impact, and context packs. `show` takes a top-level `targets` array of path + declaration-name objects, with an optional line to disambiguate.
 
 Pi keeps ordinary filesystem tools (`ls`, `find`, `grep`, `read`). Explore adds structure on top of supported source languages via in-process tree-sitter (WASM) on every platform supported by the Node runtime. Registered languages share the same tools and exploration workflow.
 
@@ -11,7 +11,7 @@ When `explore.read.enabled` is on (default), a full Pi `read` or autoread of a r
 ## Tools
 
 - `outline` — declarations and structure for a file, one-level directory, or recursive subtree (no bodies).
-- `show` — exact signature / docs / declaration / declaration+imports for path+name targets.
+- `show` — exact signature / docs / declaration / declaration+imports for one or more targets in its top-level `targets` array.
 - `discover` — find reusable declarations across a repo/package/subtree by name, kind, or docs (signatures only).
 - `deps` / `reverse_deps` — file import graph forward and reverse.
 - `callers` / `callees` / `references` / `implementations` — symbol relationship sites.

package/extensions/explore/guidance.ts

@@ -4,7 +4,8 @@ const GUIDANCE = `## Explore
 Shape-backed languages: \`markdown\`, \`typescript\`, \`tsx\`, \`go\`, \`rust\`, \`c_sharp\`, \`java\`, \`kotlin\`, \`swift\`.
 
 Structural tools (\`outline\`, \`show\`, \`discover\`, \`ast_search\`, deps/relationships, \`impact\`, \`context\`) apply to those languages. Other files: harness \`read\` / \`grep\` / \`find\` / \`ls\`.
-Full \`read\` of a large registered source returns outline + follow-up hint, not the body — use ranged \`read\` or \`show\`.`;
+Full \`read\` of a large registered source returns outline + follow-up hint, not the body — use ranged \`read\` or \`show\`.
+\`show\` always takes a top-level \`targets\` array, even for one declaration: \`{"targets":[{"path":"...","name":"..."}],"view":"declaration"}\`.`;
 
 export function registerExploreGuidance(pi: ExtensionAPI): void {
 	pi.on("before_agent_start", (event) => ({ systemPrompt: `${event.systemPrompt}\n\n${GUIDANCE}` }));

package/extensions/explore/tools/render.ts

@@ -1,6 +1,7 @@
 import { formatSize, keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import { formatToolRowTitle, type ToolRowStateStore } from "../../../shared/tool-row-state.ts";
+import { renderToolOutputPreview } from "../../../shared/text.ts";
 
 export type ExploreToolDetails = {
 	declarationCount: number;
@@ -94,28 +95,21 @@ export function renderExploreResult(
 	context: { lastComponent?: Component; isError: boolean },
 ): Text {
 	const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+	const output = result.content
+		.filter((item): item is { type: string; text: string } => item.type === "text" && typeof item.text === "string")
+		.map((item) => item.text)
+		.join("\n");
 	if (!expanded && !context.isError) {
 		const count = result.details?.declarationCount ?? 0;
 		const noun = count === 1 ? "declaration" : "declarations";
 		const bytes = result.details === undefined ? "" : `, ${formatSize(result.details.returnedBytes)} returned`;
+		const summary = theme.fg("muted", `${count} ${noun}${bytes}`);
+		const preview = renderToolOutputPreview(output, false, theme);
 		text.setText(
-			theme.fg("muted", `${count} ${noun}${bytes} (`) +
-				keyHint("app.tools.expand", "to expand") +
-				theme.fg("muted", ")"),
+			preview ? `${summary}\n${preview}` : `${summary} (` + keyHint("app.tools.expand", "to expand") + ")",
 		);
 		return text;
 	}
-	const output = result.content
-		.filter((item): item is { type: string; text: string } => item.type === "text" && typeof item.text === "string")
-		.map((item) => item.text)
-		.join("\n");
-	text.setText(
-		output
-			? output
-					.split("\n")
-					.map((line) => theme.fg("toolOutput", line))
-					.join("\n")
-			: "",
-	);
+	text.setText(renderToolOutputPreview(output, true, theme));
 	return text;
 }

package/extensions/explore/tools/show.ts

@@ -12,7 +12,7 @@ import { ExploreCallComponent, renderExploreResult, shrinkingListVariants, type
 
 const showTargetSchema = Type.Object(
 	{
-		path: Type.String({ description: "Defining file" }),
+		path: Type.String({ description: "Defining file for this target" }),
 		name: Type.String({ minLength: 1, description: "Decl name; dotted Type.method ok" }),
 		line: Type.Optional(Type.Integer({ minimum: 1, description: "1-based line inside decl range" })),
 	},
@@ -23,7 +23,8 @@ const showParams = Type.Object(
 	{
 		targets: Type.Array(showTargetSchema, {
 			minItems: 1,
-			description: "path+name targets (optional line pin)",
+			description:
+				'Required top-level array, even for one declaration. For one target: [{"path":"...","name":"..."}].',
 		}),
 		view: StringEnum(["signature", "signatureWithDocs", "declaration", "declarationWithImports"] as const, {
 			description: "signature | signatureWithDocs | declaration | declarationWithImports",
@@ -68,13 +69,30 @@ export function createShowTool(rowState: ToolRowStateStore, engineFor: (cwd: str
 		name: "show",
 		label: "show",
 		description:
-			"Exact signature or source for path+name targets. Whole batch fails on any missing/ambiguous target (candidate list, no partials). Views: signature → signatureWithDocs → declaration → declarationWithImports. Over budget throws — request fewer targets (bodies are not truncated).",
-		promptSnippet: "Signature or source for path+name targets",
+			'Show one or more declarations. Arguments always require a top-level `targets` array, even for one target: `{"targets":[{"path":"...","name":"..."}],"view":"declaration"}`. Whole batch fails on any missing/ambiguous target (candidate list, no partials). Views: signature → signatureWithDocs → declaration → declarationWithImports. Over budget throws — request fewer targets (bodies are not truncated).',
+		promptSnippet: "Show declarations using a top-level targets array",
 		promptGuidelines: [
+			"show always requires a top-level targets array, even for one declaration; do not pass path or name at the root.",
 			"Cheapest view that answers; declarationWithImports only when edits need imports.",
 			"Pin with path and line when names collide — do not guess.",
 		],
 		parameters: showParams,
+		prepareArguments(args) {
+			if (args === null || typeof args !== "object" || Array.isArray(args)) {
+				return args as Static<typeof showParams>;
+			}
+
+			const input = args as Record<string, unknown>;
+			if ("targets" in input || typeof input.path !== "string" || typeof input.name !== "string") {
+				return input as Static<typeof showParams>;
+			}
+
+			const { path, name, line, ...rest } = input;
+			return {
+				...rest,
+				targets: [{ path, name, ...(line === undefined ? {} : { line }) }],
+			} as Static<typeof showParams>;
+		},
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			const engine = engineFor(ctx.cwd);
 			const abort = signal ?? new AbortController().signal;

package/extensions/patch/render.ts

@@ -1,4 +1,4 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
 import { type ApplyPatchSummary, deriveStats } from "./executor.ts";
@@ -23,6 +23,7 @@ const REPLACE_FILE_MARKER = "*** Replace File: ";
 const DELETE_FILE_MARKER = "*** Delete File: ";
 const UPDATE_FILE_MARKER = "*** Update File: ";
 const MOVE_TO_MARKER = "*** Move to: ";
+const PATCH_PREVIEW_OPERATIONS = 10;
 
 function topLevelDirective(line: string): string {
 	return line.trim();
@@ -156,6 +157,21 @@ function renderOpLine(op: PreviewOp, status: OpStatus | undefined, theme: Theme)
 	return ind ? `${label}  ${ind}` : label;
 }
 
+function renderPreviewLines(preview: PreviewOp[], statuses: Map<number, OpStatus> | undefined, theme: Theme): string[] {
+	const lines = preview
+		.slice(0, PATCH_PREVIEW_OPERATIONS)
+		.map((op) => renderOpLine(op, statuses?.get(op.sectionIndex), theme));
+	const remaining = preview.length - lines.length;
+	if (remaining > 0) {
+		lines.push(
+			`${theme.fg("muted", `... (${remaining} more operations, ${preview.length} total,`)} ` +
+				keyHint("app.tools.expand", "to expand") +
+				theme.fg("muted", ")"),
+		);
+	}
+	return lines;
+}
+
 interface RenderCallContext {
 	expanded: boolean;
 	executionStarted: boolean;
@@ -198,7 +214,7 @@ export function renderPatchCall(args: { input?: string } | undefined, theme: The
 		text.setText(header);
 		return text;
 	}
-	const lines = preview.map((op) => renderOpLine(op, "pending", theme));
+	const lines = renderPreviewLines(preview, undefined, theme);
 	text.setText([header, ...lines].join("\n"));
 	return text;
 }
@@ -234,7 +250,7 @@ export function renderPatchResult(
 		return text;
 	}
 
-	const lines = preview.map((op) => renderOpLine(op, statuses.get(op.sectionIndex), theme));
+	const lines = renderPreviewLines(preview, statuses, theme);
 	text.setText([header, ...lines].join("\n"));
 	return text;
 }

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[] {
@@ -596,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();
@@ -748,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,
 	};
 }
 

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,147 +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") {
-				await showLatestReview(pi, ctx);
-				return;
-			}
-			const mode = await resolveReviewMode(requested, ctx);
-			if (!mode) return;
+			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 output = await runReviewWithPanel(pi, ctx, mode, status.root);
-			if (!output) return;
-			pi.appendEntry(REVIEW_ENTRY_TYPE, output);
-			await showReview(pi, ctx, output);
+			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,
+				});
+				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: ${errorText(error)}`,
+					signal.aborted ? "info" : "error",
+				);
+			} finally {
+				ctx.ui.setStatus("review", undefined);
+			}
 		},
 	});
 }
 
-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 showLatestReview(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	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);
-}
-
-async function resolveReviewMode(requested: string, ctx: ExtensionContext): Promise<ReviewMode | undefined> {
-	if (requested) {
-		if (!isReviewMode(requested)) {
-			ctx.ui.notify("Usage: /review [simplify|architecture|correctness|show]", "warning");
-			return undefined;
-		}
-		return requested;
-	}
-	const selected = await ctx.ui.select("Review mode", ["Simplify", "Architecture", "Correctness"]);
-	if (!selected) return undefined;
-	const normalized = selected.toLowerCase();
-	return isReviewMode(normalized) ? normalized : undefined;
-}
-
-async function runReviewWithPanel(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	mode: ReviewMode,
-	root: string,
-): Promise<ReviewRecord | undefined> {
-	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({
-			ctx,
-			root,
-			mode,
-			parentThinkingLevel: pi.getThinkingLevel(),
-			signal,
-			onProgress: (line) => panel.update(line),
-		})
-			.then((result) => done({ ...result, mode, root, createdAt: new Date().toISOString() }))
-			.catch((error: unknown) => {
-				failure = errorText(error);
-				done(undefined);
-			});
-		return panel;
-	});
-	if (output) return output;
-	ctx.ui.notify(
-		signal.aborted ? "Review cancelled" : `Review failed: ${failure ?? "unknown error"}`,
-		signal.aborted ? "info" : "error",
-	);
-	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"]>;
 }