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

package/dist/.setup/{native-subagent-monitor-DOLEIf9r.mjs → native-subagent-monitor-C3CIIaZG.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 { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as defineCodexBuildState } from "./build-state-Ds14X10-.mjs";
-import { a as readHookOutputEntries, o as readItem, s as readNullableString } from "./event-projector-values-CLvG1Hil.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-CTinVtjo.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { n as defineCodexBuildState } from "./build-state-CjLCC0wm.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-BO6i_pfk.mjs";
-import { P as claimCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, q as retainCodexAppServerLiveThread } from "./shared-client-BCx1wbyA.mjs";
-import { M as readCodexAppServerWarningMessage } from "./client-D93nbdB8.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-DBVMToGo.mjs";
-import { s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-zNuNTKVr.mjs";
-import { t as projectCodexWebSearchItem } from "./web-search-item-CvokaZOo.mjs";
-import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-CD88q3yx.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 { t as projectCodexWebSearchItem } from "./web-search-item-DHVuNSqk.mjs";
+import { n as codexApprovalTimeoutText } from "./plugin-approval-roundtrip-CGEiG7hG.mjs";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-CZz2DJ4q.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.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";
@@ -19,7 +19,8 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import path from "node:path";
 import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, embeddedAgentLog, emitAgentEvent, formatErrorMessage as formatErrorMessage$1, inferToolMetaFromArgs, projectAgentActivityItem, projectAgentToolActivity, runAgentHarnessAfterToolCallHook, sanitizeToolArgs } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, embeddedAgentLog, emitAgentEvent, formatErrorMessage as formatErrorMessage$1, inferToolMetaFromArgs, projectAgentActivityItem, projectAgentToolActivity, runAgentHarnessAfterToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM, NativeToolOutputAccumulator, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS, createAgentHarnessToolCallMessage, createAgentHarnessToolResultMessage, formatNativeToolOutput, formatNativeToolSummary, truncateNativeToolTranscriptText } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 import { captureAgentHarnessCompletionCustody, createAgentHarnessCompletionEventSink, deliverAgentHarnessCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-completion";
 import { compileFunction } from "node:vm";
@@ -184,6 +185,12 @@ function retainNativeModelExecution(owner, turnId, threadId, completionCustody =
 	const capture = owner?.modelSource?.capture();
 	if (!owner || !capture) return;
 	const nativeOwner = {
+		requestCustody: owner.requestCustody,
+		requesterTurnRunId: owner.requesterTurnRunId,
+		requesterAgentId: owner.requesterAgentId,
+		requesterSessionKey: owner.requesterSessionKey,
+		requesterSessionId: owner.requesterSessionId,
+		requesterLifecycleRevision: owner.requesterLifecycleRevision,
 		modelSource: owner.modelSource,
 		modelMapping: owner.modelMapping,
 		configurationQualification: owner.configurationQualification,
@@ -266,6 +273,10 @@ function releaseNativeDirectChild(child) {
 }
 function admitNativeChildModelExecution(child, owner, known) {
 	if (known) known.configurationQualification = owner.configurationQualification;
+	if (!child.modelExecution) {
+		child.requesterTurnRunId = owner.requesterTurnRunId;
+		child.requestCustody = owner.requestCustody;
+	}
 	child.modelExecution ??= retainNativeModelExecution(owner, child.nativeTurnId, child.childThreadId, child.completionCustody);
 	owner.onDirectChildAccepted?.();
 }
@@ -563,6 +574,7 @@ var CodexNativeSubagentAssignmentInventory = class {
 		this.dependencies = dependencies;
 		this.writes = /* @__PURE__ */ new Map();
 		this.snapshots = /* @__PURE__ */ new WeakMap();
+		this.cancelled = /* @__PURE__ */ new WeakSet();
 	}
 	hasWrites(state) {
 		return this.writes.has(state);
@@ -620,18 +632,33 @@ var CodexNativeSubagentAssignmentInventory = class {
 			await state.assignmentStore?.consume(assignment, () => this.dependencies.assertCurrent(state));
 		});
 	}
+	settleCancelled(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.cancelled.has(child)) return;
+			if (!await state.assignmentStore.consume(assignment, assertAdmission)) throw new Error("Cancelled native assignment was not acknowledged.");
+			this.cancelled.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 {
-			store.assertCurrent();
-			for (const assignment of store.read()) {
+			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();
 				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);
 			}
@@ -664,6 +691,22 @@ var CodexNativeSubagentAssignmentInventory = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/app-server/native-subagent-cancellation-wait.ts
+/** Bound pending registration and turn discovery by Stop's shared native deadline. */
+async function waitForNativeCancellationWork(client, work, deadline) {
+	const remaining = deadline - performance.now();
+	if (remaining <= 0) throw new Error("Codex descendant cancellation did not settle before its deadline");
+	const interrupted = createDeferred();
+	const timer = setTimeout(() => interrupted.reject(/* @__PURE__ */ new Error("Codex descendant cancellation did not settle before its deadline")), remaining);
+	const releaseClose = client.addCloseHandler(() => interrupted.reject(/* @__PURE__ */ new Error("Codex client closed during descendant cancellation")));
+	try {
+		return await Promise.race([work, interrupted.promise]);
+	} finally {
+		clearTimeout(timer);
+		releaseClose();
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-subagent-retry.ts
 function delayForAttempt(delays, attempt) {
 	return Math.max(1, delays[Math.min(attempt, delays.length - 1)] ?? 1);
@@ -683,29 +726,14 @@ const DEFAULT_RECOVERY_POLL_DELAYS_MS = [
 var CodexNativeSubagentRecoveryCoordinator = class {
 	constructor(dependencies) {
 		this.dependencies = dependencies;
-		this.threadStatusRevisions = /* @__PURE__ */ new Map();
+		this.terminalThreads = /* @__PURE__ */ new Map();
 		this.recoveryPollDelaysMs = dependencies.recoveryPollDelaysMs ?? DEFAULT_RECOVERY_POLL_DELAYS_MS;
 	}
-	hasRevision(threadId) {
-		return this.threadStatusRevisions.has(threadId);
+	isTerminalThread(threadId) {
+		return this.terminalThreads.has(threadId);
 	}
-	observeRevision(threadId) {
-		const revision = this.threadStatusRevisions.get(threadId);
-		if (revision) revision.value += 1;
-	}
-	isTerminalRevision(threadId) {
-		return this.threadStatusRevisions.get(threadId)?.terminal === true;
-	}
-	markTerminalRevision(threadId) {
-		const revision = this.threadStatusRevisions.get(threadId);
-		if (revision) revision.terminal = true;
-	}
-	seedRevision(threadId, parentThreadId) {
-		this.threadStatusRevisions.set(threadId, this.threadStatusRevisions.get(threadId) ?? {
-			value: 0,
-			readers: 0,
-			parentThreadId
-		});
+	markTerminalThread(threadId, parentThreadId) {
+		this.terminalThreads.set(threadId, parentThreadId);
 	}
 	async reconcileRegisteredChild(childState) {
 		if (childState.terminal || this.dependencies.isDisposed() || !this.dependencies.isRegisteredChild(childState)) return false;
@@ -715,16 +743,11 @@ var CodexNativeSubagentRecoveryCoordinator = class {
 		try {
 			return await recovery;
 		} finally {
-			if (childState.recoveryInFlight === recovery) childState.recoveryInFlight = void 0;
+			childState.recoveryInFlight = void 0;
 		}
 	}
-	clearTerminalRevisionsForParent(parentThreadId) {
-		for (const [threadId, revision] of this.threadStatusRevisions) if (revision.parentThreadId === parentThreadId) this.collectThreadStatusRevision(threadId, revision);
-	}
-	collectThreadStatusRevision(threadId, revision = this.threadStatusRevisions.get(threadId)) {
-		if (!revision || revision.readers > 0 || Boolean(this.dependencies.currentChild(threadId))) return;
-		if ((revision.parentThreadId ? this.dependencies.parentState(revision.parentThreadId) : void 0)?.owners.size) return;
-		if (this.threadStatusRevisions.get(threadId) === revision) this.threadStatusRevisions.delete(threadId);
+	clearTerminalThreadsForParent(parentThreadId) {
+		for (const [threadId, parent] of this.terminalThreads) if (parent === parentThreadId) this.terminalThreads.delete(threadId);
 	}
 	scheduleRecoveryPoll(childState) {
 		if (childState.terminal || childState.settledWithoutCompletion || childState.recoveryTimer || this.dependencies.isDisposed() || this.recoveryPollDelaysMs.length === 0) return;
@@ -763,25 +786,6 @@ var CodexNativeSubagentRecoveryCoordinator = class {
 		if (childState.fallbackCompletion?.statusLabel !== "system_error") return;
 		childState.fallbackCompletion = void 0;
 	}
-	retainThreadStatusRevision(threadId) {
-		const revision = this.threadStatusRevisions.get(threadId) ?? {
-			value: 0,
-			readers: 0
-		};
-		this.threadStatusRevisions.set(threadId, revision);
-		revision.readers += 1;
-		const capturedValue = revision.value;
-		let retained = true;
-		return {
-			isCurrent: () => this.threadStatusRevisions.get(threadId) === revision && revision.value === capturedValue,
-			release: () => {
-				if (!retained) return;
-				retained = false;
-				revision.readers -= 1;
-				this.collectThreadStatusRevision(threadId, revision);
-			}
-		};
-	}
 	clearRecoveryTimers(childState) {
 		clearTimeout(childState.recoveryTimer);
 		childState.recoveryTimer = void 0;
@@ -809,7 +813,7 @@ var CodexNativeSubagentCloseOwner = class {
 		this.calls.delete(state);
 	}
 	hasPending(state) {
-		return [...this.calls.get(state)?.values() ?? []].some((call) => call.completing && !call.settled);
+		return [...this.calls.get(state)?.values() ?? []].some((call) => call.settlement !== void 0);
 	}
 	settlements(state) {
 		return [...this.calls.get(state)?.values() ?? []].flatMap((call) => call.settlement ? [call.settlement] : []);
@@ -862,7 +866,7 @@ var CodexNativeSubagentCloseOwner = class {
 		const calls = this.calls.get(state);
 		if (!calls) return;
 		for (const [key, call] of calls) {
-			if (call.completing && !call.settled) continue;
+			if (call.settlement) continue;
 			if (!this.hasCallOwner(state, call, true)) calls.delete(key);
 		}
 	}
@@ -883,7 +887,7 @@ var CodexNativeSubagentCloseOwner = class {
 				known.assignment.terminal = true;
 				known.assignment.nativeTurnId = childState.nativeTurnId;
 			}
-			this.callbacks.markTerminalRevision(childState.childThreadId);
+			this.callbacks.markTerminalThread(childState.childThreadId, state.parentThreadId);
 		}
 		childState.pendingCompletion = void 0;
 		childState.subscriptionClosed = true;
@@ -899,9 +903,9 @@ var CodexNativeSubagentCloseOwner = class {
 	}
 	completeChildClose(state, key, call) {
 		if (call.settlement) return call.settlement;
-		const settlement = this.confirmChildClose(state, key, call);
-		if (call.completing) call.settlement = settlement;
-		return settlement;
+		if (!this.callbacks.isParentCurrent(state) || !this.hasCallOwner(state, call, false)) return Promise.resolve();
+		call.settlement = this.confirmChildClose(state, key, call);
+		return call.settlement;
 	}
 	async confirmChildClose(state, key, call) {
 		const isCurrent = () => this.callbacks.isParentCurrent(state) && this.calls.get(state)?.get(key) === call;
@@ -910,19 +914,13 @@ var CodexNativeSubagentCloseOwner = class {
 			const childState = this.callbacks.currentChild(target.childThreadId);
 			return known?.parent === state && known.assignment.runId === target.runId && known.turnId === target.nativeTurnId && known.pendingTurns.length === 0 && (childState === void 0 || childState === target.childState);
 		};
-		if (call.completing || !isCurrent() || !this.hasCallOwner(state, call, false)) return;
-		call.completing = true;
-		let settled = false;
 		let retiring = false;
 		try {
 			const forgetters = await Promise.all(call.targets.map((target) => Promise.resolve(target.forget)));
 			if (!isCurrent()) return;
 			const loaded = await this.client.request("thread/loaded/list", {}, { timeoutMs: 1e4 });
 			if (!isCurrent()) return;
-			if (!isJsonObject(loaded) || loaded.nextCursor !== null || !Array.isArray(loaded.data) || !loaded.data.every((id) => typeof id === "string" && id.trim() !== "")) {
-				settled = true;
-				return;
-			}
+			if (!isJsonObject(loaded) || loaded.nextCursor !== null || !Array.isArray(loaded.data) || !loaded.data.every((id) => typeof id === "string" && id.trim() !== "")) return;
 			for (const [index, target] of call.targets.entries()) {
 				const childState = this.callbacks.currentChild(target.childThreadId);
 				if (loaded.data.includes(target.childThreadId) || !isTargetCurrent(target)) continue;
@@ -933,21 +931,14 @@ var CodexNativeSubagentCloseOwner = class {
 					if (!isCurrent()) return;
 				} else forget?.();
 			}
-			settled = true;
 		} catch (error) {
 			embeddedAgentLog.warn("Failed to confirm Codex native subagent close", {
 				parentThreadId: state.parentThreadId,
 				error: formatErrorMessage$1(error)
 			});
 			if (retiring) throw error;
-			settled = true;
 		} finally {
-			if (settled || !isCurrent()) call.settled = true;
-			else {
-				call.completing = void 0;
-				call.settlement = void 0;
-			}
-			if (call.settled && this.calls.get(state)?.get(key) === call) call.targets = [];
+			if (this.calls.get(state)?.get(key) === call) this.calls.get(state)?.delete(key);
 			this.prune(state);
 			this.callbacks.pruneParent(state);
 		}
@@ -980,21 +971,24 @@ var CodexNativeSubagentCompletionDelivery = class {
 	deliverPending(state, childState) {
 		const existing = this.attempts.get(childState);
 		if (existing) return existing;
-		const attempt = this.deliverAttempt(state, childState);
+		const attempt = Promise.resolve().then(() => this.deliverAttempt(state, childState));
 		this.attempts.set(childState, attempt);
 		const release = () => {
-			if (this.attempts.get(childState) === attempt) this.attempts.delete(childState);
+			this.attempts.delete(childState);
 		};
 		attempt.then(release, release);
 		return attempt;
 	}
+	async join(child) {
+		await this.attempts.get(child);
+	}
 	async deliverAttempt(state, childState) {
 		const completion = childState.pendingCompletion;
 		if (!completion || !this.isCurrent(state, childState)) return;
-		if (childState.deliveringCompletion || childState.completionDeliveryTimer) return;
-		childState.deliveringCompletion = true;
+		if (childState.completionDeliveryTimer) return;
 		let deferredToForeground = false;
 		try {
+			if (childState.cancellationRequested && completion.status === "cancelled") return;
 			if (!this.prepareDelivery(state, childState)) return;
 			if (state.owners.size > 0 || !state.completionScope) {
 				deferredToForeground = state.owners.size > 0;
@@ -1047,7 +1041,6 @@ var CodexNativeSubagentCompletionDelivery = class {
 			});
 		} finally {
 			if (!deferredToForeground) childState.completionCustody?.settleExecution();
-			childState.deliveringCompletion = false;
 		}
 	}
 	finish(state, child) {
@@ -1070,7 +1063,7 @@ var CodexNativeSubagentCompletionDelivery = class {
 				if (!this.claim(deliveryParent, child)) continue;
 			}
 			child.nativeCompletionDelivered = true;
-			if (child.pendingCompletion && !child.deliveringCompletion) this.finish(deliveryParent, child);
+			if (child.pendingCompletion && !this.attempts.has(child)) this.finish(deliveryParent, child);
 		}
 	}
 	deliverDetached(state) {
@@ -1155,12 +1148,6 @@ const NATIVE_SUBAGENT_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
 	"item/completed",
 	"rawResponseItem/completed"
 ]);
-const RECOVERY_REVISION_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
-	"thread/started",
-	"thread/status/changed",
-	"turn/started",
-	"turn/completed"
-]);
 const CODEX_SUBAGENT_NOTIFICATION_START = "<subagent_notification>";
 const CODEX_SUBAGENT_NOTIFICATION_END = "</subagent_notification>";
 function extractCodexNativeSubagentCompletions(notification) {
@@ -1618,7 +1605,6 @@ async function prepareNativeModelToolInput(request, dependencies) {
 	}
 	let preparedSource;
 	let pendingBinding;
-	let targetRevision;
 	let assertTargetCurrent;
 	const assertCurrent = () => {
 		request.signal?.throwIfAborted();
@@ -1631,16 +1617,16 @@ async function prepareNativeModelToolInput(request, dependencies) {
 	try {
 		assertCurrent();
 		const targetThreadId = resolveInputTarget(request, dependencies);
-		targetRevision = dependencies.retainTargetRevision(targetThreadId);
 		const targetParent = dependencies.parents.get(targetThreadId);
 		const targetChild = dependencies.knownChildren.get(targetThreadId);
+		const targetLoad = (targetParent ?? targetChild)?.nativeLoad;
 		const targetConfiguration = targetChild?.configurationQualification;
 		const targetRouting = request.readQualification(targetThreadId);
 		let metadataRead = false;
 		assertTargetCurrent = () => {
 			const nativeRoot = nativeRootThreadId(request.threadId, dependencies.knownChildren, state);
 			if (!(targetParent ? (targetParent === state || nativeRoot === targetThreadId) && dependencies.canPrepareReceiver(state, targetThreadId) : targetChild ? dependencies.canPrepareReceiver(state, targetThreadId) : !metadataRead || nativeRoot === targetThreadId || nativeParentThreadId === state.parentThreadId || nativeParentThreadId !== void 0 && dependencies.knownChildren.get(nativeParentThreadId)?.parent === state)) throw new Error("Codex native input target is outside the sender's admitted tree");
-			if (!targetRevision?.isCurrent() || dependencies.parents.get(targetThreadId) !== targetParent || dependencies.knownChildren.get(targetThreadId) !== targetChild || targetChild?.configurationQualification !== targetConfiguration || request.readQualification(targetThreadId) !== targetRouting) throw new Error("Codex native receiver changed during input preparation; retry with its current thread");
+			if (dependencies.parents.get(targetThreadId) !== targetParent || dependencies.knownChildren.get(targetThreadId) !== targetChild || (targetParent ?? targetChild)?.nativeLoad !== targetLoad || targetChild?.configurationQualification !== targetConfiguration || request.readQualification(targetThreadId) !== targetRouting) throw new Error("Codex native receiver changed during input preparation; retry with its current thread");
 			targetConfiguration?.assertCurrent();
 			targetRouting?.assertCurrent();
 		};
@@ -1722,7 +1708,6 @@ async function prepareNativeModelToolInput(request, dependencies) {
 			targetThreadId
 		}, pendingModelSources, preparedOwner);
 	} finally {
-		targetRevision?.release();
 		preparedSource?.release();
 		if (!preparedSource) capture.release();
 	}
@@ -1813,6 +1798,12 @@ function createCodexNativeSubagentMonitorRuntime(Monitor) {
 			};
 			monitor = new Monitor(client, runtime ?? defaultNativeSubagentMonitorRuntime, {
 				retainClient,
+				interruptChildAndWait: (threadId, turnId, assertCurrent, timeoutMs) => interruptCodexTurnAndWaitBestEffort(client, {
+					threadId,
+					turnId,
+					assertCurrent,
+					timeoutMs
+				}),
 				interruptModelExecution: (threadId, turnId) => {
 					interruptCodexTurnAndWaitBestEffort(client, {
 						threadId,
@@ -1870,6 +1861,10 @@ function createCodexNativeSubagentMonitorRuntime(Monitor) {
 			if (!monitor) return Promise.reject(/* @__PURE__ */ new Error("Codex native input has no admitted model source"));
 			return monitor.prepareModelInput(request);
 		},
+		withDescendantCancellation: (client, params, run) => monitors.get(client)?.withDescendantCancellation(params, run) ?? run(async () => ({
+			killed: 0,
+			cancelledRequesters: []
+		})),
 		retireParent: (client, parentThreadId) => monitors.get(client)?.retireParent(parentThreadId) ?? Promise.resolve()
 	};
 }
@@ -1976,6 +1971,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 	const parentThreadId = params.parentThreadId.trim();
 	if (!parentThreadId) throw new Error("Codex native subagent monitor requires a parent thread id");
 	if (dependencies.isClosed()) throw new Error("Codex native subagent monitor is closed");
+	dependencies.assertAdmissionCurrent?.(params);
 	let state = dependencies.states.get(parentThreadId);
 	if (state?.requesterSessionKey && params.requesterSessionKey && state.requesterSessionKey !== params.requesterSessionKey) throw new Error(`Codex thread ${parentThreadId} is already bound to another session`);
 	if (!state) {
@@ -1990,11 +1986,18 @@ async function registerNativeSubagentParent(input, dependencies) {
 	}
 	state.requesterSessionKey ??= params.requesterSessionKey;
 	const requesterSessionKey = state.requesterSessionKey;
-	state.pendingRegistrations = (state.pendingRegistrations ?? 0) + 1;
 	const registeredState = state;
 	const isCurrent = () => !dependencies.isClosed() && !dependencies.isRetired(registeredState) && dependencies.states.get(parentThreadId) === registeredState;
 	const ownerKey = Symbol("codex-native-subagent-owner");
+	const registrationSettled = createDeferred();
 	let owner = {
+		requestCustody: params.requestCustody,
+		requesterAgentId: params.agentId,
+		requesterSessionKey: params.requesterSessionKey,
+		requesterTurnRunId: params.requesterTurnRunId,
+		requesterSessionId: params.historyOwner?.sessionId,
+		requesterLifecycleRevision: params.historyOwner?.lifecycleRevision,
+		registrationSettled: registrationSettled.promise,
 		configurationQualification: params.configurationQualification,
 		unqualifiedModelExecution: params.modelSource ? params.unqualifiedModelExecution : void 0,
 		interruptModelExecution: dependencies.interruptModelExecution,
@@ -2003,6 +2006,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 		onDirectChildAccepted: params.onDirectChildAccepted,
 		isTurnYielded: params.isTurnYielded
 	};
+	(state.pendingRegistrations ??= /* @__PURE__ */ new Set()).add(owner);
 	let rootModelBinding;
 	let cancellationReported = false;
 	let interruptedTurnId;
@@ -2025,11 +2029,12 @@ async function registerNativeSubagentParent(input, dependencies) {
 	};
 	try {
 		owner.completionCustody = params.completionScope ? await dependencies.runtime.captureAgentHarnessCompletionCustody(params.completionScope) : void 0;
+		await params.assertCurrentAsync?.();
 		if (!isCurrent() || state.requesterSessionKey !== requesterSessionKey || owner.completionCustody && !owner.completionCustody.isCurrent()) throw new Error("Codex native subagent parent registration is no longer current");
 		params.assertCurrent?.();
 		params.modelSource?.assertCurrent();
 		if (Object.hasOwn(params, "modelSource")) owner.modelSource = createNativeModelSourceOwner(params.modelSource, state, () => {
-			if (!isCurrent()) throw new Error("Codex native model source owner is no longer current");
+			if (owner.descendantsCancelled || !isCurrent()) throw new Error("Codex native model source owner is no longer current");
 		}, () => dependencies.prune(registeredState));
 		if (owner.unqualifiedModelExecution && params.modelSource) {
 			rootModelBinding = params.modelSource.bindModelExecution?.(void 0);
@@ -2038,6 +2043,8 @@ async function registerNativeSubagentParent(input, dependencies) {
 			if (rootModelBinding.signal.aborted) cancelUnqualifiedRoot();
 		}
 		params.assertCurrent?.();
+		if (owner.descendantsCancelled) throw new Error("Codex parent registration was cancelled before admission");
+		dependencies.assertAdmissionCurrent?.(params);
 		state.completionScope ??= params.completionScope;
 		state.historyOwner ??= params.historyOwner;
 		state.submissionStore ??= params.submissionStore;
@@ -2046,7 +2053,6 @@ async function registerNativeSubagentParent(input, dependencies) {
 		state.owners.set(ownerKey, owner);
 		state.preparing = void 0;
 		dependencies.deliverDetached(state);
-		dependencies.submissions.restore(state, owner);
 	} catch (error) {
 		releaseRootModelBinding();
 		state.owners.delete(ownerKey);
@@ -2055,10 +2061,11 @@ async function registerNativeSubagentParent(input, dependencies) {
 		else params.modelSource?.release();
 		throw error;
 	} finally {
-		state.pendingRegistrations -= 1;
+		state.pendingRegistrations?.delete(owner);
 		dependencies.prune(registeredState);
+		registrationSettled.resolve();
 	}
-	const ready = dependencies.assignments.restore(state, owner);
+	const ready = dependencies.submissions.restore(state, owner).then(() => dependencies.assignments.restore(state, owner));
 	let registered = true;
 	let settlement;
 	return {
@@ -2095,6 +2102,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 			dependencies.clearAdmissions();
 			notifyNativeModelSourceWaiters(registeredState);
 		},
+		listPendingChildren: () => registered && dependencies.states.get(parentThreadId) === registeredState ? dependencies.pendingChildren(registeredState) : [],
 		unregister: () => {
 			if (!registered) return settlement ?? Promise.resolve();
 			registered = false;
@@ -2122,6 +2130,7 @@ async function registerNativeSubagentParent(input, dependencies) {
 				await Promise.allSettled([dependencies.submissions.drain(registeredState)]);
 				await Promise.allSettled([dependencies.assignments.drain(registeredState)]);
 				dependencies.prune(registeredState);
+				if (params.submissionStore !== registeredState.submissionStore) params.submissionStore?.release?.();
 			})();
 			return settlement;
 		}
@@ -2391,25 +2400,20 @@ function captureSubmissionPredecessor(params) {
 //#region extensions/codex/src/app-server/native-subagent-submission-history.ts
 async function readCodexNativeSubmissionTurn(receipt, dependencies) {
 	if (!dependencies.prepareReceiver()) return;
-	const revision = dependencies.recovery.retainThreadStatusRevision(receipt.childThreadId);
-	try {
-		const response = await dependencies.client.request("thread/read", {
-			threadId: receipt.childThreadId,
-			includeTurns: true
-		}, { timeoutMs: 3e4 });
-		if (!revision.isCurrent() || !dependencies.isCurrent()) return;
-		const thread = isJsonObject(response.thread) ? response.thread : void 0;
-		if (readStringField(thread, "id") !== receipt.childThreadId || readThreadParentThreadId(thread) !== dependencies.parentThreadId()) return;
-		const turns = (Array.isArray(thread?.turns) ? thread.turns : []).flatMap((turn) => isJsonObject(turn) ? [turn] : []);
-		const predecessorIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.predecessorNativeTurnId);
-		const turnIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.submissionId);
-		if (predecessorIndex < 0 || turnIndex <= predecessorIndex || !["completed", "failed"].includes(readStringField(turns[predecessorIndex], "status") ?? "")) return;
-		const previous = dependencies.currentChild();
-		if (previous && !previous.terminal && previous.nativeTurnId !== receipt.submissionId) await dependencies.recovery.reconcileRegisteredChild(previous);
-		return dependencies.isCurrent() ? turns[turnIndex] : void 0;
-	} finally {
-		revision.release();
-	}
+	const response = await dependencies.client.request("thread/read", {
+		threadId: receipt.childThreadId,
+		includeTurns: true
+	}, { timeoutMs: 3e4 });
+	if (!dependencies.isCurrent()) return;
+	const thread = isJsonObject(response.thread) ? response.thread : void 0;
+	if (readStringField(thread, "id") !== receipt.childThreadId || readThreadParentThreadId(thread) !== dependencies.parentThreadId()) return;
+	const turns = (Array.isArray(thread?.turns) ? thread.turns : []).flatMap((turn) => isJsonObject(turn) ? [turn] : []);
+	const predecessorIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.predecessorNativeTurnId);
+	const turnIndex = turns.findIndex((turn) => readStringField(turn, "id") === receipt.submissionId);
+	if (predecessorIndex < 0 || turnIndex <= predecessorIndex || !["completed", "failed"].includes(readStringField(turns[predecessorIndex], "status") ?? "")) return;
+	const previous = dependencies.currentChild();
+	if (previous && !previous.terminal && previous.nativeTurnId !== receipt.submissionId) await dependencies.recovery.reconcileRegisteredChild(previous);
+	return dependencies.isCurrent() ? turns[turnIndex] : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-subagent-submission-owner.ts
@@ -2467,11 +2471,17 @@ var CodexNativeSubagentSubmissionOwner = class {
 	bind(state, turnId) {
 		for (const call of this.calls.get(state)?.values() ?? []) if (call.parentTurnId === turnId && call.submissionId) this.modelInputs.acceptNativeSubmission(state, call);
 	}
-	restore(state, owner) {
+	async restore(state, owner) {
+		const custody = owner.completionCustody?.retain();
 		try {
-			for (const receipt of state.submissionStore?.read() ?? []) this.capture(state, receipt, void 0, false, owner.completionCustody);
+			const receipts = await state.submissionStore?.read() ?? [];
+			await state.submissionStore?.assertCurrentAsync();
+			if (this.disposed || !this.isCurrent(state) || custody && !custody.isCurrent()) return;
+			for (const receipt of receipts) this.capture(state, receipt, void 0, false, custody);
 		} catch (error) {
 			embeddedAgentLog.warn("Cannot recover native follow-up submission receipts", { error: formatErrorMessage$1(error) });
+		} finally {
+			custody?.release();
 		}
 	}
 	observeTurn(threadId, turn) {
@@ -2546,13 +2556,14 @@ var CodexNativeSubagentSubmissionOwner = class {
 		entries.set(key, custody);
 		this.pending.set(state, entries);
 		if (persist) this.dependencies.recordPendingAssignment(state, receipt, this.nativeParentThreadId(state, receipt.childThreadId));
-		if (persist && state.submissionStore) custody.recorded = this.track(state, (async () => {
-			try {
+		if (persist && state.submissionStore) {
+			custody.recorded = this.track(state, (async () => {
 				if (!await state.submissionStore.record(receipt, () => this.dependencies.assertPersistenceCurrent(state))) throw new Error("Native submission binding changed before receipt persistence.");
-			} catch (error) {
+			})());
+			custody.recorded.catch((error) => {
 				embeddedAgentLog.warn("Accepted native follow-up lost restart protection; retaining local observation", { error: formatErrorMessage$1(error) });
-			}
-		})());
+			});
+		}
 		const observed = this.modelInputs.readObservedSubmissionTurn(state, receipt.childThreadId, receipt.submissionId);
 		if (observed) this.promote(state, custody, observed);
 		if (custody.phase !== "promoting") this.reconcile(state, custody);
@@ -2567,7 +2578,7 @@ var CodexNativeSubagentSubmissionOwner = class {
 			if (custody.phase === "settled" || codexNativeSubagentRunId(custody.receipt.childThreadId, custody.receipt.submissionId) !== child.runId) continue;
 			custody.phase = "settled";
 			const settlement = (async () => {
-				await custody.recorded;
+				await custody.recorded.catch(() => {});
 				try {
 					if ((child.nativeCompletionDelivered || child.subscriptionClosed && !child.pendingCompletion) && state.submissionStore) await state.submissionStore.consume(custody.receipt, () => this.dependencies.assertPersistenceCurrent(state));
 				} catch (error) {
@@ -2579,6 +2590,24 @@ var CodexNativeSubagentSubmissionOwner = class {
 			this.track(state, settlement);
 		}
 	}
+	settleCancelled(state, child, assertCurrent) {
+		const settlement = async () => {
+			const assertAdmission = () => {
+				this.dependencies.assertPersistenceCurrent(state);
+				assertCurrent();
+			};
+			assertAdmission();
+			for (const custody of this.pending.get(state)?.values() ?? []) {
+				if (codexNativeSubagentRunId(custody.receipt.childThreadId, custody.receipt.submissionId) !== child.runId) continue;
+				await custody.recorded;
+				assertAdmission();
+				if (state.submissionStore && !await state.submissionStore.consume(custody.receipt, assertAdmission)) throw new Error("Cancelled native follow-up receipt was not acknowledged.");
+				this.finishCustody(state, custody);
+				assertAdmission();
+			}
+		};
+		return this.track(state, settlement());
+	}
 	async reconcile(state, custody) {
 		if (!this.isObserving(state, custody)) return;
 		try {
@@ -2726,11 +2755,8 @@ function isCodexCommandBearingToolCall(name, args) {
 	const normalizedName = name?.trim().toLowerCase();
 	return normalizedName === "exec" || normalizedName === "bash" || normalizedName === "shell" || typeof args?.command === "string" && args.command.trim().length > 0;
 }
-function sanitizeCodexAgentEventRecord(value) {
-	return sanitizeToolArgs(value);
-}
-function sanitizeCodexToolArguments(value) {
-	return isJsonObject(value) ? sanitizeCodexAgentEventRecord(value) : void 0;
+function asCodexToolArguments(value) {
+	return isJsonObject(value) ? value : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-items.ts
@@ -2773,13 +2799,13 @@ function shouldSuppressChannelProgressForItem(item) {
 	return isProjectedNativeToolItem(item) || item.type === "dynamicToolCall";
 }
 function itemToolArgs(item) {
-	if (item.type === "commandExecution") return sanitizeCodexAgentEventRecord({
+	if (item.type === "commandExecution") return {
 		command: item.command,
 		...typeof item.cwd === "string" ? { cwd: item.cwd } : {}
-	});
-	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({ changes: itemFileChanges(item, true) });
+	};
+	if (item.type === "fileChange") return { changes: itemFileChanges(item, true) };
 	if (item.type === "webSearch") return webSearchToolArgs(item);
-	if (item.type === "dynamicToolCall" || item.type === "mcpToolCall") return sanitizeCodexToolArguments(item.arguments);
+	if (item.type === "dynamicToolCall" || item.type === "mcpToolCall") return asCodexToolArguments(item.arguments);
 }
 function isCommandBearingToolItem(item, args) {
 	if (item.type === "commandExecution") return true;
@@ -2788,29 +2814,29 @@ function isCommandBearingToolItem(item, args) {
 function webSearchToolArgs(item) {
 	const args = projectCodexWebSearchItem(item);
 	if (!args.query && !args.url && !args.pattern) args.queryUnavailable = true;
-	return sanitizeCodexAgentEventRecord(args);
+	return args;
 }
 function itemToolResult(item) {
-	if (item.type === "commandExecution") return sanitizeCodexAgentEventRecord({
+	if (item.type === "commandExecution") return {
 		status: item.status,
 		exitCode: item.exitCode,
 		durationMs: item.durationMs
-	});
-	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({
+	};
+	if (item.type === "fileChange") return {
 		status: item.status,
 		changes: itemFileChanges(item)
-	});
-	if (item.type === "mcpToolCall") return sanitizeCodexAgentEventRecord({
+	};
+	if (item.type === "mcpToolCall") return {
 		status: item.status,
 		durationMs: item.durationMs,
 		...item.error ? { error: item.error } : {},
 		...item.result ? { result: item.result } : {}
-	});
-	if (item.type === "webSearch") return sanitizeCodexAgentEventRecord({
+	};
+	if (item.type === "webSearch") return {
 		status: itemStatus(item),
 		...typeof item.durationMs === "number" ? { durationMs: item.durationMs } : {},
 		...webSearchToolArgs(item)
-	});
+	};
 }
 function itemFileChangeRecords(item) {
 	const changes = item.changes;
@@ -3359,7 +3385,7 @@ var CodexToolTranscriptProjection = class {
 		this.recordToolCall({
 			id: params.callId,
 			name: params.tool,
-			arguments: sanitizeCodexToolArguments(params.arguments)
+			arguments: asCodexToolArguments(params.arguments)
 		});
 	}
 	recordDynamicToolResult(params, resultContentSource) {
@@ -4344,9 +4370,12 @@ var Monitor = class {
 		this.childStates = /* @__PURE__ */ new Map();
 		this.knownChildren = /* @__PURE__ */ new Map();
 		this.childThreadIdsByAgentPath = /* @__PURE__ */ new Map();
+		this.cancellationReservations = /* @__PURE__ */ new Map();
+		this.cancellationTurnWaiters = /* @__PURE__ */ new Map();
 		this.parentThreadRetentions = /* @__PURE__ */ new Map();
 		this.disposed = false;
 		this.interruptModelExecution = options.interruptModelExecution;
+		this.interruptChildAndWait = options.interruptChildAndWait;
 		this.admissionCustody = new CodexNativeSubagentAdmissionCustody({
 			parentState: (id) => this.parentStates.get(id),
 			knownChild: (id) => this.knownChildren.get(id),
@@ -4367,7 +4396,7 @@ var Monitor = class {
 			captureForget: options.captureChildThreadForget,
 			releaseDirectChild: releaseNativeDirectChild,
 			clearRecoveryTimers: (child) => this.recovery.clearRecoveryTimers(child),
-			markTerminalRevision: (id) => this.recovery.markTerminalRevision(id),
+			markTerminalThread: (id, parentId) => this.recovery.markTerminalThread(id, parentId),
 			unregisterChild: (child) => this.unregisterChild(child, { retainSubscription: false }),
 			releaseClientRetentionIfIdle: () => this.releaseClientRetentionIfIdle(),
 			pruneParent: (state) => this.pruneParentIfUnused(state)
@@ -4402,7 +4431,6 @@ var Monitor = class {
 		this.recovery = new CodexNativeSubagentRecoveryCoordinator({
 			isDisposed: () => this.disposed,
 			isRegisteredChild: (child) => this.childStates.get(child.runId) === child,
-			currentChild: (id) => this.currentChild(id),
 			parentState: (id) => this.parentStates.get(id),
 			reconcileChildState: (child) => this.reconcileChildState(child),
 			processCompletion: (state, child, completion, eventAt) => this.processCompletion(state, child, completion, eventAt),
@@ -4474,23 +4502,15 @@ var Monitor = class {
 				state.assignmentStore?.assertCurrent();
 			},
 			isCurrent: (state) => this.isCurrentParent(state),
-			readHistory: async (assignment) => {
-				const revision = this.recovery.retainThreadStatusRevision(assignment.childThreadId);
-				try {
-					const history = await this.historyRecovery.read({
-						...assignment,
-						nativeTurnId: assignment.nativeTurnId
-					}, {
-						resumeInterrupted: assignment.recordedCompletion === void 0,
-						predecessorNativeTurnId: assignment.submission?.predecessorNativeTurnId,
-						recordedCompletion: assignment.recordedCompletion,
-						initialAssignment: !readCodexNativeSubagentRunId(assignment.runId)?.turnId
-					});
-					return revision.isCurrent() ? history : void 0;
-				} finally {
-					revision.release();
-				}
-			},
+			readHistory: (assignment) => this.historyRecovery.read({
+				...assignment,
+				nativeTurnId: assignment.nativeTurnId
+			}, {
+				resumeInterrupted: assignment.recordedCompletion === void 0,
+				predecessorNativeTurnId: assignment.submission?.predecessorNativeTurnId,
+				recordedCompletion: assignment.recordedCompletion,
+				initialAssignment: !readCodexNativeSubagentRunId(assignment.runId)?.turnId
+			}),
 			restore: async (state, assignment, recovery, custody) => {
 				const existing = this.childStates.get(assignment.runId);
 				if (existing) {
@@ -4551,14 +4571,15 @@ var Monitor = class {
 		}
 		const parents = [...this.parentStates.values()];
 		for (const state of parents) notifyNativeModelSourceWaiters(state);
-		if (!parents.some((state) => this.assignments.hasWrites(state) || this.submissions.hasCustody(state))) {
-			this.finishDisposal();
-			return this.disposal = Promise.resolve();
-		}
+		const pending = parents.some((state) => this.assignments.hasWrites(state) || this.submissions.hasCustody(state));
+		if (!pending) this.finishDisposal();
 		this.disposal = (async () => {
 			await Promise.allSettled(parents.flatMap((state) => [this.submissions.drain(state), this.assignments.drain(state)]));
-			this.finishDisposal();
-			await Promise.allSettled(parents.flatMap((state) => [this.submissions.drain(state), this.assignments.drain(state)]));
+			if (pending) {
+				this.finishDisposal();
+				await Promise.allSettled(parents.flatMap((state) => [this.submissions.drain(state), this.assignments.drain(state)]));
+			}
+			for (const state of parents) if (this.parentStates.get(state.parentThreadId) !== state) state.submissionStore?.release?.();
 		})();
 		return this.disposal;
 	}
@@ -4596,6 +4617,9 @@ var Monitor = class {
 			states: this.parentStates,
 			isClosed: () => this.disposed,
 			isRetired: (state) => this.retiredParentStates.has(state),
+			assertAdmissionCurrent: (input) => {
+				for (const { params: request } of this.cancellationReservations.values()) if (input.agentId === request.agentId && input.requesterSessionKey === request.sessionKey && input.historyOwner?.sessionId === request.sessionId && input.historyOwner?.lifecycleRevision === request.lifecycleRevision && request.acceptsRequest(input.requestCustody)) throw new Error("Codex descendant cancellation is still settling");
+			},
 			runtime: this.runtime,
 			submissions: this.submissions,
 			assignments: this.assignments,
@@ -4604,9 +4628,170 @@ var Monitor = class {
 			drainAdmissions: (state, owner, turnId) => this.drainPendingChildAdmissionEvidence(state, owner, turnId, true),
 			clearAdmissions: () => this.clearUnconsumablePendingChildAdmissionEvidence(),
 			prune: (state) => this.pruneParentIfUnused(state),
+			pendingChildren: (state) => this.listPendingChildren(state),
 			interruptModelExecution: this.interruptModelExecution
 		});
 	}
+	async withDescendantCancellation(params, run) {
+		params.assertCurrent();
+		const parent = this.parentStates.get(params.parentThreadId);
+		if (!parent) return run(async () => ({
+			killed: 0,
+			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 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 (!matches(parent)) throw new Error("Codex descendant cancellation requester generation changed");
+		const states = [...this.parentStates.values()].filter(matches);
+		const assertCurrent = () => {
+			params.assertCurrent();
+			if (this.disposed || states.some((state) => !this.isCurrentParent(state) || !matches(state) || !this.cancellationReservations.has(state))) throw new Error("Codex descendant cancellation reservation changed");
+			for (const state of states) state.assignmentStore?.assertCurrent();
+		};
+		if (states.some((state) => this.cancellationReservations.has(state))) throw new Error("Codex descendants already have a cancellation owner");
+		const reservation = {
+			params,
+			accepted: false,
+			lateAdmission: false
+		};
+		for (const state of states) this.cancellationReservations.set(state, reservation);
+		let consumed = false;
+		try {
+			const cancellationResult = await run(async () => {
+				assertCurrent();
+				if (consumed) throw new Error("Codex descendant cancellation was already consumed");
+				consumed = true;
+				reservation.accepted = true;
+				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 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);
+					if (pending.modelSource) owners.add(pending.modelSource.owner);
+				}
+				for (const entries of this.admissionCustody.entries.values()) for (const evidence of entries) if (evidence.kind === "interaction" && states.some((state) => state.parentThreadId === evidence.parentThreadId)) {
+					if (evidence.owner) owners.add(evidence.owner);
+					if (evidence.modelOwner) owners.add(evidence.modelOwner);
+					if (evidence.modelSource) owners.add(evidence.modelSource.owner);
+				}
+				for (const child of selected) {
+					if (child.modelExecution) owners.add(child.modelExecution.owner);
+					if (child.directOwner) owners.add(child.directOwner);
+				}
+				for (const owner of owners) if (matchesOwner(owner)) owner.descendantsCancelled = true;
+				const results = await Promise.allSettled(selected.map(async (child) => {
+					const state = states.find((candidate) => candidate.parentThreadId === child.parentThreadId);
+					if (!state) throw new Error("Codex descendant requester owner changed");
+					let turnId = child.nativeTurnId;
+					const requesterTurnRunId = child.requesterTurnRunId;
+					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");
+					};
+					assertChild();
+					if (!child.terminal) {
+						child.cancellationRequested = true;
+						if (!turnId) {
+							const observed = createDeferred();
+							this.cancellationTurnWaiters.set(child, () => observed.resolve());
+							try {
+								if (!child.nativeTurnId && !child.terminalHandling) await waitForNativeCancellationWork(this.client, observed.promise, deadline);
+							} finally {
+								this.cancellationTurnWaiters.delete(child);
+							}
+							assertCurrent();
+							if (child.requesterTurnRunId !== requesterTurnRunId) throw new Error("Codex descendant requester changed while awaiting its native turn");
+							turnId = child.nativeTurnId;
+						}
+						if (!child.terminalHandling) {
+							assertChild();
+							if (child.nativeTurnState === "interrupted") child.terminalHandling = this.cancelInterruptedChild(state, child);
+							else {
+								const remaining = deadline - performance.now();
+								if (!turnId || !this.interruptChildAndWait || remaining <= 0) throw new Error("Codex descendant has no exact cancellable native turn");
+								const terminal = await this.interruptChildAndWait(child.childThreadId, turnId, assertChild, remaining);
+								assertCurrent();
+								if (!terminal) throw new Error("Codex descendant interruption did not reach its native terminal");
+							}
+						}
+						const terminalHandling = child.terminalHandling;
+						if (!terminalHandling && !child.terminal) throw new Error("Codex descendant terminal has not reached its completion owner");
+						await terminalHandling;
+						assertCurrent();
+					}
+					await this.completionDelivery.join(child);
+					assertCurrent();
+					const cancelled = child.cancellationRequested && child.pendingCompletion?.status === "cancelled";
+					if (cancelled && this.childStates.get(child.runId) === child) {
+						assertChild();
+						await this.submissions.settleCancelled(state, child, assertChild);
+						assertChild();
+						await this.assignments.settleCancelled(state, child, assertChild);
+						assertChild();
+						this.unregisterChild(child);
+					}
+					if (this.childStates.get(child.runId) === child) throw new Error("Codex descendant completion delivery remains unsettled");
+					if (!cancelled) {
+						await this.assignments.drain(state);
+						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");
+					return {
+						killed: cancelled ? 1 : 0,
+						cancelledRequesters: cancelled && requesterTurnRunId ? [{
+							agentId: params.agentId,
+							sessionKey: params.sessionKey,
+							sessionId: params.sessionId,
+							lifecycleRevision: params.lifecycleRevision,
+							requesterTurnRunId
+						}] : []
+					};
+				}));
+				const completedRegistrations = await registrationResults;
+				const failed = [...results, ...completedRegistrations].flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+				try {
+					assertCurrent();
+				} catch (error) {
+					failed.push(error);
+				}
+				const pending = [...this.knownChildren.values()].some((known) => states.includes(known.parent) && known.pendingTurns.some((turn) => {
+					return (turn.modelSource?.owner ?? turn.admittedOwner)?.descendantsCancelled && turn.state !== "completed" && turn.state !== "failed";
+				}));
+				if (reservation.lateAdmission || pending) failed.push(/* @__PURE__ */ new Error("Codex descendant admission remains unsettled after cancellation"));
+				return results.reduce((total, result) => {
+					if (result.status === "fulfilled") {
+						total.killed += result.value.killed;
+						total.cancelledRequesters.push(...result.value.cancelledRequesters);
+					}
+					return total;
+				}, {
+					killed: 0,
+					cancelledRequesters: [],
+					...failed.length ? { errors: failed } : {}
+				});
+			});
+			assertCurrent();
+			return cancellationResult;
+		} finally {
+			for (const state of states) {
+				this.cancellationReservations.delete(state);
+				this.pruneParentIfUnused(state);
+			}
+		}
+	}
 	async captureModelSource(request) {
 		const capture = await captureNativeModelSource(request, {
 			parents: this.parentStates,
@@ -4648,7 +4833,8 @@ var Monitor = class {
 	}
 	async persistModelAssignment(request, capture) {
 		const known = this.knownChildren.get(request.threadId);
-		if (!known?.parent.assignmentStore) return;
+		const store = known?.parent.assignmentStore;
+		if (!known || !store) return;
 		const state = known.parent;
 		const child = this.currentChild(request.threadId);
 		const current = child?.nativeTurnId === request.turnId ? child : void 0;
@@ -4668,6 +4854,7 @@ var Monitor = class {
 			nativeParentThreadId: known.nativeParentThreadId,
 			owner
 		}, assertCurrent);
+		await store.assertCurrentAsync();
 		assertCurrent();
 	}
 	resolveModelThreadId(turnId) {
@@ -4681,7 +4868,6 @@ var Monitor = class {
 			knownChildren: this.knownChildren,
 			isCurrent: (state) => this.isCurrentParent(state),
 			interruptModelExecution: this.interruptModelExecution,
-			retainTargetRevision: (threadId) => this.recovery.retainThreadStatusRevision(threadId),
 			currentModelExecution: (threadId) => currentNativeModelExecution(threadId, this.parentStates, this.knownChildren, this.childStates),
 			admissions: this.admissionCustody.entries,
 			canPrepareReceiver: (state, threadId) => this.canPrepareReceiverChild(state, threadId),
@@ -4727,8 +4913,14 @@ var Monitor = class {
 	async handleNotification(notification) {
 		if (this.disposed) return;
 		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		const revisedThreadId = readStringField(params, "threadId") ?? (isJsonObject(params?.thread) ? readStringField(params.thread, "id") : void 0);
-		if (revisedThreadId && (RECOVERY_REVISION_NOTIFICATION_METHODS.has(notification.method) || notification.method === "thread/closed")) this.recovery.observeRevision(revisedThreadId);
+		const startedThread = isJsonObject(params?.thread) ? params.thread : void 0;
+		const threadId = readStringField(params, "threadId")?.trim() ?? readStringField(startedThread, "id")?.trim();
+		const threadStatus = isJsonObject(params?.status) ? normalizeIdentifier(readStringField(params.status, "type")) : void 0;
+		const loadOwner = threadId ? this.parentStates.get(threadId) ?? this.knownChildren.get(threadId) : void 0;
+		if (loadOwner && (notification.method === "thread/started" || notification.method === "thread/closed" || notification.method === "thread/status/changed" && threadStatus)) {
+			const loaded = notification.method !== "thread/closed" && threadStatus !== "notloaded";
+			if (loadOwner.nativeLoad?.loaded !== loaded) loadOwner.nativeLoad = { loaded };
+		}
 		if (notification.method === "thread/closed") {
 			const closedThreadId = readStringField(params, "threadId");
 			if (closedThreadId) this.releasePendingModelInputs(closedThreadId);
@@ -4753,13 +4945,9 @@ var Monitor = class {
 			}
 		}
 		const notificationState = this.resolveNotificationState(notification);
-		const startedThread = isJsonObject(params?.thread) ? params.thread : void 0;
-		const threadId = readStringField(params, "threadId")?.trim() ?? readStringField(startedThread, "id")?.trim();
-		const threadStatus = isJsonObject(params?.status) ? normalizeIdentifier(readStringField(params.status, "type")) : void 0;
 		const parent = threadId ? this.parentStates.get(threadId) : void 0;
 		if (parent) observeNativeParentTurn(parent, notification);
-		const tracksRecoveryRevision = Boolean(threadId && this.recovery.hasRevision(threadId));
-		if (!notificationState && (!threadId || !this.parentStates.has(threadId) && !this.currentChild(threadId) && !tracksRecoveryRevision)) return;
+		if (!notificationState && (!threadId || !this.parentStates.has(threadId) && !this.currentChild(threadId))) return;
 		const notificationTurnId = readStringField(params, "turnId") ?? (isJsonObject(params?.turn) ? readStringField(params.turn, "id") : void 0);
 		const pendingTurns = threadId ? this.knownChildren.get(threadId)?.pendingTurns : void 0;
 		const pendingNativeTurn = pendingTurns?.some((pending) => !notificationTurnId || pending.turnId === notificationTurnId);
@@ -4823,26 +5011,38 @@ var Monitor = class {
 		this.recovery.clearRecoveryTimers(childState);
 		this.releaseClientRetentionIfIdle();
 	}
-	async handleChildTurnCompletion(notification, childState) {
-		if (notification.method !== "turn/completed") return;
+	handleChildTurnCompletion(notification, childState) {
+		if (notification.method !== "turn/completed") return Promise.resolve();
 		const params = isJsonObject(notification.params) ? notification.params : void 0;
 		const childThreadId = readStringField(params, "threadId")?.trim();
 		const state = childState ? this.parentStates.get(childState.parentThreadId) : void 0;
 		const turn = isJsonObject(params?.turn) ? params.turn : void 0;
-		if (!state || !childState || childState.childThreadId !== childThreadId || !turn || childState.terminal) return;
+		if (!state || !childState || childState.childThreadId !== childThreadId || !turn || childState.terminal) return Promise.resolve();
+		const turnId = readStringField(turn, "id");
+		if (childState.nativeTurnId && turnId !== childState.nativeTurnId) return Promise.resolve();
+		if (childState.terminalHandling) return childState.terminalHandling;
+		const handling = this.completeChildTurn(state, childState, turn);
+		childState.terminalHandling = handling;
+		this.cancellationTurnWaiters.get(childState)?.();
+		handling.finally(() => {
+			if (childState.terminalHandling === handling && !childState.cancellationRequested) childState.terminalHandling = void 0;
+		}).catch(() => {});
+		return handling;
+	}
+	async completeChildTurn(state, childState, turn) {
 		const turnId = readStringField(turn, "id");
-		if (childState.nativeTurnId && turnId !== childState.nativeTurnId) return;
 		const status = normalizeIdentifier(readStringField(turn, "status"));
 		if (status === "interrupted") {
 			this.removePendingSpawnAdmissionEvidenceForChild(childState.childThreadId);
 			this.rejectPendingDirectChild(state, childState.childThreadId, "Codex child turn interrupted");
-			this.settleResumableChild(childState);
+			if (childState.cancellationRequested) await this.cancelInterruptedChild(state, childState);
+			else this.settleResumableChild(childState);
 			return;
 		}
 		if (status === "completed" || status === "failed") {
 			const latestTurnId = this.knownChildren.get(childState.childThreadId)?.turnId;
 			if (!latestTurnId || latestTurnId === turnId) {
-				this.recovery.markTerminalRevision(childState.childThreadId);
+				this.recovery.markTerminalThread(childState.childThreadId, state.parentThreadId);
 				this.rejectPendingDirectChild(state, childState.childThreadId, "Codex child turn completed");
 				this.removePendingSpawnAdmissionEvidenceForChild(childState.childThreadId);
 			}
@@ -4853,6 +5053,14 @@ var Monitor = class {
 		if (!completion) return;
 		await this.processObservedCompletion(state, childState, completion);
 	}
+	cancelInterruptedChild(state, child) {
+		return this.processCompletion(state, child, {
+			childThreadId: child.childThreadId,
+			status: "cancelled",
+			statusLabel: "interrupted",
+			result: "Cancelled by the requester."
+		});
+	}
 	async reconcileChildThread(childThreadIdInput) {
 		const childState = this.currentChild(childThreadIdInput.trim());
 		return childState ? this.recovery.reconcileRegisteredChild(childState) : false;
@@ -4896,45 +5104,40 @@ var Monitor = class {
 	async reconcileChildState(childState) {
 		const state = this.parentStates.get(childState.parentThreadId);
 		if (!state) return false;
-		const statusRead = this.recovery.retainThreadStatusRevision(childState.childThreadId);
-		try {
-			const recovery = await this.historyRecovery.read(childState, {
-				resumeInterrupted: !childState.terminal,
-				initialAssignment: childState.recoverInitialAssignment,
-				recordedCompletion: childState.pendingCompletion
+		const recovery = await this.historyRecovery.read(childState, {
+			resumeInterrupted: !childState.terminal,
+			initialAssignment: childState.recoverInitialAssignment,
+			recordedCompletion: childState.pendingCompletion
+		});
+		if (this.childStates.get(childState.runId) !== childState || !this.isCurrentParent(state)) return false;
+		if (childState.completionCustody && !childState.completionCustody.isCurrent()) {
+			this.unregisterChild(childState);
+			return false;
+		}
+		if (recovery.parentThreadId && recovery.parentThreadId !== childState.nativeParentThreadId) {
+			embeddedAgentLog.warn("Codex native subagent parent did not match monitor state", {
+				childThreadId: childState.childThreadId,
+				expectedParentThreadId: childState.nativeParentThreadId,
+				actualParentThreadId: recovery.parentThreadId
 			});
-			if (!statusRead.isCurrent() || this.childStates.get(childState.runId) !== childState || !this.isCurrentParent(state)) return false;
-			if (childState.completionCustody && !childState.completionCustody.isCurrent()) {
-				this.unregisterChild(childState);
-				return false;
-			}
-			if (recovery.parentThreadId && recovery.parentThreadId !== childState.nativeParentThreadId) {
-				embeddedAgentLog.warn("Codex native subagent parent did not match monitor state", {
-					childThreadId: childState.childThreadId,
-					expectedParentThreadId: childState.nativeParentThreadId,
-					actualParentThreadId: recovery.parentThreadId
-				});
-				this.unregisterChild(childState);
-				return false;
-			}
-			if (recovery.agentPath) this.registerAgentPath(state, childState.childThreadId, recovery.agentPath);
-			this.recordRecoveredChildTurn(state, childState, recovery);
-			if (recovery.threadState === "active") {
-				this.observeActiveChild(childState);
-				return false;
-			}
-			if (recovery.threadState === "other") this.recovery.clearSystemErrorFallback(childState);
-			if (recovery.resumable) {
-				this.settleResumableChild(childState);
-				return false;
-			}
-			const completion = this.processRecoveredCompletion(state, childState, recovery);
-			if (!completion) return false;
-			await completion;
-			return true;
-		} finally {
-			statusRead.release();
+			this.unregisterChild(childState);
+			return false;
+		}
+		if (recovery.agentPath) this.registerAgentPath(state, childState.childThreadId, recovery.agentPath);
+		this.recordRecoveredChildTurn(state, childState, recovery);
+		if (recovery.threadState === "active") {
+			this.observeActiveChild(childState);
+			return false;
 		}
+		if (recovery.threadState === "other") this.recovery.clearSystemErrorFallback(childState);
+		if (recovery.resumable) {
+			this.settleResumableChild(childState);
+			return false;
+		}
+		const completion = this.processRecoveredCompletion(state, childState, recovery);
+		if (!completion) return false;
+		await completion;
+		return true;
 	}
 	processRecoveredCompletion(state, child, recovery) {
 		const completion = recovery.completion;
@@ -4990,7 +5193,7 @@ var Monitor = class {
 			...acceptedCompletion,
 			completedAt: eventAt
 		};
-		this.recovery.markTerminalRevision(childState.childThreadId);
+		this.recovery.markTerminalThread(childState.childThreadId, state.parentThreadId);
 		releaseNativeDirectChild(childState);
 		this.recovery.clearRecoveryTimers(childState);
 		this.completionDelivery.applyReceipts(state, childState.deliveryReceipts.record(childState.runId, this.knownChildren.get(childState.childThreadId)?.agentPaths ?? [childState.childThreadId], acceptedCompletion.result));
@@ -5017,13 +5220,24 @@ var Monitor = class {
 		for (const agentPath of known.agentPaths) this.registerAgentPath(state, threadId, agentPath);
 		return true;
 	}
+	childAdmissionCancelled(state, owner, history = state.historyOwner) {
+		const reservation = this.cancellationReservations.get(state);
+		const requestMatches = reservation?.params.acceptsRequest(owner?.requestCustody) === true;
+		const generationMatches = (owner ? owner.requesterSessionId : history?.sessionId) === reservation?.params.sessionId && (owner ? owner.requesterLifecycleRevision : history?.lifecycleRevision) === reservation?.params.lifecycleRevision;
+		if (owner?.descendantsCancelled || reservation?.accepted && generationMatches && requestMatches) {
+			if (reservation) reservation.lateAdmission = true;
+			return true;
+		}
+		return false;
+	}
 	registerChildThread(state, childInput, options = {}) {
 		const parentThreadId = state.parentThreadId;
 		const preparedAssignment = typeof childInput === "string" ? void 0 : childInput;
 		const childThreadId = typeof childInput === "string" ? childInput.trim() : childInput.childThreadId;
 		if (!parentThreadId || !childThreadId || this.disposed || state.preparing) return;
+		if (this.childAdmissionCancelled(state, options.directOwner, options.historyOwner)) return;
 		const claimDirectChild = options.directOwner?.claimDirectChild;
-		if (claimDirectChild && this.recovery.isTerminalRevision(childThreadId)) return;
+		if (claimDirectChild && this.recovery.isTerminalThread(childThreadId)) return;
 		if (!preparedAssignment && !this.prepareReceiverChild(state, childThreadId)) return;
 		const known = this.knownChildren.get(childThreadId);
 		const observedTurns = options.observedTurns ?? [];
@@ -5053,6 +5267,7 @@ var Monitor = class {
 			}
 			childState = {
 				runId,
+				requestCustody: options.directOwner?.requestCustody,
 				nativeTurnId: assignment.nativeTurnId,
 				nativeTurnState: observedTurns.find((turn) => turn.turnId === assignment.nativeTurnId)?.state,
 				deliveryReceipts: this.resolveChildReceiptOwner(state, childThreadId),
@@ -5065,12 +5280,10 @@ var Monitor = class {
 				terminal: false,
 				nativeCompletionDelivered: false,
 				settledWithoutCompletion: false,
-				completionDeliveryAttempt: 0,
-				deliveringCompletion: false
+				completionDeliveryAttempt: 0
 			};
 			this.childStates.set(runId, childState);
 			if (!known || !known.assignment.nativeTurnId && assignment.nativeTurnId && observedTurns.length > 0) this.restoreKnownChild(state, assignment, observedTurns);
-			this.recovery.seedRevision(childThreadId, parentThreadId);
 		}
 		if (known && options.admitAssignment) {
 			const previousRunId = known.assignment.runId;
@@ -5082,6 +5295,8 @@ var Monitor = class {
 		}
 		if (claimDirectChild && !childState.terminal && !childState.settledWithoutCompletion && !childState.releaseDirectChild) {
 			childState.directOwner = options.directOwner;
+			childState.requesterTurnRunId = options.directOwner?.requesterTurnRunId;
+			childState.requestCustody = options.directOwner?.requestCustody;
 			childState.releaseDirectChild = claimDirectChild(childThreadId);
 		}
 		childState.completionCustody ??= (options.completionCustody ?? options.directOwner?.completionCustody)?.retain();
@@ -5133,7 +5348,7 @@ var Monitor = class {
 		if (pending) pending.state = "active";
 		if (known.observedTurns.has(turnId) && (known.turnId !== turnId || known.assignment.terminal || pending || previous?.nativeTurnState !== void 0)) return false;
 		const observedTurn = !known.observedTurns.has(turnId);
-		const startsPendingTurn = !pending && (known.pendingTurns.length > 0 || known.assignment.unanchored || !previous || known.assignment.terminal || previous.terminal || previous.nativeTurnState === "completed" || previous.nativeTurnState === "failed" || previous.nativeTurnId && previous.nativeTurnId !== turnId);
+		const startsPendingTurn = !pending && !(previous?.cancellationRequested && !previous.nativeTurnId && !previous.terminal && known.pendingTurns.length === 0) && (known.pendingTurns.length > 0 || known.assignment.unanchored || !previous || known.assignment.terminal || previous.terminal || previous.nativeTurnState === "completed" || previous.nativeTurnState === "failed" || previous.nativeTurnId && previous.nativeTurnId !== turnId);
 		if (observedTurn) known.observedTurns.set(turnId, startsPendingTurn ? { awaitingInteraction: true } : {});
 		if (startsPendingTurn) {
 			const previousPending = known.pendingTurns.at(-1);
@@ -5158,6 +5373,7 @@ var Monitor = class {
 			previous.nativeTurnState = "active";
 			this.assignments.record(known.parent, previous);
 			if (previous.modelExecution && !previous.modelExecution.executionOwner.turnId) previous.modelExecution.bindTurn(turnId);
+			this.cancellationTurnWaiters.get(previous)?.();
 		}
 		if (observedTurn) this.associatePendingChildInteraction(known, turnId);
 		this.admitFollowupChild(known);
@@ -5207,8 +5423,14 @@ var Monitor = class {
 			if (child && !child.terminal && !known.assignment.terminal && (recoveredIndex >= 0 || child.nativeTurnState === "interrupted")) {
 				let continuationCount = Math.max(1, recoveredIndex + 1);
 				if (recoveredIndex < 0) while (continuationCount < known.pendingTurns.length && known.pendingTurns[continuationCount - 1]?.state === "interrupted") continuationCount += 1;
+				const resumed = known.pendingTurns[continuationCount - 1];
+				const resumedOwner = resumed.modelSource?.owner ?? resumed.admittedOwner;
+				if (this.childAdmissionCancelled(known.parent, resumedOwner)) return;
 				const continuations = known.pendingTurns.splice(0, continuationCount);
-				const resumed = continuations.at(-1);
+				child.requesterTurnRunId = resumedOwner?.requesterTurnRunId;
+				child.requestCustody = resumedOwner?.requestCustody;
+				child.cancellationRequested = void 0;
+				child.terminalHandling = void 0;
 				child.completionCustody ??= resumed.completionCustody?.retain();
 				continuations.forEach(releaseCompletionCustody);
 				if (recoveredIndex < 0) {
@@ -5232,6 +5454,8 @@ var Monitor = class {
 				return;
 			}
 			if (!pending.admittedOwner && !pending.admittedSubmission && !pending.modelSource) return;
+			const pendingOwner = pending.modelSource?.owner ?? pending.admittedOwner;
+			if (this.childAdmissionCancelled(known.parent, pendingOwner)) return;
 			const runId = codexNativeSubagentRunId(threadId, pending.turnId);
 			child = this.registerChildThread(known.parent, {
 				runId,
@@ -5244,6 +5468,8 @@ var Monitor = class {
 			if (!child) return;
 			child.nativeTurnId = pending.turnId;
 			child.nativeTurnState = pending.state;
+			child.requesterTurnRunId = pendingOwner?.requesterTurnRunId;
+			child.requestCustody = pendingOwner?.requestCustody;
 			if (pending.modelSource) {
 				releaseNativeModelExecution(child);
 				child.modelExecution = pending.modelSource;
@@ -5262,6 +5488,9 @@ var Monitor = class {
 		const currentInteraction = [...this.admissionCustody.entries.values()].flat().findLast((evidence) => evidence.kind === "interaction" && evidence.parentThreadId === known.parent.parentThreadId && evidence.childThreadId === threadId && !evidence.nativeTurnId && evidence.owner && [...known.parent.owners.values()].includes(evidence.owner));
 		if (currentInteraction?.kind === "interaction" && currentInteraction.owner) claimOwner = currentInteraction.owner;
 		if (claimOwner && [...known.parent.owners.values()].includes(claimOwner)) {
+			if (this.childAdmissionCancelled(known.parent, claimOwner)) return;
+			child.requesterTurnRunId = claimOwner.requesterTurnRunId;
+			child.requestCustody = claimOwner.requestCustody;
 			child.completionCustody ??= claimOwner.completionCustody?.retain();
 			if (child.directOwner !== claimOwner) {
 				releaseNativeDirectChild(child);
@@ -5326,7 +5555,6 @@ var Monitor = class {
 			this.parentThreadRetentions.delete(childState.parentThreadId);
 			releaseParentThread?.();
 		}
-		this.recovery.collectThreadStatusRevision(childState.childThreadId);
 		this.releaseClientRetentionIfIdle();
 		const state = this.parentStates.get(childState.parentThreadId);
 		if (state) {
@@ -5362,8 +5590,25 @@ var Monitor = class {
 	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)));
 	}
+	listPendingChildren(source) {
+		const parentThreadIds = new Set(this.requesterParents(source).filter((state) => state.requesterSessionKey && state.completionScope).map((state) => state.parentThreadId));
+		const pending = [];
+		for (const child of this.childStates.values()) {
+			if (!parentThreadIds.has(child.parentThreadId) || child.settledWithoutCompletion || child.nativeCompletionDelivered || child.terminal && !child.pendingCompletion) continue;
+			const label = [...this.knownChildren.get(child.childThreadId)?.agentPaths ?? []].find((path) => path !== child.childThreadId);
+			pending.push({
+				runId: child.runId,
+				childSessionKey: child.runId,
+				...label ? { label } : {},
+				state: child.terminal ? "completing" : "running",
+				wakeArmed: false
+			});
+		}
+		return pending;
+	}
 	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;
+		if (this.cancellationReservations.has(state)) return true;
+		if (state.modelSourceReferences || state.pendingRegistrations?.size && !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;
 	}
@@ -5378,8 +5623,9 @@ var Monitor = class {
 		for (const state of states) {
 			this.submissions.retire(state);
 			this.childCloses.clear(state);
-			this.recovery.clearTerminalRevisionsForParent(state.parentThreadId);
+			this.recovery.clearTerminalThreadsForParent(state.parentThreadId);
 			this.parentStates.delete(state.parentThreadId);
+			state.submissionStore?.release?.();
 			for (const [threadId, known] of this.knownChildren) if (known.parent === state) {
 				this.childCloses.retireReceiver(known, () => this.updateChildThreadOwnership("release", threadId, this.releaseChildThread));
 				for (const path of known.agentPaths) this.childThreadIdsByAgentPath.delete(buildCodexNativeSubagentAgentPathKey(state.parentThreadId, path));
@@ -5425,4 +5671,4 @@ var Monitor = class {
 };
 const codexNativeSubagentMonitorRuntime = createCodexNativeSubagentMonitorRuntime(Monitor);
 //#endregion
-export { CodexToolTranscriptProjection as a, isCodexCommandBearingToolCall as c, sanitizeCodexToolArguments as d, emitCodexAgentEvent as i, resolveCodexToolProgressDetailMode as l, native_subagent_monitor_exports as n, CodexToolProgressProjection as o, CodexEventProjection as r, shouldEmitTranscriptToolProgress as s, codexNativeSubagentMonitorRuntime as t, sanitizeCodexAgentEventRecord as u };
+export { CodexToolTranscriptProjection as a, asCodexToolArguments as c, emitCodexAgentEvent as i, isCodexCommandBearingToolCall as l, native_subagent_monitor_exports as n, CodexToolProgressProjection as o, CodexEventProjection as r, shouldEmitTranscriptToolProgress as s, codexNativeSubagentMonitorRuntime as t, resolveCodexToolProgressDetailMode as u };