@shanepadgett/tau-agent 0.44.1 → 0.45.1

package/extensions/review/README.md

@@ -14,6 +14,6 @@ Choose one focused review type:
 - `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.
+Then choose which logged-in provider runs the review. Models come from Tau's shared `deep` effort tier: OpenAI Codex uses `gpt-6-astra` and Anthropic uses `claude-opus-5-5`, both at medium 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/run-summary/README.md

@@ -1,5 +1,5 @@
 # Run Summary
 
-Run Summary adds a compact marker after the agent settles with no automatic continuation pending. It shows wall time and model cost across the full continuation chain. Older markers also display the delegated cost recorded for those runs.
+Run Summary adds a compact marker after the agent settles with no automatic continuation pending. It shows wall time and model cost across the full continuation chain.
 
 The marker is stored as a display-only session entry. It does not enter model context or trigger another agent turn.

package/extensions/run-summary/index.ts

@@ -1,4 +1,3 @@
-import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Marker } from "@shanepadgett/tau-tui";
 
@@ -9,11 +8,6 @@ interface RunSummary {
 	runCost: number;
 }
 
-interface PreviousRunSummary extends RunSummary {
-	subagentCost: number;
-	totalCost: number;
-}
-
 export default function runSummaryExtension(pi: ExtensionAPI): void {
 	let startedAt: number | undefined;
 	let runCost = 0;
@@ -25,13 +19,7 @@ export default function runSummaryExtension(pi: ExtensionAPI): void {
 			theme,
 			state: "muted",
 			label: "Run complete:",
-			parts: [
-				`Wall ${formatDuration(summary.wallMs)}`,
-				`Run ${formatCost(summary.runCost)}`,
-				...("subagentCost" in summary
-					? [`Subagents ${formatCost(summary.subagentCost)}`, `Total ${formatCost(summary.totalCost)}`]
-					: []),
-			],
+			parts: [`Wall ${formatDuration(summary.wallMs)}`, `Run ${formatCost(summary.runCost)}`],
 		});
 	});
 
@@ -46,7 +34,10 @@ export default function runSummaryExtension(pi: ExtensionAPI): void {
 
 	pi.on("agent_end", (event) => {
 		for (const message of event.messages) {
-			if (message.role === "assistant") runCost += finiteNonNegative((message as AssistantMessage).usage.cost.total);
+			// Tool results carry the usage of model calls a tool made.
+			if (message.role === "assistant") runCost += finiteNonNegative(message.usage.cost.total);
+			else if (message.role === "toolResult" && message.usage)
+				runCost += finiteNonNegative(message.usage.cost.total);
 		}
 	});
 
@@ -62,19 +53,10 @@ export default function runSummaryExtension(pi: ExtensionAPI): void {
 	});
 }
 
-function readRunSummary(value: unknown): RunSummary | PreviousRunSummary | undefined {
+function readRunSummary(value: unknown): RunSummary | undefined {
 	if (!value || typeof value !== "object") return undefined;
 	const record = value as Record<string, unknown>;
 	if (![record.wallMs, record.runCost].every(isFiniteNonNegative)) return undefined;
-	if ("subagentCost" in record || "totalCost" in record) {
-		if (![record.subagentCost, record.totalCost].every(isFiniteNonNegative)) return undefined;
-		return {
-			wallMs: record.wallMs as number,
-			runCost: record.runCost as number,
-			subagentCost: record.subagentCost as number,
-			totalCost: record.totalCost as number,
-		};
-	}
 	return {
 		wallMs: record.wallMs as number,
 		runCost: record.runCost as number,

package/extensions/runtime-context/README.md

@@ -1,5 +1,5 @@
 # Runtime Context
 
-Supplies Soul with the local date and root directory snapshot. Both are captured together when a prompt baseline is created and refreshed after successful compaction. Reload, resume, and midnight do not change an existing baseline.
+Supplies Soul with the local date and root directory snapshot. Both are captured on the first prompt of a session and refreshed after successful compaction. Reload, resume, and midnight do not change them.
 
 After changing this extension, run `/reload` before testing the new behavior.

package/extensions/silent-command-runner/index.ts

@@ -2,7 +2,6 @@ import { readdir, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { type ExecResult, type ExtensionAPI, keyText, type Theme } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
-import { emitTauEvent } from "../../shared/events.ts";
 import { registerPromptSource } from "../../shared/prompt-contributions.ts";
 import { matchGlob, posixPath } from "../../shared/glob.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
@@ -82,16 +81,6 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	let turnPaths = new Set<string>();
 	let abortController: AbortController | undefined;
 	let sessionActive = false;
-	let chainActive = false;
-	let attentionHoldSequence = 0;
-	let attentionHoldId: string | undefined;
-
-	function finalizeChain(): void {
-		chainActive = false;
-		const holdId = attentionHoldId;
-		attentionHoldId = undefined;
-		if (holdId) emitTauEvent(pi, "tau:attention.hold.release", { id: holdId, disposition: "notify" });
-	}
 
 	pi.registerMessageRenderer<FailureDetails>(MESSAGE_TYPE, (message, { expanded }, theme) =>
 		renderFailure(asFailureDetails(message.details), expanded, theme),
@@ -102,9 +91,6 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		sessionActive = true;
 		turnStart = Date.now();
 		turnPaths = new Set();
-		chainActive = false;
-		attentionHoldSequence = 0;
-		attentionHoldId = undefined;
 	});
 
 	registerPromptSource(pi, {
@@ -119,41 +105,43 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("agent_start", async (_event, ctx) => {
-		const startingChain = !chainActive;
-		chainActive = true;
-		if (!settings.enabled || settings.commands.length === 0) {
-			if (startingChain) {
-				turnStart = Date.now();
-				turnPaths = new Set();
-			}
-			return;
-		}
-		if (!startingChain) return;
-		attentionHoldId = `silent-command-runner:${++attentionHoldSequence}`;
-		emitTauEvent(pi, "tau:attention.hold.acquire", { id: attentionHoldId });
 		turnStart = Date.now();
-		const projectRoot = await resolveProjectRoot(ctx.cwd);
-		turnPaths = new Set(await walkFiles(projectRoot));
+		turnPaths =
+			settings.enabled && settings.commands.length > 0
+				? new Set(await walkFiles(await resolveProjectRoot(ctx.cwd)))
+				: new Set();
 	});
 
-	pi.on("agent_end", async (event, ctx) => {
-		if (hasAbortedAssistantMessage(event.messages)) return;
+	// The last boundary before the run settles: failures continue the run instead of starting a new one.
+	pi.on("agent_before_settle", async (event, ctx) => {
+		if (event.outcome !== "completed") return undefined;
 		try {
-			await runChangedCommands(ctx.cwd, turnStart, ctx.ui.notify);
+			const failures = await runChangedCommands(ctx.cwd, ctx.ui.notify);
+			if (!failures || failures.length === 0) return undefined;
+			return {
+				entries: [
+					...event.entries,
+					{
+						type: "custom_message" as const,
+						customType: MESSAGE_TYPE,
+						content: formatAgentMessage(failures),
+						display: true,
+						details: { failed: [...failures] } satisfies FailureDetails,
+					},
+				],
+				continue: true,
+			};
 		} catch (error: unknown) {
 			ctx.ui.notify(`silent-command-runner: ${errorMessage(error)}`, "error");
+			return undefined;
 		}
 	});
 
-	pi.on("agent_settled", finalizeChain);
-
 	pi.on("session_shutdown", () => {
 		sessionActive = false;
 		abortController?.abort();
 		abortController = undefined;
 		turnPaths = new Set();
-		chainActive = false;
-		attentionHoldId = undefined;
 	});
 
 	async function collectCommandFailures(
@@ -183,37 +171,16 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		return failures;
 	}
 
-	function reportCommandResults(
-		changed: readonly CommandConfig[],
-		failures: readonly FailedCommandDetails[],
-		notify: (message: string, type?: "info" | "warning" | "error") => void,
-	): void {
-		const failedNames = new Set(failures.map((failure) => failure.name));
-		const passed = changed.filter((command) => !failedNames.has(command.name));
-		if (passed.length > 0) notify(`silent-command-runner: passed ${formatCommandNames(passed)}`, "info");
-		if (failures.length === 0) return;
-		pi.sendMessage<FailureDetails>(
-			{
-				customType: MESSAGE_TYPE,
-				content: formatAgentMessage(failures),
-				display: true,
-				details: { failed: [...failures] },
-			},
-			{ deliverAs: "followUp" },
-		);
-	}
-
 	async function runChangedCommands(
 		cwd: string,
-		turnStart: number,
 		notify: (message: string, type?: "info" | "warning" | "error") => void,
-	): Promise<void> {
-		if (!settings.enabled || settings.commands.length === 0) return;
+	): Promise<FailedCommandDetails[] | undefined> {
+		if (!settings.enabled || settings.commands.length === 0) return undefined;
 
 		const projectRoot = await resolveProjectRoot(cwd);
 		const paths = await walkFiles(projectRoot);
 		const changed = await scanChangedCommands(projectRoot, settings.commands, paths, turnPaths, turnStart);
-		if (!sessionActive || changed.length === 0) return;
+		if (!sessionActive || changed.length === 0) return undefined;
 
 		notify(
 			changed.length === 1
@@ -223,8 +190,16 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		);
 
 		const failures = await collectCommandFailures(projectRoot, changed, notify);
-		if (failures === undefined || !sessionActive) return;
-		reportCommandResults(changed, failures, notify);
+		if (failures === undefined || !sessionActive) return undefined;
+		const failedNames = new Set(failures.map((failure) => failure.name));
+		const passed = changed.filter((command) => !failedNames.has(command.name));
+		if (passed.length > 0) notify(`silent-command-runner: passed ${formatCommandNames(passed)}`, "info");
+		if (failures.length > 0) {
+			// Only files the agent changes after this report can trigger another check and continuation.
+			turnStart = Date.now();
+			turnPaths = new Set(paths);
+		}
+		return failures;
 	}
 }
 
@@ -255,7 +230,7 @@ function normalizeSettings(value: typeof silentCommandRunnerSettings.defaults):
 
 function formatSilentCheckPrompt(commands: readonly CommandConfig[]): string {
 	return [
-		"Do not manually run the commands listed below. They run automatically after matching changes. After fixing a reported failure, end the turn so they can run again. Targeted checks outside this list remain allowed when needed.",
+		"Do not manually run the commands listed below. They run automatically after matching changes. Complete the work and finish normally; treat it as correct unless a failure is reported. Do not announce pending validation, hedge completion because of these commands, or tell the user that checks will run or rerun. If a failure is reported, fix it and describe the correction, then finish normally. Do not claim commands passed without evidence. Targeted checks outside this list remain allowed when needed.",
 		"Automatic commands:",
 		...commands.map(formatSilentCheckCommand),
 	].join("\n");
@@ -271,12 +246,6 @@ function formatSilentCheckCommand(command: CommandConfig): string {
 	].join("\n");
 }
 
-function hasAbortedAssistantMessage(messages: readonly unknown[]): boolean {
-	return messages.some(
-		(message) => isRecord(message) && message.role === "assistant" && message.stopReason === "aborted",
-	);
-}
-
 async function scanChangedCommands(
 	projectRoot: string,
 	commands: readonly CommandConfig[],
@@ -403,7 +372,7 @@ function formatAgentMessage(failures: readonly FailedCommandDetails[]): string {
 	return [
 		`silent-command-runner failed: ${failures.length} command${failures.length === 1 ? "" : "s"}`,
 		...failures.map(formatAgentFailure),
-		"**Do not** rerun these checks. They will run automatically after your fix.",
+		"Fix the reported failures without manually rerunning these commands. Describe the correction and finish normally; do not announce validation or reruns.",
 	].join("\n\n");
 }
 

package/extensions/soul/README.md

@@ -2,10 +2,8 @@
 
 Soul supplies Tau's system prompt: communication, discussion, planning, execution, and coding guidance. It is always on.
 
-Soul captures tools, skills, project instructions, documentation, and environment context in a saved baseline. Reload and resume reuse it. Successful compaction captures a fresh baseline, including a new date and directory listing.
+Soul adds Pi documentation pointers, tool guidance, and the context that other Tau extensions supply, such as the local date, directory snapshot, and automatic-check instructions. The date and directory snapshot are captured on the first prompt and again after successful compaction, so they stay fixed across turns, reload, resume, and tree navigation.
 
-Changes to available agents, automatic checks, approval guidance, and loaded tools are supplied as saved context updates. Earlier instructions and updates keep their positions instead of being rewritten each turn.
+Everything else is read each turn. When an instruction changes, such as an edited `AGENTS.md` after `/reload`, a changed automatic-check configuration, or a different set of active tools, Pi appends the updated section without rewriting earlier instructions. Models that cannot take later system messages receive the change in the leading instructions, which costs one cache miss on the next request.
 
-Tools that cannot be loaded without changing the cached prefix wait for compaction. Tool execution permissions still take effect immediately. Soul reports incompatible prompt replacements or changes to previously sent history rather than silently replacing its baseline.
-
-Run `/reload` after changing this extension. The first request after installation captures the new Soul baseline; later instruction edits take effect after compaction.
+Run `/reload` after changing this extension.

package/extensions/soul/index.ts

@@ -1,144 +1,68 @@
-import { getCurrentTools, toToolDeclaration } from "@earendil-works/pi-ai";
-import { createHash } from "node:crypto";
-import type { BuildSystemPromptOptions, ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { emitTauEvent, onTauEventImmediately } from "../../shared/events.ts";
-import { readPromptValues, renderBaseline, renderUpdate } from "./context.ts";
-import {
-	admittedTools,
-	BASELINE_TYPE,
-	projectPrompt,
-	restorePrompt,
-	UPDATE_TYPE,
-	type SavedBaseline,
-	type SavedUpdate,
-} from "./state.ts";
-import { toolChangeReason } from "./tools.ts";
+import { getDocsPath, getExamplesPath, getReadmePath, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { emitTauEvent } from "../../shared/events.ts";
+import { collectPromptSources } from "../../shared/prompt-contributions.ts";
+import { FIXED_INSTRUCTIONS } from "./prompt.ts";
 
-const CHECKPOINT_TYPE = "tau.soul.prefix";
-interface PrefixCheckpoint {
-	baselineEntryId: string;
-	count: number;
-	hash: string;
-}
+const CAPTURE_TYPE = "tau.soul.capture";
 
-export default function soulExtension(pi: ExtensionAPI): void {
-	let inputs: BuildSystemPromptOptions | null = null;
+const DOCUMENTATION = `Consult Pi or Tau documentation when the request concerns their usage or extension APIs.
+Pi documentation:
+- Main documentation: ${getReadmePath()}
+- Additional docs: ${getDocsPath()}
+- Examples: ${getExamplesPath()}
+- Resolve docs/... and examples/... under those installed paths, not the working directory.
+- Extensions: docs/extensions.md and examples/extensions/; themes: docs/themes.md; skills: docs/skills.md; prompt templates: docs/prompt-templates.md; TUI: docs/tui.md; keybindings: docs/keybindings.md; SDK: docs/sdk.md; providers: docs/custom-provider.md; models: docs/models.md; packages: docs/packages.md; environment: docs/environment-variables.md.
+- Read the relevant documentation and follow related Markdown references before implementing Pi integrations.`;
 
-	pi.on("session_start", () => {
-		inputs = null;
-	});
-	pi.on("session_shutdown", () => {
-		inputs = null;
-	});
-	pi.on("before_agent_start", (event) => {
-		// Keep the shared options reference until all contributors have finished.
-		inputs = event.systemPromptOptions;
-	});
+export default function soulExtension(pi: ExtensionAPI): void {
+	pi.on("before_agent_start", async (event, ctx) => {
+		const options = event.systemPromptOptions;
 
-	onTauEventImmediately(pi, "soul.tools", "tau:prompt.tools.check", ({ ctx, tools, reject }) => {
-		try {
-			const saved = restorePrompt(ctx.sessionManager.getBranch());
-			if (!saved || !ctx.model) return;
-			const previous = admittedTools(saved);
-			// getAllTools exposes schemas but not constrainedSampling. Preserve that
-			// metadata here; the request boundary checks the complete Pi declarations.
-			const reason = toolChangeReason(
-				ctx.model,
-				previous,
-				tools.map((tool) => ({
-					...previous.find((candidate) => candidate.name === tool.name),
-					...tool,
-				})),
-			);
-			if (reason) reject(reason);
-		} catch (error) {
-			reject(String(error));
+		// Sources that refresh on compaction are read once per compaction epoch and saved on the branch.
+		const branch = ctx.sessionManager.getBranch();
+		let epochStart = 0;
+		branch.forEach((entry, index) => {
+			if (entry.type === "compaction") epochStart = index + 1;
+		});
+		let captured: Record<string, string> = {};
+		for (const entry of branch.slice(epochStart)) {
+			if (entry.type === "custom" && entry.customType === CAPTURE_TYPE)
+				captured = entry.data as Record<string, string>;
+		}
+		const sources = collectPromptSources(pi);
+		const missing = sources.filter((source) => source.refresh === "compaction" && !(source.key in captured));
+		if (missing.length > 0) {
+			const read = await Promise.all(missing.map(async (source) => [source.key, await source.read(ctx)] as const));
+			captured = { ...captured, ...Object.fromEntries(read) };
+			pi.appendEntry(CAPTURE_TYPE, captured);
 		}
-	});
 
-	pi.on("context_with_system", async (event, ctx) => {
-		try {
-			if (!inputs) throw new Error("Soul has no loaded prompt inputs.");
-			if (inputs.forceSystemPrompt !== undefined)
-				throw new Error(
-					"A forced system prompt conflicts with Soul. Remove the extension's systemPrompt replacement.",
-				);
-			const branch = ctx.sessionManager.getBranch();
-			const newestFirst = [...branch].reverse();
-			const projection = ctx.sessionManager.buildSessionProjection();
-			const anchor = [...projection.entries].reverse().find((entry) => entry.messages.length > 0);
-			if (!anchor) throw new Error("Soul has no conversation anchor.");
-			const saved = restorePrompt(branch);
-			const active = new Set(pi.getActiveTools());
-			const requested = getCurrentTools(event.messages)
-				.filter((tool) => active.has(tool.name))
-				.map(toToolDeclaration);
-			if (saved && ctx.model) {
-				const reason = toolChangeReason(ctx.model, admittedTools(saved), requested);
-				if (reason) throw new Error(reason);
-			}
-			const values = await readPromptValues(pi, ctx, inputs, saved === null);
-			if (!saved) {
-				pi.appendEntry<SavedBaseline>(BASELINE_TYPE, {
-					version: 1,
-					compactionId: newestFirst.find((entry) => entry.type === "compaction")?.id ?? null,
-					afterEntryId: anchor.sourceEntry.id,
-					text: renderBaseline(inputs, values),
-					values,
-					initialTools: getCurrentTools(event.messages),
-				});
-			} else {
-				const previous = new Map(saved.baseline.values.map((value) => [value.key, value]));
-				for (const update of saved.updates) for (const value of update.data.values) previous.set(value.key, value);
-				const currentKeys = new Set(values.map((value) => value.key));
-				for (const value of previous.values()) {
-					if (value.refresh === "append" && !currentKeys.has(value.key)) values.push({ ...value, text: "" });
-				}
-				const changed = values.filter((value) => previous.get(value.key)?.text !== value.text);
-				const tools = new Map(admittedTools(saved).map((tool) => [tool.name, tool]));
-				const added = requested.some((tool) => !tools.has(tool.name));
-				for (const tool of requested) tools.set(tool.name, tool);
-				if (changed.length > 0 || added)
-					pi.appendEntry<SavedUpdate>(UPDATE_TYPE, {
-						version: 1,
-						baselineEntryId: saved.entryId,
-						afterEntryId: anchor.sourceEntry.id,
-						text: renderUpdate(changed),
-						values: changed,
-						tools: [...tools.values()],
-					});
-			}
-			const admitted = restorePrompt(ctx.sessionManager.getBranch());
-			if (!admitted) throw new Error("Soul failed to save its baseline.");
-			const messages = projectPrompt(event.messages, admitted, ctx);
-			const checkpointEntry = newestFirst.find(
-				(entry) => entry.type === "custom" && entry.customType === CHECKPOINT_TYPE,
-			);
-			const checkpoint = checkpointEntry?.type === "custom" ? (checkpointEntry.data as PrefixCheckpoint) : null;
-			if (checkpoint?.baselineEntryId === admitted.entryId) {
-				const prefix = createHash("sha256")
-					.update(JSON.stringify(messages.slice(0, checkpoint.count)))
-					.digest("hex");
-				if (prefix !== checkpoint.hash)
-					throw new Error("Previously sent conversation content changed. Compact before continuing.");
-			}
-			const hash = createHash("sha256").update(JSON.stringify(messages)).digest("hex");
-			if (hash !== checkpoint?.hash)
-				pi.appendEntry<PrefixCheckpoint>(CHECKPOINT_TYPE, {
-					baselineEntryId: admitted.entryId,
-					count: messages.length,
-					hash,
-				});
-			emitTauEvent(pi, "tau:prompt.snapshot", {
-				text: [admitted.baseline.text, ...admitted.updates.map((update) => update.data.text)].join("\n\n"),
-			});
-			return { messages };
-		} catch (error) {
-			ctx.ui.notify(`Soul stopped this request: ${error instanceof Error ? error.message : String(error)}`, "error");
-			ctx.abort();
-			// Pi currently enters the provider with an aborted signal; do not weaken that
-			// cancellation into a fallback prompt. See soul-request-check-findings.md.
-			return undefined;
+		const active = pi.getActiveTools();
+		const guidance = [
+			...new Set([
+				...(active.includes("bash") ? ["Use bash for file operations like ls, rg, find."] : []),
+				...active.flatMap((name) => options.toolGuidelines[name] ?? []),
+				...options.promptGuidelines,
+			]),
+		]
+			.map((rule) => `- ${rule}`)
+			.join("\n");
+
+		const sections = new Map<string, string[]>();
+		const add = (section: string, text: string) => {
+			if (text.trim()) sections.set(section, [...(sections.get(section) ?? []), text]);
+		};
+		add("documentation", DOCUMENTATION);
+		add("tool-guidance", guidance);
+		if (options.customPrompt) add("additional-instructions", options.customPrompt);
+		for (const source of sources) {
+			add(source.section, source.refresh === "append" ? await source.read(ctx) : (captured[source.key] ?? ""));
 		}
+
+		// Pi diffs these sections against the prompt already in the transcript and appends a patch only for
+		// sections whose text changed, so unchanged sections keep the cached prefix.
+		options.customPrompt = FIXED_INSTRUCTIONS;
+		for (const name of [...sections.keys()].sort()) options.sections[name] = (sections.get(name) ?? []).join("\n\n");
+		emitTauEvent(pi, "tau:prompt.snapshot", { text: event.systemPrompt });
 	});
 }

package/extensions/soul/prompt.ts

@@ -9,6 +9,8 @@ Use headings or tables when they improve clarity. In conversational, personal, o
 Use technical terms when they help. Keep paths, commands, API names, and errors exact.
 State the intended action directly. Avoid adding what you won't do, what will remain unchanged, or how you'll separate or categorize results.
 Give useful facts instead of praise, ceremony, or commentary about following instructions.
+Talk about the user's work, not the machinery directing your behavior. Do not volunteer commentary about system prompts, tool prompts, internal instructions, the harness, or automatic validation. Discuss those mechanisms only when the user asks about them as the subject of the work.
+Finish with the concrete result. Do not hedge completion because silent validation is pending, announce that checks will run or rerun, or explain what happens when you end the turn. When a failure is reported, fix it and describe the correction without narrating the validation process.
 You are a partner, and the user expects you to act like one.
 </communication>
 

package/extensions/tau-help/help.md

@@ -32,6 +32,10 @@ Records private prompt-cache fingerprints without storing prompt content. Run `/
 
 Adds `/clear-screen` to clear terminal output without changing the session.
 
