@shanepadgett/tau-agent 0.41.1 → 0.41.3

package/extensions/auto-name/index.ts

@@ -88,7 +88,7 @@ async function runAutoName(
 	const ui = ctx.ui;
 	try {
 		const candidates = await resolveCandidates(ctx, AUTO_NAME_MODELS, true);
-		const result = await generateToolValidated(
+		const { value: result } = await generateToolValidated(
 			{ ui, signal: controller.signal },
 			candidates,
 			`${NAMING_PROMPT}\n\n${prompt}`,

package/extensions/commit/commit-plan.ts

@@ -57,7 +57,7 @@ export async function generatePlan(
 	options?: CommitGenerationOptions,
 ): Promise<CommitGroup[]> {
 	const prompt = buildPlanPrompt(evidence, previousPlan, regenerationNote);
-	return generateToolValidated(
+	const { value } = await generateToolValidated(
 		ctx,
 		await resolveEffortCandidates(ctx, commitEffort(evidence.files), { includeParentModel: true }),
 		prompt,
@@ -79,6 +79,7 @@ export async function generatePlan(
 			notifyOnFallback: true,
 		},
 	);
+	return value;
 }
 
 export async function regenerateMessage(

package/extensions/handoff/index.ts

@@ -75,7 +75,7 @@ export default function handoffExtension(pi: ExtensionAPI): void {
 								].join("\n"),
 							{ maxAttempts: 3 },
 						);
-						done(result);
+						done(result.value);
 					} catch (error) {
 						if (!loader.signal.aborted) generationError = errorText(error);
 						done(null);

package/extensions/soul/overseer.ts

@@ -130,7 +130,7 @@ async function reviewPrimaryDirective(
 	toolCalls: readonly ToolSignature[],
 ): Promise<PrimaryDirectiveReview> {
 	const candidates = await resolveEffortCandidates(ctx, "standard", { includeParentModel: false });
-	return generateToolValidated(
+	const { value } = await generateToolValidated(
 		ctx,
 		candidates,
 		buildReviewPrompt(branch, toolCalls),
@@ -144,6 +144,7 @@ async function reviewPrimaryDirective(
 		undefined,
 		{ maxAttempts: 1 },
 	);
+	return value;
 }
 
 function buildReviewPrompt(branch: readonly SessionEntry[], toolCalls: readonly ToolSignature[]): string {

package/extensions/subagent/index.ts

@@ -18,32 +18,29 @@ interface SubagentSessionState {
 
 const SUBAGENT_SESSION_STATE_TYPE = "tau.subagent.disabled";
 
-const params = Type.Union([
-	Type.Object(
-		{
-			agent: Type.String({ minLength: 1 }),
-			task: Type.String({ minLength: 1 }),
-			files: Type.Optional(
-				Type.Array(Type.String({ minLength: 1 }), {
-					description: "Files to autoread into the child's context before this turn",
-				}),
-			),
-		},
-		{ additionalProperties: false },
-	),
-	Type.Object(
-		{
-			thread: Type.String({ minLength: 1 }),
-			task: Type.String({ minLength: 1 }),
-			files: Type.Optional(
-				Type.Array(Type.String({ minLength: 1 }), {
-					description: "Files to autoread into the child's context before this turn",
-				}),
-			),
-		},
-		{ additionalProperties: false },
-	),
-]);
+const params = Type.Object(
+	{
+		agent: Type.Optional(
+			Type.String({
+				minLength: 1,
+				description: "Fresh agent name. Pass agent or thread, never both.",
+			}),
+		),
+		thread: Type.Optional(
+			Type.String({
+				minLength: 1,
+				description: "Retained thread id. Pass thread or agent, never both.",
+			}),
+		),
+		task: Type.String({ minLength: 1 }),
+		files: Type.Optional(
+			Type.Array(Type.String({ minLength: 1 }), {
+				description: "Files to autoread into the child's context before this turn",
+			}),
+		),
+	},
+	{ additionalProperties: false },
+);
 
 export default function subagentExtension(pi: ExtensionAPI): void {
 	const runtime = new SubagentRuntime(pi);
@@ -215,7 +212,7 @@ Use \`subagent\` only when an available agent's listed purpose matches the deleg
 Available agents for this turn:
 ${lines.join("\n") || "none"}
 
-Start a fresh thread with \`agent\` and \`task\`. Continue an existing thread with \`thread\` and \`task\`. Reuse a thread when feedback or follow-up work depends on its prior reads and reasoning. Start fresh for unrelated work or when its context is stale or oversized.
+Start a fresh thread with \`agent\` and \`task\`. Continue an existing thread with \`thread\` and \`task\`. Pass exactly one of \`agent\` or \`thread\`, never both and never neither. Reuse a thread when feedback or follow-up work depends on its prior reads and reasoning. Start fresh for unrelated work or when its context is stale or oversized.
 
 Pass \`files\` when exact relevant files are already known. Tau autoreads current line-numbered snapshots into that child turn before it starts.
 
@@ -296,25 +293,48 @@ Delegate one focused task per call. Children do not inherit parent messages. Inc
 			async execute(_id, raw, signal, onUpdate, ctx) {
 				const task = raw.task.trim();
 				const files = [...new Set((raw.files ?? []).map((path) => path.trim()))];
-				const continuing = "thread" in raw;
+				const agentName = raw.agent?.trim() || undefined;
+				const threadKey = raw.thread?.trim() || undefined;
 				const parentModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable";
 				const parentThinking = pi.getThinkingLevel();
-				const agent = continuing ? raw.thread.trim() : raw.agent.trim();
-				const threadKey = continuing ? raw.thread.trim() : undefined;
 
 				failureNotify = (message) => {
 					ctx.ui.notify(message, "warning");
 				};
 				dashboard.setInteractive(ctx.mode === "tui" && ctx.hasUI);
 
-				if (!task || !agent || files.some((path) => !path)) {
-					const error = continuing
-						? "Subagent continuation requires non-empty thread, task, and file paths"
-						: "Subagent input requires non-empty agent, task, and file paths";
-					return failedToolResult(agent, task, "queue", parentModel, parentThinking, error, threadKey);
+				const failQueue = (agent: string, error: string, thread?: string) =>
+					failedToolResult(agent, task, "queue", parentModel, parentThinking, error, thread);
+
+				if (!task || files.some((path) => !path)) {
+					return failQueue(
+						agentName ?? threadKey ?? "",
+						threadKey !== undefined
+							? "Subagent continuation requires non-empty thread, task, and file paths"
+							: "Subagent input requires non-empty agent, task, and file paths",
+						threadKey,
+					);
+				}
+				if (agentName !== undefined && threadKey !== undefined) {
+					return failQueue(
+						agentName,
+						"Subagent input requires exactly one of agent or thread, not both",
+						threadKey,
+					);
 				}
 
-				if (continuing) {
+				const onUpdateDetails = (details: SubagentDetails) =>
+					onUpdate?.({
+						content: [
+							{
+								type: "text",
+								text: details.currentActivity ?? details.response ?? `${details.agent}: ${details.status}`,
+							},
+						],
+						details,
+					});
+
+				if (threadKey !== undefined) {
 					const disabledContinuation = await disabledContinuationResult(
 						ctx,
 						threadKey,
@@ -323,29 +343,36 @@ Delegate one focused task per call. Children do not inherit parent messages. Inc
 						parentThinking,
 					);
 					if (disabledContinuation) return disabledContinuation;
+					return runtime.execute({
+						agent: threadKey,
+						task,
+						files,
+						continuing: true,
+						threadKey,
+						ctx,
+						parentModel,
+						parentThinking,
+						signal,
+						onUpdate: onUpdateDetails,
+						resolveFreshDefinition: () => resolveFreshSubagentDefinition(ctx, threadKey),
+					});
+				}
+
+				if (agentName === undefined) {
+					return failQueue("", "Subagent input requires exactly one of agent or thread");
 				}
 
 				return runtime.execute({
-					agent,
+					agent: agentName,
 					task,
 					files,
-					continuing,
-					threadKey,
+					continuing: false,
 					ctx,
 					parentModel,
 					parentThinking,
 					signal,
-					onUpdate: (details) =>
-						onUpdate?.({
-							content: [
-								{
-									type: "text",
-									text: details.currentActivity ?? details.response ?? `${details.agent}: ${details.status}`,
-								},
-							],
-							details,
-						}),
-					resolveFreshDefinition: () => resolveFreshSubagentDefinition(ctx, agent),
+					onUpdate: onUpdateDetails,
+					resolveFreshDefinition: () => resolveFreshSubagentDefinition(ctx, agentName),
 				});
 			},
 			renderCall(args, theme, context) {

package/extensions/tool-approval/README.md

@@ -2,9 +2,9 @@
 
 Reviews agent `bash` and `script_runner` requests before they run.
 
-Common read-only bash commands skip review and run immediately. Other bash and every `script_runner` request go to a quick-effort model. The reviewer returns a validated decision and one concise paragraph that explains the request.
+Common read-only bash commands skip review and run immediately. Other bash and every `script_runner` request go to a separate reviewer. Tau uses the reviewer model for the current provider, then the current chat model if that reviewer is unavailable or fails. If a reviewer model is unavailable or fails, Tau notifies and tries the next one. The reviewer returns a validated decision and one concise paragraph that explains the request.
 
-With `autoApprove` enabled, reviewer-approved requests run without another confirmation. Tau shows a user-only marker after those auto-approvals. Common read-only bash that skips review does not get a marker. Routine local development work should be approved, including requests that modify project files or run scripts. The reviewer asks for human approval only when it finds a concrete destructive, system, production, privileged, or security-sensitive effect.
+With `autoApprove` enabled, reviewer-approved requests run without another confirmation. Tau shows a user-only marker with the reviewer model after those auto-approvals. Common read-only bash that skips review does not get a marker. Routine local development work should be approved, including requests that modify project files or run scripts. The reviewer asks for human approval only when it finds a concrete destructive, system, production, privileged, or security-sensitive effect.
 
 When approval is required, Tau shows one paragraph that explains the effect and risk without repeating the request. If the reviewer fails or returns a malformed decision, Tau asks for direct human approval instead of running it automatically. Tau also sends an attention notification when the approval window opens.
 

package/extensions/tool-approval/index.ts

@@ -1,4 +1,4 @@
-import type { Tool } from "@earendil-works/pi-ai";
+import type { ThinkingLevel, Tool } from "@earendil-works/pi-ai";
 import {
 	isToolCallEventType,
 	type ExtensionAPI,
@@ -6,11 +6,9 @@ import {
 	type ToolCallEvent,
 } from "@earendil-works/pi-coding-agent";
 import { Marker } from "@shanepadgett/tau-tui";
-import { Type, type Static } from "typebox";
-import { Value } from "typebox/value";
+import { Type } from "typebox";
 import { emitAgentBlocked } from "../../shared/agent-blocked.ts";
-import { resolveEffortCandidates } from "../../shared/model-effort.ts";
-import { generateToolValidated } from "../../shared/model-fallback/index.ts";
+import { generateToolValidated, resolveCandidates } from "../../shared/model-fallback/index.ts";
 import { errorText, truncAt } from "../../shared/text.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { isAllowlistedBash } from "./allowlist.ts";
@@ -19,34 +17,22 @@ import toolApprovalSettings from "./settings.ts";
 const STATUS_KEY = "tool-approval";
 const AUTO_APPROVED_TYPE = "tau.tool-approval.auto-approved";
 
-const SUMMARY_SCHEMA = Type.String({
-	minLength: 1,
-	maxLength: 600,
-	pattern: "^[^\\r\\n]+$",
-	description: "One concise paragraph that fully explains what the tool request does.",
-});
-const REVIEW_SCHEMA = Type.Union([
-	Type.Object(
-		{
-			decision: Type.Literal("approved"),
-			summary: SUMMARY_SCHEMA,
-		},
-		{ additionalProperties: false },
-	),
-	Type.Object(
-		{
-			decision: Type.Literal("requires_user_approval"),
-			summary: SUMMARY_SCHEMA,
-			reason: Type.String({
-				minLength: 1,
-				maxLength: 300,
-				pattern: "^[^\\r\\n]+$",
-				description: "One concise paragraph that states the concrete high-impact risk requiring approval.",
-			}),
-		},
-		{ additionalProperties: false },
-	),
-]);
+const REVIEW_SCHEMA = Type.Object(
+	{
+		decision: Type.Union([Type.Literal("approved"), Type.Literal("requires_user_approval")]),
+		summary: Type.String({
+			minLength: 1,
+			maxLength: 600,
+			description: "One concise paragraph that fully explains what the tool request does.",
+		}),
+		reason: Type.String({
+			maxLength: 300,
+			description:
+				"Empty when approved. One concise paragraph naming the concrete risk when user approval is required.",
+		}),
+	},
+	{ additionalProperties: false },
+);
 
 const REVIEW_SYSTEM_PROMPT = [
 	"You are a tool-request safety reviewer.",
@@ -59,8 +45,8 @@ const REVIEW_SYSTEM_PROMPT = [
 	"Do not require approval merely because the request writes files, invokes code, uses shell composition, could fail, or has ordinary local side effects.",
 	"Routine deletion of generated, temporary, or local project files is ordinary local work. Escalate deletion only when it is broad or difficult to recover.",
 	"Default to approved. Uncertainty is not a reason to escalate; require user approval only when the request shows a concrete substantial risk listed above.",
-	"The summary must be one concise paragraph with no line breaks. Explain the complete effect of the request without lists, headings, or repeated details.",
-	"An approved review has no reason field. A review that requires user approval must give one concise reason naming the concrete risk without repeating the summary.",
+	"The summary must be one concise paragraph. Explain the complete effect of the request without lists, headings, or repeated details.",
+	"Always set reason. Use an empty string when approved. When user approval is required, give one concise reason naming the concrete risk without repeating the summary.",
 ].join("\n");
 
 const REVIEW_TOOL = {
@@ -69,7 +55,18 @@ const REVIEW_TOOL = {
 	parameters: REVIEW_SCHEMA,
 } satisfies Tool;
 
-type ToolReview = Static<typeof REVIEW_SCHEMA>;
+const REVIEW_MODELS: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = [
+	{ provider: "openai", model: "gpt-5.6-luna", reasoning: "medium" },
+	{ provider: "openai-codex", model: "gpt-5.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: "low" },
+	{ provider: "opencode-go", model: "deepseek-v4.1-flash", reasoning: "low" },
+];
+
+type ToolReview =
+	| { decision: "approved"; summary: string }
+	| { decision: "requires_user_approval"; summary: string; reason: string };
 type ApprovalToolName = "bash" | "script_runner";
 
 interface ToolApprovalRequest {
@@ -79,6 +76,8 @@ interface ToolApprovalRequest {
 
 interface AutoApprovedMarker {
 	toolName: ApprovalToolName;
+	provider: string;
+	model: string;
 }
 
 export default function toolApprovalExtension(pi: ExtensionAPI): void {
@@ -91,7 +90,7 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 			theme,
 			state: "complete",
 			label: "Auto-approved",
-			parts: [toolLabel(marker.toolName)],
+			parts: [toolLabel(marker.toolName), `${marker.provider}/${marker.model}`],
 		});
 	});
 
@@ -109,7 +108,7 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 		return {
 			systemPrompt: `${event.systemPrompt}\n\n${[
 				"Known-safe read-only bash commands skip review.",
-				"Other bash and every script_runner request are reviewed by a separate quick-effort safety classifier before execution.",
+				"Other bash and every script_runner request are reviewed by a separate safety classifier before execution.",
 				"Treat classifier approval as a gate, not as permission to hide command intent from the user.",
 				"Routine local development requests can be approved automatically.",
 				"Requests with destructive, system, production, privileged, or security-sensitive effects require human confirmation.",
@@ -143,7 +142,7 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 
 		ctx.ui.setStatus(STATUS_KEY, `reviewing ${toolLabel(request.toolName)}`);
 		try {
-			const review = await reviewToolRequest(ctx, request);
+			const { review, provider, model } = await reviewToolRequest(ctx, request);
 			if (review.decision === "requires_user_approval") {
 				return requestToolApproval(
 					pi,
@@ -154,7 +153,11 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 				);
 			}
 			if (settings.autoApprove) {
-				pi.appendEntry<AutoApprovedMarker>(AUTO_APPROVED_TYPE, { toolName: request.toolName });
+				pi.appendEntry<AutoApprovedMarker>(AUTO_APPROVED_TYPE, {
+					toolName: request.toolName,
+					provider,
+					model,
+				});
 				return undefined;
 			}
 			return requestToolApproval(
@@ -198,26 +201,41 @@ function toolLabel(toolName: ApprovalToolName): string {
 
 function autoApprovedMarker(value: unknown): AutoApprovedMarker | undefined {
 	if (!value || typeof value !== "object") return undefined;
-	const toolName = (value as AutoApprovedMarker).toolName;
-	if (toolName !== "bash" && toolName !== "script_runner") return undefined;
-	return { toolName };
+	const record = value as AutoApprovedMarker;
+	if (record.toolName !== "bash" && record.toolName !== "script_runner") return undefined;
+	if (typeof record.provider !== "string" || record.provider.length === 0) return undefined;
+	if (typeof record.model !== "string" || record.model.length === 0) return undefined;
+	return { toolName: record.toolName, provider: record.provider, model: record.model };
 }
 
-async function reviewToolRequest(ctx: ExtensionContext, request: ToolApprovalRequest): Promise<ToolReview> {
+async function reviewToolRequest(
+	ctx: ExtensionContext,
+	request: ToolApprovalRequest,
+): Promise<{ review: ToolReview; provider: string; model: string }> {
 	const requestJson = JSON.stringify(request);
-	const candidates = await resolveEffortCandidates(ctx, "quick", {
-		includeParentModel: false,
-		preferredProvider: "xai",
-	});
-	return generateToolValidated(
+	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");
+	}
+	const { value, candidate } = await generateToolValidated(
 		ctx,
 		candidates,
 		[REVIEW_SYSTEM_PROMPT, "", "Review this tool request JSON:", requestJson].join("\n"),
 		REVIEW_TOOL,
-		(input) => {
-			if (!Value.Check(REVIEW_SCHEMA, input)) throw new Error("quick reviewer returned an invalid review shape");
-			return input;
-		},
+		reviewFromToolInput,
 		(error, output) =>
 			[
 				`The tool review failed validation: ${error.message}`,
@@ -226,8 +244,25 @@ async function reviewToolRequest(ctx: ExtensionContext, request: ToolApprovalReq
 				"Previous response:",
 				output,
 			].join("\n"),
-		{ maxAttempts: 3 },
+		{ maxAttempts: 3, notifyOnFallback: true },
 	);
+	return { review: value, provider: candidate.model.provider, model: candidate.model.id };
+}
+
+function reviewFromToolInput(input: unknown): ToolReview {
+	if (!input || typeof input !== "object") throw new Error("reviewer returned an invalid review shape");
+	const record = input as Record<string, unknown>;
+	const decision = record.decision;
+	if (decision !== "approved" && decision !== "requires_user_approval") {
+		throw new Error("reviewer returned an invalid review shape");
+	}
+	if (typeof record.summary !== "string") throw new Error("reviewer returned an invalid review shape");
+	const summary = truncAt(singleLine(record.summary), 600);
+	if (!summary) throw new Error("reviewer returned an invalid review shape");
+	const reason = typeof record.reason === "string" ? truncAt(singleLine(record.reason), 300) : "";
+	if (decision === "approved") return { decision, summary };
+	if (!reason) throw new Error("reviewer returned an invalid review shape");
+	return { decision, summary, reason };
 }
 
 function formatApproval(summary: string, reason: string): string {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.41.1",
+	"version": "0.41.3",
 	"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.1",
-		"@shanepadgett/tau-tui": "0.41.1",
+		"@shanepadgett/tau-tui": "0.41.3",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.8.0",

package/shared/model-fallback/index.ts

@@ -71,9 +71,10 @@ export async function generateValidated<T>(
 	correctionPrompt?: (error: Error, text: string) => string,
 	options?: ModelFallbackOptions,
 ): Promise<T> {
-	return withModelFallback(ctx, candidates, options, (candidate) =>
+	const { value } = await withModelFallback(ctx, candidates, options, (candidate) =>
 		requestValidated(ctx, candidate, prompt, validate, correctionPrompt),
 	);
+	return value;
 }
 
 export async function generateToolValidated<T>(
@@ -84,7 +85,7 @@ export async function generateToolValidated<T>(
 	validate: (input: unknown) => T,
 	correctionPrompt?: (error: Error, output: string) => string,
 	options?: ModelFallbackOptions,
-): Promise<T> {
+): Promise<{ value: T; candidate: ModelCandidate }> {
 	return withModelFallback(ctx, candidates, options, (candidate) =>
 		requestToolValidated(
 			ctx,
@@ -117,7 +118,7 @@ async function withModelFallback<T>(
 	candidates: readonly ModelCandidate[],
 	options: ModelFallbackOptions | undefined,
 	request: (candidate: ModelCandidate) => Promise<T>,
-): Promise<T> {
+): Promise<{ value: T; candidate: ModelCandidate }> {
 	const failures: string[] = [];
 	const statusKey = options?.statusKey;
 
@@ -126,7 +127,7 @@ async function withModelFallback<T>(
 		if (statusKey) ctx.ui.setStatus(statusKey, `generating (${label})`);
 		await options?.onStatus?.(`Generating with ${label}`);
 		try {
-			return await request(candidate);
+			return { value: await request(candidate), candidate };
 		} catch (error) {
 			if (ctx.signal?.aborted) throw new Error("Cancelled.");
 			if (shouldCooldownProvider(error)) await markProviderUnavailable(candidate.model.provider);