pi-subagents 0.32.0 → 0.33.0

package/src/runs/background/notify.ts

@@ -1,10 +1,22 @@
 /**
  * Subagent completion notifications.
+ *
+ * Successful (completed) async results are held briefly and emitted as a
+ * single grouped message when sibling jobs finish within a short window (see
+ * `completion-batcher.ts`). Failed and paused results bypass grouping and fire
+ * immediately, flushing any held successes first, so failure and attention
+ * signals are never delayed.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+import {
+	type CompletionBatchConfig,
+	type CompletionBatcher,
+	createCompletionBatcher,
+	resolveCompletionBatchConfig,
+} from "./completion-batcher.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, type SubagentState } from "../../shared/types.ts";
 
 interface ChainStepResult {
 	agent: string;
@@ -31,6 +43,7 @@ interface SubagentResult {
 	state?: string;
 	timestamp: number;
 	durationMs?: number;
+	cwd?: string;
 	sessionFile?: string;
 	shareUrl?: string;
 	gistUrl?: string;
@@ -38,10 +51,116 @@ interface SubagentResult {
 	results?: ChainStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
+	sessionId?: string | null;
 }
 
-export default function registerSubagentNotify(pi: ExtensionAPI): void {
+interface NotifyTimerApi {
+	setTimeout(handler: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+}
+
+export interface RegisterSubagentNotifyOptions {
+	batchConfig?: CompletionBatchConfig;
+	timers?: NotifyTimerApi;
+	now?: () => number;
+}
+
+function formatSessionLine(details: SubagentNotifyDetails): string | undefined {
+	if (!details.sessionValue) return undefined;
+	return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
+}
+
+export function formatSingleCompletion(details: SubagentNotifyDetails): string {
+	const sessionLine = formatSessionLine(details);
+	return [
+		`Background task ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
+		"",
+		details.resultPreview.trim() ? details.resultPreview : "(no output)",
+		sessionLine ? "" : undefined,
+		sessionLine,
+	]
+		.filter((line) => line !== undefined)
+		.join("\n");
+}
+
+export function formatGroupedCompletion(details: SubagentNotifyDetails[]): string {
+	const header = `Background tasks completed (${details.length}): ${details.map((d) => `**${d.agent}**${d.taskInfo ?? ""}`).join(", ")}`;
+	const blocks: string[] = [header, ""];
+	for (let index = 0; index < details.length; index++) {
+		const detail = details[index];
+		if (!detail) continue;
+		const sessionLine = formatSessionLine(detail);
+		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}`);
+		blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
+		if (sessionLine) blocks.push(sessionLine);
+		blocks.push("");
+	}
+	return blocks.join("\n").trimEnd();
+}
+
+function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, details: SubagentNotifyDetails[]): void {
+	if (details.length === 0) return;
+	const content = details.length === 1
+		? formatSingleCompletion(details[0]!)
+		: formatGroupedCompletion(details);
+	pi.sendMessage(
+		{
+			customType: "subagent-notify",
+			content,
+			display: true,
+		},
+		{ triggerTurn: true },
+	);
+}
+
+function completionBatchKey(result: SubagentResult): string {
+	const sessionId = typeof result.sessionId === "string" ? result.sessionId.trim() : "";
+	if (sessionId) return `session:${sessionId}`;
+	const cwd = typeof result.cwd === "string" ? result.cwd.trim() : "";
+	return cwd ? `cwd:${cwd}` : "unknown";
+}
+
+export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDetails {
+	const agent = result.agent ?? "unknown";
+	const summary = typeof result.summary === "string" ? result.summary : "";
+	const paused = !result.success && (
+		result.exitCode === 0
+		|| result.state === "paused"
+		|| summary.startsWith("Paused after interrupt.")
+	);
+	const status = paused ? "paused" : result.success ? "completed" : "failed";
+
+	const taskInfo =
+		result.taskIndex !== undefined && result.totalTasks !== undefined
+			? ` (${result.taskIndex + 1}/${result.totalTasks})`
+			: undefined;
+
+	const session =
+		result.shareUrl
+			? { label: "Session", value: result.shareUrl }
+			: result.shareError
+				? { label: "Session share error", value: result.shareError }
+				: result.sessionFile
+					? { label: "Session file", value: result.sessionFile }
+					: undefined;
+
+	return {
+		agent,
+		status,
+		...(taskInfo ? { taskInfo } : {}),
+		resultPreview: summary,
+		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
+		...(session ? { sessionLabel: session.label, sessionValue: session.value } : {}),
+	};
+}
+
+export default function registerSubagentNotify(
+	pi: ExtensionAPI,
+	state: Pick<SubagentState, "currentSessionId">,
+	options: RegisterSubagentNotifyOptions = {},
+): void {
 	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
+	const batcherStoreKey = "__pi_subagents_notify_batcher__";
 	const globalStore = globalThis as Record<string, unknown>;
 	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
 	if (typeof previousUnsubscribe === "function") {
@@ -51,57 +170,55 @@ export default function registerSubagentNotify(pi: ExtensionAPI): void {
 			// Best effort cleanup for stale handlers from an older reload.
 		}
 	}
+	const previousBatcher = globalStore[batcherStoreKey];
+	if (previousBatcher && typeof (previousBatcher as { dispose?: () => void }).dispose === "function") {
+		try {
+			(previousBatcher as { dispose: () => void }).dispose();
+		} catch {
+			// Best effort cleanup for a stale batcher from an older reload.
+		}
+	}
 
 	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
 	const ttlMs = 10 * 60 * 1000;
+	const nowFn = options.now ?? Date.now;
+	const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
+	const batchers = new Map<string, CompletionBatcher<SubagentNotifyDetails>>();
+	globalStore[batcherStoreKey] = {
+		dispose() {
+			for (const batcher of batchers.values()) batcher.dispose();
+			batchers.clear();
+		},
+	};
 
 	const handleComplete = (data: unknown) => {
 		const result = data as SubagentResult;
-		const now = Date.now();
+		if (typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return;
+		const now = nowFn();
 		const key = buildCompletionKey(result, "notify");
 		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
 
-		const agent = result.agent ?? "unknown";
-		const summary = typeof result.summary === "string" ? result.summary : "";
-		const paused = !result.success && (
-			result.exitCode === 0
-			|| result.state === "paused"
-			|| summary.startsWith("Paused after interrupt.")
-		);
-		const status = paused ? "paused" : result.success ? "completed" : "failed";
-
-		const taskInfo =
-			result.taskIndex !== undefined && result.totalTasks !== undefined
-				? ` (${result.taskIndex + 1}/${result.totalTasks})`
-				: "";
-
-		const sessionLine = result.shareUrl
-			? `Session: ${result.shareUrl}`
-			: result.shareError
-				? `Session share error: ${result.shareError}`
-				: result.sessionFile
-					? `Session file: ${result.sessionFile}`
-					: undefined;
-
-		const displaySummary = summary.trim() ? summary : "(no output)";
-		const content = [
-			`Background task ${status}: **${agent}**${taskInfo}`,
-			"",
-			displaySummary,
-			sessionLine ? "" : undefined,
-			sessionLine,
-		]
-			.filter((line) => line !== undefined)
-			.join("\n");
-
-		pi.sendMessage(
-			{
-				customType: "subagent-notify",
-				content,
-				display: true,
-			},
-			{ triggerTurn: true },
-		);
+		const details = buildCompletionDetails(result);
+		const batchKey = completionBatchKey(result);
+		let batcher = batchers.get(batchKey);
+		if (!batcher) {
+			batcher = createCompletionBatcher<SubagentNotifyDetails>({
+				config: batchConfig,
+				emit: (items) => sendCompletion(pi, items),
+				...(options.timers ? { timers: options.timers } : {}),
+				now: nowFn,
+			});
+			batchers.set(batchKey, batcher);
+		}
+		if (details.status !== "completed") {
+			// Failures and paused runs bypass grouping. Flush any held
+			// successes for the same owner first so they are not stranded
+			// behind this signal, then emit the non-completion result immediately.
+			batcher.flush();
+			sendCompletion(pi, [details]);
+			return;
+		}
+		batcher.push(details);
 	};
 
 	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);

package/src/runs/background/result-watcher.ts

@@ -118,8 +118,7 @@ export function createResultWatcher(
 		if (!fsApi.existsSync(resultPath)) return;
 		try {
 			const data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8")) as ResultFileData;
-			if (data.sessionId && data.sessionId !== state.currentSessionId) return;
-			if (!data.sessionId && data.cwd && (!state.baseCwd || data.cwd !== state.baseCwd)) return;
+			if (typeof data.sessionId !== "string" || data.sessionId !== state.currentSessionId) return;
 
 			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
 			const hasExplicitNestedChildren = data.nestedChildren !== undefined;

package/src/runs/background/run-id-resolver.ts

@@ -28,7 +28,8 @@ function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string
 }
 
 function foregroundIds(state: SubagentState | undefined): string[] {
-	return state ? [...state.foregroundControls.keys()] : [];
+	if (!state) return [];
+	return [...new Set([...state.foregroundControls.keys(), ...(state.foregroundRuns?.keys() ?? [])])];
 }
 
 function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolutionScope | undefined {
@@ -57,7 +58,7 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 
 	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
-	if (deps.state?.foregroundControls.has(id)) return { kind: "foreground", id };
+	if (deps.state?.foregroundControls.has(id) || deps.state?.foregroundRuns?.has(id)) return { kind: "foreground", id };
 	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
 	if (exactAsync) return { kind: "async", id, location: exactAsync };
 	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});

package/src/runs/background/run-status.ts

@@ -2,10 +2,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
+import { formatAsyncResultTranscript, formatAsyncRunTranscript, formatNestedRunTranscript, inspectSubagentFleet } from "./fleet-view.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
-import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
+import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type ForegroundResumeRun, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
@@ -18,6 +19,9 @@ interface RunStatusParams {
 	id?: string;
 	runId?: string;
 	dir?: string;
+	index?: number;
+	view?: "fleet" | "transcript";
+	lines?: number;
 }
 
 interface RunStatusDeps {
@@ -27,6 +31,7 @@ interface RunStatusDeps {
 	now?: () => number;
 	state?: SubagentState;
 	nested?: NestedRunResolutionScope;
+	sessionRoots?: string[];
 }
 
 function hasExistingSessionFile(value: unknown): value is string {
@@ -68,6 +73,87 @@ function nestedRunDisplayName(run: NestedRunSummary): string {
 	return run.id;
 }
 
+function formatSteeringSummary(input: { steerCount?: number; lastSteerAt?: number }): string | undefined {
+	const parts: string[] = [];
+	if (input.steerCount !== undefined) parts.push(`${input.steerCount} steer${input.steerCount === 1 ? "" : "s"}`);
+	if (typeof input.lastSteerAt === "number" && Number.isFinite(input.lastSteerAt)) parts.push(`last ${new Date(input.lastSteerAt).toISOString()}`);
+	return parts.length ? parts.join(", ") : undefined;
+}
+
+function rememberedForegroundChildOutput(child: ForegroundResumeRun["children"][number]): string {
+	const outputPath = child.artifactPaths?.outputPath;
+	if (outputPath && fs.existsSync(outputPath)) {
+		try {
+			const artifactOutput = fs.readFileSync(outputPath, "utf-8").trim();
+			if (artifactOutput) return artifactOutput;
+		} catch {
+			// Fall back to the remembered snapshot below.
+		}
+	}
+	return child.finalOutput ?? "";
+}
+
+function formatRememberedForegroundStatus(run: ForegroundResumeRun): string {
+	const lines = [
+		`Run: ${run.runId}`,
+		"State: remembered foreground",
+		`Mode: ${run.mode}`,
+		`Updated: ${new Date(run.updatedAt).toISOString()}`,
+		`Cwd: ${run.cwd}`,
+	];
+	for (const child of run.children) {
+		const output = rememberedForegroundChildOutput(child).trim().split(/\r?\n/).find((line) => line.trim());
+		const parts = [
+			`${child.index + 1}. ${child.agent} ${child.status}`,
+			child.exitCode !== undefined ? `exit ${child.exitCode}` : undefined,
+			child.detachedReason ? `detached: ${child.detachedReason}` : undefined,
+			output ? `output: ${output.slice(0, 160)}` : undefined,
+		].filter(Boolean);
+		lines.push(parts.join(", "));
+		if (child.sessionFile) lines.push(`  Session: ${child.sessionFile}`);
+		if (child.transcriptPath) lines.push(`  Transcript: ${child.transcriptPath}`);
+		if (child.artifactPaths?.outputPath) lines.push(`  Output: ${child.artifactPaths.outputPath}`);
+		if (child.transcriptError) lines.push(`  Transcript warning: ${child.transcriptError}`);
+	}
+	lines.push("", `Status: subagent({ action: "status", id: "${run.runId}" })`);
+	if (run.children.length === 1) lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", view: "transcript" })`);
+	else lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", index: 0, view: "transcript" })`);
+	const resumable = run.children.find((child) => child.status !== "detached" && hasExistingSessionFile(child.sessionFile));
+	if (resumable) {
+		lines.push(run.children.length === 1
+			? `Revive: subagent({ action: "resume", id: "${run.runId}", message: "..." })`
+			: `Revive child: subagent({ action: "resume", id: "${run.runId}", index: ${resumable.index}, message: "..." })`);
+	} else if (run.children.some((child) => child.status === "detached")) {
+		lines.push("Recovery: child detached for intercom coordination; status will show recovered output after the child exits when Pi can observe it.");
+	} else {
+		lines.push("Resume: unavailable; no child session file was persisted.");
+	}
+	return lines.join("\n");
+}
+
+function formatRememberedForegroundTranscript(run: ForegroundResumeRun, options: { index?: number; lines?: number }): string {
+	let index = options.index;
+	if (index !== undefined && !Number.isInteger(index)) throw new Error("Transcript index must be an integer.");
+	if (index === undefined && run.children.length === 1) index = 0;
+	if (index === undefined) return `Transcript view requires index for foreground run '${run.runId}' with ${run.children.length} children.`;
+	if (index < 0 || index >= run.children.length) throw new Error(`Transcript index ${index} is out of range for ${run.children.length} foreground children.`);
+	const child = run.children[index]!;
+	const lineLimit = Math.max(1, Math.min(options.lines ?? 80, 1000));
+	const outputLines = rememberedForegroundChildOutput(child).split(/\r?\n/).filter((line) => line.trim()).slice(-lineLimit);
+	const lines = [
+		`Run: ${run.runId}`,
+		`State: ${child.status}`,
+		`Child: ${index} (${child.agent})`,
+		child.sessionFile ? `Session: ${child.sessionFile}` : undefined,
+		child.transcriptPath ? `Transcript: ${child.transcriptPath}` : undefined,
+		child.artifactPaths?.outputPath ? `Output: ${child.artifactPaths.outputPath}` : undefined,
+	].filter((line): line is string => Boolean(line));
+	lines.push("Result transcript tail:");
+	if (outputLines.length === 0) lines.push("  (no recovered final output available yet)");
+	else for (const line of outputLines) lines.push(`  ${line}`);
+	return lines.join("\n");
+}
+
 function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): string {
 	const lines = [
 		`Nested run: ${run.id}`,
@@ -78,6 +164,7 @@ function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): stri
 		run.mode ? `Mode: ${run.mode}` : undefined,
 		`Agent: ${nestedRunDisplayName(run)}`,
 		run.currentStep !== undefined ? `Progress: step ${run.currentStep + 1}/${run.chainStepCount ?? run.steps?.length ?? 1}` : undefined,
+		run.turnBudget ? `Turn budget: ${run.turnBudget.turnCount}/${run.turnBudget.maxTurns}+${run.turnBudget.graceTurns} (${run.turnBudget.outcome})` : undefined,
 		run.asyncDir ? `Dir: ${run.asyncDir}` : undefined,
 		run.sessionFile ? `Session: ${run.sessionFile}` : undefined,
 		run.error ? `Error: ${run.error}` : undefined,
@@ -89,18 +176,30 @@ function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): stri
 		lines.push("Steps:");
 		for (const [index, step] of run.steps.entries()) {
 			const activity = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
-			lines.push(`  ${index + 1}. ${step.agent} ${step.status}${activity ? `, ${activity}` : ""}${step.error ? `, error: ${step.error}` : ""}`);
+			const budget = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
+			lines.push(`  ${index + 1}. ${step.agent} ${step.status}${activity ? `, ${activity}` : ""}${budget}${step.error ? `, error: ${step.error}` : ""}`);
 			lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: true }));
 		}
 	}
 	lines.push(...formatNestedRunStatusLines(run.children, { indent: "  ", commandHints: true }));
-	lines.push("Commands:", `  Status: subagent({ action: "status", id: "${run.id}" })`, `  Interrupt: subagent({ action: "interrupt", id: "${run.id}" })`, `  Resume: subagent({ action: "resume", id: "${run.id}", message: "..." })`, `  Root status: subagent({ action: "status", id: "${rootRunId}" })`);
+	lines.push("Commands:", `  Status: subagent({ action: "status", id: "${run.id}" })`, `  Interrupt: subagent({ action: "interrupt", id: "${run.id}" })`, `  Resume: subagent({ action: "resume", id: "${run.id}", message: "..." })`, `  Steer: subagent({ action: "steer", id: "${run.id}", message: "..." })`, `  Root status: subagent({ action: "status", id: "${rootRunId}" })`);
 	return lines.join("\n");
 }
 
 export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDeps = {}): AgentToolResult<Details> {
 	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
+	const currentSessionId = deps.state?.currentSessionId ?? undefined;
+	if (params.view && params.view !== "fleet" && params.view !== "transcript") {
+		return {
+			content: [{ type: "text", text: `Unknown status view: ${params.view}. Valid: fleet, transcript.` }],
+			isError: true,
+			details: { mode: "single", results: [] },
+		};
+	}
+	if (params.view === "fleet") {
+		return inspectSubagentFleet(params, { asyncDirRoot, resultsDir, kill: deps.kill, now: deps.now, state: deps.state, childSafe: Boolean(deps.nested) });
+	}
 	if (!params.id && !params.runId && !params.dir) {
 		if (deps.nested) {
 			return {
@@ -110,7 +209,15 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			};
 		}
 		try {
-			const runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], resultsDir, kill: deps.kill, now: deps.now });
+			const runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: currentSessionId, resultsDir, kill: deps.kill, now: deps.now });
+			if (params.view === "transcript") {
+				if (runs.length === 1) return inspectSubagentStatus({ ...params, id: runs[0]!.id }, deps);
+				return {
+					content: [{ type: "text", text: runs.length === 0 ? "No active async run transcript is available." : `Transcript view requires an id when ${runs.length} active async runs exist. Use subagent({ action: "status", view: "fleet" }) to choose one.` }],
+					isError: true,
+					details: { mode: "single", results: [] },
+				};
+			}
 			return {
 				content: [{ type: "text", text: formatAsyncRunList(runs) }],
 				details: { mode: "single", results: [] },
@@ -130,10 +237,32 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const requestedId = params.id ?? params.runId;
 		if (!params.dir && requestedId) {
 			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+			if (resolved?.kind === "foreground") {
+				const run = deps.state?.foregroundRuns?.get(resolved.id);
+				if (run) {
+					try {
+						return {
+							content: [{ type: "text", text: params.view === "transcript" ? formatRememberedForegroundTranscript(run, { index: params.index, lines: params.lines }) : formatRememberedForegroundStatus(run) }],
+							details: { mode: "single", results: [] },
+						};
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+					}
+				}
+			}
 			if (resolved?.kind === "nested") {
 				reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
 				const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
 				const nested = refreshed?.kind === "nested" ? refreshed : resolved;
+				if (params.view === "transcript") {
+					try {
+						return { content: [{ type: "text", text: formatNestedRunTranscript(nested.match.run, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+					}
+				}
 				return { content: [{ type: "text", text: formatNestedExactStatus(nested.match.rootRunId, nested.match.run) }], details: { mode: "single", results: [] } };
 			}
 			if (resolved?.kind === "async") location = resolved.location;
@@ -176,6 +305,21 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
 		const eventsPath = path.join(asyncDir, "events.jsonl");
 		if (status) {
+			if (params.view === "transcript") {
+				if (currentSessionId && status.sessionId !== currentSessionId) {
+					return {
+						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+						isError: true,
+						details: { mode: "single", results: [] },
+					};
+				}
+				try {
+					return { content: [{ type: "text", text: formatAsyncRunTranscript(status, asyncDir, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+				}
+			}
 			let nestedChildren: NestedRunSummary[] = [];
 			let nestedWarning: string | undefined;
 			try {
@@ -198,17 +342,20 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			const started = new Date(status.startedAt).toISOString();
 			const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
 			const statusActivityText = status.state === "running" ? formatActivityLabel(status.lastActivityAt, status.activityState) : undefined;
+			const steeringText = formatSteeringSummary(status);
 
 			const lines = [
 				`Run: ${status.runId}`,
 				`State: ${status.state}`,
 				status.error ? `Error: ${status.error}` : undefined,
 				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
+				steeringText ? `Steering: ${steeringText}` : undefined,
 				`Mode: ${status.mode}`,
 				`Progress: ${progressLabel}`,
 				status.pendingAppends ? `Pending appends: ${status.pendingAppends}` : undefined,
 				`Started: ${started}`,
 				`Updated: ${updated}`,
+				status.turnBudget ? `Turn budget: ${status.turnBudget.turnCount}/${status.turnBudget.maxTurns}+${status.turnBudget.graceTurns} (${status.turnBudget.outcome})` : undefined,
 				`Dir: ${asyncDir}`,
 				outputPath ? `Output: ${outputPath}` : undefined,
 				reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
@@ -218,16 +365,20 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
 				const modelThinking = formatModelThinking(step.model, step.thinking);
 				const modelText = modelThinking ? ` (${modelThinking})` : "";
+				const steeringText = formatSteeringSummary(step);
+				const steeringSuffix = steeringText ? `, steering: ${steeringText}` : "";
 				const errorText = step.error ? `, error: ${step.error}` : "";
 				const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "";
+				const budgetText = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
 				const display = step.label ? `${step.label} (${step.agent})` : step.agent;
 				const phase = step.phase ? `[${step.phase}] ` : "";
-				lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${acceptanceText}${errorText}`);
+				lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText}`);
 				lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: true, maxLines: 20 }));
 				const stepOutputPath = path.join(asyncDir, `output-${index}.log`);
 				if (stepOutputPath !== outputPath && fs.existsSync(stepOutputPath)) lines.push(`  Output: ${stepOutputPath}`);
 				if (step.status === "running") {
 					lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.agent, index)} (if registered)`);
+					lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`);
 				}
 			}
 			const attached = new Set((status.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? []));
@@ -235,6 +386,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: true, maxLines: 20 }));
 			if (nestedWarning) lines.push(`Warning: ${nestedWarning}`);
 			if (status.sessionFile) lines.push(`Session: ${status.sessionFile}`);
+			if (status.state === "running") lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`);
 			if (status.state !== "running") {
 				lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile));
 			}
@@ -248,7 +400,15 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	if (resultPath) {
 		try {
 			const raw = fs.readFileSync(resultPath, "utf-8");
-			const data = JSON.parse(raw) as { id?: string; runId?: string; agent?: string; success?: boolean; summary?: string; exitCode?: number; state?: string; sessionFile?: string; results?: Array<{ agent?: string; sessionFile?: string }> };
+			const data = JSON.parse(raw) as { id?: string; runId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; sessionFile?: string; results?: Array<{ agent?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null }> };
+			if (params.view === "transcript") {
+				try {
+					return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+				}
+			}
 			const status = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 			const runId = data.runId ?? data.id ?? resolvedId;
 			const lines = [`Run: ${runId}`, `State: ${status}`, `Result: ${resultPath}`];