@openclaw/codex 2026.10.7 → 2026.10.8

package/dist/.setup/{native-subagent-monitor-CJaIve3h.mjs → native-subagent-monitor-CuNglHrq.mjs}

@@ -1,17 +1,17 @@
-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 { d as readCodexNativeSubagentRunId, f as readNativeSubagentThreadIds, h as assertHistoryOwnerMatchesRegistration, l as codexNativeSubagentRunId, m as readThreadSpawnSource, p as readThreadParentThreadId, t as matchesNativeAssignmentLifecycle, u as normalizeIdentifier } from "./native-subagent-pending-assignments-BAOzwy85.mjs";
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as defineCodexBuildState } from "./build-state-B5mKL-in.mjs";
+import { n as defineCodexBuildState } from "./build-state-vxQdf_74.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 { J as retainCodexAppServerLiveThread, P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, U as isCodexAppServerLiveThreadProtected } from "./shared-client-AdQX0Tdq.mjs";
-import { M as readCodexAppServerWarningMessage } from "./client-BM97zH3z.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-DnfbVPvu.mjs";
-import { s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-jWVRH043.mjs";
+import { J as retainCodexAppServerLiveThread, P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, U as isCodexAppServerLiveThreadProtected } from "./shared-client-Bo9MCCKj.mjs";
+import { M as readCodexAppServerWarningMessage } from "./client-BTWv2cJe.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-Ba0-h2NE.mjs";
+import { s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-BmPBqnW3.mjs";
 import { t as projectCodexWebSearchItem } from "./web-search-item-CvokaZOo.mjs";
-import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-x7UI_uqk.mjs";
+import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-DIE4DZ9S.mjs";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-CZz2DJ4q.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DijNZb31.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-CAHe3enw.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";
@@ -563,6 +563,7 @@ var CodexNativeSubagentAssignmentInventory = class {
 		this.dependencies = dependencies;
 		this.writes = /* @__PURE__ */ new Map();
 		this.snapshots = /* @__PURE__ */ new WeakMap();
+		this.acknowledged = /* @__PURE__ */ new WeakSet();
 	}
 	hasWrites(state) {
 		return this.writes.has(state);
@@ -600,7 +601,7 @@ var CodexNativeSubagentAssignmentInventory = class {
 	}
 	record(state, child) {
 		const assignment = this.fact(child);
-		if (!assignment || !state.assignmentStore || child.nativeCompletionDelivered || child.subscriptionClosed) return;
+		if (!assignment || !state.assignmentStore || child.nativeCompletionDelivered || child.completionDeliveryAbandoned || child.subscriptionClosed) return;
 		const snapshot = JSON.stringify(assignment);
 		if (this.snapshots.get(child) === snapshot) return;
 		this.snapshots.set(child, snapshot);
@@ -615,11 +616,46 @@ var CodexNativeSubagentAssignmentInventory = class {
 	}
 	settle(state, child) {
 		const assignment = this.fact(child);
-		if (!assignment || !state.assignmentStore || !child.nativeCompletionDelivered && (!child.subscriptionClosed || child.pendingCompletion)) return;
+		if (!assignment || !state.assignmentStore || this.acknowledged.has(child) || !child.nativeCompletionDelivered && (!child.subscriptionClosed || child.pendingCompletion)) return;
 		this.enqueue(state, async () => {
 			await state.assignmentStore?.consume(assignment, () => this.dependencies.assertCurrent(state));
 		});
 	}
+	abandon(state, child, assertCurrent) {
+		return this.enqueue(state, async () => {
+			const assignment = this.fact(child);
+			if (!assignment || !state.assignmentStore || !child.pendingCompletion) return;
+			if (!await state.assignmentStore.consume(assignment, () => {
+				this.dependencies.assertCurrent(state);
+				assertCurrent();
+			}, { status: child.pendingCompletion.status })) throw new Error("Undeliverable native assignment was not retired.");
+		});
+	}
+	async settleNestedCompletion(state, child, assertCurrent) {
+		const owner = child.historyOwner;
+		if (!owner || owner.parentThreadId === child.nativeParentThreadId || !await this.dependencies.isNativeChildThread(child.nativeParentThreadId)) return false;
+		await this.acknowledge(state, child, () => {
+			assertCurrent();
+			assertHistoryOwnerMatchesRegistration(owner, state.historyOwner, owner.parentThreadId, true);
+		});
+		child.nativeCompletionDelivered = true;
+		child.pendingCompletion = void 0;
+		return true;
+	}
+	acknowledge(state, child, assertCurrent) {
+		return this.enqueue(state, async () => {
+			const assertAdmission = () => {
+				this.dependencies.assertCurrent(state);
+				assertCurrent();
+			};
+			assertAdmission();
+			const assignment = this.fact(child);
+			if (!assignment || !state.assignmentStore || this.acknowledged.has(child)) return;
+			if (!await state.assignmentStore.consume(assignment, assertAdmission)) throw new Error("Native assignment was not acknowledged.");
+			this.acknowledged.add(child);
+			assertAdmission();
+		});
+	}
 	async restore(state, owner) {
 		const store = state.assignmentStore;
 		const current = state.historyOwner;
@@ -631,11 +667,15 @@ var CodexNativeSubagentAssignmentInventory = class {
 			for (const assignment of store.read()) {
 				if (!matchesNativeAssignmentLifecycle(assignment.owner, current)) continue;
 				const recovery = await this.dependencies.readHistory(assignment);
+				const pending = store.read();
 				if (!this.dependencies.isCurrent(state) || !custody.isCurrent()) return;
 				store.assertCurrent();
 				if (!recovery || recovery.parentThreadId !== assignment.nativeParentThreadId) continue;
-				await this.dependencies.restore(state, assignment, recovery, custody);
-				await this.drain(state);
+				const surviving = pending.find((entry) => entry.childThreadId === assignment.childThreadId && entry.nativeParentThreadId === assignment.nativeParentThreadId && matchesNativeAssignmentLifecycle(entry.owner, assignment.owner) && (entry.nativeTurnId === assignment.nativeTurnId && (entry.nativeTurnId !== void 0 || entry.runId === assignment.runId) || recovery.nativeTurnId !== void 0 && entry.nativeTurnId === recovery.nativeTurnId && (assignment.nativeTurnId === void 0 || entry.runId === assignment.runId)));
+				if (surviving) {
+					await this.dependencies.restore(state, surviving, recovery, custody);
+					await this.drain(state);
+				}
 			}
 		} catch (error) {
 			embeddedAgentLog.warn("Native pending assignments remain for reconciliation", { error: formatErrorMessage$1(error) });
@@ -997,7 +1037,18 @@ var CodexNativeSubagentCompletionDelivery = class {
 		childState.deliveringCompletion = true;
 		let deferredToForeground = false;
 		try {
+			if (await this.dependencies.settleNestedCompletion(state, childState, () => {
+				if (!this.isCurrent(state, childState) || childState.completionCustody && !childState.completionCustody.isCurrent()) throw new Error("Native completion acknowledgement is no longer current.");
+			})) {
+				this.dependencies.unregisterChild(childState);
+				return;
+			}
+			if (!this.isCurrent(state, childState)) return;
 			if (!this.prepareDelivery(state, childState)) return;
+			if (childState.completionDeliveryAbandoned) {
+				await this.abandon(state, childState);
+				return;
+			}
 			if (state.owners.size > 0 || !state.completionScope) {
 				deferredToForeground = state.owners.size > 0;
 				return;
@@ -1027,13 +1078,17 @@ var CodexNativeSubagentCompletionDelivery = class {
 				this.prepareDelivery(state, childState);
 				return;
 			}
-			if (!this.claim(state, childState) || delivery.recoveryBlocked) {
+			if (!this.claim(state, childState)) {
 				this.dependencies.unregisterChild(childState);
 				return;
 			}
+			if (delivery.recoveryBlocked) {
+				await this.abandon(state, childState);
+				return;
+			}
 			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);
+			await this.scheduleRetry(state, childState, error, !recoveryPending);
 		} catch (error) {
 			if (!this.isCurrent(state, childState)) return;
 			if (!this.claim(state, childState)) {
@@ -1041,7 +1096,7 @@ var CodexNativeSubagentCompletionDelivery = class {
 				return;
 			}
 			const message = formatErrorMessage$1(error);
-			this.scheduleRetry(childState, message);
+			await this.scheduleRetry(state, childState, message, !childState.completionDeliveryAbandoned);
 			embeddedAgentLog.warn("Failed to deliver Codex native subagent completion", {
 				parentThreadId: state.parentThreadId,
 				childThreadId: completion.childThreadId,
@@ -1102,22 +1157,41 @@ var CodexNativeSubagentCompletionDelivery = class {
 		this.dependencies.releaseClientRetentionIfIdle();
 		return true;
 	}
-	scheduleRetry(childState, error, chargeAttempt = true) {
+	async abandon(state, child) {
+		child.completionDeliveryAbandoned = true;
+		try {
+			await this.dependencies.abandon(state, child, () => {
+				if (child.nativeCompletionDelivered || !this.isCurrent(state, child) || !this.claim(state, child)) throw new Error("Native completion retirement is no longer current.");
+			});
+			this.dependencies.unregisterChild(child);
+		} catch (error) {
+			if (this.isCurrent(state, child) && child.nativeCompletionDelivered) {
+				this.prepareDelivery(state, child);
+				return;
+			}
+			embeddedAgentLog.warn("Native completion retirement remains pending", {
+				childThreadId: child.childThreadId,
+				error: formatErrorMessage$1(error)
+			});
+			await this.scheduleRetry(state, child, formatErrorMessage$1(error), false);
+		}
+	}
+	async scheduleRetry(state, childState, error, chargeAttempt = true) {
 		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,
 				error
 			});
-			this.dependencies.unregisterChild(childState);
+			await this.abandon(state, childState);
 			return;
 		}
 		const delayMs = delayForAttempt(this.retryDelaysMs, chargeAttempt ? childState.completionDeliveryAttempt++ : childState.completionDeliveryAttempt);
 		childState.completionDeliveryTimer = setTimeout(() => {
 			childState.completionDeliveryTimer = void 0;
 			if (this.dependencies.children.get(childState.runId) !== childState) return;
-			const state = this.dependencies.parents.get(childState.parentThreadId);
-			if (state) this.deliverPending(state, childState);
+			const currentParent = this.dependencies.parents.get(childState.parentThreadId);
+			if (currentParent) this.deliverPending(currentParent, childState);
 		}, delayMs);
 		childState.completionDeliveryTimer.unref();
 	}
@@ -1125,7 +1199,7 @@ var CodexNativeSubagentCompletionDelivery = class {
 		if (childState.completionCustody && !childState.completionCustody.isCurrent()) return false;
 		const requesterSessionKey = state.requesterSessionKey?.trim();
 		if (!requesterSessionKey) return true;
-		const key = `${requesterSessionKey}\0${childState.runId}`;
+		const key = childState.deliveryOwnerKey ?? `${requesterSessionKey}\0${childState.nativeTurnId ? codexNativeSubagentRunId(childState.childThreadId, childState.nativeTurnId) : childState.runId}`;
 		try {
 			state.assignmentStore?.assertCurrent();
 			assertHistoryOwnerMatchesRegistration(childState.historyOwner, state.historyOwner, childState.nativeParentThreadId, state.historyOwner !== void 0);
@@ -1372,6 +1446,11 @@ var CodexNativeSubagentHistoryRecovery = class {
 			includeTurns
 		}, { timeoutMs: THREAD_READ_TIMEOUT_MS });
 	}
+	async isNativeChildThread(threadId) {
+		if (this.knownChildren.has(threadId)) return true;
+		const response = await this.requestThreadRead(threadId, false);
+		return response.thread.id === threadId && Boolean(readThreadParentThreadId(response.thread));
+	}
 	async read(assignment, options) {
 		const { childThreadId } = assignment;
 		const { recordedCompletion } = options;
@@ -1917,6 +1996,38 @@ function createCodexNativeSubagentMonitorRuntime(Monitor) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/native-subagent-monitor-state.ts
+/** Parent registrations that share the source requester's session lifecycle. */
+function selectRequesterParentStates(states, source) {
+	return [...states].filter((state) => state === source || Boolean(source.requesterSessionKey && state.requesterSessionKey === source.requesterSessionKey && state.agentId === source.agentId && source.historyOwner && state.historyOwner && matchesNativeAssignmentLifecycle(source.historyOwner, state.historyOwner)));
+}
+/**
+* Rebuilds a restored child's pending and observed native turns. Pending turns that still hold
+* a model source keep their completion custody; every other superseded pending turn releases it.
+*/
+function restoreKnownChildTurns(assignment, observedTurns, previous) {
+	const currentIndex = observedTurns.findIndex((turn) => turn.turnId === assignment.nativeTurnId);
+	const pendingTurns = observedTurns.filter((turn, index) => index > currentIndex && turn.turnId !== assignment.nativeTurnId).map((turn, index, turns) => ({
+		turnId: turn.turnId,
+		state: turn.state === "active" && index < turns.length - 1 ? void 0 : turn.state
+	}));
+	const retainedPending = previous?.pendingTurns.filter((pending) => pending.modelSource) ?? [];
+	for (const retained of retainedPending) {
+		const recovered = pendingTurns.find((pending) => pending.turnId === retained.turnId);
+		if (recovered) {
+			recovered.modelSource = retained.modelSource;
+			recovered.completionCustody = retained.completionCustody;
+			retained.completionCustody = void 0;
+		} else pendingTurns.push(retained);
+	}
+	for (const pending of previous?.pendingTurns ?? []) if (!pendingTurns.includes(pending)) releaseCompletionCustody(pending);
+	const turnIds = new Set([assignment.nativeTurnId, ...observedTurns.map((turn) => turn.turnId)].filter((id) => Boolean(id)));
+	return {
+		pendingTurns,
+		observedTurns: new Map([...turnIds].map((turnId) => [turnId, pendingTurns.some((turn) => turn.turnId === turnId) ? { awaitingInteraction: true } : {}]))
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-subagent-notification-routing.ts
 function createCodexNativeSubagentNotificationRouter(deps) {
 	return (notification) => {
@@ -2608,6 +2719,7 @@ var CodexNativeSubagentSubmissionOwner = class {
 		if (!this.isObserving(state, custody) || !this.admitTurn(state, custody, turn, historyValidated)) return;
 		custody.phase = "promoting";
 		clearTimeout(custody.timer);
+		custody.release();
 	}
 	settleChild(state, child) {
 		for (const custody of this.pending.get(state)?.values() ?? []) {
@@ -4428,6 +4540,8 @@ var Monitor = class {
 			parents: this.parentStates,
 			retiredParents: this.retiredParentStates,
 			unregisterChild: (child) => this.unregisterChild(child),
+			abandon: (state, child, assertCurrent) => this.assignments.abandon(state, child, assertCurrent),
+			settleNestedCompletion: (state, child, assertCurrent) => this.assignments.settleNestedCompletion(state, child, assertCurrent),
 			releaseClientRetentionIfIdle: () => this.releaseClientRetentionIfIdle()
 		});
 		this.turnObservation = new CodexNativeSubagentTurnObservation({
@@ -4521,6 +4635,7 @@ var Monitor = class {
 				state.assignmentStore?.assertCurrent();
 			},
 			isCurrent: (state) => this.isCurrentParent(state),
+			isNativeChildThread: (threadId) => this.historyRecovery.isNativeChildThread(threadId),
 			readHistory: async (assignment) => {
 				const revision = this.recovery.retainThreadStatusRevision(assignment.childThreadId);
 				try {
@@ -4539,7 +4654,7 @@ var Monitor = class {
 				}
 			},
 			restore: async (state, assignment, recovery, custody) => {
-				const existing = this.childStates.get(assignment.runId);
+				const existing = this.childStates.get(assignment.runId) ?? [...this.childStates.values()].find((child) => assignment.nativeTurnId !== void 0 && child.childThreadId === assignment.childThreadId && child.nativeTurnId === assignment.nativeTurnId && child.nativeParentThreadId === assignment.nativeParentThreadId && child.historyOwner !== void 0 && matchesNativeAssignmentLifecycle(child.historyOwner, assignment.owner));
 				if (existing) {
 					const original = this.parentStates.get(existing.parentThreadId);
 					if (original && original.requesterSessionKey === state.requesterSessionKey && original.historyOwner && state.historyOwner && matchesNativeAssignmentLifecycle(original.historyOwner, state.historyOwner)) original.assignmentStore = state.assignmentStore;
@@ -4684,6 +4799,9 @@ var Monitor = class {
 		});
 		if (!capture) return;
 		try {
+			const known = this.knownChildren.get(request.threadId);
+			const child = known ? this.admitFollowupChild(known) : void 0;
+			if (child?.nativeTurnId === request.turnId && child.settledWithoutCompletion) this.resumeChild(child);
 			await this.persistModelAssignment(request, capture);
 			request.signal?.throwIfAborted();
 			capture.assertCurrent();
@@ -4745,7 +4863,7 @@ var Monitor = class {
 	}
 	retireParent(parentThreadIdInput) {
 		const current = this.parentStates.get(parentThreadIdInput.trim());
-		const states = current ? this.requesterParents(current) : [];
+		const states = current ? selectRequesterParentStates(this.parentStates.values(), current) : [];
 		for (const state of states) this.retiredParentStates.add(state);
 		const settlements = [];
 		for (const state of states) {
@@ -4858,6 +4976,7 @@ var Monitor = class {
 		childState.settledWithoutCompletion = false;
 		childState.fallbackCompletion = void 0;
 		this.releaseClientRetention ??= this.retainClient?.();
+		this.retainParentThreadForChild(childState.parentThreadId);
 	}
 	settleResumableChild(childState) {
 		if (childState.terminal) return;
@@ -4868,6 +4987,7 @@ var Monitor = class {
 		releaseNativeDirectChild(childState);
 		releaseNativeModelExecution(childState);
 		this.recovery.clearRecoveryTimers(childState);
+		this.releaseParentThreadIfChildrenSettled(childState.parentThreadId);
 		this.releaseClientRetentionIfIdle();
 	}
 	async handleChildTurnCompletion(notification, childState) {
@@ -5040,6 +5160,7 @@ var Monitor = class {
 		this.recovery.markTerminalRevision(childState.childThreadId);
 		releaseNativeDirectChild(childState);
 		this.recovery.clearRecoveryTimers(childState);
+		this.releaseParentThreadIfChildrenSettled(state.parentThreadId);
 		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);
 	}
@@ -5094,10 +5215,7 @@ var Monitor = class {
 		if (!childState) {
 			this.updateChildThreadOwnership("claim", childThreadId, this.claimChildThread);
 			this.releaseClientRetention ??= this.retainClient?.();
-			if (!this.parentThreadRetentions.has(parentThreadId)) {
-				const releaseParentThread = this.retainParentThread?.(parentThreadId);
-				if (releaseParentThread) this.parentThreadRetentions.set(parentThreadId, releaseParentThread);
-			}
+			this.retainParentThreadForChild(parentThreadId);
 			childState = {
 				runId,
 				nativeTurnId: assignment.nativeTurnId,
@@ -5317,6 +5435,7 @@ var Monitor = class {
 			}
 			if (!transitioned) claimOwner.onDirectChildAccepted?.();
 		}
+		this.observeActiveChild(child);
 		this.admissionCustody.bindEventSink(child);
 		return child;
 	}
@@ -5368,11 +5487,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.hasChildrenForParent(childState.parentThreadId)) {
-			const releaseParentThread = this.parentThreadRetentions.get(childState.parentThreadId);
-			this.parentThreadRetentions.delete(childState.parentThreadId);
-			releaseParentThread?.();
-		}
+		this.releaseParentThreadIfChildrenSettled(childState.parentThreadId);
 		this.recovery.collectThreadStatusRevision(childState.childThreadId);
 		this.releaseClientRetentionIfIdle();
 		const state = this.parentStates.get(childState.parentThreadId);
@@ -5406,21 +5521,28 @@ var Monitor = class {
 		this.releaseClientRetention = void 0;
 		release?.();
 	}
-	requesterParents(source) {
-		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) || 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;
 	}
+	retainParentThreadForChild(parentThreadId) {
+		if (this.parentThreadRetentions.has(parentThreadId)) return;
+		const releaseParentThread = this.retainParentThread?.(parentThreadId);
+		if (releaseParentThread) this.parentThreadRetentions.set(parentThreadId, releaseParentThread);
+	}
+	releaseParentThreadIfChildrenSettled(parentThreadId) {
+		for (const childState of this.childStates.values()) if (childState.parentThreadId === parentThreadId && !childState.terminal && !childState.settledWithoutCompletion) return;
+		const releaseParentThread = this.parentThreadRetentions.get(parentThreadId);
+		this.parentThreadRetentions.delete(parentThreadId);
+		releaseParentThread?.();
+	}
 	hasChildrenForParent(parentThreadId) {
-		for (const childState of this.childStates.values()) if (childState.parentThreadId === parentThreadId) return true;
-		return false;
+		return [...this.childStates.values()].some((child) => child.parentThreadId === parentThreadId);
 	}
 	pruneParentIfUnused(source) {
 		if (this.parentStates.get(source.parentThreadId) !== source) return;
-		const states = this.requesterParents(source);
+		const states = selectRequesterParentStates(this.parentStates.values(), source);
 		if (states.some((state) => this.hasParentWork(state))) return;
 		for (const state of states) {
 			this.submissions.retire(state);
@@ -5436,23 +5558,9 @@ var Monitor = class {
 		}
 	}
 	restoreKnownChild(state, assignment, observedTurns = []) {
-		const currentIndex = observedTurns.findIndex((turn) => turn.turnId === assignment.nativeTurnId);
-		const pendingTurns = observedTurns.filter((turn, index) => index > currentIndex && turn.turnId !== assignment.nativeTurnId).map((turn, index, turns) => ({
-			turnId: turn.turnId,
-			state: turn.state === "active" && index < turns.length - 1 ? void 0 : turn.state
-		}));
 		const previous = this.knownChildren.get(assignment.childThreadId);
 		const previousRunId = previous?.assignment.runId;
-		const retainedPending = previous?.pendingTurns.filter((pending) => pending.modelSource) ?? [];
-		for (const retained of retainedPending) {
-			const recovered = pendingTurns.find((pending) => pending.turnId === retained.turnId);
-			if (recovered) {
-				recovered.modelSource = retained.modelSource;
-				recovered.completionCustody = retained.completionCustody;
-				retained.completionCustody = void 0;
-			} else pendingTurns.push(retained);
-		}
-		for (const pending of previous?.pendingTurns ?? []) if (!pendingTurns.includes(pending)) releaseCompletionCustody(pending);
+		const { pendingTurns, observedTurns: observedTurnStates } = restoreKnownChildTurns(assignment, observedTurns, previous);
 		this.knownChildren.set(assignment.childThreadId, {
 			configurationQualification: previous?.configurationQualification,
 			parent: state,
@@ -5463,7 +5571,7 @@ var Monitor = class {
 				terminal: false
 			},
 			turnId: pendingTurns.at(-1)?.turnId ?? assignment.nativeTurnId,
-			observedTurns: new Map([...new Set([assignment.nativeTurnId, ...observedTurns.map((turn) => turn.turnId)].filter((id) => Boolean(id)))].map((turnId) => [turnId, pendingTurns.some((turn) => turn.turnId === turnId) ? { awaitingInteraction: true } : {}])),
+			observedTurns: observedTurnStates,
 			pendingTurns,
 			agentPaths: this.knownChildren.get(assignment.childThreadId)?.agentPaths ?? /* @__PURE__ */ new Set([assignment.childThreadId])
 		});

package/dist/.setup/{native-subagent-pending-assignments-DmVhedNs.mjs → native-subagent-pending-assignments-BAOzwy85.mjs}

@@ -151,7 +151,7 @@ const assignmentSchema = z.object({
 const inventorySchema = z.object({
 	version: z.literal(1),
 	assignments: z.array(assignmentSchema)
-}).strict().refine(({ assignments }) => new Set(assignments.map((entry) => entry.runId)).size === assignments.length);
+}).strict();
 /** Native parent rotation is not physical requester or connection adoption. */
 function matchesNativeAssignmentLifecycle(saved, current) {
 	return saved.sessionId === current.sessionId && saved.lifecycleRevision === current.lifecycleRevision && saved.connectionFingerprint === current.connectionFingerprint;
@@ -159,29 +159,67 @@ function matchesNativeAssignmentLifecycle(saved, current) {
 function readNativePendingAssignments(value) {
 	if (value === void 0) return;
 	const parsed = inventorySchema.safeParse(value);
-	if (!parsed.success) throw new Error("Invalid Codex native pending assignment metadata.");
+	if (!parsed.success || new Set(parsed.data.assignments.map((entry) => entry.runId)).size !== parsed.data.assignments.length) throw new Error("Invalid Codex native pending assignment metadata.");
 	return parsed.data;
 }
+function mergeNativeAssignmentMetadata(current, incoming) {
+	const genericRunId = codexNativeSubagentRunId(current.childThreadId);
+	if (current.runId !== incoming.runId && current.runId !== genericRunId && incoming.runId !== genericRunId || current.submission && incoming.submission && !isDeepStrictEqual(current.submission, incoming.submission) || current.recordedCompletion && incoming.recordedCompletion && !isDeepStrictEqual(current.recordedCompletion, incoming.recordedCompletion)) throw new Error("Conflicting Codex native pending assignment metadata.");
+	if (current.runId === genericRunId) current.runId = incoming.runId;
+	if (incoming.submission) current.submission = incoming.submission;
+	if (incoming.recordedCompletion) current.recordedCompletion = incoming.recordedCompletion;
+}
+/** Doctor and binding writes merge compatible facts for one obligation, never distinct turns. */
+function normalizeNativePendingAssignments(value) {
+	if (value === void 0) return;
+	return {
+		version: 1,
+		assignments: mergeNativePendingAssignments(inventorySchema.parse(value).assignments)
+	};
+}
+function mergeNativePendingAssignments(entries) {
+	const assignments = [];
+	for (const entry of entries) {
+		const existing = assignments.find((saved) => saved.childThreadId === entry.childThreadId && saved.nativeTurnId === entry.nativeTurnId && (entry.nativeTurnId !== void 0 || saved.runId === entry.runId));
+		if (!existing) {
+			assignments.push(entry);
+			continue;
+		}
+		if (existing.nativeParentThreadId !== entry.nativeParentThreadId || !isDeepStrictEqual(existing.owner, entry.owner)) throw new Error("Conflicting Codex native pending assignment metadata.");
+		mergeNativeAssignmentMetadata(existing, entry);
+	}
+	if (new Set(assignments.map((entry) => entry.runId)).size !== assignments.length) throw new Error("Conflicting Codex native pending assignment metadata.");
+	return assignments;
+}
 function mutateNativePendingAssignments(params) {
-	const current = readNativePendingAssignments(params.current);
-	const assignment = assignmentSchema.parse(params.assignment);
+	const current = normalizeNativePendingAssignments(params.current);
+	let assignment = assignmentSchema.parse(params.assignment);
 	const owner = codexNativeSubagentHistoryOwnerSchema.parse(params.owner);
 	if (!matchesNativeAssignmentLifecycle(assignment.owner, owner)) return { applied: false };
 	const assignments = current?.assignments ?? [];
-	const existing = assignments.find((entry) => entry.runId === assignment.runId);
-	if (existing && (!isDeepStrictEqual(existing.owner, assignment.owner) || existing.nativeParentThreadId !== assignment.nativeParentThreadId || existing.childThreadId !== assignment.childThreadId) || params.consume && (!existing || existing.nativeTurnId !== assignment.nativeTurnId)) return { applied: false };
+	const existing = assignments.find((entry) => entry.runId === assignment.runId) ?? assignments.find((entry) => assignment.nativeTurnId !== void 0 && entry.childThreadId === assignment.childThreadId && entry.nativeTurnId === assignment.nativeTurnId);
+	if (params.consume && !existing) return {
+		applied: false,
+		absent: true
+	};
+	if (existing && (!isDeepStrictEqual(existing.owner, assignment.owner) || existing.nativeParentThreadId !== assignment.nativeParentThreadId || existing.childThreadId !== assignment.childThreadId) || params.consume && existing?.nativeTurnId !== assignment.nativeTurnId) return { applied: false };
 	const remaining = assignments.filter((entry) => entry !== existing);
 	if (!params.consume) {
-		if (existing?.recordedCompletion && !assignment.recordedCompletion) assignment.recordedCompletion = existing.recordedCompletion;
+		if (existing && existing.nativeTurnId === assignment.nativeTurnId) {
+			mergeNativeAssignmentMetadata(existing, assignment);
+			assignment = existing;
+		} else if (existing?.recordedCompletion && !assignment.recordedCompletion) assignment.recordedCompletion = existing.recordedCompletion;
 		remaining.push(assignment);
 	}
+	const next = !params.consume && existing && existing.nativeTurnId !== assignment.nativeTurnId ? mergeNativePendingAssignments(remaining) : remaining;
 	return {
 		applied: true,
-		next: remaining.length ? {
+		next: next.length ? {
 			version: 1,
-			assignments: remaining
-		} : void 0
+			assignments: next
+		} : void 0,
+		consumed: params.consume ? existing : void 0
 	};
 }
 //#endregion
-export { readCodexNativeSubagentHistoryOwner as _, matchesCodexNativeSubagentSubmissionOwner as a, codexNativeSubagentRunId as c, readNativeSubagentThreadIds as d, readThreadParentThreadId as f, createCodexNativeSubagentHistoryOwner as g, codexNativeSubagentHistoryConnectionFingerprint as h, adoptCodexNativeSubagentSubmissions as i, normalizeIdentifier as l, assertHistoryOwnerMatchesRegistration as m, mutateNativePendingAssignments as n, mutateCodexNativeSubagentSubmissions as o, readThreadSpawnSource as p, readNativePendingAssignments as r, readCodexNativeSubagentSubmissions as s, matchesNativeAssignmentLifecycle as t, readCodexNativeSubagentRunId as u };
+export { createCodexNativeSubagentHistoryOwner as _, adoptCodexNativeSubagentSubmissions as a, readCodexNativeSubagentSubmissions as c, readCodexNativeSubagentRunId as d, readNativeSubagentThreadIds as f, codexNativeSubagentHistoryConnectionFingerprint as g, assertHistoryOwnerMatchesRegistration as h, readNativePendingAssignments as i, codexNativeSubagentRunId as l, readThreadSpawnSource as m, mutateNativePendingAssignments as n, matchesCodexNativeSubagentSubmissionOwner as o, readThreadParentThreadId as p, normalizeNativePendingAssignments as r, mutateCodexNativeSubagentSubmissions as s, matchesNativeAssignmentLifecycle as t, normalizeIdentifier as u, readCodexNativeSubagentHistoryOwner as v };

package/dist/.setup/{native-task-assignments-DYL9uxNe.mjs → native-task-assignments-Dap5NqiR.mjs}

@@ -1,4 +1,4 @@
-import { _ as readCodexNativeSubagentHistoryOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
+import { d as readCodexNativeSubagentRunId, g as codexNativeSubagentHistoryConnectionFingerprint, i as readNativePendingAssignments, v as readCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-BAOzwy85.mjs";
 import { i as CODEX_APP_SERVER_BINDING_NAMESPACE, r as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-Lkm5Lpf4.mjs";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
@@ -56,7 +56,7 @@ async function inspect(params) {
 		if (extractErrorCode(error) === "ENOENT") return [];
 		throw error;
 	}
-	const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-C2kDBZhx.mjs").then((n) => n.h);
+	const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-O62ZRFhy.mjs").then((n) => n.h);
 	const { executeSqliteQuerySync, getNodeSqliteKysely, openNodeSqliteDatabase, prepareSqliteReadOnlyLocation, tableExists } = await import("openclaw/plugin-sdk/sqlite-runtime");
 	const snapshot = await prepareSqliteReadOnlyLocation(source, { preserveSourceArtifacts: true });
 	try {
@@ -126,7 +126,7 @@ function prepareAssignment(task, stored, params, { getSessionEntry, resolveStore
 }
 async function settleHistoricalDelivery(task, key, observedBinding, params, sessionStore) {
 	const { executeSqliteQuerySync, getNodeSqliteKysely, openNodeSqliteDatabase, resolveExistingSqliteFileUri, runSqliteImmediateTransactionSync } = await import("openclaw/plugin-sdk/sqlite-runtime");
-	const { readStoredCodexAppServerBinding } = await import("./session-binding-record-C2kDBZhx.mjs").then((n) => n.h);
+	const { readStoredCodexAppServerBinding } = await import("./session-binding-record-O62ZRFhy.mjs").then((n) => n.h);
 	const db = openNodeSqliteDatabase(resolveExistingSqliteFileUri(databasePath(params)));
 	try {
 		const sql = getNodeSqliteKysely(db);
@@ -170,7 +170,7 @@ const codexNativeTaskAssignmentMigration = {
 			changes: [],
 			warnings
 		};
-		const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-C2kDBZhx.mjs").then((n) => n.h);
+		const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-O62ZRFhy.mjs").then((n) => n.h);
 		const sessionStore = await import("openclaw/plugin-sdk/session-store-runtime");
 		let imported = 0;
 		let settled = 0;

package/dist/.setup/{node-cli-sessions-BxVYZNuY.mjs → node-cli-sessions-BQNAFnCa.mjs}

@@ -1,4 +1,4 @@
-import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-B4OyhylL.mjs";
+import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-DmZmgRou.mjs";
 import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
 import { o as formatCodexDisplayText } from "./command-formatters-xW9KpoSZ.mjs";
 import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
@@ -196,7 +196,7 @@ async function resumeCodexCliSessionOnNode(params) {
 	let catalogAgentId;
 	let catalogHomeId;
 	if (params.sessionKey) {
-		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-D11N0CMr.mjs");
+		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-BjYvYtAd.mjs");
 		const entry = params.runtime.agent.session.getSessionEntry({
 			sessionKey: params.sessionKey,
 			readConsistency: "latest"

package/dist/.setup/{node-exec-server.runtime-8RehgPdQ.mjs → node-exec-server.runtime-B-4ogz9C.mjs}

@@ -1,5 +1,5 @@
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-DwC9wxch.mjs";
-import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-lgeKKHyw.mjs";
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-Boj8_lWV.mjs";
+import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-BsXQmXll.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { stripVTControlCharacters } from "node:util";
 import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";

package/dist/.setup/{plan-GqWF4XGA.mjs → plan-CqI4m0CC.mjs}

@@ -1,7 +1,7 @@
 import { t as isOnlyMigrationKind } from "./scope-DOC1Xjc8.mjs";
-import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-OhiCoyPH.mjs";
-import "./config-LQemoqTL.mjs";
-import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-BszpKEvi.mjs";
+import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-CZLnMaxf.mjs";
+import "./config-d0gOFYEk.mjs";
+import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-C4Al9cJx.mjs";
 import { asBoolean, asOptionalRecord, isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { runCommandBuffered } from "openclaw/plugin-sdk/process-runtime";
@@ -97,8 +97,8 @@ async function readCodexCliCredentialsAsync(options) {
 	options.signal?.throwIfAborted();
 	if (!options.allowKeychainPrompt) return;
 	const home = await fs.realpath(options.codexHome).catch(() => path.resolve(options.codexHome));
-	const { CodexAppServerClient } = await import("./client-BM97zH3z.mjs").then((n) => n.n);
-	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-DwC9wxch.mjs").then((n) => n.n);
+	const { CodexAppServerClient } = await import("./client-BTWv2cJe.mjs").then((n) => n.n);
+	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-Boj8_lWV.mjs").then((n) => n.n);
 	const launcher = resolveManagedCodexPackageEntrypoint(path.dirname(fileURLToPath(import.meta.url)));
 	const command = launcher ? resolveManagedCodexNativeCommand(launcher) : void 0;
 	if (!command) return;

package/dist/.setup/{plugin-activation-BgfNFH2L.mjs → plugin-activation-Dbq2m2gh.mjs}

@@ -1,6 +1,6 @@
 import { r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
-import { i as listCodexPluginMetadata, n as findCodexMarketplacePluginSummary, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, t as createCodexAppInventoryRequest, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-OhiCoyPH.mjs";
-import "./config-LQemoqTL.mjs";
+import { i as listCodexPluginMetadata, n as findCodexMarketplacePluginSummary, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, t as createCodexAppInventoryRequest, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-CZLnMaxf.mjs";
+import "./config-d0gOFYEk.mjs";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/codex/src/app-server/plugin-activation.ts
 /** Activates legacy curated plugins without granting install authority to other marketplaces. */

package/dist/.setup/{plugin-approval-roundtrip-x7UI_uqk.mjs → plugin-approval-roundtrip-DIE4DZ9S.mjs}

@@ -1,4 +1,4 @@
-import { _t as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-AdQX0Tdq.mjs";
+import { _t as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-Bo9MCCKj.mjs";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { isApprovalNotFoundError, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { racePromiseWithAbortSignal } from "openclaw/plugin-sdk/time-runtime";

package/dist/.setup/{plugin-inventory-OhiCoyPH.mjs → plugin-inventory-CZLnMaxf.mjs}

@@ -1,5 +1,5 @@
 import { c as findCodexAppById } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
-import "./config-LQemoqTL.mjs";
+import "./config-d0gOFYEk.mjs";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/config-contracts.ts
 const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";