@scotthuang/agent-knock-knock 0.12.5 → 0.12.6

package/dist/src/cli-core.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 import { createCodexTerminalAgentAdapter, detectCodexDurableCompletion } from "./codex-terminal-agent-adapter.js";
 import { createClaudeTerminalAgentAdapter } from "./claude-terminal-agent-adapter.js";
 import { captureClaudeTranscriptAnchor, defaultClaudeHome, detectClaudeTranscriptAcceptance, detectClaudeTranscriptCompletion, detectClaudeTranscriptPendingApproval, listClaudeThreadLifecycleCandidates, revalidateClaudeThreadLifecycleCandidate } from "./claude-local-transcript-provider.js";
-import { captureCodexRolloutAcceptanceAnchor, detectCodexBoundRolloutCompletion, detectCodexRolloutAcceptance, terminalSubmissionReplayReceipt, validateTerminalSubmissionAcceptanceEvidence } from "./terminal-submission-acceptance.js";
+import { captureCodexCandidateSetRolloutAcceptanceAnchor, captureCodexRolloutAcceptanceAnchor, detectCodexBoundRolloutCompletion, detectCodexCandidateSetRolloutAcceptance, detectCodexRolloutAcceptance, terminalSubmissionReplayReceipt, validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence } from "./terminal-submission-acceptance.js";
 import { CodexLocalSessionProvider } from "./codex-local-session-provider.js";
 import { CodexStoreAdapter } from "./codex-store-adapter.js";
 import { createDeferredForegroundTransferId, listDeferredForegroundTransfers, loadDeferredForegroundTransfer, saveDeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
@@ -1710,7 +1710,8 @@ function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, a
     return child;
 }
 function startTerminalBridgeMonitorForConversation({ conversation, statePath, logPath, options }) {
-    if (!terminalBridgeEnabled(conversation) || !conversation.gateway_method || options.disableTerminalBridgeMonitor === true) {
+    if (!terminalBridgeEnabled(conversation) ||
+        options.disableTerminalBridgeMonitor === true) {
         return undefined;
     }
     const nativeTakeover = isRecord(conversation.native_session_takeover)
@@ -2883,12 +2884,18 @@ function exactTerminalBridgeCollateralStallRepairEvidence({ conversation, storeD
     };
 }
 function reconcileTerminalBridgeCollateralStalls(storeDir, conversationId) {
+    const reservedSourceTurnIds = new Set(listDeferredForegroundTransfers(storeDir)
+        .filter((transfer) => transfer.version === 2 &&
+        transfer.source_kind === "candidate_rollout_quiescent" &&
+        !["resolved", "abort_resolved"].includes(transfer.status))
+        .flatMap((transfer) => (transfer.source_turn_history ?? []).map((turn) => turn.turn_id)));
     const candidates = listConversations(storeDir).filter((conversation) => {
         const takeover = isRecord(conversation.native_session_takeover)
             ? conversation.native_session_takeover
             : undefined;
         return (conversationId === undefined ||
             conversation.conversation_id === conversationId) &&
+            !reservedSourceTurnIds.has(turnIdForConversation(conversation)) &&
             conversation.status === "stalled" &&
             isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence);
     });
@@ -3191,8 +3198,14 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     }
     const terminalState = await listStateForTerminal(session.agent, terminalControl, options, bridge, {
         pid: session.pid,
-        sessionId: session.sessionId,
         cwd: session.cwd,
+        // Raw Codex status and approval use the exact full terminal selector as
+        // their runtime conversation identity. Use the same identity while
+        // projecting list actions so a prompt-bound terminal token can be
+        // revalidated by the later status/approve calls.
+        ...(session.agent === "codex"
+            ? { conversationId: bridge.terminalConversationId(session) }
+            : { sessionId: session.sessionId }),
         terminalTarget: terminalControl.target
     });
     const orphanedDispatch = orphanedTerminalDispatchForRecovery(terminalControl);
@@ -3233,6 +3246,26 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     const nativeAgentIdentity = nativeIdentityObservation.status === "resolved"
         ? nativeIdentityObservation.identity
         : undefined;
+    let codexOpenRootRolloutInventory;
+    if (session.agent === "codex") {
+        try {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid: session.pid,
+                cwd: session.cwd ?? terminalControl.currentPath
+            });
+            if (inventory.roots.length > 0) {
+                codexOpenRootRolloutInventory = inventory;
+            }
+        }
+        catch (error) {
+            runtimeLog("warn", "terminal_codex_open_root_inventory_unavailable", {
+                terminal_target: terminalControl.target,
+                pid: session.pid,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
     if (nativeIdentityObservation.status === "unavailable") {
         runtimeLog("warn", "terminal_native_session_identity_unavailable", {
             agent: session.agent,
@@ -3244,6 +3277,11 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     let nativeProcessUuid = nativeAgentIdentity?.processUuid;
     let nativeProcessBirth = nativeAgentIdentity?.processBirth;
     let nativeProcessEvidence = nativeAgentIdentity?.evidence;
+    if (codexOpenRootRolloutInventory) {
+        nativeProcessUuid = codexOpenRootRolloutInventory.processUuid;
+        nativeProcessBirth = codexOpenRootRolloutInventory.processBirth;
+        nativeProcessEvidence = "codex_open_root_rollout_inventory";
+    }
     if (session.agent === "codex" &&
         (!nativeProcessUuid || !nativeProcessBirth)) {
         try {
@@ -3365,6 +3403,11 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         // this field after gating every automated-input action that can follow a
         // human native-thread switch.
         _automated_input_composer_ready: automatedInputComposerReady,
+        ...(codexOpenRootRolloutInventory
+            ? {
+                _codex_open_root_rollout_inventory: codexOpenRootRolloutInventory
+            }
+            : {}),
         ...(orphanedDispatch
             ? {
                 orphaned_terminal_dispatch: {
@@ -3416,9 +3459,16 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     };
 }
 function terminalFirstListProjection({ storeDir, terminals, managedSessions, sessionAuthorityRequired, allConversations, displayedConversations, includeAll, managedOnly, statusFilter, mutationsAllowed }) {
-    const nonterminalDeferredTransfers = listDeferredForegroundTransfers(storeDir).filter((transfer) => !["resolved", "aborted", "abort_resolved"].includes(transfer.status));
+    const nonterminalDeferredTransfers = listDeferredForegroundTransfers(storeDir).filter((transfer) => !["resolved", "abort_resolved"].includes(transfer.status));
     const nonterminalDeferredTransferIds = new Set(nonterminalDeferredTransfers.map((transfer) => transfer.transfer_id));
+    const nonterminalDeferredSourceTurnIds = new Set(nonterminalDeferredTransfers.flatMap((transfer) => transfer.version === 2 &&
+        transfer.source_kind === "candidate_rollout_quiescent"
+        ? (transfer.source_turn_history ?? []).map((turn) => turn.turn_id)
+        : []));
     const conversationHasNonterminalDeferredTransfer = (conversation) => {
+        if (nonterminalDeferredSourceTurnIds.has(turnIdForConversation(conversation))) {
+            return true;
+        }
         const takeover = isRecord(conversation.native_session_takeover)
             ? conversation.native_session_takeover
             : undefined;
@@ -3432,7 +3482,10 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         return control ? [control] : [];
     });
     const projectedTerminals = terminals.map((terminal) => {
-        const { _automated_input_composer_ready: automatedInputComposerReady, ...publicTerminal } = terminal;
+        const { _automated_input_composer_ready: automatedInputComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, ...publicTerminal } = terminal;
+        const codexOpenRootRolloutInventory = isRecord(codexOpenRootRolloutInventoryValue)
+            ? codexOpenRootRolloutInventoryValue
+            : undefined;
         const terminalControl = isRecord(terminal.terminal_control)
             ? terminal.terminal_control
             : undefined;
@@ -3675,9 +3728,14 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 sourceSession: soleBindingConflict.session
             })
             : undefined;
+        const deferredCodexCandidateInventory = codexOpenRootRolloutInventory &&
+            codexOpenRootRolloutInventory.roots.length > 0
+            ? codexOpenRootRolloutInventory
+            : undefined;
         const deferredCodexSource = authoritativeSession &&
             terminal.agent === "codex" &&
-            nativeIdentityObservation?.status === "verified_absent"
+            (nativeIdentityObservation?.status === "verified_absent" ||
+                deferredCodexCandidateInventory !== undefined)
             ? authoritativeSession
             : undefined;
         const deferredCodexProcessUuid = stringValue(terminal.native_agent_process_uuid);
@@ -3692,15 +3750,11 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const deferredCodexDispatchSnapshot = terminalControl
             ? tryDeferredCodexForegroundDispatchSnapshot(terminalControl)
             : undefined;
-        const deferredCodexForegroundEligible = Boolean(mutationsAllowed &&
-            !terminalHasNonterminalDeferredTransfer &&
-            deferredCodexSource &&
+        const deferredCodexCandidateSourceTurnHistory = deferredCodexCandidateInventory && deferredCodexSource
+            ? deferredCandidateSourceTurnHistory(storeDir, deferredCodexSource)
+            : undefined;
+        const deferredCodexStatusCardSourceEligible = Boolean(deferredCodexSource &&
             terminalControl &&
-            hasCanonicalTerminalEndpoint(terminalControl) &&
-            discoveredOwnership.state === "none" &&
-            unresolvedSessionClaims.length === 0 &&
-            matchingSessions.length === 1 &&
-            conflictingBoundSessionClaims.length === 0 &&
             deferredCodexProcessUuid &&
             deferredCodexProcessBirth &&
             deferredCodexWorkspace &&
@@ -3715,7 +3769,44 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             }) &&
             managedTurnsForSession(storeDir, deferredCodexSource.session_id).length === 0 &&
             !deferredCodexSource.last_transition_id &&
-            !managedSessionHasAnyNativeTransition(storeDir, deferredCodexSource) &&
+            !managedSessionHasAnyNativeTransition(storeDir, deferredCodexSource));
+        const deferredCodexCandidateSourceEligible = Boolean(deferredCodexSource &&
+            terminalControl &&
+            deferredCodexProcessUuid &&
+            deferredCodexProcessBirth &&
+            deferredCodexWorkspace &&
+            deferredCodexCandidateInventory &&
+            deferredCodexCandidateSourceTurnHistory &&
+            exactBoundCodexCandidateSourceForDeferredSend({
+                session: deferredCodexSource,
+                terminalId: String(terminal.id),
+                terminalControl,
+                pid: Number(terminal.pid),
+                workspace: deferredCodexWorkspace,
+                processUuid: deferredCodexProcessUuid,
+                processBirth: deferredCodexProcessBirth,
+                inventory: deferredCodexCandidateInventory
+            }) &&
+            candidateSourceTransitionHistoryIsTerminal(storeDir, deferredCodexSource));
+        const deferredCodexCandidateRouteNeeded = Boolean(deferredCodexCandidateInventory &&
+            (deferredCodexCandidateInventory.status === "unbound" ||
+                nativeIdentityObservation?.status === "unavailable" ||
+                deferredCodexSource?.binding?.native_process.rollout === undefined));
+        const deferredCodexForegroundEligible = Boolean(mutationsAllowed &&
+            !terminalHasNonterminalDeferredTransfer &&
+            deferredCodexSource &&
+            terminalControl &&
+            hasCanonicalTerminalEndpoint(terminalControl) &&
+            discoveredOwnership.state === "none" &&
+            unresolvedSessionClaims.length === 0 &&
+            matchingSessions.length === 1 &&
+            conflictingBoundSessionClaims.length === 0 &&
+            deferredCodexProcessUuid &&
+            deferredCodexProcessBirth &&
+            deferredCodexWorkspace &&
+            (deferredCodexStatusCardSourceEligible ||
+                (deferredCodexCandidateRouteNeeded &&
+                    deferredCodexCandidateSourceEligible)) &&
             terminalBlockingTurns.length === 0 &&
             terminal.orphaned_terminal_dispatch === undefined &&
             deferredCodexDispatchSnapshot &&
@@ -3742,7 +3833,10 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 processUuid: deferredCodexProcessUuid,
                 processBirth: deferredCodexProcessBirth,
                 sourceSession: deferredCodexSource,
-                dispatchSnapshot: deferredCodexDispatchSnapshot
+                dispatchSnapshot: deferredCodexDispatchSnapshot,
+                ...(deferredCodexCandidateInventory
+                    ? { candidateInventory: deferredCodexCandidateInventory }
+                    : {})
             })
             : undefined;
         const reconcileBindingAction = mutationsAllowed &&
@@ -3843,6 +3937,67 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         // stalls; clear those first, refresh, and only then decide the handoff.
         const terminalRecoveryBlockingTurns = terminalBlockingTurns.filter((turn) => !blockingHandoffTurnIds.has(turn.conversation_id) &&
             !conversationHasNonterminalDeferredTransfer(turn));
+        let terminalScopedCodexApprovalAction;
+        const terminalScopedCodexApprovalPrompt = terminalScopedCodexApprovalPromptSnapshot(terminal.approval_state);
+        if (mutationsAllowed &&
+            terminal.agent === "codex" &&
+            terminalControl &&
+            hasCanonicalTerminalEndpoint(terminalControl) &&
+            authoritativeSession &&
+            !sessionAuthorityConflict &&
+            !terminalHasNonterminalDeferredTransfer &&
+            unresolvedSessionClaims.length === 0 &&
+            conflictingBoundSessionClaims.length === 0 &&
+            terminalScopedCodexApprovalPrompt &&
+            isRecord(rawActions.approve)) {
+            try {
+                const ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+                const boundary = ownership.state === "conflict" &&
+                    discoveredOwnership.state === "current" &&
+                    ledger
+                    ? terminalScopedCodexApprovalBoundaryFromSnapshot({
+                        storeDir,
+                        terminal,
+                        owner: discoveredOwnership.conversation,
+                        session: authoritativeSession,
+                        ledger,
+                        approval: terminalScopedCodexApprovalPrompt
+                    })
+                    : ownership.state === "none" &&
+                        discoveredOwnership.state === "none"
+                        ? terminalScopedCodexApprovalWithoutDispatchOwnerBoundary({
+                            storeDir,
+                            terminal,
+                            session: authoritativeSession,
+                            ledger,
+                            approval: terminalScopedCodexApprovalPrompt
+                        })
+                        : undefined;
+                if (!boundary) {
+                    throw new Error("terminal-scoped Codex approval has no eligible managed authority");
+                }
+                terminalScopedCodexApprovalAction = {
+                    ...rawActions.approve,
+                    arguments: {
+                        conversation_id: String(terminal.id),
+                        expected_terminal_token: boundary.token
+                    },
+                    scope: "terminal_current_prompt",
+                    authority: boundary.authority.kind,
+                    managed_state_unchanged: true,
+                    automatic_approval_eligible: false,
+                    durable_dispatch_receipt: false,
+                    uncertain_outcome_recovery: "refresh status and inspect the live prompt; do not retry blindly"
+                };
+            }
+            catch (error) {
+                runtimeLog("info", "terminal_scoped_codex_approval_not_advertised", {
+                    terminal_id: String(terminal.id),
+                    terminal_target: terminalControl.target,
+                    reason: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
         const terminalCanAcceptSend = ownership.state === "none" && isRecord(sessionAwareRawActions.send);
         if (ownership.state === "current" &&
             !allRelated.some((conversation) => conversation.conversation_id === ownership.conversation.conversation_id)) {
@@ -3887,6 +4042,9 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const currentTurn = currentTurnProjection
             ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
             : undefined;
+        const nonOwnerRawActions = authoritativeSession
+            ? Object.fromEntries(Object.entries(sessionAwareRawActions).filter(([actionName]) => actionName !== "approve"))
+            : sessionAwareRawActions;
         const sortedDisplayed = [...sessionDisplayedRelated]
             .filter((conversation) => conversation.conversation_id !== currentTurn?.conversation_id)
             .sort(compareManagedConversationRecency);
@@ -3939,7 +4097,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 : {}),
             ...(includeAll ? { history } : {})
         };
-        const availableActions = ownership.state === "current"
+        const baseAvailableActions = ownership.state === "current"
             ? currentTerminalActions(currentTurn)
             : ownership.state === "conflict"
                 ? {
@@ -3977,7 +4135,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 : deferredCodexForegroundToken &&
                     isRecord(rawActions.send)
                     ? {
-                        ...sessionAwareRawActions,
+                        ...nonOwnerRawActions,
                         send: {
                             ...rawActions.send,
                             arguments: {
@@ -3992,10 +4150,16 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                         sessionBindingMatchesLiveTerminal &&
                         isRecord(sessionAwareRawActions.send)
                         ? {
-                            ...sessionAwareRawActions,
+                            ...nonOwnerRawActions,
                             send: sendActionForManagedSession(sessionAwareRawActions.send, managedSessionId)
                         }
-                        : sessionAwareRawActions;
+                        : nonOwnerRawActions;
+        const availableActions = terminalScopedCodexApprovalAction
+            ? {
+                ...baseAvailableActions,
+                approve: terminalScopedCodexApprovalAction
+            }
+            : baseAvailableActions;
         const authoritativeBinding = authoritativeSession?.binding;
         const authoritativeIdentity = authoritativeBinding?.native_thread_id
             ? {
@@ -4144,6 +4308,24 @@ function managedSessionMatchesLiveTerminalEntry(session, terminal, storeDir) {
         return false;
     }
     if (!liveThreadId) {
+        const candidateInventory = isRecord(terminal._codex_open_root_rollout_inventory)
+            ? terminal._codex_open_root_rollout_inventory
+            : undefined;
+        const boundRollout = binding.native_process.rollout;
+        const candidateRoot = candidateInventory?.roots.find((root) => root.sessionId.toLowerCase() ===
+            binding.native_thread_id?.toLowerCase());
+        if (session.agent === "codex" &&
+            binding.native_thread_id &&
+            isCompleteNativeRollout(boundRollout) &&
+            candidateRoot &&
+            exactNativeRolloutMatches(candidateRoot.rollout, boundRollout) &&
+            candidateInventory?.pid === binding.native_process.pid &&
+            candidateInventory.processUuid ===
+                binding.native_process.process_uuid &&
+            candidateInventory.processBirth ===
+                binding.native_process.process_birth) {
+            return true;
+        }
         return Boolean(session.agent === "codex" &&
             binding.native_thread_id &&
             isCodexStatusCardEvidence(binding.native_process.evidence) &&
@@ -4504,118 +4686,624 @@ function localTerminalDispatchOwnership(ledgerOwner, localConversations, termina
         }
     };
 }
-function sameCanonicalStatePath(left, right) {
-    const leftPath = stringValue(left);
-    const rightPath = stringValue(right);
-    return Boolean(leftPath &&
-        rightPath &&
-        path.resolve(leftPath) === path.resolve(rightPath));
-}
-function currentTerminalActions(currentTurn) {
-    if (!currentTurn || !isRecord(currentTurn.available_actions)) {
-        return {};
-    }
-    const actions = {};
-    for (const action of ["status", "respond", "approve", "cancel", "renew", "retry_callback"]) {
-        if (isRecord(currentTurn.available_actions[action])) {
-            actions[action] = currentTurn.available_actions[action];
-        }
+function terminalScopedCodexApprovalObservation(terminal) {
+    const observation = isRecord(terminal.native_agent_identity_observation)
+        ? terminal.native_agent_identity_observation
+        : undefined;
+    const status = stringValue(observation?.status);
+    if (!status || !["resolved", "verified_absent", "unavailable"].includes(status)) {
+        return undefined;
     }
-    return actions;
-}
-function safeTerminalActionsDuringConflict(rawActions) {
-    const actions = {};
-    for (const action of ["status", "close"]) {
-        if (isRecord(rawActions[action])) {
-            actions[action] = rawActions[action];
-        }
+    if (status !== "resolved") {
+        return { status };
     }
-    return actions;
-}
-function sendActionForManagedSession(action, sessionId) {
-    const { selector: _selector, ...existingArguments } = isRecord(action.arguments)
-        ? action.arguments
-        : {};
+    const rollout = isRecord(terminal.native_agent_rollout)
+        ? terminal.native_agent_rollout
+        : undefined;
     return {
-        ...action,
-        arguments: {
-            ...existingArguments,
-            session_id: sessionId
-        }
+        status,
+        session_id: stringValue(terminal.native_agent_session_id) ?? null,
+        process_uuid: stringValue(terminal.native_agent_process_uuid) ?? null,
+        process_birth: stringValue(terminal.native_agent_process_birth) ?? null,
+        rollout: isCompleteNativeRollout(rollout)
+            ? {
+                fd: rollout.fd,
+                device: rollout.device,
+                inode: rollout.inode,
+                path: rollout.path
+            }
+            : null
     };
 }
-function actionsForManagedSessionBinding(actions, session) {
-    const token = managedSessionBindingToken(session);
-    const next = { ...actions };
-    for (const actionName of ["new_thread", "resume_thread", "native_inspect"]) {
-        const action = isRecord(next[actionName]) ? next[actionName] : undefined;
-        if (!action) {
-            continue;
-        }
-        next[actionName] = {
-            ...action,
-            arguments: {
-                ...(isRecord(action.arguments) ? action.arguments : {}),
-                expected_binding_token: token
-            }
-        };
+function terminalScopedCodexApprovalPromptSnapshot(approvalState) {
+    if (!isRecord(approvalState) || approvalState.approvable !== true) {
+        return undefined;
     }
-    return next;
-}
-function safeUnavailableManagedTurnActions(actionsValue) {
-    const actions = {};
-    for (const action of ["status", "retry_callback", "close"]) {
-        if (isRecord(actionsValue[action])) {
-            actions[action] = actionsValue[action];
-        }
+    const fingerprint = stringValue(approvalState.fingerprint);
+    const rawKeys = Array.isArray(approvalState.keys)
+        ? approvalState.keys
+        : stringValue(approvalState.key)
+            ? [approvalState.key]
+            : [];
+    const keys = rawKeys.filter((value) => typeof value === "string" && value.length > 0);
+    if (!fingerprint ||
+        !/^[0-9a-f]{64}$/u.test(fingerprint) ||
+        keys.length === 0 ||
+        keys.length !== rawKeys.length ||
+        stringValue(approvalState.decision_mode) !== "keys") {
+        return undefined;
     }
-    return actions;
-}
-function readOnlyListActions(actionsValue) {
-    return isRecord(actionsValue.status)
-        ? { status: actionsValue.status }
-        : {};
-}
-function readOnlyManagedTurn(managedTurn) {
+    const requestId = stringValue(approvalState.request_id) ?? null;
     return {
-        ...managedTurn,
-        available_actions: readOnlyListActions(isRecord(managedTurn.available_actions)
-            ? managedTurn.available_actions
-            : {})
+        fingerprint,
+        keys,
+        requestId,
+        digest: terminalActionFingerprint({
+            version: 1,
+            kind: "terminal_scoped_codex_approval_prompt",
+            fingerprint,
+            keys,
+            request_id: requestId
+        })
     };
 }
-function withoutGenericHandoffSourceClose(managedTurn, blockingHandoffTurnIds) {
-    const conversationId = stringValue(managedTurn.conversation_id);
-    if (!conversationId || !blockingHandoffTurnIds.has(conversationId)) {
-        return managedTurn;
-    }
-    const availableActions = isRecord(managedTurn.available_actions)
-        ? managedTurn.available_actions
-        : {};
-    const { close: _genericClose, ...safeActions } = availableActions;
-    return {
-        ...managedTurn,
-        available_actions: safeActions
-    };
+function terminalScopedCodexApprovalToken({ storeDir, terminal, authority, approval }) {
+    const terminalControl = terminal.terminal_control;
+    const workspace = stringValue(terminal.workspace ?? terminal.cwd);
+    const processUuid = stringValue(terminal.native_agent_process_uuid);
+    const processBirth = stringValue(terminal.native_agent_process_birth);
+    const terminalToken = unmanagedTerminalBindingToken({
+        terminalId: String(terminal.id),
+        terminalControl,
+        agent: "codex",
+        pid: Number(terminal.pid),
+        workspace,
+        processUuid,
+        processBirth
+    });
+    const session = authority.session;
+    const owner = authority.kind === "current_dispatch_owner"
+        ? authority.owner
+        : undefined;
+    const takeover = owner && isRecord(owner.native_session_takeover)
+        ? owner.native_session_takeover
+        : undefined;
+    const ledger = authority.ledger;
+    return createHash("sha256")
+        .update(JSON.stringify({
+        version: 2,
+        kind: "terminal_scoped_codex_manual_approval",
+        store_dir: path.resolve(storeDir),
+        terminal_token: terminalToken,
+        observation: terminalScopedCodexApprovalObservation(terminal),
+        authority: authority.kind,
+        owner_session_id: session.session_id,
+        owner_session_revision: managedSessionRevision(session),
+        owner_binding_token: managedSessionBindingToken(session),
+        owner_turn_id: owner ? turnIdForConversation(owner) : null,
+        owner_turn_status: owner?.status ?? null,
+        owner_turn_updated_at: owner?.updated_at ?? null,
+        owner_message_id: stringValue(takeover?.terminal_bridge_message_id) ?? null,
+        dispatch_snapshot: ledger
+            ? {
+                status: stringValue(ledger.status),
+                fingerprint: terminalActionFingerprint(ledger)
+            }
+            : { status: "none", fingerprint: null },
+        approval_snapshot_digest: approval.digest,
+        approval_fingerprint: approval.fingerprint,
+        approval_keys: approval.keys,
+        approval_request_id: approval.requestId
+    }))
+        .digest("hex");
 }
-function historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal) {
-    const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
-        terminalBridge: terminalBridgeEnabled(conversation),
-        approvalState: managedListApprovalState(conversation),
-        conversation
+function terminalScopedCodexApprovalBoundaryFromSnapshot({ storeDir, terminal, owner, session, ledger, approval }) {
+    const terminalControl = isRecord(terminal.terminal_control)
+        ? terminal.terminal_control
+        : undefined;
+    const binding = session.binding;
+    const workspace = stringValue(terminal.workspace ?? terminal.cwd);
+    const processUuid = stringValue(terminal.native_agent_process_uuid);
+    const processBirth = stringValue(terminal.native_agent_process_birth);
+    const observation = terminalScopedCodexApprovalObservation(terminal);
+    if (terminal.agent !== "codex" ||
+        !terminalControl ||
+        !hasCanonicalTerminalEndpoint(terminalControl) ||
+        !Number.isSafeInteger(Number(terminal.pid)) ||
+        Number(terminal.pid) <= 1 ||
+        !workspace ||
+        !processUuid ||
+        !processBirth ||
+        !observation ||
+        !approval) {
+        throw new Error("terminal-scoped Codex approval requires an exact terminal and process incarnation");
+    }
+    if (session.status !== "bound" ||
+        session.agent !== "codex" ||
+        !binding ||
+        binding.native_process.pid !== Number(terminal.pid) ||
+        binding.native_process.process_uuid !== processUuid ||
+        binding.native_process.process_birth !== processBirth ||
+        !terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminal.id, terminalControl) ||
+        !terminalControlsShareIncarnation(binding.terminal_control, terminalControl) ||
+        path.resolve(session.workspace) !== path.resolve(workspace) ||
+        sessionIdForConversation(owner) !== session.session_id ||
+        !["waiting_for_agent", "waiting_for_openclaw"].includes(owner.status)) {
+        throw new Error("terminal-scoped Codex approval has no single current managed owner");
+    }
+    const relatedBoundSessions = listManagedSessions(storeDir).filter((candidate) => candidate.status === "bound" &&
+        candidate.agent === "codex" &&
+        candidate.binding?.native_process.pid === Number(terminal.pid) &&
+        terminalControlsShareIncarnation(candidate.binding?.terminal_control, terminalControl));
+    if (relatedBoundSessions.length !== 1 ||
+        relatedBoundSessions[0].session_id !== session.session_id) {
+        throw new Error("terminal-scoped Codex approval has ambiguous managed Session ownership");
+    }
+    const blockingTurns = terminalIncarnationBlockingTurns(storeDir, terminalControl);
+    if (blockingTurns.length !== 1 ||
+        turnIdForConversation(blockingTurns[0]) !== turnIdForConversation(owner)) {
+        throw new Error("terminal-scoped Codex approval has collateral unresolved Turn state");
+    }
+    if (managedSessionHasAnyNativeTransition(storeDir, session) ||
+        listDeferredForegroundTransfers(storeDir).some((transfer) => !["resolved", "abort_resolved"].includes(transfer.status) &&
+            (transfer.source_session_id === session.session_id ||
+                transfer.target_session_id === session.session_id ||
+                (transfer.terminal_id === String(terminal.id) &&
+                    terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl))))) {
+        throw new Error("terminal-scoped Codex approval is blocked by managed recovery state");
+    }
+    assertManagedTerminalDispatchOwner({
+        storeDir,
+        conversation: owner,
+        terminalControl,
+        action: "approve"
     });
-    const availableActions = isRecord(managedTurn.available_actions)
-        ? managedTurn.available_actions
-        : {};
-    const safeActions = safeUnavailableManagedTurnActions(availableActions);
+    if (!terminalDispatchRecordMatchesControl(ledger, terminalControl) ||
+        !["submitted", "agent_accepted"].includes(String(ledger.status))) {
+        throw new Error(`terminal-scoped Codex approval cannot use ${String(ledger.status)} dispatch ownership`);
+    }
+    const observedSessionId = stringValue(terminal.native_agent_session_id);
+    const statusCardSessionId = stringValue(terminal.native_agent_status_card_session_id);
+    for (const knownSessionId of [observedSessionId, statusCardSessionId]) {
+        if (knownSessionId &&
+            knownSessionId.toLowerCase() !==
+                String(binding.native_thread_id ?? "").toLowerCase()) {
+            throw new Error("terminal-scoped Codex approval observed a different native thread");
+        }
+    }
+    if (observedSessionId &&
+        (stringValue(terminal.native_agent_process_uuid) !==
+            binding.native_process.process_uuid ||
+            stringValue(terminal.native_agent_process_birth) !==
+                binding.native_process.process_birth ||
+            (binding.native_process.rollout &&
+                !exactNativeRolloutMatches(binding.native_process.rollout, isRecord(terminal.native_agent_rollout)
+                    ? terminal.native_agent_rollout
+                    : undefined)))) {
+        throw new Error("terminal-scoped Codex approval observed a changed native rollout incarnation");
+    }
+    const currentIdentity = observedSessionId
+        ? {
+            sessionId: observedSessionId,
+            processUuid,
+            processBirth,
+            rollout: isRecord(terminal.native_agent_rollout)
+                ? terminal.native_agent_rollout
+                : undefined,
+            evidence: "terminal_scoped_approval"
+        }
+        : undefined;
+    if (nativeAgentIdentityMatchesTurn(owner, currentIdentity)) {
+        throw new Error("the Codex managed identity is exact; use the managed Turn approval action");
+    }
     return {
-        ...managedTurn,
-        available_actions: safeActions
+        authority: {
+            kind: "current_dispatch_owner",
+            owner,
+            session,
+            ledger
+        },
+        approval,
+        token: terminalScopedCodexApprovalToken({
+            storeDir,
+            terminal,
+            authority: {
+                kind: "current_dispatch_owner",
+                owner,
+                session,
+                ledger
+            },
+            approval
+        })
     };
 }
-function managedTurnMatchesLiveTerminal(conversation, terminal) {
-    const takeover = isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
+function terminalScopedCodexApprovalWithoutDispatchOwnerBoundary({ storeDir, terminal, session, ledger, approval }) {
+    const terminalControl = isRecord(terminal.terminal_control)
+        ? terminal.terminal_control
+        : undefined;
+    const binding = session.binding;
+    const workspace = stringValue(terminal.workspace ?? terminal.cwd);
+    const processUuid = stringValue(terminal.native_agent_process_uuid);
+    const processBirth = stringValue(terminal.native_agent_process_birth);
+    const observation = terminalScopedCodexApprovalObservation(terminal);
+    if (terminal.agent !== "codex" ||
+        !terminalControl ||
+        !hasCanonicalTerminalEndpoint(terminalControl) ||
+        !Number.isSafeInteger(Number(terminal.pid)) ||
+        Number(terminal.pid) <= 1 ||
+        !workspace ||
+        !processUuid ||
+        !processBirth ||
+        !observation ||
+        !approval) {
+        throw new Error("terminal-scoped Codex approval requires an exact terminal, process, and prompt incarnation");
+    }
+    if (session.status !== "bound" ||
+        session.agent !== "codex" ||
+        !binding ||
+        !isExactNativeThreadId(binding.native_thread_id) ||
+        binding.native_process.pid !== Number(terminal.pid) ||
+        binding.native_process.process_uuid !== processUuid ||
+        binding.native_process.process_birth !== processBirth ||
+        !terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminal.id, terminalControl) ||
+        !terminalControlsShareIncarnation(binding.terminal_control, terminalControl) ||
+        path.resolve(session.workspace) !== path.resolve(workspace)) {
+        throw new Error("terminal-scoped Codex approval has no single exact managed Session");
+    }
+    const relatedBoundSessions = listManagedSessions(storeDir).filter((candidate) => candidate.status === "bound" &&
+        candidate.agent === "codex" &&
+        candidate.binding?.native_process.pid === Number(terminal.pid) &&
+        terminalControlsShareIncarnation(candidate.binding?.terminal_control, terminalControl));
+    if (relatedBoundSessions.length !== 1 ||
+        relatedBoundSessions[0].session_id !== session.session_id) {
+        throw new Error("terminal-scoped Codex approval has ambiguous managed Session ownership");
+    }
+    if (terminalDispatchOwnership(terminalControl).state !== "none") {
+        throw new Error("terminal-scoped Codex approval acquired a current or conflicted dispatch owner");
+    }
+    if (ledger &&
+        (ledger.status !== "resolved" ||
+            !terminalDispatchRecordMatchesControl(ledger, terminalControl))) {
+        throw new Error(`terminal-scoped Codex approval cannot use ${String(ledger.status)} dispatch ownership`);
+    }
+    if (terminalIncarnationBlockingTurns(storeDir, terminalControl).length > 0) {
+        throw new Error("terminal-scoped Codex approval has unresolved managed Turn state");
+    }
+    if (managedSessionHasAnyNativeTransition(storeDir, session) ||
+        orphanedTerminalDispatchForRecovery(terminalControl) ||
+        listDeferredForegroundTransfers(storeDir).some((transfer) => !["resolved", "abort_resolved"].includes(transfer.status) &&
+            (transfer.source_session_id === session.session_id ||
+                transfer.target_session_id === session.session_id ||
+                (transfer.terminal_id === String(terminal.id) &&
+                    terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl))))) {
+        throw new Error("terminal-scoped Codex approval is blocked by managed recovery state");
+    }
+    const observedSessionId = stringValue(terminal.native_agent_session_id);
+    const statusCardSessionId = stringValue(terminal.native_agent_status_card_session_id);
+    for (const knownSessionId of [observedSessionId, statusCardSessionId]) {
+        if (knownSessionId &&
+            knownSessionId.toLowerCase() !== binding.native_thread_id.toLowerCase()) {
+            throw new Error("terminal-scoped Codex approval observed a different native thread");
+        }
+    }
+    if (observedSessionId &&
+        (stringValue(terminal.native_agent_process_uuid) !==
+            binding.native_process.process_uuid ||
+            stringValue(terminal.native_agent_process_birth) !==
+                binding.native_process.process_birth ||
+            (binding.native_process.rollout &&
+                !exactNativeRolloutMatches(binding.native_process.rollout, isRecord(terminal.native_agent_rollout)
+                    ? terminal.native_agent_rollout
+                    : undefined)))) {
+        throw new Error("terminal-scoped Codex approval observed a changed native rollout incarnation");
+    }
+    const authority = {
+        kind: "managed_session_no_dispatch_owner",
+        session,
+        ...(ledger ? { ledger } : {})
+    };
+    return {
+        authority,
+        approval,
+        token: terminalScopedCodexApprovalToken({
+            storeDir,
+            terminal,
+            authority,
+            approval
+        })
+    };
+}
+async function resolveTerminalScopedCodexApproval({ options, terminal, approvalSnapshot }) {
+    if (terminal.agent !== "codex") {
+        return { state: "blocked", reason: "raw Claude approval remains unsupported" };
+    }
+    const storeDir = path.resolve(storeDirFromOptions(options));
+    let ledger;
+    try {
+        ledger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
+    }
+    catch (error) {
+        return {
+            state: "blocked",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const relatedSessions = listManagedSessions(storeDir).filter((session) => session.binding?.native_process.pid === terminal.pid &&
+        terminalControlsShareIncarnation(session.binding?.terminal_control, terminal.terminalControl));
+    const relatedTurns = listConversations(storeDir).filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminal.terminalControl));
+    if (ledger?.status === "uncertain") {
+        return {
+            state: "blocked",
+            reason: "terminal dispatch is uncertain; inspect the pane and do not retry approval"
+        };
+    }
+    const ownership = terminalDispatchOwnership(terminal.terminalControl);
+    if (ownership.state === "conflict") {
+        return {
+            state: "blocked",
+            reason: stringValue(ownership.conflict.reason) ??
+                "terminal dispatch ownership is conflicted"
+        };
+    }
+    if (ownership.state === "none" &&
+        relatedSessions.length === 0 &&
+        relatedTurns.length === 0) {
+        return { state: "unmanaged" };
+    }
+    const owner = ownership.state === "current"
+        ? ownership.conversation
+        : undefined;
+    if (owner) {
+        const ownerStoreDir = managedSessionStoreDirForConversation(owner);
+        if (!ownerStoreDir || path.resolve(ownerStoreDir) !== storeDir) {
+            return {
+                state: "blocked",
+                reason: "terminal dispatch owner belongs to another AKK Store"
+            };
+        }
+    }
+    const ownerSession = owner
+        ? tryLoadManagedSession(storeDir, sessionIdForConversation(owner))
+        : undefined;
+    if (owner && !ownerSession) {
+        return {
+            state: "blocked",
+            reason: "terminal dispatch owner has no current managed Session"
+        };
+    }
+    let identityContext;
+    try {
+        identityContext = codexManagedIdentityResolutionContext({
+            storeDir,
+            terminal
+        });
+    }
+    catch {
+        // The terminal-scoped path deliberately tolerates an unavailable Codex
+        // rollout resolver. Store, pane, process, owner, and prompt fences below
+        // remain mandatory.
+    }
+    const observation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: "codex",
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath,
+        preferredSessionId: identityContext?.preferredSessionId,
+        allowedCompanionIdentity: identityContext?.companions.primary,
+        allowedAdditionalIdentities: identityContext?.companions.additional
+    });
+    let processIncarnation;
+    try {
+        processIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    }
+    catch (error) {
+        return {
+            state: "blocked",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const identity = observation.status === "resolved"
+        ? observation.identity
+        : undefined;
+    let approval = approvalSnapshot;
+    if (!approval) {
+        try {
+            const terminalStatus = await terminalStatusForControl("codex", terminal.terminalControl, options, {
+                pid: terminal.pid,
+                cwd: terminal.terminalControl.currentPath,
+                conversationId: terminal.conversationId,
+                terminalTarget: terminal.terminalControl.target
+            });
+            approval = terminalScopedCodexApprovalPromptSnapshot(terminalStatus.approval_state);
+        }
+        catch (error) {
+            return {
+                state: "blocked",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    if (!approval) {
+        return {
+            state: "blocked",
+            reason: "terminal-scoped Codex approval requires one fresh exact approval prompt"
+        };
+    }
+    const terminalSnapshot = {
+        id: terminal.conversationId,
+        source: "terminal",
+        agent: "codex",
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath,
+        workspace: terminal.terminalControl.currentPath,
+        terminal_control: terminal.terminalControl,
+        native_agent_session_id: identity?.sessionId,
+        native_agent_process_uuid: identity?.processUuid ?? processIncarnation.processUuid,
+        native_agent_process_birth: identity?.processBirth ?? processIncarnation.processBirth,
+        native_agent_rollout: identity?.rollout,
+        native_agent_identity_observation: { status: observation.status },
+        approval_state: {
+            approvable: true,
+            fingerprint: approval.fingerprint,
+            keys: approval.keys,
+            decision_mode: "keys",
+            request_id: approval.requestId
+        }
+    };
+    try {
+        if (owner && ownerSession && ledger) {
+            return {
+                state: "eligible",
+                boundary: terminalScopedCodexApprovalBoundaryFromSnapshot({
+                    storeDir,
+                    terminal: terminalSnapshot,
+                    owner,
+                    session: ownerSession,
+                    ledger,
+                    approval
+                })
+            };
+        }
+        if (ownership.state !== "none") {
+            throw new Error("managed terminal approval has no current exact dispatch owner");
+        }
+        if (ledger && ledger.status !== "resolved") {
+            throw new Error(`terminal-scoped Codex approval cannot use ${String(ledger.status)} dispatch ownership`);
+        }
+        const matchingSessions = relatedSessions.filter((session) => managedSessionMatchesLiveTerminalEntry(session, terminalSnapshot, storeDir));
+        if (matchingSessions.length !== 1) {
+            throw new Error("terminal-scoped Codex approval has no single exact managed Session");
+        }
+        return {
+            state: "eligible",
+            boundary: terminalScopedCodexApprovalWithoutDispatchOwnerBoundary({
+                storeDir,
+                terminal: terminalSnapshot,
+                session: matchingSessions[0],
+                ledger,
+                approval
+            })
+        };
+    }
+    catch (error) {
+        return {
+            state: "blocked",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function sameCanonicalStatePath(left, right) {
+    const leftPath = stringValue(left);
+    const rightPath = stringValue(right);
+    return Boolean(leftPath &&
+        rightPath &&
+        path.resolve(leftPath) === path.resolve(rightPath));
+}
+function currentTerminalActions(currentTurn) {
+    if (!currentTurn || !isRecord(currentTurn.available_actions)) {
+        return {};
+    }
+    const actions = {};
+    for (const action of ["status", "respond", "approve", "cancel", "renew", "retry_callback"]) {
+        if (isRecord(currentTurn.available_actions[action])) {
+            actions[action] = currentTurn.available_actions[action];
+        }
+    }
+    return actions;
+}
+function safeTerminalActionsDuringConflict(rawActions) {
+    const actions = {};
+    for (const action of ["status", "close"]) {
+        if (isRecord(rawActions[action])) {
+            actions[action] = rawActions[action];
+        }
+    }
+    return actions;
+}
+function sendActionForManagedSession(action, sessionId) {
+    const { selector: _selector, ...existingArguments } = isRecord(action.arguments)
+        ? action.arguments
+        : {};
+    return {
+        ...action,
+        arguments: {
+            ...existingArguments,
+            session_id: sessionId
+        }
+    };
+}
+function actionsForManagedSessionBinding(actions, session) {
+    const token = managedSessionBindingToken(session);
+    const next = { ...actions };
+    for (const actionName of ["new_thread", "resume_thread", "native_inspect"]) {
+        const action = isRecord(next[actionName]) ? next[actionName] : undefined;
+        if (!action) {
+            continue;
+        }
+        next[actionName] = {
+            ...action,
+            arguments: {
+                ...(isRecord(action.arguments) ? action.arguments : {}),
+                expected_binding_token: token
+            }
+        };
+    }
+    return next;
+}
+function safeUnavailableManagedTurnActions(actionsValue) {
+    const actions = {};
+    for (const action of ["status", "retry_callback", "close"]) {
+        if (isRecord(actionsValue[action])) {
+            actions[action] = actionsValue[action];
+        }
+    }
+    return actions;
+}
+function readOnlyListActions(actionsValue) {
+    return isRecord(actionsValue.status)
+        ? { status: actionsValue.status }
+        : {};
+}
+function readOnlyManagedTurn(managedTurn) {
+    return {
+        ...managedTurn,
+        available_actions: readOnlyListActions(isRecord(managedTurn.available_actions)
+            ? managedTurn.available_actions
+            : {})
+    };
+}
+function withoutGenericHandoffSourceClose(managedTurn, blockingHandoffTurnIds) {
+    const conversationId = stringValue(managedTurn.conversation_id);
+    if (!conversationId || !blockingHandoffTurnIds.has(conversationId)) {
+        return managedTurn;
+    }
+    const availableActions = isRecord(managedTurn.available_actions)
+        ? managedTurn.available_actions
+        : {};
+    const { close: _genericClose, ...safeActions } = availableActions;
+    return {
+        ...managedTurn,
+        available_actions: safeActions
+    };
+}
+function historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal) {
+    const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
+        terminalBridge: terminalBridgeEnabled(conversation),
+        approvalState: managedListApprovalState(conversation),
+        conversation
+    });
+    const availableActions = isRecord(managedTurn.available_actions)
+        ? managedTurn.available_actions
+        : {};
+    const safeActions = safeUnavailableManagedTurnActions(availableActions);
+    return {
+        ...managedTurn,
+        available_actions: safeActions
+    };
+}
+function managedTurnMatchesLiveTerminal(conversation, terminal) {
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
         : undefined;
     const liveControl = isRecord(terminal.terminal_control)
         ? terminal.terminal_control
@@ -4835,17 +5523,17 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 11,
+        version: 12,
         instructions: [
             "Treat terminals[] as the primary resource and use only actions present in available_actions, except the snapshot-bound terminals[].handoff_decision.choices.take_over_current.action and an exact terminals[].blocking_turns[].recovery_action. Either nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
             "An existing managed session's ordinary send targets session_id and creates a new turn. A turn id is never an ordinary send target.",
             "Read-only native-thread listing targets an exact terminal_id. Native-thread new/resume mutations also use the listed expected_binding_token and never create a Turn.",
             "Native inspection is a separate terminal action: use only its closed inspection enum and current exact terminal_id/token; AKK status does not execute a native slash command.",
-            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. A conclusively ended Codex rollout may expose the same snapshot-bound send only after AKK proves zero current rollout and an exact empty composer; it detaches the ended Session and creates an isolated virgin Session. A status-card-only Codex Session with no rollout or Turn may also expose this exact action: AKK submits the ordinary task first and binds only the rollout that durably accepts that request, so narrow panes do not require /status. Until that promotion commits, strict session_id send, respond, approve, cancel, native lifecycle, and native_inspect remain unavailable, and the provisional binding has no callback authority. If dispatch, acceptance, or post-submit binding is uncertain, do not retry automatically. Other binding conflicts remain fail-closed and may expose only exact low-level reconcile_binding recovery.",
+            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. A conclusively ended Codex rollout may expose the same snapshot-bound send only after AKK proves zero current rollout and an exact empty composer; it detaches the ended Session and creates an isolated virgin Session. A status-card-only zero-rollout source, or a quiescent rollout-backed source whose complete pinned open-rollout inventory cannot identify one foreground candidate, may also expose this exact action. AKK freezes any released predecessor Turn history, submits the ordinary task once, and binds a separate provisional Session only after one post-anchor rollout uniquely accepts that exact request. The accepted UUID may equal or differ from the predecessor without merging their Session lineages, and narrow panes do not require /status. Until that promotion commits, strict session_id send, respond, approve, cancel, native lifecycle, and native_inspect remain unavailable, and the provisional binding has no callback authority. If dispatch, acceptance, or post-submit binding is uncertain, do not retry automatically. Other binding conflicts remain fail-closed and may expose only exact low-level reconcile_binding recovery.",
             "List resumable threads before resume; use only a complete native_thread_id and the action returned for that candidate.",
             "Use a terminal selector only when explicitly named by the user or prefilled by that terminal row's send action. A handoff action also carries expected_terminal_token; never infer, guess, or reuse either value.",
             "Use respond only for an in-flight turn that is explicitly waiting for OpenClaw.",
-            "Managed controls target turn_id. A raw terminal may be controlled only through its own list-prefilled conversation_id action; never construct, guess, or reuse that compatibility selector.",
+            "Managed controls target turn_id. A raw terminal may be controlled only through its own list-prefilled conversation_id action. When a Codex managed prompt has no usable AKK Turn owner, list may expose one manual terminal-scoped approve carrying expected_terminal_token; copy the complete action after explicit human confirmation. It does not mutate the Turn or Session binding, has no durable dispatch receipt, and is never eligible for automatic approval. If its result is interrupted, refresh status and inspect the live prompt instead of retrying blindly. Never construct, guess, or reuse either selector or token.",
             "Start with the action's prefilled arguments, supply every missing_required field, and consult the top-level action's optional fields only when needed.",
             "Authoritative full IDs are prefilled; short_ref is for display and human input.",
             "Availability is a snapshot. AKK revalidates process, provider-owned terminal identity, workspace, activity, approval, and recovery state before side effects."
@@ -4916,7 +5604,8 @@ function listActionContracts() {
                 ],
                 unsupported: ["timeoutSeconds"],
                 status_card_only_deferred_scope: "A zero-Turn Codex status-card binding has no rollout; only its listed selector/token send creates an isolated provisional Session and binds it after exact request acceptance. Until promotion commits, strict managed controls, native lifecycle, native_inspect, and callback authority remain unavailable; an uncertain dispatch, acceptance, or post-submit binding must not be retried automatically.",
-                ordinary_use: "Create a new managed turn in the exact Session. A live terminal selector can attach an unmanaged pane, adopt one verified human-selected native context, detach a verified-empty Codex source, or replace a zero-Turn status-card-only binding after the submitted request proves its exact rollout; an explicit session_id never follows the pane."
+                candidate_rollout_deferred_scope: "A quiescent rollout-backed Codex source may use a listed selector/token send only when AKK pins the complete exact candidate inventory but cannot prove one foreground UUID. Released predecessor Turn history stays read-only while a separate provisional Session sends once and waits for one unique post-anchor request acceptance. Same-UUID and different-UUID results keep separate Session lineages; zero, multiple, drifted, or uncertain acceptance is never retried blindly.",
+                ordinary_use: "Create a new managed turn in the exact Session. A live terminal selector can attach an unmanaged pane, adopt one verified human-selected native context, detach a verified-empty Codex source, or replace an eligible status-card/candidate-rollout source after the submitted request proves its unique exact rollout; an explicit session_id never follows the pane."
             },
             new_thread: {
                 tool: "agent_knock_knock_new_thread",
@@ -4989,8 +5678,10 @@ function listActionContracts() {
                 tool: "agent_knock_knock_approve",
                 target_argument: "turn_id",
                 compatibility_target_argument: "conversation_id",
-                compatibility_scope: "A deprecated legacy Turn alias, or only the exact selector prefilled by an unmanaged raw-terminal row's available approval action; never construct, guess, or reuse it.",
+                compatibility_scope: "A deprecated legacy Turn alias, or only the exact selector prefilled by a raw-terminal or manual terminal-scoped Codex approval action; never construct, guess, or reuse it.",
                 required: ["turn_id", "expected_approval_fingerprint"],
+                optional: ["expected_terminal_token"],
+                terminal_scoped_scope: "Only the latest list-prefilled Codex conversation_id/token action may approve a managed current prompt without a usable Turn owner. It remains human-confirmed, revalidates exact terminal/process/Session/dispatch/prompt state before keys, never mutates managed state, has no durable dispatch receipt, cannot be auto-approved, and must not be blindly retried after an interrupted result.",
                 requires_explicit_user_confirmation: true,
                 requires_fresh_status: true
             },
@@ -5203,12 +5894,14 @@ function availableListActions(entry, { conversation } = {}) {
 }
 async function resolveConversationSelectorOption(commandName, options) {
     const sendOperation = commandName === "send";
-    if (sendOperation && stringValue(options.expectedTerminalToken)) {
+    if (stringValue(options.expectedTerminalToken)) {
         // Selector resolution may replace an alias (or an omitted selector) with a
         // discovered full terminal id. Preserve the caller's actual authority so
         // the handoff token fence cannot mistake that convenience resolution for
         // an exact selector supplied by the caller.
-        originalExpectedTerminalSelector.set(options, stringValue(options.session ?? options.conversation ?? options.conversationId)?.trim());
+        originalExpectedTerminalSelector.set(options, stringValue(sendOperation
+            ? options.session ?? options.conversation ?? options.conversationId
+            : options.turn ?? options.conversation ?? options.conversationId)?.trim());
     }
     if (!SESSION_SELECTOR_COMMANDS.has(String(commandName ?? "")) ||
         options.state) {
@@ -6342,7 +7035,101 @@ function exactBoundCodexStatusCardSourceForDeferredSend({ session, terminalId, t
             liveProcessBirth: processBirth
         }) === "same");
 }
-function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession, dispatchSnapshot }) {
+function exactCodexCandidateInventoryForDeferredSend({ inventory, sourceSession, pid, workspace, processUuid, processBirth }) {
+    const sourceNativeThreadId = sourceSession.binding?.native_thread_id;
+    return Boolean(inventory.roots.length > 0 &&
+        inventory.pid === pid &&
+        inventory.processUuid === processUuid &&
+        inventory.processBirth === processBirth &&
+        inventory.cwd &&
+        path.resolve(inventory.cwd) === path.resolve(workspace) &&
+        /^[0-9a-f]{64}$/u.test(inventory.inventoryFingerprint) &&
+        (sourceSession.binding?.native_process.rollout === undefined ||
+            (sourceNativeThreadId &&
+                inventory.roots.some((root) => root.sessionId.toLowerCase() === sourceNativeThreadId.toLowerCase()))));
+}
+function exactBoundCodexCandidateSourceForDeferredSend({ session, terminalId, terminalControl, pid, workspace, processUuid, processBirth, inventory }) {
+    const binding = session.binding;
+    const sourceNativeThreadId = binding?.native_thread_id;
+    const sourceRollout = binding?.native_process.rollout;
+    const inventoryRoot = inventory.roots.find((root) => root.sessionId.toLowerCase() === sourceNativeThreadId?.toLowerCase());
+    return Boolean(session.agent === "codex" &&
+        session.status === "bound" &&
+        binding &&
+        isExactNativeThreadId(sourceNativeThreadId) &&
+        isCompleteNativeRollout(sourceRollout) &&
+        inventoryRoot &&
+        exactNativeRolloutMatches(inventoryRoot.rollout, sourceRollout) &&
+        terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminalId, terminalControl) &&
+        path.resolve(session.workspace) === path.resolve(workspace) &&
+        processIncarnationRelationship({
+            binding,
+            livePid: pid,
+            liveProcessUuid: processUuid,
+            liveProcessBirth: processBirth
+        }) === "same" &&
+        exactCodexCandidateInventoryForDeferredSend({
+            inventory,
+            sourceSession: session,
+            pid,
+            workspace,
+            processUuid,
+            processBirth
+        }));
+}
+function deferredCandidateSourceTurnHistory(storeDir, session) {
+    const binding = session.binding;
+    if (!binding?.native_thread_id) {
+        return undefined;
+    }
+    const turns = managedTurnsForSession(storeDir, session.session_id);
+    if (turns.some((turn) => !TERMINAL_DISPATCH_RELEASE_STATUSES.has(turn.status) ||
+        managedTurnNeedsAttention(turn) ||
+        (isRecord(turn.callback_delivery) &&
+            turn.callback_delivery.status !== "delivered") ||
+        (Boolean(turn.gateway_method) &&
+            (!isRecord(turn.callback_delivery) ||
+                turn.callback_delivery.status !== "delivered")) ||
+        stringValue(turn.terminal_binding_id) !== binding.binding_id ||
+        Number(turn.terminal_binding_generation) !== binding.generation ||
+        (stringValue(turn.native_thread_id) ??
+            stringValue(isRecord(turn.native_session_takeover)
+                ? turn.native_session_takeover.terminal_agent_session_id
+                : undefined)) !== binding.native_thread_id)) {
+        return undefined;
+    }
+    return turns
+        .map((turn) => ({
+        turn_id: turnIdForConversation(turn),
+        status: turn.status,
+        updated_at: required(stringValue(turn.updated_at), `managed Turn ${turnIdForConversation(turn)} updated_at is unavailable`),
+        binding_id: binding.binding_id,
+        binding_generation: binding.generation,
+        native_thread_id: binding.native_thread_id,
+        turn_fingerprint: createHash("sha256")
+            .update(JSON.stringify(turn))
+            .digest("hex")
+    }))
+        .sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+}
+function candidateSourceTransitionHistoryIsTerminal(storeDir, session) {
+    if (managedSessionHasUnresolvedNativeTransition(storeDir, session)) {
+        return false;
+    }
+    if (!session.last_transition_id) {
+        return true;
+    }
+    try {
+        const transition = loadNativeThreadTransition(storeDir, session.last_transition_id);
+        return ["committed", "aborted"].includes(transition.status) &&
+            (transition.source_session_id === session.session_id ||
+                transition.target_session_id === session.session_id);
+    }
+    catch {
+        return false;
+    }
+}
+function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession, dispatchSnapshot, candidateInventory }) {
     const terminalToken = unmanagedTerminalBindingToken({
         terminalId,
         terminalControl,
@@ -6352,16 +7139,27 @@ function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid,
         processUuid,
         processBirth
     });
+    const candidateAuthority = candidateInventory
+        ? {
+            inventory_pid: candidateInventory.pid,
+            inventory_cwd: candidateInventory.cwd,
+            inventory_fingerprint: candidateInventory.inventoryFingerprint,
+            candidate_native_thread_ids: candidateInventory.roots.map((root) => root.sessionId)
+        }
+        : undefined;
     return createHash("sha256")
         .update(JSON.stringify({
-        version: 2,
+        version: candidateAuthority ? 3 : 2,
         kind: "deferred_codex_foreground_binding",
         terminal_token: terminalToken,
         source_session_id: sourceSession.session_id,
         source_revision: managedSessionRevision(sourceSession),
         source_binding_token: managedSessionBindingToken(sourceSession),
         terminal_dispatch_snapshot: dispatchSnapshot,
-        observation: "verified_absent"
+        observation: candidateAuthority
+            ? "exact_unbound_open_root_inventory"
+            : "verified_absent",
+        ...(candidateAuthority ?? {})
     }))
         .digest("hex");
 }
@@ -6660,37 +7458,91 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
         managedSessionBindingToken(source) !== expectedBindingToken) {
         throw new Error("the deferred Codex foreground source changed; refresh AKK list");
     }
-    if (!exactBoundCodexStatusCardSourceForDeferredSend({
-        session: { ...source, status: "bound" },
-        terminalId: boundary.terminal.conversationId,
-        terminalControl: boundary.terminal.terminalControl,
-        pid: boundary.terminal.pid,
-        workspace: boundary.terminal.terminalControl.currentPath,
-        processUuid: boundary.processUuid,
-        processBirth: boundary.processBirth
-    }) ||
-        source.last_transition_id !== (expectedSourceStatus === "bound" ? undefined : boundary.transferId) ||
-        managedSessionHasAnyNativeTransition(storeDir, source) ||
-        managedTurnsForSession(storeDir, source.session_id).length !== 0) {
-        throw new Error("the deferred Codex foreground source is no longer an isolated status-card binding");
+    if (source.last_transition_id !== (expectedSourceStatus === "bound"
+        ? boundary.sourcePreviousLastTransitionId
+        : boundary.transferId)) {
+        throw new Error("the deferred Codex foreground source transition authority changed");
     }
     const liveIncarnation = codexProcessIncarnationForPid(boundary.terminal.pid);
     if (liveIncarnation.processUuid !== boundary.processUuid ||
         liveIncarnation.processBirth !== boundary.processBirth) {
         throw new Error("the deferred Codex foreground process incarnation changed");
     }
-    const observation = await observeCurrentNativeAgentSessionIdentity({
-        options,
-        agent: "codex",
-        pid: boundary.terminal.pid,
-        cwd: boundary.terminal.terminalControl.currentPath
-    });
-    if (observation.status === "unavailable") {
-        throw new Error(`Codex native identity observation is unavailable: ${observation.reason}`);
+    let candidateInventoryForBoundary;
+    if (boundary.candidateAcceptanceAnchor) {
+        const inventory = await inspectCodexOpenRootRolloutInventory({
+            options,
+            pid: boundary.terminal.pid,
+            cwd: boundary.terminal.terminalControl.currentPath
+        });
+        candidateInventoryForBoundary = inventory;
+        if (inventory.inventoryFingerprint !==
+            boundary.candidateAcceptanceAnchor.inventory_fingerprint ||
+            !exactCodexCandidateInventoryForDeferredSend({
+                inventory,
+                sourceSession: source,
+                pid: boundary.terminal.pid,
+                workspace: required(boundary.terminal.terminalControl.currentPath, "deferred Codex terminal workspace is unavailable"),
+                processUuid: boundary.processUuid,
+                processBirth: boundary.processBirth
+            })) {
+            throw new Error("the exact Codex open-root inventory changed; refresh AKK list before sending");
+        }
     }
-    if (observation.status !== "verified_absent") {
-        throw new Error(`Codex materialized native thread ${observation.identity.sessionId}; ` +
-            "refresh AKK list before sending");
+    else {
+        const observation = await observeCurrentNativeAgentSessionIdentity({
+            options,
+            agent: "codex",
+            pid: boundary.terminal.pid,
+            cwd: boundary.terminal.terminalControl.currentPath
+        });
+        if (observation.status === "unavailable") {
+            throw new Error(`Codex native identity observation is unavailable: ${observation.reason}`);
+        }
+        if (observation.status !== "verified_absent") {
+            throw new Error(`Codex materialized native thread ${observation.identity.sessionId}; ` +
+                "refresh AKK list before sending");
+        }
+    }
+    const sourceAsBound = {
+        ...source,
+        status: "bound",
+        last_transition_id: boundary.sourcePreviousLastTransitionId
+    };
+    if (boundary.sourceKind === "status_card_only") {
+        if (!exactBoundCodexStatusCardSourceForDeferredSend({
+            session: sourceAsBound,
+            terminalId: boundary.terminal.conversationId,
+            terminalControl: boundary.terminal.terminalControl,
+            pid: boundary.terminal.pid,
+            workspace: boundary.terminal.terminalControl.currentPath,
+            processUuid: boundary.processUuid,
+            processBirth: boundary.processBirth
+        }) ||
+            managedTurnsForSession(storeDir, source.session_id).length !== 0 ||
+            boundary.sourcePreviousLastTransitionId !== undefined ||
+            managedSessionHasAnyNativeTransition(storeDir, sourceAsBound)) {
+            throw new Error("the deferred Codex foreground source is no longer an isolated status-card binding");
+        }
+    }
+    else {
+        const history = deferredCandidateSourceTurnHistory(storeDir, sourceAsBound);
+        if (!boundary.candidateAcceptanceAnchor ||
+            !history ||
+            JSON.stringify(history) !== JSON.stringify(boundary.sourceTurnHistory) ||
+            !exactBoundCodexCandidateSourceForDeferredSend({
+                session: sourceAsBound,
+                terminalId: boundary.terminal.conversationId,
+                terminalControl: boundary.terminal.terminalControl,
+                pid: boundary.terminal.pid,
+                workspace: required(boundary.terminal.terminalControl.currentPath, "deferred Codex terminal workspace is unavailable"),
+                processUuid: boundary.processUuid,
+                processBirth: boundary.processBirth,
+                inventory: required(candidateInventoryForBoundary, "deferred Codex candidate inventory is unavailable")
+            }) ||
+            !candidateSourceTransitionHistoryIsTerminal(storeDir, sourceAsBound)) {
+            throw new Error("the deferred Codex candidate source history or rollout authority changed");
+        }
     }
     if (requireNoDispatch) {
         assertTerminalIncarnationCanStartTurn(storeDir, boundary.terminal.terminalControl);
@@ -6704,7 +7556,8 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
     const status = await createTerminalAgentBridge(options).status("codex", boundary.terminal.terminalControl, {
         runtime: terminalRuntimeForLiveIdentity({
             terminal: boundary.terminal,
-            expectedEmptyNativeSession: true
+            expectedEmptyNativeSession: boundary.candidateAcceptanceAnchor === undefined,
+            physicalOnly: boundary.candidateAcceptanceAnchor !== undefined
         })
     });
     if (status.reachable !== true ||
@@ -6722,11 +7575,12 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
     }
     return source;
 }
-async function prepareDeferredCodexForegroundBinding({ options, terminal, sourceSession, observation, requestText }) {
+async function prepareDeferredCodexForegroundBinding({ options, terminal, sourceSession, observation, candidateInventory, requestText }) {
     const expectedToken = stringValue(options.expectedTerminalToken);
+    const candidateMode = Boolean(candidateInventory?.roots.length);
     if (terminal.agent !== "codex" ||
         !sourceSession?.binding ||
-        observation.status !== "verified_absent" ||
+        (observation.status !== "verified_absent" && !candidateMode) ||
         !expectedToken) {
         return undefined;
     }
@@ -6734,19 +7588,47 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
     const processBirth = sourceSession.binding.native_process.process_birth;
     const workspace = terminal.terminalControl.currentPath;
     const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    const storeDir = storeDirFromOptions(options);
+    const sourceKind = sourceSession.binding.native_process.rollout
+        ? "candidate_rollout_quiescent"
+        : "status_card_only";
+    const candidateSourceTurnHistory = sourceKind ===
+        "candidate_rollout_quiescent"
+        ? deferredCandidateSourceTurnHistory(storeDir, sourceSession)
+        : undefined;
+    const exactSource = !workspace
+        ? false
+        : sourceKind === "candidate_rollout_quiescent"
+            ? candidateInventory !== undefined &&
+                candidateSourceTurnHistory !== undefined &&
+                candidateSourceTransitionHistoryIsTerminal(storeDir, sourceSession) &&
+                exactBoundCodexCandidateSourceForDeferredSend({
+                    session: sourceSession,
+                    terminalId: terminal.conversationId,
+                    terminalControl: terminal.terminalControl,
+                    pid: terminal.pid,
+                    workspace,
+                    processUuid: liveIncarnation.processUuid,
+                    processBirth: liveIncarnation.processBirth,
+                    inventory: candidateInventory
+                })
+            : exactBoundCodexStatusCardSourceForDeferredSend({
+                session: sourceSession,
+                terminalId: terminal.conversationId,
+                terminalControl: terminal.terminalControl,
+                pid: terminal.pid,
+                workspace,
+                processUuid: liveIncarnation.processUuid,
+                processBirth: liveIncarnation.processBirth
+            }) &&
+                managedTurnsForSession(storeDir, sourceSession.session_id).length === 0 &&
+                !sourceSession.last_transition_id &&
+                !managedSessionHasAnyNativeTransition(storeDir, sourceSession);
     if (!processUuid ||
         !processBirth ||
         !workspace ||
         !hasCanonicalTerminalEndpoint(terminal.terminalControl) ||
-        !exactBoundCodexStatusCardSourceForDeferredSend({
-            session: sourceSession,
-            terminalId: terminal.conversationId,
-            terminalControl: terminal.terminalControl,
-            pid: terminal.pid,
-            workspace,
-            processUuid: liveIncarnation.processUuid,
-            processBirth: liveIncarnation.processBirth
-        })) {
+        !exactSource) {
         return undefined;
     }
     const dispatchSnapshot = deferredCodexForegroundDispatchSnapshot(terminal.terminalControl);
@@ -6758,7 +7640,8 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         processUuid,
         processBirth,
         sourceSession,
-        dispatchSnapshot
+        dispatchSnapshot,
+        ...(candidateMode ? { candidateInventory } : {})
     });
     if (expectedToken !== token) {
         throw new Error("deferred Codex foreground binding requires the fresh exact terminal " +
@@ -6766,6 +7649,12 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
     }
     const targetSessionId = createManagedSessionId();
     const transferId = createDeferredForegroundTransferId();
+    const candidateAcceptanceAnchor = candidateMode
+        ? captureCodexCandidateSetRolloutAcceptanceAnchor({
+            inventory: required(candidateInventory, "Codex candidate inventory is unavailable"),
+            now: cliNow()
+        })
+        : undefined;
     const boundary = {
         terminal,
         transferId,
@@ -6775,7 +7664,15 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         sourceBoundBindingToken: managedSessionBindingToken(sourceSession),
         processUuid,
         processBirth,
-        previousDispatchSnapshot: dispatchSnapshot
+        previousDispatchSnapshot: dispatchSnapshot,
+        sourceKind,
+        ...(sourceSession.last_transition_id
+            ? { sourcePreviousLastTransitionId: sourceSession.last_transition_id }
+            : {}),
+        ...(candidateSourceTurnHistory
+            ? { sourceTurnHistory: candidateSourceTurnHistory }
+            : {}),
+        ...(candidateAcceptanceAnchor ? { candidateAcceptanceAnchor } : {})
     };
     await assertDeferredCodexForegroundBindingBoundary({
         options,
@@ -6793,8 +7690,7 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         terminalControl: terminal.terminalControl,
         excludedManagedSessionId: sourceSession.session_id
     });
-    const storeDir = storeDirFromOptions(options);
-    const existingTransfer = listDeferredForegroundTransfers(storeDir).find((candidate) => !["resolved", "aborted", "abort_resolved"].includes(candidate.status) &&
+    const existingTransfer = listDeferredForegroundTransfers(storeDir).find((candidate) => !["resolved", "abort_resolved"].includes(candidate.status) &&
         (candidate.source_session_id === sourceSession.session_id ||
             (candidate.terminal_id === terminal.conversationId &&
                 terminalControlEvidenceMatches(candidate.terminal_endpoint, terminal.terminalControl))));
@@ -6804,7 +7700,7 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
     }
     saveDeferredForegroundTransfer(storeDir, {
         schema: "agent-knock-knock/deferred-foreground-transfer",
-        version: 1,
+        version: 2,
         transfer_id: transferId,
         status: "prepared",
         input_stage: "none",
@@ -6819,6 +7715,10 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         source_binding_token: managedSessionBindingToken(sourceSession),
         source_previous_last_transition_id: sourceSession.last_transition_id,
         source_before_binding: sourceSession.binding,
+        source_kind: sourceKind,
+        ...(candidateSourceTurnHistory
+            ? { source_turn_history: candidateSourceTurnHistory }
+            : {}),
         target_session_id: targetSessionId,
         target_expected_revision: null,
         previous_dispatch_status: dispatchSnapshot.status,
@@ -6846,6 +7746,13 @@ function assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary })
             boundary.previousDispatchSnapshot.status ||
         transfer.previous_dispatch_fingerprint !==
             boundary.previousDispatchSnapshot.fingerprint ||
+        (transfer.version === 1
+            ? "status_card_only"
+            : transfer.source_kind) !== boundary.sourceKind ||
+        JSON.stringify(transfer.source_turn_history) !==
+            JSON.stringify(boundary.sourceTurnHistory) ||
+        transfer.source_previous_last_transition_id !==
+            boundary.sourcePreviousLastTransitionId ||
         transfer.process_pid !== boundary.terminal.pid ||
         transfer.process_uuid !== boundary.processUuid ||
         transfer.process_birth !== boundary.processBirth ||
@@ -10757,209 +11664,215 @@ function terminalBridgeApprovalInstructions({ conversation, terminalControl, ter
     ].filter((line) => line !== undefined).join("\n");
 }
 function recordTerminalBridgeApprovalNotification({ statePath, logPath, terminalControl, terminalStatus, fingerprint, expectedConversation, onRecorded }) {
-    const releaseLock = acquireFileLock(`${statePath}.lock`);
-    try {
-        const conversation = loadState(statePath);
-        const currentNativeTakeover = isRecord(conversation.native_session_takeover)
-            ? conversation.native_session_takeover
-            : undefined;
-        const currentTerminalControl = terminalControlFromTakeover(currentNativeTakeover);
-        if (!isWaitingForAgent(conversation.status) ||
-            conversation.conversation_id !== expectedConversation.conversationId ||
-            conversation.status !== expectedConversation.status ||
-            conversation.updated_at !== expectedConversation.updatedAt ||
-            currentNativeTakeover?.terminal_bridge !== true ||
-            stringValue(currentNativeTakeover.terminal_bridge_message_id) !==
-                expectedConversation.messageId ||
-            !currentTerminalControl ||
-            !terminalControlsShareIncarnation(currentTerminalControl, terminalControl)) {
-            return {
-                conversation,
-                duplicate: false,
-                stale: true,
-                recorded: undefined
-            };
-        }
-        const nativeTakeover = isRecord(conversation.native_session_takeover)
-            ? { ...conversation.native_session_takeover }
-            : {};
-        const approvalScreenDigest = stringValue(isRecord(terminalStatus?.screen)
-            ? terminalStatus.screen.digest
-            : undefined);
-        const previousApproval = isRecord(nativeTakeover.terminal_bridge_approval)
-            ? nativeTakeover.terminal_bridge_approval
-            : undefined;
-        const previousNotifiedAt = validTimestampMs(previousApproval?.notified_at);
-        const callbackDelivery = isRecord(conversation.callback_delivery)
-            ? conversation.callback_delivery
-            : undefined;
-        const callbackMessage = isRecord(callbackDelivery?.message)
-            ? callbackDelivery.message
-            : undefined;
-        const previousCallbackMessageId = stringValue(previousApproval?.callback_message_id);
-        const matchingApprovalOutbox = callbackDelivery?.kind === "approval_notification" &&
-            previousCallbackMessageId !== undefined &&
-            callbackMessage?.id === previousCallbackMessageId;
-        const callbackDeliveryStatus = stringValue(callbackDelivery?.status);
-        const callbackDeliveryAttempts = Number(callbackDelivery?.attempts ?? 0);
-        const conflictingActiveOutbox = !matchingApprovalOutbox &&
-            (callbackDeliveryStatus === "pending" ||
-                (callbackDeliveryStatus === "failed" &&
-                    Number.isFinite(callbackDeliveryAttempts) &&
-                    callbackDeliveryAttempts <= CALLBACK_RETRY_DELAYS_MS.length));
-        if (previousApproval?.fingerprint === fingerprint &&
-            previousNotifiedAt !== undefined &&
-            cliNowMs() - previousNotifiedAt <= CLAUDE_SCREEN_APPROVAL_TTL_MS) {
-            if (conflictingActiveOutbox) {
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+    return withStoreWriterLease(storeDir, () => {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const conversation = loadState(statePath);
+            const currentNativeTakeover = isRecord(conversation.native_session_takeover)
+                ? conversation.native_session_takeover
+                : undefined;
+            const currentTerminalControl = terminalControlFromTakeover(currentNativeTakeover);
+            if (!isWaitingForAgent(conversation.status) ||
+                conversation.conversation_id !== expectedConversation.conversationId ||
+                conversation.status !== expectedConversation.status ||
+                conversation.updated_at !== expectedConversation.updatedAt ||
+                currentNativeTakeover?.terminal_bridge !== true ||
+                stringValue(currentNativeTakeover.terminal_bridge_message_id) !==
+                    expectedConversation.messageId ||
+                !currentTerminalControl ||
+                !terminalControlsShareIncarnation(currentTerminalControl, terminalControl)) {
                 return {
                     conversation,
                     duplicate: false,
                     stale: true,
-                    deferred: true,
-                    previousApproval,
                     recorded: undefined
                 };
             }
-            if (!matchingApprovalOutbox && !conflictingActiveOutbox) {
-                const recoveryMessageId = previousCallbackMessageId ?? `msg-${randomUUID()}`;
-                const recoveryMessageTs = stringValue(previousApproval?.callback_message_ts) ??
-                    stringValue(previousApproval?.notified_at) ??
-                    cliNow().toISOString();
-                const recoveryConversation = previousCallbackMessageId
-                    ? conversation
-                    : {
-                        ...conversation,
-                        native_session_takeover: {
-                            ...nativeTakeover,
-                            terminal_bridge_approval: {
-                                ...previousApproval,
-                                callback_message_id: recoveryMessageId,
-                                callback_message_ts: recoveryMessageTs
+            const nativeTakeover = isRecord(conversation.native_session_takeover)
+                ? { ...conversation.native_session_takeover }
+                : {};
+            const approvalScreenDigest = stringValue(isRecord(terminalStatus?.screen)
+                ? terminalStatus.screen.digest
+                : undefined);
+            const previousApproval = isRecord(nativeTakeover.terminal_bridge_approval)
+                ? nativeTakeover.terminal_bridge_approval
+                : undefined;
+            const previousNotifiedAt = validTimestampMs(previousApproval?.notified_at);
+            const callbackDelivery = isRecord(conversation.callback_delivery)
+                ? conversation.callback_delivery
+                : undefined;
+            const callbackMessage = isRecord(callbackDelivery?.message)
+                ? callbackDelivery.message
+                : undefined;
+            const previousCallbackMessageId = stringValue(previousApproval?.callback_message_id);
+            const matchingApprovalOutbox = callbackDelivery?.kind === "approval_notification" &&
+                previousCallbackMessageId !== undefined &&
+                callbackMessage?.id === previousCallbackMessageId;
+            const callbackDeliveryStatus = stringValue(callbackDelivery?.status);
+            const callbackDeliveryAttempts = Number(callbackDelivery?.attempts ?? 0);
+            const conflictingActiveOutbox = !matchingApprovalOutbox &&
+                (callbackDeliveryStatus === "pending" ||
+                    (callbackDeliveryStatus === "failed" &&
+                        Number.isFinite(callbackDeliveryAttempts) &&
+                        callbackDeliveryAttempts <= CALLBACK_RETRY_DELAYS_MS.length));
+            if (previousApproval?.fingerprint === fingerprint &&
+                previousNotifiedAt !== undefined &&
+                cliNowMs() - previousNotifiedAt <= CLAUDE_SCREEN_APPROVAL_TTL_MS) {
+                if (conflictingActiveOutbox) {
+                    return {
+                        conversation,
+                        duplicate: false,
+                        stale: true,
+                        deferred: true,
+                        previousApproval,
+                        recorded: undefined
+                    };
+                }
+                if (!matchingApprovalOutbox && !conflictingActiveOutbox) {
+                    const recoveryMessageId = previousCallbackMessageId ?? `msg-${randomUUID()}`;
+                    const recoveryMessageTs = stringValue(previousApproval?.callback_message_ts) ??
+                        stringValue(previousApproval?.notified_at) ??
+                        cliNow().toISOString();
+                    const recoveryConversation = previousCallbackMessageId
+                        ? conversation
+                        : {
+                            ...conversation,
+                            native_session_takeover: {
+                                ...nativeTakeover,
+                                terminal_bridge_approval: {
+                                    ...previousApproval,
+                                    callback_message_id: recoveryMessageId,
+                                    callback_message_ts: recoveryMessageTs
+                                }
                             }
-                        }
+                        };
+                    if (!previousCallbackMessageId) {
+                        saveState(statePath, recoveryConversation);
+                    }
+                    const recorded = onRecorded?.(recoveryConversation, {
+                        recoverMissingOutbox: true
+                    });
+                    appendEvent(logPath, {
+                        ts: cliNow().toISOString(),
+                        conversation_id: recoveryConversation.conversation_id,
+                        event: "terminal_bridge_approval_notification_outbox_recovered",
+                        terminal_control: terminalControl,
+                        fingerprint,
+                        callback_message_id: recoveryMessageId
+                    });
+                    return {
+                        conversation: isRecord(recorded) && isRecord(recorded.prepared)
+                            ? recorded.prepared.conversation
+                            : recoveryConversation,
+                        duplicate: false,
+                        recovered: true,
+                        stale: false,
+                        previousApproval,
+                        recorded
                     };
-                if (!previousCallbackMessageId) {
-                    saveState(statePath, recoveryConversation);
                 }
-                const recorded = onRecorded?.(recoveryConversation, {
-                    recoverMissingOutbox: true
-                });
-                appendEvent(logPath, {
-                    ts: cliNow().toISOString(),
-                    conversation_id: recoveryConversation.conversation_id,
-                    event: "terminal_bridge_approval_notification_outbox_recovered",
-                    terminal_control: terminalControl,
-                    fingerprint,
-                    callback_message_id: recoveryMessageId
-                });
                 return {
-                    conversation: isRecord(recorded) && isRecord(recorded.prepared)
-                        ? recorded.prepared.conversation
-                        : recoveryConversation,
-                    duplicate: false,
-                    recovered: true,
+                    conversation,
+                    duplicate: true,
                     stale: false,
                     previousApproval,
-                    recorded
+                    recorded: undefined
                 };
             }
+            const now = cliNow().toISOString();
+            const callbackMessageId = `msg-${randomUUID()}`;
+            const nextConversation = {
+                ...conversation,
+                native_session_takeover: {
+                    ...nativeTakeover,
+                    terminal_bridge_approval: {
+                        fingerprint,
+                        screen_digest: approvalScreenDigest,
+                        notified_at: now,
+                        terminal_control: terminalControl,
+                        approval_state: terminalStatus.approval_state,
+                        callback_message_id: callbackMessageId,
+                        callback_message_ts: now
+                    }
+                },
+                updated_at: now
+            };
+            // Persist the stable callback identity before any message/outbox event. If
+            // the process exits during callback preparation, recovery can recreate the
+            // exact same message and safely finish the outbox transaction.
+            saveState(statePath, nextConversation);
+            appendEvent(logPath, {
+                ts: now,
+                conversation_id: conversation.conversation_id,
+                event: "terminal_bridge_approval_notification_recorded",
+                terminal_control: terminalControl,
+                fingerprint,
+                screen_digest: approvalScreenDigest
+            });
+            const recorded = onRecorded?.(nextConversation);
             return {
-                conversation,
-                duplicate: true,
+                conversation: isRecord(recorded) && isRecord(recorded.prepared)
+                    ? recorded.prepared.conversation
+                    : nextConversation,
+                duplicate: false,
                 stale: false,
-                previousApproval,
-                recorded: undefined
+                recorded
             };
         }
-        const now = cliNow().toISOString();
-        const callbackMessageId = `msg-${randomUUID()}`;
-        const nextConversation = {
-            ...conversation,
-            native_session_takeover: {
-                ...nativeTakeover,
-                terminal_bridge_approval: {
-                    fingerprint,
-                    screen_digest: approvalScreenDigest,
-                    notified_at: now,
-                    terminal_control: terminalControl,
-                    approval_state: terminalStatus.approval_state,
-                    callback_message_id: callbackMessageId,
-                    callback_message_ts: now
-                }
-            },
-            updated_at: now
-        };
-        // Persist the stable callback identity before any message/outbox event. If
-        // the process exits during callback preparation, recovery can recreate the
-        // exact same message and safely finish the outbox transaction.
-        saveState(statePath, nextConversation);
-        appendEvent(logPath, {
-            ts: now,
-            conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_approval_notification_recorded",
-            terminal_control: terminalControl,
-            fingerprint,
-            screen_digest: approvalScreenDigest
-        });
-        const recorded = onRecorded?.(nextConversation);
-        return {
-            conversation: isRecord(recorded) && isRecord(recorded.prepared)
-                ? recorded.prepared.conversation
-                : nextConversation,
-            duplicate: false,
-            stale: false,
-            recorded
-        };
-    }
-    finally {
-        releaseLock();
-    }
+        finally {
+            releaseLock();
+        }
+    });
 }
 function markTerminalBridgeApprovalPromptCleared({ statePath, logPath, expectedConversationId, expectedMessageId }) {
-    const releaseLock = acquireFileLock(`${statePath}.lock`);
-    try {
-        const conversation = loadState(statePath);
-        const nativeTakeover = isRecord(conversation.native_session_takeover)
-            ? conversation.native_session_takeover
-            : undefined;
-        if (conversation.conversation_id !== expectedConversationId ||
-            conversation.status !== "waiting_for_agent" ||
-            nativeTakeover?.terminal_bridge !== true ||
-            stringValue(nativeTakeover.terminal_bridge_message_id) !==
-                expectedMessageId ||
-            stringValue(nativeTakeover.terminal_bridge_last_approval_message_id) !==
-                expectedMessageId ||
-            validTimestampMs(nativeTakeover.terminal_bridge_approval_resolved_at) === undefined ||
-            validTimestampMs(nativeTakeover.terminal_bridge_last_approval_prompt_cleared_at) !== undefined) {
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+    return withStoreWriterLease(storeDir, () => {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const conversation = loadState(statePath);
+            const nativeTakeover = isRecord(conversation.native_session_takeover)
+                ? conversation.native_session_takeover
+                : undefined;
+            if (conversation.conversation_id !== expectedConversationId ||
+                conversation.status !== "waiting_for_agent" ||
+                nativeTakeover?.terminal_bridge !== true ||
+                stringValue(nativeTakeover.terminal_bridge_message_id) !==
+                    expectedMessageId ||
+                stringValue(nativeTakeover.terminal_bridge_last_approval_message_id) !==
+                    expectedMessageId ||
+                validTimestampMs(nativeTakeover.terminal_bridge_approval_resolved_at) === undefined ||
+                validTimestampMs(nativeTakeover.terminal_bridge_last_approval_prompt_cleared_at) !== undefined) {
+                return {
+                    conversation,
+                    marked: false
+                };
+            }
+            const clearedAt = cliNow().toISOString();
+            const nextConversation = {
+                ...conversation,
+                native_session_takeover: {
+                    ...nativeTakeover,
+                    terminal_bridge_last_approval_prompt_cleared_at: clearedAt
+                },
+                updated_at: clearedAt
+            };
+            saveState(statePath, nextConversation);
+            appendEvent(logPath, {
+                ts: clearedAt,
+                conversation_id: conversation.conversation_id,
+                event: "terminal_bridge_approval_prompt_cleared",
+                terminal_bridge_message_id: expectedMessageId
+            });
             return {
-                conversation,
-                marked: false
+                conversation: nextConversation,
+                marked: true
             };
         }
-        const clearedAt = cliNow().toISOString();
-        const nextConversation = {
-            ...conversation,
-            native_session_takeover: {
-                ...nativeTakeover,
-                terminal_bridge_last_approval_prompt_cleared_at: clearedAt
-            },
-            updated_at: clearedAt
-        };
-        saveState(statePath, nextConversation);
-        appendEvent(logPath, {
-            ts: clearedAt,
-            conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_approval_prompt_cleared",
-            terminal_bridge_message_id: expectedMessageId
-        });
-        return {
-            conversation: nextConversation,
-            marked: true
-        };
-    }
-    finally {
-        releaseLock();
-    }
+        finally {
+            releaseLock();
+        }
+    });
 }
 function terminalBridgeApprovalCallbackIdentity(conversation) {
     const nativeTakeover = isRecord(conversation?.native_session_takeover)
@@ -11126,7 +12039,28 @@ async function runSend(options) {
                     allowedCompanionIdentity: knownCodexCompanions.primary,
                     allowedAdditionalIdentities: knownCodexCompanions.additional
                 });
-                if (nativeIdentityObservation.status === "unavailable") {
+                let deferredCodexCandidateInventory;
+                if (terminalConversation.agent === "codex" &&
+                    stringValue(options.expectedTerminalToken)) {
+                    try {
+                        const inventory = await inspectCodexOpenRootRolloutInventory({
+                            options,
+                            pid: terminalConversation.pid,
+                            cwd: terminalConversation.terminalControl.currentPath
+                        });
+                        if (inventory.roots.length > 0) {
+                            deferredCodexCandidateInventory = inventory;
+                        }
+                    }
+                    catch (error) {
+                        if (nativeIdentityObservation.status === "unavailable") {
+                            throw new Error(`native Codex identity observation is unavailable and its exact ` +
+                                `open-root inventory could not be proven: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+                if (nativeIdentityObservation.status === "unavailable" &&
+                    !deferredCodexCandidateInventory) {
                     throw new Error(`native ${terminalConversation.agent} identity observation is ` +
                         `unavailable: ${nativeIdentityObservation.reason}`);
                 }
@@ -11166,6 +12100,7 @@ async function runSend(options) {
                         terminal: terminalConversation,
                         sourceSession: claimedSession,
                         observation: nativeIdentityObservation,
+                        candidateInventory: deferredCodexCandidateInventory,
                         requestText: String(messageBody)
                     })
                     : undefined;
@@ -11762,12 +12697,16 @@ async function runTurnResponse({ options, messageBody }) {
 async function runApprove(options) {
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
+        assertExpectedHandoffTokenUsesExactTerminalSelector({
+            options,
+            terminal: terminalConversation
+        });
+        if (options.autoApproved === true) {
+            throw new Error("automatic approval requires an exact managed Turn and cannot use a raw terminal selector");
+        }
         await runTerminalConversationApprove({
             options,
-            conversationId: terminalConversation.conversationId,
-            agent: terminalConversation.agent,
-            terminalControl: terminalConversation.terminalControl,
-            pid: terminalConversation.pid
+            terminal: terminalConversation
         });
         return;
     }
@@ -12276,8 +13215,10 @@ async function runApprove(options) {
         }
     }
 }
-async function runTerminalConversationApprove({ options, conversationId, agent, terminalControl, pid }) {
-    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
+async function runTerminalConversationApprove({ options, terminal }) {
+    const { conversationId, agent, terminalControl, pid } = terminal;
+    const storeDir = storeDirFromOptions(options);
+    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, terminalControl, { timeoutMs: 30000 });
     try {
         if (agent === "claude") {
             printJson({
@@ -12290,16 +13231,74 @@ async function runTerminalConversationApprove({ options, conversationId, agent,
             });
             return;
         }
-        const approval = await createTerminalAgentBridge(options).approve(agent, terminalControl, {
+        const suppliedTerminalToken = stringValue(options.expectedTerminalToken);
+        const initialResolution = await resolveTerminalScopedCodexApproval({
+            options,
+            terminal
+        });
+        if (initialResolution.state === "blocked") {
+            throw new Error(initialResolution.reason);
+        }
+        if (initialResolution.state === "unmanaged" && suppliedTerminalToken) {
+            throw new Error("--expected-terminal-token does not match an advertised terminal-scoped Codex approval");
+        }
+        if (initialResolution.state === "eligible" &&
+            suppliedTerminalToken !== initialResolution.boundary.token) {
+            throw new Error("terminal-scoped Codex approval token is missing or stale; refresh AKK list");
+        }
+        const runtime = {
+            pid,
+            cwd: terminalControl.currentPath,
+            conversationId,
+            terminalTarget: terminalControl.target
+        };
+        const approveCurrentPrompt = async (terminalScoped) => createTerminalAgentBridge(options).approve(agent, terminalControl, {
             expectedFingerprint: stringValue(options.expectedApprovalFingerprint),
             scrollbackLines: Number(options.scrollbackLines ?? 120),
-            runtime: {
-                pid,
-                cwd: terminalControl.currentPath,
-                conversationId,
-                terminalTarget: terminalControl.target
-            }
+            runtime,
+            beforeKeyDispatch: terminalScoped
+                ? async (context) => {
+                    const approvalSnapshot = terminalScopedCodexApprovalPromptSnapshot({
+                        approvable: true,
+                        fingerprint: context.fingerprint,
+                        keys: context.keys,
+                        decision_mode: context.inspection.approval.approvable
+                            ? context.inspection.approval.action.mode ?? "keys"
+                            : undefined,
+                        request_id: context.inspection.approval.approvable
+                            ? context.inspection.approval.action.requestId
+                            : undefined
+                    });
+                    const current = await resolveTerminalScopedCodexApproval({
+                        options,
+                        terminal,
+                        approvalSnapshot
+                    });
+                    if (current.state !== "eligible" ||
+                        current.boundary.token !== suppliedTerminalToken) {
+                        throw new Error(current.state === "blocked"
+                            ? current.reason
+                            : "terminal-scoped Codex approval authority changed before key dispatch");
+                    }
+                }
+                : undefined
         });
+        const terminalScoped = initialResolution.state === "eligible";
+        const approval = terminalScoped
+            ? await withStoreWriterLeaseAsync(storeDir, async () => {
+                const current = await resolveTerminalScopedCodexApproval({
+                    options,
+                    terminal
+                });
+                if (current.state !== "eligible" ||
+                    current.boundary.token !== suppliedTerminalToken) {
+                    throw new Error(current.state === "blocked"
+                        ? current.reason
+                        : "terminal-scoped Codex approval authority changed while waiting for Store control");
+                }
+                return approveCurrentPrompt(true);
+            })
+            : await approveCurrentPrompt(false);
         if (!approval.approved) {
             printJson({
                 conversation_id: conversationId,
@@ -12332,7 +13331,14 @@ async function runTerminalConversationApprove({ options, conversationId, agent,
             label: approval.label,
             approval_fingerprint: approval.fingerprint,
             decision_mode: approval.decisionMode,
-            request_id: approval.requestId
+            request_id: approval.requestId,
+            terminal_scoped: terminalScoped,
+            ...(terminalScoped
+                ? {
+                    durable_dispatch_receipt: false,
+                    uncertain_outcome_recovery: "refresh status and inspect the live prompt; do not retry blindly"
+                }
+                : {})
         });
     }
     finally {
@@ -12570,17 +13576,20 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         : undefined;
     const terminalAgentPid = Number(sendTakeover?.terminal_agent_pid);
     const expectedManagedNativeThreadId = stringValue(sendTakeover?.terminal_agent_expected_session_id) ?? stringValue(sendTakeover?.terminal_agent_session_id);
-    const currentNativeIdentity = await resolveCurrentNativeAgentSessionIdentity({
-        options,
-        agent: executor.kind,
-        pid: terminalAgentPid,
-        cwd: terminalControl.currentPath,
-        preferredSessionId: allowedPreMaterializationIdentity
-            ? expectedManagedNativeThreadId
-            : undefined,
-        allowedCompanionIdentity: allowedPreMaterializationIdentity,
-        allowedAdditionalIdentities
-    });
+    const currentNativeIdentity = deferredCodexForegroundBinding
+        ?.candidateAcceptanceAnchor
+        ? undefined
+        : await resolveCurrentNativeAgentSessionIdentity({
+            options,
+            agent: executor.kind,
+            pid: terminalAgentPid,
+            cwd: terminalControl.currentPath,
+            preferredSessionId: allowedPreMaterializationIdentity
+                ? expectedManagedNativeThreadId
+                : undefined,
+            allowedCompanionIdentity: allowedPreMaterializationIdentity,
+            allowedAdditionalIdentities
+        });
     const virginRawAttach = Boolean(recordRawAttachmentAfterSend &&
         !stringValue(sendTakeover?.terminal_agent_session_id));
     const pendingManagedNativeBinding = Boolean(!stringValue(sendTakeover?.terminal_agent_session_id) &&
@@ -12600,7 +13609,12 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         });
     }
     const preSendRuntime = {
-        ...terminalRuntimeIdentityForConversation(nextConversation, terminalControl),
+        ...(deferredCodexForegroundBinding?.candidateAcceptanceAnchor
+            ? terminalRuntimeForLiveIdentity({
+                terminal: deferredCodexForegroundBinding.terminal,
+                physicalOnly: true
+            })
+            : terminalRuntimeIdentityForConversation(nextConversation, terminalControl)),
         allowedPreMaterializationNativeIdentity: allowedPreMaterializationIdentity,
         allowedAdditionalNativeIdentities: allowedAdditionalIdentities,
         messageId: message.id
@@ -12661,7 +13675,8 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     boundProcessUuid: stringValue(sendTakeover?.terminal_agent_process_uuid),
                     boundProcessBirth: stringValue(sendTakeover?.terminal_agent_process_birth),
                     allowedPreMaterializationIdentity,
-                    needsPostSendNativeBinding
+                    needsPostSendNativeBinding,
+                    candidateSetAnchor: deferredCodexForegroundBinding?.candidateAcceptanceAnchor
                 });
             }
             else {
@@ -13196,6 +14211,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             cliExit(86);
         }
         let submittedBase = stagedConversation;
+        let deferredCandidateBindingPending = false;
         if (needsPostSendNativeBinding) {
             let boundIdentity;
             let boundConversation;
@@ -13203,7 +14219,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             try {
                 if (deferredCodexForegroundBinding &&
                     !allowsSyntheticTerminalAcceptance(options) &&
-                    codexRolloutAcceptanceAnchor?.version !== 2) {
+                    ![2, 3].includes(Number(codexRolloutAcceptanceAnchor?.version))) {
                     throw new Error("deferred Codex foreground binding requires a virgin rollout acceptance anchor");
                 }
                 boundIdentity = await pollNativeAgentSessionIdentity({
@@ -13215,7 +14231,8 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     allowedPreMaterializationIdentity,
                     allowedAdditionalIdentities,
                     ...(deferredCodexForegroundBinding &&
-                        codexRolloutAcceptanceAnchor?.version === 2
+                        codexRolloutAcceptanceAnchor &&
+                        [2, 3].includes(codexRolloutAcceptanceAnchor.version)
                         ? {
                             requiredCodexAcceptance: {
                                 anchor: codexRolloutAcceptanceAnchor,
@@ -13342,138 +14359,154 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 }
             }
             if (!boundIdentity) {
-                const bindingFailedAt = cliNow().toISOString();
-                const bindingReason = bindingError
-                    ? `AKK dispatched terminal input but could not verify the new native agent session: ${bindingError}`
-                    : "AKK dispatched terminal input but no exact native agent session appeared within the binding window";
-                if (deferredCodexForegroundBinding) {
-                    try {
-                        markDeferredCodexForegroundTransferUncertain({
-                            options,
-                            boundary: deferredCodexForegroundBinding,
-                            reason: bindingReason
-                        });
+                if (deferredCodexForegroundBinding &&
+                    codexRolloutAcceptanceAnchor?.version === 3 &&
+                    bindingError === undefined) {
+                    // The exact candidate inventory is still stable but Codex has not
+                    // materialized the request in any root yet. Enter is durable; keep
+                    // the transfer fenced at dispatch_started and let the monitor or a
+                    // later dedicated recovery finish the UUID binding without replay.
+                    deferredCandidateBindingPending = true;
+                    submittedBase = stagedConversation;
+                }
+                else {
+                    const bindingFailedAt = cliNow().toISOString();
+                    const bindingReason = bindingError
+                        ? `AKK dispatched terminal input but could not verify the new native agent session: ${bindingError}`
+                        : "AKK dispatched terminal input but no exact native agent session appeared within the binding window";
+                    if (deferredCodexForegroundBinding) {
+                        try {
+                            markDeferredCodexForegroundTransferUncertain({
+                                options,
+                                boundary: deferredCodexForegroundBinding,
+                                reason: bindingReason
+                            });
+                        }
+                        catch (error) {
+                            runtimeLog("error", "deferred_codex_foreground_uncertain_persist_failed", {
+                                transfer_id: deferredCodexForegroundBinding.transferId,
+                                error: error instanceof Error ? error.message : String(error)
+                            });
+                        }
                     }
-                    catch (error) {
-                        runtimeLog("error", "deferred_codex_foreground_uncertain_persist_failed", {
-                            transfer_id: deferredCodexForegroundBinding.transferId,
-                            error: error instanceof Error ? error.message : String(error)
+                    const unfencedBase = {
+                        ...stagedConversation,
+                        status: "stalled",
+                        stalled_at: bindingFailedAt,
+                        stalled_reason: bindingReason,
+                        native_session_takeover: {
+                            ...(isRecord(stagedConversation.native_session_takeover)
+                                ? stagedConversation.native_session_takeover
+                                : {}),
+                            terminal_agent_identity_status: "unresolved_after_submit",
+                            terminal_agent_identity_error: textSummary(bindingReason)
+                        },
+                        updated_at: bindingFailedAt
+                    };
+                    const unfencedConversation = withTerminalBridgeSubmission({
+                        conversation: unfencedBase,
+                        messageId: message.id,
+                        messageType: message.type,
+                        messageBody: String(message.body),
+                        requestText: terminalPayload,
+                        status: "uncertain",
+                        preparedAt: bridgeStartedAt,
+                        textInjectedAt,
+                        enterDispatchedAt,
+                        uncertainAt: bindingFailedAt,
+                        error: bindingReason,
+                        lastProvenStage: "enter_dispatched"
+                    });
+                    if (!deferredCodexForegroundBinding) {
+                        quarantineManagedSessionBinding({
+                            conversation: unfencedConversation,
+                            reason: bindingReason
                         });
                     }
-                }
-                const unfencedBase = {
-                    ...stagedConversation,
-                    status: "stalled",
-                    stalled_at: bindingFailedAt,
-                    stalled_reason: bindingReason,
-                    native_session_takeover: {
-                        ...(isRecord(stagedConversation.native_session_takeover)
-                            ? stagedConversation.native_session_takeover
-                            : {}),
-                        terminal_agent_identity_status: "unresolved_after_submit",
-                        terminal_agent_identity_error: textSummary(bindingReason)
-                    },
-                    updated_at: bindingFailedAt
-                };
-                const unfencedConversation = withTerminalBridgeSubmission({
-                    conversation: unfencedBase,
-                    messageId: message.id,
-                    messageType: message.type,
-                    messageBody: String(message.body),
-                    requestText: terminalPayload,
-                    status: "uncertain",
-                    preparedAt: bridgeStartedAt,
-                    textInjectedAt,
-                    enterDispatchedAt,
-                    uncertainAt: bindingFailedAt,
-                    error: bindingReason,
-                    lastProvenStage: "enter_dispatched"
-                });
-                if (!deferredCodexForegroundBinding) {
-                    quarantineManagedSessionBinding({
-                        conversation: unfencedConversation,
-                        reason: bindingReason
+                    saveTerminalBridgeDispatchLedger(terminalControl, {
+                        ...terminalBindingLedgerFields(unfencedConversation),
+                        status: "uncertain",
+                        generation_id: message.id,
+                        conversation_id: unfencedConversation.conversation_id,
+                        session_id: sessionIdForConversation(unfencedConversation),
+                        turn_id: turnIdForConversation(unfencedConversation),
+                        message_id: message.id,
+                        message_type: message.type,
+                        request_hash: terminalRequestHash,
+                        prepared_at: bridgeStartedAt,
+                        text_injected_at: textInjectedAt,
+                        enter_dispatched_at: enterDispatchedAt,
+                        uncertain_at: bindingFailedAt,
+                        dispatcher_pid: cliPid(),
+                        state_path: statePath,
+                        event_log_path: logPath,
+                        callback_expected: false,
+                        native_identity_status: "unresolved_after_submit",
+                        error: textSummary(bindingReason),
+                        previous_generation_id: stringValue(previousDispatchLedger?.generation_id) ??
+                            stringValue(previousDispatchLedger?.message_id)
                     });
-                }
-                saveTerminalBridgeDispatchLedger(terminalControl, {
-                    ...terminalBindingLedgerFields(unfencedConversation),
-                    status: "uncertain",
-                    generation_id: message.id,
-                    conversation_id: unfencedConversation.conversation_id,
-                    session_id: sessionIdForConversation(unfencedConversation),
-                    turn_id: turnIdForConversation(unfencedConversation),
-                    message_id: message.id,
-                    message_type: message.type,
-                    request_hash: terminalRequestHash,
-                    prepared_at: bridgeStartedAt,
-                    text_injected_at: textInjectedAt,
-                    enter_dispatched_at: enterDispatchedAt,
-                    uncertain_at: bindingFailedAt,
-                    dispatcher_pid: cliPid(),
-                    state_path: statePath,
-                    event_log_path: logPath,
-                    callback_expected: false,
-                    native_identity_status: "unresolved_after_submit",
-                    error: textSummary(bindingReason),
-                    previous_generation_id: stringValue(previousDispatchLedger?.generation_id) ??
-                        stringValue(previousDispatchLedger?.message_id)
-                });
-                saveState(statePath, unfencedConversation);
-                appendEvent(logPath, {
-                    ts: bindingFailedAt,
-                    conversation_id: unfencedConversation.conversation_id,
-                    event: "terminal_agent_identity_binding_failed",
-                    message_id: message.id,
-                    executor,
-                    terminal_control: terminalControl,
-                    error: textSummary(bindingReason),
-                    delivered: false,
-                    do_not_retry: true
-                });
-                runtimeLog("error", "terminal_agent_identity_binding_failed", {
-                    conversation_id: unfencedConversation.conversation_id,
-                    agent: executor.kind,
-                    terminal_target: terminalControl.target,
-                    error: bindingReason,
-                    delivered: false,
-                    do_not_retry: true
-                });
-                printJson({
-                    session_id: sessionIdForConversation(unfencedConversation),
-                    turn_id: turnIdForConversation(unfencedConversation),
-                    conversation: unfencedConversation,
-                    message,
-                    delivered: false,
-                    status: "submission_uncertain",
-                    submission_outcome: "uncertain",
-                    background: true,
-                    callback_expected: false,
-                    terminal_control: terminalControl,
-                    monitor_pid: bridgeMonitor?.pid ?? null,
-                    executor,
-                    delivery_receipt: "enter_dispatched",
-                    do_not_retry: true,
-                    reason: bindingReason,
-                    openclaw_next_action: {
-                        action: "inspect",
+                    saveState(statePath, unfencedConversation);
+                    appendEvent(logPath, {
+                        ts: bindingFailedAt,
+                        conversation_id: unfencedConversation.conversation_id,
+                        event: "terminal_agent_identity_binding_failed",
+                        message_id: message.id,
+                        executor,
+                        terminal_control: terminalControl,
+                        error: textSummary(bindingReason),
+                        delivered: false,
+                        do_not_retry: true
+                    });
+                    runtimeLog("error", "terminal_agent_identity_binding_failed", {
                         conversation_id: unfencedConversation.conversation_id,
+                        agent: executor.kind,
+                        terminal_target: terminalControl.target,
+                        error: bindingReason,
+                        delivered: false,
+                        do_not_retry: true
+                    });
+                    printJson({
                         session_id: sessionIdForConversation(unfencedConversation),
                         turn_id: turnIdForConversation(unfencedConversation),
+                        conversation: unfencedConversation,
+                        message,
+                        delivered: false,
+                        status: "submission_uncertain",
+                        submission_outcome: "uncertain",
+                        background: true,
+                        callback_expected: false,
+                        terminal_control: terminalControl,
+                        monitor_pid: bridgeMonitor?.pid ?? null,
+                        executor,
+                        delivery_receipt: "enter_dispatched",
                         do_not_retry: true,
-                        reason: "The input was submitted, but AKK could not fence later side effects to an exact native session. Inspect the pane and close this Turn before continuing."
-                    }
-                });
-                return;
+                        reason: bindingReason,
+                        openclaw_next_action: {
+                            action: "inspect",
+                            conversation_id: unfencedConversation.conversation_id,
+                            session_id: sessionIdForConversation(unfencedConversation),
+                            turn_id: turnIdForConversation(unfencedConversation),
+                            do_not_retry: true,
+                            reason: "The input was submitted, but AKK could not fence later side effects to an exact native session. Inspect the pane and close this Turn before continuing."
+                        }
+                    });
+                    return;
+                }
+            }
+            if (!deferredCandidateBindingPending) {
+                submittedBase = boundConversation;
             }
-            submittedBase = boundConversation;
         }
-        acceptanceResult = await pollTerminalSubmissionAcceptance({
-            options,
-            executor: executor.kind,
-            conversation: submittedBase,
-            terminalControl,
-            terminalBridge
-        });
+        acceptanceResult = deferredCandidateBindingPending
+            ? { outcome: "pending_acceptance" }
+            : await pollTerminalSubmissionAcceptance({
+                options,
+                executor: executor.kind,
+                conversation: submittedBase,
+                terminalControl,
+                terminalBridge
+            });
         const acceptanceResolvedAt = cliNow().toISOString();
         const terminalStatus = acceptanceResult.outcome === "pending_acceptance"
             ? "enter_dispatched"
@@ -14031,10 +15064,13 @@ function syntheticTerminalAcceptanceEvidence({ options, executor, conversation,
             .digest("hex")
     };
 }
-function captureCodexAcceptanceAnchorForSend({ options, currentIdentity, expectedNativeThreadId, boundProcessUuid, boundProcessBirth, allowedPreMaterializationIdentity, needsPostSendNativeBinding }) {
+function captureCodexAcceptanceAnchorForSend({ options, currentIdentity, expectedNativeThreadId, boundProcessUuid, boundProcessBirth, allowedPreMaterializationIdentity, needsPostSendNativeBinding, candidateSetAnchor }) {
     if (allowsSyntheticTerminalAcceptance(options)) {
         return undefined;
     }
+    if (candidateSetAnchor) {
+        return candidateSetAnchor;
+    }
     const nativeThreadId = needsPostSendNativeBinding
         ? expectedNativeThreadId
         : currentIdentity?.sessionId;
@@ -14319,6 +15355,27 @@ async function detectTerminalSubmissionAcceptance({ options, executor, conversat
             throw new Error("Codex rollout acceptance anchor is unavailable");
         }
         const pid = Number(nativeTakeover?.terminal_agent_pid);
+        const validatedAnchor = validateCodexRolloutAcceptanceAnchor(anchor);
+        if (validatedAnchor.version === 3) {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid,
+                cwd: terminalControl.currentPath
+            });
+            const result = detectCodexCandidateSetRolloutAcceptance({
+                anchor: validatedAnchor,
+                currentInventory: inventory,
+                requestHash
+            });
+            if (result.status === "accepted") {
+                return result.evidence;
+            }
+            if (result.status === "uncertain") {
+                throw new Error(`Codex candidate-set acceptance is uncertain (${result.code}): ` +
+                    result.reason);
+            }
+            return undefined;
+        }
         const currentIdentity = await resolveCurrentNativeAgentSessionIdentity({
             options,
             agent: "codex",
@@ -14330,7 +15387,7 @@ async function detectTerminalSubmissionAcceptance({ options, executor, conversat
             return undefined;
         }
         return detectCodexRolloutAcceptance({
-            anchor: anchor,
+            anchor: validatedAnchor,
             currentIdentity,
             requestHash
         });
@@ -14401,6 +15458,90 @@ async function pollTerminalSubmissionAcceptance({ options, executor, conversatio
     return { outcome: "pending_acceptance" };
 }
 async function reconcileTerminalAcceptanceInMonitor({ options, conversation, statePath, logPath, terminalControl, executor, terminalBridge }) {
+    const initialTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const deferredTransferId = stringValue(initialTakeover?.deferred_foreground_transfer_id);
+    if (deferredTransferId) {
+        const transferStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+        let transfer = loadDeferredForegroundTransfer(transferStoreDir, deferredTransferId);
+        const pid = Number(initialTakeover?.terminal_agent_pid);
+        if (!Number.isSafeInteger(pid) || pid <= 1) {
+            throw new Error("deferred Codex acceptance monitor lost its exact process identity");
+        }
+        const terminal = await terminalBridge.resolveStoredTerminal("codex", pid, terminalControl, { pid });
+        if (!["resolved", "abort_resolved"].includes(transfer.status)) {
+            await recoverDeferredCodexForegroundTransferBeforeMutation({
+                options: {
+                    ...options,
+                    storeDir: transferStoreDir
+                },
+                terminal
+            });
+            transfer = loadDeferredForegroundTransfer(transferStoreDir, deferredTransferId);
+            conversation = loadState(statePath);
+            if (!["resolved", "abort_resolved"].includes(transfer.status)) {
+                return { outcome: "pending" };
+            }
+        }
+        if (transfer.status === "abort_resolved") {
+            const submission = terminalBridgeSubmission(conversation);
+            if (conversation.conversation_id !== transfer.turn_id ||
+                stringValue(submission?.message_id) !== transfer.message_id ||
+                submission?.status !== "aborted" ||
+                submission.safe_to_retry !== true) {
+                throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved its ` +
+                    "abort without an exact zero-input Turn receipt");
+            }
+            return { outcome: "not_accepted", conversation };
+        }
+        // Dedicated deferred recovery is authoritative and may have closed the
+        // transfer while this monitor held the terminal lock. Do not fall through
+        // to the generic enter_dispatched reconciler: it would reject the stronger
+        // agent_accepted Turn/ledger that recovery just persisted. Re-prove that
+        // exact monotonic authority here, then let this same monitor invocation
+        // continue into completion polling without replaying terminal input.
+        const authority = loadDeferredForegroundTurnAuthority({
+            storeDir: transferStoreDir,
+            terminal,
+            transfer
+        });
+        const ledger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
+        if (!ledger) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved ` +
+                "without an exact terminal dispatch ledger");
+        }
+        assertDeferredForegroundLedgerAuthority({
+            storeDir: transferStoreDir,
+            terminal,
+            transfer,
+            ledger,
+            statePath: authority.statePath,
+            expectedMessageBodyHash: stringValue(authority.submission.message_body_hash)
+        });
+        const acceptedBinding = transfer.target_accepted_binding;
+        const rollout = acceptedBinding?.native_process.rollout;
+        if (!acceptedBinding ||
+            !transfer.target_native_thread_id ||
+            acceptedBinding.native_thread_id !== transfer.target_native_thread_id ||
+            !isCompleteNativeRollout(rollout)) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved ` +
+                "without an exact accepted native binding");
+        }
+        const acceptedIdentity = {
+            sessionId: transfer.target_native_thread_id,
+            processUuid: acceptedBinding.native_process.process_uuid,
+            processBirth: acceptedBinding.native_process.process_birth,
+            rollout,
+            evidence: acceptedBinding.native_process.evidence
+        };
+        assertNativeAgentIdentityForTurn({
+            conversation: authority.conversation,
+            currentIdentity: acceptedIdentity,
+            operation: "continue deferred foreground monitor for"
+        });
+        return { outcome: "accepted", conversation: authority.conversation };
+    }
     let bindingRecovery = await recoverVirginCodexPostSubmissionBinding({
         options,
         conversation,
@@ -14667,6 +15808,13 @@ function assertOrdinaryTerminalPayloadDoesNotInvokeNativeLifecycle(payload) {
         "use an advertised dedicated native action when one exists, or enter " +
         "the unsupported native command manually in the terminal UI");
 }
+async function inspectCodexOpenRootRolloutInventory({ options, pid, cwd }) {
+    const provider = createAgentSessionProvider("codex", options);
+    if (!provider.inspectOpenRootRolloutInventoryForPid) {
+        throw new Error("Codex open-root rollout inventory inspection is unavailable");
+    }
+    return provider.inspectOpenRootRolloutInventoryForPid(pid, cwd);
+}
 function isCompleteNativeRollout(value) {
     return isRecord(value) &&
         Boolean(stringValue(value.fd)) &&
@@ -15187,6 +16335,29 @@ function quarantineManagedSessionBinding({ conversation, reason }) {
 }
 async function pollNativeAgentSessionIdentity({ options, executor, terminalControl, pid, expectedSessionId, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], requiredCodexAcceptance, attempts = 40, delayMs = 50 }) {
     for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (requiredCodexAcceptance?.anchor.version === 3) {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid,
+                cwd: terminalControl.currentPath
+            });
+            const result = detectCodexCandidateSetRolloutAcceptance({
+                anchor: requiredCodexAcceptance.anchor,
+                currentInventory: inventory,
+                requestHash: requiredCodexAcceptance.requestHash
+            });
+            if (result.status === "accepted") {
+                return result.identity;
+            }
+            if (result.status === "uncertain") {
+                throw new Error(`Codex candidate-set acceptance is uncertain (${result.code}): ` +
+                    result.reason);
+            }
+            if (attempt + 1 < attempts) {
+                await cliSleep(delayMs);
+            }
+            continue;
+        }
         const identity = await resolveCurrentNativeAgentSessionIdentity({
             options,
             agent: executor.kind,
@@ -15592,12 +16763,26 @@ async function reconcileMonitors(options, { includeCallbackRecovery, reason, con
         const logPath = expandHome(stringValue(listedConversation.event_log_path) ??
             logPathForStatePath(statePath));
         try {
+            const localCompletion = settleLocalTerminalBridgeCompletionClaim({
+                storeDir,
+                statePath,
+                logPath
+            });
+            if (localCompletion.handled) {
+                skipped += 1;
+                items.push({
+                    conversation_id: listedConversation.conversation_id,
+                    status: localCompletion.recovered ? "recovered" : "skipped",
+                    reason: localCompletion.reason
+                });
+                continue;
+            }
             if (includeCallbackRecovery) {
-                const callbackRecovery = prepareCallbackDeliveryReconciliation({
+                const callbackRecovery = withStoreWriterLease(storeDir, () => prepareCallbackDeliveryReconciliation({
                     statePath,
                     logPath,
                     delayMs: options.callbackRetryDelayMs
-                });
+                }));
                 if (callbackRecovery.handled) {
                     if (callbackRecovery.status === "launched") {
                         launched += 1;
@@ -15644,13 +16829,78 @@ async function reconcileMonitors(options, { includeCallbackRecovery, reason, con
                 logPath,
                 options
             });
+            const initialTakeover = isRecord(initialConversation.native_session_takeover)
+                ? initialConversation.native_session_takeover
+                : undefined;
+            const deferredTransferId = stringValue(initialTakeover?.deferred_foreground_transfer_id);
+            if (deferredTransferId) {
+                const deferredTransfer = loadDeferredForegroundTransfer(storeDir, deferredTransferId);
+                if (![
+                    "resolved",
+                    "abort_resolved"
+                ].includes(deferredTransfer.status)) {
+                    const deferredControl = terminalControlFromTakeover(initialTakeover);
+                    const deferredPid = Number(initialTakeover?.terminal_agent_pid);
+                    if (!deferredControl ||
+                        !Number.isSafeInteger(deferredPid) ||
+                        deferredPid <= 1) {
+                        throw new Error(`deferred foreground Turn ${initialConversation.conversation_id} ` +
+                            "lost its exact terminal process authority");
+                    }
+                    const bridge = createTerminalAgentBridge(options);
+                    const deferredTerminal = await bridge.resolveStoredTerminal("codex", deferredPid, deferredControl, { pid: deferredPid });
+                    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, deferredControl, { timeoutMs: 30000 });
+                    try {
+                        await withStoreWriterLeaseAsync(storeDir, async () => {
+                            await recoverDeferredCodexForegroundTransferBeforeMutation({
+                                options,
+                                terminal: deferredTerminal
+                            });
+                        });
+                    }
+                    finally {
+                        releaseTerminalLock();
+                    }
+                    initialConversation = loadState(statePath);
+                    const refreshedTransfer = loadDeferredForegroundTransfer(storeDir, deferredTransferId);
+                    if (![
+                        "resolved",
+                        "abort_resolved"
+                    ].includes(refreshedTransfer.status)) {
+                        const pendingSubmission = terminalBridgeSubmission(initialConversation);
+                        const pendingTakeover = isRecord(initialConversation.native_session_takeover)
+                            ? initialConversation.native_session_takeover
+                            : undefined;
+                        const pendingAnchor = validateCodexRolloutAcceptanceAnchor(pendingTakeover?.codex_rollout_acceptance_anchor);
+                        if (pendingAnchor?.version !== 3 ||
+                            initialConversation.status !== "waiting_for_agent" ||
+                            pendingSubmission?.status !== "enter_dispatched" ||
+                            stringValue(pendingSubmission.message_id) !==
+                                stringValue(pendingTakeover?.terminal_bridge_message_id) ||
+                            refreshedTransfer.status !== "dispatch_started") {
+                            throw new Error(`deferred foreground Turn ${initialConversation.conversation_id} ` +
+                                "is not an exact pending candidate-set acceptance");
+                        }
+                    }
+                }
+            }
             initialConversation = (await recoverVirginCodexPostSubmissionBinding({
                 options,
                 conversation: initialConversation,
                 statePath,
                 logPath
             })).conversation;
-            assertTurnBindingCurrent(initialConversation, "reconcile monitor for");
+            const reconciledTakeover = isRecord(initialConversation.native_session_takeover)
+                ? initialConversation.native_session_takeover
+                : undefined;
+            const reconciledTransferId = stringValue(reconciledTakeover?.deferred_foreground_transfer_id);
+            const reconciledTransfer = reconciledTransferId
+                ? loadDeferredForegroundTransfer(storeDir, reconciledTransferId)
+                : undefined;
+            if (!reconciledTransfer ||
+                ["resolved", "abort_resolved"].includes(reconciledTransfer.status)) {
+                assertTurnBindingCurrent(initialConversation, "reconcile monitor for");
+            }
             const initialEligibility = terminalBridgeReconciliationEligibility(initialConversation);
             if (!initialEligibility.eligible) {
                 skipped += 1;
@@ -15849,6 +17099,12 @@ function prepareCallbackDeliveryReconciliation({ statePath, logPath, delayMs })
                 handled: false
             };
         }
+        const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+        assertConversationHasNoNonterminalDeferredForegroundTransfer({
+            storeDir,
+            conversation,
+            action: "reconcile callback delivery for"
+        });
         const conversationId = stringValue(conversation.conversation_id) ?? "unknown";
         const attempts = Number(callbackDelivery?.attempts ?? 0);
         if (!["pending", "failed"].includes(String(callbackDelivery?.status ?? "")) ||
@@ -15955,12 +17211,6 @@ function terminalBridgeReconciliationEligibility(conversation) {
     if (nativeTakeover?.terminal_bridge !== true) {
         return { eligible: false, reason: "not_terminal_bridge" };
     }
-    if (!conversation.gateway_method) {
-        return { eligible: false, reason: "gateway_method_missing" };
-    }
-    if (!stringValue(conversation.gateway_session) && !stringValue(conversation.openclaw_session)) {
-        return { eligible: false, reason: "gateway_session_missing" };
-    }
     if (!isWaitingForAgent(conversation.status)) {
         return {
             eligible: false,
@@ -15973,18 +17223,38 @@ function terminalBridgeReconciliationEligibility(conversation) {
         return { eligible: false, reason: "terminal_bridge_identity_missing" };
     }
     const dispatchLedger = loadTerminalBridgeDispatchLedger(terminalControl);
-    if (dispatchLedger &&
-        (stringValue(dispatchLedger.message_id) !== terminalMessageId ||
-            ![
-                "prepared",
-                "text_injected",
-                "enter_dispatched",
-                "agent_accepted",
-                "submitted"
-            ].includes(String(dispatchLedger.status)))) {
+    const conversationStatePath = stringValue(conversation.state_path);
+    const conversationStoreDir = managedSessionStoreDirForConversation(conversation);
+    const bindingId = stringValue(conversation.terminal_binding_id);
+    const bindingGeneration = Number(conversation.terminal_binding_generation);
+    if ((!dispatchLedger ||
+        stringValue(dispatchLedger.message_id) !== terminalMessageId ||
+        !terminalDispatchRecordMatchesControl(dispatchLedger, terminalControl) ||
+        stringValue(dispatchLedger.conversation_id) !==
+            conversation.conversation_id ||
+        stringValue(dispatchLedger.session_id) !==
+            sessionIdForConversation(conversation) ||
+        stringValue(dispatchLedger.turn_id) !==
+            turnIdForConversation(conversation) ||
+        !conversationStatePath ||
+        !sameCanonicalStatePath(dispatchLedger.state_path, conversationStatePath) ||
+        !conversationStoreDir ||
+        path.resolve(stringValue(dispatchLedger.store_dir) ?? "") !==
+            path.resolve(conversationStoreDir) ||
+        (bindingId !== undefined &&
+            stringValue(dispatchLedger.binding_id) !== bindingId) ||
+        (Number.isSafeInteger(bindingGeneration) &&
+            Number(dispatchLedger.binding_generation) !== bindingGeneration) ||
+        ![
+            "prepared",
+            "text_injected",
+            "enter_dispatched",
+            "agent_accepted",
+            "submitted"
+        ].includes(String(dispatchLedger.status)))) {
         return {
             eligible: false,
-            reason: `terminal_dispatch_${String(dispatchLedger.status ?? "generation_replaced")}`
+            reason: `terminal_dispatch_${String(dispatchLedger?.status ?? "missing_or_generation_replaced")}`
         };
     }
     const submission = terminalBridgeSubmission(conversation);
@@ -16000,6 +17270,27 @@ function terminalBridgeReconciliationEligibility(conversation) {
     if (!Number.isInteger(runtime.pid) || Number(runtime.pid) <= 0 || !stringValue(runtime.cwd)) {
         return { eligible: false, reason: "terminal_agent_identity_missing" };
     }
+    const storeDir = managedSessionStoreDirForConversation(conversation);
+    const deferredTransferId = stringValue(nativeTakeover.deferred_foreground_transfer_id);
+    const deferredTransfer = storeDir && deferredTransferId
+        ? loadDeferredForegroundTransfer(storeDir, deferredTransferId)
+        : undefined;
+    if (deferredTransfer &&
+        !["resolved", "abort_resolved"].includes(deferredTransfer.status)) {
+        const anchor = validateCodexRolloutAcceptanceAnchor(nativeTakeover.codex_rollout_acceptance_anchor);
+        if (anchor?.version !== 3 ||
+            deferredTransfer.status !== "dispatch_started" ||
+            submission?.status !== "enter_dispatched" ||
+            deferredTransfer.turn_id !== turnIdForConversation(conversation) ||
+            deferredTransfer.message_id !== terminalMessageId ||
+            deferredTransfer.target_session_id !==
+                sessionIdForConversation(conversation)) {
+            return {
+                eligible: false,
+                reason: `deferred_foreground_transfer_${deferredTransfer.status}`
+            };
+        }
+    }
     const inactivityTimeoutMinutes = Number(nativeTakeover.terminal_bridge_inactivity_timeout_minutes);
     const hardTimeoutMinutes = Number(nativeTakeover.terminal_bridge_hard_timeout_minutes);
     const startedAtMs = validTimestampMs(nativeTakeover.terminal_bridge_started_at);
@@ -16028,6 +17319,179 @@ function terminalBridgeReconciliationEligibility(conversation) {
         hardDeadlineAtMs
     };
 }
+function settleLocalTerminalBridgeCompletionClaim({ storeDir, statePath, logPath }) {
+    const initial = loadState(statePath);
+    const initialTakeover = isRecord(initial.native_session_takeover)
+        ? initial.native_session_takeover
+        : undefined;
+    const initialClaim = isRecord(initialTakeover?.terminal_bridge_completion_claim)
+        ? initialTakeover.terminal_bridge_completion_claim
+        : undefined;
+    if (stringValue(initial.gateway_method) ||
+        !initialClaim ||
+        !["idle", "failed"].includes(String(initial.status))) {
+        return {
+            handled: false,
+            recovered: false,
+            reason: "local_completion_not_applicable"
+        };
+    }
+    const initialTerminalControl = terminalControlFromTakeover(initialTakeover);
+    if (!initialTerminalControl) {
+        throw new Error(`local terminal completion ${initial.conversation_id} lost its terminal authority`);
+    }
+    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, initialTerminalControl, { timeoutMs: 30000 });
+    try {
+        return withStoreWriterLease(storeDir, () => {
+            const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+            try {
+                const conversation = loadState(statePath);
+                const takeover = isRecord(conversation.native_session_takeover)
+                    ? conversation.native_session_takeover
+                    : undefined;
+                const claim = isRecord(takeover?.terminal_bridge_completion_claim)
+                    ? takeover.terminal_bridge_completion_claim
+                    : undefined;
+                const terminalControl = terminalControlFromTakeover(takeover);
+                const terminalMessageId = stringValue(takeover?.terminal_bridge_message_id);
+                const callbackMessageId = stringValue(claim?.callback_message_id);
+                const completionFingerprint = stringValue(claim?.completion_fingerprint);
+                const completionId = stringValue(claim?.completion_id);
+                const claimedAt = stringValue(claim?.claimed_at);
+                const outcome = stringValue(claim?.outcome);
+                const expectedMessageType = outcome === "success"
+                    ? "done"
+                    : outcome === "failure"
+                        ? "error"
+                        : undefined;
+                if (stringValue(conversation.gateway_method) ||
+                    conversation.callback_delivery !== undefined ||
+                    !claim ||
+                    !terminalControl ||
+                    !terminalControlsShareIncarnation(terminalControl, initialTerminalControl) ||
+                    !terminalMessageId ||
+                    !callbackMessageId ||
+                    !completionFingerprint ||
+                    !completionId ||
+                    !claimedAt ||
+                    validTimestampMs(claimedAt) === undefined ||
+                    !expectedMessageType ||
+                    (outcome === "success" && conversation.status !== "idle") ||
+                    (outcome === "failure" && conversation.status !== "failed") ||
+                    deterministicTerminalCallbackMessageId({
+                        conversationId: conversation.conversation_id,
+                        terminalMessageId,
+                        completionFingerprint,
+                        outcome
+                    }) !== callbackMessageId) {
+                    throw new Error(`local terminal completion ${conversation.conversation_id} has ` +
+                        "inconsistent claim, Turn phase, or callback authority");
+                }
+                const submission = terminalBridgeSubmission(conversation);
+                if (submission?.status !== "agent_accepted" ||
+                    stringValue(submission.message_id) !== terminalMessageId ||
+                    stringValue(submission.session_id) !==
+                        sessionIdForConversation(conversation) ||
+                    stringValue(submission.turn_id) !== turnIdForConversation(conversation)) {
+                    throw new Error(`local terminal completion ${conversation.conversation_id} is ` +
+                        "not tied to one accepted terminal submission");
+                }
+                const events = readExistingEvents(logPath);
+                const claimed = events.some((event) => event.event === "terminal_bridge_completion_claimed" &&
+                    event.conversation_id === conversation.conversation_id &&
+                    event.terminal_bridge_message_id === terminalMessageId &&
+                    event.completion_fingerprint === completionFingerprint &&
+                    event.completion_id === completionId &&
+                    event.callback_message_id === callbackMessageId &&
+                    event.outcome === outcome &&
+                    event.ts === claimedAt);
+                const detected = events.some((event) => event.event === "terminal_bridge_completion_detected" &&
+                    event.conversation_id === conversation.conversation_id &&
+                    event.terminal_bridge_message_id === terminalMessageId &&
+                    event.completion_id === completionId &&
+                    event.callback_message_id === callbackMessageId &&
+                    event.completion_outcome === outcome);
+                const messageRecorded = events.some((event) => {
+                    const message = isRecord(event.message) ? event.message : undefined;
+                    const metadata = isRecord(message?.metadata)
+                        ? message.metadata
+                        : undefined;
+                    return event.event === "message" &&
+                        event.conversation_id === conversation.conversation_id &&
+                        event.session_id === sessionIdForConversation(conversation) &&
+                        event.turn_id === turnIdForConversation(conversation) &&
+                        message?.id === callbackMessageId &&
+                        message?.type === expectedMessageType &&
+                        message?.to === "openclaw" &&
+                        message?.requires_response === false &&
+                        metadata?.terminal_bridge_message_id === terminalMessageId;
+                });
+                if (!claimed || !detected || !messageRecorded) {
+                    throw new Error(`local terminal completion ${conversation.conversation_id} is ` +
+                        "missing exact claim, detection, or message evidence");
+                }
+                const ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+                const expectedBindingId = stringValue(conversation.terminal_binding_id);
+                const expectedBindingGeneration = Number(conversation.terminal_binding_generation);
+                if (!ledger ||
+                    !["agent_accepted", "resolved"].includes(String(ledger.status)) ||
+                    !terminalDispatchRecordMatchesControl(ledger, terminalControl) ||
+                    stringValue(ledger.conversation_id) !== conversation.conversation_id ||
+                    stringValue(ledger.session_id) !== sessionIdForConversation(conversation) ||
+                    stringValue(ledger.turn_id) !== turnIdForConversation(conversation) ||
+                    stringValue(ledger.message_id) !== terminalMessageId ||
+                    stringValue(ledger.native_thread_id) !==
+                        stringValue(conversation.native_thread_id) ||
+                    (expectedBindingId !== undefined &&
+                        stringValue(ledger.binding_id) !== expectedBindingId) ||
+                    (Number.isSafeInteger(expectedBindingGeneration) &&
+                        Number(ledger.binding_generation) !== expectedBindingGeneration) ||
+                    path.resolve(stringValue(ledger.store_dir) ?? "") !==
+                        path.resolve(storeDir) ||
+                    !sameCanonicalStatePath(ledger.state_path, statePath)) {
+                    throw new Error(`local terminal completion ${conversation.conversation_id} has ` +
+                        "no exact accepted terminal ledger");
+                }
+                if (ledger.status === "resolved") {
+                    return {
+                        handled: true,
+                        recovered: false,
+                        reason: "local_terminal_completion_already_settled"
+                    };
+                }
+                if (!resolveTerminalBridgeDispatchLedger({
+                    terminalControl,
+                    conversation,
+                    expectedMessageId: terminalMessageId,
+                    reason: "callbackless terminal bridge task reached durable completion"
+                })) {
+                    throw new Error(`local terminal completion ${conversation.conversation_id} ` +
+                        "changed before ledger settlement");
+                }
+                appendEvent(logPath, {
+                    ts: cliNow().toISOString(),
+                    conversation_id: conversation.conversation_id,
+                    event: "terminal_bridge_local_completion_settled",
+                    terminal_bridge_message_id: terminalMessageId,
+                    completion_id: completionId,
+                    callback_message_id: callbackMessageId,
+                    outcome
+                });
+                return {
+                    handled: true,
+                    recovered: true,
+                    reason: "local_terminal_completion_ledger_recovered"
+                };
+            }
+            finally {
+                releaseStateLock();
+            }
+        });
+    }
+    finally {
+        releaseTerminalLock();
+    }
+}
 function latestTerminalBridgeMonitorLaunchPid(logPath) {
     let events;
     try {
@@ -16152,37 +17616,46 @@ async function runCancel(options) {
     throw new Error(`conversation ${conversation.conversation_id} is not attached to a live terminal`);
 }
 async function runTerminalConversationCancel({ options, conversationId, agent, terminalControl, pid }) {
-    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
+    const storeDir = storeDirFromOptions(options);
+    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, terminalControl, { timeoutMs: 30000 });
     try {
-        const cancellation = await createTerminalAgentBridge(options).cancel(agent, terminalControl, {
-            runtime: {
+        await withStoreWriterLeaseAsync(storeDir, async () => {
+            assertTerminalHasNoNonterminalDeferredForegroundTransfer({
+                storeDir,
                 pid,
-                cwd: terminalControl.currentPath,
-                terminalTarget: terminalControl.target
-            },
-            scrollbackLines: Number(options.scrollbackLines ?? 120)
-        });
-        runtimeLog("info", "terminal_cancel_requested", {
-            conversation_id: conversationId,
-            agent,
-            terminal_target: terminalControl.target,
-            key: cancellation.key,
-            keys: cancellation.keys,
-            denied_approval: cancellation.deniedApproval,
-            request_id: cancellation.requestId,
-            cancel_requested: cancellation.cancelRequested,
-            reason: cancellation.reason
-        });
-        printJson({
-            conversation_id: conversationId,
-            source: "terminal_control",
-            cancel_requested: cancellation.cancelRequested,
-            reason: cancellation.reason,
-            terminal_control: terminalControl,
-            key: cancellation.key,
-            keys: cancellation.keys,
-            denied_approval: cancellation.deniedApproval,
-            request_id: cancellation.requestId
+                terminalControl,
+                action: "cancel"
+            });
+            const cancellation = await createTerminalAgentBridge(options).cancel(agent, terminalControl, {
+                runtime: {
+                    pid,
+                    cwd: terminalControl.currentPath,
+                    terminalTarget: terminalControl.target
+                },
+                scrollbackLines: Number(options.scrollbackLines ?? 120)
+            });
+            runtimeLog("info", "terminal_cancel_requested", {
+                conversation_id: conversationId,
+                agent,
+                terminal_target: terminalControl.target,
+                key: cancellation.key,
+                keys: cancellation.keys,
+                denied_approval: cancellation.deniedApproval,
+                request_id: cancellation.requestId,
+                cancel_requested: cancellation.cancelRequested,
+                reason: cancellation.reason
+            });
+            printJson({
+                conversation_id: conversationId,
+                source: "terminal_control",
+                cancel_requested: cancellation.cancelRequested,
+                reason: cancellation.reason,
+                terminal_control: terminalControl,
+                key: cancellation.key,
+                keys: cancellation.keys,
+                denied_approval: cancellation.deniedApproval,
+                request_id: cancellation.requestId
+            });
         });
     }
     finally {
@@ -16679,7 +18152,7 @@ async function runTerminalDispatchClose({ options, terminalConversation }) {
                     throw new Error(`terminal ${terminalControl.target} deferred dispatch authority ` +
                         "does not match its exact Store/terminal transfer");
                 }
-                if (!["resolved", "aborted", "abort_resolved"].includes(transfer.status)) {
+                if (!["resolved", "abort_resolved"].includes(transfer.status)) {
                     throw new Error(`terminal ${terminalControl.target} dispatch is fenced by deferred ` +
                         `foreground transfer ${transfer.transfer_id} (${transfer.status}); ` +
                         "generic terminal close cannot resolve it");
@@ -17149,7 +18622,7 @@ async function runTerminalBridgeMonitor(options) {
                 return;
             }
             catch (error) {
-                if (!(error instanceof StoreLockTimeoutError)) {
+                if (!isStoreMutationLockTimeout(error)) {
                     throw error;
                 }
                 storeDeferredAttempts += 1;
@@ -17158,8 +18631,12 @@ async function runTerminalBridgeMonitor(options) {
                 runtimeLog("warn", "terminal_bridge_monitor_store_operation_deferred", {
                     conversation_id: conversation.conversation_id,
                     terminal_bridge_message_id: terminalMessageId,
-                    error_code: error.code,
-                    lock_kind: error.lockKind,
+                    error_code: isRecord(error)
+                        ? stringValue(error.code) ?? "LOCK_TIMEOUT"
+                        : "LOCK_TIMEOUT",
+                    lock_kind: error instanceof StoreLockTimeoutError
+                        ? error.lockKind
+                        : "conversation",
                     attempt: storeDeferredAttempts,
                     retry_in_ms: retryInMs
                 });
@@ -17376,6 +18853,9 @@ async function runTerminalBridgeMonitorWithLock(options, lifecycle, expectedTerm
                     }
                 }
                 catch (error) {
+                    if (isStoreMutationLockTimeout(error)) {
+                        throw error;
+                    }
                     const reason = error instanceof Error ? error.message : String(error);
                     conversation = markTerminalAcceptanceUncertain({
                         conversation,
@@ -19106,6 +20586,17 @@ function terminalBindingLedgerFields(conversation) {
     };
 }
 function assertConversationHasNoNonterminalDeferredForegroundTransfer({ storeDir, conversation, action }) {
+    const turnId = turnIdForConversation(conversation);
+    const sourceTransfer = listDeferredForegroundTransfers(storeDir).find((candidate) => candidate.version === 2 &&
+        candidate.source_kind === "candidate_rollout_quiescent" &&
+        !["resolved", "abort_resolved"].includes(candidate.status) &&
+        (candidate.source_turn_history ?? []).some((sourceTurn) => sourceTurn.turn_id === turnId));
+    if (sourceTransfer) {
+        throw new Error(`cannot ${action} Turn ${turnId} while deferred foreground transfer ` +
+            `${sourceTransfer.transfer_id} reserves it as immutable source ` +
+            `history in ${sourceTransfer.status}; dedicated transfer recovery ` +
+            "must finish first");
+    }
     const takeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
@@ -19114,12 +20605,23 @@ function assertConversationHasNoNonterminalDeferredForegroundTransfer({ storeDir
         return;
     }
     const transfer = loadDeferredForegroundTransfer(storeDir, transferId);
-    if (!["resolved", "aborted", "abort_resolved"].includes(transfer.status)) {
+    if (!["resolved", "abort_resolved"].includes(transfer.status)) {
         throw new Error(`cannot ${action} Turn ${turnIdForConversation(conversation)} while ` +
             `deferred foreground transfer ${transfer.transfer_id} is ` +
             `${transfer.status}; dedicated transfer recovery must finish first`);
     }
 }
+function assertTerminalHasNoNonterminalDeferredForegroundTransfer({ storeDir, pid, terminalControl, action }) {
+    const transfer = listDeferredForegroundTransfers(storeDir).find((candidate) => !["resolved", "abort_resolved"].includes(candidate.status) &&
+        candidate.process_pid === pid &&
+        terminalControlEvidenceMatches(candidate.terminal_endpoint, terminalControl));
+    if (!transfer) {
+        return;
+    }
+    throw new Error(`cannot ${action} terminal ${terminalControl.target} while deferred ` +
+        `foreground transfer ${transfer.transfer_id} is ${transfer.status}; ` +
+        "dedicated transfer recovery must finish first");
+}
 function reconcilePreparedTerminalDispatchLedger(terminalControl, ledger) {
     if (terminalDispatchLedgerLooksLifecycle(ledger)) {
         return ledger;
@@ -19492,6 +20994,17 @@ function deferredCodexBoundaryFromTransfer({ terminal, transfer }) {
             status: transfer.previous_dispatch_status,
             fingerprint: transfer.previous_dispatch_fingerprint
         },
+        sourceKind: transfer.version === 1
+            ? "status_card_only"
+            : required(transfer.source_kind, "deferred foreground source kind is unavailable"),
+        ...(transfer.source_turn_history
+            ? { sourceTurnHistory: transfer.source_turn_history }
+            : {}),
+        ...(transfer.source_previous_last_transition_id
+            ? {
+                sourcePreviousLastTransitionId: transfer.source_previous_last_transition_id
+            }
+            : {}),
         sourceReservedRevision: transfer.source_expected_revision + 1,
         sourceReservedBindingToken: managedSessionBindingToken({
             session_id: transfer.source_session_id,
@@ -19517,6 +21030,28 @@ function loadDeferredForegroundTurnAuthority({ storeDir, terminal, transfer }) {
     const submission = terminalBridgeSubmission(conversation);
     const terminalControl = terminalControlFromTakeover(takeover);
     const anchor = takeover?.codex_rollout_acceptance_anchor;
+    let validatedAnchor;
+    try {
+        validatedAnchor = validateCodexRolloutAcceptanceAnchor(anchor);
+    }
+    catch {
+        validatedAnchor = undefined;
+    }
+    const exactDeferredAnchor = Boolean(validatedAnchor &&
+        validatedAnchor.process_uuid === transfer.process_uuid &&
+        validatedAnchor.process_birth === transfer.process_birth &&
+        ((validatedAnchor.version === 2 &&
+            validatedAnchor.mode === "pre_materialization" &&
+            validatedAnchor.native_thread_binding === "post_submission" &&
+            validatedAnchor.file_existed === false &&
+            validatedAnchor.offset_bytes === 0 &&
+            validatedAnchor.expected_empty_native_session === true) ||
+            (validatedAnchor.version === 3 &&
+                validatedAnchor.mode === "candidate_set" &&
+                validatedAnchor.inventory_pid === transfer.process_pid &&
+                path.resolve(validatedAnchor.inventory_cwd ?? "") ===
+                    path.resolve(transfer.workspace) &&
+                validatedAnchor.candidate_rollouts.length > 0)));
     const target = loadManagedSession(storeDir, transfer.target_session_id);
     const targetBefore = transfer.target_before_binding;
     const requestText = stringValue(takeover?.terminal_bridge_request_text);
@@ -19627,20 +21162,7 @@ function loadDeferredForegroundTurnAuthority({ storeDir, terminal, transfer }) {
         target.binding.native_process.pid !== transfer.process_pid ||
         target.binding.native_process.process_uuid !== transfer.process_uuid ||
         target.binding.native_process.process_birth !== transfer.process_birth ||
-        !isRecord(anchor) ||
-        anchor.schema !== "agent-knock-knock/codex-rollout-acceptance-anchor" ||
-        anchor.version !== 2 ||
-        anchor.mode !== "pre_materialization" ||
-        anchor.native_thread_binding !== "post_submission" ||
-        anchor.file_existed !== false ||
-        anchor.offset_bytes !== 0 ||
-        anchor.expected_empty_native_session !== true ||
-        anchor.native_thread_id !== undefined ||
-        anchor.rollout !== undefined ||
-        anchor.process_uuid !== transfer.process_uuid ||
-        anchor.process_birth !== transfer.process_birth ||
-        typeof anchor.anchor_fingerprint !== "string" ||
-        !/^[0-9a-f]{64}$/u.test(anchor.anchor_fingerprint)) {
+        !exactDeferredAnchor) {
         throw new Error(`deferred foreground transfer ${transfer.transfer_id} Turn authority ` +
             "does not match its exact request/terminal/process fence");
     }
@@ -19650,7 +21172,7 @@ function loadDeferredForegroundTurnAuthority({ storeDir, terminal, transfer }) {
         logPath: canonical.logPath,
         takeover,
         submission,
-        anchor: anchor
+        anchor: validatedAnchor
     };
 }
 function assertDeferredForegroundLedgerAuthority({ storeDir, terminal, transfer, ledger, statePath, expectedMessageBodyHash }) {
@@ -19675,6 +21197,18 @@ function assertDeferredForegroundLedgerAuthority({ storeDir, terminal, transfer,
             exactCommittedAcceptance = false;
         }
     }
+    const exactPostDispatchPending = Boolean(transfer.status === "dispatch_started" &&
+        transfer.input_stage === "enter_dispatched" &&
+        ledger.status === "enter_dispatched" &&
+        ledger.dispatcher_pid === null &&
+        stringValue(ledger.prepared_at) === transfer.prepared_at &&
+        stringValue(ledger.text_injected_at) === transfer.text_injected_at &&
+        stringValue(ledger.enter_dispatched_at) === transfer.enter_dispatched_at &&
+        ledger.agent_accepted_at === undefined &&
+        ledger.not_accepted_at === undefined &&
+        ledger.uncertain_at === undefined &&
+        ledger.acceptance_evidence === undefined &&
+        ledger.safe_to_retry !== true);
     if (!targetBefore ||
         terminalDispatchLedgerLooksLifecycle(ledger) ||
         !terminalDispatchRecordMatchesControl(ledger, terminal.terminalControl) ||
@@ -19704,6 +21238,7 @@ function assertDeferredForegroundLedgerAuthority({ storeDir, terminal, transfer,
             path.resolve(storeDir) ||
         (ledger.status !== "resolved" &&
             !exactCommittedAcceptance &&
+            !exactPostDispatchPending &&
             Number(ledger.dispatcher_pid) !== transfer.dispatcher_pid)) {
         throw new Error(`deferred foreground transfer ${transfer.transfer_id} dispatch ledger ` +
             "does not match its exact Turn authority");
@@ -20040,21 +21575,44 @@ async function recoverAcceptedDeferredForegroundDispatch({ options, storeDir, te
             throw new Error(`deferred foreground transfer ${transfer.transfer_id} has invalid ` +
                 `${String(ledger.status)} dispatch evidence for acceptance recovery`);
         }
-        const identity = await resolveCurrentNativeAgentSessionIdentity({
-            options,
-            agent: "codex",
-            pid: transfer.process_pid,
-            cwd: terminal.terminalControl.currentPath
-        });
-        if (!identity) {
-            return false;
+        let identity;
+        let acceptance;
+        if (authority.anchor.version === 3) {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid: transfer.process_pid,
+                cwd: terminal.terminalControl.currentPath
+            });
+            const result = detectCodexCandidateSetRolloutAcceptance({
+                anchor: authority.anchor,
+                currentInventory: inventory,
+                requestHash: transfer.request_hash
+            });
+            if (result.status === "uncertain") {
+                throw new Error(`Codex candidate-set recovery is uncertain (${result.code}): ` +
+                    result.reason);
+            }
+            if (result.status === "accepted") {
+                identity = result.identity;
+                acceptance = result.evidence;
+            }
         }
-        const acceptance = detectCodexRolloutAcceptance({
-            anchor: authority.anchor,
-            currentIdentity: identity,
-            requestHash: transfer.request_hash
-        });
-        if (!acceptance) {
+        else {
+            identity = await resolveCurrentNativeAgentSessionIdentity({
+                options,
+                agent: "codex",
+                pid: transfer.process_pid,
+                cwd: terminal.terminalControl.currentPath
+            });
+            if (identity) {
+                acceptance = detectCodexRolloutAcceptance({
+                    anchor: authority.anchor,
+                    currentIdentity: identity,
+                    requestHash: transfer.request_hash
+                });
+            }
+        }
+        if (!identity || !acceptance) {
             return false;
         }
         if (ledger.status === "agent_accepted") {
@@ -20212,7 +21770,7 @@ async function recoverAcceptedDeferredForegroundDispatch({ options, storeDir, te
         releaseStateLock();
     }
 }
-function persistCommittedDeferredForegroundTurnAcceptance({ storeDir, terminal, transfer }) {
+async function persistCommittedDeferredForegroundTurnAcceptance({ options, storeDir, terminal, transfer }) {
     const current = loadDeferredForegroundTransfer(storeDir, transfer.transfer_id);
     if (current.status !== "committed" ||
         !current.target_accepted_binding ||
@@ -20270,11 +21828,36 @@ function persistCommittedDeferredForegroundTurnAcceptance({ storeDir, terminal,
             throw new Error(`deferred foreground transfer ${current.transfer_id} has invalid ` +
                 `${String(ledger.status)} dispatch evidence for committed recovery`);
         }
-        const acceptance = detectCodexRolloutAcceptance({
-            anchor: authority.anchor,
-            currentIdentity: identity,
-            requestHash: current.request_hash
-        });
+        let acceptance;
+        if (authority.anchor.version === 3) {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid: current.process_pid,
+                cwd: terminal.terminalControl.currentPath
+            });
+            const result = detectCodexCandidateSetRolloutAcceptance({
+                anchor: authority.anchor,
+                currentInventory: inventory,
+                requestHash: current.request_hash
+            });
+            if (result.status === "uncertain") {
+                throw new Error(`Codex committed candidate acceptance is uncertain (${result.code}): ` +
+                    result.reason);
+            }
+            if (result.status === "accepted") {
+                if (result.identity.sessionId !== identity.sessionId) {
+                    throw new Error("committed candidate acceptance resolved to a different native thread");
+                }
+                acceptance = result.evidence;
+            }
+        }
+        else {
+            acceptance = detectCodexRolloutAcceptance({
+                anchor: authority.anchor,
+                currentIdentity: identity,
+                requestHash: current.request_hash
+            });
+        }
         if (!acceptance) {
             throw new Error(`deferred foreground transfer ${current.transfer_id} cannot re-prove ` +
                 "its exact request acceptance");
@@ -20331,6 +21914,15 @@ function persistCommittedDeferredForegroundTurnAcceptance({ storeDir, terminal,
 }
 async function recoverDeferredCodexForegroundTransferBeforeMutation({ options, terminal }) {
     const storeDir = storeDirFromOptions(options);
+    await withStoreWriterLeaseAsync(storeDir, async () => {
+        await recoverDeferredCodexForegroundTransferWhileWriterLease({
+            options,
+            terminal,
+            storeDir
+        });
+    });
+}
+async function recoverDeferredCodexForegroundTransferWhileWriterLease({ options, terminal, storeDir }) {
     let transfers = listDeferredForegroundTransfers(storeDir);
     // An abort intent is Store authority: it is finalized without consulting a
     // live pane, PID, cwd, or process birth. Once the exact cleanup receipt is
@@ -20357,7 +21949,8 @@ async function recoverDeferredCodexForegroundTransferBeforeMutation({ options, t
     let transfer = candidates[0];
     const boundary = deferredCodexBoundaryFromTransfer({ terminal, transfer });
     if (transfer.status === "committed") {
-        const accepted = persistCommittedDeferredForegroundTurnAcceptance({
+        const accepted = await persistCommittedDeferredForegroundTurnAcceptance({
+            options,
             storeDir,
             terminal,
             transfer
@@ -20413,6 +22006,9 @@ async function recoverDeferredCodexForegroundTransferBeforeMutation({ options, t
             }
         }
         catch (error) {
+            if (isStoreMutationLockTimeout(error)) {
+                throw error;
+            }
             const durable = loadDeferredForegroundTransfer(storeDir, transfer.transfer_id);
             if (durable.status === "dispatch_started") {
                 transfer = markDeferredCodexForegroundTransferUncertain({
@@ -20428,6 +22024,18 @@ async function recoverDeferredCodexForegroundTransferBeforeMutation({ options, t
                     : String(error)}`, { cause: error });
         }
         if (transfer.status !== "uncertain") {
+            const pendingAuthority = loadDeferredForegroundTurnAuthority({
+                storeDir,
+                terminal,
+                transfer
+            });
+            if (pendingAuthority.anchor.version === 3) {
+                // A stable candidate inventory with no exact request match is normal
+                // materialization latency, not ambiguity. Keep the durable Enter and
+                // transfer fences active; monitor/recovery will rescan the same v3
+                // anchor and must never replay terminal input.
+                return;
+            }
             transfer = markDeferredCodexForegroundTransferUncertain({
                 options,
                 boundary,
@@ -21838,7 +23446,17 @@ function terminalBridgeCompletionFingerprint({ completion, terminalMessageId })
     }))
         .digest("hex");
 }
-function prepareTerminalBridgeCompletionCallback({ options, statePath, logPath, conversation, executor, terminalControl, terminalMessageId, completion, allowSupersedeRecovery = false, completionFingerprint = terminalBridgeCompletionFingerprint({
+function prepareTerminalBridgeCompletionCallback(args) {
+    const storeDir = pathsForConversationDir(path.dirname(args.statePath)).storeDir;
+    const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, args.terminalControl, { timeoutMs: 30000 });
+    try {
+        return withStoreWriterLease(storeDir, () => prepareTerminalBridgeCompletionCallbackWithLocksHeld(args));
+    }
+    finally {
+        releaseTerminalLock();
+    }
+}
+function prepareTerminalBridgeCompletionCallbackWithLocksHeld({ options, statePath, logPath, conversation, executor, terminalControl, terminalMessageId, completion, allowSupersedeRecovery = false, completionFingerprint = terminalBridgeCompletionFingerprint({
     completion,
     terminalMessageId
 }) }) {
@@ -21926,21 +23544,26 @@ function prepareTerminalBridgeCompletionCallback({ options, statePath, logPath,
             gatewayUrl: stringValue(claimedConversation.gateway_token)
                 ? claimedConversation.gateway_url
                 : undefined,
-            token: stringValue(claimedConversation.gateway_token)
+            token: stringValue(claimedConversation.gateway_token),
+            recordOnly: !stringValue(claimedConversation.gateway_method)
         });
+        if (prepared.outcome === "record_only" &&
+            cliEnv().AKK_TEST_EXIT_AFTER_LOCAL_COMPLETION_STATE === "1") {
+            // The final Turn phase, completion claim, detection event, and local
+            // message are durable. Startup reconciliation must finish the terminal
+            // ledger without manufacturing a callback outbox or replaying input.
+            cliExit(86);
+        }
         claim.release();
         claimReleased = true;
-        const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
-        try {
-            resolveTerminalBridgeDispatchLedger({
-                terminalControl,
-                conversation: claimedConversation,
-                expectedMessageId: terminalMessageId,
-                reason: "terminal bridge task reached durable completion"
-            });
-        }
-        finally {
-            releaseTerminalLock();
+        if (!resolveTerminalBridgeDispatchLedger({
+            terminalControl,
+            conversation: claimedConversation,
+            expectedMessageId: terminalMessageId,
+            reason: "terminal bridge task reached durable completion"
+        })) {
+            throw new Error(`terminal completion ${claimedConversation.conversation_id} ` +
+                "changed before its dispatch ledger could be settled");
         }
         return {
             claimed: true,
@@ -22057,73 +23680,76 @@ function terminalBridgeActivityPersistIntervalMs(timeoutMinutes, pollIntervalMs)
     return Math.max(pollIntervalMs, Math.min(timeoutMinutes * 30 * 1000, 5 * 60 * 1000));
 }
 function persistTerminalBridgeActivity({ conversation, statePath, logPath, observedAtMs, reason, activityState, timeoutMinutes, hardTimeoutMinutes }) {
-    const releaseLock = acquireFileLock(`${statePath}.lock`);
-    try {
-        const currentConversation = loadState(statePath);
-        if (!isWaitingForAgent(currentConversation.status)) {
-            return currentConversation;
-        }
-        const expectedNativeTakeover = isRecord(conversation.native_session_takeover)
-            ? conversation.native_session_takeover
-            : {};
-        const nativeTakeover = isRecord(currentConversation.native_session_takeover)
-            ? currentConversation.native_session_takeover
-            : {};
-        if (nativeTakeover["terminal_bridge_message_id"] !==
-            expectedNativeTakeover["terminal_bridge_message_id"]) {
-            return currentConversation;
-        }
-        const previousActivityAtMs = validTimestampMs(nativeTakeover["terminal_bridge_last_activity_at"]);
-        const observedAt = new Date(observedAtMs).toISOString();
-        const inactivityDeadlineAt = Number.isFinite(timeoutMinutes) && timeoutMinutes > 0
-            ? new Date(observedAtMs + timeoutMinutes * 60 * 1000).toISOString()
-            : undefined;
-        const nextConversation = {
-            ...currentConversation,
-            native_session_takeover: {
-                ...nativeTakeover,
-                terminal_bridge_last_activity_at: observedAt,
-                terminal_bridge_last_activity_reason: reason,
-                terminal_bridge_inactivity_deadline_at: inactivityDeadlineAt,
-                terminal_bridge_inactivity_timeout_minutes: timeoutMinutes,
-                terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes
-            },
-            updated_at: observedAt
-        };
-        saveState(statePath, nextConversation);
-        appendEvent(logPath, {
-            ts: observedAt,
-            conversation_id: currentConversation.conversation_id,
-            event: "terminal_bridge_activity_observed",
-            reason,
-            last_activity_at: observedAt,
-            terminal_activity_state: activityState
-        });
-        if (inactivityDeadlineAt) {
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+    return withStoreWriterLease(storeDir, () => {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const currentConversation = loadState(statePath);
+            if (!isWaitingForAgent(currentConversation.status)) {
+                return currentConversation;
+            }
+            const expectedNativeTakeover = isRecord(conversation.native_session_takeover)
+                ? conversation.native_session_takeover
+                : {};
+            const nativeTakeover = isRecord(currentConversation.native_session_takeover)
+                ? currentConversation.native_session_takeover
+                : {};
+            if (nativeTakeover["terminal_bridge_message_id"] !==
+                expectedNativeTakeover["terminal_bridge_message_id"]) {
+                return currentConversation;
+            }
+            const previousActivityAtMs = validTimestampMs(nativeTakeover["terminal_bridge_last_activity_at"]);
+            const observedAt = new Date(observedAtMs).toISOString();
+            const inactivityDeadlineAt = Number.isFinite(timeoutMinutes) && timeoutMinutes > 0
+                ? new Date(observedAtMs + timeoutMinutes * 60 * 1000).toISOString()
+                : undefined;
+            const nextConversation = {
+                ...currentConversation,
+                native_session_takeover: {
+                    ...nativeTakeover,
+                    terminal_bridge_last_activity_at: observedAt,
+                    terminal_bridge_last_activity_reason: reason,
+                    terminal_bridge_inactivity_deadline_at: inactivityDeadlineAt,
+                    terminal_bridge_inactivity_timeout_minutes: timeoutMinutes,
+                    terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes
+                },
+                updated_at: observedAt
+            };
+            saveState(statePath, nextConversation);
             appendEvent(logPath, {
                 ts: observedAt,
                 conversation_id: currentConversation.conversation_id,
-                event: "terminal_bridge_inactivity_deadline_extended",
+                event: "terminal_bridge_activity_observed",
                 reason,
-                previous_last_activity_at: previousActivityAtMs === undefined
-                    ? null
-                    : new Date(previousActivityAtMs).toISOString(),
                 last_activity_at: observedAt,
-                inactivity_deadline_at: inactivityDeadlineAt,
-                agent_timeout_minutes: timeoutMinutes
+                terminal_activity_state: activityState
             });
+            if (inactivityDeadlineAt) {
+                appendEvent(logPath, {
+                    ts: observedAt,
+                    conversation_id: currentConversation.conversation_id,
+                    event: "terminal_bridge_inactivity_deadline_extended",
+                    reason,
+                    previous_last_activity_at: previousActivityAtMs === undefined
+                        ? null
+                        : new Date(previousActivityAtMs).toISOString(),
+                    last_activity_at: observedAt,
+                    inactivity_deadline_at: inactivityDeadlineAt,
+                    agent_timeout_minutes: timeoutMinutes
+                });
+            }
+            return nextConversation;
         }
-        return nextConversation;
-    }
-    finally {
-        releaseLock();
-    }
+        finally {
+            releaseLock();
+        }
+    });
 }
 function persistTerminalBridgeDetectorDiagnostic({ statePath, logPath, expectedConversationId, expectedMessageId, limitation, fingerprint }) {
     const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
-    const releaseLock = acquireFileLock(`${statePath}.lock`);
-    try {
-        return withStoreWriterLease(storeDir, () => {
+    return withStoreWriterLease(storeDir, () => {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
             const conversation = loadState(statePath);
             const nativeTakeover = isRecord(conversation.native_session_takeover)
                 ? conversation.native_session_takeover
@@ -22208,11 +23834,11 @@ function persistTerminalBridgeDetectorDiagnostic({ statePath, logPath, expectedC
                 conversation: nextConversation,
                 diagnostic: nextDiagnostic
             };
-        });
-    }
-    finally {
-        releaseLock();
-    }
+        }
+        finally {
+            releaseLock();
+        }
+    });
 }
 function terminalBridgeApprovalCandidate({ executor, terminalControl, terminalStatus, fingerprint }) {
     const approval = isRecord(terminalStatus?.approval_state) ? terminalStatus.approval_state : {};
@@ -22506,14 +24132,17 @@ function resolveCallbackGatewayRoute(...candidates) {
     };
 }
 function runCallbackTransaction(options) {
-    const releaseLock = acquireFileLock(`${options.statePath}.lock`);
     let prepared;
-    try {
-        prepared = prepareLockedCallback(options);
-    }
-    finally {
-        releaseLock();
-    }
+    const callbackStoreDir = pathsForConversationDir(path.dirname(options.statePath)).storeDir;
+    withStoreWriterLease(callbackStoreDir, () => {
+        const releaseLock = acquireFileLock(`${options.statePath}.lock`);
+        try {
+            prepared = prepareLockedCallback(options);
+        }
+        finally {
+            releaseLock();
+        }
+    });
     return runPreparedCallback(prepared);
 }
 function prepareLockedCallback(options) {
@@ -22523,6 +24152,12 @@ function prepareLockedCallback(options) {
         ? options.conversationOverride
         : loadState(options.statePath);
     const conversation = normalizeLegacyCallbackStatus(loadedConversation);
+    const callbackStoreDir = pathsForConversationDir(path.dirname(options.statePath)).storeDir;
+    assertConversationHasNoNonterminalDeferredForegroundTransfer({
+        storeDir: callbackStoreDir,
+        conversation,
+        action: "prepare callback for"
+    });
     const executor = executorForConversation(conversation);
     const persistedGatewayRoute = resolveCallbackGatewayRoute({
         gatewayUrl: options.gatewayUrl,
@@ -23607,6 +25242,10 @@ function acquireFileLock(lockPath, { timeoutMs = 5000, retryMs = 50 } = {}) {
         }
     }
 }
+function isStoreMutationLockTimeout(error) {
+    return error instanceof StoreLockTimeoutError ||
+        (isRecord(error) && error.code === "LOCK_TIMEOUT");
+}
 function staleFileLock(lockPath) {
     try {
         const stat = fs.lstatSync(lockPath);
@@ -24239,72 +25878,80 @@ function isZombieProcess(pid) {
     return result.stdout.trim().toUpperCase().startsWith("Z");
 }
 function markConversationStalled({ statePath, logPath, reason, detail = {} }) {
-    const releaseLock = acquireFileLock(`${statePath}.lock`);
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     let stalledConversation;
     let stalledMessage;
-    try {
-        const conversation = loadState(statePath);
-        if (!isWaitingForAgent(conversation.status)) {
-            runtimeLog("info", "executor_monitor_finished", {
+    let unchangedConversation;
+    withStoreWriterLease(storeDir, () => {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const conversation = loadState(statePath);
+            if (!isWaitingForAgent(conversation.status)) {
+                runtimeLog("info", "executor_monitor_finished", {
+                    conversation_id: conversation.conversation_id,
+                    status: conversation.status,
+                    reason: "conversation_changed_before_stall"
+                });
+                unchangedConversation = conversation;
+                return;
+            }
+            const now = cliNow().toISOString();
+            const executor = executorForConversation(conversation);
+            const terminalBridge = terminalBridgeEnabled(conversation);
+            const shouldNotify = Boolean(conversation.gateway_method && !conversation.stalled_notification_sent_at);
+            stalledMessage = shouldNotify
+                ? createMessage({
+                    conversation,
+                    from: executor.actor,
+                    to: "openclaw",
+                    type: "error",
+                    requiresResponse: false,
+                    body: [
+                        `AKK marked this ${executor.display_name} task as stalled: ${reason}.`,
+                        "",
+                        `Turn: ${turnIdForConversation(conversation)}`,
+                        `AKK session: ${sessionIdForConversation(conversation)}`,
+                        `Agent session: ${executor.session}`,
+                        terminalBridge
+                            ? `Use \`AKK status --turn ${turnIdForConversation(conversation)}\` for details, \`AKK renew --turn ${turnIdForConversation(conversation)}\` to resume monitoring in this Turn, or \`AKK close --turn ${turnIdForConversation(conversation)}\` to close it. Start any independent retry with \`AKK send --session ${sessionIdForConversation(conversation)}\`.`
+                            : `Use \`AKK status --turn ${turnIdForConversation(conversation)}\` for details or \`AKK close --turn ${turnIdForConversation(conversation)}\` to close this Turn.`
+                    ].join("\n")
+                })
+                : undefined;
+            stalledConversation = {
+                ...conversation,
+                status: "stalled",
+                stalled_at: now,
+                stalled_reason: reason,
+                stalled_notification_sent_at: shouldNotify ? now : conversation.stalled_notification_sent_at,
+                stalled_notification_message_id: stalledMessage?.id ?? conversation.stalled_notification_message_id,
+                updated_at: now
+            };
+            saveState(statePath, stalledConversation);
+            appendEvent(logPath, {
+                ts: now,
                 conversation_id: conversation.conversation_id,
-                status: conversation.status,
-                reason: "conversation_changed_before_stall"
+                event: "conversation_stalled",
+                status: "stalled",
+                reason,
+                ...detail
+            });
+            runtimeLog("warn", "conversation_stalled", {
+                conversation_id: conversation.conversation_id,
+                agent: executorForConversation(conversation).kind,
+                executor_session: executorForConversation(conversation).session,
+                state_path: statePath,
+                event_log_path: logPath,
+                reason,
+                ...detail
             });
-            return conversation;
         }
-        const now = cliNow().toISOString();
-        const executor = executorForConversation(conversation);
-        const terminalBridge = terminalBridgeEnabled(conversation);
-        const shouldNotify = Boolean(conversation.gateway_method && !conversation.stalled_notification_sent_at);
-        stalledMessage = shouldNotify
-            ? createMessage({
-                conversation,
-                from: executor.actor,
-                to: "openclaw",
-                type: "error",
-                requiresResponse: false,
-                body: [
-                    `AKK marked this ${executor.display_name} task as stalled: ${reason}.`,
-                    "",
-                    `Turn: ${turnIdForConversation(conversation)}`,
-                    `AKK session: ${sessionIdForConversation(conversation)}`,
-                    `Agent session: ${executor.session}`,
-                    terminalBridge
-                        ? `Use \`AKK status --turn ${turnIdForConversation(conversation)}\` for details, \`AKK renew --turn ${turnIdForConversation(conversation)}\` to resume monitoring in this Turn, or \`AKK close --turn ${turnIdForConversation(conversation)}\` to close it. Start any independent retry with \`AKK send --session ${sessionIdForConversation(conversation)}\`.`
-                        : `Use \`AKK status --turn ${turnIdForConversation(conversation)}\` for details or \`AKK close --turn ${turnIdForConversation(conversation)}\` to close this Turn.`
-                ].join("\n")
-            })
-            : undefined;
-        stalledConversation = {
-            ...conversation,
-            status: "stalled",
-            stalled_at: now,
-            stalled_reason: reason,
-            stalled_notification_sent_at: shouldNotify ? now : conversation.stalled_notification_sent_at,
-            stalled_notification_message_id: stalledMessage?.id ?? conversation.stalled_notification_message_id,
-            updated_at: now
-        };
-        saveState(statePath, stalledConversation);
-        appendEvent(logPath, {
-            ts: now,
-            conversation_id: conversation.conversation_id,
-            event: "conversation_stalled",
-            status: "stalled",
-            reason,
-            ...detail
-        });
-        runtimeLog("warn", "conversation_stalled", {
-            conversation_id: conversation.conversation_id,
-            agent: executorForConversation(conversation).kind,
-            executor_session: executorForConversation(conversation).session,
-            state_path: statePath,
-            event_log_path: logPath,
-            reason,
-            ...detail
-        });
-    }
-    finally {
-        releaseLock();
+        finally {
+            releaseLock();
+        }
+    });
+    if (unchangedConversation) {
+        return unchangedConversation;
     }
     if (stalledConversation && stalledMessage) {
         deliverStalledNotification({
@@ -24397,6 +26044,11 @@ function reconcileIdleConversations(storeDir, options = {}, now = cliNow(), conv
     ensureStoreWritable(storeDir);
     const conversations = listConversations(storeDir).filter((conversation) => (conversationId === undefined || conversation.conversation_id === conversationId) &&
         matchesConfiguredWorkspace(options.workspace, conversation.workspace));
+    const reservedSourceTurnIds = new Set(listDeferredForegroundTransfers(storeDir)
+        .filter((transfer) => transfer.version === 2 &&
+        transfer.source_kind === "candidate_rollout_quiescent" &&
+        !["resolved", "abort_resolved"].includes(transfer.status))
+        .flatMap((transfer) => (transfer.source_turn_history ?? []).map((turn) => turn.turn_id)));
     let closed = 0;
     let skipped = 0;
     for (const listedConversation of conversations) {
@@ -24410,6 +26062,10 @@ function reconcileIdleConversations(storeDir, options = {}, now = cliNow(), conv
         if (now.getTime() - listedIdleSinceMs < timeoutMinutes * 60 * 1000) {
             continue;
         }
+        if (reservedSourceTurnIds.has(turnIdForConversation(listedConversation))) {
+            skipped += 1;
+            continue;
+        }
         const statePath = listedConversation.state_path ??
             statePathForConversationId(listedConversation.conversation_id, storeDir);
         let releaseStateLock;
@@ -24987,7 +26643,7 @@ function usage() {
   agent-knock-knock resume-thread --terminal <exact-terminal-id> (--selection-handle <handle> | --selection-snapshot <id> (--selection-number <n> | --selection-short-id <@id>)) --selection-scope <opaque-scope>
   agent-knock-knock reconcile-binding --terminal <exact-terminal-id> --conflicting-session <session-id> --expected-session-revision <n> --expected-binding-token <token> --expected-terminal-token <token>
   agent-knock-knock respond --turn <turn-id|selector> --message <text> [--conversation <selector>]
-  agent-knock-knock approve [--turn <turn-id|selector>] [--conversation <selector>] --expected-approval-fingerprint <fingerprint>
+  agent-knock-knock approve [--turn <turn-id|selector>] [--conversation <selector>] [--expected-terminal-token <token>] --expected-approval-fingerprint <fingerprint>
   agent-knock-knock cancel [--turn <turn-id|selector>] [--conversation <selector>]
   agent-knock-knock renew [--turn <turn-id|selector>] [--conversation <selector>]
   agent-knock-knock retry-callback [--turn <turn-id|selector>] [--conversation <selector>]