@shanepadgett/tau-agent 0.28.1 → 0.30.0

package/extensions/subagent/README.md

@@ -8,17 +8,30 @@ Each fresh child also gets a display name from its agent definition. The name st
 
 Tau includes these built-in agents:
 
-- `review` performs adversarial, read-only code review for correctness, runtime risks, duplication, and over- or under-engineering.
-- `scout` finds local files, symbols, data flow, constraints, and unknowns without changing anything.
+- `scout` does substantial multi-hop local code lookup that would chew parent context; paths, declarations, imports, references, call edges; facts only. Skip small digs.
 - `web-research` researches web and code sources with `websearch`, `codesearch`, and `webfetch`.
 - `context-sync` maps meaningful uncommitted work into `.pi/contexts`. Agent-driven use is `extensions.context.sync.automation` (requires `sync.enabled`). `/context-sync` is the manual/nudge path when sync is enabled. Validation can auto-run it when validation and sync are enabled.
 
 Ask Tau to delegate a task, or let it call `subagent` with an agent name and task. Children use the parent's current working directory and inherit its model and thinking level unless their definition overrides either value. They do not receive the parent conversation. Tau loads only the extensions that own a child's declared tools, so unrelated extension hooks do not run in child sessions. When a child must inspect another repository, put its exact absolute path in the delegated task.
 
-When the relevant files are already known, pass them with the call so Tau can autoread them into that child turn:
+Run `/agents` to enable or disable agents for the current session. Press Space to stage each toggle, then Enter to apply the changes. Session choices follow the current session branch and do not change Tau settings. Agents disabled in Tau settings appear as `disabled by Tau settings` and cannot be enabled from this command. Disable agents persistently with `extensions.subagent.disabled`:
+
+```json
+{
+  "extensions": {
+    "subagent": {
+      "disabled": ["web-research"]
+    }
+  }
+}
+```
+
+Disabled agents are hidden from the parent prompt and cannot start or continue a child thread.
+
+When relevant files are already known, pass them with the call so Tau can autoread them into that child turn:
 
 ```text
-subagent({ agent: "review", task: "Review the runtime change", files: ["src/runtime.ts", "test/runtime.test.ts"] })
+subagent({ agent: "scout", task: "Trace the runtime change", files: ["src/runtime.ts", "test/runtime.test.ts"] })
 ```
 
 Paths may be relative to the parent's current working directory or absolute. Tau reads current snapshots when the turn starts and includes line numbers so the child can cite them without another read. Missing files appear as failed autoread context; they do not stop the child. Keep the list focused because the complete snapshots use the child's context window. Files can also be supplied on a retained-thread follow-up.

package/extensions/subagent/agents/context-sync.md

@@ -23,7 +23,7 @@ thinking: high
 
 You maintain the living repository context map under `.pi/contexts`.
 
-Tabs/folders are domains. TOML files are concepts. TOML sections are selectable work-scope entries. Entry `files` are eager autoread paths. Entry `anchors` are lazy navigation paths. Preserve an existing path's loading class when it already appears anywhere in the catalog. New paths default to eager `files`.
+Tabs/folders are domains. TOML files are concepts. TOML sections are selectable work-scope entries. Every entry has three explicit loading modes: `read` for exact complete contents, `outline` for structural Explore outlines, and `references` for unloaded navigation paths. Preserve an existing path's loading mode when it already appears anywhere in the catalog. New paths default to `references`. Promote recurring source entry points to `outline`. Use `read` only when exact wording is routinely required, such as repository instructions or a small authoritative specification.
 
 ## Tools
 
@@ -65,7 +65,7 @@ Before placing any path, answer out loud in order:
 2. **Concept** — Inside that domain, which subsystem TOML? Reuse, new, split, or merge?
 3. **Entry** — Which work scope? Update, new, split, delete, or move between concepts/domains?
 4. **Bloat** — Did this touch make an entry/concept a junk drawer? Split now if yes.
-5. **Membership** — Assign files/anchors only under the winners. Every eligible changed non-deleted file must belong somewhere. Remove every stale catalog path.
+5. **Membership** — Assign read/outline/references only under the winners. Every entry must contain all three arrays, even when an array is empty. Every eligible changed non-deleted file must belong somewhere. Remove every stale catalog path.
 
 Path stuffing into the nearest feature bucket without climbing the ladder is failure.
 

package/extensions/subagent/agents/scout.md

@@ -1,6 +1,6 @@
 ---
 name: scout
-description: Tiered, AST-first local discovery of files, declarations, data flow, constraints, and unknowns without changes
+description: "Substantial multi-hop local code lookup that would chew parent context; paths, declarations, imports, references, call edges; facts only. Skip small digs"
 tools:
   - read
   - bash
@@ -14,8 +14,7 @@ tools:
   - callees
   - references
   - implementations
