@shanepadgett/tau-agent 0.44.0 → 0.45.0

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/script-runner/README.md

@@ -2,6 +2,8 @@
 
 Gives the agent a first-class `script_runner` tool for running Python 3, Node.js, and Deno scripts instead of falling back to bash. The agent picks whichever runtime is more efficient for the task.
 
-When a run fails, the tool keeps the script and returns a `scriptId`. The agent retries with targeted `{oldText, newText}` edits against what it just wrote instead of resending the whole script, saving output tokens and keeping duplicate scripts out of context. Only the source the agent already sent is referenced; no file path is exposed.
+When a run fails, the tool keeps the script and returns a `scriptId`. The agent retries with targeted `{oldText, newText}` edits against what it just wrote instead of resending the whole script, saving output tokens and keeping duplicate scripts out of context. Only the source the agent already sent is referenced; no script source file path is exposed.
+
+Long output shows the tail and a path to the complete output in a temporary file for the active session.
 
 Runtimes are detected from the environment: Python 3 via `python3`, Node via the current process when Node is 22.6 or newer (`node --experimental-strip-types`), Deno via `deno` (`deno run -A`). The `node` language is the local Node.js runtime with full Node APIs; scripts may be TypeScript with erasable syntax or plain JavaScript. The `deno` language is the local Deno runtime with full permissions and native TypeScript/JavaScript. The tool registers only the runtimes actually available and is hidden from the prompt entirely when none are present.

package/extensions/script-runner/index.ts

