@shanepadgett/tau-agent 0.34.0 → 0.35.0

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"]>;
 }

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;
-}

package/extensions/soul/README.md

@@ -3,7 +3,7 @@
 Soul shapes how Tau works and talks by adding two independent sections to Pi's native assistant prompt:
 
 - **ponytail** — a lazy-senior-dev build ethos: do the smallest correct thing, reuse before writing, YAGNI, fix bugs at the root, never cut validation, security, or accessibility.
-- **caveman** — a terse communication style: drop filler, keep technical substance exact, quote the shortest decisive line, spell out anything where brevity would risk safety.
+- **simplified** — Simplified Technical English (ASD-STE100): use short sentences and paragraphs, explain jargon, and shape plans and conversations in small chunks.
 
 Pi continues to own tool guidance, project instructions, skills, documentation paths, custom prompts, and working-directory context.
 
@@ -12,7 +12,7 @@ Toggle each section in Tau settings (both on by default):
 ```json
 {
   "extensions": {
-    "soul": { "ponytail": true, "caveman": false }
+    "soul": { "ponytail": true, "simplified": false }
   }
 }
 ```

package/extensions/soul/index.ts

@@ -1,22 +1,22 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { CAVEMAN_STYLE, PONYTAIL_ETHOS } from "./prompt.ts";
+import { PONYTAIL_ETHOS, SIMPLIFIED_TECHNICAL_ENGLISH } from "./prompt.ts";
 import soulSettings from "./settings.ts";
 
 export default function soulExtension(pi: ExtensionAPI): void {
 	let ponytail = true;
-	let caveman = true;
+	let simplified = true;
 
 	pi.on("session_start", async (_event, ctx) => {
 		const settings = await loadTauExtensionSettings(ctx, soulSettings);
 		ponytail = settings.ponytail;
-		caveman = settings.caveman;
+		simplified = settings.simplified;
 	});
 
 	pi.on("before_agent_start", (event) => {
 		const sections: string[] = [];
 		if (ponytail) sections.push(PONYTAIL_ETHOS);
-		if (caveman) sections.push(CAVEMAN_STYLE);
+		if (simplified) sections.push(SIMPLIFIED_TECHNICAL_ENGLISH);
 		if (sections.length === 0) return undefined;
 		return { systemPrompt: [event.systemPrompt, ...sections].join("\n\n") };
 	});

package/extensions/soul/prompt.ts

@@ -26,18 +26,14 @@ Non-trivial logic leaves one runnable check behind: the smallest thing that fail
 
 Mark a deliberate simplification that cuts a real corner with a named ceiling and its upgrade path.`;
 
-export const CAVEMAN_STYLE = `## Communication style
+export const SIMPLIFIED_TECHNICAL_ENGLISH = `## Communication style
 
-Primary directive: simple, terse, human-like conversation. Talk to the human the way a person does, not the way a document reads. A wall of text does not get read. Outside a plan or a file you were asked to write, keep replies short. All technical substance stays. Only fluff dies.
+Use Simplified Technical English (ASD-STE100) when you communicate with the user. Assume the user is tired and has limited capacity for jargon.
 
-Drop articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), and hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No emoji, no decorative tables, no tool-call narration. Do not dump long raw logs. Quote the shortest decisive line.
+Use short sentences and short paragraphs. Explain one idea at a time. Prefer common words, active voice, and concrete explanations. Avoid idioms, vague language, filler, and unexplained abbreviations. Explain unavoidable jargon in plain words when you first use it.
 
-Standard well-known acronyms OK (DB, API, HTTP). Never invent abbreviations (cfg, impl, req, fn). The tokenizer splits them the same as the full word, so they save nothing and cost the reader clarity. No causal arrows. Technical terms, code blocks, and error strings stay exact and verbatim.
+Keep technical content exact. Do not alter paths, commands, API names, code symbols, flags, or error messages. Explain what they mean around the exact text.
 
-Preserve the user's language. Compress the style, not the language.
+Work in small chunks. Answer the immediate question first. For plans, start with the smallest useful outline and expand it only when needed. Expect plans to change after each decision. Do not write a novel before the plan has been checked.
 
-No self-reference. Never name or announce the style.
-
-No filler emphasis or manufactured insight. Skip "here's the thing", "that's the part that really matters", "and that's the key". Skip "not just X, it's Y" and "it's not X, it's Y" framing. Skip grand closers that restate the point as a lesson. State the fact, the mechanism, or the next step, then stop.
-
-Full clear sentences, terse style dropped, for security warnings, irreversible-action confirmations, multi-step sequences where order matters, and anywhere compression would create ambiguity. Resume terse after.`;
+Keep responses short enough to scan, while giving enough explanation for the user to understand the reason and next step. Do not replace explanations with fragments just to be brief. Use full clear sentences for safety, irreversible actions, exact step order, and uncertainty.`;

package/extensions/soul/settings.ts

@@ -3,14 +3,17 @@ import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
 
 export default defineTauExtensionSettings({
 	key: "soul",
-	defaults: { ponytail: true as boolean, caveman: true as boolean },
+	defaults: { ponytail: true as boolean, simplified: true as boolean },
 	schema: Type.Object(
 		{
 			ponytail: Type.Optional(
 				Type.Boolean({ default: true, description: "Add the lazy-senior-dev build ethos to Tau's system prompt." }),
 			),
-			caveman: Type.Optional(
-				Type.Boolean({ default: true, description: "Add the terse communication style to Tau's system prompt." }),
+			simplified: Type.Optional(
+				Type.Boolean({
+					default: true,
+					description: "Add Simplified Technical English and small-chunk explanations to Tau's system prompt.",
+				}),
 			),
 		},
 		{ additionalProperties: false },

package/extensions/subagent/agents/web-research.md

@@ -11,8 +11,8 @@ names:
   - Crawler
   - Netscout
   - Wayfinder
-model: openai-codex/gpt-5.6-sol
-thinking: medium
+model: openai-codex/gpt-5.6-luna
+thinking: xhigh
 ---
 
 Stay inside delegated task. Answer exactly what was asked. No broader research, background collection, unrequested recommendations, or implementation work.

package/extensions/subagent/run.ts

@@ -306,8 +306,12 @@ function subscribeTurnEvents(options: {
 	const { session, details, usage, toolUsage, turnMessages, assistantMessageEndAt, publish } = options;
 	const actionById = new Map<string, string>();
 	return session.subscribe((event: AgentSessionEvent) => {
-		if (event.type === "message_update" && event.message.role === "assistant") {
-			details.response = cappedTail(textOf(event.message), PREVIEW_LIMIT);
+		if (event.type === "message_start" && event.message.role === "assistant") {
+			details.response = "";
+			return;
+		}
+		if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+			details.response = cappedTail(details.response + event.assistantMessageEvent.delta, PREVIEW_LIMIT);
 			publish();
 			return;
 		}

package/extensions/tau-help/help.md

@@ -22,6 +22,10 @@ Names sessions from their first request so saved sessions remain findable.
 
 Adds `/branch` to create and switch Git branches from the TUI.
 
+## bash-approval
+
+Reviews every agent `bash` call with a quick-effort model before execution. Set `extensions.bashApproval.autoApprove` to run every reviewer-approved command without another confirmation. The reviewer approves routine local development work. Concrete destructive, system, production, privileged, or security-sensitive effects require human approval with one explanatory paragraph. Reviewer failures fall back to human approval and send an attention notification.
+
 ## cache-diagnostics
 
 Records private prompt-cache fingerprints without storing prompt content. Run `/cache-debug` after suspicious cache misses to write a bounded investigation report under `~/.pi/agent/cache-diagnostics/reports/`.
@@ -84,7 +88,7 @@ Adds `/ready` to scan agent-readiness rails (cold start, toolchain, verify, lint
 
 ## review
 
-Adds `/review` for explicit isolated review of current Git changes. Choose `simplify`, `architecture`, or `correctness`, or run a mode directly. Results stay outside agent context until you send them from result view, and can be exported under `.pi/tau/reviews/`. `/review show` reopens latest result on current session branch.
+Adds `/review [direction]` for an isolated simplify, architecture, or correctness review. With no direction, it reviews current Git changes. Free-form direction reviews the requested part of the repository even when the working tree is clean. Choose a review type and logged-in provider, then Tau writes the result as Markdown under `.pi/tau/reviews/` without adding it to the parent agent context.
 
 ## reference
 
@@ -108,7 +112,7 @@ Runs configured commands while keeping their output out of agent context when th
 
 ## soul
 
-Adds two independently toggleable sections to Pi’s native assistant prompt: `ponytail` (a lazy-senior-dev build ethos) and `caveman` (a terse communication style). Both on by default.
+Adds two independently toggleable sections to Pi’s native assistant prompt: `ponytail` (a lazy-senior-dev build ethos) and `simplified` (Simplified Technical English with short, explanatory responses and small planning chunks). Both on by default.
 
 ## stash
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.34.0",
+	"version": "0.35.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.0",
-		"@shanepadgett/tau-tui": "0.34.0",
+		"@shanepadgett/tau-tui": "0.35.0",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.7.1",

package/schemas/tau.schema.json

@@ -12,6 +12,22 @@
 		"extensions": {
 			"type": "object",
 			"properties": {
+				"bashApproval": {
+					"type": "object",
+					"properties": {
+						"enabled": {
+							"type": "boolean",
+							"default": true,
+							"description": "Enable bash command review and approval."
+						},
+						"autoApprove": {
+							"type": "boolean",
+							"default": true,
+							"description": "Run reviewer-approved commands without human confirmation."
+						}
+					},
+					"additionalProperties": false
+				},
 				"checkpoint": {
 					"type": "object",
 					"required": [
@@ -260,10 +276,10 @@
 							"default": true,
 							"description": "Add the lazy-senior-dev build ethos to Tau's system prompt."
 						},
-						"caveman": {
+						"simplified": {
 							"type": "boolean",
 							"default": true,
-							"description": "Add the terse communication style to Tau's system prompt."
+							"description": "Add Simplified Technical English and small-chunk explanations to Tau's system prompt."
 						}
 					},
 					"additionalProperties": false

package/shared/isolated-session.ts

@@ -142,7 +142,7 @@ export async function createIsolatedSessionResource(
 		const modelRuntime = await ModelRuntime.create();
 		modelRuntime.registerNativeProvider(inputs.provider);
 		if (inputs.runtimeApiKey !== undefined)
-			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey, { allowNetwork: false });
+			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey, { signal });
 		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
 		const resourceLoader = new DefaultResourceLoader({
 			cwd: inputs.cwd,

package/shared/model-effort.ts

@@ -24,6 +24,11 @@ export interface EffortProviderCandidates {
 	}>;
 }
 
+export interface EffortCandidateOptions {
+	includeParentModel: boolean;
+	preferredProvider?: string;
+}
+
 const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
 	quick: [
 		{
@@ -94,13 +99,19 @@ export function resolveEffortProviders(
 export function resolveEffortCandidates(
 	ctx: Pick<ExtensionContext, "modelRegistry" | "model" | "cwd" | "isProjectTrusted">,
 	effort: ModelEffort,
-	includeParentModel: boolean,
+	options: EffortCandidateOptions,
 ): Promise<ModelCandidate[]> {
+	const preferences = options.preferredProvider
+		? [
+				...MODEL_PREFERENCES[effort].filter(({ provider }) => provider === options.preferredProvider),
+				...MODEL_PREFERENCES[effort].filter(({ provider }) => provider !== options.preferredProvider),
+			]
+		: MODEL_PREFERENCES[effort];
 	return resolveCandidates(
 		ctx,
-		MODEL_PREFERENCES[effort].flatMap((preference) =>
+		preferences.flatMap((preference) =>
 			preference.models.map((model) => ({ provider: preference.provider, ...model })),
 		),
-		includeParentModel,
+		options.includeParentModel,
 	);
 }