@shanepadgett/tau-agent 0.29.0 → 0.31.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 },
+	),
+});