@shanepadgett/tau-agent 0.15.0 → 0.17.0

package/extensions/subagent/run.ts

@@ -1,44 +1,30 @@
-import { mkdtemp, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { join, resolve } from "node:path";
+import type { AssistantMessage, Usage } from "@earendil-works/pi-ai";
 import {
-	createAgentSession,
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
-	DefaultResourceLoader,
 	formatSize,
-	getAgentDir,
-	SessionManager,
 	truncateHead,
-	type AgentSession,
 	type AgentSessionEvent,
 	type ExtensionAPI,
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { createCompleteFileMeta } from "../explore/full-file-knowledge.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";
 
 const PREVIEW_LIMIT = 600;
 const VALUE_LIMIT = 180;
-
-const CHILD_UI_BLOCKED_METHODS = new Set([
-	"setEditorComponent",
-	"setFooter",
-	"setStatus",
-	"setTitle",
-	"setWidget",
-	"setWorkingIndicator",
-]);
-
-function childUiContext(ui: ExtensionContext["ui"]): ExtensionContext["ui"] {
-	return new Proxy(ui, {
-		get(target, property, receiver) {
-			if (typeof property === "string" && CHILD_UI_BLOCKED_METHODS.has(property)) return () => undefined;
-			const value = Reflect.get(target, property, receiver) as unknown;
-			return typeof value === "function" ? value.bind(target) : value;
-		},
-	});
-}
+const AUTOREAD_MESSAGE_TYPE = "tau.autoread";
 
 export interface SubagentAction {
 	tool: string;
@@ -53,11 +39,17 @@ export interface SubagentUsage {
 	cost: number;
 	turns: number;
 }
+
+export type SubagentLifecycle = "waiting" | "starting" | "running" | "completed" | "failed" | "aborted";
+export type SubagentPhase = "discovery" | "queue" | "startup" | "run" | "output";
+
 export interface SubagentDetails {
 	agent: string;
+	displayName: string;
 	threadId?: string;
-	status: "waiting" | "running" | "completed" | "failed" | "aborted";
-	phase: "discovery" | "queue" | "startup" | "run" | "output";
+	invocationId?: string;
+	status: SubagentLifecycle;
+	phase: SubagentPhase;
 	completionState?: string;
 	task: string;
 	model: string;
@@ -81,14 +73,24 @@ export interface SubagentDetails {
 	};
 }
 
+/** Immutable observer payload. Distinct invocation IDs for queued turns of one thread. */
+export interface SubagentInvocationSnapshot extends SubagentDetails {
+	invocationId: string;
+	startedAt: number;
+}
+
 export interface SubagentThread {
 	id: string;
+	displayName: string;
 	definition: AgentDefinition;
-	session: AgentSession;
+	sessionInputs: SubagentSessionInputs;
+	resource: SubagentSessionResource;
 	cwd: string;
 	model: string;
 	thinkingLevel: string;
 	initialTask: string;
+	resumeState: SubagentResumeState;
+	lastAssistantMessageAt: number | undefined;
 	turns: number;
 	turnGate: FifoGate;
 	pendingTurns: number;
@@ -162,6 +164,18 @@ function capped(value: unknown, limit = VALUE_LIMIT): string {
 	return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
 }
 
+/** Rolling tail so live previews keep changing after the limit. */
+export function cappedTail(value: unknown, limit = PREVIEW_LIMIT): string {
+	let text: string;
+	try {
+		text = typeof value === "string" ? value : (JSON.stringify(value) ?? String(value));
+	} catch {
+		text = "[unavailable]";
+	}
+	if (text.length <= limit) return text;
+	return `…${text.slice(-(limit - 1))}`;
+}
+
 function textOf(message: AssistantMessage): string {
 	return message.content
 		.filter((part) => part.type === "text")
@@ -169,8 +183,17 @@ function textOf(message: AssistantMessage): string {
 		.join("");
 }
 
+function cloneSnapshot(details: SubagentDetails): SubagentDetails {
+	return structuredClone(details);
+}
+
+export function cloneInvocationSnapshot(snapshot: SubagentInvocationSnapshot): SubagentInvocationSnapshot {
+	return structuredClone(snapshot);
+}
+
 export async function createSubagentThread(options: {
 	id: string;
+	displayName: string;
 	definition: AgentDefinition;
 	extensionPaths: readonly string[];
 	initialTask: string;
@@ -181,6 +204,7 @@ export async function createSubagentThread(options: {
 }): Promise<SubagentThread> {
 	const {
 		id,
+		displayName,
 		definition,
 		extensionPaths,
 		initialTask,
@@ -189,104 +213,76 @@ export async function createSubagentThread(options: {
 		signal,
 		onWarning,
 	} = options;
-	let model = ctx.model;
-	let thinkingLevel = parentThinkingLevel;
-	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;
-		}
-	}
-	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;
-	}
-	const modelName = model ? `${model.provider}/${model.id}` : "unavailable";
-	let session: AgentSession | undefined;
+	const sessionInputs = await resolveSubagentSessionInputs({
+		definition,
+		extensionPaths,
+		ctx,
+		parentThinkingLevel,
+		signal,
+		...(onWarning === undefined ? {} : { onWarning }),
+	});
+	const resource = await createSubagentSessionResource(sessionInputs, signal);
 	try {
-		if (!model) throw new Error(`Agent ${definition.name} startup failed: parent has no model`);
-		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!auth.ok) throw new Error(`Agent ${definition.name} startup failed: ${auth.error}`);
-		if (signal.aborted) throw new Error(`Agent ${definition.name} startup aborted`);
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: ctx.cwd,
-			agentDir: getAgentDir(),
-			noExtensions: true,
-			additionalExtensionPaths: [...extensionPaths],
-		});
-		await resourceLoader.reload();
-		const created = await createAgentSession({
-			cwd: ctx.cwd,
-			model,
-			thinkingLevel: thinkingLevel as "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max",
-			tools: definition.tools,
-			excludeTools: ["subagent"],
-			resourceLoader,
-			sessionManager: SessionManager.inMemory(ctx.cwd),
-		});
-		session = created.session;
-		await session.bindExtensions(
-			ctx.mode === "tui" && ctx.hasUI ? { mode: "tui", uiContext: childUiContext(ctx.ui) } : { mode: "print" },
-		);
-		const active = session.getActiveToolNames().sort();
-		const expected = [...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 ${definition.name} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
-			);
-		}
 		return {
 			id,
+			displayName,
 			definition,
-			session,
+			sessionInputs,
+			resource,
 			cwd: ctx.cwd,
-			model: modelName,
-			thinkingLevel,
+			model: sessionInputs.modelName,
+			thinkingLevel: sessionInputs.thinkingLevel,
 			initialTask,
+			resumeState: emptySubagentResumeState(),
+			lastAssistantMessageAt: undefined,
 			turns: 0,
 			turnGate: new FifoGate(1),
 			pendingTurns: 0,
 			lastUsedAt: Date.now(),
 		};
 	} catch (error) {
-		if (session?.isStreaming) await session.abort().catch(() => undefined);
-		session?.dispose();
+		await resource.dispose();
 		throw error;
 	}
 }
 
 export async function disposeSubagentThread(thread: SubagentThread): Promise<void> {
-	if (thread.session.isStreaming) await thread.session.abort().catch(() => undefined);
-	thread.session.dispose();
+	await thread.resource.dispose();
 }
 
 export async function runSubagentTurn(options: {
 	thread: SubagentThread;
 	task: string;
+	files?: readonly string[];
+	invocationId?: string;
 	initial: boolean;
+	resumePrompt?: string;
 	signal: AbortSignal;
 	onUpdate?: (details: SubagentDetails) => void | Promise<void>;
-}): Promise<{ content: string; details: SubagentDetails }> {
-	const { thread, task, initial, signal, onUpdate } = options;
-	const { definition, session } = thread;
+}): Promise<{
+	content: string;
+	details: SubagentDetails;
+	retainable: boolean;
+	terminalOutcome: RetainedTurnOutcome;
+	assistantMessageEndAt: readonly number[];
+	usage?: Usage;
+}> {
+	const { thread, task, files = [], invocationId = thread.id, initial, resumePrompt, signal, onUpdate } = options;
+	const { definition } = thread;
+	const { session } = thread.resource;
 	const started = Date.now();
 	const usage: SubagentUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+	const toolUsage: Usage = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
 	const details: SubagentDetails = {
 		agent: definition.name,
+		displayName: thread.displayName,
 		threadId: thread.id,
 		status: "running",
 		phase: "run",
@@ -301,26 +297,67 @@ export async function runSubagentTurn(options: {
 		durationMs: 0,
 	};
 	let unsubscribe: (() => void) | undefined;
-	let updateChain = Promise.resolve();
 	let lastTextUpdate = 0;
 	const turnMessages: AssistantMessage[] = [];
+	const assistantMessageEndAt: number[] = [];
+	let retainable = false;
 	const publish = (force = false) => {
 		const now = Date.now();
 		if (!force && now - lastTextUpdate < 100) return;
 		lastTextUpdate = now;
 		details.durationMs = now - started;
-		const snapshot = structuredClone(details);
+		const snapshot = cloneSnapshot(details);
 		snapshot.actions = snapshot.actions.slice(-5);
-		updateChain = updateChain.then(() => onUpdate?.(snapshot)).catch(() => undefined);
+		// Detached observer chain — must not delay prompt completion.
+		void Promise.resolve()
+			.then(() => onUpdate?.(snapshot))
+			.catch(() => undefined);
 	};
 	try {
+		if (signal.aborted) {
+			details.status = "aborted";
+			details.error = "Subagent call aborted before prompt";
+			details.durationMs = Date.now() - started;
+			publish(true);
+			return {
+				content: details.error,
+				details,
+				retainable: false,
+				terminalOutcome: "aborted",
+				assistantMessageEndAt,
+			};
+		}
 		const actionById = new Map<string, string>();
 		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
 			if (event.type === "message_update" && event.message.role === "assistant") {
-				details.response = capped(textOf(event.message), PREVIEW_LIMIT);
+				details.response = cappedTail(textOf(event.message), PREVIEW_LIMIT);
 				publish();
 			} else if (event.type === "message_end" && event.message.role === "assistant") {
 				turnMessages.push(event.message);
+				assistantMessageEndAt.push(Date.now());
+				usage.input += event.message.usage.input;
+				usage.output += event.message.usage.output;
+				usage.cacheRead += event.message.usage.cacheRead;
+				usage.cacheWrite += event.message.usage.cacheWrite;
+				usage.cost += event.message.usage.cost.total;
+				usage.turns += 1;
+				toolUsage.input += event.message.usage.input;
+				toolUsage.output += event.message.usage.output;
+				toolUsage.cacheRead += event.message.usage.cacheRead;
+				toolUsage.cacheWrite += event.message.usage.cacheWrite;
+				toolUsage.totalTokens += event.message.usage.totalTokens;
+				toolUsage.cost.input += event.message.usage.cost.input;
+				toolUsage.cost.output += event.message.usage.cost.output;
+				toolUsage.cost.cacheRead += event.message.usage.cost.cacheRead;
+				toolUsage.cost.cacheWrite += event.message.usage.cost.cacheWrite;
+				toolUsage.cost.total += event.message.usage.cost.total;
+				if (event.message.usage.cacheWrite1h !== undefined)
+					toolUsage.cacheWrite1h = (toolUsage.cacheWrite1h ?? 0) + event.message.usage.cacheWrite1h;
+				if (event.message.usage.reasoning !== undefined)
+					toolUsage.reasoning = (toolUsage.reasoning ?? 0) + event.message.usage.reasoning;
+				details.response = cappedTail(textOf(event.message), PREVIEW_LIMIT);
+				details.currentActivity = undefined;
+				publish(true);
 			} else if (event.type === "tool_execution_start") {
 				details.toolCalls += 1;
 				const summary = `${event.toolName} ${capped(event.args)}`.trim();
@@ -345,27 +382,73 @@ export async function runSubagentTurn(options: {
 			}
 		});
 		const abort = () => {
-			void session?.abort();
+			void session.abort().catch(() => undefined);
 		};
 		signal.addEventListener("abort", abort, { once: true });
 		try {
+			const autoreadMessages = await Promise.all(
+				files.map(async (file, index) => {
+					const pathKey = resolve(thread.cwd, file);
+					const common = {
+						rowId: `${invocationId}:${index}`,
+						path: file,
+						cwd: thread.cwd,
+						source: "subagent",
+						batchId: invocationId,
+					};
+					try {
+						const bytes = await readFile(pathKey);
+						const content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+						const lines = content.split("\n");
+						const numbered = lines.map((line, lineIndex) => `${lineIndex + 1}: ${line}`).join("\n");
+						return {
+							customType: AUTOREAD_MESSAGE_TYPE,
+							content: `${file}\n${numbered}`,
+							display: false,
+							details: {
+								...common,
+								status: "read",
+								readCache: createCompleteFileMeta({
+									pathKey,
+									presentation: "line-numbered",
+									servedHash: createHash("sha256").update(bytes).digest("hex"),
+									mode: "baseline",
+									sourceText: content,
+									returnedText: `${file}\n${numbered}`,
+									totalLines: lines.length,
+									summary: `${lines.length} lines`,
+								}),
+							},
+						};
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						return {
+							customType: AUTOREAD_MESSAGE_TYPE,
+							content: `${file}\nAutoread failed: ${message}`,
+							display: false,
+							details: { ...common, status: "failed", error: message },
+						};
+					}
+				}),
+			);
+			if (signal.aborted) throw new Error("Subagent call aborted before prompt");
+			for (const message of autoreadMessages) {
+				if (signal.aborted) throw new Error("Subagent call aborted during autoread delivery");
+				await session.sendCustomMessage<unknown>(message, { deliverAs: "nextTurn" });
+			}
+			if (signal.aborted) throw new Error("Subagent call aborted before prompt");
 			await session.prompt(
-				initial
-					? `You are an isolated delegated child agent. Stay within the delegated task and return only the requested result.\n\n## Agent instructions\n${definition.prompt}\n\n## Delegated task\n${task}`
-					: `Continue the existing delegated work using the context already in this thread. Return only the requested result.\n\n## Parent follow-up\n${task}`,
+				resumePrompt ??
+					(initial
+						? `You are an isolated delegated child agent. Stay within the delegated task and return only the requested result.${files.length ? " Parent-supplied autoread files are included as line-numbered context for this turn." : ""}\n\n## Agent instructions\n${definition.prompt}\n\n## Delegated task\n${task}`
+						: `Continue the existing delegated work using the context already in this thread. Return only the requested result.${files.length ? " Parent-supplied autoread files are included as line-numbered context for this turn." : ""}\n\n## Parent follow-up\n${task}`),
 				{ expandPromptTemplates: false },
 			);
 		} finally {
 			signal.removeEventListener("abort", abort);
 		}
-		for (const message of turnMessages) {
-			usage.input += message.usage.input;
-			usage.output += message.usage.output;
-			usage.cacheRead += message.usage.cacheRead;
-			usage.cacheWrite += message.usage.cacheWrite;
-			usage.cost += message.usage.cost.total;
-			usage.turns += 1;
-		}
+		// Prompt returned without throw — session remains usable for retention decisions.
+		retainable = true;
 		const terminal = turnMessages.at(-1);
 		if (!terminal) throw new Error(`Agent ${definition.name} run failed: no terminal assistant response`);
 		const response = textOf(terminal);
@@ -406,21 +489,33 @@ export async function runSubagentTurn(options: {
 		}
 		details.durationMs = Date.now() - started;
 		publish(true);
-		await updateChain;
 		return {
 			content:
 				details.status === "completed"
 					? (details.response ?? "")
 					: (details.error ?? `Agent ${definition.name} failed`),
 			details,
+			retainable,
+			terminalOutcome:
+				details.status === "completed" ? "completed" : details.status === "aborted" ? "aborted" : "failed",
+			assistantMessageEndAt,
+			...(usage.turns === 0 ? {} : { usage: toolUsage }),
 		};
 	} catch (error) {
 		details.status = signal.aborted ? "aborted" : "failed";
 		details.error = capped(error instanceof Error ? error.message : "Subagent failed");
 		details.durationMs = Date.now() - started;
+		// Prompt/session failures leave the child unsafe for reuse.
+		retainable = false;
 		publish(true);
-		await updateChain;
-		return { content: details.error, details };
+		return {
+			content: details.error,
+			details,
+			retainable,
+			terminalOutcome: details.status === "aborted" ? "aborted" : "failed",
+			assistantMessageEndAt,
+			...(usage.turns === 0 ? {} : { usage: toolUsage }),
+		};
 	} finally {
 		unsubscribe?.();
 		thread.turns += 1;