@shanepadgett/tau-agent 0.29.0 → 0.30.0

package/extensions/subagent/index.ts

@@ -6,9 +6,17 @@ import { createToolRowStateStore } from "../../shared/tool-row-state.js";
 import contextSettings from "../context/settings.ts";
 import { discoverAgents, type AgentDiscovery } from "./agents.ts";
 import { createCmuxDashboard, type CmuxDashboard, type DashboardOrphan } from "./cmux-dashboard.ts";
+import { createAgentsPanel } from "./panel.ts";
 import { renderSubagentCall, renderSubagentResult } from "./render.ts";
 import type { SubagentDetails } from "./run.ts";
 import { failedToolResult, SubagentRuntime } from "./runtime.ts";
+import subagentSettings from "./settings.ts";
+
+interface SubagentSessionState {
+	disabled: string[];
+}
+
+const SUBAGENT_SESSION_STATE_TYPE = "tau.subagent.disabled";
 
 const params = Type.Union([
 	Type.Object(
@@ -39,6 +47,7 @@ const params = Type.Union([
 
 export default function subagentExtension(pi: ExtensionAPI): void {
 	const runtime = new SubagentRuntime(pi);
+	let sessionDisabled = new Set<string>();
 	let failureNotify: ((message: string) => void) | undefined;
 	const orphans: DashboardOrphan[] = [];
 	const retryOrphans = async () => {
@@ -122,13 +131,74 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		}
 		for (const path of fingerprints.keys()) if (!current.has(path)) fingerprints.delete(path);
 	};
+	const disabledAgentNames = async (ctx: ExtensionContext) => {
+		const configured = new Set((await loadTauExtensionSettings(ctx, subagentSettings)).disabled);
+		return { configured, effective: new Set([...configured, ...sessionDisabled]) };
+	};
 	const parentVisibleAgents = async (ctx: ExtensionContext, discovery: AgentDiscovery) => {
-		const sync = (await loadTauExtensionSettings(ctx, contextSettings)).sync;
+		const [sync, disabled] = await Promise.all([
+			loadTauExtensionSettings(ctx, contextSettings).then((settings) => settings.sync),
+			disabledAgentNames(ctx),
+		]);
 		const parentVisible = sync.enabled && sync.automation;
 		return [...discovery.agents.values()]
-			.filter((agent) => agent.name !== "context-sync" || parentVisible)
+			.filter((agent) => !disabled.effective.has(agent.name) && (agent.name !== "context-sync" || parentVisible))
 			.sort((a, b) => a.name.localeCompare(b.name));
 	};
+	const restoreSessionState = (ctx: ExtensionContext) => {
+		let saved: string[] | undefined;
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "custom" || entry.customType !== SUBAGENT_SESSION_STATE_TYPE) continue;
+			const data = entry.data as { disabled?: unknown } | undefined;
+			if (Array.isArray(data?.disabled)) {
+				saved = data.disabled.filter((name): name is string => typeof name === "string" && name.length > 0);
+			}
+		}
+		sessionDisabled = new Set(saved ?? []);
+	};
+
+	pi.registerCommand("agents", {
+		description: "Enable/disable subagents for this session",
+		handler: async (_args, ctx) => {
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/agents requires TUI mode", "error");
+				return;
+			}
+
+			const [discovery, disabled] = await Promise.all([
+				discoverAgents(ctx.cwd, ctx.isProjectTrusted()),
+				disabledAgentNames(ctx),
+			]);
+			warn(discovery, ctx);
+			const agents = [...discovery.agents.values()].sort((a, b) => a.name.localeCompare(b.name));
+			if (agents.length === 0) {
+				ctx.ui.notify("No valid subagents found", "warning");
+				return;
+			}
+
+			await ctx.ui.custom((tui, theme, _keybindings, done) =>
+				createAgentsPanel(
+					tui,
+					theme,
+					agents.map((agent) => ({
+						id: agent.name,
+						disabled: disabled.effective.has(agent.name),
+						configured: disabled.configured.has(agent.name),
+					})),
+					(disabledNames) => {
+						for (const agent of agents) {
+							if (!disabled.configured.has(agent.name)) sessionDisabled.delete(agent.name);
+						}
+						for (const name of disabledNames) sessionDisabled.add(name);
+						pi.appendEntry<SubagentSessionState>(SUBAGENT_SESSION_STATE_TYPE, {
+							disabled: [...sessionDisabled].sort(),
+						});
+					},
+					() => done(undefined),
+				),
+			);
+		},
+	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
 		if (!pi.getActiveTools().includes("subagent")) return undefined;
@@ -147,7 +217,7 @@ Pass \`files\` when exact relevant files are already known. Tau autoreads curren
 
 Delegate one focused task per call. Children do not inherit parent messages. Include exact absolute reference paths when a child must inspect a repository outside the current working directory.
 
-Review limit: for one user task or coherent implementation batch, call the \`review\` agent at most twice. The first call is the initial review. The only permitted second call is a follow-up in the same retained thread to check fixes from that initial review. Never call \`review\` a third time for the same task. Do not call it for documentation-only work, trivial edits, small localized changes, or micro-adjustments after review; inspect and test those directly.`;
+Scout only for substantial multi-hop lookup that would flood parent context. Skip few known-path reads, single declaration lookups, or small digs with most evidence already in hand; use tools directly. When uncertain, dig yourself.`;
 		return { systemPrompt: `${event.systemPrompt}\n\n${prompt}` };
 	});
 	pi.registerTool(
@@ -180,6 +250,27 @@ Review limit: for one user task or coherent implementation batch, call the \`rev
 					return failedToolResult(agent, task, "queue", parentModel, parentThinking, error, threadKey);
 				}
 
+				if (continuing) {
+					const thread = runtime.listThreads(ctx.cwd).find((item) => item.id === threadKey);
+					if (thread) {
+						const disabled = await disabledAgentNames(ctx);
+						if (disabled.effective.has(thread.definition.name)) {
+							const source = disabled.configured.has(thread.definition.name)
+								? "in Tau settings"
+								: "for this session";
+							return failedToolResult(
+								thread.definition.name,
+								task,
+								"discovery",
+								parentModel,
+								parentThinking,
+								`Agent ${thread.definition.name} is disabled ${source}.`,
+								threadKey,
+							);
+						}
+					}
+				}
+
 				return runtime.execute({
 					agent,
 					task,
@@ -215,6 +306,11 @@ Review limit: for one user task or coherent implementation batch, call the \`rev
 								error: `Agent ${agent} discovery failed: ${reason}. Runnable agents: ${names}`,
 							};
 						}
+						const disabled = await disabledAgentNames(ctx);
+						if (disabled.effective.has(definition.name)) {
+							const source = disabled.configured.has(definition.name) ? "in Tau settings" : "for this session";
+							return { ok: false, phase: "discovery", error: `Agent ${definition.name} is disabled ${source}.` };
+						}
 						if (definition.name === "context-sync") {
 							const sync = (await loadTauExtensionSettings(ctx, contextSettings)).sync;
 							if (!sync.enabled) {
@@ -257,13 +353,17 @@ Review limit: for one user task or coherent implementation batch, call the \`rev
 		const details = event.details as SubagentDetails | undefined;
 		if (details?.status === "failed" || details?.status === "aborted") return { isError: true };
 	});
-	pi.on("session_start", async () => {
+	pi.on("session_start", async (_event, ctx) => {
+		restoreSessionState(ctx);
 		await runtime.reset();
 		await replaceDashboard();
 		rowState.clear();
 		fingerprints.clear();
 		failureNotify = undefined;
 	});
+	pi.on("session_tree", (_event, ctx) => {
+		restoreSessionState(ctx);
+	});
 	pi.on("session_shutdown", async () => {
 		unsubscribeDashboard();
 		await runtime.shutdown();
@@ -273,5 +373,6 @@ Review limit: for one user task or coherent implementation batch, call the \`rev
 		rowState.clear();
 		fingerprints.clear();
 		failureNotify = undefined;
+		sessionDisabled.clear();
 	});
 }

package/extensions/subagent/panel.ts

@@ -0,0 +1,124 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, getKeybindings, Key, matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
+import {
+	rawHint,
+	SelectableList,
+	type SelectableListResult,
+	ToolPanel,
+	type ToolPanelConfig,
+} from "@shanepadgett/tau-tui";
+
+export interface AgentPanelItem {
+	id: string;
+	disabled: boolean;
+	configured: boolean;
+}
+
+export function createAgentsPanel(
+	tui: TUI,
+	theme: Theme,
+	initial: readonly AgentPanelItem[],
+	onApply: (disabled: readonly string[]) => void,
+	done: () => void,
+): Component {
+	return new AgentsPanel(tui, theme, initial, onApply, done);
+}
+
+class AgentsPanel implements Component {
+	private readonly tui: TUI;
+	private readonly onApply: (disabled: readonly string[]) => void;
+	private readonly done: () => void;
+	private readonly list: SelectableList<AgentPanelItem>;
+	private readonly panelConfig: ToolPanelConfig;
+	private readonly panel: ToolPanel;
+	private items: readonly AgentPanelItem[];
+	private closed = false;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		initial: readonly AgentPanelItem[],
+		onApply: (disabled: readonly string[]) => void,
+		done: () => void,
+	) {
+		this.tui = tui;
+		this.items = initial;
+		this.onApply = onApply;
+		this.done = done;
+		this.list = new SelectableList(theme, {
+			items: initial,
+			emptyMessage: "No valid subagents found.",
+			selection: { kind: "single", primaryLabel: "apply" },
+			actions: [],
+			cancelLabel: "close",
+			maxVisible: 10,
+			renderItem: (item, state, width) => {
+				const label = state.active ? theme.bold(item.id) : item.id;
+				const status = item.configured
+					? theme.fg("muted", "disabled by Tau settings")
+					: item.disabled
+						? theme.fg("warning", "disabled")
+						: theme.fg("success", "enabled");
+				return [truncateToWidth(`${label}  ${status}`, width, "…")];
+			},
+			onResult: (result) => this.handleResult(result),
+		});
+		this.panelConfig = {
+			title: "Subagents",
+			secondary: "Changes apply to this session.",
+			body: this.list,
+			footer: { kind: "hints", hints: this.hints() },
+			border: "box",
+		};
+		this.panel = new ToolPanel(theme, this.panelConfig);
+	}
+
+	render(width: number): string[] {
+		return this.panel.render(width);
+	}
+
+	invalidate(): void {
+		this.panel.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.space) || data === " ") {
+			const current = this.list.getCurrentItem();
+			if (!current || current.configured) return;
+			this.items = this.items.map((item) => (item.id === current.id ? { ...item, disabled: !item.disabled } : item));
+			this.list.setItems(this.items, current.id);
+			this.syncPanel();
+			return;
+		}
+		if (getKeybindings().matches(data, "tui.select.confirm")) {
+			this.onApply(this.items.filter((item) => item.disabled && !item.configured).map((item) => item.id));
+			this.closed = true;
+			this.done();
+			return;
+		}
+		this.list.handleInput(data);
+		if (!this.closed) this.syncPanel();
+	}
+
+	private handleResult(result: SelectableListResult<AgentPanelItem>): void {
+		if (result.kind === "cancel") {
+			this.closed = true;
+			this.done();
+			return;
+		}
+	}
+
+	private syncPanel(): void {
+		this.panelConfig.footer = { kind: "hints", hints: this.hints() };
+		this.tui.requestRender();
+	}
+
+	private hints() {
+		const hints = this.list.getKeyHints();
+		const current = this.list.getCurrentItem();
+		if (current && !current.configured) {
+			hints.splice(1, 0, rawHint("Space", "toggle"));
+		}
+		return hints;
+	}
+}

package/extensions/subagent/render.ts

@@ -48,7 +48,8 @@ export function renderSubagentResult(
 		return text;
 	}
 	const identity = `${details.displayName} (${details.agent})`;
-	const header = `${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", identity)}  ${theme.fg("muted", `$${details.usage.cost.toFixed(4)} · ${(details.durationMs / 1000).toFixed(1)}s · ${details.toolCalls} tools`)}`;
+	const ctx = typeof details.contextPercent === "number" ? ` · ${details.contextPercent.toFixed(1)}% ctx` : "";
+	const header = `${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", identity)}  ${theme.fg("muted", `$${details.usage.cost.toFixed(4)} · ${(details.durationMs / 1000).toFixed(1)}s · ${details.toolCalls} tools${ctx}`)}`;
 	if (!expanded) {
 		text.setText(`${header}  ${theme.fg("muted", details.task.replace(/\s+/g, " ").trim())}`);
 		return text;

package/extensions/subagent/run.ts

@@ -13,14 +13,10 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { createCompleteFileMeta } from "../../shared/full-file-knowledge.ts";
+import { createIsolatedSessionResource, type IsolatedSessionResource } from "../../shared/isolated-session.ts";
 import type { AgentDefinition } from "./agents.ts";
 import { emptySubagentResumeState, type RetainedTurnOutcome, type SubagentResumeState } from "./resume.ts";
-import {
-	createSubagentSessionResource,
-	resolveSubagentSessionInputs,
-	type SubagentSessionInputs,
-	type SubagentSessionResource,
-} from "./session-resource.ts";
+import { resolveSubagentSessionInputs, type SubagentSessionInputs } from "./session-resource.ts";
 
 const PREVIEW_LIMIT = 600;
 const VALUE_LIMIT = 180;
@@ -62,6 +58,7 @@ export interface SubagentDetails {
 	omittedActions: number;
 	omittedErrors: number;
 	usage: SubagentUsage;
+	contextPercent?: number;
 	durationMs: number;
 	truncation?: {
 		truncated: boolean;
@@ -85,7 +82,7 @@ export interface SubagentThread {
 	displayName: string;
 	definition: AgentDefinition;
 	sessionInputs: SubagentSessionInputs;
-	resource: SubagentSessionResource;
+	resource: IsolatedSessionResource;
 	cwd: string;
 	model: string;
 	thinkingLevel: string;
@@ -199,7 +196,7 @@ export async function createSubagentThread(options: {
 	extensionPaths: readonly string[];
 	initialTask: string;
 	ctx: ExtensionContext;
-	thinkingLevel: string;
+	thinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
 	signal: AbortSignal;
 	onWarning?: (warning: string) => void;
 }): Promise<SubagentThread> {
@@ -222,7 +219,7 @@ export async function createSubagentThread(options: {
 		signal,
 		...(onWarning === undefined ? {} : { onWarning }),
 	});
-	const resource = await createSubagentSessionResource(sessionInputs, signal);
+	const resource = await createIsolatedSessionResource(sessionInputs, signal);
 	try {
 		return {
 			id,
@@ -307,6 +304,9 @@ export async function runSubagentTurn(options: {
 		if (!force && now - lastTextUpdate < 100) return;
 		lastTextUpdate = now;
 		details.durationMs = now - started;
+		const context = session.getContextUsage();
+		if (typeof context?.percent === "number") details.contextPercent = context.percent;
+		else delete details.contextPercent;
 		const snapshot = cloneSnapshot(details);
 		snapshot.actions = snapshot.actions.slice(-5);
 		// Detached observer chain — must not delay prompt completion.

package/extensions/subagent/runtime.ts

@@ -1,5 +1,6 @@
 import type { Usage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createIsolatedSessionResource, type IsolatedSessionResource } from "../../shared/isolated-session.ts";
 import type { AgentDefinition } from "./agents.ts";
 import { buildColdResumePrompt, retainSubagentTurn } from "./resume.ts";
 import {
@@ -15,7 +16,6 @@ import {
 	type SubagentPhase,
 	type SubagentThread,
 } from "./run.ts";
-import { createSubagentSessionResource, type SubagentSessionResource } from "./session-resource.ts";
 
 const MAX_RETAINED_THREADS = 16;
 const GLOBAL_CONCURRENCY = 4;
@@ -216,7 +216,7 @@ export class SubagentRuntime {
 		definition?: AgentDefinition;
 		ctx: ExtensionContext;
 		parentModel: string;
-		parentThinking: string;
+		parentThinking: NonNullable<ExtensionContext["thinkingLevel"]>;
 		signal?: AbortSignal;
 		onUpdate?: (details: SubagentDetails) => void | Promise<void>;
 		resolveFreshDefinition: () => Promise<
@@ -286,7 +286,7 @@ export class SubagentRuntime {
 			threadKey?: string;
 			ctx: ExtensionContext;
 			parentModel: string;
-			parentThinking: string;
+			parentThinking: NonNullable<ExtensionContext["thinkingLevel"]>;
 			definition?: AgentDefinition;
 			signal?: AbortSignal;
 			onUpdate?: (details: SubagentDetails) => void | Promise<void>;
@@ -316,7 +316,7 @@ export class SubagentRuntime {
 		let releaseGlobal: (() => void) | undefined;
 		let reservedThread: TrackedThread | undefined;
 		let provisionalThread: TrackedThread | undefined;
-		let provisionalResource: SubagentSessionResource | undefined;
+		let provisionalResource: IsolatedSessionResource | undefined;
 		let reservationToken: symbol | undefined;
 		let admitAdvanced = false;
 		let phase: SubagentPhase = "queue";
@@ -513,7 +513,7 @@ export class SubagentRuntime {
 				phase = "startup";
 				fanOut({ ...active.snapshot, status: "starting", phase: "startup", agent, threadId: thread.id }, true);
 				const oldResource = thread.resource;
-				provisionalResource = await createSubagentSessionResource(thread.sessionInputs, combined);
+				provisionalResource = await createIsolatedSessionResource(thread.sessionInputs, combined);
 				if (!this.isLive(generation, combined) || thread.disposed || this.threads.get(thread.id) !== thread) {
 					await provisionalResource.dispose();
 					provisionalResource = undefined;

package/extensions/subagent/session-resource.ts

@@ -1,12 +1,5 @@
-import {
-	createAgentSession,
-	DefaultResourceLoader,
-	getAgentDir,
-	ModelRuntime,
-	SessionManager,
-	type AgentSession,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { resolveIsolatedSessionModel, type IsolatedSessionInputs } from "../../shared/isolated-session.ts";
 import type { AgentDefinition, ThinkingLevel } from "./agents.ts";
 
 const CHILD_UI_BLOCKED_METHODS = new Set([
@@ -18,25 +11,10 @@ const CHILD_UI_BLOCKED_METHODS = new Set([
 	"setWorkingIndicator",
 ]);
 
-type SelectedModel = NonNullable<ExtensionContext["model"]>;
-type SelectedProvider = NonNullable<ReturnType<ExtensionContext["modelRegistry"]["getProvider"]>>;
-
-export interface SubagentSessionInputs {
+export interface SubagentSessionInputs extends IsolatedSessionInputs {
 	definition: AgentDefinition;
-	extensionPaths: readonly string[];
-	cwd: string;
-	model: SelectedModel;
 	modelName: string;
-	provider: SelectedProvider;
-	runtimeApiKey: string | undefined;
 	thinkingLevel: ThinkingLevel;
-	bindTarget: { mode: "print" } | { mode: "tui"; uiContext: ExtensionContext["ui"] };
-}
-
-export interface SubagentSessionResource {
-	readonly inputs: SubagentSessionInputs;
-	readonly session: AgentSession;
-	dispose(): Promise<void>;
 }
 
 function childUiContext(ui: ExtensionContext["ui"]): ExtensionContext["ui"] {
@@ -53,117 +31,31 @@ export async function resolveSubagentSessionInputs(options: {
 	definition: AgentDefinition;
 	extensionPaths: readonly string[];
 	ctx: ExtensionContext;
-	parentThinkingLevel: string;
+	parentThinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
 	signal: AbortSignal;
 	onWarning?: (warning: string) => void;
 }): Promise<SubagentSessionInputs> {
 	const { definition, extensionPaths, ctx, signal, onWarning } = options;
-	let model = ctx.model;
-	let thinkingLevel = options.parentThinkingLevel as ThinkingLevel;
-	let selectedAuth: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>> | undefined;
-	if (definition.model) {
-		const separator = definition.model.indexOf("/");
-		const configured = ctx.modelRegistry.find(
-			definition.model.slice(0, separator),
-			definition.model.slice(separator + 1),
-		);
-		if (!configured) onWarning?.(`model ${definition.model} is unavailable; using parent model`);
-		else {
-			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configured);
-			if (!auth.ok) onWarning?.(`model ${definition.model} is unavailable: ${auth.error}; using parent model`);
-			else {
-				model = configured;
-				selectedAuth = auth;
-			}
-		}
-	}
-	if (definition.thinking) {
-		const mapped = model?.thinkingLevelMap?.[definition.thinking];
-		const unsupported =
-			!model?.reasoning ||
-			mapped === null ||
-			((definition.thinking === "xhigh" || definition.thinking === "max") && mapped === undefined);
-		if (unsupported)
-			onWarning?.(`thinking ${definition.thinking} is unavailable for the selected model; using parent thinking`);
-		else thinkingLevel = definition.thinking;
-	}
-	if (!model) throw new Error(`Agent ${definition.name} startup failed: parent has no model`);
-	const auth = selectedAuth ?? (await ctx.modelRegistry.getApiKeyAndHeaders(model));
-	if (!auth.ok) throw new Error(`Agent ${definition.name} startup failed: ${auth.error}`);
-	const provider = ctx.modelRegistry.getProvider(model.provider);
-	if (!provider) throw new Error(`Agent ${definition.name} startup failed: provider ${model.provider} is unavailable`);
-	if (signal.aborted) throw new Error(`Agent ${definition.name} startup aborted`);
+	const selected = await resolveIsolatedSessionModel({
+		label: `Agent ${definition.name}`,
+		preferredModel: definition.model,
+		preferredThinkingLevel: definition.thinking,
+		usePreferredThinkingAfterModelFallback: true,
+		ctx,
+		parentThinkingLevel: options.parentThinkingLevel,
+		signal,
+		...(onWarning === undefined ? {} : { onWarning }),
+	});
 	return {
+		...selected,
+		label: `Agent ${definition.name}`,
 		definition,
 		extensionPaths: [...extensionPaths],
 		cwd: ctx.cwd,
-		model,
-		modelName: `${model.provider}/${model.id}`,
-		provider,
-		runtimeApiKey:
-			auth.apiKey && provider.auth.apiKey && !ctx.modelRegistry.isUsingOAuth(model) ? auth.apiKey : undefined,
-		thinkingLevel,
+		modelName: `${selected.model.provider}/${selected.model.id}`,
+		tools: definition.tools,
+		customTools: [],
 		bindTarget:
 			ctx.mode === "tui" && ctx.hasUI ? { mode: "tui", uiContext: childUiContext(ctx.ui) } : { mode: "print" },
 	};
 }
-
-export async function createSubagentSessionResource(
-	inputs: SubagentSessionInputs,
-	signal: AbortSignal,
-): Promise<SubagentSessionResource> {
-	let session: AgentSession | undefined;
-	try {
-		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
-		const modelRuntime = await ModelRuntime.create();
-		modelRuntime.registerNativeProvider(inputs.provider);
-		if (inputs.runtimeApiKey !== undefined)
-			await modelRuntime.setRuntimeApiKey(inputs.model.provider, inputs.runtimeApiKey, { allowNetwork: false });
-		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: inputs.cwd,
-			agentDir: getAgentDir(),
-			noExtensions: true,
-			additionalExtensionPaths: [...inputs.extensionPaths],
-		});
-		await resourceLoader.reload();
-		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
-		const created = await createAgentSession({
-			cwd: inputs.cwd,
-			model: inputs.model,
-			modelRuntime,
-			thinkingLevel: inputs.thinkingLevel,
-			tools: inputs.definition.tools,
-			excludeTools: ["subagent"],
-			resourceLoader,
-			sessionManager: SessionManager.inMemory(inputs.cwd),
-		});
-		session = created.session;
-		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
-		await session.bindExtensions(inputs.bindTarget);
-		if (signal.aborted) throw new Error(`Agent ${inputs.definition.name} startup aborted`);
-		const active = session.getActiveToolNames().sort();
-		const expected = [...inputs.definition.tools].sort();
-		if (active.join("\0") !== expected.join("\0") || active.includes("subagent")) {
-			const missing = expected.filter((tool) => !active.includes(tool));
-			throw new Error(
-				`Agent ${inputs.definition.name} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
-			);
-		}
-		let disposed = false;
-		return {
-			inputs,
-			session,
-			async dispose() {
-				if (disposed) return;
-				disposed = true;
-				if (session?.isStreaming) await session.abort().catch(() => undefined);
-				session?.dispose();
-			},
-		};
-	} catch (error) {
-		if (session?.isStreaming) await session.abort().catch(() => undefined);
-		session?.dispose();
-		throw error;
-	}
-}

package/extensions/subagent/settings.ts

@@ -0,0 +1,18 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
+
+export default defineTauExtensionSettings({
+	key: "subagent",
+	defaults: { disabled: [] as string[] },
+	schema: Type.Object(
+		{
+			disabled: Type.Optional(
+				Type.Array(Type.String({ minLength: 1 }), {
+					default: [],
+					description: "Agent names unavailable for delegation.",
+				}),
+			),
+		},
+		{ additionalProperties: false },
+	),
+});

package/extensions/tau-help/help.md

@@ -32,7 +32,7 @@ Adds `/commit` for semantic commit grouping, review, and committing selected rep
 
 ## context
 
-Adds `/context` to select reusable repository work scopes from `.pi/contexts`, and `/context-sync` or `/context-sync <nudge>` for human-driven catalog sync (optional nudge). Escape cancels a running manual sync. When `sync.automation` is on, the coding agent can also run the `context-sync` subagent 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 the master switch for command, automation, and validation auto-run. Entry `files` are autoread; entry `anchors` are unloaded navigation paths. Context validation is off by default; when on (and sync enabled), Tau auto-runs context-sync on failure. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
+Adds `/context` to set branch-local reusable repository work scopes from `.pi/contexts`, and `/context-sync` or `/context-sync <nudge>` for human-driven catalog sync. Active entries produce one ephemeral per-call projection instead of transcript messages. Entry `read` paths supply exact contents, `outline` paths use Explore, and `references` stay unloaded. Clear all selections and confirm to remove active context. Escape cancels a running manual sync. 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. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
 
 ## working-memory
 
@@ -74,6 +74,10 @@ Adds `/publish` to create a tagged release, trigger trusted npm publishing in Gi
 
 Adds `/qna` for when the agent has asked you several questions in chat and you want a friendly UI for answering them on your own terms. It is only active when you manually run the command.
 
+## review
+
+Adds `/review` for explicit isolated review of current Git changes. Choose `simplify`, `architecture`, or `correctness`, or run a mode directly. Results stay outside agent context until you send them from result view, and can be exported under `.pi/tau/reviews/`. `/review show` reopens latest result on current session branch.
+
 ## reference
 
 Adds `/reference` to manage separate repositories kept outside the current project for inspiration or comparison. Add one with `/reference new <git-url>`, update it, switch its referenced branch, or open it in an editor. Select references and explain why they matter; Tau then puts their paths and that reason into the editor for the agent. References stay outside the project so the agent does not wander into unrelated code unless you explicitly point it there.
@@ -86,6 +90,10 @@ Shows a compact display-only marker after each run with wall time and model cost
 
 Supplies the agent with the current local date and an initial root directory snapshot as hidden session context.
 
+## script-runner
+
+Gives the agent a first-class `script_runner` tool to execute Python and TypeScript instead of bash. On failure it returns a `scriptId`; the agent retries with targeted `{oldText,newText}` edits against the script it already wrote rather than resending the whole script. Languages are detected from the environment (Python via `python3`/`python`; TypeScript via Node `--experimental-strip-types`, Node 22.6+). The tool registers only available languages and is hidden from the prompt if neither is present.
+
 ## silent-command-runner
 
 Runs configured commands while keeping their output out of agent context when that is useful.
@@ -100,7 +108,7 @@ Adds `Alt+S` to stash the current prompt draft and `/pop` to browse stashed draf
 
 ## subagent
 
-Gives Tau a subagent delegation tool for isolated, focused work. The built-in `review` agent performs adversarial, read-only code reviews; `scout` finds local files, symbols, data flow, constraints, and unknowns without changing anything; `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 the supported subagent directories. Ask Tau how to do it and have it consult the extension’s own documentation; the built-in agents show the 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 the active cohort finishes.
+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
 
@@ -114,10 +122,6 @@ Adds `/tau`, `/tau init [--global|--project]`, and `/tau doctor` for Tau setup a
 
 Progressively exposes specialist tools through `load_tools`. Tau normally loads the fixed `web`, `image`, and `appshot` groups itself when needed; supported providers can preserve more prompt-cache reuse.
 
-## turn-budget
-
-Tracks and limits agent turns to keep work bounded.
-
 ## web
 
 Gives the agent compact `websearch`, `webfetch`, and `codesearch` tools for web and implementation research.