@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/src/runs/background/run-child-session.ts

@@ -19,14 +19,17 @@ import {
 	type ChildWatchdogStatusEvent,
 } from "../../watchdog/child-status.ts";
 import { projectChildLifecycle, type ChildLifecycleAction, type ChildLifecycleState } from "../shared/child-lifecycle.ts";
-import { formatSubagentModelVerificationError } from "../shared/model-fallback.ts";
+import { formatSubagentModelVerificationError } from "../shared/model-resolution.ts";
+import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.ts";
 import { isMutatingTool, resolveCurrentPath } from "../shared/long-running-guard.ts";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, toolTimeoutCallKey } from "../shared/tool-timeout.ts";
 import { createReportedChildSessionInput, type InProcessChildLaunch } from "../shared/child-launch.ts";
-import { projectChildSessionEventForJson, type ChildSession, type ChildSessionEvent, type ChildSessionFactory } from "../shared/child-session.ts";
+import { createPartialOutputTracker, formatPartialOutput, type PartialOutputCause } from "../shared/partial-output.ts";
+import { childSessionHasQueuedMessages, projectChildSessionEventForJson, type ChildSession, type ChildSessionEvent, type ChildSessionFactory } from "../shared/child-session.ts";
+import { reconcileAttemptUsage } from "../shared/usage-reconciliation.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";
+import { takeMatchingAcceptedSteer, unconsumedSteerReason } from "./steering.ts";
 
 export interface ChildEventContext {
 	runId: string;
@@ -84,11 +87,14 @@ export interface RunChildSessionInput {
 	registerTimeout?: (interrupt: (() => void) | undefined) => void;
 	registerStop?: (stop: (() => void) | undefined) => void;
 	registerSteer?: (steer: StepSteerHandler | undefined) => void;
+	/** Consumption (or unconsumed settlement) after the child accepted a steer or follow-up. */
+	onSteerOutcome?: (request: SteerRequest, delivery: SteerDelivery) => void;
 	/** Receives the sink the child's watchdog hook reports status through; the launch's `watchdogStatus` must forward to it. */
 	registerWatchdogStatus?: (sink: ((event: ChildWatchdogStatusEvent) => void) | undefined) => void;
 	timeoutMessage?: string;
 	stopMessage?: string;
 	onChildEvent?: (event: ChildEvent) => void;
+	onContextWindow?: (contextWindow: number) => void;
 	transcriptWriter?: ChildTranscriptWriter;
 	toolTimeoutMs?: number;
 	runDeadlineAt?: number;
@@ -96,16 +102,6 @@ export interface RunChildSessionInput {
 	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 {
@@ -115,9 +111,12 @@ export interface RunChildSessionResult {
 	toolCount: number;
 	durationMs: number;
 	model?: string;
+	nativeMachine?: { provider: "herdr"; machineId: string; initialGit?: import("../../shared/types.ts").HerdrRemoteGitStatus; finalGit?: import("../../shared/types.ts").HerdrRemoteGitStatus };
 	error?: string;
 	finalOutput: string;
 	outputState: SubagentOutputState;
+	/** Unfinished streamed text recovered after a timeout or child error. */
+	outputPartial?: boolean;
 	interrupted?: boolean;
 	timedOut?: boolean;
 	stopped?: boolean;
@@ -131,12 +130,12 @@ export interface RunChildSessionResult {
 	currentToolArgs?: string;
 	currentPath?: string;
 	afterCompactionSettlement?: boolean;
+	abortRecoveryDiagnostic?: string;
 	/** Set by the runner while it finalizes the attempt. */
 	toolBudget?: ToolBudgetState;
 	toolBudgetBlocked?: boolean;
 	structuredOutput?: unknown;
 	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedChildExtensions;
-	abortRecoveryDiagnostic?: string;
 	effects?: EffectsProjection;
 }
 
@@ -179,6 +178,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		let assistantError: string | undefined;
 		let interrupted = false;
 		let timedOut = false;
+		const partialOutput = createPartialOutputTracker();
 		let stopped = false;
 		let observedMutationAttempt = false;
 		let structuredOutputToolInvoked = false;
@@ -188,12 +188,15 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		let currentPath: string | undefined;
 		let toolCount = 0;
 		let session: ChildSession | undefined;
+		let messageBaseline: number | undefined;
+		const acceptedSteers: Array<{ request: SteerRequest; text: string }> = [];
 		let unsubscribe: (() => void) | undefined;
 		let settled = false;
 		let promptSettled = false;
 		let forcedTermination = false;
 		let cleanTerminalAssistantStopReceived = false;
 		let agentSettledReceived = false;
+		let queuedDrainHold = false;
 		let compactionStartedReceived = false;
 		let afterCompactionSettlement = false;
 		let finalDrainTimer: NodeJS.Timeout | undefined;
@@ -248,8 +251,10 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		};
 
 		const abortChild = (): void => {
-			if (!session || settled || promptSettled) return;
-			void session.abort().catch(() => {
+			if (settled || promptSettled) return;
+			// A hung session creation has no session to abort yet; the settle timer below is the only
+			// thing that ends the run, and a session created afterwards is disposed by the launch block.
+			void session?.abort().catch(() => {
 				// The run settles through its prompt promise; abort failures are not separately actionable.
 			});
 			if (!abortSettleTimer) {
@@ -312,14 +317,28 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		}
 		// If the child emits its terminal event but its run never settles (a hook
 		// is stuck), abort it after a short grace period and then finish without it.
+		const observeQueuedDrainHold = (): boolean => {
+			if (childSessionHasQueuedMessages(session)) queuedDrainHold = true;
+			return queuedDrainHold;
+		};
 		function startFinalDrain(): void {
 			if (childWatchdogIsActive(childWatchdogState)) {
 				armWatchdogTail();
 				return;
 			}
+			if (promptSettled || finalDrainTimer || settled) return;
+			if (observeQueuedDrainHold()) return;
+			armFinalDrainTimer();
+		}
+		function armFinalDrainTimer(): void {
 			if (promptSettled || finalDrainTimer || settled) return;
 			finalDrainTimer = setTimeout(() => {
 				if (settled || promptSettled) return;
+				if (input.launch.capture.finalDrainHeld() || observeQueuedDrainHold()) {
+					finalDrainTimer = undefined;
+					armFinalDrainTimer();
+					return;
+				}
 				forcedTermination = true;
 				if (!cleanTerminalAssistantStopReceived && !agentSettledReceived && !error && !assistantError) {
 					error = `Subagent session did not settle within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Aborting it.`;
@@ -335,6 +354,8 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		}
 		const applyChildLifecycle = (action: ChildLifecycleAction): void => {
 			if (action === "cancel-drain") {
+				cleanTerminalAssistantStopReceived = false;
+				agentSettledReceived = false;
 				clearFinalDrainTimers();
 				clearWatchdogTailTimer();
 				return;
@@ -394,14 +415,21 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 
 		const processEvent = (raw: ChildSessionEvent): void => {
 			if (settled) return;
+			partialOutput.observe(raw);
 			const event = raw as ChildSessionEvent & ChildEvent;
 			appendChildEvent(projectChildSessionEventForJson(raw) as Record<string, unknown>);
 			input.transcriptWriter?.writeChildEvent(projectChildSessionEventForJson(raw) as ChildEvent);
-			if (event.type === "compaction_start") compactionStartedReceived = true;
+			if (event.type === "compaction_start") {
+				compactionStartedReceived = true;
+				if (agentSettledReceived) afterCompactionSettlement = true;
+			}
 			if (event.type === "compaction_end" && event.willRetry === true) {
 				compactionStartedReceived = false;
 				afterCompactionSettlement = false;
 			}
+			if (event.type === "turn_start" || event.type === "agent_start" || event.type === "auto_retry_start") {
+				queuedDrainHold = false;
+			}
 			if (event.type === "agent_start" || event.type === "auto_retry_start") {
 				compactionStartedReceived = false;
 				afterCompactionSettlement = false;
@@ -471,6 +499,16 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 				messages.push(event.message);
 				const text = extractTextFromContent(event.message.content);
 				if (text) writeOutputText(text);
+				if (event.type === "message_end" && event.message.role === "user" && text) {
+					const matched = takeMatchingAcceptedSteer(acceptedSteers, text);
+					if (matched) {
+						input.onSteerOutcome?.(matched.request, {
+							state: "delivered",
+							deliveryStatus: "delivered",
+							message: "Child consumed the steering input.",
+						});
+					}
+				}
 
 				if (input.childWatchdog && event.type === "message_end") {
 					const next = applyChildWatchdogMessage(childWatchdogState, event.message);
@@ -481,7 +519,7 @@ 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, input.modelResponseAliases);
+						const modelVerificationError = formatSubagentModelVerificationError(input.expectedModelForVerification, event.message.model, input.modelVerificationRegistry, input.modelResponseAliases, session?.virtualModelId);
 						if (modelVerificationError && !error) error = modelVerificationError;
 					}
 				}
@@ -512,7 +550,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		};
 
 		/** Stops observing the child and returns when its extensions have shut down. */
-		const finish = (): Promise<void> => {
+		const finish = async (): Promise<string | undefined> => {
 			clearFinalDrainTimers();
 			clearWatchdogTailTimer();
 			clearAllToolTimeouts();
@@ -526,40 +564,78 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 			input.registerSteer?.(undefined);
 			input.registerWatchdogStatus?.(undefined);
 			unsubscribe?.();
-			return Promise.resolve().then(() => session?.dispose()).catch(() => undefined);
+			let commandError: string | undefined;
+			if (!interrupted && !timedOut && !stopped) {
+				try { await session?.finishCommands?.(); }
+				catch (error) { commandError = error instanceof Error ? error.message : String(error); }
+			}
+			await Promise.resolve().then(() => session?.dispose()).catch(() => undefined);
+			return commandError;
 		};
 
 		/** The child run ended (or was forced to end); fold in the outcome once the child's shutdown work is done. */
+		const failUnconsumedSteers = (): void => {
+			for (const entry of acceptedSteers.splice(0)) {
+				input.onSteerOutcome?.(entry.request, { state: "failed", message: unconsumedSteerReason(entry.request.mode) });
+			}
+		};
 		const settle = (promptError: unknown, forced = false): void => {
 			if (settled) return;
 			settled = true;
+			failUnconsumedSteers();
+			const terminalUsage = session && messageBaseline !== undefined
+				? reconcileAttemptUsage(usage, session.messages, messageBaseline)
+				: usage;
 			const closed = finish();
-			const finalOutput = getFinalOutput(messages);
+			const completedOutput = getFinalOutput(messages);
+			// Text still streaming at a timeout or thrown session error never reached a
+			// completed message; keep it, labeled. The run still fails.
+			const partialCause: PartialOutputCause | undefined = timedOut
+				? "timeout"
+				: promptError !== undefined && !stopped && !interrupted ? "child error" : undefined;
+			const streamedPartial = partialCause ? partialOutput.text() : undefined;
+			const finalOutput = partialCause && streamedPartial ? formatPartialOutput(streamedPartial, partialCause) : completedOutput;
 			let finalError = error ?? assistantError;
-			if (!finalError && promptError !== undefined) {
-				finalError = promptError instanceof Error ? promptError.message : String(promptError);
+			const promptErrorMessage = promptError === undefined ? undefined : promptError instanceof Error ? promptError.message : String(promptError);
+			if (!finalError && promptErrorMessage !== undefined) {
+				finalError = promptErrorMessage;
+			}
+			// A child launched without the ambient extensions resolves a provider
+			// extension's model as "not found". Annotate only a creation/prompt failure
+			// that produced no turn; keep the core error and add the rule and the
+			// remedies that load the extension for this child.
+			if (promptErrorMessage !== undefined
+				&& finalError === promptErrorMessage
+				&& isChildModelResolutionFailure(promptErrorMessage)
+				&& messages.length === 0
+				&& terminalUsage.turns === 0
+				&& !input.launch.session.ambientExtensions) {
+				finalError = `${promptErrorMessage}\n\n${formatChildModelResolutionDiagnostic({ agent: input.launch.config.agent, model: input.launch.session.model, host: "runner", capabilityCeiling: input.launch.toolPlan.capabilityCeiling })}`;
 			}
 			const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !finalError;
 			const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(messages);
 			if (!finalError && forced && !forcedDrainAfterFinalSuccess && !interrupted && !timedOut && !stopped) {
 				finalError = "Subagent session did not settle after it was aborted.";
 			}
-			const exitCode = timedOut || stopped
+			let exitCode = timedOut || stopped
 				? 1
 				: interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal)
 					? 0
 					: finalError || promptError !== undefined ? 1 : 0;
-			void closed.then(() => {
+			void closed.then((commandError) => {
+				if (commandError) { finalError ??= commandError; exitCode = 1; }
 				const result: RunChildSessionResult = omitUndefined({
 					exitCode,
 					messages,
-					usage,
+					usage: terminalUsage,
 					toolCount,
 					durationMs: Date.now() - startedAt,
 					model,
-					error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal) ? undefined : finalError,
+					nativeMachine: session?.machineEvidence ? { provider: "herdr", machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) } : undefined,
+					error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal && !commandError) ? undefined : finalError,
 					finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
 					outputState: finalOutput.trim() ? "present" : "absent",
+					outputPartial: partialCause && streamedPartial ? true : undefined,
 					interrupted: interrupted || undefined,
 					timedOut: timedOut || undefined,
 					stopped: stopped || undefined,
@@ -573,7 +649,6 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					currentPath,
 					afterCompactionSettlement: afterCompactionSettlement || undefined,
 				});
-				if (session && !forced && !forcedTermination && !interrupted && !timedOut && !stopped && getReadonlySessionEvidence(session)) settledChildren.set(result, session);
 				resolve(result);
 			});
 		};
@@ -595,42 +670,48 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 
 		void (async () => {
 			try {
-				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();
+					await created.dispose().catch(() => undefined);
 					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");
+				if (created.contextWindow !== undefined) input.onContextWindow?.(created.contextWindow);
+				const steer = created.steer.bind(created);
+				const followUp = created.followUp.bind(created);
+				created.steer = async (text) => {
+					if (cleanTerminalAssistantStopReceived || agentSettledReceived) queuedDrainHold = true;
+					return steer(text);
+				};
+				created.followUp = async (text) => {
+					if (cleanTerminalAssistantStopReceived || agentSettledReceived) queuedDrainHold = true;
+					return followUp(text);
+				};
 				unsubscribe = created.subscribe(processEvent);
 				input.registerWatchdogStatus?.((event) => processEvent(event as unknown as ChildSessionEvent));
 				input.registerSteer?.(async (request) => {
 					const text = formatSteerMessage(request);
 					const followUp = request.mode === "follow_up";
+					const accepted = { request, text };
+					acceptedSteers.push(accepted);
+					const queued: SteerDelivery = {
+						state: "queued",
+						deliveryStatus: "queued",
+						message: followUp ? "Pi queued the follow-up input." : "Pi accepted the steering input.",
+					};
 					try {
 						if (followUp) await created.followUp(text);
 						else await created.steer(text);
 					} catch (steerError) {
+						const index = acceptedSteers.indexOf(accepted);
+						if (index >= 0) acceptedSteers.splice(index, 1);
 						return { state: "failed", message: steerError instanceof Error ? steerError.message : String(steerError) };
 					}
-					return followUp
-						? { state: "queued", deliveryStatus: "queued", message: "Pi queued the follow-up input." }
-						: { state: "delivered", deliveryStatus: "delivered", message: "Pi accepted the steering input." };
+					return queued;
 				});
 				if (interrupted || timedOut || stopped) abortChild();
-				checkContinuation();
+				messageBaseline = created.messages.length;
 				await created.prompt(input.prompt);
 				promptSettled = true;
 				settle(undefined);

package/dist/extensions/pi-subagents/src/runs/background/run-id-resolver.ts

@@ -21,11 +21,11 @@ export interface ResolveSubagentRunIdDeps {
 
 function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string): AsyncRunLocation | undefined {
 	const asyncDir = path.join(asyncDirRoot, id);
-	const asyncDirExists = fs.existsSync(asyncDir);
+	const hasStatus = fs.existsSync(path.join(asyncDir, "status.json"));
 	const resultPath = resultPathFor(resultsDir, id);
-	if (!asyncDirExists && !resultPath) return undefined;
+	if (!hasStatus && !resultPath) return undefined;
 	return {
-		asyncDir: asyncDirExists ? asyncDir : null,
+		asyncDir: hasStatus ? asyncDir : null,
 		resultPath,
 		resolvedId: id,
 	};
@@ -131,11 +131,16 @@ function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolu
 	};
 	for (const control of state.foregroundControls.values()) add(control.nestedRoute as NestedRoute | undefined);
 	for (const job of state.asyncJobs.values()) add(job.nestedRoute as NestedRoute | undefined);
+	if (state.retainedNestedLookupRoutes?.sessionId === state.currentSessionId) {
+		for (const route of state.retainedNestedLookupRoutes.routes.values()) add(route);
+	}
 	return { routes };
 }
 
 function asyncPrefixMatches(prefix: string, asyncDirRoot: string, resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
-	return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
+	return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir).filter((match) =>
+		match.location.resultPath || (match.location.asyncDir && fs.existsSync(path.join(match.location.asyncDir, "status.json")))
+	);
 }
 
 export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps = {}): ResolvedSubagentRunId | undefined {
@@ -143,7 +148,6 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
 	const resultsDir = deps.resultsDir ?? DIRS.results;
 
-	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
 	if (hasExactForegroundId(deps.state, id)) return { kind: "foreground", id };
 	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
 	if (exactAsync) return { kind: "async", id, location: exactAsync };
@@ -152,6 +156,7 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	const exactToolCallIdMatches = indexedToolCallIdAsyncLocations(id, asyncDirRoot, resultsDir);
 	if (exactToolCallIdMatches.length > 1) throw new Error(`Subagent tool-call id '${id}' is ambiguous across async runs. Use the returned asyncId instead.`);
 	if (exactToolCallIdMatches[0]) return { kind: "async", id: exactToolCallIdMatches[0].id, location: exactToolCallIdMatches[0].location };
+	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
 	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
 	if (exactNested.length > 1) throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
 	if (exactNested[0]) return { kind: "nested", id, match: exactNested[0] };
@@ -172,4 +177,4 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 		throw new Error(`Ambiguous subagent run id prefix '${id}' matched: ${values.map((match) => `${match.kind}:${match.id}`).join(", ")}. Provide a longer id.`);
 	}
 	return values[0];
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/run-status.ts

@@ -33,6 +33,8 @@ import { getExternalJobProvider } from "../../api/external-job-provider.ts";
 import { formatTimeoutRecoveryLines } from "../shared/mutation-evidence.ts";
 import { formatWorkflowChecklistText, projectWorkflowChecklist } from "../../workflows/workflow-checklist.ts";
 import { validHostStepNodes } from "../shared/host-step-status.ts";
+import { workflowAsyncChildSteeringGuidance } from "../shared/workflow-async-child-guidance.ts";
+import { formatWorkflowKeyRevival, projectWorkflowKeyRevival } from "../../workflows/workflow-revival.ts";
 
 interface RunStatusParams {
 	action?: string;
@@ -570,6 +572,12 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 
 			const workflowReturnPreview = status.workflow?.value !== undefined ? formatWorkflowJsonPreview(status.workflow.value, 240) : undefined;
 			const workflowEmitPreview = status.workflow?.emits.length ? formatWorkflowJsonPreview(status.workflow.emits.at(-1), 240) : undefined;
+			const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
+			if (workflowChildren && workflowChildren.workflowRunId !== status.runId) throw new Error("workflowChildren.workflowRunId does not match async status runId.");
+			const workflowTerminalProof = workflowChildren
+				? readWorkflowTerminalProof(asyncDir, status.steps, workflowChildren, validHostStepNodes(status.workflowGraph).length, status.endedAt ?? status.lastUpdate ?? status.startedAt)
+				: undefined;
+			const workflowChildrenByKey = new Map(workflowChildren?.children.map((child) => [child.childId, child]));
 			const lines = [
 				`Run: ${status.runId}`,
 				status.toolCallId ? `Tool call: ${status.toolCallId}` : undefined,
@@ -588,6 +596,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
 				status.mode === "workflow" && workflowReturnPreview !== undefined ? `Return: ${workflowReturnPreview}` : undefined,
 				status.mode === "workflow" && workflowEmitPreview !== undefined ? `Latest emit: ${workflowEmitPreview}` : undefined,
+				status.mode === "workflow" && (workflowReturnPreview?.endsWith("…") || workflowEmitPreview?.endsWith("…")) ? `Full return value and emits: ${path.join(asyncDir, "status.json")} (workflow.value, workflow.emits)` : undefined,
 				`Progress: ${progressLabel}`,
 				...(status.mode === "workflow" ? formatWorkflowChecklistText(projectWorkflowChecklist({
 					graph: status.workflowGraph,
@@ -615,7 +624,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			let hasExternalJobFollowUpHint = false;
 			for (const [index, step] of (status.steps ?? []).entries()) {
 				const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
-				const modelThinking = formatModelThinking(step.model, step.thinking);
+				const workflowChild = step.workflowKey ? workflowChildrenByKey.get(step.workflowKey) : undefined;
+				const modelThinking = formatModelThinking(step.model ?? workflowChild?.model, step.thinking ?? workflowChild?.thinking);
 				const modelText = modelThinking ? ` (${modelThinking})` : "";
 				const steeringText = formatSteeringSummary(step);
 				const steeringSuffix = steeringText ? `, steering: ${steeringText}` : "";
@@ -625,6 +635,11 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const display = runStatusStepDisplayName(step);
 				const phase = step.phase ? `[${step.phase}] ` : "";
 				lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText}`);
+				if (status.mode === "workflow" && step.runId) lines.push(`  Child run: ${step.runId}`);
+				if (status.mode === "workflow" && step.runId && step.workflowKey && step.status === "failed") {
+					const revival = projectWorkflowKeyRevival(asyncDirRoot, status.runId, step.workflowKey, step.runId);
+					if (revival) lines.push(`  ${formatWorkflowKeyRevival(revival)}`);
+				}
 				const structuredOutputPreview = step.structuredOutput === undefined ? undefined : formatWorkflowJsonPreview(step.structuredOutput, 4_000);
 				if (structuredOutputPreview !== undefined) lines.push(`  Structured output: ${structuredOutputPreview}`);
 				if (step.structuredOutputPath) lines.push(`  Structured output path: ${step.structuredOutputPath}`);
@@ -689,6 +704,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 						lines.push(`Steer live foreground child: subagent({ action: "steer", id: "${control.runId}", index: ${index}, message: "..." })`);
 					}
 				}
+				lines.push(...workflowAsyncChildSteeringGuidance(status, deps.state));
 			}
 			if (nestedWarning) lines.push(`Warning: ${nestedWarning}`);
 			if (status.workflowReceiptPath) lines.push(`Workflow receipt: ${status.workflowReceiptPath}`);
@@ -703,11 +719,6 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
 			if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
 
-			const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
-			if (workflowChildren && workflowChildren.workflowRunId !== status.runId) throw new Error("workflowChildren.workflowRunId does not match async status runId.");
-			const workflowTerminalProof = workflowChildren
-				? readWorkflowTerminalProof(asyncDir, status.steps, workflowChildren, validHostStepNodes(status.workflowGraph).length, status.endedAt ?? status.lastUpdate ?? status.startedAt)
-				: undefined;
 			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 } : {}), ...(workflowTerminalProof ? { workflowTerminalProof } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}
@@ -784,4 +795,4 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		isError: true,
 		details: { mode: "single", results: [] },
 	};
-}
+}