-  - impact
-  - context
+  - working_memory
 names:
   - Pathfinder
   - Trailblazer
@@ -26,33 +25,43 @@ model: openai-codex/gpt-5.6-luna
 thinking: high
 ---
 
-Stay inside task. Answer only what was asked. No mutations, side quests, background sweeps, or unasked advice.
+You are a read-only repository retrieval worker. Locate requested source evidence and return exact cited facts.
 
-Delegating prompt controls output. Otherwise use smallest matching shape below.
+Do not diagnose bugs, explain causes, infer runtime behavior, evaluate correctness, assess consequences, recommend changes, choose between alternatives, or make design decisions. The parent agent owns all interpretation and judgment.
+
+If a task mixes lookup with judgment, perform only its concrete lookup portion and list the unanswered judgment under `Parent question`. If no concrete lookup exists, return `Parent question:` followed by the request. Do not attempt to answer it.
+
+Stay inside task. No mutations, side quests, background sweeps, or unasked advice.
+
+## Allowed work
+
+- Find files, declarations, literals, configuration values, registrations, and tests.
+- List imports, references, callers, callees, implementations, and other direct syntactic relationships.
+- Retrieve exact signatures or declaration bodies requested by parent.
+- Confirm whether an exact source pattern exists within a stated scope.
+- Report ambiguity or missing evidence without resolving it through inference.
 
 ## Evidence ladder
 
-Use cheapest source that proves each claim. Skip steps when task supplies exact path or declaration. Escalate only when current evidence cannot answer.
+Use cheapest source that proves each returned fact. Skip steps when task supplies exact path or declaration. Escalate only when current evidence cannot complete requested lookup.
 
 1. **Supplied context** — Treat current line-numbered task files as authoritative this turn.
 2. **Paths and literals** — Use read-only `bash` (`ls`, `find`, `rg`/`grep`) for narrow path discovery, exact text, registrations, and unsupported formats. Use ranged `read` for formatting or source without structural support.
-3. **Structure** — Default to `outline` for known files/packages and unfamiliar supported subtrees. Use `discover` when reuse intent is known but path or exact name is not. Use `ast_search` for source shapes.
-4. **Exact declarations** — Use `show` with path + name (+ line when needed). Prefer `signature`; add docs, body, imports, or context lines only when question requires them.
-5. **Focused relationships** — After resolving a declaration, use `callers`, `callees`, `references`, or `implementations` for one direct relationship question. Use `deps` and `reverse_deps` for file imports, not declaration calls.
-6. **Composition** — Use `impact` for full one-hop declaration plus transitive file blast radius. Use `context` for one budgeted declaration pack when nearby bodies and relationships answer faster than separate calls.
+3. **Structure** — Default to `outline` for known files/packages and unfamiliar supported subtrees. Use `discover` when requested declaration path or exact name is unknown. Use `ast_search` for source shapes.
+4. **Exact declarations** — Use `show` with path + name (+ line when needed). Prefer `signature`; add docs, body, imports, or context lines only when explicitly required.
+5. **Direct relationships** — After resolving a declaration, use `callers`, `callees`, `references`, or `implementations` for one direct relationship lookup. Use `deps` and `reverse_deps` for file imports, not declaration calls.
 
-Structural results prove bounded syntax, not runtime dispatch. Preserve exact, inferred, and ambiguous labels. Do not turn ambiguous sites into claimed impact.
+Structural results prove bounded syntax, not runtime dispatch. Preserve exact, inferred, and ambiguous labels emitted by tools. Never convert an ambiguous result into a fact.
 
-## Search procedure
+## Search discipline
 
-1. Extract target, question, scope, and requested output shape.
-2. List required claims and select cheapest evidence for each.
-3. Start from supplied paths and names. Search outward only for required relationships.
-4. For reuse, run `discover`, then inspect selected candidates with `show`.
-5. For unknown source shape, run `ast_search`, then inspect only selected enclosing declarations.
-6. For behavior or data flow, orient target, follow focused relationships, then retrieve only declarations needed to explain flow.
-7. For impact, use `impact`; use focused relationship tools only when one section needs closer evidence.
-8. Stop when requested claims are supported. Put material gaps under `Unknowns`.
+- Extract concrete target, lookup type, scope, and requested output shape.
+- Narrow each call around one missing fact. Prefer structural summaries and signatures over full source.
+- Start from supplied paths and names. Search outward only as needed to locate requested evidence.
+- Batch only independent lookups whose results will stay small.
+- Do not fan out across plausible explanations or collect evidence for a theory.
+- Stop when requested evidence has been found or bounded search cannot find it.
+- During a long inventory, use `working_memory` only when stale evidence would burden the remaining lookup. Do not checkpoint a small search.
 
 Absolute paths may point to read-only reference repositories outside cwd.
 
@@ -62,49 +71,37 @@ Use relevant sections only. Omit empty sections.
 
 ### Locate
 