+## codex-priority
+
+Requests Codex priority processing (Fast mode) for every `gpt-6-luna` request on the `openai-codex` provider, including the agent loop, compaction, tool approval, auto-naming, commit, and handoff. It has no command or setting. Cost uses OpenAI's 2.5x Fast mode rate for GPT-6 models. Do not run another extension that overlays `openai-codex` or sets `service_tier`.
+
 ## commit
 
 Adds `/commit` for semantic commit grouping, review, and committing selected repository changes.
@@ -40,6 +44,10 @@ Adds `/commit` for semantic commit grouping, review, and committing selected rep
 
 Adds `/cost-report` to build an HTML spend report from local session usage. Pick a time frame (past 7 days, current week, current month, year to date, or a specific month) and scope (current project or all sessions). Tau scans sessions, writes under `~/.pi/tau/cost-reports/`, opens the file, and notifies with the path. Empty windows warn without writing a file.
 
+## compaction
+
+Writes compaction summaries (automatic, `/compact`, and overflow recovery) with a cheaper model from the same provider as the session, so Opus, GPT-6.1 Sol, and Astra sessions do not pay their own rates to summarize themselves. Summaries never cross providers, and a notice names the model that wrote each one. When no cheaper model fits, Pi's default compaction runs.
+
 ## context
 
 Adds `/context` to browse and inject reusable repository work scopes from `.pi/contexts`. Selecting entries injects them once into the conversation: `read` paths as complete files, `show` targets as current declaration slices, `outline` paths as Explore structures, and one hidden note listing `references` plus instructions to treat the injected material as current. Run `/context` again to inject more. Edit catalog files by hand when work scopes change. Domain folders are `NN_slug` tabs (ordered by the two-digit prefix; UI shows the slug), TOML files are concepts, and TOML sections are selectable entries.
