@openclaw/codex 2026.10.10-beta.2 → 2026.10.10-beta.4

package/dist/.setup/{native-subagent-monitor-C3CIIaZG.mjs → native-subagent-monitor-LJd5_D5F.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-CTinVtjo.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-CX-LtYDX.mjs";
 import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
-import { n as defineCodexBuildState } from "./build-state-CjLCC0wm.mjs";
+import { n as defineCodexBuildState } from "./build-state-CpGXWSN4.mjs";
 import { a as readHookOutputEntries, o as readItem, s as readNullableString } from "./event-projector-values-yf4us9Pf.mjs";
 import { n as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-Ccd9MFRJ.mjs";
 import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-7W0cgTXF.mjs";
-import { A as hasCodexAppServerLiveThread, B as retainCodexAppServerLiveThread, E as claimCodexAppServerLiveThread } from "./shared-client-CkyTrNB8.mjs";
-import { j as readCodexAppServerWarningMessage } from "./client--P8jwXvA.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-BGj67FMK.mjs";
-import { s as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DMJWXGxM.mjs";
+import { A as hasCodexAppServerLiveThread, E as claimCodexAppServerLiveThread, V as retainCodexAppServerLiveThread } from "./shared-client-BelwlhWf.mjs";
+import { j as readCodexAppServerWarningMessage } from "./client-Bxe8bl-K.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-B62dF4CM.mjs";
+import { s as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-Bj4T3tcX.mjs";
 import { t as projectCodexWebSearchItem } from "./web-search-item-DHVuNSqk.mjs";
-import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-CGEiG7hG.mjs";
+import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-DEbTgtVQ.mjs";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-CZz2DJ4q.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-C9uEGpDX.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";
@@ -574,7 +574,7 @@ var CodexNativeSubagentAssignmentInventory = class {
 		this.dependencies = dependencies;
 		this.writes = /* @__PURE__ */ new Map();
 		this.snapshots = /* @__PURE__ */ new WeakMap();
-		this.cancelled = /* @__PURE__ */ new WeakSet();
+		this.acknowledged = /* @__PURE__ */ new WeakSet();
 	}
 	hasWrites(state) {
 		return this.writes.has(state);
@@ -612,7 +612,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);
@@ -627,12 +627,33 @@ 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));
 		});
 	}
-	settleCancelled(state, child, assertCurrent) {
+	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);
@@ -640,9 +661,9 @@ var CodexNativeSubagentAssignmentInventory = class {
 			};
 			assertAdmission();
 			const assignment = this.fact(child);
-			if (!assignment || !state.assignmentStore || this.cancelled.has(child)) return;
-			if (!await state.assignmentStore.consume(assignment, assertAdmission)) throw new Error("Cancelled native assignment was not acknowledged.");
-			this.cancelled.add(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();
 		});
 	}
@@ -652,15 +673,20 @@ var CodexNativeSubagentAssignmentInventory = class {
 		if (!store || !current || !owner.completionCustody?.isCurrent()) return;
 		const custody = owner.completionCustody.retain();
 		try {
+			await this.drain(state);
 			const assignments = await store.read();
 			if (!this.dependencies.isCurrent(state) || !custody.isCurrent()) return;
 			for (const assignment of assignments) {
 				if (!matchesNativeAssignmentLifecycle(assignment.owner, current)) continue;
 				const recovery = await this.dependencies.readHistory(assignment);
-				await store.assertCurrentAsync();
+				const pending = await store.read();
 				if (!this.dependencies.isCurrent(state) || !custody.isCurrent()) return;
 				if (!recovery || recovery.parentThreadId !== assignment.nativeParentThreadId) continue;
-				await this.dependencies.restore(state, assignment, recovery, custody);
+				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) });
@@ -989,7 +1015,18 @@ var CodexNativeSubagentCompletionDelivery = class {
 		let deferredToForeground = false;
 		try {
 			if (childState.cancellationRequested && completion.status === "cancelled") return;
+			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;
@@ -1019,13 +1056,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)) {
@@ -1033,7 +1074,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,
@@ -1093,22 +1134,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();
 	}
@@ -1116,7 +1176,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);
@@ -1357,6 +1417,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;
@@ -2065,7 +2130,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 		dependencies.prune(registeredState);
 		registrationSettled.resolve();
 	}
