pi-subagents 0.65.0 → 0.66.0

package/src/runs/background/process-terminal.ts

@@ -4,10 +4,10 @@ import { writeAtomicJson, writePrivateAtomicJson } from "../../shared/atomic-jso
 import {
 	SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
 	type AsyncStatus,
-	type CanonicalSessionTerminalV1,
-	type ProcessInstanceExitV1,
+	type CanonicalSessionTerminal,
+	type ProcessInstanceExit,
 	type ProcessTerminalReason,
-	type ProcessTerminalV1,
+	type ProcessTerminal,
 } from "../../shared/types.ts";
 import { canonicalSessionId, inspectSessionLease } from "../shared/session-lease.ts";
 import { releaseActiveRunIndex } from "./active-run-index.ts";
@@ -16,7 +16,7 @@ export interface ProcessTerminalCandidate {
 	version: 1;
 	runId: string;
 	runnerProcessInstanceId: string;
-	writers: Record<string, ProcessInstanceExitV1[]>;
+	writers: Record<string, ProcessInstanceExit[]>;
 	expectedWriters?: Record<string, number>;
 	sessionFile?: string;
 	revivalLeaseToken?: string;
@@ -34,7 +34,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function validProcessInstance(value: unknown, kind?: "runner" | "pi-writer"): value is ProcessInstanceExitV1 {
+function validProcessInstance(value: unknown, kind?: "runner" | "pi-writer"): value is ProcessInstanceExit {
 	if (!isRecord(value)) return false;
 	if (typeof value.processInstanceId !== "string" || value.processInstanceId.length === 0) return false;
 	if (kind ? value.kind !== kind : (value.kind !== "runner" && value.kind !== "pi-writer")) return false;
@@ -56,7 +56,7 @@ function validProcessInstance(value: unknown, kind?: "runner" | "pi-writer"): va
 		&& (value.processTree.diagnostic === undefined || typeof value.processTree.diagnostic === "string");
 }
 
-function validInstance(value: unknown): value is ProcessInstanceExitV1 {
+function validInstance(value: unknown): value is ProcessInstanceExit {
 	return validProcessInstance(value, "pi-writer");
 }
 
@@ -78,7 +78,7 @@ export function readProcessTerminalCandidate(asyncDir: string): ProcessTerminalC
 		if (!isRecord(raw) || raw.version !== 1 || typeof raw.runId !== "string" || typeof raw.runnerProcessInstanceId !== "string" || !isRecord(raw.writers)) {
 			throw new Error(`Invalid process-terminal candidate in '${asyncDir}'.`);
 		}
-		const writers: Record<string, ProcessInstanceExitV1[]> = {};
+		const writers: Record<string, ProcessInstanceExit[]> = {};
 		for (const [index, entries] of Object.entries(raw.writers)) {
 			if (!Array.isArray(entries) || !entries.every(validInstance)) throw new Error(`Invalid writer process records for child '${index}'.`);
 			writers[index] = entries;
@@ -137,7 +137,7 @@ export function markProcessTerminalCandidateLeaseRelease(asyncDir: string, token
 	writeProcessTerminalCandidate(asyncDir, { ...candidate, revivalLeaseReleaseAcknowledged: acknowledged });
 }
 
-function unknownProof(runId: string, runnerProcessInstanceId: string, reason: ProcessTerminalReason, diagnostic?: string): ProcessTerminalV1 {
+function unknownProof(runId: string, runnerProcessInstanceId: string, reason: ProcessTerminalReason, diagnostic?: string): ProcessTerminal {
 	return { version: 1, state: "unknown", runId, runnerProcessInstanceId, reason, ...(diagnostic ? { diagnostic } : {}) };
 }
 
@@ -147,7 +147,7 @@ function resumeDisposition(state: string | undefined, sessionFile: string | unde
 	return sessionFile && fs.existsSync(sessionFile) ? "resumable" : "unavailable";
 }
 
-function sessionProjection(candidate: ProcessTerminalCandidate, lease: ReturnType<typeof inspectSessionLease>): CanonicalSessionTerminalV1 | undefined {
+function sessionProjection(candidate: ProcessTerminalCandidate, lease: ReturnType<typeof inspectSessionLease>): CanonicalSessionTerminal | undefined {
 	if (!candidate.sessionFile || lease.state !== "free") return undefined;
 	if (candidate.revivalLeaseToken && candidate.revivalLeaseReleaseAcknowledged !== true) return undefined;
 	return {
@@ -158,7 +158,7 @@ function sessionProjection(candidate: ProcessTerminalCandidate, lease: ReturnTyp
 	};
 }
 
-function validateProof(raw: unknown, asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): raw is ProcessTerminalV1 {
+function validateProof(raw: unknown, asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): raw is ProcessTerminal {
 	if (!isRecord(raw) || raw.version !== 1 || !["pending", "observed", "unknown", "not-started"].includes(String(raw.state)) || typeof raw.runId !== "string" || !raw.runId || typeof raw.runnerProcessInstanceId !== "string" || !raw.runnerProcessInstanceId) {
 		throw new Error(`Invalid process-terminal proof in '${asyncDir}'.`);
 	}
@@ -177,21 +177,21 @@ function validateProof(raw: unknown, asyncDir: string, fallback?: { runId?: stri
 	return true;
 }
 
-export function sanitizeProcessTerminal(value: unknown, fallback: { runId?: string; runnerProcessInstanceId?: string }, label = "status"): ProcessTerminalV1 | undefined {
+export function sanitizeProcessTerminal(value: unknown, fallback: { runId?: string; runnerProcessInstanceId?: string }, label = "status"): ProcessTerminal | undefined {
 	if (value === undefined) return undefined;
 	try {
 		validateProof(value, label, fallback);
-		return value as ProcessTerminalV1;
+		return value as ProcessTerminal;
 	} catch (error) {
 		return unknownProof(fallback.runId ?? label, fallback.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
 	}
 }
 
-export function readProcessTerminal(asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): ProcessTerminalV1 | undefined {
+export function readProcessTerminal(asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): ProcessTerminal | undefined {
 	try {
 		const raw = JSON.parse(fs.readFileSync(processTerminalPath(asyncDir), "utf-8")) as unknown;
 		validateProof(raw, asyncDir, fallback);
-		return raw as ProcessTerminalV1;
+		return raw as ProcessTerminal;
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
 		return unknownProof(fallback?.runId ?? path.basename(asyncDir), fallback?.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
@@ -199,12 +199,12 @@ export function readProcessTerminal(asyncDir: string, fallback?: { runId?: strin
 }
 
 function stepProcessTerminalProof(
-	proof: ProcessTerminalV1,
+	proof: ProcessTerminal,
 	childIndex: number,
-	state: ProcessTerminalV1["state"],
-	records: ProcessInstanceExitV1[],
-	resumeDispositionValue: ProcessTerminalV1["resumeDisposition"],
-): ProcessTerminalV1 {
+	state: ProcessTerminal["state"],
+	records: ProcessInstanceExit[],
+	resumeDispositionValue: ProcessTerminal["resumeDisposition"],
+): ProcessTerminal {
 	const base = {
 		version: 1 as const,
 		runId: proof.runId,
@@ -221,7 +221,7 @@ function stepProcessTerminalProof(
 	return { ...base, state };
 }
 
-function overlayStatus(asyncDir: string, proof: ProcessTerminalV1, candidate?: ProcessTerminalCandidate): void {
+function overlayStatus(asyncDir: string, proof: ProcessTerminal, candidate?: ProcessTerminalCandidate): void {
 	const statusPath = path.join(asyncDir, "status.json");
 	try {
 		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatus;
@@ -244,13 +244,13 @@ export function finalizeProcessTerminal(
 	asyncDir: string,
 	runId: string,
 	runnerClose: RunnerCloseObservation,
-): ProcessTerminalV1 {
+): ProcessTerminal {
 	const existing = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId: runnerClose.processInstanceId });
 	if (existing && fs.existsSync(processTerminalPath(asyncDir))) {
 		if (existing.state === "observed" && existing.runId === runId && existing.runnerProcessInstanceId === runnerClose.processInstanceId) return existing;
 		if (existing.state === "unknown") return existing;
 	}
-	let proof: ProcessTerminalV1;
+	let proof: ProcessTerminal;
 	let candidateForOverlay: ProcessTerminalCandidate | undefined;
 	try {
 		const candidate = readProcessTerminalCandidate(asyncDir);
@@ -279,7 +279,7 @@ export function finalizeProcessTerminal(
 			} else if (allWriters.some((writer) => writer.kind === "pi-writer" && writer.processTree.state !== "observed")) {
 				proof = unknownProof(runId, runnerClose.processInstanceId, "process-tree-unverified");
 			} else {
-				const runner: ProcessInstanceExitV1 = { kind: "runner", ...runnerClose };
+				const runner: ProcessInstanceExit = { kind: "runner", ...runnerClose };
 				const canonicalSession = session && sessionProjection(candidate, session);
 				proof = {
 					version: 1,

package/src/runs/background/retained-nested-route-tracker.ts

@@ -0,0 +1,96 @@
+import * as fs from "node:fs";
+import type { SubagentState } from "../../shared/types.ts";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.ts";
+import { hasLiveNestedDescendants, projectNestedEvents } from "../shared/nested-events.ts";
+
+interface RetainedNestedRouteTrackerOptions {
+	pollIntervalMs?: number;
+	platform?: NodeJS.Platform;
+	watch?: typeof fs.watch;
+}
+
+const DEFAULT_POLL_INTERVAL_MS = 5000;
+const REFRESH_DEBOUNCE_MS = 25;
+
+export function createRetainedNestedRouteTracker(
+	state: Pick<SubagentState, "retainedForegroundNestedRoutes">,
+	options: RetainedNestedRouteTrackerOptions = {},
+): { track: (rootRunId: string) => void; clear: () => void } {
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const watch = options.watch ?? fs.watch;
+	const watchers = new Map<string, fs.FSWatcher>();
+	const refreshTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	let poller: ReturnType<typeof setInterval> | undefined;
+
+	const close = (rootRunId: string): void => {
+		watchers.get(rootRunId)?.close();
+		watchers.delete(rootRunId);
+		const timer = refreshTimers.get(rootRunId);
+		if (timer) clearTimeout(timer);
+		refreshTimers.delete(rootRunId);
+	};
+
+	const refresh = (rootRunId: string): void => {
+		const retained = state.retainedForegroundNestedRoutes?.get(rootRunId);
+		if (!retained) {
+			close(rootRunId);
+			return;
+		}
+		try {
+			if (hasLiveNestedDescendants(projectNestedEvents(retained).children)) return;
+			state.retainedForegroundNestedRoutes?.delete(rootRunId);
+			close(rootRunId);
+		} catch (error) {
+			console.error(`Failed to refresh retained nested descendants for foreground run '${rootRunId}':`, error);
+		}
+	};
+
+	const scheduleRefresh = (rootRunId: string): void => {
+		if (refreshTimers.has(rootRunId)) return;
+		const timer = setTimeout(() => {
+			refreshTimers.delete(rootRunId);
+			refresh(rootRunId);
+		}, REFRESH_DEBOUNCE_MS);
+		timer.unref?.();
+		refreshTimers.set(rootRunId, timer);
+	};
+
+	const ensurePoller = (): void => {
+		if (poller || (state.retainedForegroundNestedRoutes?.size ?? 0) === 0) return;
+		poller = setInterval(() => {
+			for (const rootRunId of state.retainedForegroundNestedRoutes?.keys() ?? []) refresh(rootRunId);
+			if ((state.retainedForegroundNestedRoutes?.size ?? 0) > 0) return;
+			if (poller) clearInterval(poller);
+			poller = undefined;
+		}, pollIntervalMs);
+		poller.unref?.();
+	};
+
+	const track = (rootRunId: string): void => {
+		const retained = state.retainedForegroundNestedRoutes?.get(rootRunId);
+		if (!retained) return;
+		if (shouldUseNativeFsWatch("retained-nested-route-tracker", options.platform) && !watchers.has(rootRunId)) {
+			try {
+				const watcher = watch(retained.eventSink, () => scheduleRefresh(rootRunId));
+				watcher.on("error", () => close(rootRunId));
+				watcher.unref?.();
+				watchers.set(rootRunId, watcher);
+			} catch {
+				// The bounded safety poll below covers unsupported or failed watchers.
+			}
+		}
+		scheduleRefresh(rootRunId);
+		ensurePoller();
+	};
+
+	const clear = (): void => {
+		if (poller) clearInterval(poller);
+		poller = undefined;
+		for (const rootRunId of watchers.keys()) close(rootRunId);
+		for (const timer of refreshTimers.values()) clearTimeout(timer);
+		refreshTimers.clear();
+		state.retainedForegroundNestedRoutes?.clear();
+	};
+
+	return { track, clear };
+}

package/src/runs/background/run-child-session.ts

@@ -8,7 +8,7 @@
 import type { Message } from "@earendil-works/pi-ai";
 import type { ChildTranscriptWriter } from "../../shared/child-transcript.ts";
 import { extractTextFromContent, extractToolArgsPreview, getFinalOutput, hasEmptyTerminalAssistantResponse } from "../../shared/utils.ts";
-import type { EffectsProjection, RuntimeAcknowledgedChildExtensionsV1, SubagentOutputState, ToolBudgetState, Usage } from "../../shared/types.ts";
+import type { EffectsProjection, RuntimeAcknowledgedChildExtensions, SubagentOutputState, ToolBudgetState, Usage } from "../../shared/types.ts";
 import {
 	acceptChildWatchdogEvent,
 	applyChildWatchdogMessage,
@@ -22,9 +22,10 @@ import { projectChildLifecycle, type ChildLifecycleAction, type ChildLifecycleSt
 import { formatSubagentModelVerificationError } from "../shared/model-fallback.ts";
 import { isMutatingTool, resolveCurrentPath } from "../shared/long-running-guard.ts";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, toolTimeoutCallKey } from "../shared/tool-timeout.ts";
-import type { InProcessChildLaunch } from "../shared/child-launch.ts";
+import { createReportedChildSessionInput, type InProcessChildLaunch } from "../shared/child-launch.ts";
 import { projectChildSessionEventForJson, type ChildSession, type ChildSessionEvent, type ChildSessionFactory } from "../shared/child-session.ts";
 import { formatSteerMessage } from "../shared/subagent-prompt-runtime.ts";
+import { getReadonlySessionEvidence, requestReadonlySessionEvidence, type SettledReadonlyEvidence } from "../shared/readonly-session-evidence.ts";
 import type { SteerDeliveryStatus, SteerRequest } from "./control-channel.ts";
 
 export interface ChildEventContext {
@@ -93,7 +94,18 @@ export interface RunChildSessionInput {
 	runDeadlineAt?: number;
 	expectedModelForVerification?: string;
 	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string }>;
+	modelResponseAliases?: Record<string, string[]>;
 	mutationTools?: readonly string[];
+	/** Internal guarded continuation handoff; never part of persisted results. */
+	readonlyContinuation?: { source: ChildSession; expected: SettledReadonlyEvidence; modelId: string };
+	collectReadonlyEvidence?: boolean;
+	canContinue?: () => boolean;
+}
+
+const settledChildren = new WeakMap<RunChildSessionResult, ChildSession>();
+export function getSettledReadonlyChild(result: RunChildSessionResult): ChildSession | undefined {
+	const child = settledChildren.get(result);
+	return child && getReadonlySessionEvidence(child) ? child : undefined;
 }
 
 export interface RunChildSessionResult {
@@ -122,7 +134,7 @@ export interface RunChildSessionResult {
 	toolBudget?: ToolBudgetState;
 	toolBudgetBlocked?: boolean;
 	structuredOutput?: unknown;
-	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedChildExtensionsV1;
+	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedChildExtensions;
 	abortRecoveryDiagnostic?: string;
 	effects?: EffectsProjection;
 }
@@ -468,11 +480,15 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 				if (event.message.model) {
 					model = event.message.model;
 					if (input.expectedModelForVerification && !hasToolCall) {
-						const modelVerificationError = formatSubagentModelVerificationError(input.expectedModelForVerification, event.message.model, input.modelVerificationRegistry);
+						const modelVerificationError = formatSubagentModelVerificationError(input.expectedModelForVerification, event.message.model, input.modelVerificationRegistry, input.modelResponseAliases);
 						if (modelVerificationError && !error) error = modelVerificationError;
 					}
 				}
 				if (event.message.errorMessage) assistantError = event.message.errorMessage;
+				else if (hasToolCall && event.message.stopReason === "toolUse") {
+					// A recovered request can finish via a terminating tool, without a text stop.
+					assistantError = undefined;
+				}
 				const eventUsage = event.message.usage;
 				if (eventUsage) {
 					usage.turns++;
@@ -532,29 +548,33 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 				: interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal)
 					? 0
 					: finalError || promptError !== undefined ? 1 : 0;
-			void closed.then(() => resolve(omitUndefined({
-				exitCode,
-				messages,
-				usage,
-				toolCount,
-				durationMs: Date.now() - startedAt,
-				model,
-				error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal) ? undefined : finalError,
-				finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
-				outputState: finalOutput.trim() ? "present" : "absent",
-				interrupted: interrupted || undefined,
-				timedOut: timedOut || undefined,
-				stopped: stopped || undefined,
-				observedMutationAttempt,
-				structuredOutputToolInvoked,
-				structuredOutputMessageStartIndex,
-				watchdog: childWatchdogState,
-				sessionFile: session?.sessionFile,
-				currentTool,
-				currentToolArgs,
-				currentPath,
-				afterCompactionSettlement: afterCompactionSettlement || undefined,
-			})));
+			void closed.then(() => {
+				const result: RunChildSessionResult = omitUndefined({
+					exitCode,
+					messages,
+					usage,
+					toolCount,
+					durationMs: Date.now() - startedAt,
+					model,
+					error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal) ? undefined : finalError,
+					finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
+					outputState: finalOutput.trim() ? "present" : "absent",
+					interrupted: interrupted || undefined,
+					timedOut: timedOut || undefined,
+					stopped: stopped || undefined,
+					observedMutationAttempt,
+					structuredOutputToolInvoked,
+					structuredOutputMessageStartIndex,
+					watchdog: childWatchdogState,
+					sessionFile: session?.sessionFile,
+					currentTool,
+					currentToolArgs,
+					currentPath,
+					afterCompactionSettlement: afterCompactionSettlement || undefined,
+				});
+				if (session && !forced && !forcedTermination && !interrupted && !timedOut && !stopped && getReadonlySessionEvidence(session)) settledChildren.set(result, session);
+				resolve(result);
+			});
 		};
 
 		input.registerInterrupt?.(() => {
@@ -574,17 +594,25 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 
 		void (async () => {
 			try {
-				const created = await input.factory.create({
-					...input.launch.session,
-					onExtensionError: (extensionError) => {
-						input.transcriptWriter?.writeStderrLine(`Extension error (${extensionError.extensionPath}, ${extensionError.event}): ${extensionError.error instanceof Error ? extensionError.error.message : String(extensionError.error)}`);
-					},
-				});
+				const continuation = input.readonlyContinuation;
+				const checkContinuation = () => {
+					if (!continuation) return;
+					if (interrupted || timedOut || stopped || input.canContinue?.() !== true
+						|| (input.runDeadlineAt !== undefined && Date.now() >= input.runDeadlineAt)
+						|| getReadonlySessionEvidence(continuation.source) !== continuation.expected
+						|| continuation.source.detached || continuation.source.shutDown) throw new Error("Read-only continuation handoff vetoed");
+				};
+				checkContinuation();
+				const createInput = createReportedChildSessionInput(input.launch, input.transcriptWriter);
+				if (input.collectReadonlyEvidence || continuation) requestReadonlySessionEvidence(createInput, continuation?.expected);
+				const created = await input.factory.create(createInput);
 				if (settled) {
 					void created.dispose();
 					return;
 				}
 				session = created;
+				checkContinuation();
+				if (continuation && (created.modelId !== continuation.modelId || input.launch.capture.completionIntentContext?.()?.model?.api !== continuation.expected.api)) throw new Error("Read-only continuation model changed");
 				unsubscribe = created.subscribe(processEvent);
 				input.registerWatchdogStatus?.((event) => processEvent(event as unknown as ChildSessionEvent));
 				input.registerSteer?.(async (request) => {
@@ -601,6 +629,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 						: { state: "delivered", deliveryStatus: "delivered", message: "Pi accepted the steering input." };
 				});
 				if (interrupted || timedOut || stopped) abortChild();
+				checkContinuation();
 				await created.prompt(input.prompt);
 				promptSettled = true;
 				settle(undefined);

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

@@ -2,12 +2,14 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { safeTerminalText } from "../../shared/display-text.ts";
+import { getArtifactPaths, getArtifactsDir } from "../../shared/artifacts.ts";
+import { readFleetTranscript } from "../../tui/fleet-transcript.ts";
 import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, formatWorkflowStageLine, 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 { DIRS, type AsyncStatus, type Details, type ForegroundResumeRun, type NestedRunSummary, type SteeringStatus, type SubagentState } from "../../shared/types.ts";
+import { DIRS, type AsyncStatus, type Details, type ForegroundRunControl, type ForegroundResumeRun, type NestedRunSummary, type SteeringStatus, type SubagentState } from "../../shared/types.ts";
 import { inspectActiveAsyncCapacityOwner, type ActiveAsyncCapacityInspection } from "./active-async-capacity.ts";
 import { readStatus } from "../../shared/utils.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
@@ -88,6 +90,7 @@ function formatRunLifecycleDebug(input: { status: AsyncStatus; asyncDir: string;
 		`Run: ${status.runId}`,
 		`Dir: ${asyncDir}`,
 		`Status file: ${path.join(asyncDir, "status.json")}`,
+		status.workflowReceiptPath ? `Workflow receipt: ${status.workflowReceiptPath}` : undefined,
 		`Process terminal file: ${path.join(asyncDir, "process-terminal.json")}`,
 		`Session: ${status.sessionId ?? "unknown"}`,
 		`State: ${status.state}`,
@@ -241,6 +244,54 @@ function formatRememberedForegroundStatus(run: ForegroundResumeRun): string {
 	return lines.join("\n");
 }
 
+/** Request-only snapshot of the same artifact used by Fleet; no session or output fallback. */
+function formatLiveForegroundTranscript(control: ForegroundRunControl, state: SubagentState, options: { index?: number; lines?: number }): string {
+	if (!state.currentSessionId || control.sessionId !== state.currentSessionId) {
+		throw new Error(`Foreground run '${control.runId}' is not owned by the current session.`);
+	}
+	if (options.index !== undefined && (!Number.isInteger(options.index) || options.index < 0)) {
+		throw new Error("Transcript index must be a non-negative integer.");
+	}
+	const children = control.activeChildren
+		? [...control.activeChildren.values()]
+		: control.currentAgent ? [{ index: control.currentIndex ?? 0, agent: control.currentAgent, sessionName: control.sessionName }] : [];
+	const header = [`Run: ${control.runId}`, "State: live foreground"];
+	if (children.length === 0) return `${header.map((line) => safeTerminalText(line)).join("\n")}\nTranscript unavailable: no active foreground child.`;
+	if (options.index === undefined && children.length > 1) {
+		throw new Error(`Transcript view requires index for foreground run '${control.runId}'. Active child indexes: ${children.map((child) => child.index).join(", ")}.`);
+	}
+	const child = options.index === undefined ? children[0]! : children.find((child) => child.index === options.index);
+	if (!child) throw new Error(`Transcript index ${options.index} is not an active foreground child of '${control.runId}'.`);
+	const root = getArtifactsDir(state.parentSessionFile ?? null, control.cwd ?? state.baseCwd, state.artifactDirPreference);
+	const transcriptPath = getArtifactPaths(root, control.runId, child.agent, child.index).transcriptPath;
+	const transcript = readFleetTranscript(transcriptPath, { trustedRoots: [root] });
+	const lineLimit = Number.isFinite(options.lines) ? Math.max(1, Math.min(500, Math.trunc(options.lines!))) : 80;
+	const allLines = transcript.events.flatMap((event) => {
+		const text = event.kind === "tool"
+			? [`Tool: ${event.name} (${event.status})`, event.argsPayload ?? event.args, event.output ?? event.error].filter(Boolean).join("\n")
+			: event.kind === "notice" ? event.text : `${event.kind === "assistant" ? "Assistant" : "Supervisor"}: ${event.text}`;
+		return text.split(/\r?\n/);
+	});
+	let body = allLines.slice(-lineLimit).join("\n");
+	let truncated = transcript.truncated || allLines.length > lineLimit
+		|| transcript.events.some((event) => event.kind === "tool" && event.outputTruncated)
+		|| body.includes("… message truncated");
+	const maxOutputBytes = 32 * 1024;
+	const bytes = Buffer.from(body);
+	if (bytes.length > maxOutputBytes) {
+		// Skip UTF-8 continuation bytes at the beginning of the bounded tail.
+		let start = bytes.length - maxOutputBytes;
+		while ((bytes[start]! & 0xc0) === 0x80) start++;
+		body = bytes.subarray(start).toString("utf-8");
+		truncated = true;
+	}
+	header.push(`Child: ${child.index} (${child.sessionName?.trim() || child.agent})`, `Transcript: ${transcriptPath}`);
+	if (transcript.warning) header.push(`Transcript warning: ${transcript.warning}`);
+	header.push(`Live transcript tail${truncated ? " (tail truncated)" : ""}:`);
+	if (!body) header.push("Transcript unavailable: no readable activity in the bounded artifact tail yet.");
+	return [...header.map((line) => safeTerminalText(line)), body].filter(Boolean).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.");
@@ -313,6 +364,12 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		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 (params.view === "transcript" && deps.state?.currentSessionId) {
+			const controls = [...deps.state.foregroundControls.values()].filter((control) => control.sessionId === currentSessionId);
+			const foreground = controls.find((control) => control.runId === deps.state?.lastForegroundControlId)
+				?? controls.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+			if (foreground) return inspectSubagentStatus({ ...params, id: foreground.runId }, deps);
+		}
 		if (deps.nested) {
 			return {
 				content: [{ type: "text", text: "Child-safe subagent status requires an id when no foreground run is active." }],
@@ -353,6 +410,13 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		} else if (!params.dir && requestedId) {
 			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
 			if (resolved?.kind === "foreground") {
+				const control = deps.state?.foregroundControls.get(resolved.id);
+				if (control && deps.state && params.view === "transcript") {
+					return {
+						content: [{ type: "text", text: formatLiveForegroundTranscript(control, deps.state, params) }],
+						details: { mode: "management", results: [] },
+					};
+				}
 				const run = deps.state?.foregroundRuns?.get(resolved.id);
 				if (run) {
 					try {
@@ -423,7 +487,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const capacity = inspectActiveAsyncCapacityOwner({ runId: diskStatus.runId, sessionId: diskStatus.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
 				return {
 					content: [{ type: "text", text: formatRunLifecycleDebug({ status: diskStatus, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
-					details: { mode: "single", results: [], ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
+					details: { mode: "single", results: [], ...(diskStatus.workflowReceiptPath ? { workflowReceiptPath: diskStatus.workflowReceiptPath } : {}), ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
 				};
 			}
 			if (params.view === "transcript") {
@@ -450,7 +514,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const capacity = inspectActiveAsyncCapacityOwner({ runId: status.runId, sessionId: status.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
 				return {
 					content: [{ type: "text", text: formatRunLifecycleDebug({ status, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
-					details: { mode: "single", results: [], ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
+					details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
 				};
 			}
 			if (params.view === "transcript") {
@@ -626,6 +690,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				}
 			}
 			if (nestedWarning) lines.push(`Warning: ${nestedWarning}`);
+			if (status.workflowReceiptPath) lines.push(`Workflow receipt: ${status.workflowReceiptPath}`);
 			if (status.sessionFile) lines.push(`Session: ${status.sessionFile}`);
 			const allExternal = (status.steps?.length ?? 0) > 0 && status.steps!.every((step) => step.runner?.type === "external-cli" || step.runner?.type === "external-job");
 			if (status.state === "running" && !allExternal && status.mode !== "workflow") lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`);
@@ -639,7 +704,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 
 			const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
 			if (workflowChildren && workflowChildren.workflowRunId !== status.runId) throw new Error("workflowChildren.workflowRunId does not match async status runId.");
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}
 
@@ -680,6 +745,11 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			const runId = data.runId ?? data.id ?? resolvedId;
 			const lines = [`Run: ${runId}`, data.toolCallId ? `Tool call: ${data.toolCallId}` : undefined, `State: ${status}`, `Result: ${resultPath}`].filter((line): line is string => Boolean(line));
 			if (data.parallelHandoff?.path) lines.push(`Parallel handoff: ${data.parallelHandoff.path}`);
+			const receipt = (data as Record<string, unknown>).workflowReceipt;
+			const receiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt)
+				? (receipt as Record<string, unknown>).path : undefined;
+			const workflowReceiptPath = typeof receiptPath === "string" && receiptPath ? receiptPath : undefined;
+			if (workflowReceiptPath) lines.push(`Workflow receipt: ${workflowReceiptPath}`);
 			const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
 			lines.push(...formatTimeoutRecoveryLines(data.timeoutRecovery, "  "));
 			for (const [index, child] of children.entries()) {
@@ -694,7 +764,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			if (data.summary) lines.push("", data.summary);
 			const workflowChildren = parseWorkflowChildSummary((data as unknown as Record<string, unknown>).workflowChildren);
 			if (workflowChildren && workflowChildren.workflowRunId !== runId) throw new Error("workflowChildren.workflowRunId does not match the result run id.");
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(workflowChildren ? { workflowChildren } : {}) } };
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(workflowReceiptPath ? { workflowReceiptPath } : {}), ...(workflowChildren ? { workflowChildren } : {}) } };
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return {