pi-subagents 0.69.0 → 0.70.0

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

@@ -1,690 +0,0 @@
-/**
- * Drives one in-process child session for the detached async runner: creates
- * the session through the runner's `ChildSessionFactory`, mirrors its events
- * into `events.jsonl`, the transcript, and the step output log, applies
- * interrupt, timeout, stop, and steer requests, and folds the run into the
- * step result the runner finalizes.
- */
-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, RuntimeAcknowledgedChildExtensions, SubagentOutputState, ToolBudgetState, Usage } from "../../shared/types.ts";
-import {
-	acceptChildWatchdogEvent,
-	applyChildWatchdogMessage,
-	childWatchdogIsActive,
-	isChildWatchdogStatusEvent,
-	type ChildWatchdogConfig,
-	type ChildWatchdogStateSnapshot,
-	type ChildWatchdogStatusEvent,
-} from "../../watchdog/child-status.ts";
-import { projectChildLifecycle, type ChildLifecycleAction, type ChildLifecycleState } from "../shared/child-lifecycle.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 { childSessionHasQueuedMessages, projectChildSessionEventForJson, type ChildSession, type ChildSessionEvent, type ChildSessionFactory } from "../shared/child-session.ts";
-import { formatSteerMessage } from "../shared/subagent-prompt-runtime.ts";
-import type { SteerDeliveryStatus, SteerRequest } from "./control-channel.ts";
-import { takeMatchingAcceptedSteer, unconsumedSteerReason } from "./steering.ts";
-
-export interface ChildEventContext {
-	runId: string;
-	stepIndex: number;
-	agent: string;
-}
-
-export interface ChildUsage {
-	input?: number;
-	inputTokens?: number;
-	output?: number;
-	outputTokens?: number;
-	cacheRead?: number;
-	cacheReadTokens?: number;
-	cacheWrite?: number;
-	cost?: { total?: number };
-}
-
-export type ChildMessage = Message & {
-	model?: string;
-	errorMessage?: string;
-	usage?: ChildUsage;
-};
-
-export interface ChildEvent {
-	type?: string;
-	message?: ChildMessage;
-	toolName?: string;
-	toolCallId?: string;
-	args?: Record<string, unknown>;
-	willRetry?: unknown;
-}
-
-/** Outcome of handing a steer request to a live child session. */
-export interface SteerDelivery {
-	state: "delivered" | "queued" | "failed";
-	deliveryStatus?: SteerDeliveryStatus;
-	message: string;
-}
-
-export type StepSteerHandler = (request: SteerRequest) => Promise<SteerDelivery>;
-
-export interface RunChildSessionInput {
-	factory: ChildSessionFactory;
-	launch: InProcessChildLaunch;
-	/** Prompt text; the task with its `Task:` prefix. */
-	prompt: string;
-	childWatchdog?: ChildWatchdogConfig;
-	childEventContext?: ChildEventContext;
-	/** Persist one child event into `events.jsonl`; the runner owns the bounded log. */
-	appendChildEvent: (event: Record<string, unknown>) => void;
-	/** Append one line to the step output log and the progress tab. */
-	writeOutputLine: (line: string) => void;
-	registerInterrupt?: (interrupt: (() => void) | undefined) => void;
-	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;
-	transcriptWriter?: ChildTranscriptWriter;
-	toolTimeoutMs?: number;
-	runDeadlineAt?: number;
-	expectedModelForVerification?: string;
-	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string }>;
-	modelResponseAliases?: Record<string, string[]>;
-	mutationTools?: readonly string[];
-}
-
-export interface RunChildSessionResult {
-	exitCode: number;
-	messages: Message[];
-	usage: Usage;
-	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;
-	interrupted?: boolean;
-	timedOut?: boolean;
-	stopped?: boolean;
-	observedMutationAttempt?: boolean;
-	structuredOutputToolInvoked?: boolean;
-	structuredOutputMessageStartIndex?: number;
-	watchdog?: ChildWatchdogStateSnapshot;
-	sessionFile?: string;
-	currentTool?: string;
-	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;
-	effects?: EffectsProjection;
-}
-
-/** Events the child emits while the model streams; not persisted into the diagnostic log. */
-function shouldPersistChildEvent(event: Record<string, unknown>): boolean {
-	return event.type !== "message_update";
-}
-
-function assistantStartsToolCall(message: Message): boolean {
-	return Array.isArray(message.content)
-		&& message.content.some((part) => (part as { type?: string }).type === "toolCall");
-}
-
-function isTerminalAssistantStop(message: Message): boolean {
-	return (message as { stopReason?: string }).stopReason === "stop" && !assistantStartsToolCall(message);
-}
-
-function emptyUsage(): Usage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-function omitUndefined<T extends object>(value: T): T {
-	for (const key of Object.keys(value) as Array<keyof T>) {
-		if (value[key] === undefined) delete value[key];
-	}
-	return value;
-}
-
-const FINAL_STOP_GRACE_MS = 1000;
-const HARD_FINISH_MS = 3000;
-const ABORT_SETTLE_MS = 3000;
-
-export function runChildSession(input: RunChildSessionInput): Promise<RunChildSessionResult> {
-	return new Promise((resolve) => {
-		const startedAt = Date.now();
-		const messages: Message[] = [];
-		const usage = emptyUsage();
-		let model: string | undefined;
-		let error: string | undefined;
-		let assistantError: string | undefined;
-		let interrupted = false;
-		let timedOut = false;
-		let stopped = false;
-		let observedMutationAttempt = false;
-		let structuredOutputToolInvoked = false;
-		let structuredOutputMessageStartIndex: number | undefined;
-		let currentTool: string | undefined;
-		let currentToolArgs: string | undefined;
-		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;
-		let finalHardFinishTimer: NodeJS.Timeout | undefined;
-		let watchdogTailTimer: NodeJS.Timeout | undefined;
-		let abortSettleTimer: NodeJS.Timeout | undefined;
-		let childWatchdogState: ChildWatchdogStateSnapshot | undefined;
-		const childLifecycleState: ChildLifecycleState = { compactionRetryActive: false };
-		const timeoutMessage = () => input.timeoutMessage ?? "Subagent timed out.";
-		const stopMessage = () => input.stopMessage ?? "Subagent stopped by user.";
-
-		type ActiveToolCall = { key: string; tool: string; args?: string; path?: string };
-		let activeToolSequence = 0;
-		const activeToolCalls = new Map<string, ActiveToolCall>();
-		const activeToolKeysByName = new Map<string, string[]>();
-		const refreshCurrentTool = (): void => {
-			const active = [...activeToolCalls.values()].at(-1);
-			currentTool = active?.tool;
-			currentToolArgs = active?.args;
-			currentPath = active?.path;
-		};
-		const recordActiveToolCall = (event: { toolCallId?: unknown; toolName: string; args?: Record<string, unknown> }): void => {
-			const key = toolTimeoutCallKey(event, ++activeToolSequence);
-			const active = omitUndefined({
-				key,
-				tool: event.toolName,
-				args: extractToolArgsPreview(event.args ?? {}),
-				path: resolveCurrentPath(event.toolName, event.args),
-			});
-			activeToolCalls.set(key, active);
-			const keys = activeToolKeysByName.get(active.tool) ?? [];
-			keys.push(key);
-			activeToolKeysByName.set(active.tool, keys);
-			refreshCurrentTool();
-		};
-		const removeActiveToolCall = (event: { toolCallId?: unknown; toolName?: unknown }): void => {
-			const key = typeof event.toolCallId === "string" && event.toolCallId.length > 0
-				? `id:${event.toolCallId}`
-				: typeof event.toolName === "string"
-					? activeToolKeysByName.get(event.toolName)?.[0]
-					: activeToolCalls.size === 1
-						? [...activeToolCalls.keys()][0]
-						: undefined;
-			if (!key) return;
-			const active = activeToolCalls.get(key);
-			if (!active) return;
-			activeToolCalls.delete(key);
-			const keys = activeToolKeysByName.get(active.tool)?.filter((candidate) => candidate !== key) ?? [];
-			if (keys.length > 0) activeToolKeysByName.set(active.tool, keys);
-			else activeToolKeysByName.delete(active.tool);
-			refreshCurrentTool();
-		};
-
-		const abortChild = (): void => {
-			if (!session || settled || promptSettled) return;
-			void session.abort().catch(() => {
-				// The run settles through its prompt promise; abort failures are not separately actionable.
-			});
-			if (!abortSettleTimer) {
-				abortSettleTimer = setTimeout(() => {
-					abortSettleTimer = undefined;
-					if (!settled && !promptSettled) settle(undefined, true);
-				}, ABORT_SETTLE_MS);
-				abortSettleTimer.unref?.();
-			}
-		};
-
-		const writeOutputText = (text: string) => {
-			for (const line of text.split("\n")) {
-				if (line.trim()) input.writeOutputLine(line);
-			}
-		};
-		const appendChildEvent = (event: Record<string, unknown>) => {
-			if (!input.childEventContext) return;
-			if (!shouldPersistChildEvent(event)) return;
-			input.appendChildEvent({
-				...event,
-				subagentSource: "child",
-				subagentRunId: input.childEventContext.runId,
-				subagentStepIndex: input.childEventContext.stepIndex,
-				subagentAgent: input.childEventContext.agent,
-				observedAt: Date.now(),
-			});
-		};
-
-		const clearWatchdogTailTimer = (): void => {
-			if (watchdogTailTimer) {
-				clearTimeout(watchdogTailTimer);
-				watchdogTailTimer = undefined;
-			}
-		};
-		const clearFinalDrainTimers = (): void => {
-			if (finalDrainTimer) {
-				clearTimeout(finalDrainTimer);
-				finalDrainTimer = undefined;
-			}
-			if (finalHardFinishTimer) {
-				clearTimeout(finalHardFinishTimer);
-				finalHardFinishTimer = undefined;
-			}
-		};
-		function armWatchdogTail(): void {
-			if ((!cleanTerminalAssistantStopReceived && !agentSettledReceived) || watchdogTailTimer || settled || promptSettled) return;
-			watchdogTailTimer = setTimeout(() => {
-				watchdogTailTimer = undefined;
-				childWatchdogState = {
-					phase: "stale",
-					seq: (childWatchdogState?.seq ?? 0) + 1,
-					lastUpdate: Date.now(),
-					reason: "child watchdog tail timeout",
-					timedOut: true,
-				};
-				startFinalDrain();
-			}, input.childWatchdog?.watchdogTailTimeoutMs ?? 120_000);
-			watchdogTailTimer.unref?.();
-		}
-		// 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.`;
-				}
-				abortChild();
-				finalHardFinishTimer = setTimeout(() => {
-					if (settled || promptSettled) return;
-					settle(undefined, true);
-				}, HARD_FINISH_MS);
-				finalHardFinishTimer.unref?.();
-			}, FINAL_STOP_GRACE_MS);
-			finalDrainTimer.unref?.();
-		}
-		const applyChildLifecycle = (action: ChildLifecycleAction): void => {
-			if (action === "cancel-drain") {
-				cleanTerminalAssistantStopReceived = false;
-				agentSettledReceived = false;
-				clearFinalDrainTimers();
-				clearWatchdogTailTimer();
-				return;
-			}
-			if (action === "start-drain") startFinalDrain();
-		};
-
-		let toolTimeoutSequence = 0;
-		const activeToolTimeouts = new Map<string, { toolName: string; timer: ReturnType<typeof setTimeout> }>();
-		const activeToolTimeoutKeysByName = new Map<string, string[]>();
-		const removeToolTimeoutKey = (key: string): void => {
-			const active = activeToolTimeouts.get(key);
-			if (!active) return;
-			clearTimeout(active.timer);
-			activeToolTimeouts.delete(key);
-			const keys = activeToolTimeoutKeysByName.get(active.toolName)?.filter((candidate) => candidate !== key) ?? [];
-			if (keys.length > 0) activeToolTimeoutKeysByName.set(active.toolName, keys);
-			else activeToolTimeoutKeysByName.delete(active.toolName);
-		};
-		const clearActiveToolTimeout = (event: { toolCallId?: unknown; toolName?: unknown }): void => {
-			const key = typeof event.toolCallId === "string" && event.toolCallId.length > 0
-				? `id:${event.toolCallId}`
-				: typeof event.toolName === "string"
-					? activeToolTimeoutKeysByName.get(event.toolName)?.[0]
-					: activeToolTimeouts.size === 1
-						? [...activeToolTimeouts.keys()][0]
-						: undefined;
-			if (key) removeToolTimeoutKey(key);
-		};
-		const clearAllToolTimeouts = (): void => {
-			for (const key of [...activeToolTimeouts.keys()]) removeToolTimeoutKey(key);
-		};
-		const terminateForTimeout = (message: string): void => {
-			if (settled || promptSettled || timedOut || stopped) return;
-			timedOut = true;
-			interrupted = false;
-			error = message;
-			abortChild();
-		};
-		const armToolTimeout = (event: { toolCallId?: unknown; toolName: string }): void => {
-			const timeoutForTool = effectiveToolTimeoutMs(event.toolName, input.toolTimeoutMs);
-			if (timeoutForTool === undefined) return;
-			const runRemaining = input.runDeadlineAt === undefined ? undefined : Math.max(0, input.runDeadlineAt - Date.now());
-			if (runRemaining !== undefined && timeoutForTool >= runRemaining) return;
-			const key = toolTimeoutCallKey(event, ++toolTimeoutSequence);
-			const toolName = event.toolName;
-			const timer = setTimeout(() => {
-				removeToolTimeoutKey(key);
-				terminateForTimeout(formatToolTimeoutMessage(toolName, timeoutForTool));
-			}, timeoutForTool);
-			timer.unref?.();
-			activeToolTimeouts.set(key, { toolName, timer });
-			const keys = activeToolTimeoutKeysByName.get(toolName) ?? [];
-			keys.push(key);
-			activeToolTimeoutKeysByName.set(toolName, keys);
-		};
-
-		const processEvent = (raw: ChildSessionEvent): void => {
-			if (settled) return;
-			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_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;
-			}
-			const lifecycleAction = projectChildLifecycle(event, false, childLifecycleState);
-			if (event.type === "agent_settled" && lifecycleAction === "start-drain") {
-				agentSettledReceived = true;
-				afterCompactionSettlement = compactionStartedReceived;
-			}
-			applyChildLifecycle(lifecycleAction);
-
-			if (isChildWatchdogStatusEvent(event)) {
-				if (!input.childWatchdog) return;
-				const next = acceptChildWatchdogEvent({
-					current: childWatchdogState,
-					event,
-					...(input.childEventContext ? {
-						runId: input.childEventContext.runId,
-						agent: input.childEventContext.agent,
-						childIndex: input.childEventContext.stepIndex,
-					} : {}),
-				});
-				if (!next) return;
-				childWatchdogState = next;
-				input.onChildEvent?.(event);
-				if (childWatchdogIsActive(next)) {
-					clearFinalDrainTimers();
-					armWatchdogTail();
-				} else {
-					clearWatchdogTailTimer();
-					if (cleanTerminalAssistantStopReceived || agentSettledReceived) startFinalDrain();
-				}
-				return;
-			}
-
-			input.onChildEvent?.(event);
-
-			if (event.type === "tool_execution_end") {
-				clearActiveToolTimeout(event);
-				removeActiveToolCall(event);
-				return;
-			}
-
-			if (event.type === "tool_execution_start" && event.toolName) {
-				toolCount += 1;
-				const toolArgs = event.args && typeof event.args === "object" && !Array.isArray(event.args) ? event.args : {};
-				armToolTimeout({ toolCallId: event.toolCallId, toolName: event.toolName });
-				recordActiveToolCall({ toolCallId: event.toolCallId, toolName: event.toolName, args: toolArgs });
-				if (event.toolName === "structured_output") {
-					structuredOutputToolInvoked = true;
-					structuredOutputMessageStartIndex = messages.length;
-				}
-				observedMutationAttempt = observedMutationAttempt || isMutatingTool(event.toolName, toolArgs, input.mutationTools);
-				const preview = extractToolArgsPreview(toolArgs);
-				input.writeOutputLine(preview ? `${event.toolName}: ${preview}` : event.toolName);
-				return;
-			}
-
-			if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
-				if (event.type === "tool_result_end") {
-					clearActiveToolTimeout(event);
-					removeActiveToolCall({
-						toolCallId: (event.message as { toolCallId?: unknown }).toolCallId ?? event.toolCallId,
-						toolName: (event.message as { toolName?: unknown }).toolName ?? event.toolName,
-					});
-				}
-				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);
-					if (next) childWatchdogState = next;
-				}
-				if (event.type !== "message_end" || event.message.role !== "assistant") return;
-				const hasToolCall = assistantStartsToolCall(event.message);
-				if (event.message.model) {
-					model = event.message.model;
-					if (input.expectedModelForVerification && !hasToolCall) {
-						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++;
-					usage.input += eventUsage.input ?? eventUsage.inputTokens ?? 0;
-					usage.output += eventUsage.output ?? eventUsage.outputTokens ?? 0;
-					usage.cacheRead += eventUsage.cacheRead ?? 0;
-					usage.cacheWrite += eventUsage.cacheWrite ?? 0;
-					usage.cost += eventUsage.cost?.total ?? 0;
-				}
-				if (isTerminalAssistantStop(event.message)) {
-					if (!event.message.errorMessage && extractTextFromContent(event.message.content).trim()) assistantError = undefined;
-					cleanTerminalAssistantStopReceived ||= !event.message.errorMessage;
-					clearAllToolTimeouts();
-					activeToolCalls.clear();
-					activeToolKeysByName.clear();
-					refreshCurrentTool();
-					applyChildLifecycle(projectChildLifecycle(event, true, childLifecycleState));
-				}
-			}
-		};
-
-		/** Stops observing the child and returns when its extensions have shut down. */
-		const finish = (): Promise<void> => {
-			clearFinalDrainTimers();
-			clearWatchdogTailTimer();
-			clearAllToolTimeouts();
-			if (abortSettleTimer) {
-				clearTimeout(abortSettleTimer);
-				abortSettleTimer = undefined;
-			}
-			input.registerInterrupt?.(undefined);
-			input.registerTimeout?.(undefined);
-			input.registerStop?.(undefined);
-			input.registerSteer?.(undefined);
-			input.registerWatchdogStatus?.(undefined);
-			unsubscribe?.();
-			return Promise.resolve().then(() => session?.dispose()).catch(() => undefined);
-		};
-
-		/** 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;
-			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);
-			if (!finalError && forced && !forcedDrainAfterFinalSuccess && !interrupted && !timedOut && !stopped) {
-				finalError = "Subagent session did not settle after it was aborted.";
-			}
-			const exitCode = timedOut || stopped
-				? 1
-				: interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal)
-					? 0
-					: finalError || promptError !== undefined ? 1 : 0;
-			void closed.then(() => {
-				const result: RunChildSessionResult = omitUndefined({
-					exitCode,
-					messages,
-					usage,
-					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",
-					interrupted: interrupted || undefined,
-					timedOut: timedOut || undefined,
-					stopped: stopped || undefined,
-					observedMutationAttempt,
-					structuredOutputToolInvoked,
-					structuredOutputMessageStartIndex,
-					watchdog: childWatchdogState,
-					sessionFile: session?.sessionFile,
-					currentTool,
-					currentToolArgs,
-					currentPath,
-					afterCompactionSettlement: afterCompactionSettlement || undefined,
-				});
-				resolve(result);
-			});
-		};
-
-		input.registerInterrupt?.(() => {
-			if (settled || promptSettled || timedOut || stopped) return;
-			interrupted = true;
-			if (!error) error = "Interrupted. Waiting for explicit next action.";
-			abortChild();
-		});
-		input.registerTimeout?.(() => terminateForTimeout(timeoutMessage()));
-		input.registerStop?.(() => {
-			if (settled || promptSettled || timedOut || stopped) return;
-			stopped = true;
-			interrupted = false;
-			error = stopMessage();
-			abortChild();
-		});
-
-		void (async () => {
-			try {
-				const createInput = createReportedChildSessionInput(input.launch, input.transcriptWriter);
-				const created = await input.factory.create(createInput);
-				if (settled) {
-					void created.dispose();
-					return;
-				}
-				session = created;
-				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 queued;
-				});
-				if (interrupted || timedOut || stopped) abortChild();
-				await created.prompt(input.prompt);
-				promptSettled = true;
-				settle(undefined);
-			} catch (promptError) {
-				promptSettled = true;
-				settle(promptError ?? new Error("Child session failed."));
-			}
-		})();
-	});
-}

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

@@ -1,7 +0,0 @@
-export const MIN_SAFE_ASYNC_RUN_PREFIX_LENGTH = 8;
-const FULL_ASYNC_RUN_ID_LENGTH = 36;
-
-/** Full generated ids and longer exact identities never fall back to a root scan. */
-export function canScanAsyncRunPrefix(id: string): boolean {
-	return id.length >= MIN_SAFE_ASYNC_RUN_PREFIX_LENGTH && id.length < FULL_ASYNC_RUN_ID_LENGTH;
-}