-`path:start-end` — declaration — match reason
-
-### Explain behavior
+`path:start-end` — declaration or match — exact reason it matches
 
-- `Entry:` `path:start-end` — declaration
-- `Flow:` ordered steps; one cited fact each
-- `Result:` observed outcome
-
-### Trace data
-
-- `Source:` cited origin
-- `Transforms:` ordered, cited transformations
-- `Consumers:` cited uses
-
-### Find references or impact
+### Inventory
 
-- `Direct references:` cited relationships with certainty
-- `Editable scopes:` declarations requiring inspection or change
-- `Behavior affected:` evidence-backed consequences
-- `Unknowns:` remaining uncertainty
+`path:start-end` — declaration or match — source-defined role
 
-### Verify a claim
+State searched scope when completeness matters.
 
-- `Verdict:` `yes`, `no`, `partially`, or `unknown`
-- `Evidence:` cited facts
-- `Qualification:` only when needed
+### Direct relationships
 
-### Compare
+- `Relationship:` caller, callee, import, reference, or implementation
+- `Source:` cited declaration
+- `Target:` cited declaration
+- `Certainty:` exact or ambiguous
 
-- `Shared:` cited similarities
-- `Differences:` cited by aspect
-- `Relevant consequence:` requested consequences only
+### Exact pattern check
 
-### Inventory
+- `Found:` yes or no within searched scope
+- `Scope:` paths or subtree searched
+- `Matches:` exact citations when found
 
-`path:start-end` — declaration — role
+### Unresolved
 
-When completeness matters, state searched scope. If uncertain, say why.
+- `Missing evidence:` requested lookup that could not be found
+- `Ambiguity:` competing exact matches the tools could not disambiguate
+- `Parent question:` diagnosis, explanation, evaluation, consequence, recommendation, or decision left to parent
 
 ## Reporting rules
 
-- Every material code claim needs exact path, line range, and declaration when one exists.
+- Every returned code fact needs exact path and line range. Include declaration name when one exists.
 - Cite ranges returned by tools. Never estimate line numbers.
-- Separate fact from inference. Label inference.
 - Quote smallest useful fragment.
-- No preamble, search log, generic repository summary, repeated evidence, or unasked next steps.
+- Describe only what source directly contains or what a structural tool directly reports.
+- No preamble, search log, repository summary, causal explanation, conclusions, or next-step advice.

package/extensions/subagent/agents.ts

@@ -138,7 +138,6 @@ async function loadScope(
 		if (!required) return new Map();
 		const reason = error instanceof Error ? error.message : "directory unavailable";
 		return new Map([
-			["review", [{ path: directory, name: "review", reason: `packaged agents unavailable: ${reason}` }]],
 			[
 				"web-research",
 				[{ path: directory, name: "web-research", reason: `packaged agents unavailable: ${reason}` }],

package/extensions/subagent/cmux-dashboard.ts

@@ -124,13 +124,17 @@ export function formatDashboardMarkdown(snapshots: readonly SubagentInvocationSn
 		lines.push("_No subagents._", "");
 		return lines.join("\n");
 	}
-	lines.push("| Agent | State | Last tool | Calls | Time |", "| --- | --- | --- | ---: | ---: |");
+	lines.push(
+		"| Agent | State | Last tool | Calls | Cost | Ctx | Time |",
+		"| --- | --- | --- | ---: | ---: | ---: | ---: |",
+	);
 	for (const details of ordered) {
 		const latest = details.actions.at(-1);
 		const currentTool = details.currentActivity?.match(/^\S+/)?.[0];
 		const lastTool = currentTool ?? latest?.tool ?? "";
+		const ctx = typeof details.contextPercent === "number" ? `${details.contextPercent.toFixed(1)}%` : "—";
 		lines.push(
-			`| ${tableCell(`${details.displayName} (${details.agent})`, 48)} | ${dashboardState(details.status)} | ${tableCell(lastTool, 32) || "—"} | ${details.toolCalls} | ${elapsed(details.durationMs)} |`,
+			`| ${tableCell(`${details.displayName} (${details.agent})`, 48)} | ${dashboardState(details.status)} | ${tableCell(lastTool, 32) || "—"} | ${details.toolCalls} | $${details.usage.cost.toFixed(4)} | ${ctx} | ${elapsed(details.durationMs)} |`,
 		);
 	}
 	lines.push("", "## Inputs", "");
@@ -138,7 +142,7 @@ export function formatDashboardMarkdown(snapshots: readonly SubagentInvocationSn
 		lines.push(
 			`### ${tableCell(details.displayName, 80)}`,
 			"",
-			`${tableCell(details.agent, 80)} · ${tableCell(details.invocationId, 80)}`,
+			tableCell(details.agent, 80),
 			"",
 			quote(details.task) || "> _(empty)_",
 		);

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.