@shanepadgett/tau-agent 0.16.0 → 0.17.0

package/extensions/subagent/index.ts

@@ -1,66 +1,109 @@
+import { rm } from "node:fs/promises";
 import { defineTool, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { createToolRowStateStore } from "../../shared/tool-row-state.js";
-import { discoverAgents, type AgentDefinition, type AgentDiscovery } from "./agents.ts";
+import contextSettings from "../context/settings.ts";
+import { discoverAgents, type AgentDiscovery } from "./agents.ts";
+import { createCmuxDashboard, type CmuxDashboard, type DashboardOrphan } from "./cmux-dashboard.ts";
 import { renderSubagentCall, renderSubagentResult } from "./render.ts";
-import {
-	createSubagentThread,
-	disposeSubagentThread,
-	extensionPathsForTools,
-	FifoGate,
-	runSubagentTurn,
-	type SubagentDetails,
-	type SubagentThread,
-} from "./run.ts";
+import type { SubagentDetails } from "./run.ts";
+import { failedToolResult, SubagentRuntime } from "./runtime.ts";
 
 const params = Type.Union([
 	Type.Object(
-		{ agent: Type.String({ minLength: 1 }), task: Type.String({ minLength: 1 }) },
+		{
+			agent: Type.String({ minLength: 1 }),
+			task: Type.String({ minLength: 1 }),
+			files: Type.Optional(
+				Type.Array(Type.String({ minLength: 1 }), {
+					description: "Files to autoread into the child's context before this turn",
+				}),
+			),
+		},
 		{ additionalProperties: false },
 	),
 	Type.Object(
-		{ thread: Type.String({ minLength: 1 }), task: Type.String({ minLength: 1 }) },
+		{
+			thread: Type.String({ minLength: 1 }),
+			task: Type.String({ minLength: 1 }),
+			files: Type.Optional(
+				Type.Array(Type.String({ minLength: 1 }), {
+					description: "Files to autoread into the child's context before this turn",
+				}),
+			),
+		},
 		{ additionalProperties: false },
 	),
 ]);
 
-const MAX_RETAINED_THREADS = 16;
-
-function emptyDetails(
-	agent: string,
-	task: string,
-	status: "waiting" | "failed" | "aborted",
-	phase: "discovery" | "queue" | "startup",
-	model: string,
-	thinkingLevel: string,
-	threadId: string | undefined,
-	error: string | undefined,
-): SubagentDetails {
-	return {
-		agent,
-		...(threadId === undefined ? {} : { threadId }),
-		status,
-		phase,
-		task,
-		model,
-		thinkingLevel,
-		toolCalls: 0,
-		actions: [],
-		omittedActions: 0,
-		omittedErrors: 0,
-		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-		durationMs: 0,
-		...(error === undefined ? {} : { error }),
-	};
-}
-
 export default function subagentExtension(pi: ExtensionAPI): void {
-	const gate = new FifoGate(4);
-	const controllers = new Set<AbortController>();
-	const threads = new Map<string, SubagentThread>();
+	const runtime = new SubagentRuntime(pi);
+	let failureNotify: ((message: string) => void) | undefined;
+	const orphans: DashboardOrphan[] = [];
+	const retryOrphans = async () => {
+		if (orphans.length === 0) return;
+		const pending = orphans.splice(0, orphans.length);
+		for (const orphan of pending) {
+			if (orphan.surfaceId && orphan.workspaceId) {
+				const result = await pi
+					.exec(
+						"cmux",
+						[
+							"--json",
+							"--id-format",
+							"both",
+							"rpc",
+							"surface.close",
+							JSON.stringify({ workspace_id: orphan.workspaceId, surface_id: orphan.surfaceId }),
+						],
+						{ timeout: 2500 },
+					)
+					.catch(() => ({ stdout: "", stderr: "close failed", code: 1, killed: false }));
+				const closed =
+					(result.code === 0 && !result.killed) ||
+					/not found|unknown surface|no such/i.test(`${result.stderr}\n${result.stdout}`);
+				if (!closed) {
+					orphans.push(orphan);
+					continue;
+				}
+			}
+			// Known-closed or never had a surface id after ambiguous open: drop directory only when closed/absent.
+			// Ambiguous no-id orphans stay on disk; keep tracking so we do not open more without awareness.
+			if (orphan.surfaceId) {
+				await rm(orphan.directory, { recursive: true, force: true }).catch(() => undefined);
+			} else {
+				orphans.push(orphan);
+			}
+		}
+	};
+	const makeDashboard = () =>
+		createCmuxDashboard({
+			exec: (command, args, options) => pi.exec(command, args, options),
+			canOpen: () => orphans.length === 0,
+			notify: (message) => {
+				try {
+					failureNotify?.(message);
+				} catch {
+					// ignore
+				}
+			},
+		});
+	let dashboard: CmuxDashboard = makeDashboard();
+	let unsubscribeDashboard = runtime.subscribe((snapshot) => {
+		dashboard.onSnapshot(snapshot);
+	});
+	const replaceDashboard = async () => {
+		unsubscribeDashboard();
+		const leftover = await dashboard.shutdown();
+		orphans.push(...leftover);
+		await retryOrphans();
+		dashboard = makeDashboard();
+		unsubscribeDashboard = runtime.subscribe((snapshot) => {
+			dashboard.onSnapshot(snapshot);
+		});
+	};
 	const fingerprints = new Map<string, string>();
-	const runtimeWarnings = new Set<string>();
-	let nextThreadId = 1;
 	const rowState = createToolRowStateStore(pi, "subagent.tool-row-state");
 	const warn = (discovery: AgentDiscovery, ctx: ExtensionContext) => {
 		const current = new Set<string>();
@@ -79,25 +122,23 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		}
 		for (const path of fingerprints.keys()) if (!current.has(path)) fingerprints.delete(path);
 	};
-	const disposeThreads = async () => {
-		const retained = [...threads.values()];
-		threads.clear();
-		await Promise.all(retained.map((thread) => disposeSubagentThread(thread)));
+	const parentVisibleAgents = async (ctx: ExtensionContext, discovery: AgentDiscovery) => {
+		const sync = (await loadTauExtensionSettings(ctx, contextSettings)).sync;
+		const parentVisible = sync.enabled && sync.automation;
+		return [...discovery.agents.values()]
+			.filter((agent) => agent.name !== "context-sync" || parentVisible)
+			.sort((a, b) => a.name.localeCompare(b.name));
 	};
+
 	pi.on("before_agent_start", async (event, ctx) => {
 		if (!pi.getActiveTools().includes("subagent")) return undefined;
 		const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
 		warn(discovery, ctx);
-		const lines = [...discovery.agents.values()]
-			.sort((a, b) => a.name.localeCompare(b.name))
-			.map((agent) => `- ${agent.name}: ${agent.description}`);
-		const activeThreads = [...threads.values()]
-			.filter((thread) => thread.cwd === ctx.cwd)
-			.sort((a, b) => a.id.localeCompare(b.id))
-			.map((thread) => {
-				const task = thread.initialTask.replace(/\s+/g, " ").trim();
-				return `- ${thread.id} (${thread.definition.name}): ${task.length <= 160 ? task : `${task.slice(0, 159)}…`}`;
-			});
+		const lines = (await parentVisibleAgents(ctx, discovery)).map((agent) => `- ${agent.name}: ${agent.description}`);
+		const activeThreads = runtime.listThreads(ctx.cwd).map((thread) => {
+			const task = thread.initialTask.replace(/\s+/g, " ").trim();
+			return `- ${thread.id} (${thread.displayName} · ${thread.definition.name}): ${task.length <= 160 ? task : `${task.slice(0, 159)}…`}`;
+		});
 		const threadSection = activeThreads.length ? `\n\nActive reusable threads:\n${activeThreads.join("\n")}` : "";
 		const prompt = `## Subagents
 Use \`subagent\` when an available agent matches a focused part of the task.
@@ -107,6 +148,8 @@ ${lines.join("\n")}
 
 Start a fresh thread with \`agent\` and \`task\`. Continue an existing thread with \`thread\` and \`task\`. Reuse a thread when feedback or follow-up work depends on its prior reads and reasoning. Start fresh for unrelated work or when its context is stale or oversized.${threadSection}
 
+Pass \`files\` when exact relevant files are already known. Tau autoreads current line-numbered snapshots into that child turn before it starts.
+
 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.`;
 		return { systemPrompt: `${event.systemPrompt}\n\n${prompt}` };
 	});
@@ -115,182 +158,82 @@ Delegate one focused task per call. Children do not inherit parent messages. Inc
 			name: "subagent",
 			label: "Subagent",
 			description:
-				"Start a focused isolated child agent or continue a retained child thread. Output is limited to 50KB or 2,000 lines.",
+				"Start a focused isolated child agent or continue a retained child thread. Known files can be autoread into the child turn. Output is limited to 50KB or 2,000 lines.",
 			promptSnippet: "Start a focused child agent or continue a retained child thread",
 			parameters: params,
 			executionMode: "parallel",
 			async execute(_id, raw, signal, onUpdate, ctx) {
 				const task = raw.task.trim();
+				const files = [...new Set((raw.files ?? []).map((path) => path.trim()))];
 				const continuing = "thread" in raw;
 				const parentModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable";
 				const parentThinking = pi.getThinkingLevel();
-				let thread: SubagentThread | undefined;
-				let definition: AgentDefinition | undefined;
-				let agent = continuing ? raw.thread.trim() : raw.agent.trim();
-				let threadId = continuing ? raw.thread.trim() : undefined;
-				if (!task || !agent) {
+				const agent = continuing ? raw.thread.trim() : raw.agent.trim();
+				const threadKey = continuing ? raw.thread.trim() : undefined;
+
+				failureNotify = (message) => {
+					ctx.ui.notify(message, "warning");
+				};
+				dashboard.setInteractive(ctx.mode === "tui" && ctx.hasUI);
+
+				if (!task || !agent || files.some((path) => !path)) {
 					const error = continuing
-						? "Subagent continuation requires non-empty thread and task"
-						: "Subagent input requires non-empty agent and task";
-					return {
-						content: [{ type: "text", text: error }],
-						details: emptyDetails(agent, task, "failed", "queue", parentModel, parentThinking, threadId, error),
-					};
-				}
-				if (continuing) {
-					thread = threads.get(agent);
-					if (!thread || thread.cwd !== ctx.cwd) {
-						const names =
-							[...threads.values()]
-								.filter((item) => item.cwd === ctx.cwd)
-								.map((item) => item.id)
-								.sort()
-								.join(", ") || "none";
-						const error = `Subagent thread ${agent} is unavailable. Active threads: ${names}`;
-						return {
-							content: [{ type: "text", text: error }],
-							details: emptyDetails(
-								agent,
-								task,
-								"failed",
-								"discovery",
-								parentModel,
-								parentThinking,
-								agent,
-								error,
-							),
-						};
-					}
-					agent = thread.definition.name;
-					threadId = thread.id;
-					definition = thread.definition;
-				} else {
-					const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
-					warn(discovery, ctx);
-					definition = discovery.agents.get(agent);
-					const invalid = discovery.invalid.get(agent);
-					if (!definition) {
-						const reason = invalid?.map((item) => item.reason).join("; ") ?? "unknown agent";
-						const names = [...discovery.agents.keys()].sort().join(", ") || "none";
-						const error = `Agent ${agent} discovery failed: ${reason}. Runnable agents: ${names}`;
-						return {
-							content: [{ type: "text", text: error }],
-							details: emptyDetails(
-								agent,
-								task,
-								"failed",
-								"discovery",
-								parentModel,
-								parentThinking,
-								undefined,
-								error,
-							),
-						};
-					}
-					threadId = `thread-${nextThreadId++}`;
+						? "Subagent continuation requires non-empty thread, task, and file paths"
+						: "Subagent input requires non-empty agent, task, and file paths";
+					return failedToolResult(agent, task, "queue", parentModel, parentThinking, error, threadKey);
 				}
-				const controller = new AbortController();
-				controllers.add(controller);
-				const combined = AbortSignal.any([controller.signal, ...(signal ? [signal] : [])]);
-				let releaseThread: (() => void) | undefined;
-				let releaseGlobal: (() => void) | undefined;
-				let reservedThread: SubagentThread | undefined;
-				let phase: "queue" | "startup" = "queue";
-				try {
-					const waiting = emptyDetails(
-						agent,
-						task,
-						"waiting",
-						"queue",
-						thread?.model ?? parentModel,
-						thread?.thinkingLevel ?? parentThinking,
-						threadId,
-						undefined,
-					);
-					await onUpdate?.({ content: [{ type: "text", text: `${agent}: waiting` }], details: waiting });
-					if (thread) {
-						reservedThread = thread;
-						thread.pendingTurns += 1;
-						releaseThread = await thread.turnGate.acquire(combined);
-					}
-					releaseGlobal = await gate.acquire(combined);
-					if (!thread) {
-						phase = "startup";
-						if (!threadId || !definition) throw new Error("Subagent startup state is incomplete");
-						const selectedDefinition = definition;
-						if (threads.size >= MAX_RETAINED_THREADS) {
-							const evicted = [...threads.values()]
-								.filter((item) => item.pendingTurns === 0)
-								.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
-							if (!evicted) throw new Error("Subagent thread limit reached while all retained threads are busy");
-							threads.delete(evicted.id);
-							await disposeSubagentThread(evicted);
+
+				return runtime.execute({
+					agent,
+					task,
+					files,
+					continuing,
+					threadKey,
+					ctx,
+					parentModel,
+					parentThinking,
+					signal,
+					onUpdate: (details) =>
+						onUpdate?.({
+							content: [
+								{
+									type: "text",
+									text: details.currentActivity ?? details.response ?? `${details.agent}: ${details.status}`,
+								},
+							],
+							details,
+						}),
+					resolveFreshDefinition: async () => {
+						const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
+						warn(discovery, ctx);
+						const definition = discovery.agents.get(agent);
+						const invalid = discovery.invalid.get(agent);
+						if (!definition) {
+							const reason = invalid?.map((item) => item.reason).join("; ") ?? "unknown agent";
+							const names =
+								(await parentVisibleAgents(ctx, discovery)).map((item) => item.name).join(", ") || "none";
+							return {
+								ok: false,
+								phase: "discovery",
+								error: `Agent ${agent} discovery failed: ${reason}. Runnable agents: ${names}`,
+							};
 						}
-						thread = await createSubagentThread({
-							id: threadId,
-							definition: selectedDefinition,
-							extensionPaths: extensionPathsForTools(pi, selectedDefinition.tools),
-							initialTask: task,
-							ctx,
-							thinkingLevel: parentThinking,
-							signal: combined,
-							onWarning: (warning) => {
-								const message = `Subagent definition ${selectedDefinition.path}: ${warning}`;
-								if (runtimeWarnings.has(message)) return;
-								runtimeWarnings.add(message);
-								ctx.ui.notify(message, "warning");
-							},
-						});
-						threads.set(thread.id, thread);
-						reservedThread = thread;
-						thread.pendingTurns += 1;
-					}
-					if (!thread) throw new Error("Subagent thread startup failed");
-					const result = await runSubagentTurn({
-						thread,
-						task,
-						initial: thread.turns === 0,
-						signal: combined,
-						onUpdate: (details) =>
-							onUpdate?.({
-								content: [
-									{
-										type: "text",
-										text: details.currentActivity ?? details.response ?? `${agent}: ${details.status}`,
-									},
-								],
-								details,
-							}),
-					});
-					return {
-						content: [
-							{
-								type: "text",
-								text: `Thread: ${thread.id}\nReuse with subagent({ thread: "${thread.id}", task: "..." })\n\n${result.content}`,
-							},
-						],
-						details: result.details,
-					};
-				} catch (error) {
-					const message = error instanceof Error ? error.message : `Agent ${agent} ${phase} failed`;
-					const status = combined.aborted ? "aborted" : "failed";
-					const details = emptyDetails(
-						agent,
-						task,
-						status,
-						phase,
-						thread?.model ?? parentModel,
-						thread?.thinkingLevel ?? parentThinking,
-						thread?.id ?? threadId,
-						message,
-					);
-					return { content: [{ type: "text", text: message }], details };
-				} finally {
-					if (reservedThread) reservedThread.pendingTurns -= 1;
-					releaseGlobal?.();
-					releaseThread?.();
-					controllers.delete(controller);
-				}
+						if (definition.name === "context-sync") {
+							const sync = (await loadTauExtensionSettings(ctx, contextSettings)).sync;
+							if (!sync.enabled) {
+								return { ok: false, phase: "discovery", error: "Context sync is disabled in settings." };
+							}
+							if (!sync.automation) {
+								return {
+									ok: false,
+									phase: "discovery",
+									error: "Context-sync automation is disabled. Use /context-sync or enable extensions.context.sync.automation.",
+								};
+							}
+						}
+						return { ok: true, definition };
+					},
+				});
 			},
 			renderCall(args, theme, context) {
 				return renderSubagentCall(args, theme, {
@@ -318,16 +261,20 @@ Delegate one focused task per call. Children do not inherit parent messages. Inc
 		if (details?.status === "failed" || details?.status === "aborted") return { isError: true };
 	});
 	pi.on("session_start", async () => {
-		for (const controller of controllers) controller.abort();
-		controllers.clear();
-		await disposeThreads();
-		nextThreadId = 1;
+		await runtime.reset();
+		await replaceDashboard();
 		rowState.clear();
-		runtimeWarnings.clear();
+		fingerprints.clear();
+		failureNotify = undefined;
 	});
 	pi.on("session_shutdown", async () => {
-		for (const controller of controllers) controller.abort();
-		controllers.clear();
-		await disposeThreads();
+		unsubscribeDashboard();
+		await runtime.shutdown();
+		const leftover = await dashboard.shutdown();
+		orphans.push(...leftover);
+		await retryOrphans();
+		rowState.clear();
+		fingerprints.clear();
+		failureNotify = undefined;
 	});
 }

package/extensions/subagent/render.ts

@@ -47,7 +47,7 @@ export function renderSubagentResult(
 		text.setText("");
 		return text;
 	}
-	const identity = details.threadId ? `${details.agent} · ${details.threadId}` : details.agent;
+	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`)}`;
 	if (!expanded) {
 		text.setText(`${header}  ${theme.fg("muted", details.task.replace(/\s+/g, " ").trim())}`);

package/extensions/subagent/resume.ts

@@ -0,0 +1,78 @@
+import type { AgentDefinition } from "./agents.ts";
+
+const RESUME_OPTIONAL_HISTORY_TOKENS = 20_000;
+
+export type RetainedTurnOutcome = "completed" | "failed" | "aborted";
+
+export interface RetainedTurnRecord {
+	task: string;
+	outcome: RetainedTurnOutcome;
+	terminalText: string;
+	files: readonly string[];
+}
+
+export interface SubagentResumeState {
+	records: readonly RetainedTurnRecord[];
+	relevantPaths: readonly string[];
+}
+
+export function emptySubagentResumeState(): SubagentResumeState {
+	return { records: [], relevantPaths: [] };
+}
+
+export function retainSubagentTurn(state: SubagentResumeState, record: RetainedTurnRecord): SubagentResumeState {
+	const paths = new Set(state.relevantPaths);
+	for (const path of record.files) paths.add(path);
+	return {
+		records: [...state.records, { ...record, files: [...record.files] }],
+		relevantPaths: [...paths],
+	};
+}
+
+export function selectRetainedTurns(
+	state: SubagentResumeState,
+	optionalTokenBudget = RESUME_OPTIONAL_HISTORY_TOKENS,
+): { records: readonly RetainedTurnRecord[]; omitted: number } {
+	const initial = state.records[0];
+	if (!initial) return { records: [], omitted: 0 };
+	let used = 0;
+	const selectedIndexes = new Set<number>();
+	for (let index = state.records.length - 1; index >= 1; index -= 1) {
+		const record = state.records[index];
+		if (!record) continue;
+		const tokens = Math.ceil(JSON.stringify(record).length / 4);
+		if (used + tokens > optionalTokenBudget) continue;
+		used += tokens;
+		selectedIndexes.add(index);
+	}
+	return {
+		records: [initial, ...state.records.slice(1).filter((_record, index) => selectedIndexes.has(index + 1))],
+		omitted: state.records.length - 1 - selectedIndexes.size,
+	};
+}
+
+export function buildColdResumePrompt(options: {
+	definition: AgentDefinition;
+	state: SubagentResumeState;
+	followUp: string;
+	hasAutoreadFiles: boolean;
+}): string {
+	const selected = selectRetainedTurns(options.state);
+	const data = JSON.stringify({
+		version: 1,
+		retainedTurns: selected.records,
+		omittedRetainedTurns: selected.omitted,
+		relevantPaths: options.state.relevantPaths,
+		parentFollowUp: options.followUp,
+	});
+	return `You are an isolated delegated child agent resuming prior delegated work. Stay within the delegated task and return only the requested result.${options.hasAutoreadFiles ? " Parent-supplied autoread files are included as line-numbered context for this turn." : ""}
+
+## Agent instructions
+${options.definition.prompt}
+
+The JSON object between the fixed markers is prior work data. Its retained terminal text is exact. Earlier file contents, tool calls, tool results, intermediate responses, and thinking are absent. Relevant paths are a manifest only; read current source before relying on it.
+
+<tau-subagent-resume-json>
+${data}
+</tau-subagent-resume-json>`;
+}