@shanepadgett/tau-agent 0.42.2 → 0.43.0

package/extensions/soul/state.ts

@@ -0,0 +1,114 @@
+import type { Tool } from "@earendil-works/pi-ai";
+import type { ContextWithSystemEvent, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { PromptValue } from "../../shared/prompt-contributions.ts";
+
+export const BASELINE_TYPE = "tau.soul.baseline";
+export const UPDATE_TYPE = "tau.soul.update";
+
+export interface SavedBaseline {
+	version: 1;
+	compactionId: string | null;
+	afterEntryId: string;
+	text: string;
+	values: PromptValue[];
+	initialTools: Tool[];
+}
+
+export interface SavedUpdate {
+	version: 1;
+	baselineEntryId: string;
+	afterEntryId: string;
+	text: string;
+	values: PromptValue[];
+	tools: Tool[];
+}
+
+interface ActivePrompt {
+	entryId: string;
+	baseline: SavedBaseline;
+	updates: Array<{ timestamp: number; data: SavedUpdate }>;
+}
+
+export function restorePrompt(branch: readonly SessionEntry[]): ActivePrompt | null {
+	const newestFirst = [...branch].reverse();
+	const compaction = newestFirst.find((entry) => entry.type === "compaction");
+	const entry = newestFirst.find((item) => item.type === "custom" && item.customType === BASELINE_TYPE);
+	if (entry?.type !== "custom") return null;
+	const baseline = entry.data as SavedBaseline;
+	if (baseline?.version !== 1 || typeof baseline.text !== "string" || !Array.isArray(baseline.values)) {
+		throw new Error("Invalid saved Soul baseline.");
+	}
+	if (baseline.compactionId !== (compaction?.id ?? null)) return null;
+	const updates: ActivePrompt["updates"] = [];
+	for (const item of branch) {
+		if (item.type !== "custom" || item.customType !== UPDATE_TYPE) continue;
+		const data = item.data as SavedUpdate;
+		if (data?.version !== 1 || typeof data.text !== "string" || !Array.isArray(data.values)) {
+			throw new Error("Invalid saved Soul update.");
+		}
+		if (data.baselineEntryId === entry.id) updates.push({ timestamp: Date.parse(item.timestamp), data });
+	}
+	return { entryId: entry.id, baseline, updates };
+}
+
+/** Rebuild only Soul's text; tool declarations retain their original transcript positions. */
+export function projectPrompt(
+	messages: ContextWithSystemEvent["messages"],
+	saved: ActivePrompt,
+	ctx: ExtensionContext,
+): ContextWithSystemEvent["messages"] {
+	const projection = ctx.sessionManager.buildSessionProjection();
+	// Pi clones the hook input. Compare content, never object identity. A rewrite from
+	// another extension must not silently move a saved update or tool declaration.
+	if (JSON.stringify(messages) !== JSON.stringify(projection.messages)) {
+		throw new Error("Soul cannot preserve the prompt prefix: another extension changed request history.");
+	}
+	const output: ContextWithSystemEvent["messages"] = [
+		{
+			role: "system",
+			content: saved.baseline.text,
+			toolsAdded: saved.baseline.initialTools,
+			timestamp: 0,
+		},
+	];
+	let pastBaseline = false;
+	const placed = new Set<SavedUpdate>();
+	const admitted = new Set(saved.baseline.initialTools.map((tool) => tool.name));
+	for (const entry of projection.entries) {
+		for (const message of entry.messages) {
+			if (message.role !== "system") {
+				output.push(message);
+				continue;
+			}
+			if (!pastBaseline) continue;
+			if (typeof message.content === "string" ? message.content.trim() : message.content.length > 0) {
+				throw new Error("A later system instruction bypassed Soul's prompt contributions.");
+			}
+			// Removed tools remain declared for cache stability; Pi still controls execution.
+			const added = (message.toolsAdded ?? []).filter((tool) => !admitted.has(tool.name));
+			for (const tool of added) admitted.add(tool.name);
+			if (added.length > 0)
+				output.push({ role: "system", content: "", toolsAdded: added, timestamp: message.timestamp });
+		}
+		if (entry.sourceEntry.id === saved.baseline.afterEntryId) pastBaseline = true;
+		for (const update of saved.updates) {
+			if (update.data.afterEntryId !== entry.sourceEntry.id) continue;
+			if (update.data.text)
+				output.push({
+					role: "custom",
+					customType: UPDATE_TYPE,
+					content: update.data.text,
+					display: false,
+					timestamp: update.timestamp,
+				});
+			placed.add(update.data);
+		}
+	}
+	if (!pastBaseline || placed.size !== saved.updates.length)
+		throw new Error("Soul prompt history lost a saved anchor.");
+	return output;
+}
+
+export function admittedTools(saved: ActivePrompt): Tool[] {
+	return saved.updates.at(-1)?.data.tools ?? saved.baseline.initialTools;
+}

package/extensions/soul/tools.ts

@@ -0,0 +1,31 @@
+import { declarationsEqual, type Api, type Model, type Tool } from "@earendil-works/pi-ai";
+
+/** Removals only disable execution; changed declarations wait for compaction. */
+export function toolChangeReason(
+	model: Model<Api>,
+	previous: readonly Tool[],
+	requested: readonly Tool[],
+): string | null {
+	const existing = new Map(previous.map((tool) => [tool.name, tool]));
+	for (const tool of requested) {
+		const old = existing.get(tool.name);
+		if (old && !declarationsEqual(old, tool))
+			return `Tool ${tool.name} changed its schema or description. Compact before loading it.`;
+	}
+	if (requested.every((tool) => existing.has(tool.name))) return null;
+	const compat = model.compat;
+	const supported =
+		compat &&
+		"supportsMidConvoSystemMessages" in compat &&
+		compat.supportsMidConvoSystemMessages === true &&
+		((model.api === "anthropic-messages" &&
+			"supportsMidConvoToolChanges" in compat &&
+			compat.supportsMidConvoToolChanges === true &&
+			previous.length > 0) ||
+			((model.api === "openai-responses" || model.api === "openai-codex-responses") &&
+				(("supportsAdditionalTools" in compat && compat.supportsAdditionalTools === true) ||
+					("supportsToolSearch" in compat && compat.supportsToolSearch === true))));
+	return supported
+		? null
+		: "This model cannot add tools without changing the cached prefix. Compact before loading them.";
+}

package/extensions/tau-help/help.md

@@ -12,16 +12,12 @@ Adds `/aside <question>` for a one-off question to the current model without put
 
 ## attention
 
-Shows attention state when Tau needs the user to look at the chat, finishes a manual compaction, or summarizes an abandoned branch. Automatic compaction stays quiet until its resumed work settles.
+Shows attention state when Tau needs the user to look at the chat, finishes a compaction, or summarizes an abandoned branch.
 
 ## auto-name
 
 Names sessions from their first request so saved sessions remain findable.
 
-## auto-compact
-
-Uses Pi's native compaction before a model turn when the current context reaches `extensions.autoCompact.tokenLimit`, which defaults to 175,000 tokens for every model. Set `extensions.autoCompact.enabled` to `false` to disable it. Interrupted work resumes through a hidden continuation message without an attention alert until the resumed work settles. Pi's native collapsed compaction entry remains visible in chat.
-
 ## branch
 
 Adds `/branch` to create and switch Git branches from the TUI. Switching
@@ -46,11 +42,7 @@ Adds `/cost-report` to build an HTML spend report from local session usage. Pick
 
 ## context
 
-Adds `/context` to inject reusable repository work scopes from `.pi/contexts`, and `/context-sync` or `/context-sync <nudge>` for human-driven catalog sync. Selecting entries injects them once into the conversation: `read` paths as complete files, `show` targets as current declaration slices, `outline` paths as Explore structures, and one hidden note listing `references` plus instructions to treat the injected material as current. Run `/context` again to inject more. Manual sync replaces the editor with a status panel; Escape or Ctrl+C cancels. When `sync.automation` is on, coding agent can also run `context-sync` after meaningful uncommitted work. Sync catalogs durable code and long-lived documentation; recurring scratch, planning, interview, and rough-idea paths belong in `validation.ignoreGlobs`. `sync.enabled` is master switch for command, automation, and validation auto-run. Context validation is off by default; when on (and sync enabled), Tau auto-runs context-sync on failure. Domain folders are `NN_slug` tabs (ordered by the two-digit prefix; UI shows the slug), TOML files are concepts, and TOML sections are selectable entries.
-
-## effort
-
-Adds `/effort [quick|standard|deep]` to select effort and a provider from current logins. Tau selects provider’s best available model for tier, then tries its configured model fallback. `Ctrl+Shift+E` cycles tiers on current provider. Footer derives effort from current provider, model, and thinking level, and hides it when no configured tier matches.
+Adds `/context` to browse and inject reusable repository work scopes from `.pi/contexts`. Selecting entries injects them once into the conversation: `read` paths as complete files, `show` targets as current declaration slices, `outline` paths as Explore structures, and one hidden note listing `references` plus instructions to treat the injected material as current. Run `/context` again to inject more. Edit catalog files by hand when work scopes change. Domain folders are `NN_slug` tabs (ordered by the two-digit prefix; UI shows the slug), TOML files are concepts, and TOML sections are selectable entries.
 
 ## explore
 
@@ -102,7 +94,7 @@ Shows a compact display-only marker after each run with wall time and model cost
 
 ## runtime-context
 
-Supplies the agent with the current local date and an initial root directory snapshot as hidden session context.
+Supplies Soul with the local date and root directory snapshot. Both remain fixed across turns, reload, and resume, and refresh after successful compaction.
 
 ## script-runner
 
@@ -114,16 +106,12 @@ Runs configured commands while keeping their output out of agent context when th
 
 ## soul
 
-Adds the baseline Tau system prompt on every session: communication style, operating model, and code style. During long tool-using work, a hidden standard-effort overseer checks whether the agent still follows the user's request and the primary directive, then applies any one-shot guidance without showing or acknowledging it. Set `extensions.soul.overseer.enabled` to turn this check on or off and `extensions.soul.overseer.toolCallInterval` to change the default 20-tool interval.
+Supplies Tau's communication, discussion, planning, execution, and coding instructions. Saves a prompt baseline across turns, reload, and resume; refreshes it after successful compaction. Operational changes arrive as saved context updates without rewriting earlier instructions. Tool groups that cannot load without changing the cached prefix wait for successful compaction.
 
 ## stash
 
 Adds `Alt+S` to stash the current prompt draft and `/pop` to browse stashed drafts and put one back in the editor.
 
-## subagent
-
-Gives Tau a subagent delegation tool for isolated, focused work. Run `/agents` to enable or disable individual agents for the current session, or set `extensions.subagent.disabled` in Tau settings for a persistent choice. `scout` is substantial multi-hop local code lookup that would chew parent context; facts only, not small digs; `web-research` handles external research. Known files can be autoread as line-numbered snapshots into a fresh or retained child turn. Tau can continue a retained child thread when follow-up work depends on its prior reads and reasoning. You can also create your own subagents in supported subagent directories. Ask Tau how to do it and have it consult extension documentation; built-in agents show pattern. Each subagent can register its own model, tools, and pool of display names. Reused pool names get numeric suffixes. In interactive cmux sessions, Tau opens one temporary Markdown dashboard for live subagent progress; it does not change how children run and closes shortly after active cohort finishes.
-
 ## tau-help
 
 Adds `/tau-help` to show this guide as rendered Markdown in the chat.
@@ -134,11 +122,11 @@ Adds `/tau`, `/tau init [--global|--project]`, and `/tau doctor` for Tau setup a
 
 ## tool-approval
 
-Reviews agent `bash` and `script_runner` requests before they run. Common read-only bash commands skip review. Set `extensions.toolApproval.autoApprove` to run every reviewer-approved request without another confirmation. Those auto-approvals show a user-only marker. The reviewer approves routine local development work. Concrete destructive, system, production, privileged, or security-sensitive effects require human approval with one explanatory paragraph. Reviewer failures fall back to human approval and send an attention notification.
+Reviews agent `bash` and `script_runner` requests before they run. Common read-only bash commands skip review. Set `extensions.toolApproval.autoApprove` to run every reviewer-approved request without another confirmation. Those auto-approvals show a user-only marker. The reviewer approves routine local development work. Concrete destructive, system, production, privileged, or security-sensitive effects require human approval with one explanatory paragraph. Reviewer failures fall back to human approval and send an attention notification. In the terminal approval panel, press `n` to add a note to Approve or Reject before choosing. Rejection notes tell the agent why the request was blocked; approval notes reach it with the tool result without changing the request. Reject with a note to ask for a revised request.
 
 ## tool-loader
 
-Progressively exposes registered specialist tool groups through `load_tools`. Tau registers `web`, `image`, and `appshot`; project or global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. Supported providers can preserve more prompt-cache reuse.
+Progressively exposes registered specialist tool groups through `load_tools`. Tau registers `web`, `image`, and `appshot`; project or global package extensions can add groups with `registerDeferredToolGroup()` from `@shanepadgett/tau-agent`. Compatible models load tools without replacing the cached prefix. Otherwise, requested groups are queued until successful compaction; loading never triggers compaction automatically.
 
 ## web
 

package/extensions/tau-help/index.ts

@@ -3,11 +3,12 @@ import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { Markdown, type Component, visibleWidth } from "@earendil-works/pi-tui";
+import { registerPromptSource } from "../../shared/prompt-contributions.ts";
 
 const TAU_DOCS_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "docs");
 const TAU_DOCS_GUIDANCE = `Tau Agent documentation (read only when the user asks about Tau Agent, Rok, Tau extensions, Tau event APIs, harness behavior, or extending Tau Agent):
 - Tau Agent docs: ${TAU_DOCS_PATH}
-- When asked about: context management / .pi/contexts taxonomy (docs/context.md), public events / external integration (docs/extending-tau-agent.md), custom subagents (docs/subagents.md), Tau TUI components (docs/tui.md)
+- When asked about: context management / .pi/contexts taxonomy (docs/context.md), public events / external integration (docs/extending-tau-agent.md), Tau TUI components (docs/tui.md)
 - Resolve Tau docs/... under Tau Agent docs, not the current working directory
 - When working on Tau topics, read the docs and follow .md cross-references before implementing
 - Do not read Tau Agent docs for normal coding tasks`;
