@openclaw/codex 2026.9.33 → 2026.9.35

package/dist/.setup/{models-Bs4aEhpG.mjs → models-BwkZaXXj.mjs}

@@ -1,4 +1,4 @@
-import { g as assertCodexModelListResponse } from "./client-6GbdZFc0.mjs";
+import { g as assertCodexModelListResponse } from "./client-DcTISXe3.mjs";
 import { normalizeOptionalString, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 1e4;
@@ -32,8 +32,8 @@ async function withCodexAppServerModelRequest(options, run) {
 	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 1e4;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-zsK3DTPh.mjs").then((n) => n.v);
-	const { requestCodexAppServerClientJson } = await import("./request-DQh7X3fU.mjs").then((n) => n.a);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-ZXKMsK6f.mjs").then((n) => n.v);
+	const { requestCodexAppServerClientJson } = await import("./request-CWERwKIL.mjs").then((n) => n.a);
 	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,

package/dist/.setup/{native-auth-BN-BD2AV.mjs → native-auth-BNGz77PF.mjs}

@@ -1,8 +1,8 @@
 import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
 import { n as isCodexAppServerProxyLaunch, t as buildCodexLoginStatusArgs } from "./launch-args-DbFCehO7.mjs";
-import { r as resolveManagedCodexAppServerStartOptions } from "./managed-binary-B6hQ1UKR.mjs";
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-CbutOIEh.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
+import { r as resolveManagedCodexAppServerStartOptions } from "./managed-binary-Ckgvm_4V.mjs";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-DU8dIOCj.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DDhvIeUC.mjs";
 import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 //#region extensions/codex/src/app-server/native-auth.ts

package/dist/.setup/{native-subagent-monitor-DbNIloTJ.mjs → native-subagent-monitor-g-ZDkvCr.mjs}

@@ -1,11 +1,11 @@
-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-DwkCzLvD.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-XHNn4k5q.mjs";
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { c as readNonEmptyString, o as readHookOutputEntries, r as normalizeOptionalString$1, s as readItem, u as readNullableString } from "./event-projector-values-DJSz8BTk.mjs";
 import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-fXkKbPVC.mjs";
 import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-D83lJWHG.mjs";
-import { P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, mt as resolveCodexGatewayTimeoutWithGraceMs, q as retainCodexAppServerLiveThread } from "./shared-client-zsK3DTPh.mjs";
-import { A as itemStatus, D as isSideEffectingNativeToolItem, E as isProjectedNativeToolItem, M as matchesCodexSnapshotTurn, O as itemKind, P as unknownItemStatus, S as auditNativeToolTerminalStatus, T as isNonSuccessItemStatus, j as itemTitle, k as itemName, s as interruptCodexTurnAndWaitBestEffort, w as isMutatingNativeToolItem, x as auditNativeToolName } from "./attempt-client-cleanup-D1aznv7C.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, ht as resolveCodexGatewayTimeoutWithGraceMs, q as retainCodexAppServerLiveThread } from "./shared-client-ZXKMsK6f.mjs";
+import { A as itemStatus, D as isSideEffectingNativeToolItem, E as isProjectedNativeToolItem, M as matchesCodexSnapshotTurn, O as itemKind, P as unknownItemStatus, S as auditNativeToolTerminalStatus, T as isNonSuccessItemStatus, j as itemTitle, k as itemName, s as interruptCodexTurnAndWaitBestEffort, w as isMutatingNativeToolItem, x as auditNativeToolName } from "./attempt-client-cleanup-BVtNsTOE.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BuEALwJY.mjs";
 import { asFiniteNumber, asNonArrayRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
@@ -560,6 +560,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);
@@ -597,7 +598,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);
@@ -612,25 +613,66 @@ 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;
 		if (!store || !current || !owner.completionCustody?.isCurrent()) return;
 		const custody = owner.completionCustody.retain();
 		try {
+			await this.drain(state);
 			store.assertCurrent();
 			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);
+				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) });
@@ -991,7 +1033,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;
@@ -1026,15 +1079,15 @@ var CodexNativeSubagentCompletionDelivery = class {
 				return;
 			}
 			if (delivery.recoveryBlocked) {
-				this.dependencies.unregisterChild(childState);
+				await this.abandon(state, childState);
 				return;
 			}
 			if (delivery.recoveryPending) {
-				this.scheduleRetry(childState, delivery.error ?? "requester recovery owns completion", false);
+				await this.scheduleRetry(state, 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);
+			await this.scheduleRetry(state, childState, error);
 		} catch (error) {
 			if (!this.dependencies.isCurrentChild(childState) || !this.dependencies.isCurrentParent(state) || this.dependencies.isRetiredParent(state)) return;
 			if (!this.claim(state, childState)) {
@@ -1042,7 +1095,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,
@@ -1105,22 +1158,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.isCurrentChild(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.isCurrentChild(childState)) return;
-			const state = this.dependencies.getParent(childState.parentThreadId);
-			if (state) this.deliverPending(state, childState);
+			const currentParent = this.dependencies.getParent(childState.parentThreadId);
+			if (currentParent) this.deliverPending(currentParent, childState);
 		}, delayMs);
 		childState.completionDeliveryTimer.unref();
 	}
