@shanepadgett/tau-agent 0.42.3 → 0.44.0

package/extensions/tool-approval/index.ts

@@ -12,10 +12,12 @@ import { generateToolValidated, resolveCandidates } from "../../shared/model-fal
 import { errorText, truncAt } from "../../shared/text.ts";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { isAllowlistedBash } from "./allowlist.ts";
+import { ToolApprovalPanel, type ApprovalAnswer } from "./panel.ts";
 import toolApprovalSettings from "./settings.ts";
 
 const STATUS_KEY = "tool-approval";
 const AUTO_APPROVED_TYPE = "tau.tool-approval.auto-approved";
+const MAX_CONCURRENT_REVIEWS = 3;
 
 const REVIEW_SCHEMA = Type.Object(
 	{
@@ -56,12 +58,12 @@ const REVIEW_TOOL = {
 } satisfies Tool;
 
 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: "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: "low" },
-	{ provider: "opencode-go", model: "deepseek-v4.1-flash", reasoning: "low" },
+	{ provider: "openrouter", model: "deepseek/deepseek-v4.1-flash", reasoning: "high" },
+	{ provider: "opencode-go", model: "deepseek-v4.1-flash", reasoning: "high" },
 ];
 
 type ToolReview =
@@ -74,6 +76,13 @@ interface ToolApprovalRequest {
 	input: Record<string, unknown>;
 }
 
+type ToolReviewResult = { review: ToolReview; provider: string; model: string };
+
+interface CachedReview {
+	requestJson: string;
+	outcome: PromiseSettledResult<ToolReviewResult>;
+}
+
 interface AutoApprovedMarker {
 	toolName: ApprovalToolName;
 	provider: string;
@@ -82,6 +91,8 @@ interface AutoApprovedMarker {
 
 export default function toolApprovalExtension(pi: ExtensionAPI): void {
 	let settings = toolApprovalSettings.defaults;
+	let batchReviews: Map<string, CachedReview> | undefined;
+	const pendingNotes = new Map<string, string>();
 
 	pi.registerEntryRenderer<AutoApprovedMarker>(AUTO_APPROVED_TYPE, (entry, _options, theme) => {
 		const marker = autoApprovedMarker(entry.data);
@@ -98,22 +109,45 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 		settings = await loadTauExtensionSettings(ctx, toolApprovalSettings);
 	}
 
-	pi.on("session_start", async (_event, ctx) => {
-		await refreshSettings(ctx);
-	});
+	async function requestToolApproval(
+		ctx: ExtensionContext,
+		toolCallId: string,
+		toolName: ApprovalToolName,
+		title: string,
+		body: string,
+	): Promise<{ block: true; reason: string } | undefined> {
+		if (!ctx.hasUI) return block(`${toolLabel(toolName)} needs confirmation, but interactive UI is unavailable`);
+		try {
+			emitAgentBlocked(pi, {
+				title: "Tool request review",
+				body: `Waiting for ${toolLabel(toolName)} approval`,
+				source: "tool-approval.review",
+			});
+			if (ctx.mode !== "tui") {
+				const confirmed = await ctx.ui.confirm(title, body);
+				return confirmed ? undefined : block(`${toolLabel(toolName)} rejected by user`);
+			}
+			const answer = await ctx.ui.custom<ApprovalAnswer | undefined>(
+				(tui, theme, keys, done) => new ToolApprovalPanel(tui, theme, keys, title, body, done),
+			);
+			if (!answer) return block(`${toolLabel(toolName)} approval cancelled by user`);
+			const note = truncAt(answer.note, 800);
+			if (answer.choice === "reject") {
+				return block(`${toolLabel(toolName)} rejected by user${note ? `. User note: ${note}` : ""}`);
+			}
+			if (note) pendingNotes.set(toolCallId, note);
+			return undefined;
+		} catch (error) {
+			const message = singleLine(errorText(error));
+			ctx.ui.notify(`Tool approval failed; request blocked: ${truncAt(message, 600)}`, "error");
+			return block(`tool approval failed: ${truncAt(message, 600)}`);
+		}
+	}
 
-	pi.on("before_agent_start", async (event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
+		batchReviews = undefined;
+		pendingNotes.clear();
 		await refreshSettings(ctx);
-		if (!settings.enabled) return undefined;
-		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 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.",
-			].join("\n")}`,
-		};
 	});
 
 	pi.on("tool_call", async (event, ctx) => {
@@ -128,25 +162,36 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 		}
 		if (!settings.enabled) return undefined;
 
-		let command: string | undefined;
 		if (request.toolName === "bash") {
-			const value = request.input.command;
-			if (typeof value !== "string") return block("bash command was malformed");
-			if (!value.trim()) {
+			const command = request.input.command;
+			if (typeof command !== "string") return block("bash command was malformed");
+			if (!command.trim()) {
 				ctx.ui.notify("Bash command blocked: command is empty", "warning");
 				return block("bash command is empty");
 			}
-			command = value;
 			if (isAllowlistedBash(command)) return undefined;
 		}
 
 		ctx.ui.setStatus(STATUS_KEY, `reviewing ${toolLabel(request.toolName)}`);
 		try {
-			const { review, provider, model } = await reviewToolRequest(ctx, request);
+			batchReviews ??= await reviewAssistantRequests(ctx, event, request);
+			if (ctx.signal?.aborted) return block("Tool review cancelled");
+			const cached = batchReviews.get(event.toolCallId);
+			batchReviews.delete(event.toolCallId);
+			let result: ToolReviewResult;
+			if (cached && cached.requestJson === JSON.stringify(request)) {
+				if (cached.outcome.status === "rejected") throw cached.outcome.reason;
+				result = cached.outcome.value;
+			} else {
+				// A sibling's validated input may differ from its arguments in the assistant message.
+				result = await reviewToolRequest(ctx, request);
+			}
+			if (ctx.signal?.aborted) return block("Tool review cancelled");
+			const { review, provider, model } = result;
 			if (review.decision === "requires_user_approval") {
 				return requestToolApproval(
-					pi,
 					ctx,
+					event.toolCallId,
 					request.toolName,
 					`Approve high-impact ${toolLabel(request.toolName)}?`,
 					formatApproval(review.summary, review.reason),
@@ -161,18 +206,19 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 				return undefined;
 			}
 			return requestToolApproval(
-				pi,
 				ctx,
+				event.toolCallId,
 				request.toolName,
 				`Run reviewed ${toolLabel(request.toolName)}?`,
 				formatApproval(review.summary, "Automatic approval is disabled."),
 			);
 		} catch (error) {
+			if (ctx.signal?.aborted) return block("Tool review cancelled");
 			const message = singleLine(errorText(error));
 			ctx.ui.notify(`Tool review failed; manual approval required: ${truncAt(message, 600)}`, "warning");
 			return requestToolApproval(
-				pi,
 				ctx,
+				event.toolCallId,
 				request.toolName,
 				`Automatic ${toolLabel(request.toolName)} review failed. Continue?`,
 				`The automatic review failed, so Tau could not summarize this ${toolLabel(request.toolName)}. Approve it only if you understand the request shown above.`,
@@ -182,7 +228,33 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 		}
 	});
 
+	pi.on("turn_end", () => {
+		batchReviews = undefined;
+	});
+
+	pi.on("tool_result", (event) => {
+		const note = pendingNotes.get(event.toolCallId);
+		if (!note) return;
+		pendingNotes.delete(event.toolCallId);
+		return {
+			content: [
+				...event.content,
+				{
+					type: "text" as const,
+					text: `User approval note (guidance for subsequent actions; does not change this tool request):\n${note}`,
+				},
+			],
+		};
+	});
+
+	pi.on("agent_end", () => {
+		batchReviews = undefined;
+		pendingNotes.clear();
+	});
+
 	pi.on("session_shutdown", (_event, ctx) => {
+		batchReviews = undefined;
+		pendingNotes.clear();
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 }
@@ -208,10 +280,49 @@ function autoApprovedMarker(value: unknown): AutoApprovedMarker | undefined {
 	return { toolName: record.toolName, provider: record.provider, model: record.model };
 }
 
-async function reviewToolRequest(
+async function reviewAssistantRequests(
 	ctx: ExtensionContext,
-	request: ToolApprovalRequest,
-): Promise<{ review: ToolReview; provider: string; model: string }> {
+	event: ToolCallEvent,
+	currentRequest: ToolApprovalRequest,
+): Promise<Map<string, CachedReview>> {
+	const reviews = new Map<string, CachedReview>();
+	const assistant = ctx.sessionManager
+		.getBranch()
+		.reverse()
+		.find((entry) => entry.type === "message" && entry.message.role === "assistant");
+	if (!assistant || assistant.type !== "message" || assistant.message.role !== "assistant") return reviews;
+	if (
+		!assistant.message.content.some(
+			(part) => part.type === "toolCall" && part.id === event.toolCallId && part.name === currentRequest.toolName,
+		)
+	)
+		return reviews;
+
+	const requests = assistant.message.content.flatMap((part) => {
+		if (part.type !== "toolCall" || (part.name !== "bash" && part.name !== "script_runner")) return [];
+		const request: ToolApprovalRequest = {
+			toolName: part.name,
+			input: part.id === event.toolCallId ? currentRequest.input : part.arguments,
+		};
+		if (request.toolName === "bash") {
+			const command = request.input.command;
+			if (typeof command !== "string" || !command.trim() || isAllowlistedBash(command)) return [];
+		}
+		return [{ toolCallId: part.id, request, requestJson: JSON.stringify(request) }];
+	});
+
+	for (let index = 0; index < requests.length && !ctx.signal?.aborted; index += MAX_CONCURRENT_REVIEWS) {
+		const group = requests.slice(index, index + MAX_CONCURRENT_REVIEWS);
+		const outcomes = await Promise.allSettled(group.map((item) => reviewToolRequest(ctx, item.request)));
+		for (const [offset, item] of group.entries()) {
+			const outcome = outcomes[offset];
+			if (outcome) reviews.set(item.toolCallId, { requestJson: item.requestJson, outcome });
+		}
+	}
+	return reviews;
+}
+
+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] : [];
@@ -269,29 +380,6 @@ function formatApproval(summary: string, reason: string): string {
 	return singleLine(`${summary} ${reason}`);
 }
 
-async function requestToolApproval(
-	pi: Pick<ExtensionAPI, "events">,
-	ctx: ExtensionContext,
-	toolName: ApprovalToolName,
-	title: string,
-	body: string,
-): Promise<{ block: true; reason: string } | undefined> {
-	if (!ctx.hasUI) return block(`${toolLabel(toolName)} needs confirmation, but interactive UI is unavailable`);
-	try {
-		emitAgentBlocked(pi, {
-			title: "Tool request review",
-			body: `Waiting for ${toolLabel(toolName)} approval`,
-			source: "tool-approval.review",
-		});
-		const confirmed = await ctx.ui.confirm(title, body);
-		return confirmed ? undefined : block(`${toolLabel(toolName)} rejected by user`);
-	} catch (error) {
-		const message = singleLine(errorText(error));
-		ctx.ui.notify(`Tool approval failed; request blocked: ${truncAt(message, 600)}`, "error");
-		return block(`tool approval failed: ${truncAt(message, 600)}`);
-	}
-}
-
 function singleLine(text: string): string {
 	return text.replaceAll(/\s+/g, " ").trim();
 }

package/extensions/tool-approval/panel.ts

@@ -0,0 +1,153 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	Editor,
+	type Focusable,
+	Key,
+	type KeybindingsManager,
+	matchesKey,
+	type TUI,
+} from "@earendil-works/pi-tui";
+import {
+	bindingHint,
+	bindingsHint,
+	editorTheme,
+	pushSavedNote,
+	rawHint,
+	renderNoteEditor,
+	ToolPanel,
+	type ToolPanelConfig,
+	wrapWithPrefix,
+} from "@shanepadgett/tau-tui";
+
+export type ApprovalChoice = "approve" | "reject";
+export interface ApprovalAnswer {
+	choice: ApprovalChoice;
+	note: string;
+}
+
+export class ToolApprovalPanel implements Component, Focusable {
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly keys: KeybindingsManager;
+	private readonly done: (answer: ApprovalAnswer | undefined) => void;
+	private readonly noteEditor: Editor;
+	private readonly panelConfig: ToolPanelConfig;
+	private readonly panel: ToolPanel;
+	private readonly notes: Record<ApprovalChoice, string> = { approve: "", reject: "" };
+	private choice: ApprovalChoice = "approve";
+	private editing = false;
+	private _focused = false;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		keys: KeybindingsManager,
+		title: string,
+		body: string,
+		done: (answer: ApprovalAnswer | undefined) => void,
+	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.keys = keys;
+		this.done = done;
+		this.noteEditor = new Editor(tui, editorTheme(theme));
+		this.noteEditor.onSubmit = (value) => {
+			this.notes[this.choice] = value.trim();
+			this.closeNote();
+		};
+		this.panelConfig = {
+			title,
+			secondary: "Approve runs this request as shown. To change it, reject with a note.",
+			header: [body],
+			body: { render: (width) => this.renderChoices(width), invalidate: () => {} },
+			footer: { kind: "hints", hints: this.hints() },
+		};
+		this.panel = new ToolPanel(theme, this.panelConfig);
+	}
+
+	get focused(): boolean {
+		return this._focused;
+	}
+
+	set focused(value: boolean) {
+		this._focused = value;
+		this.noteEditor.focused = value && this.editing;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.done(undefined);
+			return;
+		}
+		if (this.editing) {
+			if (this.keys.matches(data, "tui.select.cancel")) this.closeNote();
+			else this.noteEditor.handleInput(data);
+			this.refresh();
+			return;
+		}
+		if (this.keys.matches(data, "tui.select.cancel")) {
+			this.done(undefined);
+			return;
+		}
+		if (this.keys.matches(data, "tui.select.up") || this.keys.matches(data, "tui.select.down")) {
+			this.choice = this.choice === "approve" ? "reject" : "approve";
+		} else if (data === "n") {
+			this.editing = true;
+			this.noteEditor.setText(this.notes[this.choice]);
+			this.focused = this._focused;
+		} else if (this.keys.matches(data, "tui.select.confirm")) {
+			this.done({ choice: this.choice, note: this.notes[this.choice] });
+			return;
+		}
+		this.refresh();
+	}
+
+	render(width: number): string[] {
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+
+	private renderChoices(width: number): string[] {
+		const lines: string[] = [];
+		for (const choice of ["approve", "reject"] as const) {
+			const selected = choice === this.choice;
+			const prefix = selected ? this.theme.fg("accent", "→ ") : "  ";
+			lines.push(
+				...wrapWithPrefix(
+					prefix,
+					this.theme.fg(selected ? "accent" : "text", choice === "approve" ? "Approve" : "Reject"),
+					width,
+				),
+			);
+			if (this.editing && selected) renderNoteEditor(lines, this.noteEditor, width, this.theme, "  ");
+			else if (this.notes[choice]) pushSavedNote(lines, this.notes[choice], width, this.theme, "  ");
+		}
+		return lines;
+	}
+
+	private closeNote(): void {
+		this.editing = false;
+		this.noteEditor.setText("");
+		this.focused = this._focused;
+	}
+
+	private hints() {
+		return this.editing
+			? [bindingHint("tui.input.submit", "save"), bindingHint("tui.select.cancel", "cancel note")]
+			: [
+					bindingsHint(["tui.select.up", "tui.select.down"], "move"),
+					bindingHint("tui.select.confirm", "choose"),
+					rawHint("n", "note"),
+					bindingHint("tui.select.cancel", "block"),
+				];
+	}
+
+	private refresh(): void {
+		this.panelConfig.footer = { kind: "hints", hints: this.hints() };
+		this.tui.requestRender();
+	}
+}

package/extensions/tool-loader/README.md

@@ -10,6 +10,6 @@ The agent normally calls `load_tools` itself. Tau's built-in groups are:
 
 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.
 
-Supported models optimize prompt caching when a group loads. Other models keep the same functional behavior.
+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.
 
 After changing this extension during development, run `/reload` before testing.

package/extensions/tool-loader/index.ts

@@ -1,6 +1,9 @@
-import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { defineTool, type ExtensionAPI, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { registeredDeferredToolGroups, type DeferredToolGroupInfo } from "../../src/tool-loading/index.ts";
+import { emitTauEvent } from "../../shared/events.ts";
+import { BoundedTextResultBuilder } from "../../shared/bounded-text-result.ts";
+import { createTemporaryOutputStore } from "../../shared/temporary-output-store.ts";
 
 const loadToolsSchema = Type.Object(
 	{
@@ -21,14 +24,25 @@ interface LoadToolsDetails {
 	addedToolNames: string[];
 }
 
+const PENDING_TYPE = "tau.tool-loader.pending";
+const APPLIED_TYPE = "tau.tool-loader.applied";
+
+interface AppliedLoad {
+	pendingId: string;
+	names: string[];
+}
+
 export default function toolLoaderExtension(pi: ExtensionAPI): void {
+	let temporaryOutput = createTemporaryOutputStore();
 	let managed = false;
 	let allowedToolNames = new Map<string, ReadonlySet<string>>();
 	let managedToolNames = new Set<string>();
 
 	pi.registerTool(createLoadToolsTool(pi, []));
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
+		temporaryOutput = createTemporaryOutputStore();
+		await temporaryOutput.start();
 		const groups = registeredDeferredToolGroups(pi);
 		pi.registerTool(createLoadToolsTool(pi, groups));
 
@@ -39,20 +53,43 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 		);
 		managedToolNames = new Set(groups.flatMap((group) => group.toolNames));
 		managed = initialSet.has("load_tools") && groups.length > 0;
-		if (managed) restoreActiveTools(pi, initial, loadedCapabilities(ctx.sessionManager.getBranch()), groups);
+		if (managed) restoreActiveTools(pi, initial, loadedCapabilities(ctx.sessionManager.getBranch(), groups), groups);
 	});
+	pi.on("session_shutdown", () => temporaryOutput.shutdown());
 
 	pi.on("session_tree", (_event, ctx) => {
 		if (managed) {
 			restoreActiveTools(
 				pi,
 				pi.getActiveTools(),
-				loadedCapabilities(ctx.sessionManager.getBranch()),
+				loadedCapabilities(ctx.sessionManager.getBranch(), registeredDeferredToolGroups(pi)),
 				registeredDeferredToolGroups(pi),
 			);
 		}
 	});
 
+	pi.on("session_compact", (_event, ctx) => {
+		const branch = ctx.sessionManager.getBranch();
+		const applied = new Set(
+			branch.flatMap((entry) =>
+				entry.type === "custom" && entry.customType === APPLIED_TYPE ? [(entry.data as AppliedLoad).pendingId] : [],
+			),
+		);
+		for (const entry of branch) {
+			if (
+				entry.type !== "custom" ||
+				entry.customType !== PENDING_TYPE ||
+				applied.has(entry.id) ||
+				!Array.isArray(entry.data)
+			)
+				continue;
+			const names = entry.data.filter((name): name is string => typeof name === "string");
+			const allowed = new Set([...allowedToolNames.values()].flatMap((group) => [...group]));
+			pi.setActiveTools([...new Set([...pi.getActiveTools(), ...names.filter((name) => allowed.has(name))])]);
+			pi.appendEntry(APPLIED_TYPE, { pendingId: entry.id, names });
+		}
+	});
+
 	function createLoadToolsTool(pi: ExtensionAPI, groups: readonly DeferredToolGroupInfo[]) {
 		return defineTool<typeof loadToolsSchema, LoadToolsDetails>({
 			name: "load_tools",
@@ -63,7 +100,7 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 				"Use load_tools before attempting a registered specialist capability whose tools are not currently available.",
 			],
 			parameters: loadToolsSchema,
-			async execute(_toolCallId, params: LoadToolsParams) {
+			async execute(_toolCallId, params: LoadToolsParams, signal, _onUpdate, ctx) {
 				const group = registeredDeferredToolGroups(pi).find((candidate) => candidate.id === params.capability);
 				if (group === undefined) {
 					throw new Error(
@@ -81,7 +118,25 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 				}
 
 				const beforeSet = new Set(before);
-				pi.setActiveTools([...before, ...loadable.filter((name) => !beforeSet.has(name))]);
+				const next = [...before, ...loadable.filter((name) => !beforeSet.has(name))];
+				const nextSet = new Set(next);
+				let blocked: string | null = null;
+				emitTauEvent(pi, "tau:prompt.tools.check", {
+					ctx,
+					tools: pi.getAllTools().filter((tool) => nextSet.has(tool.name)),
+					reject(reason) {
+						blocked = reason;
+					},
+				});
+				if (blocked) {
+					pi.appendEntry(PENDING_TYPE, loadable);
+					return boundedResult(
+						`${blocked} ${params.capability} is queued for activation after successful compaction.`,
+						{ version: 1, capability: params.capability, requestedToolNames: requested, addedToolNames: [] },
+						signal,
+					);
+				}
+				pi.setActiveTools(next);
 				const after = pi.getActiveTools();
 				const addedToolNames = requested.filter((name) => !beforeSet.has(name) && after.includes(name));
 				const available = requested.filter((name) => after.includes(name));
@@ -91,24 +146,36 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 						? `Loaded ${params.capability} tools: ${addedToolNames.join(", ")}.`
 						: `${params.capability} tools are already loaded: ${available.join(", ")}.`;
 
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text: unavailable.length ? `${text} Unavailable: ${unavailable.join(", ")}.` : text,
-						},
-					],
-					details: {
+				return boundedResult(
+					unavailable.length ? `${text} Unavailable: ${unavailable.join(", ")}.` : text,
+					{
 						version: 1,
 						capability: params.capability,
 						requestedToolNames: requested,
 						addedToolNames,
 					},
-				};
+					signal,
+				);
 			},
 		});
 	}
 
+	async function boundedResult(text: string, details: LoadToolsDetails, signal: AbortSignal | undefined) {
+		const builder = new BoundedTextResultBuilder(temporaryOutput, "head");
+		try {
+			await builder.append(text);
+			signal?.throwIfAborted();
+			const result = await builder.finish();
+			return {
+				content: [{ type: "text" as const, text: result.content }],
+				details: { ...details, overflow: result.overflow },
+			};
+		} catch (error) {
+			await builder.abort();
+			throw error;
+		}
+	}
+
 	function restoreActiveTools(
 		pi: ExtensionAPI,
 		current: readonly string[],
@@ -131,16 +198,18 @@ function formatGroupCatalog(groups: readonly DeferredToolGroupInfo[]): string {
 	return ` Registered groups: ${catalog}.`;
 }
 
-function loadedCapabilities(entries: readonly unknown[]): Set<string> {
+function loadedCapabilities(entries: readonly SessionEntry[], groups: readonly DeferredToolGroupInfo[]): Set<string> {
 	const loaded = new Set<string>();
-	for (const value of entries) {
-		if (!value || typeof value !== "object") continue;
-		const entry = value as Record<string, unknown>;
-		if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") continue;
-		const message = entry.message as Record<string, unknown>;
+	for (const entry of entries) {
+		if (entry.type === "custom" && entry.customType === APPLIED_TYPE) {
+			const { names } = entry.data as AppliedLoad;
+			for (const group of groups) if (group.toolNames.some((name) => names.includes(name))) loaded.add(group.id);
+		}
+		if (entry.type !== "message") continue;
+		const message = entry.message;
 		if (message.role !== "toolResult" || message.toolName !== "load_tools" || message.isError === true) continue;
 		if (!isLoadToolsDetails(message.details)) continue;
-		loaded.add(message.details.capability);
+		if (message.details.addedToolNames.length > 0) loaded.add(message.details.capability);
 	}
 	return loaded;
 }

package/package.json

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