@shanepadgett/tau-agent 0.44.1 → 0.45.1

package/docs/extending-tau-agent.md

@@ -67,7 +67,7 @@ Behavior:
 
 ## Deferred tool groups
 
-Extensions can register tools with Tau's `load_tools` registry while keeping their schemas out of the active tool set until the agent needs them. The extension and Tau must run in the same Pi runtime.
+Extensions can register tools as deferred tools, keeping their schemas out of the active tool set until the agent loads them with Pi's built-in `tool_search`. Tau keeps `tool_search` active whenever deferred tools exist.
 
 ```ts
 import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -96,9 +96,9 @@ export default function confluenceExtension(pi: ExtensionAPI): void {
 }
 ```
 
-`registerDeferredToolGroup()` registers tool definitions with Pi and exposes the group through `load_tools`. Call it during extension initialization. Project-local and global package extensions use the same API. `id` must be unique in the runtime, and tool names must be unique within the group.
+`registerDeferredToolGroup()` registers each tool with `exposure: "deferred"` and a namespace made from `id` and `description`. Call it during extension initialization. Project-local and global package extensions use the same API. Tool names must be unique within the group.
 
-Deferred loading affects model-visible tool schemas, not JavaScript package loading. Initialize expensive clients, authentication, and network connections inside tool execution when possible. Pi handles provider-specific deferred-tool behavior after Tau additively activates the group.
+Deferred loading affects model-visible tool schemas, not JavaScript package loading. Initialize expensive clients, authentication, and network connections inside tool execution when possible. Pi handles provider-specific deferred-tool behavior when `tool_search` loads a tool. On models that cannot take tool changes without replacing the cached prefix, Tau blocks `tool_search`.
 
 ## Events
 

package/extensions/appshot/index.ts

