@openclaw/codex 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/{native-subagent-monitor-B2C8D_N0.mjs → native-subagent-monitor-iHc8oLg5.mjs}

@@ -1,22 +1,24 @@
-import { c as codexNativeSubagentRunId, d as readNativeSubagentThreadIds, f as readThreadParentThreadId, l as normalizeIdentifier, m as assertHistoryOwnerMatchesRegistration, p as readThreadSpawnSource, t as matchesNativeAssignmentLifecycle, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-BDqhOdJp.mjs";
+import { c as codexNativeSubagentRunId, d as readNativeSubagentThreadIds, f as readThreadParentThreadId, l as normalizeIdentifier, m as assertHistoryOwnerMatchesRegistration, p as readThreadSpawnSource, t as matchesNativeAssignmentLifecycle, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as defineCodexBuildState } from "./build-state-BwxNfFEB.mjs";
-import { a as readHookOutputEntries, o as readItem, s as readNullableString } from "./event-projector-values-DTqZHizf.mjs";
-import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-fXkKbPVC.mjs";
-import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BogBHKLk.mjs";
-import { K as retainCodexAppServerLiveThread, P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread } from "./shared-client-DeenOD8U.mjs";
-import { L as readCodexAppServerWarningMessage } from "./client-BIRVBXXb.mjs";
-import { _ as itemStatus, c as auditNativeToolName, d as isMutatingNativeToolItem, f as isNonSuccessItemStatus, g as itemName, h as itemKind, l as auditNativeToolTerminalStatus, m as isSideEffectingNativeToolItem, p as isProjectedNativeToolItem, v as itemTitle, x as unknownItemStatus, y as matchesCodexSnapshotTurn } from "./turn-router-BWhX_SBh.mjs";
-import { s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-HXQxfMc1.mjs";
-import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-C_SGp5YW.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
-import { asFiniteNumber, asNonArrayRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as defineCodexBuildState } from "./build-state-CzLMy1S9.mjs";
+import { a as readHookOutputEntries, o as readItem, s as readNullableString } from "./event-projector-values-CLvG1Hil.mjs";
+import { n as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-Ccd9MFRJ.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BO6i_pfk.mjs";
+import { K as retainCodexAppServerLiveThread, P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread } from "./shared-client-ByIwuAC-.mjs";
+import { M as readCodexAppServerWarningMessage } from "./client-y7nO6X9c.mjs";
+import { C as unknownItemStatus, _ as itemName, b as matchesCodexSnapshotTurn, f as isMutatingNativeToolItem, g as itemKind, h as isSideEffectingNativeToolItem, l as auditNativeToolName, m as isProjectedNativeToolItem, p as isNonSuccessItemStatus, u as auditNativeToolTerminalStatus, v as itemStatus, y as itemTitle } from "./turn-router-DKDAziUW.mjs";
+import { s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-t-kd_1ys.mjs";
+import { t as projectCodexWebSearchItem } from "./web-search-item-CvokaZOo.mjs";
+import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-BSV-51ig.mjs";
+import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-CZz2DJ4q.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { asFiniteNumber, asNonArrayRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import path from "node:path";
 import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, embeddedAgentLog, emitAgentEvent, formatErrorMessage as formatErrorMessage$1, inferToolMetaFromArgs, projectAgentActivityItem, projectAgentToolActivity, runAgentHarnessAfterToolCallHook, sanitizeToolArgs } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM, NativeToolOutputAccumulator, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS, createAgentHarnessToolCallMessage, createAgentHarnessToolResultMessage, formatNativeToolOutput, formatNativeToolSummary, truncateNativeToolTranscriptText } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 import { captureAgentHarnessCompletionCustody, createAgentHarnessCompletionEventSink, deliverAgentHarnessCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-completion";
@@ -48,11 +50,10 @@ function matchingNativeModelAdmissions(request, admissions, parentThreadId) {
 	return [...admissions.values()].flat().filter((entry) => entry.kind === "interaction" && (parentThreadId === void 0 || entry.parentThreadId === parentThreadId) && entry.childThreadId === request.threadId && (entry.modelSourceRequiresInference || !(entry.modelSourceTurnId ?? entry.nativeTurnId) || (entry.modelSourceTurnId ?? entry.nativeTurnId) === request.turnId) && entry.modelSource !== void 0 && matchingNativeModelCause(entry.modelSource.owner, request));
 }
 function findUnqualifiedNativeModelParent(request, parents, admissions) {
-	const candidates = new Set(matchingNativeModelAdmissions(request, admissions).flatMap((entry) => {
+	const candidates = /* @__PURE__ */ new Set([...matchingNativeModelAdmissions(request, admissions).flatMap((entry) => {
 		const state = parents.get(entry.parentThreadId);
 		return state && entry.modelSource?.owner.unqualifiedModelExecution ? [state] : [];
-	}));
-	for (const state of parents.values()) if ([...state.owners.values()].some((owner) => owner.unqualifiedModelExecution && !owner.modelExecutionCancelled && !owner.modelExecutionSettled && matchingNativeModelCause(owner, request))) candidates.add(state);
+	}), ...[...parents.values()].filter((state) => [...state.owners.values()].some((owner) => owner.unqualifiedModelExecution && !owner.modelExecutionCancelled && !owner.modelExecutionSettled && matchingNativeModelCause(owner, request)))]);
 	return candidates.size === 1 ? candidates.values().next().value : void 0;
 }
 function currentNativeModelExecution(threadId, parents, knownChildren, children) {
@@ -285,16 +286,17 @@ function bindNativeChildModelAdmission(evidence, known, child) {
 	source.assertCurrent();
 	const turnId = evidence.modelSourceTurnId ?? evidence.nativeTurnId;
 	if (!turnId) return true;
+	const retainExecution = () => retainNativeModelExecution(source.owner, turnId, evidence.childThreadId, evidence.completionCustody);
 	const pending = known.pendingTurns.find((entry) => entry.turnId === turnId);
 	if (pending) {
 		if (!pending.state || pending.state === "active") {
 			pending.completionCustody ??= evidence.completionCustody?.retain();
-			pending.modelSource ??= retainNativeModelExecution(source.owner, turnId, evidence.childThreadId, evidence.completionCustody);
+			pending.modelSource ??= retainExecution();
 		}
 	} else if (child?.nativeTurnId === turnId) {
 		if (!child.terminal && !child.settledWithoutCompletion) {
 			child.completionCustody ??= evidence.completionCustody?.retain();
-			child.modelExecution ??= retainNativeModelExecution(source.owner, turnId, evidence.childThreadId, evidence.completionCustody);
+			child.modelExecution ??= retainExecution();
 		}
 	} else return true;
 	consumeNativeChildModelAdmission(evidence);
@@ -318,7 +320,8 @@ function releaseNativeParentModelSources(state, children) {
 		pending.modelSource = void 0;
 	}
 }
-function associateNativeChildInteraction(known, threadId, nativeTurnId, admissions, drain) {
+function associateNativeChildInteraction(known, nativeTurnId, admissions, drain) {
+	const threadId = known.assignment.childThreadId;
 	for (const [parentTurnId, pending] of admissions) {
 		const interaction = pending.find((evidence) => evidence.kind === "interaction" && evidence.parentThreadId === known.parent.parentThreadId && evidence.childThreadId === threadId && !evidence.nativeTurnId);
 		if (interaction?.kind !== "interaction") continue;
@@ -407,8 +410,8 @@ function executionOwner(request, state, dependencies) {
 		modelSource,
 		completionCustody: completionCustody?.retain()
 	});
-	for (const entry of admitted) if (entry.kind === "interaction" && entry.modelSource?.owner === owner) consumeNativeChildModelAdmission(entry);
-	if (pending?.state === "active" || child?.nativeTurnId === request.turnId) dependencies.onExecutionAdmitted(known, request.threadId);
+	for (const entry of admitted) if (entry.modelSource?.owner === owner) consumeNativeChildModelAdmission(entry);
+	if (pending?.state === "active" || child?.nativeTurnId === request.turnId) dependencies.onExecutionAdmitted(known);
 	return modelSource.executionOwner;
 }
 async function captureNativeModelSource(request, dependencies) {
@@ -432,22 +435,19 @@ async function captureNativeModelSource(request, dependencies) {
 		const immediate = unqualified.filter((candidate) => candidate.turnId === request.parentTurnId);
 		const waitingOwners = immediate.length > 0 ? immediate : unqualified;
 		const waitingOwner = waitingOwners.length === 1 ? waitingOwners[0] : void 0;
-		if (waitingOwner) {
-			const capture = waitingOwner.modelSource?.capture();
-			let binding;
-			try {
+		const capture = waitingOwner?.modelSource?.capture();
+		let binding;
+		try {
+			if (waitingOwner) {
 				binding = capture?.source?.bindModelExecution?.(void 0);
 				if (!binding) return;
 				binding.assertCurrent();
-				await waitForNativeModelSourceChange(state, request.signal ? AbortSignal.any([request.signal, binding.signal]) : binding.signal);
-			} finally {
-				binding?.release();
-				capture?.release();
-			}
-			continue;
+			} else if (!pending && !dependencies.hasPendingInput(request) && !(observedChildTurn && parentExecution && matchingNativeModelCause(parentExecution, request))) return;
+			await waitForNativeModelSourceChange(state, binding && request.signal ? AbortSignal.any([request.signal, binding.signal]) : binding?.signal ?? request.signal);
+		} finally {
+			binding?.release();
+			capture?.release();
 		}
-		if (!pending && !dependencies.hasPendingInput(request) && !(observedChildTurn && parentExecution && matchingNativeModelCause(parentExecution, request))) return;
-		await waitForNativeModelSourceChange(state, request.signal);
 	}
 }
 //#endregion
@@ -476,13 +476,15 @@ var CodexNativeSubagentAdmissionCustody = class {
 		}
 		if (pending.some((candidate) => candidate.parentThreadId === evidence.parentThreadId && candidate.kind === evidence.kind && candidate.childThreadId === evidence.childThreadId && candidate.agentPath === evidence.agentPath && (candidate.kind === "spawn" || evidence.kind === "spawn" || candidate.modelSourceTurnId === evidence.modelSourceTurnId && (candidate.nativeTurnId !== void 0 && candidate.nativeTurnId === evidence.nativeTurnId || evidence.itemId !== void 0 && candidate.itemId === evidence.itemId))) || requiresUnboundOwner && [...this.pending.values()].reduce((count, entries) => count + entries.length, 0) >= 32) return;
 		try {
-			if (evidence.kind === "interaction") evidence.completionCustody ??= (evidence.owner ?? evidence.modelOwner)?.completionCustody?.retain();
-			if (evidence.kind === "interaction" && !evidence.modelSourceConsumed) {
-				const owner = evidence.modelOwner ?? evidence.owner;
-				if (owner?.unqualifiedModelExecution && !owner.nativeInputConfiguration) {
-					evidence.modelSourceRequiresInference = evidence.modelSourceTurnId ? void 0 : true;
-					evidence.modelSource = retainNativeModelExecution(owner, void 0, evidence.childThreadId, evidence.completionCustody);
-				} else evidence.modelSource = retainNativeModelSource(owner);
+			if (evidence.kind === "interaction") {
+				evidence.completionCustody ??= (evidence.owner ?? evidence.modelOwner)?.completionCustody?.retain();
+				if (!evidence.modelSourceConsumed) {
+					const owner = evidence.modelOwner ?? evidence.owner;
+					if (owner?.unqualifiedModelExecution && !owner.nativeInputConfiguration) {
+						evidence.modelSourceRequiresInference = evidence.modelSourceTurnId ? void 0 : true;
+						evidence.modelSource = retainNativeModelExecution(owner, void 0, evidence.childThreadId, evidence.completionCustody);
+					} else evidence.modelSource = retainNativeModelSource(owner);
+				}
 			}
 		} catch (error) {
 			if (evidence.kind === "interaction") {
@@ -512,11 +514,7 @@ var CodexNativeSubagentAdmissionCustody = class {
 			const known = this.dependencies.knownChild(evidence.childThreadId);
 			if (known && known.parent.parentThreadId !== evidence.parentThreadId) return false;
 			const state = this.dependencies.parentState(evidence.parentThreadId);
-			if (evidence.kind === "interaction" && (evidence.owner || evidence.modelSource)) {
-				if (evidence.modelSource && state && !isRetired(state)) return true;
-				if (state && evidence.owner && [...state.owners.values()].includes(evidence.owner)) return true;
-				return false;
-			}
+			if (evidence.kind === "interaction" && (evidence.owner || evidence.modelSource)) return Boolean(evidence.modelSource && state && !isRetired(state) || state && evidence.owner && [...state.owners.values()].includes(evidence.owner));
 			return this.hasUnboundParentOwner(evidence.parentThreadId);
 		});
 	}
@@ -785,10 +783,8 @@ var CodexNativeSubagentRecoveryCoordinator = class {
 		};
 	}
 	clearRecoveryTimers(childState) {
-		if (childState.recoveryTimer) {
-			clearTimeout(childState.recoveryTimer);
-			childState.recoveryTimer = void 0;
-		}
+		clearTimeout(childState.recoveryTimer);
+		childState.recoveryTimer = void 0;
 	}
 };
 function logRecoveryFailure(childThreadId, error) {
@@ -867,7 +863,7 @@ var CodexNativeSubagentCloseOwner = class {
 		if (!calls) return;
 		for (const [key, call] of calls) {
 			if (call.completing && !call.settled) continue;
-			if (![...state.owners.values()].some((owner) => call.owners.has(owner) && (!owner.turnId || owner.turnId === call.turnId))) calls.delete(key);
+			if (!this.hasCallOwner(state, call, true)) calls.delete(key);
 		}
 	}
 	async retireChild(state, childState, releaseSubscription) {
@@ -889,7 +885,7 @@ var CodexNativeSubagentCloseOwner = class {
 			}
 			this.callbacks.markTerminalRevision(childState.childThreadId);
 		}
-		if (childState.pendingCompletion) childState.pendingCompletion = void 0;
+		childState.pendingCompletion = void 0;
 		childState.subscriptionClosed = true;
 		this.callbacks.unregisterChild(childState);
 		releaseSubscription?.();
@@ -898,6 +894,9 @@ var CodexNativeSubagentCloseOwner = class {
 		const threadId = receiver.assignment.childThreadId;
 		if (this.callbacks.isParentRetired(receiver.parent) && this.callbacks.knownChild(threadId) === receiver && !this.callbacks.currentChild(threadId)) releaseSubscription();
 	}
+	hasCallOwner(state, call, allowUnbound) {
+		return [...state.owners.values()].some((owner) => call.owners.has(owner) && (owner.turnId === call.turnId || allowUnbound && !owner.turnId));
+	}
 	completeChildClose(state, key, call) {
 		if (call.settlement) return call.settlement;
 		const settlement = this.confirmChildClose(state, key, call);
@@ -911,7 +910,7 @@ var CodexNativeSubagentCloseOwner = class {
 			const childState = this.callbacks.currentChild(target.childThreadId);
 			return known?.parent === state && known.assignment.runId === target.runId && known.turnId === target.nativeTurnId && known.pendingTurns.length === 0 && (childState === void 0 || childState === target.childState);
 		};
-		if (call.completing || !isCurrent() || ![...state.owners.values()].some((owner) => call.owners.has(owner) && owner.turnId === call.turnId)) return;
+		if (call.completing || !isCurrent() || !this.hasCallOwner(state, call, false)) return;
 		call.completing = true;
 		let settled = false;
 		let retiring = false;
@@ -1030,12 +1029,9 @@ var CodexNativeSubagentCompletionDelivery = class {
 				this.dependencies.unregisterChild(childState);
 				return;
 			}
-			if (delivery.recoveryPending) {
-				this.scheduleRetry(childState, delivery.error ?? "requester recovery owns completion", false);
-				return;
-			}
-			const error = delivery.error ?? "completion delivery did not produce a parent response";
-			this.scheduleRetry(childState, error);
+			const recoveryPending = delivery.recoveryPending;
+			const error = delivery.error ?? (recoveryPending ? "requester recovery owns completion" : "completion delivery did not produce a parent response");
+			this.scheduleRetry(childState, error, !recoveryPending);
 		} catch (error) {
 			if (!this.isCurrent(state, childState)) return;
 			if (!this.claim(state, childState)) {
@@ -1055,17 +1051,15 @@ var CodexNativeSubagentCompletionDelivery = class {
 		}
 	}
 	finish(state, child) {
-		if (child.completionDeliveryTimer) {
-			clearTimeout(child.completionDeliveryTimer);
-			child.completionDeliveryTimer = void 0;
-		}
+		clearTimeout(child.completionDeliveryTimer);
+		child.completionDeliveryTimer = void 0;
 		this.deliverPending(state, child);
 	}
-	applyReceipts(state, runIds, children) {
+	applyReceipts(state, runIds) {
 		for (const runId of runIds) {
-			const child = children.get(runId);
-			const deliveryParent = child && this.dependencies.getParent(child.parentThreadId);
-			if (!child || !deliveryParent || !this.isCurrent(state, child) || !this.dependencies.isCurrentParent(deliveryParent) || this.dependencies.isRetiredParent(deliveryParent)) continue;
+			const child = this.dependencies.children.get(runId);
+			const deliveryParent = child && this.dependencies.parents.get(child.parentThreadId);
+			if (!child || !deliveryParent || !this.isCurrent(state, child) || this.dependencies.parents.get(deliveryParent.parentThreadId) !== deliveryParent || this.dependencies.retiredParents.has(deliveryParent)) continue;
 			if (deliveryParent !== state) {
 				if (!state.requesterSessionKey?.trim() || state.requesterSessionKey !== deliveryParent.requesterSessionKey) continue;
 				try {
@@ -1079,18 +1073,18 @@ var CodexNativeSubagentCompletionDelivery = class {
 			if (child.pendingCompletion && !child.deliveringCompletion) this.finish(deliveryParent, child);
 		}
 	}
-	deliverDetached(state, children) {
-		for (const child of children) if (child.parentThreadId === state.parentThreadId && child.pendingCompletion) this.deliverPending(state, child);
+	deliverDetached(state) {
+		for (const child of this.dependencies.children.values()) if (child.parentThreadId === state.parentThreadId && child.pendingCompletion) this.deliverPending(state, child);
 	}
 	release(childState) {
 		childState.completionCustody?.release();
-		if (childState.completionDeliveryTimer) clearTimeout(childState.completionDeliveryTimer);
+		clearTimeout(childState.completionDeliveryTimer);
 		const deliveryOwnerKey = childState.deliveryOwnerKey;
 		if (deliveryOwnerKey && completionDeliveryOwners.get(deliveryOwnerKey) === childState) completionDeliveryOwners.delete(deliveryOwnerKey);
 		childState.deliveryOwnerKey = void 0;
 	}
 	isCurrent(state, child) {
-		return this.dependencies.isCurrentChild(child) && this.dependencies.isCurrentParent(state) && !this.dependencies.isRetiredParent(state);
+		return this.dependencies.children.get(child.runId) === child && this.dependencies.parents.get(state.parentThreadId) === state && !this.dependencies.retiredParents.has(state);
 	}
 	prepareDelivery(state, child) {
 		if (!child.pendingCompletion) return false;
@@ -1107,7 +1101,7 @@ var CodexNativeSubagentCompletionDelivery = class {
 		return true;
 	}
 	scheduleRetry(childState, error, chargeAttempt = true) {
-		if (!childState.pendingCompletion || childState.completionDeliveryTimer || !this.dependencies.isCurrentChild(childState)) return;
+		if (!childState.pendingCompletion || childState.completionDeliveryTimer || this.dependencies.children.get(childState.runId) !== childState) return;
 		if (chargeAttempt && childState.completionDeliveryAttempt >= this.maxRetries) {
 			embeddedAgentLog.warn("Native subagent completion retries exhausted", {
 				childThreadId: childState.childThreadId,
@@ -1119,8 +1113,8 @@ var CodexNativeSubagentCompletionDelivery = class {
 		const delayMs = delayForAttempt(this.retryDelaysMs, chargeAttempt ? childState.completionDeliveryAttempt++ : childState.completionDeliveryAttempt);
 		childState.completionDeliveryTimer = setTimeout(() => {
 			childState.completionDeliveryTimer = void 0;
-			if (!this.dependencies.isCurrentChild(childState)) return;
-			const state = this.dependencies.getParent(childState.parentThreadId);
+			if (this.dependencies.children.get(childState.runId) !== childState) return;
+			const state = this.dependencies.parents.get(childState.parentThreadId);
 			if (state) this.deliverPending(state, childState);
 		}, delayMs);
 		childState.completionDeliveryTimer.unref();
@@ -1181,8 +1175,19 @@ function extractCodexNativeSubagentCompletions(notification) {
 		if (kinds[index] !== "multi_agent.subagent_notification" || !isJsonObject(entry) || entry.type !== "input_text") return [];
 		const text = readStringField(entry, "text")?.trim();
 		if (!text?.startsWith(CODEX_SUBAGENT_NOTIFICATION_START) || !text.endsWith(CODEX_SUBAGENT_NOTIFICATION_END)) return [];
-		const completion = parseCodexNativeSubagentNotificationBody(text.slice(23, -24));
-		return completion ? [completion] : [];
+		let payload;
+		try {
+			payload = JSON.parse(text.slice(23, -24).trim());
+		} catch {
+			return [];
+		}
+		if (!isJsonObject(payload)) return [];
+		const agentPath = readStringField(payload, "agent_path")?.trim();
+		const completion = readCompletionStatus(payload.status);
+		return agentPath && completion ? [{
+			agentPath,
+			...completion
+		}] : [];
 	});
 }
 const codexNativeSubagentNotifications = {
@@ -1212,21 +1217,6 @@ function readDeliveredNativeCompletionPaths(notification) {
 	if (!isJsonObject(part) || readStringField(part, "type") !== "input_text") return [];
 	return readStringField(part, "text")?.startsWith(`Message Type: FINAL_ANSWER\nTask name: ${recipient}\nSender: ${author}\nPayload:\n`) ? [author] : [];
 }
-function parseCodexNativeSubagentNotificationBody(body) {
-	let payload;
-	try {
-		payload = JSON.parse(body.trim());
-	} catch {
-		return;
-	}
-	if (!isJsonObject(payload)) return;
-	const agentPath = readStringField(payload, "agent_path")?.trim();
-	const completion = readCompletionStatus(payload.status);
-	return agentPath && completion ? {
-		agentPath,
-		...completion
-	} : void 0;
-}
 function readCompletionStatus(status) {
 	if (status === "shutdown" || status === "not_found") return {
 		status: status === "shutdown" ? "cancelled" : "failed",
@@ -1340,19 +1330,9 @@ var CodexNativeSubagentDeliveryReceipts = class {
 		for (let index = 0; index < this.pending.length;) {
 			const receipt = this.pending[index];
 			const matches = [...this.outcomes].filter(([, outcome]) => outcome.paths.has(receipt.agentPath));
-			let match;
-			for (const candidate of matches) {
-				const outcome = candidate[1];
-				if (outcome.result !== void 0 && outcome.result === receipt.result || outcome.receiptResults.has(receipt.result)) {
-					match = candidate;
-					break;
-				}
-				if (outcome.result === void 0) {
-					match = matches.length === 1 ? candidate : void 0;
-					break;
-				}
-			}
-			if (!match) {
+			const match = matches.find(([, outcome]) => outcome.result === void 0 || outcome.result === receipt.result || outcome.receiptResults.has(receipt.result));
+			const ambiguous = match && match[1].result === void 0 && !match[1].receiptResults.has(receipt.result) && matches.length > 1;
+			if (!match || ambiguous) {
 				index += 1;
 				continue;
 			}
@@ -1379,9 +1359,10 @@ function receiptResultKey(result) {
 //#region extensions/codex/src/app-server/native-subagent-history-recovery.ts
 const THREAD_READ_TIMEOUT_MS = 3e4;
 var CodexNativeSubagentHistoryRecovery = class {
-	constructor(client, queries) {
+	constructor(client, knownChildren, children) {
 		this.client = client;
-		this.queries = queries;
+		this.knownChildren = knownChildren;
+		this.children = children;
 	}
 	requestThreadRead(childThreadId, includeTurns) {
 		return this.client.request("thread/read", {
@@ -1389,14 +1370,6 @@ var CodexNativeSubagentHistoryRecovery = class {
 			includeTurns
 		}, { timeoutMs: THREAD_READ_TIMEOUT_MS });
 	}
-	requestLatestThreadTurn(childThreadId) {
-		return this.client.request("thread/turns/list", {
-			threadId: childThreadId,
-			limit: 1,
-			sortDirection: "desc",
-			itemsView: "full"
-		}, { timeoutMs: THREAD_READ_TIMEOUT_MS });
-	}
 	async read(assignment, options) {
 		const { childThreadId } = assignment;
 		const { recordedCompletion } = options;
@@ -1429,7 +1402,7 @@ var CodexNativeSubagentHistoryRecovery = class {
 			};
 		}
 		const turnId = assignment.nativeTurnId ?? initialTurnId;
-		const pendingTurnIds = new Set(this.queries.getPendingTurnIds(childThreadId));
+		const pendingTurnIds = new Set(this.knownChildren.get(childThreadId)?.pendingTurns.map((turn) => turn.turnId) ?? []);
 		const unresolvedAssignment = options.resumeInterrupted && !turnId && pendingTurnIds.size > 0;
 		const observedPendingTurns = [];
 		for (const turn of rawTurns) {
@@ -1440,11 +1413,8 @@ var CodexNativeSubagentHistoryRecovery = class {
 			});
 		}
 		const threadStatus = isJsonObject(thread.status) ? normalizeIdentifier(readStringField(thread.status, "type")) : void 0;
-		let completion;
+		let recovery = readTurnRecovery(void 0, childThreadId);
 		let fallbackCompletion;
-		let nativeTurnId;
-		let nativeTurnState;
-		let resumable = false;
 		let threadState = threadStatus === "active" ? "active" : threadStatus === "systemerror" ? "system_error" : threadStatus ? "other" : "unavailable";
 		if (unresolvedAssignment) threadState = "unavailable";
 		else if (turnId) {
@@ -1453,26 +1423,22 @@ var CodexNativeSubagentHistoryRecovery = class {
 			while (options.resumeInterrupted && index >= 0 && index + 1 < turns.length && normalizeIdentifier(readStringField(turns[index], "status")) === "interrupted") index += 1;
 			const turn = turns[index];
 			const turnStatus = normalizeIdentifier(readStringField(turn, "status"));
-			nativeTurnId = readStringField(turn, "id");
-			nativeTurnState = readNativeTurnState(turn);
-			completion = isJsonObject(turn) ? readTurnCompletion(turn, childThreadId) : void 0;
-			resumable = turnStatus === "interrupted";
+			recovery = readTurnRecovery(turn, childThreadId);
 			threadState = turnStatus === "inprogress" ? "active" : turnStatus ? "other" : "unavailable";
 		} else if (threadStatus === "active") {
 			const turn = rawTurns.at(-1);
 			if (normalizeIdentifier(readStringField(turn, "status")) === "inprogress") {
-				nativeTurnId = readStringField(turn, "id");
-				nativeTurnState = "active";
+				recovery.nativeTurnId = readStringField(turn, "id");
+				recovery.nativeTurnState = "active";
 			}
-		} else if (threadStatus !== "systemerror") {
-			const turnRecovery = readThreadTurnRecovery(thread, childThreadId);
-			nativeTurnId = turnRecovery.nativeTurnId;
-			nativeTurnState = turnRecovery.nativeTurnState;
-			completion = turnRecovery.completion;
-			resumable = turnRecovery.resumable;
-		}
-		if (!unresolvedAssignment && threadStatus === "systemerror" && (!turnId || threadState === "unavailable" && !completion)) {
-			const turnsResponse = await this.requestLatestThreadTurn(childThreadId).catch(() => void 0);
+		} else if (threadStatus !== "systemerror") recovery = readTurnRecovery(rawTurns.findLast(isJsonObject), childThreadId);
+		if (!unresolvedAssignment && threadStatus === "systemerror" && (!turnId || threadState === "unavailable" && !recovery.completion)) {
+			const turnsResponse = await this.client.request("thread/turns/list", {
+				threadId: childThreadId,
+				limit: 1,
+				sortDirection: "desc",
+				itemsView: "full"
+			}, { timeoutMs: THREAD_READ_TIMEOUT_MS }).catch(() => void 0);
 			const data = isJsonObject(turnsResponse) && Array.isArray(turnsResponse.data) ? turnsResponse.data : [];
 			const latestTurn = isJsonObject(data[0]) ? data[0] : void 0;
 			const latestTurnId = readStringField(latestTurn, "id");
@@ -1483,51 +1449,45 @@ var CodexNativeSubagentHistoryRecovery = class {
 			const latestTurnStatus = normalizeIdentifier(readStringField(latestTurn, "status"));
 			const matchesAssignment = !turnId || readStringField(latestTurn, "id") === turnId;
 			if (latestTurn && matchesAssignment) {
-				if (turnId) {
-					const turnRecovery = readThreadTurnRecovery({ turns: [latestTurn] }, childThreadId);
-					nativeTurnId = turnRecovery.nativeTurnId;
-					nativeTurnState = turnRecovery.nativeTurnState;
-					completion = turnRecovery.completion;
-					resumable = turnRecovery.resumable;
-				} else if (latestTurnStatus === "failed") completion = readTurnCompletion(latestTurn, childThreadId);
+				if (turnId) recovery = readTurnRecovery(latestTurn, childThreadId);
+				else if (latestTurnStatus === "failed") recovery.completion = readTurnCompletion(latestTurn, childThreadId);
 			}
-			const current = !latestTurn ? this.queries.getCurrentAssignmentState(childThreadId) : void 0;
-			const unresolvedCurrentAssignment = current?.runId === assignment.runId && current?.nativeTurnState !== "completed";
+			const current = !latestTurn ? this.knownChildren.get(childThreadId)?.assignment : void 0;
+			const unresolvedCurrentAssignment = current?.runId === assignment.runId && this.children.get(current.runId)?.nativeTurnState !== "completed";
 			if (latestTurnStatus === "inprogress" && matchesAssignment) {
-				nativeTurnId = readStringField(latestTurn, "id");
-				nativeTurnState = "active";
+				recovery.nativeTurnId = readStringField(latestTurn, "id");
+				recovery.nativeTurnState = "active";
 				threadState = "active";
-			} else if (!completion && !resumable && latestTurnStatus !== "inprogress" && (!turnId || !latestTurn && unresolvedCurrentAssignment)) fallbackCompletion = systemErrorFallbackCompletion(childThreadId);
+			} else if (!recovery.completion && !recovery.resumable && latestTurnStatus !== "inprogress" && (!turnId || !latestTurn && unresolvedCurrentAssignment)) fallbackCompletion = systemErrorFallbackCompletion(childThreadId);
 		}
-		if (recordedCompletion && (!turnId || !completion || completion.status !== recordedCompletion.status)) {
-			completion = recordedCompletion;
+		if (recordedCompletion && (!turnId || !recovery.completion || recovery.completion.status !== recordedCompletion.status)) {
+			recovery.completion = recordedCompletion;
 			if (!turnId) {
-				nativeTurnId = void 0;
-				nativeTurnState = void 0;
+				recovery.nativeTurnId = void 0;
+				recovery.nativeTurnState = void 0;
 			}
 			fallbackCompletion = void 0;
-			resumable = false;
+			recovery.resumable = false;
 			threadState = "other";
 		}
 		return {
 			parentThreadId: readThreadParentThreadId(thread),
 			agentPath: normalizeOptionalString(readStringField(readThreadSpawnSource(thread), "agent_path")),
-			nativeTurnId,
-			nativeTurnState,
+			nativeTurnId: recovery.nativeTurnId,
+			nativeTurnState: recovery.nativeTurnState,
 			observedPendingTurns,
-			completion,
+			completion: recovery.completion,
 			fallbackCompletion,
-			resumable,
+			resumable: recovery.resumable,
 			threadState
 		};
 	}
 };
-function readThreadTurnRecovery(thread, childThreadId) {
-	const turn = (Array.isArray(thread.turns) ? thread.turns : []).findLast(isJsonObject);
+function readTurnRecovery(turn, childThreadId) {
 	return turn ? {
 		nativeTurnId: readStringField(turn, "id"),
 		nativeTurnState: readNativeTurnState(turn),
-		completion: readTurnCompletion(turn, childThreadId),
+		completion: isJsonObject(turn) ? readTurnCompletion(turn, childThreadId) : void 0,
 		resumable: normalizeIdentifier(readStringField(turn, "status")) === "interrupted"
 	} : { resumable: false };
 }
@@ -1538,10 +1498,6 @@ function readNativeTurnEnd(turn) {
 function readNativeTurnState(turn) {
 	return normalizeIdentifier(readStringField(turn, "status")) === "inprogress" ? "active" : readNativeTurnEnd(turn);
 }
-function readTurnErrorMessage(turn) {
-	const error = isJsonObject(turn.error) ? turn.error : void 0;
-	return normalizeOptionalString(readStringField(error, "message")) ?? normalizeOptionalString(isJsonObject(error?.codexErrorInfo) ? readStringField(error.codexErrorInfo, "message") : void 0);
-}
 function systemErrorFallbackCompletion(childThreadId) {
 	return {
 		childThreadId,
@@ -1563,14 +1519,16 @@ function readTurnCompletion(turn, childThreadId, source = "history") {
 		result: result ?? "Subagent completed without a final assistant message.",
 		...timestamp
 	};
-	if (status === "interrupted") return;
-	if (status === "failed") return {
-		childThreadId,
-		status: "failed",
-		statusLabel: source === "history" ? "task_failed" : "turn_failed",
-		result: readTurnErrorMessage(turn) ?? (source === "history" ? result : void 0) ?? "Subagent failed.",
-		...timestamp
-	};
+	if (status === "failed") {
+		const error = isJsonObject(turn.error) ? turn.error : void 0;
+		return {
+			childThreadId,
+			status: "failed",
+			statusLabel: source === "history" ? "task_failed" : "turn_failed",
+			result: normalizeOptionalString(readStringField(error, "message")) ?? normalizeOptionalString(isJsonObject(error?.codexErrorInfo) ? readStringField(error.codexErrorInfo, "message") : void 0) ?? (source === "history" ? result : void 0) ?? "Subagent failed.",
+			...timestamp
+		};
+	}
 }
 function readLastAgentMessage(turn) {
 	const items = Array.isArray(turn.items) ? turn.items : [];
@@ -1612,7 +1570,7 @@ function nativeAgentPath(known) {
 	const paths = [...known?.agentPaths ?? []].filter((path) => /^\/root(?:\/[a-z0-9_]+)*$/.test(path));
 	return paths.length === 1 ? paths[0] : void 0;
 }
-function nativeRootThreadId(threadId, knownChildren) {
+function nativeRootThreadId(threadId, knownChildren, parent) {
 	const visited = /* @__PURE__ */ new Set();
 	let current = threadId;
 	let expectedPath;
@@ -1620,7 +1578,7 @@ function nativeRootThreadId(threadId, knownChildren) {
 		visited.add(current);
 		const known = knownChildren.get(current);
 		const path = nativeAgentPath(known);
-		if (!known || !path || expectedPath && path !== expectedPath) return;
+		if (!known || parent && known.parent !== parent || !path || expectedPath && path !== expectedPath) return;
 		if (path === "/root") return current;
 		expectedPath = path.slice(0, path.lastIndexOf("/"));
 		if (expectedPath === "/root") return known.nativeParentThreadId;
@@ -1645,15 +1603,20 @@ function resolveInputTarget(request, dependencies) {
 }
 /** Qualification is read before the native handler; source custody remains with its existing call. */
 async function prepareNativeModelToolInput(request, dependencies) {
-	const state = dependencies.parents.get(request.threadId) ?? dependencies.knownChildren.get(request.threadId)?.parent;
-	const owner = state && resolveNativeModelParentOwner(state, request.turnId, request.threadId, dependencies.children, dependencies.knownChildren);
+	const resolveSender = () => {
+		const state = dependencies.parents.get(request.threadId) ?? dependencies.knownChildren.get(request.threadId)?.parent;
+		return {
+			state,
+			owner: state && resolveNativeModelParentOwner(state, request.turnId, request.threadId, dependencies.children, dependencies.knownChildren)
+		};
+	};
+	const { state, owner } = resolveSender();
 	const capture = owner?.modelSource?.capture();
 	if (!state || !owner || !capture || owner.modelExecutionSettled || owner.modelExecutionCancelled) {
 		capture?.release();
 		throw new Error("Codex native input requires its exact admitted sender turn");
 	}
 	let preparedSource;
-	let captureTransferred = false;
 	let pendingBinding;
 	let targetRevision;
 	let assertTargetCurrent;
@@ -1673,7 +1636,10 @@ async function prepareNativeModelToolInput(request, dependencies) {
 		const targetChild = dependencies.knownChildren.get(targetThreadId);
 		const targetConfiguration = targetChild?.configurationQualification;
 		const targetRouting = request.readQualification(targetThreadId);
+		let metadataRead = false;
 		assertTargetCurrent = () => {
+			const nativeRoot = nativeRootThreadId(request.threadId, dependencies.knownChildren, state);
+			if (!(targetParent ? (targetParent === state || nativeRoot === targetThreadId) && dependencies.canPrepareReceiver(state, targetThreadId) : targetChild ? dependencies.canPrepareReceiver(state, targetThreadId) : !metadataRead || nativeRoot === targetThreadId || nativeParentThreadId === state.parentThreadId || nativeParentThreadId !== void 0 && dependencies.knownChildren.get(nativeParentThreadId)?.parent === state)) throw new Error("Codex native input target is outside the sender's admitted tree");
 			if (!targetRevision?.isCurrent() || dependencies.parents.get(targetThreadId) !== targetParent || dependencies.knownChildren.get(targetThreadId) !== targetChild || targetChild?.configurationQualification !== targetConfiguration || request.readQualification(targetThreadId) !== targetRouting) throw new Error("Codex native receiver changed during input preparation; retry with its current thread");
 			targetConfiguration?.assertCurrent();
 			targetRouting?.assertCurrent();
@@ -1687,6 +1653,8 @@ async function prepareNativeModelToolInput(request, dependencies) {
 			timeoutMs: 3e4,
 			assertCurrent
 		});
+		const nativeParentThreadId = readThreadParentThreadId(thread);
+		metadataRead = true;
 		assertCurrent();
 		if (thread.id !== targetThreadId || !thread.modelProvider || resolveInputTarget(request, dependencies) !== targetThreadId) throw new Error("Codex native target returned a different thread or no provider");
 		if (thread.status?.type !== "idle" && thread.status?.type !== "notLoaded" && !dependencies.currentModelExecution(targetThreadId)) throw new Error("Codex active input requires the receiver's exact admitted execution");
@@ -1736,18 +1704,16 @@ async function prepareNativeModelToolInput(request, dependencies) {
 			}, state, () => {
 				if (!dependencies.isCurrent(state)) throw new Error("Codex native input source owner is no longer current");
 			}, () => {});
-			captureTransferred = true;
 			preparedOwner.modelSource = preparedSource;
 		}
 		assertCurrent();
-		const nativeParentThreadId = readThreadParentThreadId(thread);
+		if (targetChild && nativeParentThreadId !== targetChild.nativeParentThreadId) throw new Error("Codex native input receiver lineage changed during preparation");
 		if (!dependencies.prepareReceiver(state, thread.id, nativeParentThreadId)) throw new Error("Codex native input receiver cannot retain this sender's admitted source");
 		if (!dependencies.knownChildren.has(thread.id) && !dependencies.parents.has(thread.id)) dependencies.registerChildThread(state, thread.id, {
 			nativeParentThreadId,
 			agentPath: readStringField(readThreadSpawnSource(thread), "agent_path")
 		});
-		const currentState = dependencies.parents.get(request.threadId) ?? dependencies.knownChildren.get(request.threadId)?.parent;
-		const currentOwner = currentState && resolveNativeModelParentOwner(currentState, request.turnId, request.threadId, dependencies.children, dependencies.knownChildren);
+		const { state: currentState, owner: currentOwner } = resolveSender();
 		if (!currentOwner || currentOwner.modelExecutionSettled || currentOwner.modelExecutionCancelled) throw new Error("Codex native input requires its exact admitted sender turn");
 		if (currentState !== state || currentOwner !== owner) throw new Error("Codex native input sender changed during preparation");
 		const pendingModelSources = [...dependencies.admissions.values()].flat().filter((entry) => entry.kind === "interaction" && entry.modelSource?.owner.modelSource?.hasOperatorSource).length;
@@ -1758,13 +1724,14 @@ async function prepareNativeModelToolInput(request, dependencies) {
 	} finally {
 		targetRevision?.release();
 		preparedSource?.release();
-		if (!captureTransferred) capture.release();
+		if (!preparedSource) capture.release();
 	}
 }
 function drainNativeChildModelAdmissions(state, owner, turnId, observeActivity, dependencies) {
 	const pending = dependencies.admissions.get(turnId);
 	const ownerIsCurrent = [...state.owners.values()].includes(owner);
-	if (!pending || !dependencies.isCurrent(state) || !ownerIsCurrent && !pending.some((entry) => entry.kind === "interaction" && (entry.admittedOwner === owner || entry.modelSource?.owner === owner || entry.owner === owner && entry.modelSource))) return;
+	const admittedByOwner = (entry) => entry.kind === "interaction" && (entry.admittedOwner === owner || entry.modelSource?.owner === owner || entry.owner === owner && entry.modelSource);
+	if (!pending || !dependencies.isCurrent(state) || !ownerIsCurrent && !pending.some(admittedByOwner)) return;
 	const remaining = [];
 	const affectedChildren = /* @__PURE__ */ new Set();
 	for (const evidence of pending) {
@@ -1773,7 +1740,7 @@ function drainNativeChildModelAdmissions(state, owner, turnId, observeActivity,
 			continue;
 		}
 		if (evidence.kind === "interaction") {
-			if (!ownerIsCurrent && evidence.admittedOwner !== owner && evidence.modelSource?.owner !== owner && !(evidence.owner === owner && evidence.modelSource)) {
+			if (!ownerIsCurrent && !admittedByOwner(evidence)) {
 				remaining.push(evidence);
 				continue;
 			}
@@ -1821,7 +1788,7 @@ function drainNativeChildModelAdmissions(state, owner, turnId, observeActivity,
 		const known = dependencies.knownChildren.get(threadId);
 		if (known?.parent !== state) continue;
 		const previous = dependencies.currentChild(threadId);
-		const child = dependencies.admitFollowupChild(known, threadId, ownerIsCurrent ? owner : void 0);
+		const child = dependencies.admitFollowupChild(known, ownerIsCurrent ? owner : void 0);
 		if (observeActivity && child && child !== previous && child.nativeTurnState === "active") dependencies.observeActivity(child);
 	}
 }
@@ -1938,6 +1905,12 @@ function createCodexNativeSubagentNotificationRouter(deps) {
 			if (state && parentThreadId) {
 				const turnId = readStringField(params, "turnId");
 				const owner = deps.resolveParentOwner(state, turnId, parentThreadId);
+				const registerSpawn = (childThreadId, agentPath) => deps.registerDirectSpawnChild(state, turnId, {
+					parentThreadId: state.parentThreadId,
+					nativeParentThreadId: parentThreadId,
+					childThreadId,
+					...agentPath === void 0 ? {} : { agentPath }
+				}, owner);
 				if (notification.method === "item/completed") {
 					if (readStringField(item, "type") === "subAgentActivity" && readStringField(item, "kind") === "interacted") {
 						const childThreadId = readStringField(item, "agentThreadId");
@@ -1959,12 +1932,7 @@ function createCodexNativeSubagentNotificationRouter(deps) {
 				if (notification.method === "item/completed" && readStringField(item, "type") === "subAgentActivity" && normalizeIdentifier(readStringField(item, "kind")) === "started") {
 					const childThreadId = readStringField(item, "agentThreadId")?.trim();
 					const agentPath = readStringField(item, "agentPath");
-					if (childThreadId) deps.registerDirectSpawnChild(state, turnId, {
-						parentThreadId: state.parentThreadId,
-						nativeParentThreadId: parentThreadId,
-						childThreadId,
-						...agentPath === void 0 ? {} : { agentPath }
-					}, owner);
+					if (childThreadId) registerSpawn(childThreadId, agentPath);
 					return state;
 				}
 				const isCompletedSpawnAgentTool = notification.method === "item/completed" && readStringField(item, "type") === "collabAgentToolCall" && normalizeIdentifier(readStringField(item, "tool")) === "spawnagent" && normalizeIdentifier(readStringField(item, "status")) === "completed";
@@ -1972,11 +1940,7 @@ function createCodexNativeSubagentNotificationRouter(deps) {
 				if (parentThreadId !== state.parentThreadId && !isCompletedSpawnAgentTool) return state;
 				const childThreadIds = new Set(readNativeSubagentThreadIds(item?.receiverThreadIds));
 				let accepted = true;
-				for (const childThreadId of childThreadIds) accepted = Boolean(isCompletedSpawnAgentTool ? deps.registerDirectSpawnChild(state, turnId, {
-					parentThreadId: state.parentThreadId,
-					nativeParentThreadId: parentThreadId,
-					childThreadId
-				}, owner) : deps.registerChildThread(state, childThreadId)) && accepted;
+				for (const childThreadId of childThreadIds) accepted = Boolean(isCompletedSpawnAgentTool ? registerSpawn(childThreadId) : deps.registerChildThread(state, childThreadId)) && accepted;
 				if (!accepted) return;
 			}
 			return state;
@@ -2028,6 +1992,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 	const requesterSessionKey = state.requesterSessionKey;
 	state.pendingRegistrations = (state.pendingRegistrations ?? 0) + 1;
 	const registeredState = state;
+	const isCurrent = () => !dependencies.isClosed() && !dependencies.isRetired(registeredState) && dependencies.states.get(parentThreadId) === registeredState;
 	const ownerKey = Symbol("codex-native-subagent-owner");
 	let owner = {
 		configurationQualification: params.configurationQualification,
@@ -2060,11 +2025,11 @@ async function registerNativeSubagentParent(input, dependencies) {
 	};
 	try {
 		owner.completionCustody = params.completionScope ? await dependencies.runtime.captureAgentHarnessCompletionCustody(params.completionScope) : void 0;
-		if (dependencies.isClosed() || dependencies.isRetired(state) || dependencies.states.get(parentThreadId) !== state || state.requesterSessionKey !== requesterSessionKey || owner.completionCustody && !owner.completionCustody.isCurrent()) throw new Error("Codex native subagent parent registration is no longer current");
+		if (!isCurrent() || state.requesterSessionKey !== requesterSessionKey || owner.completionCustody && !owner.completionCustody.isCurrent()) throw new Error("Codex native subagent parent registration is no longer current");
 		params.assertCurrent?.();
 		params.modelSource?.assertCurrent();
 		if (Object.hasOwn(params, "modelSource")) owner.modelSource = createNativeModelSourceOwner(params.modelSource, state, () => {
-			if (dependencies.isClosed() || dependencies.isRetired(registeredState) || dependencies.states.get(parentThreadId) !== registeredState) throw new Error("Codex native model source owner is no longer current");
+			if (!isCurrent()) throw new Error("Codex native model source owner is no longer current");
 		}, () => dependencies.prune(registeredState));
 		if (owner.unqualifiedModelExecution && params.modelSource) {
 			rootModelBinding = params.modelSource.bindModelExecution?.(void 0);
@@ -2163,233 +2128,264 @@ async function registerNativeSubagentParent(input, dependencies) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/native-subagent-submission-call.ts
-function admitSubmissionModelInput(params) {
-	const { state, owner, request, calls, dependencies, isCurrent } = params;
-	if (!owner.modelSource || !isCurrent()) throw new Error("Codex native input has no admitted model source");
-	assertNativeModelInputCompatible(owner, dependencies.currentModelExecution(request.targetThreadId) ?? owner);
-	for (const entries of calls.values()) for (const pending of entries.values()) if (pending.modelInput?.threadId === request.targetThreadId) assertNativeModelInputCompatible(owner, pending.modelInput.source.owner);
-	const key = `${request.turnId}\0${request.itemId}`;
-	if (owner.modelSource.hasOperatorSource && !calls.get(state)?.has(key)) {
-		if ([...calls.values()].reduce((count, entries) => count + [...entries.values()].filter((call) => call.modelInput?.source.owner.modelSource?.hasOperatorSource).length, 0) + params.pendingModelSources >= 32) throw new Error("Codex pending native input admission capacity reached");
-	}
-	observeSubmissionCall(state, request.turnId, {
-		id: request.itemId,
-		receiverThreadIds: [request.targetThreadId]
-	}, calls, dependencies, isCurrent);
-	const call = calls.get(state)?.get(key);
-	if (!call || call.closed || call.owner !== owner || call.modelInput?.threadId !== request.targetThreadId) throw new Error("Codex native input reused an unsettled call identity");
-	if (params.preparedOwner && call.modelInput.source.owner === owner) {
-		const prepared = retainNativeModelSource(params.preparedOwner);
-		if (!prepared) throw new Error("Codex native input lost its prepared model source");
-		call.modelInput.source.release();
-		call.modelInput.source = prepared;
-	}
-}
-function hasPendingSubmissionModelInput(calls, request) {
-	for (const entries of calls.values()) for (const call of entries.values()) if (!call.closed && call.modelInput?.threadId === request.threadId && (call.parentTurnId === request.parentTurnId || call.parentTurnId === request.rootTurnId)) {
-		const capture = call.modelInput.source.owner.modelSource?.capture();
-		capture?.release();
-		return Boolean(capture);
-	}
-	return false;
-}
-function retireReceiverModelInputs(calls, threadId, dependencies) {
-	for (const entries of calls.values()) for (const call of entries.values()) if (call.modelInput?.threadId === threadId) {
-		settleSubmissionModelInput(call, false, dependencies);
-		call.closed = true;
+//#region extensions/codex/src/app-server/native-subagent-receiver.ts
+/** Read-only eligibility; transferring observation still needs fresh native lineage. */
+function canPrepareNativeReceiver(state, previous, child, threadId, dependencies) {
+	if (previous === state) return true;
+	if (!dependencies.isCurrent(state) || child && (!child.assignment.terminal || child.pendingTurns.length > 0 || dependencies.hasChildCustody(child.parent, threadId))) return false;
+	if (!previous) return true;
+	if (dependencies.isRetired(previous) || !state.requesterSessionKey || previous.requesterSessionKey !== state.requesterSessionKey || !previous.historyOwner || !state.historyOwner || !matchesNativeAssignmentLifecycle(previous.historyOwner, state.historyOwner) || ![...state.owners.values()].some((owner) => owner.completionCustody?.isCurrent())) return false;
+	try {
+		state.assignmentStore?.assertCurrent();
+		return true;
+	} catch {
+		return false;
 	}
 }
-function readObservedSubmissionTurn(state, threadId, turnId, dependencies) {
-	const known = dependencies.knownChildren.get(threadId);
-	if (known?.parent !== state) return;
-	const pending = known.pendingTurns.find((turn) => turn.turnId === turnId);
-	const child = dependencies.currentChild(threadId);
-	const status = pending?.state ?? (child?.nativeTurnId === turnId ? child.nativeTurnState : void 0);
-	return status ? {
-		id: turnId,
-		status: status === "active" ? "inProgress" : status
-	} : void 0;
-}
-function observeSubmissionCall(state, turnId, item, allCalls, dependencies, isCurrent) {
-	const callId = readStringField(item, "id");
-	if (!turnId || !callId || !isCurrent()) return;
-	const owner = dependencies.parentOwner(state, turnId);
-	if (!owner && ![...state.owners.values()].some((candidate) => !candidate.turnId)) return;
-	const calls = allCalls.get(state) ?? /* @__PURE__ */ new Map();
-	const key = `${turnId}\0${callId}`;
-	if (calls.has(key) || !owner && calls.size >= 32) return;
-	const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [];
-	const targets = receivers.flatMap((id) => {
-		if (typeof id !== "string") return [];
-		dependencies.prepareReceiver(state, id);
-		const predecessor = captureSubmissionPredecessor({
-			state,
-			known: dependencies.knownChildren.get(id),
-			child: dependencies.currentChild(id)
+//#endregion
+//#region extensions/codex/src/app-server/native-subagent-submission-call.ts
+function createNativeSubagentSubmissionCalls(calls, dependencies, operations) {
+	const { isCurrent } = operations;
+	function admitModelInput(state, owner, request, pendingModelSources, preparedOwner) {
+		if (!owner.modelSource || !isCurrent(state)) throw new Error("Codex native input has no admitted model source");
+		assertNativeModelInputCompatible(owner, dependencies.currentModelExecution(request.targetThreadId) ?? owner);
+		for (const entries of calls.values()) for (const pending of entries.values()) if (pending.modelInput?.threadId === request.targetThreadId) assertNativeModelInputCompatible(owner, pending.modelInput.source.owner);
+		const key = `${request.turnId}\0${request.itemId}`;
+		if (owner.modelSource.hasOperatorSource && !calls.get(state)?.has(key)) {
+			if ([...calls.values()].reduce((count, entries) => count + [...entries.values()].filter((call) => call.modelInput?.source.owner.modelSource?.hasOperatorSource).length, 0) + pendingModelSources >= 32) throw new Error("Codex pending native input admission capacity reached");
+		}
+		observeCall(state, request.turnId, {
+			id: request.itemId,
+			receiverThreadIds: [request.targetThreadId]
 		});
-		return predecessor ? [{
-			childThreadId: id,
-			predecessor
-		}] : [];
-	});
-	const receiver = receivers.length === 1 ? receivers[0] : void 0;
-	const source = typeof receiver === "string" ? retainNativeModelSource(owner) : void 0;
-	if (!targets.length && !source) return;
-	calls.set(key, {
-		parentTurnId: turnId,
-		callId,
-		targets,
-		owner,
-		...source && typeof receiver === "string" ? { modelInput: {
-			threadId: receiver,
-			source
-		} } : {}
-	});
-	allCalls.set(state, calls);
-}
-function assertSubmissionModelInputsCurrent(calls, threadId, owner) {
-	for (const pending of calls) for (const call of pending.values()) if (call.modelInput?.threadId === threadId) try {
-		assertNativeModelInputCompatible(call.modelInput.source.owner, owner);
-	} catch (error) {
-		if (call.accepted) owner.modelExecutionCancelled = true;
-		throw error;
-	}
-}
-function settleSubmissionModelInput(call, accepted, dependencies) {
-	const input = call.modelInput;
-	if (!input) return;
-	const receiver = accepted ? dependencies.currentModelExecution(input.threadId) : void 0;
-	call.modelInput = void 0;
-	try {
-		const known = dependencies.knownChildren.get(input.threadId);
-		const isOtherTurn = call.submissionId && known?.observedTurns.has(call.submissionId) && receiver?.turnId !== call.submissionId;
-		if (accepted && receiver && !isOtherTurn) try {
-			assertNativeModelInputCompatible(input.source.owner, receiver);
-		} catch {
-			receiver.modelExecutionCancelled = true;
+		const call = calls.get(state)?.get(key);
+		if (!call || call.closed || call.owner !== owner || call.modelInput?.threadId !== request.targetThreadId) throw new Error("Codex native input reused an unsettled call identity");
+		if (preparedOwner && call.modelInput.source.owner === owner) {
+			const prepared = retainNativeModelSource(preparedOwner);
+			if (!prepared) throw new Error("Codex native input lost its prepared model source");
+			call.modelInput.source.release();
+			call.modelInput.source = prepared;
 		}
-	} finally {
-		input.source.release();
 	}
-}
-function hasSubmissionCallCustody(state, call, hasObservationBacking) {
-	return Boolean(call.accepted && call.targets.some(({ childThreadId }) => state.owners.size > 0 || hasObservationBacking?.(state.parentThreadId, childThreadId)));
-}
-function captureSubmissionPredecessor(params) {
-	const { state, known, child } = params;
-	if (known?.parent !== state) return;
-	if (!known.assignment.nativeTurnId) return child && child.runId === known.assignment.runId && !child.terminal && !known.assignment.terminal && !known.assignment.unanchored ? { child } : void 0;
-	return {
-		runId: known.assignment.runId,
-		nativeTurnId: known.assignment.nativeTurnId,
-		terminal: known.assignment.terminal || child?.nativeTurnState === "completed" || child?.nativeTurnState === "failed"
-	};
-}
-function observeSubmissionPredecessor(params) {
-	const { state, call, threadId, turn, known } = params;
-	const submissionId = call.submissionId;
-	if (!call.accepted || !submissionId) return;
-	call.targets = call.targets.filter(({ childThreadId, predecessor }) => {
-		if (childThreadId !== threadId || !("child" in predecessor)) return true;
-		const child = predecessor.child;
-		if (known?.parent !== state || known.assignment.runId !== child.runId || state.owners.size === 0 && !params.hasObservationBacking?.(state.parentThreadId, threadId)) return false;
-		const nativeTurnId = child.nativeTurnId;
-		if (!nativeTurnId || nativeTurnId === submissionId || known.assignment.nativeTurnId !== nativeTurnId) return true;
-		const nativeState = (readStringField(turn, "id") === nativeTurnId ? readNativeTurnEnd(turn) : void 0) ?? child.nativeTurnState;
-		const owner = call.owner && [...state.owners.values()].includes(call.owner) ? call.owner : void 0;
-		if (nativeState === "interrupted") {
-			if (owner) params.acceptContinuation(owner);
-			return false;
+	function hasPendingModelInput(request) {
+		for (const entries of calls.values()) for (const call of entries.values()) if (!call.closed && call.modelInput?.threadId === request.threadId && (call.parentTurnId === request.parentTurnId || call.parentTurnId === request.rootTurnId)) {
+			const capture = call.modelInput.source.owner.modelSource?.capture();
+			capture?.release();
+			return Boolean(capture);
 		}
-		if (!known.assignment.terminal && nativeState !== "completed" && nativeState !== "failed") return true;
-		params.capture({
-			parentTurnId: call.parentTurnId,
-			callId: call.callId,
-			childThreadId,
-			submissionId,
-			predecessorRunId: child.runId,
-			predecessorNativeTurnId: nativeTurnId
-		}, owner);
 		return false;
-	});
-	if (call.targets.length === 0) {
-		call.owner = void 0;
-		call.completionCustody?.release();
-		call.completionCustody = void 0;
 	}
-}
-function pruneSubmissionCalls(state, calls, dependencies) {
-	const hasUnboundOwner = [...state.owners.values()].some((owner) => !owner.turnId);
-	for (const [key, call] of calls ?? []) {
-		if (hasSubmissionCallCustody(state, call, dependencies.hasObservationBacking)) {
-			if (!call.owner || ![...state.owners.values()].includes(call.owner)) call.owner = void 0;
-			continue;
+	function retireReceiverModelInputs(threadId) {
+		for (const entries of calls.values()) for (const call of entries.values()) if (call.modelInput?.threadId === threadId) {
+			settleSubmissionModelInput(call, false);
+			call.closed = true;
 		}
-		if (call.owner && ![...state.owners.values()].includes(call.owner) || !dependencies.parentOwner(state, call.parentTurnId) && !hasUnboundOwner) {
-			settleSubmissionModelInput(call, false, dependencies);
-			calls.delete(key);
-			call.completionCustody?.release();
+	}
+	function observeCall(state, turnId, item) {
+		const callId = readStringField(item, "id");
+		if (!turnId || !callId || !isCurrent(state)) return;
+		const owner = dependencies.parentOwner(state, turnId);
+		if (!owner && ![...state.owners.values()].some((candidate) => !candidate.turnId)) return;
+		const entries = calls.get(state) ?? /* @__PURE__ */ new Map();
+		const key = `${turnId}\0${callId}`;
+		if (entries.has(key) || !owner && entries.size >= 32) return;
+		const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [];
+		const targets = receivers.flatMap((id) => {
+			if (typeof id !== "string") return [];
+			dependencies.prepareReceiver(state, id);
+			const predecessor = captureSubmissionPredecessor({
+				state,
+				known: dependencies.knownChildren.get(id),
+				child: dependencies.currentChild(id)
+			});
+			return predecessor ? [{
+				childThreadId: id,
+				predecessor
+			}] : [];
+		});
+		const receiver = receivers.length === 1 ? receivers[0] : void 0;
+		const source = typeof receiver === "string" ? retainNativeModelSource(owner) : void 0;
+		if (!targets.length && !source) return;
+		entries.set(key, {
+			parentTurnId: turnId,
+			callId,
+			targets,
+			owner,
+			...source && typeof receiver === "string" ? { modelInput: {
+				threadId: receiver,
+				source
+			} } : {}
+		});
+		calls.set(state, entries);
+	}
+	function assertModelInputCurrent(threadId, owner) {
+		for (const pending of calls.values()) for (const call of pending.values()) if (call.modelInput?.threadId === threadId) try {
+			assertNativeModelInputCompatible(call.modelInput.source.owner, owner);
+		} catch (error) {
+			if (call.accepted) owner.modelExecutionCancelled = true;
+			throw error;
 		}
 	}
-}
-function acceptSubmissionModelInteraction(calls, turnId, itemId, threadId, accept, dependencies) {
-	const call = calls?.get(`${turnId ?? ""}\0${itemId ?? ""}`);
-	if (!call) return false;
-	if (call.closed || !call.modelInput) return true;
-	if (call.modelInput.threadId !== threadId) throw new Error("Codex native interaction changed its admitted target");
-	call.accepted = true;
-	accept(call.modelInput.source.owner);
-	call.closed = true;
-	settleSubmissionModelInput(call, true, dependencies);
-	return true;
-}
-function acceptNativeSubmission(state, call, dependencies) {
-	const owner = dependencies.parentOwner(state, call.parentTurnId);
-	if (call.closed || !owner || call.owner && owner !== call.owner || !call.submissionId || !dependencies.isCurrent(state)) return;
-	call.closed = true;
-	call.accepted = true;
-	call.owner = owner;
-	call.completionCustody ??= owner.completionCustody?.retain();
-	const modelSource = retainNativeModelSource(call.modelInput?.source.owner);
-	try {
-		settleSubmissionModelInput(call, true, dependencies);
-		const targets = call.targets;
-		call.targets = [];
-		for (const target of targets) {
-			const { childThreadId, predecessor } = target;
-			const modelOwner = modelSource?.owner ?? owner;
-			if (modelOwner.modelSource && ("child" in predecessor || predecessor.terminal)) dependencies.acceptContinuation(state, {
-				...owner,
-				claimDirectChild: void 0,
-				rejectPendingDirectChild: void 0,
-				onDirectChildAccepted: void 0
-			}, childThreadId, call, modelOwner);
-			if ("child" in predecessor) {
-				call.targets.push(target);
-				continue;
+	function acceptInteraction(state, turnId, itemId, threadId, accept) {
+		const call = calls.get(state)?.get(`${turnId ?? ""}\0${itemId ?? ""}`);
+		if (!call) return false;
+		if (call.closed || !call.modelInput) return true;
+		if (call.modelInput.threadId !== threadId) throw new Error("Codex native interaction changed its admitted target");
+		call.accepted = true;
+		accept(call.modelInput.source.owner);
+		call.closed = true;
+		settleSubmissionModelInput(call, true);
+		return true;
+	}
+	function readObservedSubmissionTurn(state, threadId, turnId) {
+		const known = dependencies.knownChildren.get(threadId);
+		if (known?.parent !== state) return;
+		const pending = known.pendingTurns.find((turn) => turn.turnId === turnId);
+		const child = dependencies.currentChild(threadId);
+		const status = pending?.state ?? (child?.nativeTurnId === turnId ? child.nativeTurnState : void 0);
+		return status ? {
+			id: turnId,
+			status: status === "active" ? "inProgress" : status
+		} : void 0;
+	}
+	function settleSubmissionModelInput(call, accepted) {
+		const input = call.modelInput;
+		if (!input) return;
+		const receiver = accepted ? dependencies.currentModelExecution(input.threadId) : void 0;
+		call.modelInput = void 0;
+		try {
+			const known = dependencies.knownChildren.get(input.threadId);
+			const isOtherTurn = call.submissionId && known?.observedTurns.has(call.submissionId) && receiver?.turnId !== call.submissionId;
+			if (accepted && receiver && !isOtherTurn) try {
+				assertNativeModelInputCompatible(input.source.owner, receiver);
+			} catch {
+				receiver.modelExecutionCancelled = true;
 			}
-			if (!predecessor.terminal) {
-				dependencies.acceptContinuation(state, owner, childThreadId, call, modelOwner);
-				continue;
+		} finally {
+			input.source.release();
+		}
+	}
+	function hasSubmissionCallCustody(state, call) {
+		return Boolean(call.accepted && call.targets.some(({ childThreadId }) => state.owners.size > 0 || dependencies.hasObservationBacking?.(state.parentThreadId, childThreadId)));
+	}
+	function observeSubmissionPredecessor(state, call, threadId, turn) {
+		const known = dependencies.knownChildren.get(threadId);
+		const submissionId = call.submissionId;
+		if (!call.accepted || !submissionId) return;
+		call.targets = call.targets.filter(({ childThreadId, predecessor }) => {
+			if (childThreadId !== threadId || !("child" in predecessor)) return true;
+			const child = predecessor.child;
+			if (known?.parent !== state || known.assignment.runId !== child.runId || state.owners.size === 0 && !dependencies.hasObservationBacking?.(state.parentThreadId, threadId)) return false;
+			const nativeTurnId = child.nativeTurnId;
+			if (!nativeTurnId || nativeTurnId === submissionId || known.assignment.nativeTurnId !== nativeTurnId) return true;
+			const nativeState = (readStringField(turn, "id") === nativeTurnId ? readNativeTurnEnd(turn) : void 0) ?? child.nativeTurnState;
+			const owner = call.owner && [...state.owners.values()].includes(call.owner) ? call.owner : void 0;
+			if (nativeState === "interrupted") {
+				if (owner) dependencies.acceptContinuation(state, owner, threadId, call);
+				return false;
 			}
-			dependencies.capture(state, {
+			if (!known.assignment.terminal && nativeState !== "completed" && nativeState !== "failed") return true;
+			operations.capture(state, {
 				parentTurnId: call.parentTurnId,
 				callId: call.callId,
 				childThreadId,
-				submissionId: call.submissionId,
-				predecessorRunId: predecessor.runId,
-				predecessorNativeTurnId: predecessor.nativeTurnId
-			}, owner, true);
-		}
-		for (const { childThreadId } of call.targets) dependencies.observeKnownChild(childThreadId);
-		if (!call.targets.length) {
+				submissionId,
+				predecessorRunId: child.runId,
+				predecessorNativeTurnId: nativeTurnId
+			}, owner, true, call.completionCustody);
+			return false;
+		});
+		if (call.targets.length === 0) {
+			call.owner = void 0;
 			call.completionCustody?.release();
 			call.completionCustody = void 0;
 		}
-	} finally {
-		modelSource?.release();
 	}
+	function pruneSubmissionCalls(state, parentCalls) {
+		const hasUnboundOwner = [...state.owners.values()].some((owner) => !owner.turnId);
+		for (const [key, call] of parentCalls ?? []) {
+			if (hasSubmissionCallCustody(state, call)) {
+				if (!call.owner || ![...state.owners.values()].includes(call.owner)) call.owner = void 0;
+				continue;
+			}
+			if (call.owner && ![...state.owners.values()].includes(call.owner) || !dependencies.parentOwner(state, call.parentTurnId) && !hasUnboundOwner) {
+				settleSubmissionModelInput(call, false);
+				parentCalls.delete(key);
+				call.completionCustody?.release();
+			}
+		}
+	}
+	function acceptNativeSubmission(state, call) {
+		const owner = dependencies.parentOwner(state, call.parentTurnId);
+		if (call.closed || !owner || call.owner && owner !== call.owner || !call.submissionId || !isCurrent(state)) return;
+		call.closed = true;
+		call.accepted = true;
+		call.owner = owner;
+		call.completionCustody ??= owner.completionCustody?.retain();
+		const modelSource = retainNativeModelSource(call.modelInput?.source.owner);
+		try {
+			settleSubmissionModelInput(call, true);
+			const targets = call.targets;
+			call.targets = [];
+			for (const target of targets) {
+				const { childThreadId, predecessor } = target;
+				const modelOwner = modelSource?.owner ?? owner;
+				if (modelOwner.modelSource && ("child" in predecessor || predecessor.terminal)) dependencies.acceptContinuation(state, {
+					...owner,
+					claimDirectChild: void 0,
+					rejectPendingDirectChild: void 0,
+					onDirectChildAccepted: void 0
+				}, childThreadId, call, modelOwner);
+				if ("child" in predecessor) {
+					call.targets.push(target);
+					continue;
+				}
+				if (!predecessor.terminal) {
+					dependencies.acceptContinuation(state, owner, childThreadId, call, modelOwner);
+					continue;
+				}
+				operations.capture(state, {
+					parentTurnId: call.parentTurnId,
+					callId: call.callId,
+					childThreadId,
+					submissionId: call.submissionId,
+					predecessorRunId: predecessor.runId,
+					predecessorNativeTurnId: predecessor.nativeTurnId
+				}, owner, true);
+			}
+			for (const { childThreadId } of call.targets) operations.observeKnownChild(childThreadId);
+			if (!call.targets.length) {
+				call.completionCustody?.release();
+				call.completionCustody = void 0;
+			}
+		} finally {
+			modelSource?.release();
+		}
+	}
+	return {
+		admitModelInput,
+		hasPendingModelInput,
+		retireReceiverModelInputs,
+		observeCall,
+		assertModelInputCurrent,
+		acceptInteraction,
+		readObservedSubmissionTurn,
+		settleSubmissionModelInput,
+		hasSubmissionCallCustody,
+		observeSubmissionPredecessor,
+		pruneSubmissionCalls,
+		acceptNativeSubmission
+	};
+}
+function captureSubmissionPredecessor(params) {
+	const { state, known, child } = params;
+	if (known?.parent !== state) return;
+	if (!known.assignment.nativeTurnId) return child && child.runId === known.assignment.runId && !child.terminal && !known.assignment.terminal && !known.assignment.unanchored ? { child } : void 0;
+	return {
+		runId: known.assignment.runId,
+		nativeTurnId: known.assignment.nativeTurnId,
+		terminal: known.assignment.terminal || child?.nativeTurnState === "completed" || child?.nativeTurnState === "failed"
+	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-subagent-submission-history.ts
@@ -2404,8 +2400,7 @@ async function readCodexNativeSubmissionTurn(receipt, dependencies) {
 		if (!revision.isCurrent() || !dependencies.isCurrent()) return;
 		const thread = isJsonObject(response.thread) ? response.thread : void 0;
 		if (readStringField(thread, "id") !== receipt.childThreadId || readThreadParentThreadId(thread) !== dependencies.parentThreadId()) return;
-		const turns = [];
-		for (const turn of Array.isArray(thread?.turns) ? thread.turns : []) if (isJsonObject(turn)) turns.push(turn);
+		const turns = (Array.isArray(thread?.turns) ? thread.turns : []).flatMap((turn) => isJsonObject(turn) ? [turn] : []);
 		const predecessorIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.predecessorNativeTurnId);
 		const turnIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.submissionId);
 		if (predecessorIndex < 0 || turnIndex <= predecessorIndex || !["completed", "failed"].includes(readStringField(turns[predecessorIndex], "status") ?? "")) return;
@@ -2427,6 +2422,11 @@ var CodexNativeSubagentSubmissionOwner = class {
 		this.writes = /* @__PURE__ */ new Map();
 		this.disposed = false;
 		this.pollDelays = dependencies.recoveryPollDelaysMs ?? DEFAULT_RECOVERY_POLL_DELAYS_MS;
+		this.modelInputs = createNativeSubagentSubmissionCalls(this.calls, dependencies, {
+			isCurrent: (state) => this.isCurrent(state),
+			capture: (state, receipt, owner, persist, completionCustody) => this.capture(state, receipt, owner, persist, completionCustody),
+			observeKnownChild: (threadId) => this.observeKnownChild(threadId)
+		});
 	}
 	isCurrent(state) {
 		if (this.dependencies.isCurrent(state)) return true;
@@ -2446,33 +2446,6 @@ var CodexNativeSubagentSubmissionOwner = class {
 		}
 		return true;
 	}
-	observeCall(state, turnId, item) {
-		observeSubmissionCall(state, turnId, item, this.calls, this.dependencies, () => this.isCurrent(state));
-	}
-	admitModelInput(state, owner, request, pendingModelSources, preparedOwner) {
-		admitSubmissionModelInput({
-			state,
-			owner,
-			request,
-			pendingModelSources,
-			preparedOwner,
-			calls: this.calls,
-			dependencies: this.dependencies,
-			isCurrent: () => this.isCurrent(state)
-		});
-	}
-	acceptInteraction(state, turnId, itemId, threadId, accept) {
-		return acceptSubmissionModelInteraction(this.calls.get(state), turnId, itemId, threadId, accept, this.dependencies);
-	}
-	hasPendingModelInput(request) {
-		return hasPendingSubmissionModelInput(this.calls, request);
-	}
-	retireReceiverModelInputs(threadId) {
-		retireReceiverModelInputs(this.calls, threadId, this.dependencies);
-	}
-	assertModelInputCurrent(threadId, owner) {
-		assertSubmissionModelInputsCurrent(this.calls.values(), threadId, owner);
-	}
 	observeOutput(state, turnId, item) {
 		if (item.type !== "function_call_output" || !turnId) return;
 		const key = `${turnId}\0${readStringField(item, "call_id") ?? ""}`;
@@ -2485,14 +2458,14 @@ var CodexNativeSubagentSubmissionOwner = class {
 		const submissionId = isJsonObject(output) ? readStringField(output, "submission_id")?.trim() : void 0;
 		if (!submissionId) {
 			call.closed = true;
-			settleSubmissionModelInput(call, false, this.dependencies);
+			this.modelInputs.settleSubmissionModelInput(call, false);
 			return;
 		}
 		call.submissionId = submissionId;
-		this.accept(state, call);
+		this.modelInputs.acceptNativeSubmission(state, call);
 	}
 	bind(state, turnId) {
-		for (const call of this.calls.get(state)?.values() ?? []) if (call.parentTurnId === turnId && call.submissionId) this.accept(state, call);
+		for (const call of this.calls.get(state)?.values() ?? []) if (call.parentTurnId === turnId && call.submissionId) this.modelInputs.acceptNativeSubmission(state, call);
 	}
 	restore(state, owner) {
 		try {
@@ -2508,17 +2481,17 @@ var CodexNativeSubagentSubmissionOwner = class {
 		for (const [state, entries] of this.pending) for (const custody of entries.values()) if (custody.receipt.childThreadId === threadId && custody.receipt.submissionId === turnId) this.promote(state, custody, turn);
 	}
 	hasCustody(state) {
-		return Boolean(this.pending.get(state)?.size || this.writes.get(state)?.size) || [...this.calls.get(state)?.values() ?? []].some((call) => hasSubmissionCallCustody(state, call, this.dependencies.hasObservationBacking));
+		return Boolean(this.pending.get(state)?.size || this.writes.get(state)?.size) || [...this.calls.get(state)?.values() ?? []].some((call) => this.modelInputs.hasSubmissionCallCustody(state, call));
 	}
 	hasChildCustody(state, childThreadId) {
-		return [...this.pending.get(state)?.values() ?? []].some((entry) => entry.receipt.childThreadId === childThreadId) || [...this.calls.get(state)?.values() ?? []].some((call) => call.targets.some((target) => target.childThreadId === childThreadId) && hasSubmissionCallCustody(state, call, this.dependencies.hasObservationBacking));
+		return [...this.pending.get(state)?.values() ?? []].some((entry) => entry.receipt.childThreadId === childThreadId) || [...this.calls.get(state)?.values() ?? []].some((call) => call.targets.some((target) => target.childThreadId === childThreadId) && this.modelInputs.hasSubmissionCallCustody(state, call));
 	}
 	async settleWrites(state) {
 		while (this.writes.get(state)?.size) await Promise.allSettled(this.writes.get(state));
 	}
 	async drain(state) {
 		const calls = this.calls.get(state);
-		pruneSubmissionCalls(state, calls, this.dependencies);
+		this.modelInputs.pruneSubmissionCalls(state, calls);
 		if (!calls?.size) this.calls.delete(state);
 		await this.settleWrites(state);
 		if (state.owners.size === 0) for (const custody of this.pending.get(state)?.values() ?? []) {
@@ -2532,13 +2505,13 @@ var CodexNativeSubagentSubmissionOwner = class {
 	}
 	retire(state) {
 		for (const call of this.calls.get(state)?.values() ?? []) {
-			settleSubmissionModelInput(call, false, this.dependencies);
+			this.modelInputs.settleSubmissionModelInput(call, false);
 			call.completionCustody?.release();
 		}
 		this.calls.delete(state);
 		for (const custody of this.pending.get(state)?.values() ?? []) {
 			custody.phase = "settled";
-			if (custody.timer) clearTimeout(custody.timer);
+			clearTimeout(custody.timer);
 			custody.release();
 			custody.completionCustody?.release();
 		}
@@ -2548,27 +2521,10 @@ var CodexNativeSubagentSubmissionOwner = class {
 		this.disposed = true;
 		for (const state of /* @__PURE__ */ new Set([...this.pending.keys(), ...this.calls.keys()])) this.retire(state);
 	}
-	accept(state, call) {
-		acceptNativeSubmission(state, call, {
-			...this.dependencies,
-			isCurrent: (parent) => this.isCurrent(parent),
-			capture: (parent, receipt, owner, persist) => this.capture(parent, receipt, owner, persist),
-			observeKnownChild: (threadId) => this.observeKnownChild(threadId)
-		});
-	}
 	observeKnownChild(threadId, turn) {
 		for (const [state, calls] of this.calls) {
 			if (!this.isCurrent(state)) continue;
-			for (const call of calls.values()) observeSubmissionPredecessor({
-				state,
-				call,
-				threadId,
-				turn,
-				known: this.dependencies.knownChildren.get(threadId),
-				hasObservationBacking: this.dependencies.hasObservationBacking,
-				acceptContinuation: (owner) => this.dependencies.acceptContinuation(state, owner, threadId, call),
-				capture: (receipt, owner) => this.capture(state, receipt, owner, true, call.completionCustody)
-			});
+			for (const call of calls.values()) this.modelInputs.observeSubmissionPredecessor(state, call, threadId, turn);
 			this.dependencies.onSettled(state);
 		}
 	}
@@ -2597,14 +2553,14 @@ var CodexNativeSubagentSubmissionOwner = class {
 				embeddedAgentLog.warn("Accepted native follow-up lost restart protection; retaining local observation", { error: formatErrorMessage$1(error) });
 			}
 		})());
-		const observed = readObservedSubmissionTurn(state, receipt.childThreadId, receipt.submissionId, this.dependencies);
+		const observed = this.modelInputs.readObservedSubmissionTurn(state, receipt.childThreadId, receipt.submissionId);
 		if (observed) this.promote(state, custody, observed);
 		if (custody.phase !== "promoting") this.reconcile(state, custody);
 	}
 	promote(state, custody, turn, historyValidated = false) {
-		if (!this.isObserving(state, custody) || !this.admitTurn(state, custody.receipt, turn, custody.owner, historyValidated, custody.completionCustody)) return;
+		if (!this.isObserving(state, custody) || !this.admitTurn(state, custody, turn, historyValidated)) return;
 		custody.phase = "promoting";
-		if (custody.timer) clearTimeout(custody.timer);
+		clearTimeout(custody.timer);
 	}
 	settleChild(state, child) {
 		for (const custody of this.pending.get(state)?.values() ?? []) {
@@ -2626,7 +2582,15 @@ var CodexNativeSubagentSubmissionOwner = class {
 	async reconcile(state, custody) {
 		if (!this.isObserving(state, custody)) return;
 		try {
-			const turn = await this.readTurn(state, custody);
+			const childThreadId = custody.receipt.childThreadId;
+			const turn = await readCodexNativeSubmissionTurn(custody.receipt, {
+				client: this.dependencies.client,
+				recovery: this.dependencies.recovery,
+				prepareReceiver: () => this.dependencies.prepareReceiver(state, childThreadId),
+				isCurrent: () => this.isObserving(state, custody),
+				parentThreadId: () => this.nativeParentThreadId(state, childThreadId),
+				currentChild: () => this.dependencies.currentChild(childThreadId)
+			});
 			if (turn) this.promote(state, custody, turn, true);
 		} catch (error) {
 			embeddedAgentLog.warn("Failed to reconcile an accepted native follow-up receipt", { error: formatErrorMessage$1(error) });
@@ -2638,20 +2602,9 @@ var CodexNativeSubagentSubmissionOwner = class {
 		}, delayForAttempt(this.pollDelays, custody.attempt++));
 		custody.timer.unref();
 	}
-	readTurn(state, custody) {
-		const childThreadId = custody.receipt.childThreadId;
-		return readCodexNativeSubmissionTurn(custody.receipt, {
-			client: this.dependencies.client,
-			recovery: this.dependencies.recovery,
-			prepareReceiver: () => this.dependencies.prepareReceiver(state, childThreadId),
-			isCurrent: () => this.isObserving(state, custody),
-			parentThreadId: () => this.nativeParentThreadId(state, childThreadId),
-			currentChild: () => this.dependencies.currentChild(childThreadId)
-		});
-	}
 	finishCustody(state, custody) {
 		custody.phase = "settled";
-		if (custody.timer) clearTimeout(custody.timer);
+		clearTimeout(custody.timer);
 		const entries = this.pending.get(state);
 		for (const [key, entry] of entries ?? []) if (entry === custody) entries.delete(key);
 		if (!entries?.size) this.pending.delete(state);
@@ -2659,7 +2612,7 @@ var CodexNativeSubagentSubmissionOwner = class {
 		custody.completionCustody?.release();
 		this.dependencies.onSettled(state);
 	}
-	admitTurn(state, receipt, turn, owner, historyValidated, completionCustody) {
+	admitTurn(state, { receipt, owner, completionCustody }, turn, historyValidated) {
 		if (readStringField(turn, "id") !== receipt.submissionId || this.disposed || !this.isCurrent(state)) return false;
 		const runId = codexNativeSubagentRunId(receipt.childThreadId, receipt.submissionId);
 		let known = this.dependencies.knownChildren.get(receipt.childThreadId);
@@ -2707,7 +2660,7 @@ var CodexNativeSubagentSubmissionOwner = class {
 				pending.admittedOwner = owner;
 				owner.onDirectChildAccepted?.();
 			}
-			this.dependencies.admitFollowup(known, receipt.childThreadId);
+			this.dependencies.admitFollowup(known);
 		}
 		const child = this.dependencies.currentChild(receipt.childThreadId);
 		if (child?.runId !== runId) return false;
@@ -2777,25 +2730,7 @@ function sanitizeCodexAgentEventRecord(value) {
 	return sanitizeToolArgs(value);
 }
 function sanitizeCodexToolArguments(value) {
-	if (!isJsonObject(value)) return;
-	return sanitizeCodexAgentEventRecord(value);
-}
-//#endregion
-//#region extensions/codex/src/app-server/web-search-item.ts
-function projectCodexWebSearchItem(item) {
-	const action = isJsonObject(item.action) ? item.action : void 0;
-	const actionType = normalizeOptionalString(action?.type);
-	const queries = actionType === "search" ? normalizeTrimmedStringList(action?.queries) : [];
-	const query = normalizeOptionalString(item.query) ?? (actionType === "search" ? normalizeOptionalString(action?.query) : void 0) ?? queries[0];
-	const url = normalizeOptionalString(action?.url);
-	const pattern = normalizeOptionalString(action?.pattern);
-	return {
-		...query ? { query } : {},
-		...queries.length > 0 ? { queries } : {},
-		...actionType && actionType !== "search" ? { action: actionType } : {},
-		...url ? { url } : {},
-		...pattern ? { pattern } : {}
-	};
+	return isJsonObject(value) ? sanitizeCodexAgentEventRecord(value) : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-items.ts
@@ -2828,23 +2763,21 @@ function projectCodexToolActivity(item, phase, meta) {
 	}) : void 0;
 }
 function isNativePostToolUseRelayItem(item) {
-	switch (item.type) {
-		case "commandExecution":
-		case "fileChange":
-		case "mcpToolCall": return true;
-		default: return false;
-	}
+	return [
+		"commandExecution",
+		"fileChange",
+		"mcpToolCall"
+	].includes(item.type);
 }
 function shouldSuppressChannelProgressForItem(item) {
-	if (isProjectedNativeToolItem(item)) return true;
-	return item.type === "dynamicToolCall";
+	return isProjectedNativeToolItem(item) || item.type === "dynamicToolCall";
 }
 function itemToolArgs(item) {
 	if (item.type === "commandExecution") return sanitizeCodexAgentEventRecord({
 		command: item.command,
 		...typeof item.cwd === "string" ? { cwd: item.cwd } : {}
 	});
-	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({ changes: itemFileChangesForTranscript(item) });
+	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({ changes: itemFileChanges(item, true) });
 	if (item.type === "webSearch") return webSearchToolArgs(item);
 	if (item.type === "dynamicToolCall" || item.type === "mcpToolCall") return sanitizeCodexToolArguments(item.arguments);
 }
@@ -2873,10 +2806,7 @@ function itemToolResult(item) {
 		...item.error ? { error: item.error } : {},
 		...item.result ? { result: item.result } : {}
 	});
-	if (item.type === "webSearch") return webSearchToolResult(item);
-}
-function webSearchToolResult(item) {
-	return sanitizeCodexAgentEventRecord({
+	if (item.type === "webSearch") return sanitizeCodexAgentEventRecord({
 		status: itemStatus(item),
 		...typeof item.durationMs === "number" ? { durationMs: item.durationMs } : {},
 		...webSearchToolArgs(item)
@@ -2886,20 +2816,6 @@ function itemFileChangeRecords(item) {
 	const changes = item.changes;
 	return Array.isArray(changes) ? changes.filter(isJsonObject) : [];
 }
-function itemFileChanges(item) {
-	return itemFileChangeRecords(item).flatMap((change) => {
-		const path = normalizeOptionalString(change.path);
-		if (!path || change.kind === void 0) return [];
-		return [{
-			path,
-			kind: change.kind
-		}];
-	});
-}
-function fileChangeKindType(kind) {
-	if (typeof kind === "string") return kind;
-	return isJsonObject(kind) ? normalizeOptionalString(kind.type) : void 0;
-}
 function countFileContentLines(content) {
 	if (!content) return 0;
 	const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
@@ -2907,7 +2823,7 @@ function countFileContentLines(content) {
 	return lines.length;
 }
 function fileChangeDiffStat(diff, kind) {
-	const kindType = fileChangeKindType(kind);
+	const kindType = typeof kind === "string" ? kind : isJsonObject(kind) ? normalizeOptionalString(kind.type) : void 0;
 	if (kindType === "add") return {
 		added: countFileContentLines(diff),
 		removed: 0
@@ -2942,7 +2858,7 @@ function truncateFileChangeDiffAtLineBoundary(diff, maxChars) {
 		diffTruncated: true
 	} : { diffTruncated: true };
 }
-function itemFileChangesForTranscript(item) {
+function itemFileChanges(item, includeDiff = false) {
 	let remainingDiffChars = 1e4;
 	return itemFileChangeRecords(item).flatMap((change) => {
 		const path = normalizeOptionalString(change.path);
@@ -2951,7 +2867,7 @@ function itemFileChangesForTranscript(item) {
 			path,
 			kind: change.kind
 		};
-		if (typeof change.diff !== "string") return [result];
+		if (!includeDiff || typeof change.diff !== "string") return [result];
 		result.stat = fileChangeDiffStat(change.diff, change.kind);
 		const bounded = truncateFileChangeDiffAtLineBoundary(change.diff, remainingDiffChars);
 		if (bounded.diff !== void 0) {
@@ -3024,7 +2940,7 @@ var CodexToolProgressProjection = class {
 		this.output = new NativeToolOutputAccumulator("Codex");
 		this.metas = /* @__PURE__ */ new Map();
 		this.sideEffectingNativeIds = /* @__PURE__ */ new Set();
-		this.sideEffectingDynamicIds = /* @__PURE__ */ new Set();
+		this.hasDynamicSideEffects = false;
 		this.transcriptProgressCallIds = /* @__PURE__ */ new Set();
 		this.approvalTimeoutKinds = /* @__PURE__ */ new Map();
 	}
@@ -3044,7 +2960,7 @@ var CodexToolProgressProjection = class {
 		return this.lastNativeToolError;
 	}
 	get hasPotentialSideEffects() {
-		return this.sideEffectingNativeIds.size > 0 || this.sideEffectingDynamicIds.size > 0;
+		return this.sideEffectingNativeIds.size > 0 || this.hasDynamicSideEffects;
 	}
 	approvalTimeoutExplanation(itemId, status) {
 		const kind = isNonSuccessItemStatus(status) && this.approvalTimeoutKinds.get(itemId);
@@ -3088,7 +3004,7 @@ var CodexToolProgressProjection = class {
 			error: resultText || (params.terminalType === "blocked" ? "codex dynamic tool blocked" : "codex dynamic tool failed")
 		};
 		else if (this.lastNativeToolError?.mutatingAction !== true) this.lastNativeToolError = void 0;
-		if (params.sideEffectEvidence === true) this.sideEffectingDynamicIds.add(params.callId);
+		this.hasDynamicSideEffects ||= params.sideEffectEvidence === true;
 	}
 	handleOutputDelta(params, toolName) {
 		const itemId = readStringField(params, "itemId");
@@ -3381,22 +3297,6 @@ function codeModeCommandFailed(output) {
 	}
 }
 //#endregion
-//#region extensions/codex/src/app-server/local-runtime-attribution.ts
-const OPENAI_PROVIDER_ID = "openai";
-const OPENAI_RESPONSES_API = "openai-responses";
-const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
-function resolveCodexLocalRuntimeAttribution(params) {
-	const authProfileProvider = normalizeLowercaseStringOrEmpty(params.runtimePlan?.auth?.authProfileProviderForAuth);
-	if (normalizeLowercaseStringOrEmpty(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.provider) === OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.api) === OPENAI_RESPONSES_API) return {
-		provider: OPENAI_PROVIDER_ID,
-		api: OPENAI_CODEX_RESPONSES_API
-	};
-	return {
-		provider: params.provider,
-		api: params.model.api
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-transcript.ts
 const MISSING_TOOL_RESULT_ERROR = "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
 const NATIVE_PATCH_REJECTION_RE = /^\s*patch rejected:\s*writing outside of the project;\s*rejected by user approval settings\s*$/iu;
@@ -3698,7 +3598,7 @@ var CodexToolTranscriptProjection = class {
 		});
 	}
 	emitAfterToolCallObservation(item) {
-		if (!this.shouldEmitAfterToolCallObservation(item)) return;
+		if (!isProjectedNativeToolItem(item) || this.afterToolCallObservedItemIds.has(item.id) || this.options.nativePostToolUseRelayEnabled && isNativePostToolUseRelayItem(item)) return;
 		const name = itemName(item);
 		const status = itemStatus(item);
 		if (!name || status === "running") return;
@@ -3822,10 +3722,6 @@ var CodexToolTranscriptProjection = class {
 			...item && isMutatingNativeToolItem(item) ? { mutatingAction: true } : {}
 		});
 	}
-	shouldEmitAfterToolCallObservation(item) {
-		if (!isProjectedNativeToolItem(item) || this.afterToolCallObservedItemIds.has(item.id)) return false;
-		return !(this.options.nativePostToolUseRelayEnabled && isNativePostToolUseRelayItem(item));
-	}
 	createToolCallMessage(params) {
 		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
 		return createAgentHarnessToolCallMessage({
@@ -4075,13 +3971,10 @@ var CodexEventProjection = class {
 					...reason ? { reason } : {}
 				}
 			});
-			if (reason === "highRiskCyberActivity") {
-				this.cyberNoticeState = "fallback";
-				this.emitCyberNotice("fallback", {
-					model: fromModel,
-					fallbackModel: toModel
-				});
-			}
+			if (reason === "highRiskCyberActivity") this.emitCyberNotice("fallback", {
+				model: fromModel,
+				fallbackModel: toModel
+			});
 		}
 	}
 	handleSafetyBuffering(params) {
@@ -4090,7 +3983,6 @@ var CodexEventProjection = class {
 			return;
 		}
 		if (this.safetyBufferingEnded || this.cyberNoticeState === "blocked" || this.cyberNoticeState === "fallback" || params.showBufferingUi !== true || !Array.isArray(params.useCases) || !params.useCases.includes("cyber")) return;
-		this.cyberNoticeState = "buffering";
 		const model = readStringField(params, "model");
 		const fallbackModel = readStringField(params, "fasterModel");
 		this.emitCyberNotice("buffering", {
@@ -4100,7 +3992,6 @@ var CodexEventProjection = class {
 	}
 	handleCyberPolicyError(codexErrorInfo, model) {
 		if (codexErrorInfo !== "cyberPolicy" || this.cyberNoticeState === "blocked") return;
-		this.cyberNoticeState = "blocked";
 		this.emitCyberNotice("blocked", { model: this.responseModel ?? model });
 	}
 	endSafetyBuffering() {
@@ -4112,10 +4003,10 @@ var CodexEventProjection = class {
 	}
 	clearSafetyBuffering() {
 		if (this.cyberNoticeState !== "buffering") return;
-		this.cyberNoticeState = void 0;
 		this.emitCyberNotice("cleared");
 	}
 	emitCyberNotice(state, models = {}) {
+		this.cyberNoticeState = state === "cleared" ? void 0 : state;
 		if (this.provider !== "openai") return;
 		this.emitAgentEvent({
 			stream: "notice",
@@ -4316,16 +4207,7 @@ var CodexNativeSubagentTurnObservation = class {
 		});
 	}
 	markActivityUnknown(childState) {
-		this.projectedActivityWaits.delete(childState);
-		childState.activityObserved = true;
-		this.callbacks.emitTaskEvent(childState, {
-			stream: "execution",
-			data: {
-				state: "unknown",
-				sourceId: this.observationSourceId,
-				executionId: childState.nativeTurnId
-			}
-		});
+		this.observeActivity(childState, "unknown", void 0, { executionId: childState.nativeTurnId });
 	}
 	refreshWaitDependency(childState, receiverThreadId) {
 		const activityWait = childState.activityWait;
@@ -4349,7 +4231,7 @@ var CodexNativeSubagentTurnObservation = class {
 		};
 		if (this.projectedActivityWaits.has(childState)) this.observeActivity(childState, "waiting", wait);
 	}
-	observeActivity(childState, state, wait) {
+	observeActivity(childState, state, wait, execution = childState.nativeTurnId ? { executionId: childState.nativeTurnId } : {}) {
 		if (wait && wait === childState.activityWait?.wait) this.projectedActivityWaits.add(childState);
 		else this.projectedActivityWaits.delete(childState);
 		childState.activityObserved = true;
@@ -4358,7 +4240,7 @@ var CodexNativeSubagentTurnObservation = class {
 			data: {
 				state,
 				sourceId: this.observationSourceId,
-				...childState.nativeTurnId ? { executionId: childState.nativeTurnId } : {},
+				...execution,
 				...wait ? { wait } : {}
 			}
 		});
@@ -4490,23 +4372,14 @@ var Monitor = class {
 			releaseClientRetentionIfIdle: () => this.releaseClientRetentionIfIdle(),
 			pruneParent: (state) => this.pruneParentIfUnused(state)
 		});
-		this.historyRecovery = new CodexNativeSubagentHistoryRecovery(client, {
-			getPendingTurnIds: (id) => this.knownChildren.get(id)?.pendingTurns.map((turn) => turn.turnId) ?? [],
-			getCurrentAssignmentState: (id) => {
-				return {
-					runId: this.knownChildren.get(id)?.assignment.runId,
-					nativeTurnState: this.currentChild(id)?.nativeTurnState
-				};
-			}
-		});
+		this.historyRecovery = new CodexNativeSubagentHistoryRecovery(client, this.knownChildren, this.childStates);
 		this.completionDelivery = new CodexNativeSubagentCompletionDelivery({
 			deliver: (params) => runtime.deliverAgentHarnessCompletion(params),
 			retryDelaysMs: options.completionDeliveryRetryDelaysMs,
 			maxRetries: options.completionDeliveryMaxRetries,
-			isCurrentChild: (child) => this.childStates.get(child.runId) === child,
-			isCurrentParent: (state) => this.parentStates.get(state.parentThreadId) === state,
-			isRetiredParent: (state) => this.retiredParentStates.has(state),
-			getParent: (id) => this.parentStates.get(id),
+			children: this.childStates,
+			parents: this.parentStates,
+			retiredParents: this.retiredParentStates,
 			unregisterChild: (child) => this.unregisterChild(child),
 			releaseClientRetentionIfIdle: () => this.releaseClientRetentionIfIdle()
 		});
@@ -4568,7 +4441,7 @@ var Monitor = class {
 			restoreKnownChild: (state, assignment) => this.restoreKnownChild(state, assignment),
 			prepareReceiver: (state, threadId) => this.prepareReceiverChild(state, threadId),
 			registerChild: (state, assignment, childOptions) => this.registerChildThread(state, assignment, childOptions),
-			admitFollowup: (known, id) => this.admitFollowupChild(known, id),
+			admitFollowup: (known) => this.admitFollowupChild(known),
 			resumeChild: (child) => this.resumeChild(child),
 			completeChild: (notification, child) => this.handleChildTurnCompletion(notification, child),
 			retain: (state, threadId) => {
@@ -4577,11 +4450,8 @@ var Monitor = class {
 					this.retainParentThread?.(state.parentThreadId),
 					this.retainParentThread?.(threadId)
 				];
-				let retained = true;
 				return () => {
-					if (!retained) return;
-					retained = false;
-					for (const release of releases) release?.();
+					for (const release of releases.splice(0)) release?.();
 				};
 			},
 			hasObservationBacking: options.hasObservationBacking,
@@ -4654,10 +4524,10 @@ var Monitor = class {
 			currentChild: this.currentChild.bind(this),
 			resolveParentOwner: this.resolveParentOwner.bind(this),
 			registerChildThread: this.registerChildThread.bind(this),
-			registerDirectSpawnChild: this.registerDirectSpawnChild.bind(this),
+			registerDirectSpawnChild: (state, turnId, evidence, owner) => this.admissionCustody.registerDirectSpawnChild(turnId, evidence, owner, (registration) => this.registerChildThread(state, evidence.childThreadId, registration)),
 			observeParentInteraction: this.observeParentInteraction.bind(this),
-			acceptInteraction: this.submissions.acceptInteraction.bind(this.submissions),
-			observeCall: this.submissions.observeCall.bind(this.submissions)
+			acceptInteraction: this.submissions.modelInputs.acceptInteraction,
+			observeCall: this.submissions.modelInputs.observeCall
 		});
 		this.removeCloseHandler = client.addCloseHandler(() => {
 			this.dispose().catch((error) => {
@@ -4713,10 +4583,10 @@ var Monitor = class {
 			state.turnIds.clear();
 			notifyNativeModelSourceWaiters(state);
 			this.childCloses.clear(state);
-			this.completionDelivery.deliverDetached(state, this.childStates.values());
+			this.completionDelivery.deliverDetached(state);
 		}
 		this.admissionCustody.retainOnly(() => false);
-		for (const [parentThreadId] of this.parentStates) if (![...this.childStates.values()].some((childState) => childState.parentThreadId === parentThreadId)) this.parentStates.delete(parentThreadId);
+		for (const [parentThreadId] of this.parentStates) if (!this.hasChildrenForParent(parentThreadId)) this.parentStates.delete(parentThreadId);
 		for (const known of this.knownChildren.values()) known.pendingTurns.forEach(releaseCompletionCustody);
 		this.knownChildren.clear();
 		this.childThreadIdsByAgentPath.clear();
@@ -4730,7 +4600,7 @@ var Monitor = class {
 			submissions: this.submissions,
 			assignments: this.assignments,
 			closes: this.childCloses,
-			deliverDetached: (state) => this.completionDelivery.deliverDetached(state, this.childStates.values()),
+			deliverDetached: (state) => this.completionDelivery.deliverDetached(state),
 			drainAdmissions: (state, owner, turnId) => this.drainPendingChildAdmissionEvidence(state, owner, turnId, true),
 			clearAdmissions: () => this.clearUnconsumablePendingChildAdmissionEvidence(),
 			prune: (state) => this.pruneParentIfUnused(state),
@@ -4743,10 +4613,10 @@ var Monitor = class {
 			children: this.childStates,
 			knownChildren: this.knownChildren,
 			admissions: this.admissionCustody.entries,
-			assertInputCurrent: (threadId, owner) => this.submissions.assertModelInputCurrent(threadId, owner),
-			hasPendingInput: (input) => this.submissions.hasPendingModelInput(input),
-			onExecutionAdmitted: (known, threadId) => {
-				this.admitFollowupChild(known, threadId);
+			assertInputCurrent: (threadId, owner) => this.submissions.modelInputs.assertModelInputCurrent(threadId, owner),
+			hasPendingInput: (input) => this.submissions.modelInputs.hasPendingModelInput(input),
+			onExecutionAdmitted: (known) => {
+				this.admitFollowupChild(known);
 			},
 			registerChildExecution: (state, modelRequest, agentPath, completionCustody) => {
 				this.registerChildThread(state, {
@@ -4788,7 +4658,7 @@ var Monitor = class {
 		const assertCurrent = () => {
 			request.signal?.throwIfAborted();
 			capture.assertCurrent();
-			if (this.disposed || this.retiredParentStates.has(state) || this.parentStates.get(state.parentThreadId) !== state || this.knownChildren.get(request.threadId) !== known || (current ? this.currentChild(request.threadId) !== current || current.terminal || current.settledWithoutCompletion || current.nativeTurnId !== request.turnId : !pending || !known.pendingTurns.includes(pending) || !pending.modelSource)) throw new Error("Native model execution assignment changed before admission.");
+			if (!this.isCurrentParent(state) || this.knownChildren.get(request.threadId) !== known || (current ? this.currentChild(request.threadId) !== current || current.terminal || current.settledWithoutCompletion || current.nativeTurnId !== request.turnId : !pending || !known.pendingTurns.includes(pending) || !pending.modelSource)) throw new Error("Native model execution assignment changed before admission.");
 		};
 		assertCurrent();
 		await this.assignments.recordExecution(state, {
@@ -4814,13 +4684,14 @@ var Monitor = class {
 			retainTargetRevision: (threadId) => this.recovery.retainThreadStatusRevision(threadId),
 			currentModelExecution: (threadId) => currentNativeModelExecution(threadId, this.parentStates, this.knownChildren, this.childStates),
 			admissions: this.admissionCustody.entries,
+			canPrepareReceiver: (state, threadId) => this.canPrepareReceiverChild(state, threadId),
 			prepareReceiver: (state, threadId, nativeParentThreadId) => this.prepareReceiverChild(state, threadId, nativeParentThreadId),
 			registerChildThread: (state, threadId, options) => this.registerChildThread(state, threadId, options),
-			admit: (state, owner, input, count, preparedOwner) => this.submissions.admitModelInput(state, owner, input, count, preparedOwner)
+			admit: (state, owner, input, count, preparedOwner) => this.submissions.modelInputs.admitModelInput(state, owner, input, count, preparedOwner)
 		});
 	}
 	releasePendingModelInputs(threadId) {
-		this.submissions.retireReceiverModelInputs(threadId);
+		this.submissions.modelInputs.retireReceiverModelInputs(threadId);
 		releasePendingNativeModelInputs(threadId, this.admissionCustody.entries);
 		this.clearUnconsumablePendingChildAdmissionEvidence();
 		notifyNativeModelSourceChange("thread/closed", this.parentStates.values());
@@ -4907,7 +4778,7 @@ var Monitor = class {
 			state: parent,
 			notification,
 			knownChildren: this.knownChildren.values(),
-			applyReceipts: (runIds) => this.applyNativeReceipts(parent, runIds)
+			applyReceipts: (runIds) => this.completionDelivery.applyReceipts(parent, runIds)
 		});
 		if (childState && !childState.terminal && (!pendingTurns?.length || notification.method === "turn/completed")) this.turnObservation.emitChildTaskActivity(notification, childState);
 		if (!pendingNativeTurn) await this.handleChildTurnCompletion(notification, childState);
@@ -5082,7 +4953,6 @@ var Monitor = class {
 		const observedTurn = Boolean(child.nativeTurnId && child.nativeTurnId !== turnId);
 		if (child.nativeTurnId !== turnId) {
 			child.nativeTurnId = turnId;
-			child.nativeTurnState = void 0;
 			child.activityWait = void 0;
 		}
 		child.nativeTurnState = recovery.nativeTurnState;
@@ -5096,9 +4966,9 @@ var Monitor = class {
 		known.assignment.nativeTurnId = child.nativeTurnId;
 		known.assignment.unanchored = void 0;
 		if (!known.observedTurns.has(child.nativeTurnId)) known.observedTurns.set(child.nativeTurnId, observedTurn ? { awaitingInteraction: true } : {});
-		if (observedTurn && known.pendingTurns.length === 0) this.associatePendingChildInteraction(known, child.childThreadId, child.nativeTurnId);
+		if (observedTurn && known.pendingTurns.length === 0) this.associatePendingChildInteraction(known, child.nativeTurnId);
 		this.submissions.observeKnownChild(child.childThreadId);
-		return this.admitFollowupChild(known, child.childThreadId);
+		return this.admitFollowupChild(known);
 	}
 	async processCompletion(state, childState, completion, eventAt = Date.now()) {
 		if (childState.terminal) return;
@@ -5123,28 +4993,26 @@ var Monitor = class {
 		this.recovery.markTerminalRevision(childState.childThreadId);
 		releaseNativeDirectChild(childState);
 		this.recovery.clearRecoveryTimers(childState);
-		this.applyNativeReceipts(state, childState.deliveryReceipts.record(childState.runId, this.knownChildren.get(childState.childThreadId)?.agentPaths ?? [childState.childThreadId], acceptedCompletion.result));
+		this.completionDelivery.applyReceipts(state, childState.deliveryReceipts.record(childState.runId, this.knownChildren.get(childState.childThreadId)?.agentPaths ?? [childState.childThreadId], acceptedCompletion.result));
 		await this.completionDelivery.deliverPending(state, childState);
 	}
-	applyNativeReceipts(state, runIds) {
-		this.completionDelivery.applyReceipts(state, runIds, this.childStates);
-	}
 	resolveChildReceiptOwner(state, childThreadId) {
 		const known = this.knownChildren.get(childThreadId);
 		return known?.parent === state ? known.deliveryReceipts : state.deliveryReceipts;
 	}
+	canPrepareReceiverChild(state, threadId) {
+		const child = this.knownChildren.get(threadId);
+		return canPrepareNativeReceiver(state, child?.parent ?? this.parentStates.get(threadId), child, threadId, {
+			isCurrent: (parent) => this.isCurrentParent(parent),
+			isRetired: (parent) => this.retiredParentStates.has(parent),
+			hasChildCustody: (parent, id) => this.submissions.hasChildCustody(parent, id)
+		});
+	}
 	prepareReceiverChild(state, threadId, nativeParentThreadId) {
+		if (!this.canPrepareReceiverChild(state, threadId)) return false;
 		const known = this.knownChildren.get(threadId);
-		if (known?.parent === state) return true;
-		if (!this.isCurrentParent(state) || known && (!known.assignment.terminal || known.pendingTurns.length > 0 || this.submissions.hasChildCustody(known.parent, threadId))) return false;
-		if (!known) return true;
-		const previous = known.parent;
-		if (nativeParentThreadId !== known.nativeParentThreadId || this.retiredParentStates.has(previous) || !state.requesterSessionKey || previous.requesterSessionKey !== state.requesterSessionKey || !previous.historyOwner || !state.historyOwner || !matchesNativeAssignmentLifecycle(previous.historyOwner, state.historyOwner) || ![...state.owners.values()].some((owner) => owner.completionCustody?.isCurrent())) return false;
-		try {
-			state.assignmentStore?.assertCurrent();
-		} catch {
-			return false;
-		}
+		if (!known || known.parent === state) return true;
+		if (nativeParentThreadId !== known.nativeParentThreadId) return false;
 		known.parent = state;
 		for (const agentPath of known.agentPaths) this.registerAgentPath(state, threadId, agentPath);
 		return true;
@@ -5222,7 +5090,7 @@ var Monitor = class {
 		const agentPath = normalizeOptionalString(options.agentPath);
 		if (agentPath) this.registerAgentPath(state, childThreadId, agentPath);
 		for (const path of this.knownChildren.get(childThreadId)?.agentPaths ?? []) this.registerAgentPath(state, childThreadId, path);
-		this.applyNativeReceipts(state, childState.deliveryReceipts.track(runId, this.knownChildren.get(childThreadId)?.agentPaths ?? [childThreadId]));
+		this.completionDelivery.applyReceipts(state, childState.deliveryReceipts.track(runId, this.knownChildren.get(childThreadId)?.agentPaths ?? [childThreadId]));
 		const restored = this.knownChildren.get(childThreadId);
 		if (restored && !known && options.nativeParentThreadId) restored.nativeParentThreadId = options.nativeParentThreadId;
 		if (observedTurns.length > 0 && restored?.parent === state) {
@@ -5280,7 +5148,7 @@ var Monitor = class {
 				releaseNativeDirectChild(previous);
 				this.turnObservation.markActivityUnknown(previous);
 			}
-			this.applyNativeReceipts(known.parent, known.deliveryReceipts.track(codexNativeSubagentRunId(threadId, turnId), known.agentPaths));
+			this.completionDelivery.applyReceipts(known.parent, known.deliveryReceipts.track(codexNativeSubagentRunId(threadId, turnId), known.agentPaths));
 		}
 		known.turnId = turnId;
 		if (previous && !previous.terminal && known.pendingTurns.length === 0) {
@@ -5291,8 +5159,8 @@ var Monitor = class {
 			this.assignments.record(known.parent, previous);
 			if (previous.modelExecution && !previous.modelExecution.executionOwner.turnId) previous.modelExecution.bindTurn(turnId);
 		}
-		if (observedTurn) this.associatePendingChildInteraction(known, threadId, turnId);
-		this.admitFollowupChild(known, threadId);
+		if (observedTurn) this.associatePendingChildInteraction(known, turnId);
+		this.admitFollowupChild(known);
 		const startedChild = this.currentChild(threadId);
 		if (startedChild && !known.pendingTurns.some((candidate) => candidate.turnId === turnId)) {
 			startedChild.nativeCompletionDelivered = false;
@@ -5300,8 +5168,8 @@ var Monitor = class {
 		}
 		return true;
 	}
-	associatePendingChildInteraction(known, threadId, nativeTurnId) {
-		associateNativeChildInteraction(known, threadId, nativeTurnId, this.admissionCustody.entries, (owner, turnId) => this.drainPendingChildAdmissionEvidence(known.parent, owner, turnId));
+	associatePendingChildInteraction(known, nativeTurnId) {
+		associateNativeChildInteraction(known, nativeTurnId, this.admissionCustody.entries, (owner, turnId) => this.drainPendingChildAdmissionEvidence(known.parent, owner, turnId));
 	}
 	observeParentInteraction(state, owner, threadId, agentPath, interaction = {}) {
 		this.prepareReceiverChild(state, threadId);
@@ -5325,7 +5193,8 @@ var Monitor = class {
 		if (!known && unqualified) admissionOwner.onDirectChildAccepted?.();
 		if (admissionOwner && parentTurnId) this.drainPendingChildAdmissionEvidence(state, admissionOwner, parentTurnId, true);
 	}
-	admitFollowupChild(known, threadId, owner) {
+	admitFollowupChild(known, owner) {
+		const threadId = known.assignment.childThreadId;
 		if (this.parentStates.get(known.parent.parentThreadId) !== known.parent || this.retiredParentStates.has(known.parent)) return;
 		let child = this.currentChild(threadId);
 		if (!child && !known.assignment.terminal) return;
@@ -5355,7 +5224,7 @@ var Monitor = class {
 				}
 				for (const continuation of continuations) continuation.modelSource?.release();
 				transitioned = true;
-				this.applyNativeReceipts(known.parent, known.deliveryReceipts.resumeAssignment(child.runId, continuations.map((turn) => codexNativeSubagentRunId(threadId, turn.turnId))));
+				this.completionDelivery.applyReceipts(known.parent, known.deliveryReceipts.resumeAssignment(child.runId, continuations.map((turn) => codexNativeSubagentRunId(threadId, turn.turnId))));
 				continue;
 			}
 			if (child && !child.terminal && !known.assignment.terminal && child.nativeTurnState !== "completed" && child.nativeTurnState !== "failed") {
@@ -5410,9 +5279,6 @@ var Monitor = class {
 	resolveNativeParentState(threadId) {
 		return this.parentStates.get(threadId) ?? this.knownChildren.get(threadId)?.parent;
 	}
-	registerDirectSpawnChild(state, turnIdInput, evidence, owner) {
-		return this.admissionCustody.registerDirectSpawnChild(turnIdInput, evidence, owner, (options) => this.registerChildThread(state, evidence.childThreadId, options));
-	}
 	drainPendingChildAdmissionEvidence(state, owner, turnId, observeActivity = false) {
 		drainNativeChildModelAdmissions(state, owner, turnId, observeActivity, {
 			admissions: this.admissionCustody.entries,
@@ -5422,7 +5288,7 @@ var Monitor = class {
 			currentChild: (threadId) => this.currentChild(threadId),
 			registerAgentPath: (parent, threadId, path) => this.registerAgentPath(parent, threadId, path),
 			registerChildThread: (parent, threadId, options) => this.registerChildThread(parent, threadId, options),
-			admitFollowupChild: (known, threadId, admittedOwner) => this.admitFollowupChild(known, threadId, admittedOwner),
+			admitFollowupChild: (known, admittedOwner) => this.admitFollowupChild(known, admittedOwner),
 			observeActivity: (child) => this.turnObservation.emitChildTaskActivity({
 				method: "turn/started",
 				params: {
@@ -5439,7 +5305,7 @@ var Monitor = class {
 		this.admissionCustody.retainOnly((evidence) => evidence.childThreadId !== childThreadId || evidence.kind === "interaction");
 	}
 	registerAgentPath(state, childThreadId, agentPath) {
-		this.applyNativeReceipts(state, registerCodexNativeSubagentReceiptAlias({
+		this.completionDelivery.applyReceipts(state, registerCodexNativeSubagentReceiptAlias({
 			state,
 			childThreadId,
 			agentPath,
@@ -5455,7 +5321,7 @@ var Monitor = class {
 		this.recovery.clearRecoveryTimers(childState);
 		this.completionDelivery.release(childState);
 		if (this.childStates.get(childState.runId) === childState) this.childStates.delete(childState.runId);
-		if (![...this.childStates.values()].some((remainingChild) => remainingChild.parentThreadId === childState.parentThreadId)) {
+		if (!this.hasChildrenForParent(childState.parentThreadId)) {
 			const releaseParentThread = this.parentThreadRetentions.get(childState.parentThreadId);
 			this.parentThreadRetentions.delete(childState.parentThreadId);
 			releaseParentThread?.();
@@ -5497,14 +5363,14 @@ var Monitor = class {
 		return [...this.parentStates.values()].filter((state) => state === source || Boolean(source.requesterSessionKey && state.requesterSessionKey === source.requesterSessionKey && state.agentId === source.agentId && source.historyOwner && state.historyOwner && matchesNativeAssignmentLifecycle(source.historyOwner, state.historyOwner)));
 	}
 	hasParentWork(state) {
-		if (state.modelSourceReferences || state.pendingRegistrations && !this.disposed && !this.retiredParentStates.has(state)) return true;
-		if (this.assignments.hasWrites(state) || this.submissions.hasCustody(state)) return true;
-		if (state.owners.size > 0) return true;
-		if (this.childCloses.hasPending(state)) return true;
-		for (const childState of this.childStates.values()) if (childState.parentThreadId === state.parentThreadId) return true;
+		if (state.modelSourceReferences || state.pendingRegistrations && !this.disposed && !this.retiredParentStates.has(state) || this.assignments.hasWrites(state) || this.submissions.hasCustody(state) || state.owners.size > 0 || this.childCloses.hasPending(state) || this.hasChildrenForParent(state.parentThreadId)) return true;
 		for (const known of this.knownChildren.values()) if (known.parent === state && this.currentChild(known.assignment.childThreadId)) return true;
 		return false;
 	}
+	hasChildrenForParent(parentThreadId) {
+		for (const childState of this.childStates.values()) if (childState.parentThreadId === parentThreadId) return true;
+		return false;
+	}
 	pruneParentIfUnused(source) {
 		if (this.parentStates.get(source.parentThreadId) !== source) return;
 		const states = this.requesterParents(source);
@@ -5559,4 +5425,4 @@ var Monitor = class {
 };
 const codexNativeSubagentMonitorRuntime = createCodexNativeSubagentMonitorRuntime(Monitor);
 //#endregion
-export { CodexToolTranscriptProjection as a, shouldEmitTranscriptToolProgress as c, resolveCodexToolProgressDetailMode as d, sanitizeCodexAgentEventRecord as f, emitCodexAgentEvent as i, projectCodexWebSearchItem as l, native_subagent_monitor_exports as n, resolveCodexLocalRuntimeAttribution as o, sanitizeCodexToolArguments as p, CodexEventProjection as r, CodexToolProgressProjection as s, codexNativeSubagentMonitorRuntime as t, isCodexCommandBearingToolCall as u };
+export { CodexToolTranscriptProjection as a, isCodexCommandBearingToolCall as c, sanitizeCodexToolArguments as d, emitCodexAgentEvent as i, resolveCodexToolProgressDetailMode as l, native_subagent_monitor_exports as n, CodexToolProgressProjection as o, CodexEventProjection as r, shouldEmitTranscriptToolProgress as s, codexNativeSubagentMonitorRuntime as t, sanitizeCodexAgentEventRecord as u };