pi-subagents 0.66.0 → 0.68.0

package/src/runs/background/notify.ts

@@ -6,6 +6,7 @@
  * observation channel, not a delivery acknowledgement.
  */
 
+import { statSync } from "node:fs";
 import { debuglog } from "node:util";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
@@ -27,6 +28,10 @@ export interface SubagentNotifyChildOutput {
 	agent?: string;
 	status: string;
 	savedOutputPath?: string;
+	outputArtifactPath?: string;
+	structuredOutputPath?: string;
+	outputArtifactError?: RetainedPathError;
+	structuredOutputError?: RetainedPathError;
 	preview: string;
 	previewTruncated?: boolean;
 	previewUnavailableReason?: string;
@@ -36,6 +41,7 @@ export type SubagentNotifyWatchdogBlocker = Pick<ChildWatchdogWarningSummary, "s
 
 export interface SubagentNotifyDetails {
 	workflowReceiptPath?: string;
+	asyncDir?: string;
 	agent: string;
 	status: "completed" | "failed" | "paused" | "stopped";
 	source?: "async" | "foreground";
@@ -54,6 +60,16 @@ export interface SubagentNotifyDetails {
 	watchdogBlockers?: SubagentNotifyWatchdogBlocker[];
 }
 
+export interface IncrementalChildCompletion {
+	workflowRunId: string;
+	childKey: string;
+	childRunId?: string;
+	outcome: "completed" | "failed" | "paused" | "stopped";
+	outputReference?: string;
+	error?: string;
+	workflowRunning: boolean;
+}
+
 export interface CompletionNotification {
 	[key: string]: unknown;
 	id?: string | null;
@@ -80,9 +96,12 @@ export interface CompletionNotification {
 		success?: boolean;
 		output?: string;
 		structuredOutput?: unknown;
+		structuredOutputPath?: string;
 		outputState?: "present" | "absent" | "unknown";
 		outputReference?: string | { path?: string };
 		artifactPaths?: { outputPath?: string };
+		outputSaveError?: string;
+		artifactOutputSaveFailed?: true;
 		detached?: boolean;
 		exitCode?: number | null;
 		processSignal?: string | null;
@@ -109,6 +128,7 @@ export interface CompletionNotification {
 	intercomDelivered?: boolean;
 	parallelHandoff?: ParallelHandoffReference;
 	scheduleOrigin?: ScheduleOrigin;
+	asyncDir?: string;
 }
 
 interface NotifyTimerApi {
@@ -133,6 +153,11 @@ const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 4 * 1024;
 const CHILD_OUTPUT_PREVIEW_COUNT = 8;
 const PREVIEW_TRUNCATION_MARKER = "...[preview truncated]";
 type CompletionChild = NonNullable<CompletionNotification["results"]>[number];
+interface RetainedPathError { path: string; code?: string; message: string }
+type RetainedPathProjection =
+	| { status: "verified"; path: string }
+	| { status: "unavailable" }
+	| { status: "error"; error: RetainedPathError };
 
 function truncateUtf8Head(value: string, maxBytes: number): { text: string; truncated: boolean } {
 	const bytes = Buffer.from(value, "utf8");
@@ -161,6 +186,27 @@ function childSavedOutputPath(child: CompletionChild): string | undefined {
 	return outputPathFromReference(child.outputReference);
 }
 
+function nonemptyPath(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function retainedChildPath(value: unknown, producerConfirmed = false): RetainedPathProjection {
+	const path = nonemptyPath(value);
+	if (!path) return { status: "unavailable" };
+	if (producerConfirmed) return { status: "verified", path };
+	try {
+		return statSync(path).isFile() ? { status: "verified", path } : { status: "unavailable" };
+	} catch (error) {
+		const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : undefined;
+		if (code === "ENOENT" || code === "ENOTDIR") return { status: "unavailable" };
+		return { status: "error", error: { path, ...(code ? { code } : {}), message: error instanceof Error ? error.message : String(error) } };
+	}
+}
+
+function formatRetainedPathError(label: string, error: RetainedPathError): string {
+	return `  ${label} verification failed: stat ${error.code ? boundedSafeText(error.code, 32) : "unknown"}; path=${boundedSafeText(error.path, 384)}; ${boundedSafeText(error.message, 512)}`;
+}
+
 function childStatus(child: CompletionChild, workflowState?: string): string {
 	const knownStatus = child.status === "complete"
 		? "completed"
@@ -221,6 +267,11 @@ function formatChildOutputBlock(children: SubagentNotifyChildOutput[] | undefine
 		const status = boundedSafeText(child.status) || "unavailable";
 		lines.push(`- key=${key} run=${runId} status=${status}`);
 		lines.push(`  Saved output: ${child.savedOutputPath ? boundedSafeText(child.savedOutputPath) : "unavailable"}`);
+		if (child.outputArtifactPath) lines.push(`  Output artifact (retention-managed): ${boundedSafeText(child.outputArtifactPath)}`);
+		if (child.structuredOutputPath) lines.push(`  Structured output (retention-managed): ${boundedSafeText(child.structuredOutputPath)}`);
+		if (child.outputArtifactError) lines.push(formatRetainedPathError("Output artifact", child.outputArtifactError));
+		if (child.structuredOutputError) lines.push(formatRetainedPathError("Structured output", child.structuredOutputError));
+		if (child.previewTruncated && !child.savedOutputPath && !child.outputArtifactPath) lines.push("  Full output unavailable");
 		if (index >= CHILD_OUTPUT_PREVIEW_COUNT) {
 			lines.push("  Preview: unavailable (notice preview budget exceeded)");
 			continue;
@@ -257,6 +308,7 @@ function formatChildRun(child: { runId: string; workflowKey?: string; agent?: st
 
 function formatCorrelationLines(details: SubagentNotifyDetails): string[] {
 	return [
+		details.asyncDir ? `Retention-managed async directory: ${boundedSafeText(details.asyncDir)}` : undefined,
 		details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : undefined,
 		details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : undefined,
 		details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : undefined,
@@ -308,6 +360,40 @@ export function formatSingleCompletion(details: SubagentNotifyDetails): string {
 		.join("\n");
 }
 
+export function scheduledCompletionTriggersTurn(origin: ScheduleOrigin | undefined, outcome: string): boolean {
+	return !(origin?.quiet === true && outcome === "completed");
+}
+
+/**
+ * Child settlement is useful context, but an ordinary successful child does not
+ * establish the workflow's dependency barrier while its workflow is running.
+ * Keep actionable outcomes waking the parent, and preserve a terminal child as
+ * the barrier for hosts that do not emit a separate workflow completion wake.
+ */
+export function incrementalChildCompletionTriggersTurn(
+	child: Pick<IncrementalChildCompletion, "outcome" | "workflowRunning">,
+	origin: ScheduleOrigin | undefined,
+): boolean {
+	if (child.workflowRunning && child.outcome === "completed") return false;
+	return scheduledCompletionTriggersTurn(origin, child.outcome);
+}
+
+export function formatIncrementalChildCompletion(child: IncrementalChildCompletion): string {
+	const statusText = child.outcome === "completed" ? "completed"
+		: child.outcome === "failed" ? "failed"
+			: child.outcome === "paused" ? "paused (needs attention)"
+				: "stopped";
+	const workflowStatus = child.workflowRunning ? "workflow still running" : "workflow finished";
+	return [
+		`Workflow child ${statusText}: **${child.childKey}**`,
+		`Workflow run: ${child.workflowRunId}`,
+		...(child.childRunId ? [`Child run: ${child.childRunId}`] : []),
+		...(child.outputReference ? [`Output: ${child.outputReference}`] : []),
+		...(child.error ? [`Error: ${child.error}`] : []),
+		`Status: ${workflowStatus}`,
+	].join("\n");
+}
+
 export function parseSubagentNotifyContent(content: string): SubagentNotifyDetails | undefined {
 	const lines = content.split("\n");
 	const match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
@@ -529,12 +615,20 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 			const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
 			const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
 			const savedOutputPath = childSavedOutputPath(child);
+			const outputArtifact = child.artifactOutputSaveFailed === true ? { status: "unavailable" as const } : retainedChildPath(child.artifactPaths?.outputPath);
+			const structuredOutput = child.stopped === true || child.timedOut === true
+				? { status: "unavailable" as const }
+				: retainedChildPath(child.structuredOutputPath, child.structuredOutput !== undefined);
 			return {
 				...(workflowKey ? { workflowKey } : {}),
 				...(runId ? { runId } : {}),
 				...(typeof child.agent === "string" ? { agent: child.agent } : {}),
 				status: childStatus(child, result.state),
 				...(savedOutputPath ? { savedOutputPath } : {}),
+				...(outputArtifact.status === "verified" ? { outputArtifactPath: outputArtifact.path } : {}),
+				...(structuredOutput.status === "verified" ? { structuredOutputPath: structuredOutput.path } : {}),
+				...(outputArtifact.status === "error" ? { outputArtifactError: outputArtifact.error } : {}),
+				...(structuredOutput.status === "error" ? { structuredOutputError: structuredOutput.error } : {}),
 				...(inline.preview ? { preview: inline.preview } : { preview: "" }),
 				...(inline.truncated ? { previewTruncated: true } : {}),
 				...(inline.unavailableReason ? { previewUnavailableReason: inline.unavailableReason } : {}),
@@ -542,15 +636,18 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		})
 		: undefined;
 	const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
+	const asyncDir = nonemptyPath(result.asyncDir);
 	const watchdogBlockers: SubagentNotifyWatchdogBlocker[] = [];
-	const collectWatchdogBlockers = (owner: string, progress: ChildWatchdogProgress | undefined) => {
+	const watchdogConcerns: string[] = [];
+	const collectWatchdogFindings = (owner: string, progress: ChildWatchdogProgress | undefined) => {
 		for (const warning of progress?.warnings ?? []) {
-			if (warning.severity !== "blocker") continue;
-			watchdogBlockers.push({ agent: owner, summary: warning.summary, addressed: warning.addressed, stalemate: warning.stalemate });
+			if (warning.importance !== "high") continue;
+			if (warning.severity === "blocker") watchdogBlockers.push({ agent: owner, summary: warning.summary, addressed: warning.addressed, stalemate: warning.stalemate });
+			else watchdogConcerns.push(`${owner}: ${warning.summary}\nEvidence: ${warning.evidence}\nRecommended action: ${warning.recommendedAction}`);
 		}
 	};
-	collectWatchdogBlockers(agent, result.watchdog);
-	for (const child of result.results ?? []) collectWatchdogBlockers(typeof child.agent === "string" ? child.agent : agent, child.watchdog);
+	collectWatchdogFindings(agent, result.watchdog);
+	for (const child of result.results ?? []) collectWatchdogFindings(typeof child.agent === "string" ? child.agent : agent, child.watchdog);
 	const session =
 		result.shareUrl
 			? { label: "Session", value: result.shareUrl }
@@ -568,9 +665,10 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		status,
 		...(scheduleOrigin ? { scheduleOrigin } : {}),
 		...(workflowReceiptPath ? { workflowReceiptPath } : {}),
+		...(asyncDir ? { asyncDir } : {}),
 		...(result.source ? { source: result.source } : {}),
 		...(taskInfo ? { taskInfo } : {}),
-		resultPreview,
+		resultPreview: watchdogConcerns.length ? `${resultPreview}\n\nHigh-importance watchdog concerns:\n${watchdogConcerns.map((warning) => `- ${warning}`).join("\n")}` : resultPreview,
 		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
 		...(handoffPath ? { handoffPath } : {}),
 		...(workflowRunId ? { workflowRunId } : {}),
@@ -675,7 +773,7 @@ export default function registerSubagentNotify(
 			details,
 			sessionId: result.sessionId,
 			completionOwnerId: result.completionOwnerId,
-			triggerTurn: result.triggerTurn !== false,
+			triggerTurn: result.triggerTurn !== false && scheduledCompletionTriggersTurn(result.scheduleOrigin, details.status),
 			resolve,
 		};
 		if (notificationDebug.enabled) item.trace = traceIdentity(result);

package/src/runs/background/owned-process-tree.ts

@@ -35,6 +35,23 @@ function activeProcessGroupMembers(processGroupId: number): number[] | { diagnos
 	return members;
 }
 
+function knownDetachedDescendants(processGroupId: number): number[] {
+	const result = spawnSync("ps", ["-axo", "pid=,ppid=,pgid=,stat="], { encoding: "utf-8" });
+	if (result.error || result.status !== 0) return [];
+	const owned = new Set<number>();
+	const outside: { pid: number; ppid: number }[] = [];
+	for (const line of result.stdout.split("\n")) {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+		if (!match || match[4]!.startsWith("Z")) continue;
+		const pid = Number(match[1]);
+		const ppid = Number(match[2]);
+		const pgid = Number(match[3]);
+		if (pgid === processGroupId) owned.add(pid);
+		else outside.push({ pid, ppid });
+	}
+	return outside.filter((row) => owned.has(row.ppid)).map((row) => row.pid);
+}
+
 async function waitUntilGroupTerminal(
 	processGroupId: number,
 	timeoutMs: number,
@@ -56,6 +73,15 @@ function observed(processGroupId: number): ProcessTreeTerminal {
 	return { state: "observed", mechanism: "posix-process-group", processGroupId, verifiedAt: Date.now() };
 }
 
+function observedUnlessLiveDetached(processGroupId: number, detached: readonly number[]): ProcessTreeTerminal {
+	const live = detached.filter((pid) => {
+		const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
+		return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
+	});
+	if (live.length === 0) return observed(processGroupId);
+	return { state: "unknown", reason: "verification-failed", diagnostic: `Owned detached descendant(s) still active: ${live.join(", ")}.` };
+}
+
 /** Owns one writer process group and arbitrates its cleanup exactly once. */
 export interface OwnedProcessTreeController {
 	terminate(): Promise<ProcessTreeTerminal>;
@@ -77,12 +103,13 @@ export function createOwnedProcessTreeController(
 				signalProcess(target, "SIGTERM");
 				return { state: "unknown", reason: "unsupported-platform" };
 			}
+			const detached = knownDetachedDescendants(pid);
 			const term = signalProcess(target, "SIGTERM");
 			if (term !== "sent" && term !== "absent") {
 				return { state: "unknown", reason: "signal-failed", diagnostic: term.diagnostic };
 			}
 			const termExit = await waitUntilGroupTerminal(pid, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS);
-			if (termExit === false) return observed(pid);
+			if (termExit === false) return observedUnlessLiveDetached(pid, detached);
 
 			const kill = signalProcess(target, "SIGKILL");
 			if (kill !== "sent" && kill !== "absent") {
@@ -95,7 +122,7 @@ export function createOwnedProcessTreeController(
 			if (killExit !== false) {
 				return { state: "unknown", reason: "verification-failed", diagnostic: killExit.diagnostic };
 			}
-			return observed(pid);
+			return observedUnlessLiveDetached(pid, detached);
 		})();
 		return termination;
 	};

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

@@ -241,10 +241,15 @@ function pendingResultExists(resultsDir: string, sessionId: string, runId: strin
 	return firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId)) !== undefined;
 }
 
+export function resultPayloadMatchesSessionRun(data: unknown, sessionId: string, runId: string): boolean {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+	const record = data as Record<string, unknown>;
+	return (nonEmptyString(record.runId) ?? nonEmptyString(record.id)) === runId && nonEmptyString(record.sessionId) === sessionId;
+}
+
 function pendingResultPayloadMatches(filePath: string, sessionId: string, runId: string): boolean {
 	try {
-		const data = JSON.parse(fs.readFileSync(filePath, "utf-8")) as Record<string, unknown>;
-		return (nonEmptyString(data.runId) ?? nonEmptyString(data.id)) === runId && nonEmptyString(data.sessionId) === sessionId;
+		return resultPayloadMatchesSessionRun(JSON.parse(fs.readFileSync(filePath, "utf-8")), sessionId, runId);
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !isUnaddressableResultCandidate(error)) console.error(`Ignoring invalid pending async result '${filePath}':`, error);
 		return false;
@@ -252,8 +257,7 @@ function pendingResultPayloadMatches(filePath: string, sessionId: string, runId:
 }
 
 function assertPendingResultPayloadMatches(filePath: string, sessionId: string, runId: string): boolean {
-	const data = JSON.parse(fs.readFileSync(filePath, "utf-8")) as Record<string, unknown>;
-	return (nonEmptyString(data.runId) ?? nonEmptyString(data.id)) === runId && nonEmptyString(data.sessionId) === sessionId;
+	return resultPayloadMatchesSessionRun(JSON.parse(fs.readFileSync(filePath, "utf-8")), sessionId, runId);
 }
 
 export function promotePendingResultFile(resultsDir: string, sessionId: string, runId: string, file = resultFileName(runId), options: { logFailure?: boolean } = {}): "none" | "promoted" | "pending" {

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

@@ -70,6 +70,7 @@ type ResultFileChild = {
 	sessionName?: string;
 	output?: string;
 	structuredOutput?: unknown;
+	structuredOutputPath?: string;
 	outputState?: SubagentOutputState;
 	error?: string;
 	success?: boolean;
@@ -81,6 +82,8 @@ type ResultFileChild = {
 	processSignal?: string | null;
 	sessionFile?: string;
 	artifactPaths?: { outputPath?: string };
+	outputSaveError?: string;
+	artifactOutputSaveFailed?: true;
 	intercomTarget?: string;
 	children?: unknown;
 };
@@ -408,7 +411,9 @@ export function createResultWatcher(
 			if (typeof data.sessionId !== "string" || !data.sessionId) return;
 			const sessionId = data.sessionId;
 			const completionOwnerId = data.completionOwnerId;
-			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
+			const runId = typeof data.runId === "string" && data.runId
+				? data.runId
+				: typeof data.id === "string" && data.id ? data.id : file.replace(/\.json$/i, "");
 			const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : undefined;
 			let observerSucceeded = true;
 			try {
@@ -428,7 +433,7 @@ export function createResultWatcher(
 			if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 			// Recorded before dedupe and before the unlink below so bg_wait can
 			// use the in-memory record or its bounded durable replay after cleanup.
-			recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
+			const completionPersisted = recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
 				resultsDir,
 				sessionId,
 			});
@@ -456,6 +461,10 @@ export function createResultWatcher(
 				}
 				if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 				if (markReplacedPayload()) return;
+				if (!completionPersisted) {
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+					return;
+				}
 				if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 				return;
 			}
@@ -513,6 +522,10 @@ export function createResultWatcher(
 				}
 				if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 				if (markReplacedPayload()) return;
+				if (!completionPersisted) {
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+					return;
+				}
 				if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 				return;
 			}
@@ -600,6 +613,10 @@ export function createResultWatcher(
 				return;
 			}
 			if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
+			if (!completionPersisted) {
+				scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+				return;
+			}
 			if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 		} catch (error) {
 			if (isAccessDenied(error)) {

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

@@ -19,14 +19,15 @@ 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 { childSessionHasQueuedMessages, 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";
+import { takeMatchingAcceptedSteer, unconsumedSteerReason } from "./steering.ts";
 
 export interface ChildEventContext {
 	runId: string;
@@ -84,6 +85,8 @@ 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;
@@ -96,16 +99,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,6 +108,7 @@ 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;
@@ -130,12 +124,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;
 }
 
@@ -187,12 +181,14 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		let currentPath: string | undefined;
 		let toolCount = 0;
 		let session: ChildSession | 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;
@@ -311,14 +307,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.`;
@@ -334,6 +344,8 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		}
 		const applyChildLifecycle = (action: ChildLifecycleAction): void => {
 			if (action === "cancel-drain") {
+				cleanTerminalAssistantStopReceived = false;
+				agentSettledReceived = false;
 				clearFinalDrainTimers();
 				clearWatchdogTailTimer();
 				return;
@@ -401,6 +413,9 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 				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;
@@ -470,6 +485,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);
@@ -529,14 +554,33 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 		};
 
 		/** 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 closed = finish();
 			const finalOutput = getFinalOutput(messages);
 			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
+				&& usage.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);
@@ -556,6 +600,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					toolCount,
 					durationMs: Date.now() - startedAt,
 					model,
+					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) ? undefined : finalError,
 					finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
 					outputState: finalOutput.trim() ? "present" : "absent",
@@ -572,7 +617,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);
 			});
 		};
@@ -594,42 +638,46 @@ 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();
 					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");
+				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();
 				await created.prompt(input.prompt);
 				promptSettled = true;
 				settle(undefined);