@@ -109,6 +109,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 	const listWindowsTool = defineTool<typeof listWindowsSchema, undefined>({
 		name: "list_windows",
 		label: "List Windows",
+		annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
 		description:
 			"List visible normal macOS windows as compact JSON with window IDs, titles, application identity, process IDs, and bounds. Use list_windows to discover exact window IDs and application PIDs before screenshot_window or activate_app. Requires macOS 14 or newer and Screen & System Audio Recording permission.",
 		parameters: listWindowsSchema,
@@ -145,6 +146,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 	const screenshotWindowTool = defineTool<typeof screenshotWindowSchema, ScreenshotDetails | undefined>({
 		name: "screenshot_window",
 		label: "Screenshot Window",
+		annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
 		description:
 			"Capture one visible macOS window by an exact ID returned by list_windows, resize it to fit within 1568×1568 pixels, save it to the required PNG path, and inspect the image. Call list_windows first.",
 		parameters: screenshotWindowSchema,
@@ -202,6 +204,7 @@ function registerAppshotTools(pi: ExtensionAPI, runHelper: RunHelper): void {
 	const activateAppTool = defineTool<typeof activateAppSchema, ActivationDetails>({
 		name: "activate_app",
 		label: "Activate App",
+		annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
 		description:
 			"Bring a running macOS application and its windows to the foreground by a process ID returned by list_windows. Use only when foregrounding is required for visual validation because activate_app changes user focus.",
 		parameters: activateAppSchema,

package/extensions/aside/index.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { normalizeContext, type Context, type Message, type Model } from "@earendil-works/pi-ai";
+import type { Context, Message, Model } from "@earendil-works/pi-ai";
 import {
 	buildSessionContext,
 	convertToLlm,
@@ -128,11 +128,6 @@ async function runAside(
 	withConversation: boolean,
 	signal: AbortSignal,
 ): Promise<AsideResult> {
-	const provider = ctx.modelRegistry.getProvider(model.provider);
-	if (!provider) throw new Error(`Provider ${model.provider} is unavailable`);
-	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth.ok) throw new Error(auth.error);
-
 	const request = withConversation
 		? buildAsideRequest(
 				convertToLlm(buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId()).messages),
@@ -140,11 +135,8 @@ async function runAside(
 				ctx.getSystemPrompt(),
 			)
 		: buildAsideRequest([], question, undefined);
-	const response = await provider
-		.streamSimple(model, normalizeContext(request), {
-			apiKey: auth.apiKey,
-			headers: auth.headers,
-			env: auth.env,
+	const response = await ctx.modelRegistry
+		.streamSimple(model, request, {
 			signal,
 			reasoning: ctx.thinkingLevel === "off" ? undefined : ctx.thinkingLevel,
 			sessionId: withConversation ? ctx.sessionManager.getSessionId() : randomUUID(),

package/extensions/attention/README.md

@@ -4,10 +4,8 @@ Sends a terminal-driven attention notification when Tau is ready for input, fini
 
 ## Behavior
 
-- Emits an attention notification after the agent settles with no automatic continuation pending.
-- Waits for automatic post-turn checks before deciding whether the agent is ready for input.
-- Emits an attention notification on `session_compact` unless another extension has an active attention hold.
-- Defers settlement and compaction notifications while an attention hold is active.
+- Emits an attention notification after the agent settles with no automatic continuation pending. Automatic post-turn checks run before the run settles, so this notification already waits for them.
+- Emits an attention notification on `session_compact` when the agent is idle. A compaction in the middle of a run is followed by the settle notification instead.
 - Emits an attention notification on `session_tree` when it includes a branch summary.
 - Listens for shared event `tau:agent.blocked` when Tau is waiting on user input.
 - Uses the terminal or host OS notification path that best fits the current environment.

package/extensions/attention/index.ts

@@ -25,10 +25,6 @@ function playMacOSSound(pi: ExtensionAPI): void {
 }
 
 export default function attentionExtension(pi: ExtensionAPI): void {
-	const holds = new Set<string>();
-	let pendingAttention: (() => void) | undefined;
-	let discardNextSettlement = false;
-
 	function notify(data: { title?: string; body?: string }): void {
 		const raw: unknown = data;
 		const record = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};
@@ -69,42 +65,14 @@ export default function attentionExtension(pi: ExtensionAPI): void {
 	}
 
 	onTauEvent(pi, "attention.agent-blocked", "tau:agent.blocked", notify);
-	onTauEvent(pi, "attention.hold-acquire", "tau:attention.hold.acquire", ({ id }) => {
-		holds.add(id);
-	});
-	onTauEvent(pi, "attention.hold-release", "tau:attention.hold.release", ({ id, disposition }) => {
-		if (!holds.delete(id)) return;
-		if (disposition === "discard") {
-			if (pendingAttention) pendingAttention = undefined;
-			else discardNextSettlement = true;
-		}
-		if (holds.size > 0 || !pendingAttention) return;
-		const notifyPending = pendingAttention;
-		pendingAttention = undefined;
-		notifyPending();
-	});
-
-	pi.on("session_start", () => {
-		holds.clear();
-		pendingAttention = undefined;
-		discardNextSettlement = false;
-	});
-
 	pi.on("agent_settled", (_event, ctx) => {
 		if (ctx.mode === "print") return;
-		if (discardNextSettlement) {
-			discardNextSettlement = false;
-			return;
-		}
-		if (holds.size > 0) {
-			pendingAttention = () => notify({ title: DEFAULT_TITLE, body: DEFAULT_BODY });
-			return;
-		}
 		notify({ title: DEFAULT_TITLE, body: DEFAULT_BODY });
 	});
 
 	pi.on("session_compact", (_event, ctx) => {
-		if (ctx.mode === "print" || holds.size > 0) return;
+		// A compaction in the middle of a run is followed by the settle notification.
+		if (ctx.mode === "print" || !ctx.isIdle()) return;
 		notify({ title: DEFAULT_TITLE, body: COMPACTION_BODY });
 	});
 
@@ -112,10 +80,4 @@ export default function attentionExtension(pi: ExtensionAPI): void {
 		if (ctx.mode === "print" || !event.summaryEntry) return;
 		notify({ title: DEFAULT_TITLE, body: BRANCH_SUMMARY_BODY });
 	});
-
-	pi.on("session_shutdown", () => {
-		holds.clear();
-		pendingAttention = undefined;
-		discardNextSettlement = false;
-	});
 }

package/extensions/auto-name/index.ts

@@ -1,21 +1,18 @@
-import { type ThinkingLevel, type Tool, Type } from "@earendil-works/pi-ai";
+import { type Tool, Type } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	getBranchInjectedContexts,
 	getPendingInjectedContexts,
 	type InjectedContext,
 } from "../../shared/injected-context.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 { errorText, truncAt } from "../../shared/text.ts";
 
 const STATUS_KEY = "auto-name";
 const SENTINEL = "NONE";
 const MAX_NAME_LENGTH = 80;
 const MAX_NAMING_INPUT_CHARS = 120_000;
-const AUTO_NAME_MODELS: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = [
-	{ provider: "openai-codex", model: "gpt-5.4-mini", reasoning: "medium" },
-	{ provider: "openrouter", model: "cohere/north-mini-code:free", reasoning: "high" },
-];
 
 const NAMING_PROMPT = [
 	"You are naming a chat session based on the user's first message and any injected hidden context.",
@@ -87,9 +84,9 @@ async function runAutoName(
 ): Promise<void> {
 	const ui = ctx.ui;
 	try {
-		const candidates = await resolveCandidates(ctx, AUTO_NAME_MODELS, true);
+		const candidates = await resolveEffortCandidates(ctx, "quick", { includeParentModel: true });
 		const { value: result } = await generateToolValidated(
-			{ ui, signal: controller.signal },
+			{ ui, modelRegistry: ctx.modelRegistry, signal: controller.signal },
 			candidates,
 			`${NAMING_PROMPT}\n\n${prompt}`,
 			NAME_SESSION_TOOL,

package/extensions/cache-diagnostics/index.ts

@@ -487,7 +487,7 @@ export default function cacheDiagnosticsExtension(pi: ExtensionAPI): void {
 	);
 	pi.on("session_tree", () => addMarker("session-tree"));
 	pi.on("tool_execution_end", (event) => {
-		if (event.toolName !== "load_tools") return;
+		if (event.toolName !== "tool_search") return;
 		return addMarker("cache-affecting-tool", { tool: event.toolName, isError: event.isError });
 	});
 }

package/extensions/codex-priority/README.md

@@ -0,0 +1,7 @@
+# Codex Priority
+
+Requests Codex priority processing (Fast mode) for every `gpt-6-luna` request on the `openai-codex` provider: the agent loop, `/compact` summaries, tool approval, auto-naming, commit, and handoff. Priority gives faster responses at a higher credit rate, so the approval reviewer and compaction block you for less time.
+
+There is no command and no setting. Other models are unchanged. Displayed cost uses OpenAI's documented 2.5x Fast mode rate for GPT-6 models.
+
+Do not run another extension that overlays the `openai-codex` provider or sets `service_tier`; the one that loads last wins.

package/extensions/codex-priority/index.ts

@@ -0,0 +1,95 @@
+import {
+	calculateCost,
+	clampThinkingLevel,
+	createAssistantMessageEventStream,
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	type Model,
+	type ModelThinkingLevel,
+	type SimpleStreamOptions,
+	type Usage,
+} from "@earendil-works/pi-ai";
+import { openAICodexResponsesApi } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const PRIORITY_MODEL_ID = "gpt-6-luna";
+// OpenAI documents Codex Fast mode as 2.5x credits for GPT-6 models. pi-ai applies 2x, so cost is recomputed.
+const PRIORITY_MULTIPLIER = 2.5;
+
+type CodexOptions = SimpleStreamOptions & {
+	serviceTier?: "priority";
+	reasoningEffort?: Exclude<ModelThinkingLevel, "off">;
+};
+
+function reprice(model: Model<Api>, usage: Usage): void {
+	calculateCost(model, usage);
+	usage.cost.input *= PRIORITY_MULTIPLIER;
+	usage.cost.output *= PRIORITY_MULTIPLIER;
+	usage.cost.cacheRead *= PRIORITY_MULTIPLIER;
+	usage.cost.cacheWrite *= PRIORITY_MULTIPLIER;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+
+function errorMessage(model: Model<Api>, error: unknown): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now(),
+	};
+}
+
+function withPriorityPricing(source: AssistantMessageEventStream, model: Model<Api>): AssistantMessageEventStream {
+	const output = createAssistantMessageEventStream();
+	void (async () => {
+		try {
+			for await (const event of source) {
+				if (event.type === "done") reprice(model, event.message.usage);
+				else if (event.type === "error") reprice(model, event.error.usage);
+				output.push(event);
+			}
+			const result = await source.result();
+			reprice(model, result.usage);
+			output.end(result);
+		} catch (error) {
+			const message = errorMessage(model, error);
+			output.push({ type: "error", reason: "error", error: message });
+			output.end(message);
+		}
+	})();
+	return output;
+}
+
+export default function codexPriorityExtension(pi: ExtensionAPI): void {
+	const codex = openAICodexResponsesApi();
+	// Overlay the built-in provider so its models and authentication stay intact. Pi routes both
+	// stream() and streamSimple() for this API here, including the agent loop and registry calls.
+	pi.registerProvider("openai-codex", {
+		api: "openai-codex-responses",
+		streamSimple(model, context, options) {
+			const priority = model.id === PRIORITY_MODEL_ID;
+			const request: CodexOptions = { ...options };
+			// A stream() caller passes reasoningEffort itself; only derive it from the neutral option.
+			if (options?.reasoning !== undefined) {
+				const level = clampThinkingLevel(model, options.reasoning);
+				request.reasoningEffort = level === "off" ? undefined : level;
+			}
+			if (priority) request.serviceTier = "priority";
+			const stream = codex.stream(model, context, request);
+			return priority ? withPriorityPricing(stream, model) : stream;
+		},
+	});
+}

package/extensions/compaction/README.md

@@ -0,0 +1,5 @@
+# Compaction
+
+Writes compaction summaries with a cheaper model from the same provider as the session, so long Opus, GPT-6.1 Sol, and Astra sessions do not pay their own rates to summarize themselves.
+
+Compaction, `/compact`, and overflow recovery use the `quick` effort tier for the session's provider (for example `gpt-6-luna` for OpenAI Codex and `claude-sonnet-5-5` for Anthropic). Summaries never cross providers. A notice names the model that wrote each summary, and the saved compaction entry is marked `fromHook: true`. File lists from earlier compactions are carried forward. When the session model is already the quick model, the provider has no quick model, the quick model's context window is too small for the conversation, or every quick model fails, Pi's default compaction runs with the session model.

package/extensions/compaction/index.ts

@@ -0,0 +1,47 @@
+import { compact, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resolveEffortCandidates } from "../../shared/model-effort.ts";
+import { errorText } from "../../shared/text.ts";
+
+export default function compactionExtension(pi: ExtensionAPI): void {
+	pi.on("session_before_compact", async (event, ctx) => {
+		const session = ctx.model;
+		if (!session) return undefined;
+		const { preparation } = event;
+		// Summaries stay on the session's provider, and the cheaper model needs room for the whole input.
+		const candidates = (await resolveEffortCandidates(ctx, "quick", { includeParentModel: false })).filter(
+			({ model }) =>
+				model.provider === session.provider &&
+				model.id !== session.id &&
+				model.contextWindow >= preparation.tokensBefore + preparation.settings.reserveTokens,
+		);
+		for (const { model, reasoning } of candidates) {
+			try {
+				// Pi only carries file lists forward from its own compactions, not from extension-made ones.
+				const previous = [...event.branchEntries].reverse().find((entry) => entry.type === "compaction");
+				const details = previous?.type === "compaction" && previous.fromHook ? previous.details : undefined;
+				if (details && typeof details === "object") {
+					const { readFiles, modifiedFiles } = details as { readFiles?: unknown; modifiedFiles?: unknown };
+					if (Array.isArray(readFiles)) for (const file of readFiles) preparation.fileOps.read.add(String(file));
+					if (Array.isArray(modifiedFiles))
+						for (const file of modifiedFiles) preparation.fileOps.edited.add(String(file));
+				}
+				const result = await compact(
+					preparation,
+					model,
+					undefined,
+					undefined,
+					event.customInstructions,
+					event.signal,
+					reasoning,
+					(streamModel, context, options) => ctx.modelRegistry.streamSimple(streamModel, context, options),
+				);
+				ctx.ui.notify(`Compaction summarized with ${model.provider}/${model.id}`, "info");
+				return { compaction: result };
+			} catch (error) {
+				if (event.signal.aborted) return undefined;
+				ctx.ui.notify(`Compaction with ${model.provider}/${model.id} failed: ${errorText(error)}`, "warning");
+			}
+		}
+		return undefined;
+	});
+}

package/extensions/cost-report/README.md

@@ -29,4 +29,4 @@ All-sessions reports include a project ranking and a project filter on the sessi
 
 Reports are written under `~/.pi/tau/cost-reports/` and opened automatically. Empty windows get a warning instead of a file.
 
-Costs come from stored session usage estimates, including subagent tool results on parent sessions.
+Costs come from stored session usage estimates, including model calls made by tools.

package/extensions/cost-report/analyze.ts

@@ -11,7 +11,6 @@ import type {
 	ReportScope,
 	SessionCost,
 	SessionModelCost,
-	SubagentCost,
 } from "./types.ts";
 
 export interface BuildCostReportOptions {
@@ -31,12 +30,6 @@ interface ModelBucket {
 	sessions: Set<string>;
 }
 
-interface SubagentBucket {
-	agent: string;
-	cost: number;
-	calls: number;
-}
-
 interface ProjectBucket {
 	key: string;
 	label: string;
@@ -53,11 +46,9 @@ interface SessionModelBucket {
 
 interface AnalyzedSession {
 	session: SessionCost;
-	directCost: number;
-	subagentCost: number;
+	cost: number;
 	dayCosts: Map<string, number>;
 	models: ModelBucket[];
-	subagents: SubagentBucket[];
 }
 
 function numberOrZero(value: unknown): number {
@@ -167,15 +158,12 @@ export async function buildCostReport(options: BuildCostReportOptions): Promise<
 
 	const dayMap = new Map<string, number>();
 	const modelMap = new Map<string, ModelBucket>();
-	const subagentMap = new Map<string, SubagentBucket>();
 	const projectMap = new Map<string, ProjectBucket>();
-	let directCost = 0;
-	let subagentCost = 0;
+	let totalCost = 0;
 	let totalTokens = 0;
 
 	for (const item of analyzed) {
-		directCost += item.directCost;
-		subagentCost += item.subagentCost;
+		totalCost += item.cost;
 		totalTokens += item.session.tokens;
 
 		for (const [key, cost] of item.dayCosts) {
@@ -196,16 +184,6 @@ export async function buildCostReport(options: BuildCostReportOptions): Promise<
 			}
 		}
 
-		for (const agent of item.subagents) {
-			const existing = subagentMap.get(agent.agent);
-			if (existing) {
-				existing.cost += agent.cost;
-				existing.calls += agent.calls;
-			} else {
-				subagentMap.set(agent.agent, { ...agent });
-			}
-		}
-
 		const project = projectMap.get(item.session.projectKey);
 		if (project) {
 			project.cost += item.session.cost;
@@ -234,8 +212,6 @@ export async function buildCostReport(options: BuildCostReportOptions): Promise<
 		}))
 		.sort((a, b) => b.tokens - a.tokens || b.cost - a.cost);
 
-	const subagents: SubagentCost[] = [...subagentMap.values()].sort((a, b) => b.cost - a.cost);
-
 	const projects: ProjectCost[] = [...projectMap.values()]
 		.map((bucket) => ({
 			key: bucket.key,
@@ -253,15 +229,12 @@ export async function buildCostReport(options: BuildCostReportOptions): Promise<
 		cwd,
 		scope,
 		range,
-		directCost,
-		subagentCost,
-		totalCost: directCost + subagentCost,
+		totalCost,
 		totalTokens,
 		sessionCount: sessions.length,
 		projectCount: projects.length,
 		days,
 		models,
-		subagents,
 		projects,
 		sessions,
 	};
@@ -293,9 +266,7 @@ function analyzeSession(info: SessionInfo, range: ReportRange): AnalyzedSession
 
 	const dayCosts = new Map<string, number>();
 	const modelBuckets = new Map<string, SessionModelBucket & { tokens: number; provider: string; model: string }>();
-	const subagentBuckets = new Map<string, SubagentBucket>();
-	let directCost = 0;
-	let subagentCost = 0;
+	let cost = 0;
 	let tokens = 0;
 	let startedAtMs = Number.POSITIVE_INFINITY;
 
@@ -306,7 +277,7 @@ function analyzeSession(info: SessionInfo, range: ReportRange): AnalyzedSession
 				if (ts === undefined || !inRange(ts, range)) continue;
 				const usage = normalizeUsage(entry.usage);
 				if (usage.cost <= 0 && usage.totalTokens <= 0) continue;
-				directCost += usage.cost;
+				cost += usage.cost;
 				tokens += usage.totalTokens;
 				dayCosts.set(localDateKey(ts), (dayCosts.get(localDateKey(ts)) ?? 0) + usage.cost);
 				if (ts < startedAtMs) startedAtMs = ts;
@@ -330,7 +301,7 @@ function analyzeSession(info: SessionInfo, range: ReportRange): AnalyzedSession
 		if (message.role === "assistant" && message.usage) {
 			const usage = normalizeUsage(message.usage);
 			if (usage.cost <= 0 && usage.totalTokens <= 0) continue;
-			directCost += usage.cost;
+			cost += usage.cost;
 			tokens += usage.totalTokens;
 			dayCosts.set(localDateKey(ts), (dayCosts.get(localDateKey(ts)) ?? 0) + usage.cost);
 			if (ts < startedAtMs) startedAtMs = ts;
@@ -361,29 +332,11 @@ function analyzeSession(info: SessionInfo, range: ReportRange): AnalyzedSession
 			dayCosts.set(localDateKey(ts), (dayCosts.get(localDateKey(ts)) ?? 0) + usage.cost);
 			if (ts < startedAtMs) startedAtMs = ts;
 			tokens += usage.totalTokens;
-
-			if (message.toolName === "subagent") {
-				subagentCost += usage.cost;
-				const details = asRecord(message.details);
-				const agent =
-					(typeof details?.agent === "string" && details.agent) ||
-					(typeof details?.displayName === "string" && details.displayName) ||
-					"subagent";
-				const existing = subagentBuckets.get(agent);
-				if (existing) {
-					existing.cost += usage.cost;
-					existing.calls += 1;
-				} else {
-					subagentBuckets.set(agent, { agent, cost: usage.cost, calls: 1 });
-				}
-			} else {
-				directCost += usage.cost;
-			}
+			cost += usage.cost;
 		}
 	}
 
-	const sessionCost = directCost + subagentCost;
-	if (sessionCost <= 0 && tokens <= 0) return undefined;
+	if (cost <= 0 && tokens <= 0) return undefined;
 
 	const models: ModelBucket[] = [...modelBuckets.values()].map((bucket) => ({
 		key: bucket.key,
@@ -410,14 +363,12 @@ function analyzeSession(info: SessionInfo, range: ReportRange): AnalyzedSession
 			projectKey: project.key,
 			projectLabel: project.label,
 			startedAtMs: Number.isFinite(startedAtMs) ? startedAtMs : range.startMs,
-			cost: sessionCost,
+			cost,
 			tokens,
 			models: sessionModels,
 		},
-		directCost,
-		subagentCost,
+		cost,
 		dayCosts,
 		models,
-		subagents: [...subagentBuckets.values()],
 	};
 }

package/extensions/cost-report/html.ts

@@ -126,7 +126,6 @@ export function renderCostReportHtml(report: CostReport): string {
 	const scopeClass = report.scope === "project" ? "scope-project" : "scope-all";
 	const totalShare = report.totalCost;
 	const tokenShareBase = report.totalTokens;
-	const subagentShareBase = report.subagentCost;
 
 	const modelRows = report.models
 		.map((model) => {
@@ -142,22 +141,6 @@ export function renderCostReportHtml(report: CostReport): string {
 		})
 		.join("");
 
-	const subagentRows =
-		report.subagents.length === 0
-			? `<tr><td class="px-3 py-2 text-stone-600 dark:text-stone-400" colspan="5">No subagent spend in this window.</td></tr>`
-			: report.subagents
-					.map((agent) => {
-						const share = subagentShareBase > 0 ? agent.cost / subagentShareBase : 0;
-						return `<tr>
-							<td class="px-3 py-2">${escapeHtml(agent.agent)}</td>
-							<td class="px-3 py-2 text-right">${money(agent.cost)}</td>
-							<td class="px-3 py-2 text-right">${percent(agent.cost, subagentShareBase)}</td>
-							<td class="px-3 py-2">${shareBar(share)}</td>
-							<td class="px-3 py-2 text-right">${agent.calls}</td>
-						</tr>`;
-					})
-					.join("");
-
 	const projectRows = report.projects
 		.map((project) => {
 			const share = totalShare > 0 ? project.cost / totalShare : 0;
@@ -386,24 +369,6 @@ export function renderCostReportHtml(report: CostReport): string {
 					</table>
 				</div>
 			</section>
-
-			<section aria-labelledby="subagents-heading">
-				<h2 id="subagents-heading" class="mb-3 text-sm font-semibold">Subagents</h2>
-				<div class="overflow-x-auto rounded border border-stone-300 bg-white dark:border-stone-700 dark:bg-stone-900">
-					<table class="w-full text-sm tabular">
-						<thead>
-							<tr class="text-left text-xs font-medium text-stone-600 dark:text-stone-400">
-								<th scope="col" class="px-3 py-2 font-medium">Agent</th>
-								<th scope="col" class="px-3 py-2 text-right font-medium">Cost</th>
-								<th scope="col" class="px-3 py-2 text-right font-medium">Share</th>
-								<th scope="col" class="min-w-[7rem] px-3 py-2 font-medium"></th>
-								<th scope="col" class="px-3 py-2 text-right font-medium">Calls</th>
-							</tr>
-						</thead>
-						<tbody class="divide-y divide-stone-200 dark:divide-stone-800">${subagentRows}</tbody>
-					</table>
-				</div>
-			</section>
 		</div>
 
 		<section class="all-only mb-8" aria-labelledby="projects-heading">
@@ -450,8 +415,7 @@ export function renderCostReportHtml(report: CostReport): string {
 
 		<footer class="mt-10 border-t border-stone-300 pt-4 text-xs text-stone-600 dark:border-stone-700 dark:text-stone-400">
 			<p>
-				Costs are estimates from stored session usage, not provider invoices. Branched turns count. Subagent
-				totals come from parent tool results. Direct ${money(report.directCost)} · Subagents ${money(report.subagentCost)}.
+				Costs are estimates from stored session usage, not provider invoices. Branched turns count.
 			</p>
 		</footer>
 	</main>

package/extensions/cost-report/types.ts

@@ -34,12 +34,6 @@ export interface ModelCost {
 	sessions: number;
 }
 
-export interface SubagentCost {
-	agent: string;
-	cost: number;
-	calls: number;
-}
-
 export interface ProjectCost {
 	key: string;
 	label: string;
@@ -79,15 +73,12 @@ export interface CostReport {
 	cwd: string;
 	scope: ReportScope;
 	range: ReportRange;
-	directCost: number;
-	subagentCost: number;
 	totalCost: number;
 	totalTokens: number;
 	sessionCount: number;
 	projectCount: number;
 	days: DayCost[];
 	models: ModelCost[];
-	subagents: SubagentCost[];
 	projects: ProjectCost[];
 	sessions: SessionCost[];
 }

package/extensions/handoff/index.ts

@@ -61,7 +61,7 @@ export default function handoffExtension(pi: ExtensionAPI): void {
 						);
 						const conversation = serializeConversation(convertToLlm(messages));
 						const result = await generateToolValidated(
-							{ ui: ctx.ui, signal: loader.signal },
+							{ ui: ctx.ui, modelRegistry: ctx.modelRegistry, signal: loader.signal },
 							candidates,
 							buildHandoffRequest(conversation, goal, ctx.cwd),
 							HANDOFF_TOOL,

package/extensions/image-gen/index.ts

@@ -40,6 +40,7 @@ export default function imageGenExtension(pi: ExtensionAPI): void {
 			defineTool<typeof imageGenSchema, ImageGenDetails | undefined>({
 				name: "image_gen",
 				label: "Image Generation",
+				annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
 				description:
 					"Generate a requested raster image or AI-edit existing images with OpenAI GPT Image or xAI Grok Imagine. Omit provider to follow the parent model; set it to openai or xai to override. Omit referenced_image_paths to generate; pass one to three local paths to edit or compose. Omit path to use Tau's external image store; pass path only when the user explicitly requests a repository file or other destination. Returns the image for inspection.",
 				parameters: imageGenSchema,