@@ -1128,7 +1200,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);
@@ -1406,6 +1478,10 @@ var CodexNativeSubagentHistoryRecovery = class {
 			itemsView: "full"
 		}, { timeoutMs: THREAD_READ_TIMEOUT_MS });
 	}
+	async isNativeChildThread(threadId) {
+		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;
@@ -2119,7 +2195,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 		state.pendingRegistrations -= 1;
 		dependencies.prune(registeredState);
 	}
-	const ready = dependencies.assignments.restore(state, owner);
+	const ready = dependencies.submissions.drain(registeredState).then(() => dependencies.assignments.restore(state, owner)).then(() => dependencies.assignments.drain(registeredState));
 	let registered = true;
 	let settlement;
 	return {
@@ -2631,6 +2707,7 @@ var CodexNativeSubagentSubmissionOwner = class {
 		if (!this.isObserving(state, custody) || !this.admitTurn(state, custody.receipt, turn, custody.owner, historyValidated, custody.completionCustody)) return;
 		custody.phase = "promoting";
 		if (custody.timer) clearTimeout(custody.timer);
+		custody.release();
 	}
 	settleChild(state, child) {
 		for (const custody of this.pending.get(state)?.values() ?? []) {
@@ -4580,6 +4657,8 @@ var Monitor = class {
 			isRetiredParent: (state) => this.retiredParentStates.has(state),
 			getParent: (id) => this.parentStates.get(id),
 			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({
@@ -4695,8 +4774,9 @@ var Monitor = class {
 					revision.release();
 				}
 			},
+			isNativeChildThread: async (threadId) => this.knownChildren.has(threadId) || await this.historyRecovery.isNativeChildThread(threadId),
 			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;
@@ -4843,6 +4923,9 @@ var Monitor = class {
 		});
 		if (!capture) return;
 		try {
+			const known = this.knownChildren.get(request.threadId);
+			const child = known ? this.admitFollowupChild(known, request.threadId) : void 0;
+			if (child?.nativeTurnId === request.turnId && child.settledWithoutCompletion) this.resumeChild(child);
 			await this.persistModelAssignment(request, capture);
 			request.signal?.throwIfAborted();
 			capture.assertCurrent();
@@ -5016,6 +5099,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;
@@ -5026,6 +5110,7 @@ var Monitor = class {
 		releaseNativeDirectChild(childState);
 		releaseNativeModelExecution(childState);
 		this.recovery.clearRecoveryTimers(childState);
+		this.releaseParentThreadIfChildrenSettled(childState.parentThreadId);
 		this.releaseClientRetentionIfIdle();
 	}
 	async handleChildTurnCompletion(notification, childState) {
@@ -5199,6 +5284,7 @@ var Monitor = class {
 		this.recovery.markTerminalRevision(childState.childThreadId);
 		releaseNativeDirectChild(childState);
 		this.recovery.clearRecoveryTimers(childState);
+		this.releaseParentThreadIfChildrenSettled(state.parentThreadId);
 		this.applyNativeReceipts(state, childState.deliveryReceipts.record(childState.runId, this.knownChildren.get(childState.childThreadId)?.agentPaths ?? [childState.childThreadId], acceptedCompletion.result));
 		await this.completionDelivery.deliverPending(state, childState);
 	}
@@ -5258,10 +5344,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,
@@ -5480,6 +5563,7 @@ var Monitor = class {
 			}
 			if (!transitioned) claimOwner.onDirectChildAccepted?.();
 		}
+		this.observeActiveChild(child);
 		this.admissionCustody.bindEventSink(child);
 		return child;
 	}
@@ -5534,11 +5618,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)) {
-			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);
@@ -5563,6 +5643,17 @@ var Monitor = class {
 			});
 		});
 	}