@@ -54,9 +55,14 @@ class TauHelpMessage implements Component {
 }
 
 export default function tauHelpExtension(pi: ExtensionAPI): void {
-	pi.on("before_agent_start", (event) => ({
-		systemPrompt: `${event.systemPrompt}\n\n${TAU_DOCS_GUIDANCE}`,
-	}));
+	registerPromptSource(pi, {
+		key: "tau/documentation",
+		section: "documentation",
+		refresh: "compaction",
+		async read() {
+			return TAU_DOCS_GUIDANCE;
+		},
+	});
 
 	pi.registerMessageRenderer("tau-help", (message, _options, _theme) => {
 		if (typeof message.content !== "string") return undefined;

package/extensions/tool-approval/README.md

@@ -8,6 +8,8 @@ With `autoApprove` enabled, reviewer-approved requests run without another confi
 
 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.
 
+In the terminal approval panel, move between Approve and Reject, press `n` to add a note to the highlighted choice, then press Enter to choose. Enter saves an edited note before choosing; Escape cancels note editing or blocks the request from the choice list. A rejection note tells the agent why the request was blocked. An approval note reaches the agent with the tool result; it does not change the request being approved. To ask for a different request, reject it with a note. Long notes are truncated. RPC clients use the standard confirmation dialog without notes.
+
 Configure under `extensions.toolApproval`:
 
 ```json

package/extensions/tool-approval/index.ts

@@ -12,6 +12,7 @@ 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";
@@ -56,12 +57,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 =
@@ -82,6 +83,7 @@ interface AutoApprovedMarker {
 
 export default function toolApprovalExtension(pi: ExtensionAPI): void {
 	let settings = toolApprovalSettings.defaults;
+	const pendingNotes = new Map<string, string>();
 
 	pi.registerEntryRenderer<AutoApprovedMarker>(AUTO_APPROVED_TYPE, (entry, _options, theme) => {
 		const marker = autoApprovedMarker(entry.data);
@@ -98,22 +100,44 @@ 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) => {
+		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) => {
@@ -145,8 +169,8 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 			const { review, provider, model } = await reviewToolRequest(ctx, request);
 			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,8 +185,8 @@ 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."),
@@ -171,8 +195,8 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 			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 +206,27 @@ export default function toolApprovalExtension(pi: ExtensionAPI): void {
 		}
 	});
 
+	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", () => {
+		pendingNotes.clear();
+	});
+
 	pi.on("session_shutdown", (_event, ctx) => {
+		pendingNotes.clear();
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 }
@@ -269,29 +313,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.