@shanepadgett/tau-agent 0.42.3 → 0.44.0

package/extensions/subagent/index.ts

@@ -1,425 +0,0 @@
-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 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.Object(
-	{
-		agent: Type.Optional(
-			Type.String({
-				minLength: 1,
-				description: "Fresh agent name. Pass agent or thread, never both.",
-			}),
-		),
-		thread: Type.Optional(
-			Type.String({
-				minLength: 1,
-				description: "Retained thread id. Pass thread or agent, never both.",
-			}),
-		),
-		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 },
-);
-
-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 () => {
-		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 rowState = createToolRowStateStore(pi, "subagent.tool-row-state");
-	const warn = (discovery: AgentDiscovery, ctx: ExtensionContext) => {
-		const current = new Set<string>();
-		const grouped = new Map<string, string[]>();
-		for (const diagnostic of discovery.diagnostics) {
-			const reasons = grouped.get(diagnostic.path) ?? [];
-			reasons.push(diagnostic.reason);
-			grouped.set(diagnostic.path, reasons);
-		}
-		for (const [path, reasons] of grouped) {
-			current.add(path);
-			const fingerprint = [...reasons].sort().join("\0");
-			if (fingerprints.get(path) !== fingerprint)
-				ctx.ui.notify(`Invalid subagent definition ${path}: ${reasons.join("; ").slice(0, 500)}`, "warning");
-			fingerprints.set(path, fingerprint);
-		}
-		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, 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) => !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;
-		const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
-		warn(discovery, ctx);
-		const agents = await parentVisibleAgents(ctx, discovery);
-		const lines = agents.map((agent) => `- ${agent.name}: ${agent.description}`);
-		const scoutGuidance = agents.some((agent) => agent.name === "scout")
-			? "\n\nScout 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. Do not send code review, diagnosis, design, or other judgment work to scout."
-			: "";
-		const prompt = `## Subagents
-Use \`subagent\` only when an available agent's listed purpose matches the delegated work. Stay inside that purpose. Off-purpose calls are denied — for example, do not send code review to a lookup-only agent.
-
-Available agents for this turn:
-${lines.join("\n") || "none"}
-
-Start a fresh thread with \`agent\` and \`task\`. Continue an existing thread with \`thread\` and \`task\`. Pass exactly one of \`agent\` or \`thread\`, never both and never neither. 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.
-
-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.${scoutGuidance}`;
-		return { systemPrompt: `${event.systemPrompt}\n\n${prompt}` };
-	});
-	const resolveFreshSubagentDefinition = async (ctx: ExtensionContext, agent: string) => {
-		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 as const,
-				phase: "discovery" as const,
-				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 as const,
-				phase: "discovery" as const,
-				error: `Agent ${definition.name} is disabled ${source}.`,
-			};
-		}
-		if (definition.name === "context-sync") {
-			const sync = (await loadTauExtensionSettings(ctx, contextSettings)).sync;
-			if (!sync.enabled) {
-				return { ok: false as const, phase: "discovery" as const, error: "Context sync is disabled in settings." };
-			}
-			if (!sync.automation) {
-				return {
-					ok: false as const,
-					phase: "discovery" as const,
-					error: "Context-sync automation is disabled. Use /context-sync or enable extensions.context.sync.automation.",
-				};
-			}
-		}
-		return { ok: true as const, definition };
-	};
-
-	const disabledContinuationResult = async (
-		ctx: ExtensionContext,
-		threadKey: string | undefined,
-		task: string,
-		parentModel: string,
-		parentThinking: ReturnType<ExtensionAPI["getThinkingLevel"]>,
-	) => {
-		const thread = runtime.listThreads(ctx.cwd).find((item) => item.id === threadKey);
-		if (!thread) return undefined;
-		const disabled = await disabledAgentNames(ctx);
-		if (!disabled.effective.has(thread.definition.name)) return undefined;
-		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,
-		);
-	};
-
-	pi.registerTool(
-		defineTool<typeof params, SubagentDetails>({
-			name: "subagent",
-			label: "Subagent",
-			description:
-				"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 agentName = raw.agent?.trim() || undefined;
-				const threadKey = raw.thread?.trim() || undefined;
-				const parentModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable";
-				const parentThinking = pi.getThinkingLevel();
-
-				failureNotify = (message) => {
-					ctx.ui.notify(message, "warning");
-				};
-				dashboard.setInteractive(ctx.mode === "tui" && ctx.hasUI);
-
-				const failQueue = (agent: string, error: string, thread?: string) =>
-					failedToolResult(agent, task, "queue", parentModel, parentThinking, error, thread);
-
-				if (!task || files.some((path) => !path)) {
-					return failQueue(
-						agentName ?? threadKey ?? "",
-						threadKey !== undefined
-							? "Subagent continuation requires non-empty thread, task, and file paths"
-							: "Subagent input requires non-empty agent, task, and file paths",
-						threadKey,
-					);
-				}
-				if (agentName !== undefined && threadKey !== undefined) {
-					return failQueue(
-						agentName,
-						"Subagent input requires exactly one of agent or thread, not both",
-						threadKey,
-					);
-				}
-
-				const onUpdateDetails = (details: SubagentDetails) =>
-					onUpdate?.({
-						content: [
-							{
-								type: "text",
-								text: details.currentActivity ?? details.response ?? `${details.agent}: ${details.status}`,
-							},
-						],
-						details,
-					});
-
-				if (threadKey !== undefined) {
-					const disabledContinuation = await disabledContinuationResult(
-						ctx,
-						threadKey,
-						task,
-						parentModel,
-						parentThinking,
-					);
-					if (disabledContinuation) return disabledContinuation;
-					return runtime.execute({
-						agent: threadKey,
-						task,
-						files,
-						continuing: true,
-						threadKey,
-						ctx,
-						parentModel,
-						parentThinking,
-						signal,
-						onUpdate: onUpdateDetails,
-						resolveFreshDefinition: () => resolveFreshSubagentDefinition(ctx, threadKey),
-					});
-				}
-
-				if (agentName === undefined) {
-					return failQueue("", "Subagent input requires exactly one of agent or thread");
-				}
-
-				return runtime.execute({
-					agent: agentName,
-					task,
-					files,
-					continuing: false,
-					ctx,
-					parentModel,
-					parentThinking,
-					signal,
-					onUpdate: onUpdateDetails,
-					resolveFreshDefinition: () => resolveFreshSubagentDefinition(ctx, agentName),
-				});
-			},
-			renderCall(args, theme, context) {
-				return renderSubagentCall(args, theme, {
-					executionStarted: context.executionStarted,
-					isPartial: context.isPartial,
-					lastComponent: context.lastComponent,
-					rowState,
-					rowId: context.toolCallId,
-					invalidate: context.invalidate,
-				});
-			},
-			renderResult(result, options, theme, context) {
-				return renderSubagentResult(result, options.expanded, theme, {
-					lastComponent: context.lastComponent,
-					rowState,
-					rowId: context.toolCallId,
-					invalidate: context.invalidate,
-				});
-			},
-		}),
-	);
-	pi.on("tool_result", (event) => {
-		if (event.toolName !== "subagent") return;
-		const details = event.details as SubagentDetails | undefined;
-		if (details?.status === "failed" || details?.status === "aborted") return { isError: true };
-	});
-	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();
-		const leftover = await dashboard.shutdown();
-		orphans.push(...leftover);
-		await retryOrphans();
-		rowState.clear();
-		fingerprints.clear();
-		failureNotify = undefined;
-		sessionDisabled.clear();
-	});
-}