+	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?.();
+	}
 	releaseClientRetentionIfIdle() {
 		if ([...this.childStates.values()].some((childState) => !childState.terminal && !childState.settledWithoutCompletion)) return;
 		this.releaseRetainedClient();

package/dist/.setup/{native-subagent-pending-assignments-DwkCzLvD.mjs → native-subagent-pending-assignments-XHNn4k5q.mjs}

@@ -166,7 +166,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;
@@ -174,29 +174,66 @@ 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)) return { applied: false };
-	if (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) remaining.push(existing?.recordedCompletion && !assignment.recordedCompletion ? {
-		...assignment,
-		recordedCompletion: existing.recordedCompletion
-	} : assignment);
+	if (!params.consume) {
+		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

package/dist/.setup/{native-task-assignments-DMQ0g3hu.mjs → native-task-assignments-Dna952zv.mjs}

@@ -1,5 +1,5 @@
-import { _ as readCodexNativeSubagentHistoryOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-DwkCzLvD.mjs";
-import { _ as readStoredCodexAppServerBinding, r as bindingStoreKey } from "./session-binding-record-Oe9L-CNY.mjs";
+import { _ as readCodexNativeSubagentHistoryOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-XHNn4k5q.mjs";
+import { _ as readStoredCodexAppServerBinding, r as bindingStoreKey } from "./session-binding-record-CUKpUKVm.mjs";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.mjs";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";

package/dist/.setup/{node-cli-sessions-HC4W6FLI.mjs → node-cli-sessions-BwhIYgCZ.mjs}

@@ -1,4 +1,4 @@
-import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-CnEH565l.mjs";
 import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
 import { o as formatCodexDisplayText } from "./command-formatters-R3ckE3Co.mjs";
 import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
@@ -187,7 +187,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-DgXvSGu0.mjs");
+		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-BdS7zDuY.mjs");
 		const entry = params.runtime.agent.session.getSessionEntry({
 			sessionKey: params.sessionKey,
 			readConsistency: "latest"

package/dist/.setup/{node-exec-server.runtime-BS7jsvK-.mjs → node-exec-server.runtime-9IZtsOmo.mjs}

@@ -1,5 +1,5 @@
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-B6hQ1UKR.mjs";
-import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-CbutOIEh.mjs";
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-Ckgvm_4V.mjs";
+import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-DU8dIOCj.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-NTSBQtKx.mjs → plan-Cwp_21m-.mjs}

@@ -1,7 +1,7 @@
-import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-Cky2XJUw.mjs";
+import { u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-B4uqIw4J.mjs";
 import { t as isOnlyMigrationKind } from "./scope-DOC1Xjc8.mjs";
-import "./config-DKhXquav.mjs";
-import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-DzsIjGO7.mjs";
+import "./config-DqmrqI23.mjs";
+import { i as hasCodexSource, n as defaultCodexHome, o as readJsonObject, r as discoverCodexSource, s as sanitizeName, t as codexPluginMigrationSubscriptionWarning } from "./source-Iusn97ly.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-6GbdZFc0.mjs").then((n) => n.n);
-	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-B6hQ1UKR.mjs").then((n) => n.n);
+	const { CodexAppServerClient } = await import("./client-DcTISXe3.mjs").then((n) => n.n);
+	const { resolveManagedCodexPackageEntrypoint, resolveManagedCodexNativeCommand } = await import("./managed-binary-Ckgvm_4V.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-cNHRfaxU.mjs → plugin-activation-BaDnJKJd.mjs}

@@ -1,6 +1,6 @@
-import { i as listCodexPluginMetadata, n as isOpenAiCuratedMarketplace, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, t as findCodexMarketplacePluginSummary, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-Cky2XJUw.mjs";
+import { i as listCodexPluginMetadata, n as isOpenAiCuratedMarketplace, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, t as findCodexMarketplacePluginSummary, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-B4uqIw4J.mjs";
 import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
-import "./config-DKhXquav.mjs";
+import "./config-DqmrqI23.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-inventory-Cky2XJUw.mjs → plugin-inventory-B4uqIw4J.mjs}

@@ -1,6 +1,6 @@
 import { f as resolveCodexPluginsPolicy } from "./config-parsing-b088LyhT.mjs";
 import { c as findCodexAppById } from "./plugin-app-cache-key-BL9B5H0L.mjs";
-import "./config-DKhXquav.mjs";
+import "./config-DqmrqI23.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";

package/dist/.setup/{plugin-metadata-cache-Z06WuND0.mjs → plugin-metadata-cache-C-LRxilF.mjs}

@@ -1,13 +1,13 @@
 import { t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
 import { o as resolveCodexComputerUseConfig } from "./config-options-CzyWLTJt.mjs";
-import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, t as isManagedCodexDesktopCommand } from "./managed-binary-B6hQ1UKR.mjs";
+import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, t as isManagedCodexDesktopCommand } from "./managed-binary-Ckgvm_4V.mjs";
 import { n as describeControlFailure } from "./capabilities-B3WEZl4e.mjs";
-import { r as requestCodexAppServerClientJson } from "./request-DQh7X3fU.mjs";
-import "./config-DKhXquav.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { O as acquireCodexNativeConfigFence, at as hasLegacyCodexComputerUseMcpPolicy, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, ct as ensureCodexComputerUseSharedPluginCache, d as readCodexAppServerClientDesktopGeneration, et as reconcileCodexComputerUseStartArtifacts, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, it as resolveClientManagedBundledMarketplacePath, lt as assertNotSymlink, ot as isLegacyCodexComputerUsePluginDisabled, p as readCodexAppServerClientProcessIdentity, rt as resolveBundledComputerUseMarketplacePath, st as resolveManagedCodexComputerUseConfig, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, y as waitForCodexAppServerClientDesktopGenerationDrain } from "./shared-client-zsK3DTPh.mjs";
-import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-6GbdZFc0.mjs";
-import { r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-D1aznv7C.mjs";
+import { r as requestCodexAppServerClientJson } from "./request-CWERwKIL.mjs";
+import "./config-DqmrqI23.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DDhvIeUC.mjs";
+import { O as acquireCodexNativeConfigFence, at as resolveClientManagedBundledMarketplacePath, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, ct as resolveManagedCodexComputerUseConfig, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, it as resolveBundledComputerUseMarketplacePath, lt as ensureCodexComputerUseSharedPluginCache, ot as hasLegacyCodexComputerUseMcpPolicy, p as readCodexAppServerClientProcessIdentity, st as isLegacyCodexComputerUsePluginDisabled, t as assertCodexAppServerClientStartSelectionCurrent, tt as reconcileCodexComputerUseStartArtifacts, u as isCodexAppServerStartSelectionChangedError, ut as assertNotSymlink, y as waitForCodexAppServerClientDesktopGenerationDrain } from "./shared-client-ZXKMsK6f.mjs";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-DcTISXe3.mjs";
+import { r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-BVtNsTOE.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";

package/dist/.setup/{provider-BnX84knz.mjs → provider-DUotqBZ6.mjs}

@@ -11,7 +11,7 @@ function buildCodexMigrationProvider(params = {}) {
 		].join(" "),
 		supportedItemKinds: ["memory", "auth"],
 		async detect(ctx) {
-			const { discoverCodexSource, hasCodexSource } = await import("./source-DzsIjGO7.mjs").then((n) => n.a);
+			const { discoverCodexSource, hasCodexSource } = await import("./source-Iusn97ly.mjs").then((n) => n.a);
 			const memoryOnly = isOnlyMigrationKind(ctx, "memory");
 			const authOnly = isOnlyMigrationKind(ctx, "auth");
 			const source = await discoverCodexSource({
@@ -29,16 +29,16 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		async plan(ctx) {
-			const { buildCodexMigrationPlan } = await import("./plan-NTSBQtKx.mjs");
+			const { buildCodexMigrationPlan } = await import("./plan-Cwp_21m-.mjs");
 			return buildCodexMigrationPlan(ctx);
 		},
 		deferredApply: { retrySafe: true },
 		prepareApply(ctx) {
 			if (isOnlyMigrationKind(ctx, "memory") || isOnlyMigrationKind(ctx, "auth")) return;
-			return import("./apply-C82xe8Bk.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+			return import("./apply-CxwOGLd_.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
 		},
 		async apply(ctx, plan) {
-			const { applyCodexMigrationPlan } = await import("./apply-C82xe8Bk.mjs");
+			const { applyCodexMigrationPlan } = await import("./apply-CxwOGLd_.mjs");
 			return await applyCodexMigrationPlan({
 				ctx,
 				plan,

package/dist/.setup/{provider-capabilities-CYK-rMwC.mjs → provider-capabilities-DBs9l8oL.mjs}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-zsK3DTPh.mjs";
-import { dt as normalizeCodexDynamicToolName } from "./thread-requests-15uBuGjw.mjs";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-ZXKMsK6f.mjs";
+import { dt as normalizeCodexDynamicToolName } from "./thread-requests-y_MnVuWC.mjs";
 import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
 //#region extensions/codex/src/app-server/shell-dynamic-tools.ts