@@ -106,7 +114,7 @@ Runs configured commands while keeping their output out of agent context when th
 
 ## soul
 
-Supplies Tau's communication, discussion, planning, execution, and coding instructions. Saves a prompt baseline across turns, reload, and resume; refreshes it after successful compaction. Operational changes arrive as saved context updates without rewriting earlier instructions. Tool groups that cannot load without changing the cached prefix wait for successful compaction.
+Supplies Tau's communication, discussion, planning, execution, and coding instructions, plus tool guidance and context from other Tau extensions. The date and directory snapshot stay fixed until successful compaction. Other changes, such as an edited `AGENTS.md` after `/reload`, arrive as appended updates without rewriting earlier instructions.
 
 ## stash
 
@@ -126,7 +134,7 @@ Reviews agent `bash` and `script_runner` requests before they run. Common read-o
 
 ## tool-loader
 
-Progressively exposes registered specialist tool groups through `load_tools`. Tau registers `web`, `image`, and `appshot`; project or global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. Compatible models load tools without replacing the cached prefix. Otherwise, requested groups are queued until successful compaction; loading never triggers compaction automatically.
+Keeps specialist tool groups out of every request as deferred tools and lets the agent load them with Pi's `tool_search`. Tau registers `web`, `image`, and `appshot`; project or global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. All models can load tools. Compatible models preserve the cached prefix; other models can incur a cache miss when tools are activated. Loading never triggers compaction.
 
 ## web
 