package/extensions/subagent/panel.ts

@@ -1,124 +0,0 @@
-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

@@ -1,74 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Text, type Component } from "@earendil-works/pi-tui";
-import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
-import type { SubagentDetails } from "./run.ts";
-
-const cap = (text: string | undefined, length = 240) =>
-	!text ? "" : text.length <= length ? text : `${text.slice(0, length - 1)}…`;
-const component = (last: unknown) => (last as Text | undefined) ?? new Text("", 0, 0);
-const title = (theme: Theme, rowState: ToolRowStateStore, rowId: string, invalidate: () => void) => {
-	rowState.watch(rowId, invalidate);
-	return formatToolRowTitle(rowState, rowId, "subagent", theme);
-};
-
-export function renderSubagentCall(
-	args: { agent?: string; thread?: string; task?: string },
-	theme: Theme,
-	context: {
-		executionStarted: boolean;
-		isPartial: boolean;
-		lastComponent?: unknown;
-		rowState: ToolRowStateStore;
-		rowId: string;
-		invalidate: () => void;
-	},
-): Component {
-	const text = component(context.lastComponent);
-	if (context.executionStarted || !context.isPartial) {
-		text.setText("");
-		return text;
-	}
-	const prefix =
-		`${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", args.agent ?? args.thread ?? "")}`.trimEnd();
-	const task = args.task?.replace(/\s+/g, " ").trim();
-	text.setText(task ? `${prefix}  ${theme.fg("muted", task)}` : prefix);
-	return text;
-}
-
-export function renderSubagentResult(
-	result: { details?: SubagentDetails },
-	expanded: boolean,
-	theme: Theme,
-	context: { lastComponent?: unknown; rowState: ToolRowStateStore; rowId: string; invalidate: () => void },
-): Component {
-	const text = component(context.lastComponent);
-	const details = result.details;
-	if (!details) {
-		text.setText("");
-		return text;
-	}
-	const identity = `${details.displayName} (${details.agent})`;
-	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;
-	}
-	const lines = [header, theme.fg("muted", `Task: ${cap(details.task, 1000)}`)];
-	for (const action of details.actions)
-		lines.push(theme.fg(action.error ? "error" : "dim", `${action.error ? "!" : "·"} ${cap(action.summary)}`));
-	if (details.response) lines.push(theme.fg("toolOutput", details.response));
-	if (details.error) lines.push(theme.fg("error", cap(details.error, 1000)));
-	lines.push(theme.fg("muted", `Model: ${details.model} · thinking: ${details.thinkingLevel}`));
-	lines.push(
-		theme.fg(
-			"muted",
-			`Tokens: ${details.usage.input} in, ${details.usage.output} out, ${details.usage.cacheRead} cache read, ${details.usage.cacheWrite} cache write · ${details.usage.turns} turns`,
-		),
-	);
-	if (details.omittedActions)
-		lines.push(theme.fg("muted", `${details.omittedActions} actions omitted (${details.omittedErrors} errors)`));
-	if (details.truncation?.path) lines.push(theme.fg("warning", `Full output: ${details.truncation.path}`));
-	text.setText(lines.join("\n"));
-	return text;
-}

package/extensions/subagent/resume.ts

@@ -1,78 +0,0 @@
-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],
-	};
-}
-
-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>`;
-}