-	const ready = dependencies.submissions.restore(state, owner).then(() => dependencies.assignments.restore(state, owner));
+	const ready = dependencies.submissions.restore(state, owner).then(() => dependencies.submissions.drain(registeredState)).then(() => dependencies.assignments.restore(state, owner)).then(() => dependencies.assignments.drain(registeredState));
 	let registered = true;
 	let settlement;
 	return {
@@ -2572,6 +2637,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() ?? []) {
@@ -4410,6 +4476,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({
@@ -4502,6 +4570,7 @@ var Monitor = class {
 				state.assignmentStore?.assertCurrent();
 			},
 			isCurrent: (state) => this.isCurrentParent(state),
+			isNativeChildThread: (threadId) => this.historyRecovery.isNativeChildThread(threadId),
 			readHistory: (assignment) => this.historyRecovery.read({
 				...assignment,
 				nativeTurnId: assignment.nativeTurnId
@@ -4512,7 +4581,7 @@ var Monitor = class {
 				initialAssignment: !readCodexNativeSubagentRunId(assignment.runId)?.turnId
 			}),
 			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;
@@ -4640,15 +4709,33 @@ var Monitor = class {
 			cancelledRequesters: []
 		}));
 		const matchesOwner = (owner) => owner.requesterAgentId === params.agentId && owner.requesterSessionKey === params.sessionKey && owner.requesterSessionId === params.sessionId && owner.requesterLifecycleRevision === params.lifecycleRevision && params.acceptsRequest(owner.requestCustody);
-		const preparingOwners = /* @__PURE__ */ new Map();
-		for (const state of this.parentStates.values()) if (state.preparing && !state.agentId && !state.historyOwner) {
-			const owner = [...state.pendingRegistrations ?? []].find(matchesOwner);
-			if (owner) preparingOwners.set(state, owner);
+		const selectedOwners = /* @__PURE__ */ new Map();
+		const stableOwners = /* @__PURE__ */ new Set();
+		for (const state of this.parentStates.values()) {
+			const owner = [...state.owners.values()].find(matchesOwner);
+			if (owner) {
+				selectedOwners.set(state, owner);
+				stableOwners.add(owner);
+				continue;
+			}
+			const pendingOwner = [...state.pendingRegistrations ?? []].find(matchesOwner);
+			if (pendingOwner) selectedOwners.set(state, pendingOwner);
+		}
+		for (const child of this.childStates.values()) {
+			const owner = child.modelExecution?.owner ?? child.directOwner;
+			const state = this.parentStates.get(child.parentThreadId);
+			if (state && owner && matchesOwner(owner) && params.acceptsRequest(child.requestCustody)) {
+				selectedOwners.set(state, owner);
+				stableOwners.add(owner);
+			}
 		}
+		const hasSelectedOwner = (state) => {
+			const owner = selectedOwners.get(state);
+			return Boolean(owner && matchesOwner(owner) && (stableOwners.has(owner) || state.pendingRegistrations?.has(owner) || owner.descendantsCancelled));
+		};
 		const matches = (state) => {
-			if (state.agentId || state.historyOwner) return state.agentId === params.agentId && state.requesterSessionKey === params.sessionKey && state.historyOwner?.sessionId === params.sessionId && state.historyOwner?.lifecycleRevision === params.lifecycleRevision;
-			const owner = preparingOwners.get(state);
-			return Boolean(state.preparing && owner && matchesOwner(owner) && (state.pendingRegistrations?.has(owner) || owner.descendantsCancelled));
+			if (state.agentId || state.historyOwner) return state.agentId === params.agentId && state.requesterSessionKey === params.sessionKey && state.historyOwner?.sessionId === params.sessionId && state.historyOwner?.lifecycleRevision === params.lifecycleRevision || hasSelectedOwner(state);
+			return state.preparing === true && hasSelectedOwner(state);
 		};
 		if (!matches(parent)) throw new Error("Codex descendant cancellation requester generation changed");
 		const states = [...this.parentStates.values()].filter(matches);
@@ -4674,7 +4761,15 @@ var Monitor = class {
 				const deadline = performance.now() + CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS;
 				const registrations = states.flatMap((state) => [...state.pendingRegistrations ?? []].filter(matchesOwner));
 				const registrationResults = Promise.allSettled(registrations.map((owner) => waitForNativeCancellationWork(this.client, owner.registrationSettled ?? Promise.reject(/* @__PURE__ */ new Error("Codex pending registration has no settlement owner")), deadline)));
-				const selected = [...this.childStates.values()].filter((child) => child.historyOwner?.sessionId === params.sessionId && child.historyOwner?.lifecycleRevision === params.lifecycleRevision && states.some((state) => state.parentThreadId === child.parentThreadId) && params.acceptsRequest(child.requestCustody));
+				const selectedOwnerChildren = /* @__PURE__ */ new Set();
+				const matchesGeneration = (child) => {
+					const owner = child.modelExecution?.owner ?? child.directOwner;
+					const matched = child.historyOwner?.sessionId === params.sessionId && child.historyOwner?.lifecycleRevision === params.lifecycleRevision || Boolean(owner && matchesOwner(owner));
+					if (owner && matched && matchesOwner(owner)) selectedOwnerChildren.add(child);
+					return matched;
+				};
+				const matchesChild = (child) => matchesGeneration(child) || selectedOwnerChildren.has(child);
+				const selected = [...this.childStates.values()].filter((child) => matchesGeneration(child) && states.some((state) => state.parentThreadId === child.parentThreadId) && params.acceptsRequest(child.requestCustody));
 				const owners = new Set(states.flatMap((state) => [...state.owners.values(), ...state.pendingRegistrations ?? []]));
 				for (const known of this.knownChildren.values()) if (states.includes(known.parent)) for (const pending of known.pendingTurns) {
 					if (pending.admittedOwner) owners.add(pending.admittedOwner);
@@ -4698,7 +4793,7 @@ var Monitor = class {
 					const requestCustody = child.requestCustody;
 					const assertChild = () => {
 						assertCurrent();
-						if (this.childStates.get(child.runId) !== child || this.currentChild(child.childThreadId) !== child || turnId !== void 0 && child.nativeTurnId !== turnId || child.requesterTurnRunId !== requesterTurnRunId || child.requestCustody !== requestCustody || !params.acceptsRequest(requestCustody) || child.historyOwner?.sessionId !== params.sessionId || child.historyOwner?.lifecycleRevision !== params.lifecycleRevision || child.completionCustody && !child.completionCustody.isCurrent()) throw new Error("Codex descendant assignment changed before cancellation");
+						if (this.childStates.get(child.runId) !== child || this.currentChild(child.childThreadId) !== child || turnId !== void 0 && child.nativeTurnId !== turnId || child.requesterTurnRunId !== requesterTurnRunId || child.requestCustody !== requestCustody || !params.acceptsRequest(requestCustody) || !matchesChild(child) || child.completionCustody && !child.completionCustody.isCurrent()) throw new Error("Codex descendant assignment changed before cancellation");
 					};
 					assertChild();
 					if (!child.terminal) {
@@ -4738,7 +4833,7 @@ var Monitor = class {
 						assertChild();
 						await this.submissions.settleCancelled(state, child, assertChild);
 						assertChild();
-						await this.assignments.settleCancelled(state, child, assertChild);
+						await this.assignments.acknowledge(state, child, assertChild);
 						assertChild();
 						this.unregisterChild(child);
 					}
@@ -4748,7 +4843,7 @@ var Monitor = class {
 						await this.submissions.drain(state);
 						assertCurrent();
 					}
-					if (child.requesterTurnRunId !== requesterTurnRunId || child.requestCustody !== requestCustody || child.historyOwner?.sessionId !== params.sessionId || child.historyOwner?.lifecycleRevision !== params.lifecycleRevision) throw new Error("Codex descendant requester changed during settlement");
+					if (child.requesterTurnRunId !== requesterTurnRunId || child.requestCustody !== requestCustody || !matchesChild(child)) throw new Error("Codex descendant requester changed during settlement");
 					return {
 						killed: cancelled ? 1 : 0,
 						cancelledRequesters: cancelled && requesterTurnRunId ? [{
@@ -4822,6 +4917,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();
@@ -4999,6 +5097,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;
@@ -5009,6 +5108,7 @@ var Monitor = class {
 		releaseNativeDirectChild(childState);
 		releaseNativeModelExecution(childState);
 		this.recovery.clearRecoveryTimers(childState);
+		this.releaseParentThreadIfChildrenSettled(childState.parentThreadId);
 		this.releaseClientRetentionIfIdle();
 	}
 	handleChildTurnCompletion(notification, childState) {
@@ -5196,6 +5296,7 @@ var Monitor = class {
 		this.recovery.markTerminalThread(childState.childThreadId, state.parentThreadId);
 		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);
 	}
@@ -5261,10 +5362,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,
 				requestCustody: options.directOwner?.requestCustody,
@@ -5499,6 +5597,7 @@ var Monitor = class {
 			}
 			if (!transitioned) claimOwner.onDirectChildAccepted?.();
 		}
+		this.observeActiveChild(child);
 		this.admissionCustody.bindEventSink(child);
 		return child;
 	}
@@ -5550,11 +5649,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.releaseClientRetentionIfIdle();
 		const state = this.parentStates.get(childState.parentThreadId);
 		if (state) {
@@ -5612,6 +5707,17 @@ var Monitor = class {
 		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;

package/dist/.setup/{native-subagent-pending-assignments-CTinVtjo.mjs → native-subagent-pending-assignments-CX-LtYDX.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-YJopbaVO.mjs → native-task-assignments-CMd-JiUS.mjs}

@@ -1,4 +1,4 @@
-import { _ as readCodexNativeSubagentHistoryOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-CTinVtjo.mjs";
+import { d as readCodexNativeSubagentRunId, g as codexNativeSubagentHistoryConnectionFingerprint, i as readNativePendingAssignments, v as readCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-CX-LtYDX.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-C_THntMe.mjs").then((n) => n._);
+	const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-BpWF2Sus.mjs").then((n) => n._);
 	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-C_THntMe.mjs").then((n) => n._);
+	const { readStoredCodexAppServerBinding } = await import("./session-binding-record-BpWF2Sus.mjs").then((n) => n._);
 	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-C_THntMe.mjs").then((n) => n._);
+		const { bindingStoreKey, readStoredCodexAppServerBinding } = await import("./session-binding-record-BpWF2Sus.mjs").then((n) => n._);
 		const { getSessionEntry, resolveStorePath } = await import("openclaw/plugin-sdk/session-store-runtime");
 		const sessionStore = {
 			getSessionEntry,

package/dist/.setup/{node-cli-sessions-BuJnBnEq.mjs → node-cli-sessions-C59CAyDh.mjs}

@@ -1,4 +1,4 @@
-import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-V6jyFg9g.mjs";
+import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-ktmfo9oa.mjs";
 import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
 import { o as formatCodexDisplayText } from "./command-formatters-B_7-QZ1c.mjs";
 import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
@@ -197,7 +197,7 @@ async function resumeCodexCliSessionOnNode(params) {
 	let catalogHomeId;
 	if (params.sessionKey) {
 		const storePath = params.storePath ?? params.runtime.agent.session.resolveStorePath(void 0, { agentId: params.agentId });
-		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-e9v8mGgx.mjs");
+		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-C_41f1dK.mjs");
 		const entry = await params.runtime.agent.session.getSessionEntryAsync({
 			agentId: params.agentId,
 			storePath,

package/dist/.setup/{node-exec-server.runtime-CP7RC1Nd.mjs → node-exec-server.runtime-DvRSh5Oi.mjs}

@@ -1,5 +1,5 @@
-import { a as isManagedCodexDesktopCommand, f as resolveManagedCodexNativeCommand, u as resolveManagedCodexAppServerStartOptions } from "./managed-binary-DbKvGXKl.mjs";
-import { o as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-Bq160Dhv.mjs";
+import { a as isManagedCodexDesktopCommand, f as resolveManagedCodexNativeCommand, u as resolveManagedCodexAppServerStartOptions } from "./managed-binary-BwzkwiGo.mjs";
+import { o as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-BVeWgcK6.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-Bqj6VQvQ.mjs → plan-C3H9W_2P.mjs}

@@ -1,8 +1,8 @@
 import { t as isOnlyMigrationKind } from "./scope-DOC1Xjc8.mjs";
-import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-DE9wcaeH.mjs";
-import "./config-BfrAlTMT.mjs";
+import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-BVP15PmN.mjs";
+import "./config-BZYTxljj.mjs";
 import { t as readCodexExperimentalFeature } from "./experimental-features-uGnVDtp-.mjs";
-import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-63MLSmLJ.mjs";
+import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-DQN8P65G.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";
@@ -98,8 +98,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--P8jwXvA.mjs").then((n) => n.n);
-	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-DbKvGXKl.mjs").then((n) => n.o);
+	const { CodexAppServerClient } = await import("./client-Bxe8bl-K.mjs").then((n) => n.n);
+	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-BwzkwiGo.mjs").then((n) => n.o);
 	const launcher = resolveManagedCodexPackageEntrypoint(path.dirname(fileURLToPath(import.meta.url)));
 	const command = launcher ? resolveManagedCodexNativeCommand(launcher) : void 0;
 	if (!command) return;

package/dist/.setup/{plugin-activation-CXPWe-hl.mjs → plugin-activation-Cj2k3W9n.mjs}

@@ -1,6 +1,6 @@
 import { r as CodexAppServerRpcError } from "./rpc-error-DemqqaxE.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-DE9wcaeH.mjs";
-import "./config-BfrAlTMT.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-BVP15PmN.mjs";
+import "./config-BZYTxljj.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-CGEiG7hG.mjs → plugin-approval-roundtrip-DEbTgtVQ.mjs}

@@ -1,4 +1,4 @@
-import { ut as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-CkyTrNB8.mjs";
+import { pt as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-BelwlhWf.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";