@@ -4,17 +4,13 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
-import {
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	defineTool,
-	type ExecResult,
-	type ExtensionAPI,
-	type Theme,
-	truncateTail,
-} from "@earendil-works/pi-coding-agent";
+import { defineTool, type ExecResult, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { BoundedTextResultBuilder } from "../../shared/bounded-text-result.ts";
+import { onTauEventImmediately } from "../../shared/events.ts";
+import { createScriptSourceStore } from "../../shared/script-source.ts";
+import { createTemporaryOutputStore } from "../../shared/temporary-output-store.ts";
 import { renderToolOutputPreview } from "../../shared/text.ts";
 
 type Language = "python3" | "node" | "deno";
@@ -25,13 +21,7 @@ interface Runtimes {
 	deno: string | undefined;
 }
 
-interface StoredScript {
-	language: Language;
-	source: string;
-}
-
 const TIMEOUT_MS = 120_000;
-const MAX_STORED = 8;
 
 function detectRuntimes(): Runtimes {
 	let python3: string | undefined;
@@ -81,18 +71,6 @@ function scrubPath(text: string, file: string, dir: string): string {
 	return text.replaceAll(file, "<script>").replaceAll(dir, "<tmpdir>");
 }
 
-function applyEdits(source: string, edits: ReadonlyArray<{ oldText: string; newText: string }>): string {
-	let next = source;
-	for (const edit of edits) {
-		const idx = next.indexOf(edit.oldText);
-		if (idx === -1) {
-			throw new Error("edits oldText not found. Copy exact text from the script you wrote.");
-		}
-		next = next.slice(0, idx) + edit.newText + next.slice(idx + edit.oldText.length);
-	}
-	return next;
-}
-
 function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: string }>, theme: Theme): string {
 	return edits
 		.map((edit) => {
@@ -109,56 +87,6 @@ function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: str
 		.join("\n");
 }
 
-function resolveScriptSource(
-	scripts: Map<string, StoredScript>,
-	language: Language,
-	params: {
-		script?: string;
-		scriptId?: string;
-		edits?: ReadonlyArray<{ oldText: string; newText: string }>;
-	},
-): { scriptId: string; source: string } {
-	const edits = params.edits;
-	if (edits && edits.length > 0) {
-		const scriptId = params.scriptId;
-		if (!scriptId) throw new Error("edits require scriptId from the failed run.");
-		const stored = scripts.get(scriptId);
-		if (!stored) throw new Error(`No stored script for scriptId ${scriptId}. Evicted; resend full script.`);
-		if (stored.language !== language) {
-			throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
-		}
-		return { scriptId, source: applyEdits(stored.source, edits) };
-	}
-	if (typeof params.script !== "string" || params.script.length === 0) {
-		throw new Error("Provide script, or edits + scriptId.");
-	}
-	return { scriptId: params.scriptId ?? newScriptId(), source: params.script };
-}
-
-function formatTruncatedTail(text: string): { body: string; note: string } {
-	const trunc = truncateTail(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
-	const note = trunc.truncated
-		? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
-		: "";
-	return { body: trunc.content, note };
-}
-
-function successScriptResult(stdout: string): { content: [{ type: "text"; text: string }]; details: undefined } {
-	const { body, note } = formatTruncatedTail(stdout.trim());
-	const out = body.trim();
-	return {
-		content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
-		details: undefined,
-	};
-}
-
-function throwScriptFailure(scriptId: string, result: { stdout: string; stderr: string }): never {
-	const diag = result.stderr.trim() || result.stdout.trim();
-	const { body, note } = formatTruncatedTail(diag);
-	const detail = body ? `${body}${note}\n\n` : "";
-	throw new Error(`${detail}scriptId: ${scriptId}`);
-}
-
 export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	const runtimes = detectRuntimes();
 	const detected = (["python3", "node", "deno"] as const).filter(
@@ -168,16 +96,15 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 
 	const langPhrase = formatLangList(detected);
 
-	const scripts = new Map<string, StoredScript>();
-
-	function remember(scriptId: string, script: StoredScript): void {
-		scripts.set(scriptId, script);
-		while (scripts.size > MAX_STORED) {
-			const oldest = scripts.keys().next().value;
-			if (oldest === undefined) break;
-			scripts.delete(oldest);
-		}
-	}
+	const scriptStore = createScriptSourceStore();
+	const temporaryOutput = createTemporaryOutputStore();
+	onTauEventImmediately(pi, "script-runner.source-store", "tau:script-runner.source-store", ({ accept }) =>
+		accept(scriptStore),
+	);
+	pi.on("session_start", async () => {
+		await temporaryOutput.shutdown();
+		await temporaryOutput.start();
+	});
 
 	function resolveCommand(language: Language): string {
 		const cmd = runtimes[language];
@@ -265,24 +192,41 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 			"script_runner never exposes the script path; you already have the source. Never try to read it back.",
 		],
 		parameters: paramsSchema,
-		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
 			const language = params.language;
 			if (signal?.aborted) {
 				return { content: [{ type: "text", text: "Cancelled." }], details: undefined };
 			}
+			scriptStore.verifyAndConsume(toolCallId, params);
 			const command = resolveCommand(language);
-			const { scriptId, source } = resolveScriptSource(scripts, language, params);
-			remember(scriptId, { language, source });
+			const resolved = scriptStore.resolve(params);
+			const scriptId = resolved.scriptId ?? newScriptId();
+			const source = resolved.source;
+			scriptStore.remember(scriptId, language, source);
 			await onUpdate?.({
 				content: [{ type: "text", text: `Running ${languageLabel(language)}...` }],
 				details: undefined,
 			});
 			const result = await runScript(language, command, source, ctx.cwd, signal);
-			if (result.code === 0 && !result.killed) {
-				scripts.delete(scriptId);
-				return successScriptResult(result.stdout);
+			const succeeded = result.code === 0 && !result.killed;
+			const output = new BoundedTextResultBuilder(temporaryOutput, "tail");
+			let content: string;
+			try {
+				await output.append(succeeded ? result.stdout.trim() : result.stderr.trim() || result.stdout.trim());
+				if (signal?.aborted) {
+					await output.abort();
+					return { content: [{ type: "text", text: "Cancelled." }], details: undefined };
+				}
+				content = (await output.finish()).content;
+			} catch (error) {
+				await output.abort();
+				throw error;
+			}
+			if (succeeded) {
+				scriptStore.forget(scriptId);
+				return { content: [{ type: "text", text: content.trim() || "(no output)" }], details: undefined };
 			}
-			throwScriptFailure(scriptId, result);
+			throw new Error(`${content ? `${content}\n\n` : ""}scriptId: ${scriptId}`);
 		},
 		renderCall(args, theme, context) {
 			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
@@ -312,7 +256,8 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 
 	pi.registerTool(tool);
 
-	pi.on("session_shutdown", () => {
-		scripts.clear();
+	pi.on("session_shutdown", async () => {
+		scriptStore.clear();
+		await temporaryOutput.shutdown();
 	});
 }

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.