package/extensions/tool-approval/index.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel, Tool } from "@earendil-works/pi-ai";
+import type { Tool } from "@earendil-works/pi-ai";
 import {
 	isToolCallEventType,
 	type ExtensionAPI,
@@ -9,7 +9,8 @@ import { Marker } from "@shanepadgett/tau-tui";
 import { Type } from "typebox";
 import { emitAgentBlocked } from "../../shared/agent-blocked.ts";
 import { emitTauEvent } from "../../shared/events.ts";
-import { generateToolValidated, resolveCandidates } from "../../shared/model-fallback/index.ts";
+import { generateToolValidated } from "../../shared/model-fallback/index.ts";
+import { resolveEffortCandidates } from "../../shared/model-effort.ts";
 import type { ScriptSourceStore } from "../../shared/script-source.ts";
 import { errorText, truncAt } from "../../shared/text.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
@@ -59,15 +60,6 @@ const REVIEW_TOOL = {
 	parameters: REVIEW_SCHEMA,
 } satisfies Tool;
 
-const REVIEW_MODELS: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = [
-	{ provider: "openai", model: "gpt-6-luna", reasoning: "medium" },
-	{ provider: "openai-codex", model: "gpt-6-luna", reasoning: "medium" },
-	{ provider: "anthropic", model: "claude-sonnet-5", reasoning: "medium" },
-	{ provider: "xai", model: "grok-4.5", reasoning: "low" },
-	{ provider: "openrouter", model: "deepseek/deepseek-v4.1-flash", reasoning: "high" },
-	{ provider: "opencode-go", model: "deepseek-v4.1-flash", reasoning: "high" },
-];
-
 type ToolReview =
 	| { decision: "approved"; summary: string }
 	| { decision: "requires_user_approval"; summary: string; reason: string };
@@ -383,23 +375,11 @@ async function reviewAssistantRequests(
 
 async function reviewToolRequest(ctx: ExtensionContext, request: ToolApprovalRequest): Promise<ToolReviewResult> {
 	const requestJson = JSON.stringify(request);
-	const reviewer = REVIEW_MODELS.find((item) => item.provider === ctx.model?.provider);
-	const preferred = reviewer ? [reviewer] : [];
-	if (ctx.model) {
-		preferred.push({
-			provider: ctx.model.provider,
-			model: ctx.model.id,
-			reasoning: "medium",
-		});
-	}
-	const candidates = await resolveCandidates(ctx, preferred, false);
-	const wanted = preferred[0];
-	if (
-		wanted &&
-		!candidates.some((item) => item.model.provider === wanted.provider && item.model.id === wanted.model)
-	) {
-		ctx.ui.notify(`Tool review skipped ${wanted.provider}/${wanted.model}; trying next model.`, "info");
-	}
+	// Requests contain shell commands and scripts, so only the session's own provider reviews them.
+	const provider = ctx.model?.provider;
+	const candidates = (
+		await resolveEffortCandidates(ctx, "quick", { includeParentModel: true, preferredProvider: provider })
+	).filter((candidate) => candidate.model.provider === provider);
 	const { value, candidate } = await generateToolValidated(
 		ctx,
 		candidates,

package/extensions/tool-loader/README.md

@@ -1,15 +1,15 @@
 # Tool Loader
 
-Tau progressively exposes registered specialist tool groups. Most coding turns do not need web, image, macOS application, or application-specific schemas, so Pi can load those tools later without discarding supported provider cache prefixes.
+Tau registers specialist tool groups as deferred tools so their schemas stay out of every request. Most coding turns do not need web, image, macOS application, or application-specific schemas. The agent finds and loads them with Pi's built-in `tool_search` tool, which Tau keeps active whenever deferred tools exist.
 
-The agent normally calls `load_tools` itself. Tau's built-in groups are:
+Tau's built-in groups are:
 
 - `web` for public web and implementation research
 - `image` for raster image generation and editing
 - `appshot` for macOS window discovery, capture, and activation
 
-Project and global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. The group description is included in the loader catalog so the agent can select it when a task needs that capability.
+Project and global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. The group id and description become the tool namespace shown to the agent.
 
-Supported models load new groups without replacing the cached prompt prefix. If the selected model cannot do that, the group is queued for activation after successful compaction. The loader reports this and does not compact automatically.
+Loaded tools are recorded in the session and stay available on that branch. All models can discover and load deferred tools. Supported models preserve the cached prompt prefix; other models, including Grok and opencode-go, can incur a cache miss when tools are activated. Tau does not compact automatically.
 
-After changing this extension during development, run `/reload` before testing.
+Pi's built-in `tool_search` extension must be enabled. After changing this extension during development, run `/reload` before testing.