@scotthuang/agent-knock-knock 0.12.3 → 0.12.5

package/dist/src/cli-core.js

@@ -11,16 +11,17 @@ import { captureClaudeTranscriptAnchor, defaultClaudeHome, detectClaudeTranscrip
 import { captureCodexRolloutAcceptanceAnchor, detectCodexBoundRolloutCompletion, detectCodexRolloutAcceptance, terminalSubmissionReplayReceipt, 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";
 import { applyMessageToConversation, budgetAction, createConversation, createMessage, effectiveTurnStatus, executorForConversation, extractStructuredMessage, isTurnPhaseStatus, normalizeLegacyCallbackStatus, parseMessageJson, resolveExecutor, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
 import { EXECUTOR_KINDS, executorDefinitionForKind, isExecutorKind } from "./executors.js";
 import { redactString, writeRuntimeLog } from "./runtime-log.js";
 import { formatTranscript, readNdjsonLog } from "./transcript.js";
-import { appendEvent, assertStoreWriterCompatible, defaultStoreDir, ensureDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, StoreLockTimeoutError, statePathForConversationId, withStoreWriterLease, withStoreWriterLeaseAsync } from "./store.js";
+import { appendEvent, assertStoreWriterCompatible, defaultStoreDir, ensureDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, STORE_SESSION_AUTHORITY_PROTOCOL, StoreLockTimeoutError, statePathForConversationId, withStoreWriterLease, withStoreWriterLeaseAsync } from "./store.js";
 import { createManagedSessionId, createNativeThreadTransitionId, humanObservedHandoffBindingToken, isExactNativeThreadId, legacyManagedSessionBindingToken, legacyUnmanagedTerminalBindingToken, managedSessionBindingToken, nativeThreadCommandFingerprint, terminalBindingFrom, unmanagedTerminalBindingToken } from "./managed-session.js";
 import { classifyCodexLifecyclePostcondition, evaluateResumeCandidateAvailability, hasStrongCodexLifecycleIdentity, isFreshCodexPostProbeScreen } from "./native-thread-lifecycle-policy.js";
 import { createNativeThreadResumeSnapshot, nativeThreadCandidateSnapshotFingerprint, nativeThreadResumeSnapshotRowsMatchCandidates, resolveNativeThreadResumeSelection, saveNativeThreadResumeSnapshot, sortNativeThreadCandidates, terminalActionFingerprint, verifiedPreviousResumeCandidate } from "./native-thread-resume-snapshot.js";
 import { listNativeThreadTransitions, listManagedSessions, loadManagedSession, loadNativeThreadTransition, nativeThreadTransitionsDir, saveManagedSession, saveNativeThreadTransition, tryLoadManagedSession } from "./session-store.js";
-import { createTerminalControlProviderRegistry as createProviderRegistry, StaticTerminalControlProvider, TmuxTerminalControlProvider } from "./terminal-control-provider.js";
+import { createTerminalControlProviderRegistry as createProviderRegistry, StaticTerminalControlProvider, TerminalControlUnavailableError, TmuxTerminalControlProvider } from "./terminal-control-provider.js";
 import { HerdrTerminalControlProvider } from "./herdr-terminal-control-provider.js";
 import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { associateTerminalEndpointEvidence, hasCanonicalTerminalEndpoint, sameTerminalControlEvidenceIncarnation, sameTerminalControlIncarnation, terminalControlEvidence, terminalControlEvidenceMatches, terminalEndpointFromControlRef, terminalEndpointIdentityFromEvidence, terminalEndpointIdentityKey, terminalLegacyRuntimeRoute, sameTerminalEndpointIdentity } from "./terminal-control-ref.js";
@@ -68,7 +69,8 @@ const TERMINAL_LEDGER_RECEIPT_IMMUTABLE_FIELDS = [
     "executor_kind",
     "openclaw_session",
     "state_path",
-    "event_log_path"
+    "event_log_path",
+    "deferred_foreground_transfer_id"
 ];
 const TERMINAL_BRIDGE_SUPERSEDE_STATUSES = new Set([
     "created",
@@ -96,6 +98,7 @@ const SESSION_SEND_BLOCKING_STATUSES = new Set([
     "callback_failed",
     "cancelling"
 ]);
+const TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON = "a newer terminal submission has an uncertain outcome; inspect the shared terminal pane before continuing";
 const TERMINAL_BRIDGE_MONITOR_LOCK_VERSION = 1;
 const MINIMUM_NODE_VERSION = "22.19.0";
 const PRIVATE_LOCK_FILE_MODE = 0o600;
@@ -2627,7 +2630,7 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
     const stalledConversationIds = [];
     for (const listed of listConversations(storeDir)) {
         if (listed.conversation_id === currentConversationId ||
-            !isActiveStatus(listed.status)) {
+            !SESSION_SEND_BLOCKING_STATUSES.has(listed.status)) {
             continue;
         }
         const listedTakeover = isRecord(listed.native_session_takeover)
@@ -2647,7 +2650,7 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
             const currentTakeover = isRecord(current.native_session_takeover)
                 ? current.native_session_takeover
                 : undefined;
-            if (!isActiveStatus(current.status) ||
+            if (!SESSION_SEND_BLOCKING_STATUSES.has(current.status) ||
                 currentTakeover?.terminal_bridge !== true ||
                 !terminalControlsShareIncarnation(terminalControlFromTakeover(currentTakeover), terminalControl)) {
                 continue;
@@ -2657,12 +2660,13 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
                 ...current,
                 status: "stalled",
                 stalled_at: stalledAt,
-                stalled_reason: "a newer terminal submission has an uncertain outcome; inspect the shared terminal pane before continuing",
+                stalled_reason: TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON,
                 native_session_takeover: {
                     ...currentTakeover,
                     terminal_bridge_uncertain_dispatch_fence: {
                         message_id: uncertainMessageId,
-                        observed_at: stalledAt
+                        observed_at: stalledAt,
+                        previous_status: current.status
                     }
                 },
                 updated_at: stalledAt
@@ -2688,6 +2692,303 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
     }
     return stalledConversationIds;
 }
+function exactTerminalBridgeCollateralStallRepairEvidence({ conversation, storeDir }) {
+    if (conversation.status !== "stalled" ||
+        conversation.stalled_reason !==
+            TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON) {
+        return undefined;
+    }
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const fence = isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence)
+        ? takeover.terminal_bridge_uncertain_dispatch_fence
+        : undefined;
+    const uncertainMessageId = stringValue(fence?.message_id);
+    const fenceObservedAt = stringValue(fence?.observed_at);
+    const previousStatus = stringValue(fence?.previous_status);
+    const ownMessageId = stringValue(takeover?.terminal_bridge_message_id);
+    const ownSubmission = terminalBridgeSubmission(conversation);
+    const completionClaim = isRecord(takeover?.terminal_bridge_completion_claim)
+        ? takeover.terminal_bridge_completion_claim
+        : undefined;
+    const callbackDelivery = isRecord(conversation.callback_delivery)
+        ? conversation.callback_delivery
+        : undefined;
+    const callbackMessage = isRecord(callbackDelivery?.message)
+        ? callbackDelivery.message
+        : undefined;
+    const idleSince = stringValue(conversation.idle_since);
+    const deliveredAt = stringValue(callbackDelivery?.delivered_at);
+    const claimedAt = stringValue(completionClaim?.claimed_at);
+    const fenceAtMs = validTimestampMs(fenceObservedAt);
+    const idleAtMs = validTimestampMs(idleSince);
+    const deliveredAtMs = validTimestampMs(deliveredAt);
+    const claimedAtMs = validTimestampMs(claimedAt);
+    if (takeover?.terminal_bridge !== true ||
+        !uncertainMessageId ||
+        !fenceObservedAt ||
+        fenceAtMs === undefined ||
+        uncertainMessageId === ownMessageId ||
+        (previousStatus !== undefined && previousStatus !== "idle") ||
+        conversation.stalled_at !== fenceObservedAt ||
+        conversation.updated_at !== fenceObservedAt ||
+        !idleSince ||
+        idleAtMs === undefined ||
+        idleAtMs > fenceAtMs ||
+        !ownMessageId ||
+        ownSubmission?.status !== "agent_accepted" ||
+        stringValue(ownSubmission.message_id) !== ownMessageId ||
+        stringValue(ownSubmission.session_id) !==
+            sessionIdForConversation(conversation) ||
+        stringValue(ownSubmission.turn_id) !== turnIdForConversation(conversation) ||
+        !completionClaim ||
+        stringValue(completionClaim.terminal_bridge_message_id) !== ownMessageId ||
+        completionClaim.outcome !== "success" ||
+        !claimedAt ||
+        claimedAtMs === undefined ||
+        claimedAtMs > fenceAtMs ||
+        callbackDelivery?.status !== "delivered" ||
+        callbackDelivery.final_status !== "idle" ||
+        callbackDelivery.preserve_conversation_status !== true ||
+        !callbackMessage ||
+        callbackMessage.type !== "done" ||
+        callbackMessage.requires_response !== false ||
+        stringValue(callbackMessage.id) !==
+            stringValue(completionClaim.callback_message_id) ||
+        stringValue(callbackMessage.conversation_id) !==
+            conversation.conversation_id ||
+        stringValue(callbackMessage.session_id) !==
+            sessionIdForConversation(conversation) ||
+        stringValue(callbackMessage.turn_id) !== turnIdForConversation(conversation) ||
+        stringValue(isRecord(callbackMessage.metadata)
+            ? callbackMessage.metadata.terminal_bridge_message_id
+            : undefined) !== ownMessageId ||
+        !deliveredAt ||
+        deliveredAtMs === undefined ||
+        deliveredAtMs > fenceAtMs) {
+        return undefined;
+    }
+    const control = terminalControlForManagedConversation(conversation);
+    if (!control) {
+        return undefined;
+    }
+    // The target state lock is already held by the caller. Rescan owner state
+    // now instead of trusting the unlocked discovery snapshot used to find the
+    // target candidate.
+    const ownerCandidates = listConversations(storeDir).filter((candidate) => {
+        if (candidate.conversation_id === conversation.conversation_id) {
+            return false;
+        }
+        const candidateTakeover = isRecord(candidate.native_session_takeover)
+            ? candidate.native_session_takeover
+            : undefined;
+        const candidateSubmission = terminalBridgeSubmission(candidate);
+        return candidateTakeover?.terminal_bridge === true &&
+            stringValue(candidateTakeover.terminal_bridge_message_id) ===
+                uncertainMessageId &&
+            stringValue(candidateSubmission?.message_id) === uncertainMessageId &&
+            terminalControlsShareIncarnation(terminalControlForManagedConversation(candidate), control);
+    });
+    if (ownerCandidates.length !== 1) {
+        return undefined;
+    }
+    const ownerListed = ownerCandidates[0];
+    const ownerStatePath = stringValue(ownerListed.state_path);
+    if (!ownerStatePath) {
+        return undefined;
+    }
+    let owner;
+    let ownerEvents;
+    let events;
+    try {
+        owner = loadState(ownerStatePath);
+        ownerEvents = readNdjsonLog(stringValue(owner.event_log_path) ?? logPathForStatePath(ownerStatePath));
+        const statePath = stringValue(conversation.state_path);
+        if (!statePath) {
+            return undefined;
+        }
+        events = readNdjsonLog(stringValue(conversation.event_log_path) ??
+            logPathForStatePath(statePath));
+    }
+    catch {
+        return undefined;
+    }
+    const ownerTakeover = isRecord(owner.native_session_takeover)
+        ? owner.native_session_takeover
+        : undefined;
+    const ownerSubmission = terminalBridgeSubmission(owner);
+    const ownerClosedAt = stringValue(owner.closed_at);
+    const ownerClosedAtMs = validTimestampMs(ownerClosedAt);
+    if (owner.conversation_id !== ownerListed.conversation_id ||
+        owner.status !== "closed" ||
+        !ownerClosedAt ||
+        ownerClosedAtMs === undefined ||
+        ownerClosedAtMs < fenceAtMs ||
+        !stringValue(owner.close_reason) ||
+        owner.updated_at !== ownerClosedAt ||
+        ownerTakeover?.terminal_bridge !== true ||
+        stringValue(ownerTakeover.terminal_bridge_message_id) !==
+            uncertainMessageId ||
+        ownerSubmission?.status !== "uncertain" ||
+        stringValue(ownerSubmission.message_id) !== uncertainMessageId ||
+        stringValue(ownerSubmission.session_id) !== sessionIdForConversation(owner) ||
+        stringValue(ownerSubmission.turn_id) !== turnIdForConversation(owner) ||
+        isRecord(ownerTakeover.terminal_bridge_uncertain_dispatch_fence) ||
+        !terminalControlsShareIncarnation(terminalControlForManagedConversation(owner), control)) {
+        return undefined;
+    }
+    const callbackMessageId = stringValue(callbackMessage.id);
+    const hasCompletionClaim = events.some((event) => event.event === "terminal_bridge_completion_claimed" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.terminal_bridge_message_id === ownMessageId &&
+        event.callback_message_id === callbackMessageId &&
+        event.completion_fingerprint === completionClaim.completion_fingerprint &&
+        event.completion_id === completionClaim.completion_id &&
+        event.outcome === "success" &&
+        event.ts === claimedAt);
+    const hasCompletionDetected = events.some((event) => event.event === "terminal_bridge_completion_detected" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.terminal_bridge_message_id === ownMessageId &&
+        event.callback_message_id === callbackMessageId &&
+        event.completion_id === completionClaim.completion_id &&
+        event.completion_outcome === "success" &&
+        validTimestampMs(event.ts) !== undefined &&
+        validTimestampMs(event.ts) <= fenceAtMs);
+    const hasDeliveredCallback = events.some((event) => event.event === "callback_delivery_succeeded" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.message_id === callbackMessageId &&
+        event.status === "idle" &&
+        event.ts === deliveredAt);
+    const hasExactFence = events.some((event) => event.event === "terminal_bridge_stalled_by_uncertain_dispatch" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.uncertain_message_id === uncertainMessageId &&
+        event.ts === fenceObservedAt);
+    const hasExactOwnerClose = ownerEvents.some((event) => event.event === "conversation_closed" &&
+        event.conversation_id === owner.conversation_id &&
+        event.status === "closed" &&
+        event.ts === ownerClosedAt &&
+        event.reason === owner.close_reason);
+    if (!hasCompletionClaim ||
+        !hasCompletionDetected ||
+        !hasDeliveredCallback ||
+        !hasExactFence ||
+        !hasExactOwnerClose) {
+        return undefined;
+    }
+    return {
+        uncertainMessageId,
+        ownerConversationId: owner.conversation_id,
+        restoredStatus: "idle"
+    };
+}
+function reconcileTerminalBridgeCollateralStalls(storeDir, conversationId) {
+    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) &&
+            conversation.status === "stalled" &&
+            isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence);
+    });
+    let repaired = 0;
+    let skipped = 0;
+    const errors = [];
+    const items = [];
+    for (const listed of candidates) {
+        const statePath = stringValue(listed.state_path);
+        if (!statePath) {
+            skipped += 1;
+            continue;
+        }
+        let releaseStateLock;
+        try {
+            releaseStateLock = acquireFileLock(`${statePath}.lock`);
+            const current = loadState(statePath);
+            const evidence = exactTerminalBridgeCollateralStallRepairEvidence({
+                conversation: current,
+                storeDir
+            });
+            if (!evidence) {
+                skipped += 1;
+                continue;
+            }
+            const takeover = {
+                ...current.native_session_takeover
+            };
+            delete takeover.terminal_bridge_uncertain_dispatch_fence;
+            const repairedAt = cliNow().toISOString();
+            takeover.terminal_bridge_collateral_stall_repair = {
+                repaired_at: repairedAt,
+                uncertain_message_id: evidence.uncertainMessageId,
+                uncertain_owner_conversation_id: evidence.ownerConversationId,
+                restored_status: evidence.restoredStatus,
+                evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
+            };
+            const repairedConversation = {
+                ...current,
+                status: evidence.restoredStatus,
+                native_session_takeover: takeover,
+                updated_at: repairedAt
+            };
+            delete repairedConversation.stalled_at;
+            delete repairedConversation.stalled_reason;
+            saveState(statePath, repairedConversation);
+            let eventWarning;
+            try {
+                appendEvent(stringValue(current.event_log_path) ?? logPathForStatePath(statePath), {
+                    ts: repairedAt,
+                    conversation_id: current.conversation_id,
+                    event: "terminal_bridge_collateral_stall_repaired",
+                    uncertain_message_id: evidence.uncertainMessageId,
+                    uncertain_owner_conversation_id: evidence.ownerConversationId,
+                    previous_status: "stalled",
+                    restored_status: evidence.restoredStatus,
+                    evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
+                });
+            }
+            catch (error) {
+                eventWarning = error instanceof Error ? error.message : String(error);
+                runtimeLog("warn", "terminal_bridge_collateral_stall_repair_event_failed", {
+                    conversation_id: current.conversation_id,
+                    uncertain_message_id: evidence.uncertainMessageId,
+                    error: eventWarning
+                });
+            }
+            repaired += 1;
+            items.push({
+                conversation_id: current.conversation_id,
+                status: "repaired",
+                reason: "legacy_terminal_bridge_collateral_stall",
+                uncertain_message_id: evidence.uncertainMessageId,
+                uncertain_owner_conversation_id: evidence.ownerConversationId,
+                restored_status: evidence.restoredStatus,
+                ...(eventWarning ? { event_warning: eventWarning } : {})
+            });
+        }
+        catch (error) {
+            skipped += 1;
+            const reason = error instanceof Error ? error.message : String(error);
+            errors.push(`${listed.conversation_id}: ${reason}`);
+            items.push({
+                conversation_id: listed.conversation_id,
+                status: "error",
+                reason
+            });
+        }
+        finally {
+            releaseStateLock?.();
+        }
+    }
+    return {
+        checked: candidates.length,
+        repaired,
+        skipped,
+        errors,
+        items
+    };
+}
 function environmentWithoutGatewayTokens() {
     const environment = { ...cliEnv() };
     delete environment.AKK_GATEWAY_TOKEN;
@@ -2723,7 +3024,7 @@ async function runList(options) {
         storeDir,
         terminals: physicalTerminals,
         managedSessions,
-        sessionAuthorityRequired: store.writer_protocol === 3,
+        sessionAuthorityRequired: Number(store.writer_protocol) >= STORE_SESSION_AUTHORITY_PROTOCOL,
         allConversations: allManagedConversations.filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace)),
         displayedConversations: storedConversations,
         includeAll,
@@ -2768,17 +3069,21 @@ async function reconcileStoreForList(storeDir, options) {
         }
         throw error;
     }
-    const idle = reconcileIdleConversations(storeDir, options);
     const monitors = await reconcileMonitors(options, {
         includeCallbackRecovery: false,
         reason: "list_reconciliation",
         conversationId: undefined
     });
+    const idle = reconcileIdleConversations(storeDir, options);
     return {
         status: "completed",
         checked: Math.max(idle.checked, monitors.checked),
-        changed: idle.closed + monitors.launched,
+        changed: idle.closed + monitors.launched + monitors.repaired,
         closed: idle.closed,
+        repaired: monitors.repaired,
+        collateral_stalls_checked: monitors.collateral_stalls_checked,
+        collateral_stalls_skipped: monitors.collateral_stalls_skipped,
+        collateral_stall_repairs: monitors.items.filter((item) => item.status === "repaired"),
         monitors_launched: monitors.launched,
         monitors_already_running: monitors.already_running,
         skipped: idle.skipped + monitors.skipped,
@@ -2999,9 +3304,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     });
     const codexLifecycleIncarnationAvailable = session.agent !== "codex" ||
         Boolean(nativeProcessUuid && nativeProcessBirth);
-    const nativeInspectionHasBlockingTurn = listConversations(storeDirFromOptions(options)).some((turn) => isDiscoverableTmuxConversation(turn) &&
-        terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+    const terminalHasBlockingTurn = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminalControl).length > 0;
     let automatedInputComposerReady = nativeInspectionComposerEmpty(session.agent, terminalState.screen_excerpt);
     if (session.agent === "codex" &&
         (terminalState.activity_state === "idle" ||
@@ -3078,7 +3381,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             }
             : {}),
         commands: {
-            send: true,
+            send: !terminalHasBlockingTurn,
             approve: terminalControl.capabilities.includes("terminal_approval") &&
                 terminalState.approval_state.approvable === true,
             status: true,
@@ -3086,7 +3389,8 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             close: orphanedDispatch !== undefined,
             new_thread: lifecycleCapability.status === "supported" &&
                 lifecycleCapability.newThread === true &&
-                codexLifecycleIncarnationAvailable,
+                codexLifecycleIncarnationAvailable &&
+                !terminalHasBlockingTurn,
             list_resumable_threads: lifecycleCapability.status === "supported" &&
                 lifecycleCapability.resumeExact === true &&
                 codexLifecycleIncarnationAvailable,
@@ -3101,7 +3405,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
                     : Boolean(nativeAgentIdentity?.sessionId &&
                         nativeAgentIdentity.processUuid)) &&
                 orphanedDispatch === undefined &&
-                !nativeInspectionHasBlockingTurn
+                !terminalHasBlockingTurn
         }
     };
     const availableActions = availableListActions(entry);
@@ -3112,6 +3416,15 @@ 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 nonterminalDeferredTransferIds = new Set(nonterminalDeferredTransfers.map((transfer) => transfer.transfer_id));
+    const conversationHasNonterminalDeferredTransfer = (conversation) => {
+        const takeover = isRecord(conversation.native_session_takeover)
+            ? conversation.native_session_takeover
+            : undefined;
+        const transferId = stringValue(takeover?.deferred_foreground_transfer_id);
+        return Boolean(transferId && nonterminalDeferredTransferIds.has(transferId));
+    };
     const discoveredTerminalControls = terminals.flatMap((terminal) => {
         const control = isRecord(terminal.terminal_control)
             ? terminal.terminal_control
@@ -3123,6 +3436,9 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const terminalControl = isRecord(terminal.terminal_control)
             ? terminal.terminal_control
             : undefined;
+        const terminalHasNonterminalDeferredTransfer = Boolean(terminalControl && nonterminalDeferredTransfers.some((transfer) => transfer.terminal_id === String(terminal.id) &&
+            transfer.process_pid === Number(terminal.pid) &&
+            terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl)));
         const allRelated = terminalControl
             ? allConversations.filter((conversation) => terminalControlsShareIncarnation(terminalControlForManagedConversation(conversation), terminalControl))
             : [];
@@ -3227,10 +3543,13 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const bindingAwareRawActions = authoritativeSession
             ? actionsForManagedSessionBinding(rawActions, authoritativeSession)
             : rawActions;
-        const sessionAwareRawActions = authoritativeSession &&
+        const sessionAwareRawActionsBase = authoritativeSession &&
             managedSessionHasUnresolvedNativeTransition(storeDir, authoritativeSession)
             ? Object.fromEntries(Object.entries(bindingAwareRawActions).filter(([actionName]) => actionName !== "native_inspect"))
             : bindingAwareRawActions;
+        const sessionAwareRawActions = terminalHasNonterminalDeferredTransfer
+            ? readOnlyListActions(sessionAwareRawActionsBase)
+            : sessionAwareRawActionsBase;
         const soleBindingConflict = conflictingBoundSessionClaims.length === 1
             ? conflictingBoundSessionClaims[0]
             : undefined;
@@ -3283,6 +3602,13 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             })
             : undefined;
         const blockingHandoffTurns = conflictingSessionTurns.filter((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+        const terminalBlockingTurns = terminalControl
+            ? terminalIncarnationBlockingTurns(storeDir, terminalControl, allRelated)
+            : [];
+        const externalHandoffSourceSessionIds = new Set(conflictingBoundSessionClaims
+            .filter(({ kind }) => kind === "live_external_thread_change")
+            .map(({ session }) => session.session_id));
+        const handoffSourceBlockingTurns = terminalBlockingTurns.filter((turn) => externalHandoffSourceSessionIds.has(sessionIdForConversation(turn)));
         const nativeIdentityObservation = isRecord(terminal.native_agent_identity_observation)
             ? terminal.native_agent_identity_observation
             : undefined;
@@ -3327,6 +3653,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             blockingHandoffTurns.length === 0 &&
+            terminalBlockingTurns.length === 0 &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
             !verifiedEmptySourceActiveElsewhere &&
             terminal.orphaned_terminal_dispatch === undefined &&
@@ -3348,6 +3675,76 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 sourceSession: soleBindingConflict.session
             })
             : undefined;
+        const deferredCodexSource = authoritativeSession &&
+            terminal.agent === "codex" &&
+            nativeIdentityObservation?.status === "verified_absent"
+            ? authoritativeSession
+            : undefined;
+        const deferredCodexProcessUuid = stringValue(terminal.native_agent_process_uuid);
+        const deferredCodexProcessBirth = stringValue(terminal.native_agent_process_birth);
+        const deferredCodexWorkspace = stringValue(terminal.workspace ?? terminal.cwd);
+        const deferredCodexSourceNativeThreadId = stringValue(deferredCodexSource?.binding?.native_thread_id)?.toLowerCase();
+        const deferredCodexSourceActiveElsewhere = Boolean(deferredCodexSourceNativeThreadId &&
+            terminals.some((candidate) => candidate !== terminal &&
+                candidate.agent === "codex" &&
+                stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
+                    deferredCodexSourceNativeThreadId));
+        const deferredCodexDispatchSnapshot = terminalControl
+            ? tryDeferredCodexForegroundDispatchSnapshot(terminalControl)
+            : 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 &&
+            exactBoundCodexStatusCardSourceForDeferredSend({
+                session: deferredCodexSource,
+                terminalId: String(terminal.id),
+                terminalControl,
+                pid: Number(terminal.pid),
+                workspace: deferredCodexWorkspace,
+                processUuid: deferredCodexProcessUuid,
+                processBirth: deferredCodexProcessBirth
+            }) &&
+            managedTurnsForSession(storeDir, deferredCodexSource.session_id).length === 0 &&
+            !deferredCodexSource.last_transition_id &&
+            !managedSessionHasAnyNativeTransition(storeDir, deferredCodexSource) &&
+            terminalBlockingTurns.length === 0 &&
+            terminal.orphaned_terminal_dispatch === undefined &&
+            deferredCodexDispatchSnapshot &&
+            ["idle", "unknown"].includes(String(terminal.activity_state)) &&
+            automatedInputComposerReady === true &&
+            !(isRecord(terminal.approval_state) &&
+                terminal.approval_state.blocked === true) &&
+            !deferredCodexSourceActiveElsewhere &&
+            terminalControl.capabilities.includes("send_keys") &&
+            terminalControl.capabilities.includes("screen_status") &&
+            isRecord(rawActions.send));
+        const deferredCodexForegroundToken = deferredCodexForegroundEligible &&
+            deferredCodexSource &&
+            terminalControl &&
+            deferredCodexProcessUuid &&
+            deferredCodexProcessBirth &&
+            deferredCodexWorkspace &&
+            deferredCodexDispatchSnapshot
+            ? deferredCodexForegroundBindingToken({
+                terminalId: String(terminal.id),
+                terminalControl,
+                pid: Number(terminal.pid),
+                workspace: deferredCodexWorkspace,
+                processUuid: deferredCodexProcessUuid,
+                processBirth: deferredCodexProcessBirth,
+                sourceSession: deferredCodexSource,
+                dispatchSnapshot: deferredCodexDispatchSnapshot
+            })
+            : undefined;
         const reconcileBindingAction = mutationsAllowed &&
             discoveredOwnership.state === "none" &&
             unresolvedSessionClaims.length === 0 &&
@@ -3361,6 +3758,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !conflictingSessionTurns.some((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status)) &&
+            terminalBlockingTurns.length === 0 &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session)
             ? {
                 tool: "agent_knock_knock_reconcile_binding",
@@ -3383,6 +3781,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !conflictingSessionTurns.some((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status)) &&
+            terminalBlockingTurns.length === 0 &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
             externalHandoffTarget?.status === "eligible" &&
             isRecord(rawActions.send) &&
@@ -3394,7 +3793,8 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
-            blockingHandoffTurns.length === 1
+            blockingHandoffTurns.length === 1 &&
+            terminalBlockingTurns.every((turn) => turn.conversation_id === blockingHandoffTurns[0].conversation_id)
             ? blockingHandoffTurns[0]
             : undefined;
         const handoffDecisionToken = handoffDecisionTurn &&
@@ -3434,6 +3834,15 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 }
             }
             : undefined;
+        const blockingHandoffTurnIds = new Set(handoffSourceBlockingTurns.map((turn) => turn.conversation_id));
+        // An active source Turn may be superseded only through the snapshot-bound
+        // handoff decision above. Never expose the generic Store-only close action
+        // for that Turn, because doing so would bypass expected_handoff_token after
+        // the live native thread or Turn generation changed. `blocking_turns` is
+        // reserved for other same-incarnation blockers such as legacy collateral
+        // stalls; clear those first, refresh, and only then decide the handoff.
+        const terminalRecoveryBlockingTurns = terminalBlockingTurns.filter((turn) => !blockingHandoffTurnIds.has(turn.conversation_id) &&
+            !conversationHasNonterminalDeferredTransfer(turn));
         const terminalCanAcceptSend = ownership.state === "none" && isRecord(sessionAwareRawActions.send);
         if (ownership.state === "current" &&
             !allRelated.some((conversation) => conversation.conversation_id === ownership.conversation.conversation_id)) {
@@ -3470,9 +3879,14 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const currentTurnValue = ownership.state === "current"
             ? currentManagedTurnForTerminal(ownership.conversation, terminal, sessionAwareRawActions)
             : undefined;
-        const currentTurn = currentTurnValue && !mutationsAllowed
+        const currentTurnProjection = currentTurnValue && (!mutationsAllowed ||
+            (ownership.state === "current" &&
+                conversationHasNonterminalDeferredTransfer(ownership.conversation)))
             ? readOnlyManagedTurn(currentTurnValue)
             : currentTurnValue;
+        const currentTurn = currentTurnProjection
+            ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
+            : undefined;
         const sortedDisplayed = [...sessionDisplayedRelated]
             .filter((conversation) => conversation.conversation_id !== currentTurn?.conversation_id)
             .sort(compareManagedConversationRecency);
@@ -3480,15 +3894,23 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const recentTurnValue = recentConversation
             ? historicalManagedTurnForTerminal(recentConversation, terminalCanAcceptSend, terminal)
             : undefined;
-        const recentTurn = recentTurnValue && !mutationsAllowed
+        const recentTurnProjection = recentTurnValue && (!mutationsAllowed ||
+            Boolean(recentConversation &&
+                conversationHasNonterminalDeferredTransfer(recentConversation)))
             ? readOnlyManagedTurn(recentTurnValue)
             : recentTurnValue;
+        const recentTurn = recentTurnProjection
+            ? withoutGenericHandoffSourceClose(recentTurnProjection, blockingHandoffTurnIds)
+            : undefined;
         const historyConversations = includeAll
             ? sortedDisplayed.filter((conversation) => conversation.conversation_id !== recentConversation?.conversation_id)
             : [];
         const history = historyConversations.map((conversation) => {
             const turn = historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal);
-            return mutationsAllowed ? turn : readOnlyManagedTurn(turn);
+            return withoutGenericHandoffSourceClose(mutationsAllowed &&
+                !conversationHasNonterminalDeferredTransfer(conversation)
+                ? turn
+                : readOnlyManagedTurn(turn), blockingHandoffTurnIds);
         });
         const visibleTurnIds = new Set([currentTurn, recentTurn, ...history]
             .map((turn) => stringValue(turn?.conversation_id))
@@ -3552,14 +3974,28 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                         ? { reconcile_binding: reconcileBindingAction }
                         : {})
                 }
-                : managedSessionId &&
-                    sessionBindingMatchesLiveTerminal &&
-                    isRecord(sessionAwareRawActions.send)
+                : deferredCodexForegroundToken &&
+                    isRecord(rawActions.send)
                     ? {
                         ...sessionAwareRawActions,
-                        send: sendActionForManagedSession(sessionAwareRawActions.send, managedSessionId)
+                        send: {
+                            ...rawActions.send,
+                            arguments: {
+                                ...(isRecord(rawActions.send.arguments)
+                                    ? rawActions.send.arguments
+                                    : {}),
+                                expected_terminal_token: deferredCodexForegroundToken
+                            }
+                        }
                     }
-                    : sessionAwareRawActions;
+                    : managedSessionId &&
+                        sessionBindingMatchesLiveTerminal &&
+                        isRecord(sessionAwareRawActions.send)
+                        ? {
+                            ...sessionAwareRawActions,
+                            send: sendActionForManagedSession(sessionAwareRawActions.send, managedSessionId)
+                        }
+                        : sessionAwareRawActions;
         const authoritativeBinding = authoritativeSession?.binding;
         const authoritativeIdentity = authoritativeBinding?.native_thread_id
             ? {
@@ -3602,17 +4038,45 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                     handoff_state: externalHandoffAdoptable
                         ? "external_handoff_adoptable"
                         : "external_handoff_blocked",
-                    ...(automatedInputComposerReady !== true
+                    ...(terminalRecoveryBlockingTurns.length > 0
                         ? {
-                            handoff_blocked_reason: "the current terminal composer is not an exact empty idle frame"
+                            handoff_blocked_reason: "the terminal has unresolved managed Turn state; use only a listed blocking_turns recovery action"
                         }
-                        : {})
+                        : handoffDecision
+                            ? {
+                                handoff_blocked_reason: "the source Session has one active Turn; use only the snapshot-bound handoff_decision after explicit confirmation"
+                            }
+                            : handoffSourceBlockingTurns.length > 0
+                                ? {
+                                    handoff_blocked_reason: "the conflicting source Session has unresolved Turn state but no snapshot-bound handoff decision is currently safe; inspect the conflict and refresh"
+                                }
+                                : automatedInputComposerReady !== true
+                                    ? {
+                                        handoff_blocked_reason: "the current terminal composer is not an exact empty idle frame"
+                                    }
+                                    : {})
                 }
                 : {}),
             ...(verifiedEmptyCodexSnapshotToken
                 ? { handoff_state: "verified_empty_native_session_adoptable" }
                 : {}),
             ...(handoffDecision ? { handoff_decision: handoffDecision } : {}),
+            ...(terminalRecoveryBlockingTurns.length > 0
+                ? {
+                    blocking_turns: terminalRecoveryBlockingTurns.map((turn) => ({
+                        session_id: sessionIdForConversation(turn),
+                        turn_id: turnIdForConversation(turn),
+                        status: turn.status,
+                        recovery_action: {
+                            tool: "agent_knock_knock_close",
+                            arguments: {
+                                turn_id: turnIdForConversation(turn)
+                            },
+                            requires_explicit_user_confirmation: true
+                        }
+                    }))
+                }
+                : {}),
             managed: management,
             available_actions: availableActions
         };
@@ -3637,7 +4101,8 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         });
         return {
             ...managedTurn,
-            available_actions: mutationsAllowed
+            available_actions: mutationsAllowed &&
+                !conversationHasNonterminalDeferredTransfer(conversation)
                 ? safeUnavailableManagedTurnActions(isRecord(managedTurn.available_actions)
                     ? managedTurn.available_actions
                     : {})
@@ -3850,11 +4315,56 @@ function managedSessionHasUnresolvedNativeTransition(storeDir, session) {
     }
     return false;
 }
+function managedSessionHasAnyNativeTransition(storeDir, session) {
+    const root = nativeThreadTransitionsDir(storeDir);
+    if (!fs.existsSync(root)) {
+        return false;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return true;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        let transition;
+        try {
+            transition = loadNativeThreadTransition(storeDir, entry.name);
+        }
+        catch {
+            return true;
+        }
+        if (transition.source_session_id === session.session_id ||
+            transition.target_session_id === session.session_id) {
+            return true;
+        }
+    }
+    return false;
+}
 function terminalControlForManagedConversation(conversation) {
     return terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined);
 }
+function terminalIncarnationBlockingTurns(storeDir, terminalControl, conversations = listConversations(storeDir)) {
+    return conversations
+        .filter(isDiscoverableTmuxConversation)
+        .filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminalControl) &&
+        SESSION_SEND_BLOCKING_STATUSES.has(turn.status))
+        .sort(compareManagedConversationRecency);
+}
+function assertTerminalIncarnationCanStartTurn(storeDir, terminalControl) {
+    const blocker = terminalIncarnationBlockingTurns(storeDir, terminalControl)[0];
+    if (!blocker) {
+        return;
+    }
+    throw new Error(`terminal ${terminalControl.target} still has unresolved Turn ` +
+        `${turnIdForConversation(blocker)} (${blocker.status})`);
+}
 function compareManagedConversationRecency(left, right) {
     const leftTime = Date.parse(String(left.updated_at ?? left.created_at ?? ""));
     const rightTime = Date.parse(String(right.updated_at ?? right.created_at ?? ""));
@@ -4074,6 +4584,20 @@ function readOnlyManagedTurn(managedTurn) {
             : {})
     };
 }
+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),
@@ -4311,13 +4835,13 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 9,
+        version: 11,
         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. That nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
+            "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. 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 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.",
             "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.",
@@ -4367,6 +4891,12 @@ function listActionContracts() {
                 authoritative_action_path: "terminals[].handoff_decision.choices.take_over_current.action",
                 requires_explicit_user_confirmation: true,
                 after_success: "refresh list before using a follow-current send action"
+            },
+            blocking_turns: {
+                meaning: "terminal-incarnation-wide collateral unresolved managed Turns that suppress send, lifecycle, and native-inspection actions; an active human-handoff source Turn is never listed here and remains governed only by handoff_decision",
+                authoritative_action_path: "terminals[].blocking_turns[].recovery_action",
+                requires_explicit_user_confirmation: true,
+                after_success: "refresh list before using any terminal action"
             }
         },
         actions: {
@@ -4385,7 +4915,8 @@ function listActionContracts() {
                     "agentHardTimeoutMinutes"
                 ],
                 unsupported: ["timeoutSeconds"],
-                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, or use the exact listed conflict send to detach a verified-empty Codex source before an isolated virgin attach; an explicit session_id never follows the pane."
+                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."
             },
             new_thread: {
                 tool: "agent_knock_knock_new_thread",
@@ -4745,7 +5276,7 @@ async function sessionSelectorCandidates(commandName, options) {
         managedSessions: selectorStore.readable
             ? listManagedSessions(storeDir).filter((session) => matchesConfiguredWorkspace(options.workspace, session.workspace))
             : [],
-        sessionAuthorityRequired: selectorStore.writer_protocol === 3,
+        sessionAuthorityRequired: Number(selectorStore.writer_protocol) >= STORE_SESSION_AUTHORITY_PROTOCOL,
         allConversations: discoverableWorkspaceConversations,
         displayedConversations: discoverableWorkspaceConversations,
         includeAll: false,
@@ -5473,14 +6004,9 @@ async function verifyCodexPendingManagedSendStatus({ options, terminal, session,
     if (!codexComposerVisible(initialStatus.screen.excerpt)) {
         throw new Error("Codex status-card verification requires a visible idle composer");
     }
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
     const observed = await probeCodexCurrentThread({
         options,
         terminal,
-        initialStatus,
         currentIdentity: logicalIdentity,
         runtimeOverride: runtime
     });
@@ -5709,7 +6235,7 @@ function materializeCurrentManagedSession({ options, terminal, identity }) {
         }
         return existingById;
     }
-    throw new Error(`Store protocol 3 has Turn records for Session ${sessionId} but its ` +
+    throw new Error(`Store protocol 3+ has Turn records for Session ${sessionId} but its ` +
         "authoritative Session state is missing");
 }
 async function reattachManagedSessionForNativeIdentity({ options, terminal, identity, storeDir }) {
@@ -5795,7 +6321,28 @@ function exactBoundCodexSourceForVerifiedEmptyHandoff({ session, terminalId, ter
             liveProcessBirth: processBirth
         }) === "same");
 }
-function verifiedEmptyCodexHandoffToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession }) {
+function exactBoundCodexStatusCardSourceForDeferredSend({ session, terminalId, terminalControl, pid, workspace, processUuid, processBirth }) {
+    const binding = session.binding;
+    return Boolean(session.agent === "codex" &&
+        session.status === "bound" &&
+        binding &&
+        isExactNativeThreadId(binding.native_thread_id) &&
+        !binding.native_process.rollout &&
+        isCodexStatusCardEvidence(binding.native_process.evidence) &&
+        binding.native_process.process_uuid &&
+        binding.native_process.process_birth &&
+        binding.native_process.pid === pid &&
+        terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminalId, terminalControl) &&
+        workspace &&
+        path.resolve(session.workspace) === path.resolve(workspace) &&
+        processIncarnationRelationship({
+            binding,
+            livePid: pid,
+            liveProcessUuid: processUuid,
+            liveProcessBirth: processBirth
+        }) === "same");
+}
+function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession, dispatchSnapshot }) {
     const terminalToken = unmanagedTerminalBindingToken({
         terminalId,
         terminalControl,
@@ -5807,49 +6354,159 @@ function verifiedEmptyCodexHandoffToken({ terminalId, terminalControl, pid, work
     });
     return createHash("sha256")
         .update(JSON.stringify({
-        version: 1,
-        kind: "verified_empty_codex_handoff",
+        version: 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"
     }))
         .digest("hex");
 }
-async function assertVerifiedEmptyCodexHandoffBoundary({ options, terminal, sourceSession, expectedSourceStatus, requireNoDispatch, requireEmptyComposer = true }) {
-    const currentSource = loadManagedSession(storeDirFromOptions(options), sourceSession.session_id);
-    if (currentSource.status !== expectedSourceStatus ||
-        currentSource.revision !== sourceSession.revision ||
-        managedSessionBindingToken(currentSource) !==
-            managedSessionBindingToken(sourceSession)) {
-        throw new Error("the verified-empty source Session changed; refresh AKK list");
+function deferredCodexForegroundDispatchSnapshot(terminalControl) {
+    const ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+    return deferredCodexForegroundDispatchSnapshotForLedger(terminalControl, ledger);
+}
+function deferredCodexForegroundDispatchSnapshotForLedger(terminalControl, ledger) {
+    if (!ledger) {
+        return {
+            status: "none",
+            fingerprint: terminalActionFingerprint({
+                kind: "deferred_codex_foreground_terminal_dispatch",
+                status: "none"
+            })
+        };
     }
-    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
-    if (!exactBoundCodexSourceForVerifiedEmptyHandoff({
-        session: {
-            ...currentSource,
-            // The exact source binding remains authoritative after the monotonic
-            // detach; only the Session status changes.
-            status: "bound"
-        },
-        terminalId: terminal.conversationId,
-        terminalControl: terminal.terminalControl,
-        pid: terminal.pid,
-        workspace: terminal.terminalControl.currentPath,
-        processUuid: liveIncarnation.processUuid,
-        processBirth: liveIncarnation.processBirth
-    })) {
-        throw new Error("the verified-empty source binding no longer matches the terminal");
+    const currentAnchor = terminalEndpointFromControlRef(terminalControl).processAnchorPid;
+    const ledgerAnchor = terminalDispatchRecordProcessAnchor(ledger);
+    if (ledger.status !== "resolved" ||
+        !Number.isSafeInteger(currentAnchor) ||
+        Number(currentAnchor) < 1 ||
+        ledgerAnchor !== currentAnchor ||
+        !terminalDispatchRecordMatchesControl(ledger, terminalControl, {
+            requireCurrentRoute: true,
+            requireProcessAnchor: true
+        })) {
+        throw new Error(`terminal ${terminalControl.target} does not have exact resolved ` +
+            "dispatch authority");
     }
-    const observation = await observeCurrentNativeAgentSessionIdentity({
-        options,
-        agent: "codex",
-        pid: terminal.pid,
-        cwd: terminal.terminalControl.currentPath
-    });
-    if (observation.status === "unavailable") {
-        throw new Error(`Codex native identity observation is unavailable: ${observation.reason}`);
+    const resolvedAt = stringValue(ledger.resolved_at);
+    if (!resolvedAt || !Number.isFinite(Date.parse(resolvedAt))) {
+        throw new Error(`terminal ${terminalControl.target} resolved dispatch receipt has no ` +
+            "valid resolved_at");
+    }
+    const statePath = stringValue(ledger.state_path);
+    const ledgerStoreDir = stringValue(ledger.store_dir);
+    if (ledgerStoreDir && !path.isAbsolute(ledgerStoreDir)) {
+        throw new Error(`terminal ${terminalControl.target} resolved dispatch receipt has a ` +
+            "nonabsolute Store owner");
+    }
+    if (statePath) {
+        if (!ledgerStoreDir || !path.isAbsolute(statePath) ||
+            !path.isAbsolute(ledgerStoreDir)) {
+            throw new Error(`terminal ${terminalControl.target} resolved dispatch receipt has ` +
+                "incomplete Store authority");
+        }
+        const canonicalStatePath = path.resolve(statePath);
+        const canonicalStoreDir = path.resolve(ledgerStoreDir);
+        const canonical = pathsForConversationDir(path.dirname(canonicalStatePath));
+        if (path.resolve(canonical.statePath) !== canonicalStatePath ||
+            path.resolve(canonical.storeDir) !== canonicalStoreDir) {
+            throw new Error(`terminal ${terminalControl.target} resolved dispatch receipt has a ` +
+                "noncanonical Store/state owner");
+        }
+        const conversationId = stringValue(ledger.conversation_id);
+        if (conversationId &&
+            path.resolve(pathsForConversation(conversationId, canonicalStoreDir).statePath) !== canonicalStatePath) {
+            throw new Error(`terminal ${terminalControl.target} resolved dispatch receipt has a ` +
+                "mismatched conversation owner");
+        }
+    }
+    return {
+        status: "resolved",
+        fingerprint: terminalActionFingerprint({
+            kind: "deferred_codex_foreground_terminal_dispatch",
+            status: "resolved",
+            ledger
+        })
+    };
+}
+function deferredCodexPreviousDispatchSnapshotMatches({ transfer, terminalControl, ledger }) {
+    let snapshot;
+    try {
+        snapshot = deferredCodexForegroundDispatchSnapshotForLedger(terminalControl, ledger);
+    }
+    catch {
+        return false;
+    }
+    return snapshot.status === transfer.previous_dispatch_status &&
+        snapshot.fingerprint === transfer.previous_dispatch_fingerprint;
+}
+function tryDeferredCodexForegroundDispatchSnapshot(terminalControl) {
+    try {
+        return deferredCodexForegroundDispatchSnapshot(terminalControl);
+    }
+    catch {
+        return undefined;
+    }
+}
+function verifiedEmptyCodexHandoffToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession }) {
+    const terminalToken = unmanagedTerminalBindingToken({
+        terminalId,
+        terminalControl,
+        agent: "codex",
+        pid,
+        workspace,
+        processUuid,
+        processBirth
+    });
+    return createHash("sha256")
+        .update(JSON.stringify({
+        version: 1,
+        kind: "verified_empty_codex_handoff",
+        terminal_token: terminalToken,
+        source_session_id: sourceSession.session_id,
+        source_revision: managedSessionRevision(sourceSession),
+        source_binding_token: managedSessionBindingToken(sourceSession),
+        observation: "verified_absent"
+    }))
+        .digest("hex");
+}
+async function assertVerifiedEmptyCodexHandoffBoundary({ options, terminal, sourceSession, expectedSourceStatus, requireNoDispatch, requireEmptyComposer = true }) {
+    const currentSource = loadManagedSession(storeDirFromOptions(options), sourceSession.session_id);
+    if (currentSource.status !== expectedSourceStatus ||
+        currentSource.revision !== sourceSession.revision ||
+        managedSessionBindingToken(currentSource) !==
+            managedSessionBindingToken(sourceSession)) {
+        throw new Error("the verified-empty source Session changed; refresh AKK list");
+    }
+    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    if (!exactBoundCodexSourceForVerifiedEmptyHandoff({
+        session: {
+            ...currentSource,
+            // The exact source binding remains authoritative after the monotonic
+            // detach; only the Session status changes.
+            status: "bound"
+        },
+        terminalId: terminal.conversationId,
+        terminalControl: terminal.terminalControl,
+        pid: terminal.pid,
+        workspace: terminal.terminalControl.currentPath,
+        processUuid: liveIncarnation.processUuid,
+        processBirth: liveIncarnation.processBirth
+    })) {
+        throw new Error("the verified-empty source binding no longer matches the terminal");
+    }
+    const observation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: "codex",
+        pid: terminal.pid,
+        cwd: 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}; ` +
@@ -5987,102 +6644,963 @@ async function assertVerifiedEmptyCodexTransportBoundary({ options, boundary, re
         requireEmptyComposer
     });
 }
-function observedHandoffAuthorityToken({ terminal, identity, sourceSession, target }) {
-    const exact = exactLifecycleProcessIdentity(terminal, identity);
-    const terminalToken = unmanagedTerminalBindingToken({
+async function assertDeferredCodexForegroundBindingBoundary({ options, boundary, expectedSourceStatus, requireNoDispatch, requireEmptyComposer }) {
+    const storeDir = storeDirFromOptions(options);
+    const source = loadManagedSession(storeDir, boundary.sourceSessionId);
+    const expectedRevision = expectedSourceStatus === "bound"
+        ? boundary.sourceBoundRevision
+        : boundary.sourceReservedRevision;
+    const expectedBindingToken = expectedSourceStatus === "bound"
+        ? boundary.sourceBoundBindingToken
+        : boundary.sourceReservedBindingToken;
+    if (source.status !== expectedSourceStatus ||
+        expectedRevision === undefined ||
+        managedSessionRevision(source) !== expectedRevision ||
+        expectedBindingToken === undefined ||
+        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");
+    }
+    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}`);
+    }
+    if (observation.status !== "verified_absent") {
+        throw new Error(`Codex materialized native thread ${observation.identity.sessionId}; ` +
+            "refresh AKK list before sending");
+    }
+    if (requireNoDispatch) {
+        assertTerminalIncarnationCanStartTurn(storeDir, boundary.terminal.terminalControl);
+        const currentDispatchSnapshot = deferredCodexForegroundDispatchSnapshot(boundary.terminal.terminalControl);
+        if (currentDispatchSnapshot.status !== boundary.previousDispatchSnapshot.status ||
+            currentDispatchSnapshot.fingerprint !==
+                boundary.previousDispatchSnapshot.fingerprint) {
+            throw new Error("the deferred Codex foreground dispatch history changed; refresh AKK list");
+        }
+    }
+    const status = await createTerminalAgentBridge(options).status("codex", boundary.terminal.terminalControl, {
+        runtime: terminalRuntimeForLiveIdentity({
+            terminal: boundary.terminal,
+            expectedEmptyNativeSession: true
+        })
+    });
+    if (status.reachable !== true ||
+        status.approval_state.blocked === true ||
+        !["idle", "unknown"].includes(status.activity_state)) {
+        throw new Error(`terminal ${boundary.terminal.terminalControl.target} is not at a ` +
+            `verified empty Codex prompt (${status.activity_state}: ` +
+            `${status.activity_reason})`);
+    }
+    if (requireEmptyComposer) {
+        await assertCodexComposerReadyForAutomatedInput({
+            options,
+            terminalControl: boundary.terminal.terminalControl
+        });
+    }
+    return source;
+}
+async function prepareDeferredCodexForegroundBinding({ options, terminal, sourceSession, observation, requestText }) {
+    const expectedToken = stringValue(options.expectedTerminalToken);
+    if (terminal.agent !== "codex" ||
+        !sourceSession?.binding ||
+        observation.status !== "verified_absent" ||
+        !expectedToken) {
+        return undefined;
+    }
+    const processUuid = sourceSession.binding.native_process.process_uuid;
+    const processBirth = sourceSession.binding.native_process.process_birth;
+    const workspace = terminal.terminalControl.currentPath;
+    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    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
+        })) {
+        return undefined;
+    }
+    const dispatchSnapshot = deferredCodexForegroundDispatchSnapshot(terminal.terminalControl);
+    const token = deferredCodexForegroundBindingToken({
         terminalId: terminal.conversationId,
         terminalControl: terminal.terminalControl,
-        agent: terminal.agent,
         pid: terminal.pid,
-        workspace: terminal.terminalControl.currentPath ?? cliCwd(),
-        nativeThreadId: exact.sessionId,
-        processUuid: exact.processUuid,
-        processBirth: exact.processBirth,
-        rollout: exact.rollout
+        workspace,
+        processUuid,
+        processBirth,
+        sourceSession,
+        dispatchSnapshot
     });
-    return humanObservedHandoffBindingToken({
-        terminal_token: terminalToken,
+    if (expectedToken !== token) {
+        throw new Error("deferred Codex foreground binding requires the fresh exact terminal " +
+            "token advertised by AKK list");
+    }
+    const targetSessionId = createManagedSessionId();
+    const transferId = createDeferredForegroundTransferId();
+    const boundary = {
+        terminal,
+        transferId,
+        targetSessionId,
+        sourceSessionId: sourceSession.session_id,
+        sourceBoundRevision: managedSessionRevision(sourceSession),
+        sourceBoundBindingToken: managedSessionBindingToken(sourceSession),
+        processUuid,
+        processBirth,
+        previousDispatchSnapshot: dispatchSnapshot
+    };
+    await assertDeferredCodexForegroundBindingBoundary({
+        options,
+        boundary,
+        expectedSourceStatus: "bound",
+        requireNoDispatch: true,
+        requireEmptyComposer: true
+    });
+    await assertNativeThreadHasExclusiveOwnership({
+        options,
+        agent: "codex",
+        currentPid: terminal.pid,
+        nativeThreadId: sourceSession.binding.native_thread_id,
+        storeDir: storeDirFromOptions(options),
+        terminalControl: terminal.terminalControl,
+        excludedManagedSessionId: sourceSession.session_id
+    });
+    const storeDir = storeDirFromOptions(options);
+    const existingTransfer = listDeferredForegroundTransfers(storeDir).find((candidate) => !["resolved", "aborted", "abort_resolved"].includes(candidate.status) &&
+        (candidate.source_session_id === sourceSession.session_id ||
+            (candidate.terminal_id === terminal.conversationId &&
+                terminalControlEvidenceMatches(candidate.terminal_endpoint, terminal.terminalControl))));
+    if (existingTransfer) {
+        throw new Error(`deferred foreground transfer ${existingTransfer.transfer_id} is ` +
+            `still ${existingTransfer.status}; refresh AKK list before sending`);
+    }
+    saveDeferredForegroundTransfer(storeDir, {
+        schema: "agent-knock-knock/deferred-foreground-transfer",
+        version: 1,
+        transfer_id: transferId,
+        status: "prepared",
+        input_stage: "none",
+        terminal_id: terminal.conversationId,
+        terminal_endpoint: terminalControlEvidence(terminal.terminalControl),
+        process_pid: terminal.pid,
+        process_uuid: processUuid,
+        process_birth: processBirth,
+        workspace,
         source_session_id: sourceSession.session_id,
-        source_revision: managedSessionRevision(sourceSession),
+        source_expected_revision: managedSessionRevision(sourceSession),
         source_binding_token: managedSessionBindingToken(sourceSession),
-        target
-    });
+        source_previous_last_transition_id: sourceSession.last_transition_id,
+        source_before_binding: sourceSession.binding,
+        target_session_id: targetSessionId,
+        target_expected_revision: null,
+        previous_dispatch_status: dispatchSnapshot.status,
+        previous_dispatch_fingerprint: dispatchSnapshot.fingerprint,
+        request_hash: required(terminalBridgeRequestFingerprint(terminalSubmissionPayload(requestText)), "deferred foreground request hash is unavailable"),
+        dispatcher_pid: cliPid(),
+        prepared_at: cliNow().toISOString()
+    }, { expectedRevision: null });
+    return boundary;
 }
-function activeTurnHandoffDecisionToken({ handoffToken, turn, ledger }) {
-    const takeover = isRecord(turn.native_session_takeover)
-        ? turn.native_session_takeover
-        : undefined;
-    const submission = terminalBridgeSubmission(turn);
-    return createHash("sha256")
-        .update(JSON.stringify({
-        version: 1,
-        kind: "active_turn_human_handoff",
-        handoff_token: handoffToken,
-        session_id: sessionIdForConversation(turn),
-        turn_id: turnIdForConversation(turn),
-        turn_status: turn.status,
-        turn_updated_at: turn.updated_at ?? null,
-        current_message_id: stringValue(takeover?.terminal_bridge_message_id) ??
-            stringValue(submission?.message_id) ??
-            null,
-        ledger_generation_id: stringValue(ledger?.generation_id) ?? null,
-        ledger_message_id: stringValue(ledger?.message_id) ?? null,
-        ledger_status: stringValue(ledger?.status) ?? null
-    }))
-        .digest("hex");
+function deferredForegroundTransferRevision(transfer) {
+    const revision = Number(transfer.revision);
+    if (!Number.isSafeInteger(revision) || revision < 1) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no valid revision`);
+    }
+    return revision;
 }
-const originalExpectedTerminalSelector = new WeakMap();
-function assertExpectedHandoffTokenUsesExactTerminalSelector({ options, terminal }) {
-    if (!stringValue(options.expectedTerminalToken)) {
+function assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary }) {
+    if (transfer.transfer_id !== boundary.transferId ||
+        transfer.source_session_id !== boundary.sourceSessionId ||
+        transfer.target_session_id !== boundary.targetSessionId ||
+        transfer.source_expected_revision !== boundary.sourceBoundRevision ||
+        transfer.source_binding_token !== boundary.sourceBoundBindingToken ||
+        transfer.previous_dispatch_status !==
+            boundary.previousDispatchSnapshot.status ||
+        transfer.previous_dispatch_fingerprint !==
+            boundary.previousDispatchSnapshot.fingerprint ||
+        transfer.process_pid !== boundary.terminal.pid ||
+        transfer.process_uuid !== boundary.processUuid ||
+        transfer.process_birth !== boundary.processBirth ||
+        transfer.terminal_id !== boundary.terminal.conversationId ||
+        !terminalControlEvidenceMatches(transfer.terminal_endpoint, boundary.terminal.terminalControl)) {
+        throw new Error(`deferred foreground transfer ${boundary.transferId} authority changed`);
+    }
+}
+function abortDeferredCodexForegroundTransferBeforeInput({ options, boundary, reason, terminalInputNotStartedAt }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    if (transfer.status === "abort_resolved") {
         return;
     }
-    const supplied = originalExpectedTerminalSelector.has(options)
-        ? originalExpectedTerminalSelector.get(options)
-        : stringValue(options.session ?? options.conversation ?? options.conversationId)?.trim();
-    if (supplied !== terminal.conversationId) {
-        throw new Error("--expected-terminal-token is valid only with the exact full terminal " +
-            "conversation selector advertised by AKK list");
+    const provedDispatchDidNotStart = transfer.status === "dispatch_started" &&
+        transfer.input_stage === "dispatch_started" &&
+        terminalInputNotStartedAt !== undefined &&
+        Number.isFinite(Date.parse(terminalInputNotStartedAt));
+    if (transfer.input_stage !== "none" && !provedDispatchDidNotStart) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} may have started ` +
+            "terminal input and cannot restore its source");
     }
-}
-async function observedExternalHandoffIdentity({ options, terminal, sourceSession, resolvedIdentity }) {
-    const bridge = createTerminalAgentBridge(options);
-    const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: terminalRuntimeForLiveIdentity({ terminal, physicalOnly: true }) });
-    assertSafeTerminalSend(terminal.agent, status);
-    if (terminal.agent !== "codex") {
-        return { identity: resolvedIdentity, status };
+    if (![
+        "prepared",
+        "source_reserved",
+        "target_prepared",
+        "dispatch_started",
+        "aborted"
+    ].includes(transfer.status)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot abort from ` +
+            transfer.status);
+    }
+    // Publish the terminal abort intent before restoring either Session. A crash
+    // after this receipt is completed by the Store-only finalizer below; a later
+    // successful retry may evolve the Sessions only after `abort_resolved` makes
+    // that cleanup receipt permanently self-contained.
+    if (transfer.status !== "aborted") {
+        transfer = saveDeferredForegroundTransfer(storeDir, {
+            ...transfer,
+            status: "aborted",
+            aborted_at: cliNow().toISOString(),
+            ...(provedDispatchDidNotStart
+                ? { terminal_input_not_started_at: terminalInputNotStartedAt }
+                : {}),
+            error: JSON.stringify(textSummary(reason))
+        }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
     }
-    const sourceBinding = sourceSession.binding;
-    const statusCard = terminal.adapter.observeThreadLifecycle?.({
-        operation: { kind: "new_thread" },
-        phase: "before",
-        screen: status.screen.excerpt ?? ""
+    transfer = finalizeAbortedDeferredCodexForegroundTransferCleanup({
+        storeDir,
+        transfer
+    });
+    runtimeLog("info", "deferred_codex_foreground_transfer_aborted", {
+        transfer_id: transfer.transfer_id,
+        source_session_id: transfer.source_session_id,
+        target_session_id: transfer.target_session_id,
+        terminal_input_sent: false,
+        reason: textSummary(reason)
     });
-    const statusCardId = statusCard?.status === "observed" &&
-        isExactNativeThreadId(statusCard.nativeThreadId)
-        ? statusCard.nativeThreadId.toLowerCase()
-        : undefined;
-    const sourceId = sourceBinding?.native_thread_id?.toLowerCase();
-    if (statusCardId && sourceId && statusCardId !== sourceId) {
-        const processUuid = sourceBinding?.native_process.process_uuid;
-        const processBirth = sourceBinding?.native_process.process_birth;
-        if (!processUuid || !processBirth) {
-            return { identity: undefined, status };
-        }
-        const resolvedMatchesStatus = resolvedIdentity?.sessionId.toLowerCase() === statusCardId;
-        return {
-            identity: {
-                sessionId: statusCardId,
-                processUuid,
-                processBirth,
-                rollout: resolvedMatchesStatus ? resolvedIdentity?.rollout : undefined,
-                evidence: resolvedMatchesStatus
-                    ? `${resolvedIdentity?.evidence ?? "native_thread_boundary"}+codex_status_card`
-                    : statusCard?.evidence ?? "codex_status_card"
-            },
-            status
-        };
-    }
-    return { identity: resolvedIdentity, status };
+}
+function finalizeAbortedDeferredCodexForegroundTransferCleanup({ storeDir, transfer }) {
+    let current = loadDeferredForegroundTransfer(storeDir, transfer.transfer_id);
+    if (current.status === "abort_resolved") {
+        return current;
+    }
+    const provedDispatchDidNotStart = current.input_stage === "dispatch_started" &&
+        current.terminal_input_not_started_at !== undefined &&
+        Number.isFinite(Date.parse(current.terminal_input_not_started_at));
+    if (current.status !== "aborted" ||
+        (current.input_stage !== "none" && !provedDispatchDidNotStart)) {
+        throw new Error(`deferred foreground transfer ${current.transfer_id} does not carry a ` +
+            "zero-input abort intent");
+    }
+    let target = tryLoadManagedSession(storeDir, current.target_session_id);
+    if (target) {
+        if (target.lineage.transition_id !== current.transfer_id ||
+            target.lineage.previous_session_id !== current.source_session_id ||
+            target.binding?.native_thread_id ||
+            target.binding?.native_process.rollout ||
+            target.last_transition_id !== current.transfer_id ||
+            !current.target_before_binding ||
+            JSON.stringify(target.binding) !==
+                JSON.stringify(current.target_before_binding)) {
+            throw new Error(`deferred foreground target ${target.session_id} changed before abort cleanup`);
+        }
+        if (target.status === "transitioning") {
+            if (managedSessionRevision(target) !== current.target_prepared_revision ||
+                managedSessionBindingToken(target) !==
+                    current.target_prepared_binding_token) {
+                throw new Error(`deferred foreground target ${target.session_id} changed before abort cleanup`);
+            }
+            const detachedAt = cliNow().toISOString();
+            target = saveManagedSession(storeDir, {
+                ...target,
+                status: "detached",
+                detached_at: detachedAt,
+                updated_at: detachedAt
+            }, { expectedRevision: managedSessionRevision(target) });
+        }
+        else if (target.status !== "detached" ||
+            managedSessionRevision(target) !==
+                Number(current.target_prepared_revision) + 1 ||
+            managedSessionBindingToken(target) !== managedSessionBindingToken({
+                session_id: current.target_session_id,
+                status: "detached",
+                binding: current.target_before_binding
+            })) {
+            throw new Error(`deferred foreground target ${target.session_id} cannot finish abort ` +
+                `cleanup from ${target.status}`);
+        }
+    }
+    let source = loadManagedSession(storeDir, current.source_session_id);
+    if (source.status === "transitioning" &&
+        source.last_transition_id === current.transfer_id &&
+        managedSessionRevision(source) === current.source_expected_revision + 1 &&
+        managedSessionBindingToken(source) === managedSessionBindingToken({
+            session_id: current.source_session_id,
+            status: "transitioning",
+            binding: current.source_before_binding
+        }) &&
+        JSON.stringify(source.binding) ===
+            JSON.stringify(current.source_before_binding)) {
+        const restoredAt = cliNow().toISOString();
+        source = saveManagedSession(storeDir, {
+            ...source,
+            status: "bound",
+            last_transition_id: current.source_previous_last_transition_id,
+            updated_at: restoredAt
+        }, { expectedRevision: managedSessionRevision(source) });
+    }
+    const allowedSourceRevisions = current.source_reserved_at
+        ? [current.source_expected_revision + 2]
+        : [
+            current.source_expected_revision,
+            // The source Session CAS precedes publication of source_reserved_at.
+            // This exact +2 state is the idempotent restore after that crash gap.
+            current.source_expected_revision + 2
+        ];
+    if (source.status !== "bound" ||
+        source.last_transition_id !== current.source_previous_last_transition_id ||
+        !allowedSourceRevisions.includes(managedSessionRevision(source)) ||
+        managedSessionBindingToken(source) !== current.source_binding_token ||
+        JSON.stringify(source.binding) !== JSON.stringify(current.source_before_binding)) {
+        throw new Error(`deferred foreground source ${source.session_id} changed before abort cleanup`);
+    }
+    const completedAt = cliNow().toISOString();
+    current = saveDeferredForegroundTransfer(storeDir, {
+        ...current,
+        status: "abort_resolved",
+        abort_cleanup_completed_at: completedAt,
+        abort_source_after_revision: managedSessionRevision(source),
+        abort_source_after_status: "bound",
+        abort_source_after_binding_token: managedSessionBindingToken(source),
+        abort_source_after_binding: source.binding,
+        abort_target_after_status: target ? "detached" : "absent",
+        ...(target
+            ? {
+                abort_target_after_revision: managedSessionRevision(target),
+                abort_target_after_binding_token: managedSessionBindingToken(target),
+                abort_target_after_binding: target.binding
+            }
+            : {})
+    }, { expectedRevision: deferredForegroundTransferRevision(current) });
+    return current;
+}
+async function reserveDeferredCodexForegroundTransfer({ options, boundary, targetSession, messageId, turnId, statePath }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    if (transfer.status !== "prepared" || transfer.input_stage !== "none") {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} is already ` +
+            transfer.status);
+    }
+    const source = await assertDeferredCodexForegroundBindingBoundary({
+        options,
+        boundary,
+        expectedSourceStatus: "bound",
+        requireNoDispatch: true,
+        requireEmptyComposer: true
+    });
+    try {
+        const reservedAt = cliNow().toISOString();
+        const reserved = saveManagedSession(storeDir, {
+            ...source,
+            status: "transitioning",
+            last_transition_id: transfer.transfer_id,
+            updated_at: reservedAt
+        }, { expectedRevision: managedSessionRevision(source) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_SOURCE_SESSION_RESERVED === "1") {
+            // Crash seam for the only source-reservation window not yet reflected by
+            // source_reserved_at in the transfer receipt. Recovery must prove and
+            // restore the exact transitioning revision without terminal input.
+            cliExit(86);
+        }
+        boundary.sourceReservedRevision = managedSessionRevision(reserved);
+        boundary.sourceReservedBindingToken = managedSessionBindingToken(reserved);
+        transfer = saveDeferredForegroundTransfer(storeDir, {
+            ...transfer,
+            status: "source_reserved",
+            source_reserved_at: reservedAt
+        }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_SOURCE_RESERVED === "1") {
+            cliExit(86);
+        }
+        const provisionalTarget = {
+            ...targetSession,
+            status: "transitioning",
+            last_transition_id: transfer.transfer_id
+        };
+        boundary.targetPreparedRevision = 1;
+        boundary.targetPreparedBindingToken = managedSessionBindingToken(provisionalTarget);
+        // Publish the complete target CAS authority before the target itself. A
+        // crash can therefore observe either no target or exactly this revision-1
+        // provisional target; it never leaves an unrecorded Session behind.
+        transfer = saveDeferredForegroundTransfer(storeDir, {
+            ...transfer,
+            status: "target_prepared",
+            target_prepared_at: cliNow().toISOString(),
+            target_prepared_revision: 1,
+            target_prepared_status: "transitioning",
+            target_prepared_last_transition_id: transfer.transfer_id,
+            target_prepared_binding_token: managedSessionBindingToken(provisionalTarget),
+            target_before_binding: provisionalTarget.binding,
+            message_id: messageId,
+            turn_id: turnId,
+            state_path: path.resolve(statePath)
+        }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_TARGET_PREPARED === "1") {
+            cliExit(86);
+        }
+        const createdSession = saveManagedSession(storeDir, provisionalTarget, {
+            expectedRevision: null
+        });
+        if (managedSessionRevision(createdSession) !== 1 ||
+            managedSessionBindingToken(createdSession) !==
+                boundary.targetPreparedBindingToken) {
+            throw new Error(`deferred foreground target ${createdSession.session_id} did not ` +
+                "materialize at its prepared CAS authority");
+        }
+        runtimeLog("info", "deferred_codex_foreground_source_reserved", {
+            transfer_id: transfer.transfer_id,
+            terminal_id: boundary.terminal.conversationId,
+            source_session_id: source.session_id,
+            native_thread_id: source.binding?.native_thread_id,
+            process_uuid: boundary.processUuid,
+            process_birth: boundary.processBirth,
+            terminal_input_sent: false
+        });
+        return {
+            createdSession,
+            rollback: () => abortDeferredCodexForegroundTransferBeforeInput({
+                options,
+                boundary,
+                reason: "terminal input was proved not to have started"
+            })
+        };
+    }
+    catch (error) {
+        try {
+            abortDeferredCodexForegroundTransferBeforeInput({
+                options,
+                boundary,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        }
+        catch (abortError) {
+            throw new Error(`deferred foreground reservation failed and could not be aborted: ${abortError instanceof Error ? abortError.message : String(abortError)}`, { cause: error });
+        }
+        throw error;
+    }
+}
+function assertDeferredForegroundTargetPreparedAuthority({ storeDir, transfer }) {
+    const target = loadManagedSession(storeDir, transfer.target_session_id);
+    if (target.status !== "transitioning" ||
+        target.last_transition_id !== transfer.transfer_id ||
+        managedSessionRevision(target) !== transfer.target_prepared_revision ||
+        managedSessionBindingToken(target) !==
+            transfer.target_prepared_binding_token ||
+        JSON.stringify(target.binding) !==
+            JSON.stringify(transfer.target_before_binding) ||
+        target.lineage.transition_id !== transfer.transfer_id ||
+        target.lineage.previous_session_id !== transfer.source_session_id) {
+        throw new Error(`deferred foreground target ${transfer.target_session_id} changed ` +
+            "before terminal dispatch");
+    }
+    return target;
+}
+function advanceDeferredCodexForegroundTransferInputStage({ options, boundary, stage, at }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    assertDeferredForegroundTargetPreparedAuthority({ storeDir, transfer });
+    const source = loadManagedSession(storeDir, transfer.source_session_id);
+    if (source.status !== "transitioning" ||
+        source.last_transition_id !== transfer.transfer_id ||
+        managedSessionRevision(source) !== transfer.source_expected_revision + 1 ||
+        managedSessionBindingToken(source) !== boundary.sourceReservedBindingToken ||
+        JSON.stringify(source.binding) !==
+            JSON.stringify(transfer.source_before_binding)) {
+        throw new Error(`deferred foreground source ${transfer.source_session_id} changed ` +
+            "during terminal dispatch");
+    }
+    if (stage === "text_injected" &&
+        (transfer.status !== "dispatch_started" ||
+            transfer.input_stage !== "dispatch_started")) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot record text ` +
+            `from ${transfer.status}/${transfer.input_stage}`);
+    }
+    if (stage === "enter_dispatched" &&
+        (transfer.status !== "dispatch_started" ||
+            transfer.input_stage !== "text_injected")) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot record Enter ` +
+            `from ${transfer.status}/${transfer.input_stage}`);
+    }
+    transfer = saveDeferredForegroundTransfer(storeDir, {
+        ...transfer,
+        status: "dispatch_started",
+        input_stage: stage,
+        dispatch_started_at: transfer.dispatch_started_at ?? at,
+        ...(stage === "text_injected"
+            ? { text_injected_at: at }
+            : { enter_dispatched_at: at })
+    }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+    return transfer;
+}
+function beginDeferredCodexForegroundTransferDispatch({ options, boundary, at }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    assertDeferredForegroundTargetPreparedAuthority({ storeDir, transfer });
+    if (transfer.status !== "target_prepared" || transfer.input_stage !== "none") {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot begin ` +
+            `dispatch from ${transfer.status}/${transfer.input_stage}`);
+    }
+    transfer = saveDeferredForegroundTransfer(storeDir, {
+        ...transfer,
+        status: "dispatch_started",
+        input_stage: "dispatch_started",
+        dispatch_started_at: at
+    }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+    return transfer;
+}
+function isExactDeferredScrubbedSource({ source, transfer }) {
+    const before = transfer.source_before_binding;
+    const after = source.binding;
+    return Boolean(source.status === "transitioning" &&
+        source.last_transition_id === transfer.transfer_id &&
+        managedSessionRevision(source) === transfer.source_expected_revision + 2 &&
+        after &&
+        after.binding_id !== before.binding_id &&
+        after.generation === before.generation + 1 &&
+        after.terminal_id === before.terminal_id &&
+        terminalControlsShareIncarnation(after.terminal_control, before.terminal_control) &&
+        after.native_thread_id === undefined &&
+        after.native_process.rollout === undefined &&
+        after.native_process.pid === transfer.process_pid &&
+        after.native_process.process_uuid === transfer.process_uuid &&
+        after.native_process.process_birth === transfer.process_birth &&
+        after.native_process.evidence ===
+            "deferred_predecessor_binding_scrubbed");
+}
+function isExactDeferredAcceptedTarget({ target, transfer, identity }) {
+    const before = transfer.target_before_binding;
+    const after = target.binding;
+    return Boolean(before &&
+        after &&
+        target.status === "transitioning" &&
+        target.last_transition_id === transfer.transfer_id &&
+        managedSessionRevision(target) ===
+            Number(transfer.target_prepared_revision) + 1 &&
+        after.binding_id === before.binding_id &&
+        after.generation === before.generation &&
+        after.native_thread_id === identity.sessionId &&
+        after.native_process.pid === transfer.process_pid &&
+        after.native_process.process_uuid === identity.processUuid &&
+        after.native_process.process_birth === identity.processBirth &&
+        exactNativeRolloutMatches(after.native_process.rollout, identity.rollout));
+}
+async function commitDeferredCodexForegroundBinding({ options, boundary, identity, acceptedAt }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    if (!["dispatch_started", "uncertain"].includes(transfer.status) ||
+        transfer.input_stage === "none" ||
+        identity.processUuid !== transfer.process_uuid ||
+        identity.processBirth !== transfer.process_birth ||
+        !isExactNativeThreadId(identity.sessionId) ||
+        !isCompleteNativeRollout(identity.rollout)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} lacks exact ` +
+            "accepted identity authority");
+    }
+    let source = loadManagedSession(storeDir, transfer.source_session_id);
+    const sourceIsReserved = source.status === "transitioning" &&
+        source.last_transition_id === transfer.transfer_id &&
+        managedSessionRevision(source) === transfer.source_expected_revision + 1 &&
+        managedSessionBindingToken(source) === boundary.sourceReservedBindingToken &&
+        JSON.stringify(source.binding) ===
+            JSON.stringify(transfer.source_before_binding);
+    const sameNativeThread = identity.sessionId.toLowerCase() ===
+        transfer.source_before_binding.native_thread_id?.toLowerCase();
+    const sourceAlreadyScrubbed = sameNativeThread &&
+        isExactDeferredScrubbedSource({ source, transfer });
+    if (!sourceIsReserved && !sourceAlreadyScrubbed) {
+        throw new Error(`deferred foreground source ${source.session_id} changed before commit`);
+    }
+    let target = loadManagedSession(storeDir, transfer.target_session_id);
+    const targetAlreadyAccepted = isExactDeferredAcceptedTarget({
+        target,
+        transfer,
+        identity
+    });
+    if (!targetAlreadyAccepted) {
+        target = assertDeferredForegroundTargetPreparedAuthority({
+            storeDir,
+            transfer
+        });
+    }
+    // Prove there is no third-party Store/process owner before the first
+    // retirement or target-binding CAS. The one permitted existing claim is
+    // the reserved predecessor when Codex reused its status-card UUID.
+    await assertNativeThreadHasExclusiveOwnership({
+        options,
+        agent: "codex",
+        currentPid: transfer.process_pid,
+        nativeThreadId: identity.sessionId,
+        storeDir,
+        terminalControl: boundary.terminal.terminalControl,
+        excludedManagedSessionId: targetAlreadyAccepted
+            ? transfer.target_session_id
+            : sameNativeThread
+                ? transfer.source_session_id
+                : transfer.target_session_id
+    });
+    const retirement = sameNativeThread
+        ? "binding_scrubbed_same_native_thread"
+        : "binding_retained";
+    if (sameNativeThread && !sourceAlreadyScrubbed) {
+        const scrubbedAt = cliNow();
+        const scrubbedBinding = terminalBindingFrom({
+            terminalId: transfer.source_before_binding.terminal_id,
+            terminalControl: transfer.source_before_binding.terminal_control,
+            pid: transfer.process_pid,
+            processUuid: transfer.process_uuid,
+            processBirth: transfer.process_birth,
+            evidence: "deferred_predecessor_binding_scrubbed",
+            generation: transfer.source_before_binding.generation + 1,
+            now: scrubbedAt
+        });
+        source = saveManagedSession(storeDir, {
+            ...source,
+            binding: scrubbedBinding,
+            updated_at: scrubbedAt.toISOString()
+        }, { expectedRevision: managedSessionRevision(source) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_SOURCE_SCRUBBED === "1") {
+            cliExit(86);
+        }
+    }
+    if (!targetAlreadyAccepted) {
+        const acceptedBinding = {
+            ...target.binding,
+            native_thread_id: identity.sessionId,
+            native_process: {
+                ...target.binding.native_process,
+                process_uuid: identity.processUuid,
+                process_birth: identity.processBirth,
+                rollout: identity.rollout,
+                evidence: identity.evidence
+            },
+            last_verified_at: acceptedAt
+        };
+        target = saveManagedSession(storeDir, {
+            ...target,
+            binding: acceptedBinding,
+            updated_at: acceptedAt
+        }, { expectedRevision: managedSessionRevision(target) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_TARGET_ACCEPTED === "1") {
+            cliExit(86);
+        }
+    }
+    const recoveredFromUncertainty = transfer.status === "uncertain";
+    const transportProofAt = transfer.dispatch_started_at ?? acceptedAt;
+    transfer = saveDeferredForegroundTransfer(storeDir, {
+        ...transfer,
+        status: "committed",
+        input_stage: "agent_accepted",
+        dispatch_started_at: transfer.dispatch_started_at ?? transportProofAt,
+        text_injected_at: transfer.text_injected_at ?? transportProofAt,
+        enter_dispatched_at: transfer.enter_dispatched_at ?? transportProofAt,
+        agent_accepted_at: acceptedAt,
+        target_native_thread_id: identity.sessionId,
+        target_accepted_revision: managedSessionRevision(target),
+        target_accepted_status: "transitioning",
+        target_accepted_binding_token: managedSessionBindingToken(target),
+        target_accepted_binding: target.binding,
+        source_pre_retirement_revision: managedSessionRevision(source),
+        source_pre_retirement_status: "transitioning",
+        source_pre_retirement_binding_token: managedSessionBindingToken(source),
+        source_pre_retirement_binding: source.binding,
+        source_retirement: retirement,
+        committed_at: acceptedAt,
+        ...(recoveredFromUncertainty ? { recovered_at: acceptedAt } : {})
+    }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+    if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_COMMITTED === "1") {
+        cliExit(86);
+    }
+    return resolveCommittedDeferredCodexForegroundTransfer({
+        options,
+        boundary
+    });
+}
+async function resolveCommittedDeferredCodexForegroundTransfer({ options, boundary }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    if (transfer.status === "resolved") {
+        const resolvedTarget = loadManagedSession(storeDir, transfer.target_session_id);
+        if (resolvedTarget.status !== "bound" ||
+            managedSessionRevision(resolvedTarget) !== transfer.target_after_revision ||
+            managedSessionBindingToken(resolvedTarget) !==
+                transfer.target_after_binding_token) {
+            throw new Error(`resolved deferred target ${resolvedTarget.session_id} changed`);
+        }
+        return resolvedTarget;
+    }
+    if (transfer.status !== "committed" ||
+        !transfer.source_pre_retirement_binding ||
+        !transfer.source_pre_retirement_revision ||
+        !transfer.source_pre_retirement_binding_token ||
+        !transfer.target_accepted_binding ||
+        !transfer.target_accepted_revision ||
+        !transfer.target_accepted_binding_token ||
+        !transfer.target_native_thread_id) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} is not committed`);
+    }
+    let source = loadManagedSession(storeDir, transfer.source_session_id);
+    if (source.status === "transitioning") {
+        if (source.last_transition_id !== transfer.transfer_id ||
+            managedSessionRevision(source) !== transfer.source_pre_retirement_revision ||
+            managedSessionBindingToken(source) !==
+                transfer.source_pre_retirement_binding_token ||
+            JSON.stringify(source.binding) !==
+                JSON.stringify(transfer.source_pre_retirement_binding)) {
+            throw new Error(`deferred foreground source ${source.session_id} changed during commit recovery`);
+        }
+        const detachedAt = cliNow().toISOString();
+        source = saveManagedSession(storeDir, {
+            ...source,
+            status: "detached",
+            last_transition_id: transfer.source_previous_last_transition_id,
+            detached_at: detachedAt,
+            updated_at: detachedAt
+        }, { expectedRevision: managedSessionRevision(source) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_SOURCE_DETACHED === "1") {
+            cliExit(86);
+        }
+    }
+    else if (source.status !== "detached" ||
+        managedSessionRevision(source) !==
+            transfer.source_pre_retirement_revision + 1 ||
+        managedSessionBindingToken(source) !== managedSessionBindingToken({
+            session_id: source.session_id,
+            status: "detached",
+            binding: transfer.source_pre_retirement_binding
+        }) ||
+        JSON.stringify(source.binding) !==
+            JSON.stringify(transfer.source_pre_retirement_binding)) {
+        throw new Error(`deferred foreground source ${source.session_id} has no exact retired receipt`);
+    }
+    let target = loadManagedSession(storeDir, transfer.target_session_id);
+    if (target.status === "transitioning") {
+        if (target.last_transition_id !== transfer.transfer_id ||
+            managedSessionRevision(target) !== transfer.target_accepted_revision ||
+            managedSessionBindingToken(target) !==
+                transfer.target_accepted_binding_token ||
+            JSON.stringify(target.binding) !==
+                JSON.stringify(transfer.target_accepted_binding)) {
+            throw new Error(`deferred foreground target ${target.session_id} changed during commit recovery`);
+        }
+        const boundAt = cliNow().toISOString();
+        target = saveManagedSession(storeDir, {
+            ...target,
+            status: "bound",
+            last_transition_id: undefined,
+            updated_at: boundAt
+        }, { expectedRevision: managedSessionRevision(target) });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_TARGET_BOUND === "1") {
+            cliExit(86);
+        }
+    }
+    else if (target.status !== "bound" ||
+        managedSessionRevision(target) !== transfer.target_accepted_revision + 1 ||
+        managedSessionBindingToken(target) !== managedSessionBindingToken({
+            session_id: target.session_id,
+            status: "bound",
+            binding: transfer.target_accepted_binding
+        }) ||
+        JSON.stringify(target.binding) !==
+            JSON.stringify(transfer.target_accepted_binding)) {
+        throw new Error(`deferred foreground target ${target.session_id} has no exact bound receipt`);
+    }
+    await assertNativeThreadHasExclusiveOwnership({
+        options,
+        agent: "codex",
+        currentPid: transfer.process_pid,
+        nativeThreadId: transfer.target_native_thread_id,
+        storeDir,
+        terminalControl: boundary.terminal.terminalControl,
+        excludedManagedSessionId: target.session_id
+    });
+    transfer = saveDeferredForegroundTransfer(storeDir, {
+        ...transfer,
+        status: "resolved",
+        target_after_revision: managedSessionRevision(target),
+        target_after_status: "bound",
+        target_after_binding_token: managedSessionBindingToken(target),
+        source_after_revision: managedSessionRevision(source),
+        source_after_status: "detached",
+        source_after_binding: source.binding,
+        source_after_binding_token: managedSessionBindingToken(source),
+        resolved_at: cliNow().toISOString()
+    }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+    runtimeLog("info", "deferred_codex_foreground_transfer_resolved", {
+        transfer_id: transfer.transfer_id,
+        source_session_id: source.session_id,
+        target_session_id: target.session_id,
+        native_thread_id: transfer.target_native_thread_id,
+        source_retirement: transfer.source_retirement
+    });
+    return target;
+}
+function markDeferredCodexForegroundTransferUncertain({ options, boundary, reason }) {
+    const storeDir = storeDirFromOptions(options);
+    let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
+    assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    if (["committed", "resolved", "uncertain"].includes(transfer.status)) {
+        return transfer;
+    }
+    if (![
+        "target_prepared",
+        "dispatch_started"
+    ].includes(transfer.status)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no durable ` +
+            "dispatch-start fence");
+    }
+    transfer = saveDeferredForegroundTransfer(storeDir, {
+        ...transfer,
+        status: "uncertain",
+        input_stage: transfer.input_stage === "none"
+            ? "dispatch_started"
+            : transfer.input_stage,
+        dispatch_started_at: transfer.dispatch_started_at ?? cliNow().toISOString(),
+        uncertain_at: cliNow().toISOString(),
+        error: reason.slice(0, 2000),
+        do_not_retry: true
+    }, { expectedRevision: deferredForegroundTransferRevision(transfer) });
+    return transfer;
+}
+function observedHandoffAuthorityToken({ terminal, identity, sourceSession, target }) {
+    const exact = exactLifecycleProcessIdentity(terminal, identity);
+    const terminalToken = unmanagedTerminalBindingToken({
+        terminalId: terminal.conversationId,
+        terminalControl: terminal.terminalControl,
+        agent: terminal.agent,
+        pid: terminal.pid,
+        workspace: terminal.terminalControl.currentPath ?? cliCwd(),
+        nativeThreadId: exact.sessionId,
+        processUuid: exact.processUuid,
+        processBirth: exact.processBirth,
+        rollout: exact.rollout
+    });
+    return humanObservedHandoffBindingToken({
+        terminal_token: terminalToken,
+        source_session_id: sourceSession.session_id,
+        source_revision: managedSessionRevision(sourceSession),
+        source_binding_token: managedSessionBindingToken(sourceSession),
+        target
+    });
+}
+function activeTurnHandoffDecisionToken({ handoffToken, turn, ledger }) {
+    const takeover = isRecord(turn.native_session_takeover)
+        ? turn.native_session_takeover
+        : undefined;
+    const submission = terminalBridgeSubmission(turn);
+    return createHash("sha256")
+        .update(JSON.stringify({
+        version: 1,
+        kind: "active_turn_human_handoff",
+        handoff_token: handoffToken,
+        session_id: sessionIdForConversation(turn),
+        turn_id: turnIdForConversation(turn),
+        turn_status: turn.status,
+        turn_updated_at: turn.updated_at ?? null,
+        current_message_id: stringValue(takeover?.terminal_bridge_message_id) ??
+            stringValue(submission?.message_id) ??
+            null,
+        ledger_generation_id: stringValue(ledger?.generation_id) ?? null,
+        ledger_message_id: stringValue(ledger?.message_id) ?? null,
+        ledger_status: stringValue(ledger?.status) ?? null
+    }))
+        .digest("hex");
+}
+const originalExpectedTerminalSelector = new WeakMap();
+function assertExpectedHandoffTokenUsesExactTerminalSelector({ options, terminal }) {
+    if (!stringValue(options.expectedTerminalToken)) {
+        return;
+    }
+    const supplied = originalExpectedTerminalSelector.has(options)
+        ? originalExpectedTerminalSelector.get(options)
+        : stringValue(options.session ?? options.conversation ?? options.conversationId)?.trim();
+    if (supplied !== terminal.conversationId) {
+        throw new Error("--expected-terminal-token is valid only with the exact full terminal " +
+            "conversation selector advertised by AKK list");
+    }
+}
+async function observedExternalHandoffIdentity({ options, terminal, sourceSession, resolvedIdentity, requireSafeTerminal = true }) {
+    const bridge = createTerminalAgentBridge(options);
+    const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: terminalRuntimeForLiveIdentity({ terminal, physicalOnly: true }) });
+    if (requireSafeTerminal) {
+        assertSafeTerminalSend(terminal.agent, status);
+    }
+    if (terminal.agent !== "codex") {
+        return { identity: resolvedIdentity, status };
+    }
+    const sourceBinding = sourceSession.binding;
+    const statusCard = terminal.adapter.observeThreadLifecycle?.({
+        operation: { kind: "new_thread" },
+        phase: "before",
+        screen: status.screen.excerpt ?? ""
+    });
+    const statusCardId = statusCard?.status === "observed" &&
+        isExactNativeThreadId(statusCard.nativeThreadId)
+        ? statusCard.nativeThreadId.toLowerCase()
+        : undefined;
+    const sourceId = sourceBinding?.native_thread_id?.toLowerCase();
+    if (statusCardId && sourceId && statusCardId !== sourceId) {
+        const processUuid = sourceBinding?.native_process.process_uuid;
+        const processBirth = sourceBinding?.native_process.process_birth;
+        if (!processUuid || !processBirth) {
+            return { identity: undefined, status };
+        }
+        const resolvedMatchesStatus = resolvedIdentity?.sessionId.toLowerCase() === statusCardId;
+        return {
+            identity: {
+                sessionId: statusCardId,
+                processUuid,
+                processBirth,
+                rollout: resolvedMatchesStatus ? resolvedIdentity?.rollout : undefined,
+                evidence: resolvedMatchesStatus
+                    ? `${resolvedIdentity?.evidence ?? "native_thread_boundary"}+codex_status_card`
+                    : statusCard?.evidence ?? "codex_status_card"
+            },
+            status
+        };
+    }
+    return { identity: resolvedIdentity, status };
 }
 function observedHandoffTargetResolution({ storeDir, agent, workspace, nativeThreadId, sourceSessionId }) {
     const matches = listManagedSessions(storeDir).filter((session) => session.session_id !== sourceSessionId &&
@@ -6619,10 +8137,7 @@ function assertTerminalLifecycleReady({ options, terminal, terminalStatus }) {
         throw new Error(`terminal ${terminal.terminalControl.target} is not at a verified idle prompt ` +
             `(${terminalStatus.activity_state}: ${terminalStatus.activity_reason})`);
     }
-    const blockers = listConversations(storeDirFromOptions(options))
-        .filter(isDiscoverableTmuxConversation)
-        .filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminal.terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+    const blockers = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminal.terminalControl);
     if (blockers.length > 0) {
         throw new Error(`terminal ${terminal.terminalControl.target} still has unresolved Turn ` +
             `${turnIdForConversation(blockers[0])} (${blockers[0].status})`);
@@ -7302,10 +8817,7 @@ function assertTerminalNativeInspectionReady({ options, terminal, terminalStatus
         throw new Error(`terminal ${terminal.terminalControl.target} is not at a verified idle prompt ` +
             `(${terminalStatus.activity_state}: ${terminalStatus.activity_reason})`);
     }
-    const blocker = listConversations(storeDirFromOptions(options))
-        .filter(isDiscoverableTmuxConversation)
-        .find((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminal.terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+    const blocker = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminal.terminalControl)[0];
     if (blocker) {
         throw new Error(`terminal ${terminal.terminalControl.target} still has unresolved Turn ` +
             `${turnIdForConversation(blocker)} (${blocker.status})`);
@@ -7749,6 +9261,7 @@ async function waitForVerifiedThreadTransition({ options, terminal, beforeIdenti
     const bridge = createTerminalAgentBridge(options);
     let probeSent = false;
     let postProbeBaselineDigest;
+    let postProbeObservationScrollbackLines;
     let stableIdentity;
     let stableCount = 0;
     const physicalBeforeFence = codexIdentityFence(physicalBeforeIdentity);
@@ -7816,22 +9329,37 @@ async function waitForVerifiedThreadTransition({ options, terminal, beforeIdenti
         }
         else {
             const afterProbe = plan.steps.find((step) => step.kind === "identity_probe_after");
-            if (!afterProbe || afterProbe.effect !== "read_only") {
+            if (!afterProbe ||
+                afterProbe.effect !== "read_only" ||
+                afterProbe.command !== "/status") {
                 throw new Error("the Codex lifecycle plan has no exact post-transition identity probe");
             }
+            const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+            if (!agentVersion) {
+                throw new Error("Codex lifecycle postcondition /status requires the exact running version before terminal input");
+            }
             const physicalRuntime = terminalRuntimeForLiveIdentity({
                 terminal,
                 physicalOnly: true
             });
-            const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: physicalRuntime });
+            const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+                runtime: physicalRuntime,
+                ...(postProbeObservationScrollbackLines === undefined
+                    ? {}
+                    : {
+                        scrollbackLines: postProbeObservationScrollbackLines
+                    })
+            });
             const screenDigest = stringValue(status.screen.digest);
             if (!probeSent &&
                 status.reachable &&
                 status.activity_state === "idle" &&
                 screenDigest !== undefined &&
                 screenDigest !== initialScreenDigest) {
-                postProbeBaselineDigest = screenDigest;
-                await bridge.send(terminal.agent, terminal.terminalControl, afterProbe.command, { runtime: physicalRuntime });
+                const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: physicalRuntime });
+                postProbeBaselineDigest = submission.observationBaselineDigest;
+                postProbeObservationScrollbackLines =
+                    submission.observationScrollbackLines;
                 probeSent = true;
             }
             else if (status.reachable &&
@@ -7960,7 +9488,7 @@ function assertVerifiedClaudeLifecycleBeforeObservation({ options, terminal, ide
             `for the current process incarnation${observed?.reason ? `: ${observed.reason}` : ""}`);
     }
 }
-async function probeCodexCurrentThread({ options, terminal, initialStatus, currentIdentity, runtimeIdentity, runtimeOverride }) {
+async function probeCodexCurrentThread({ options, terminal, currentIdentity, runtimeIdentity, runtimeOverride }) {
     if (terminal.agent !== "codex") {
         throw new Error("the current native thread identity is unavailable");
     }
@@ -7972,24 +9500,31 @@ async function probeCodexCurrentThread({ options, terminal, initialStatus, curre
                 terminal,
                 expectedEmptyNativeSession: true
             }));
-    // The plain activity parser intentionally recognizes Codex's composer even
-    // when a footer follows it, so "idle" alone is not authority to press Enter.
-    // Re-read the styled pane immediately before the slash probe and accept only
-    // an empty composer (or Codex's fully dim replace-on-type placeholder).
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
-    await bridge.send(terminal.agent, terminal.terminalControl, "/status", { runtime: probeRuntime });
+    const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+    if (!agentVersion) {
+        throw new Error("Codex /status requires the exact running version before terminal input");
+    }
+    // Internal status probes use the same closed submission boundary as native
+    // inspection: exact viewport and styled-empty composer proof, Codex's paste
+    // suppression settle, identity revalidation, and exactly one Enter.
+    const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: probeRuntime });
+    let lastObservationReason = "no fresh idle Codex /status card was captured after the one Enter dispatch";
+    let sawIncompleteSessionUuid = false;
     for (let attempt = 0; attempt < 50; attempt += 1) {
-        const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: probeRuntime });
+        const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+            runtime: probeRuntime,
+            scrollbackLines: submission.observationScrollbackLines
+        });
         if (status.reachable &&
-            status.screen.digest !== initialStatus.screen.digest) {
+            status.screen.digest !== submission.observationBaselineDigest) {
             const observed = terminal.adapter.observeThreadLifecycle?.({
                 operation: { kind: "new_thread" },
                 phase: "before",
                 screen: status.screen.excerpt ?? ""
             });
+            lastObservationReason = observed?.reason ?? lastObservationReason;
+            sawIncompleteSessionUuid ||= observed?.status === "missing" &&
+                /complete Session UUID/iu.test(observed.reason ?? "");
             if (observed?.status === "observed" &&
                 observed.nativeThreadId &&
                 status.activity_state === "idle") {
@@ -8006,7 +9541,12 @@ async function probeCodexCurrentThread({ options, terminal, initialStatus, curre
         }
         await cliSleep(100);
     }
-    throw new Error("Codex /status did not expose a complete current Session UUID");
+    throw new Error(sawIncompleteSessionUuid
+        ? "Codex /status Enter was dispatched exactly once, but the status card " +
+            "was truncated before the complete current Session UUID; widen or zoom " +
+            "the pane, refresh AKK list, and do not retry the probe automatically"
+        : "Codex /status Enter was dispatched exactly once, but no fresh exact " +
+            `current Session UUID was proven; do not retry automatically: ${lastObservationReason}`);
 }
 async function runNewThread(options) {
     const requireRestorableOrigin = options.requireRestorableOrigin;
@@ -8363,7 +9903,6 @@ async function runNativeThreadTransition(options, operation) {
                 const statusIdentity = await probeCodexCurrentThread({
                     options,
                     terminal,
-                    initialStatus: terminalStatus,
                     currentIdentity: beforeIdentity,
                     runtimeIdentity: snapshot.runtimeIdentity,
                     runtimeOverride: beforeRuntime
@@ -9027,17 +10566,21 @@ async function reconcileStoreForStatus(storeDir, options, conversationId) {
         }
         throw error;
     }
-    const idle = reconcileIdleConversations(storeDir, options, cliNow(), conversationId);
     const monitors = await reconcileMonitors(options, {
         includeCallbackRecovery: false,
         reason: "status_reconciliation",
         conversationId
     });
+    const idle = reconcileIdleConversations(storeDir, options, cliNow(), conversationId);
     return {
         status: "completed",
         checked: Math.max(idle.checked, monitors.checked),
-        changed: idle.closed + monitors.launched,
+        changed: idle.closed + monitors.launched + monitors.repaired,
         closed: idle.closed,
+        repaired: monitors.repaired,
+        collateral_stalls_checked: monitors.collateral_stalls_checked,
+        collateral_stalls_skipped: monitors.collateral_stalls_skipped,
+        collateral_stall_repairs: monitors.items.filter((item) => item.status === "repaired"),
         monitors_launched: monitors.launched,
         monitors_already_running: monitors.already_running,
         skipped: idle.skipped + monitors.skipped,
@@ -9564,6 +11107,7 @@ async function runSend(options) {
                 })) {
                     return;
                 }
+                assertTerminalIncarnationCanStartTurn(rawStoreDir, terminalConversation.terminalControl);
                 let claimedSession = soleBoundManagedSessionClaimForTerminal(rawStoreDir, terminalConversation);
                 let knownCodexCompanions = claimedSession
                     ? codexAllowedCompanionSetForManagedSession({
@@ -9603,7 +11147,7 @@ async function runSend(options) {
                     currentNativeIdentity = undefined;
                 }
                 const physicalNativeIdentityBeforeHandoff = currentNativeIdentity;
-                const handoff = await maybeAdoptObservedExternalThread({
+                let handoff = await maybeAdoptObservedExternalThread({
                     options,
                     terminal: terminalConversation,
                     sourceSession: claimedSession,
@@ -9616,12 +11160,35 @@ async function runSend(options) {
                         !handoff.session?.binding?.native_process.rollout
                         ? physicalNativeIdentityBeforeHandoff
                         : handoff.identity;
-                let managedSession = handoff.session ??
-                    materializeCurrentManagedSession({
+                const deferredCodexForegroundBinding = !handoff.adopted
+                    ? await prepareDeferredCodexForegroundBinding({
                         options,
                         terminal: terminalConversation,
-                        identity: currentNativeIdentity
-                    });
+                        sourceSession: claimedSession,
+                        observation: nativeIdentityObservation,
+                        requestText: String(messageBody)
+                    })
+                    : undefined;
+                if (deferredCodexForegroundBinding) {
+                    claimedSession = undefined;
+                    knownCodexCompanions = { additional: [] };
+                    currentNativeIdentity = undefined;
+                    handoff = { identity: undefined, adopted: false };
+                }
+                else if (stringValue(options.expectedTerminalToken) &&
+                    !verifiedEmptyHandoff &&
+                    !handoff.adopted) {
+                    throw new Error("the expected terminal token no longer authorizes the current " +
+                        "terminal context; refresh AKK list");
+                }
+                let managedSession = deferredCodexForegroundBinding
+                    ? undefined
+                    : handoff.session ??
+                        materializeCurrentManagedSession({
+                            options,
+                            terminal: terminalConversation,
+                            identity: currentNativeIdentity
+                        });
                 if (!managedSession && currentNativeIdentity) {
                     managedSession = await reattachManagedSessionForNativeIdentity({
                         options,
@@ -9643,13 +11210,29 @@ async function runSend(options) {
                         });
                     }
                     managedSession = createBoundManagedSession({
-                        sessionId: createManagedSessionId(),
+                        sessionId: deferredCodexForegroundBinding?.targetSessionId ??
+                            createManagedSessionId(),
                         terminal: terminalConversation,
                         identity: currentNativeIdentity,
-                        lineage: { created_by: "attach" }
+                        lineage: deferredCodexForegroundBinding
+                            ? {
+                                created_by: "attach",
+                                previous_session_id: deferredCodexForegroundBinding.sourceSessionId,
+                                transition_id: deferredCodexForegroundBinding.transferId
+                            }
+                            : { created_by: "attach" }
                     });
                     if (terminalConversation.agent === "codex" &&
                         !currentNativeIdentity) {
+                        if (deferredCodexForegroundBinding) {
+                            managedSession = {
+                                ...managedSession,
+                                // Both endpoints stay fenced from older writers until the
+                                // dedicated transfer reaches its resolved receipt.
+                                status: "transitioning",
+                                last_transition_id: deferredCodexForegroundBinding.transferId
+                            };
+                        }
                         pendingRawAttachSessionCreate = managedSession;
                     }
                     else {
@@ -9718,7 +11301,8 @@ async function runSend(options) {
                     terminalControl: terminalConversation.terminalControl,
                     previousTurn: reusableTurn,
                     managedSession,
-                    nativeAgentIdentity: materializedNativeIdentity
+                    nativeAgentIdentity: materializedNativeIdentity,
+                    deferredForegroundTransferId: deferredCodexForegroundBinding?.transferId
                 });
                 ensureStoreWritable(managed.conversation.store_dir);
                 ensureDir(path.dirname(managed.statePath));
@@ -9739,8 +11323,30 @@ async function runSend(options) {
                         recordMessageAfterSend: true,
                         recordRawAttachmentAfterSend: reusableTurn === undefined,
                         onTerminalPreflightVerified: pendingRawAttachSessionCreate
-                            ? () => {
-                                const createdSession = saveManagedSession(rawStoreDir, pendingRawAttachSessionCreate, { expectedRevision: null });
+                            ? async () => {
+                                let createdSession;
+                                try {
+                                    if (deferredCodexForegroundBinding) {
+                                        const reserved = await reserveDeferredCodexForegroundTransfer({
+                                            options,
+                                            boundary: deferredCodexForegroundBinding,
+                                            targetSession: pendingRawAttachSessionCreate,
+                                            messageId: managed.message.id,
+                                            turnId: turnIdForConversation(managed.conversation),
+                                            statePath: managed.statePath
+                                        });
+                                        createdSession = reserved.createdSession;
+                                        managedSession = createdSession;
+                                        pendingRawAttachSessionCreate = undefined;
+                                        return reserved.rollback;
+                                    }
+                                    createdSession = saveManagedSession(rawStoreDir, pendingRawAttachSessionCreate, {
+                                        expectedRevision: null
+                                    });
+                                }
+                                catch (error) {
+                                    throw error;
+                                }
                                 managedSession = createdSession;
                                 pendingRawAttachSessionCreate = undefined;
                                 return () => {
@@ -9771,7 +11377,8 @@ async function runSend(options) {
                                 transition: handoff.transition
                             }
                             : undefined,
-                        verifiedEmptyCodexHandoff: verifiedEmptyHandoff?.boundary
+                        verifiedEmptyCodexHandoff: verifiedEmptyHandoff?.boundary,
+                        deferredCodexForegroundBinding
                     });
                 }
                 finally {
@@ -9854,6 +11461,7 @@ async function runSend(options) {
             })) {
                 return;
             }
+            assertTerminalIncarnationCanStartTurn(storeDir, resolvedTerminal.terminalControl);
             let currentSession = tryLoadManagedSession(storeDir, sessionId);
             const knownCodexCompanions = currentSession
                 ? codexAllowedCompanionSetForManagedSession({
@@ -10355,6 +11963,7 @@ async function runApprove(options) {
                 throw new Error("approval state changed while waiting for terminal control; refresh status and retry");
             }
             assertManagedTerminalDispatchOwner({
+                storeDir: writerStoreDir,
                 conversation: currentConversation,
                 terminalControl: currentControl,
                 action: "approve"
@@ -10730,7 +12339,7 @@ async function runTerminalConversationApprove({ options, conversationId, agent,
         releaseTerminalLock();
     }
 }
-async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, storeWriterLeaseHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false, onTerminalPreflightVerified = undefined, allowedPreMaterializationIdentity = undefined, allowedAdditionalIdentities = [], observedHandoff = undefined, verifiedEmptyCodexHandoff = undefined, continuingTurnResponse = false }) {
+async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, storeWriterLeaseHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false, onTerminalPreflightVerified = undefined, allowedPreMaterializationIdentity = undefined, allowedAdditionalIdentities = [], observedHandoff = undefined, verifiedEmptyCodexHandoff = undefined, deferredCodexForegroundBinding = undefined, continuingTurnResponse = false }) {
     const bridge = terminalBridgeEnabled(conversation);
     if (!terminalSendLockHeld) {
         const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
@@ -10754,6 +12363,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 allowedAdditionalIdentities,
                 observedHandoff,
                 verifiedEmptyCodexHandoff,
+                deferredCodexForegroundBinding,
                 continuingTurnResponse
             });
         }
@@ -10795,6 +12405,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 allowedAdditionalIdentities,
                 observedHandoff,
                 verifiedEmptyCodexHandoff,
+                deferredCodexForegroundBinding,
                 continuingTurnResponse
             });
         }
@@ -10823,6 +12434,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             allowedAdditionalIdentities,
             observedHandoff,
             verifiedEmptyCodexHandoff,
+            deferredCodexForegroundBinding,
             continuingTurnResponse
         }));
     }
@@ -10831,7 +12443,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES);
     const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ?? DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
     const terminalPayload = terminalSubmissionPayload(String(message.body ?? ""));
-    const terminalRequestHash = terminalBridgeRequestFingerprint(terminalPayload);
+    const terminalRequestHash = required(terminalBridgeRequestFingerprint(terminalPayload), "terminal request hash is unavailable");
     let previousDispatchLedger = resolveTerminalDispatchLedgerPaneIncarnation(terminalControl, loadTerminalBridgeDispatchLedger(terminalControl));
     previousDispatchLedger =
         reconcilePreparedTerminalDispatchLedger(terminalControl, previousDispatchLedger);
@@ -11004,12 +12616,12 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             scrollbackLines: Number(options.scrollbackLines ?? 120),
             runtime: preSendRuntime
         });
-        if (verifiedEmptyCodexHandoff) {
+        if (verifiedEmptyCodexHandoff || deferredCodexForegroundBinding) {
             if (executor.kind !== "codex" ||
                 status.reachable !== true ||
                 status.approval_state.blocked === true ||
                 !["idle", "unknown"].includes(status.activity_state)) {
-                throw new Error(`Codex verified-empty handoff is not at a safe prompt ` +
+                throw new Error(`Codex deferred foreground send is not at a safe prompt ` +
                     `(${status.activity_state}: ${status.activity_reason})`);
             }
         }
@@ -11074,7 +12686,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     // acceptance check has passed, but before the Turn or dispatch ledger can
     // become durable. This prevents a failed virgin attach from leaving a
     // zero-identity `bound` Session that fences every later control action.
-    let rollbackPreTransportAttach = onTerminalPreflightVerified?.();
+    let rollbackPreTransportAttach = await onTerminalPreflightVerified?.();
     const rollbackRawAttachBeforeTransport = () => {
         if (!rollbackPreTransportAttach) {
             return true;
@@ -11094,6 +12706,39 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             return false;
         }
     };
+    const abortDeferredPreInputBeforeTransport = (terminalInputNotStartedAt) => {
+        if (!deferredCodexForegroundBinding) {
+            return false;
+        }
+        if (!terminalStateLockHeld) {
+            throw new Error("deferred Codex pre-input abort requires the exact Turn state lock");
+        }
+        const deferredStoreDir = storeDirFromOptions(options);
+        const transfer = loadDeferredForegroundTransfer(deferredStoreDir, deferredCodexForegroundBinding.transferId);
+        const durableTerminalInputNotStartedAt = terminalInputNotStartedAt === undefined || transfer.input_stage === "none"
+            ? undefined
+            : transfer.status === "dispatch_started" &&
+                transfer.input_stage === "dispatch_started"
+                ? terminalInputNotStartedAt
+                : (() => {
+                    throw new Error(`deferred foreground transfer ${transfer.transfer_id} has ` +
+                        `${transfer.input_stage} input evidence and cannot accept a ` +
+                        "terminal-input-not-started result");
+                })();
+        abortPreparedDeferredForegroundTurn({
+            storeDir: deferredStoreDir,
+            terminal: deferredCodexForegroundBinding.terminal,
+            transfer,
+            boundary: deferredCodexForegroundBinding,
+            stateLockHeld: true,
+            terminalInputNotStartedAt: durableTerminalInputNotStartedAt
+        });
+        // abortPreparedDeferredForegroundTurn has already made the Turn, ledger,
+        // transfer, and both Sessions durable in zero-input terminal states. Do
+        // not invoke the reservation rollback closure a second time.
+        rollbackPreTransportAttach = undefined;
+        return true;
+    };
     const bridgeConversation = bridge
         ? withTerminalBridgeState({
             conversation: nextConversation,
@@ -11139,11 +12784,13 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     }
     catch (error) {
         try {
-            restoreTerminalBridgeDispatchLedger({
-                terminalControl,
-                previousLedger: previousDispatchLedger,
-                reason: "prepared ledger persistence failed before terminal input"
-            });
+            if (!abortDeferredPreInputBeforeTransport()) {
+                restoreTerminalBridgeDispatchLedger({
+                    terminalControl,
+                    previousLedger: previousDispatchLedger,
+                    reason: "prepared ledger persistence failed before terminal input"
+                });
+            }
         }
         finally {
             rollbackRawAttachBeforeTransport();
@@ -11155,11 +12802,13 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     }
     catch (error) {
         try {
-            restoreTerminalBridgeDispatchLedger({
-                terminalControl,
-                previousLedger: previousDispatchLedger,
-                reason: "prepared state persistence failed before terminal input"
-            });
+            if (!abortDeferredPreInputBeforeTransport()) {
+                restoreTerminalBridgeDispatchLedger({
+                    terminalControl,
+                    previousLedger: previousDispatchLedger,
+                    reason: "prepared state persistence failed before terminal input"
+                });
+            }
         }
         finally {
             rollbackRawAttachBeforeTransport();
@@ -11220,11 +12869,13 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         const errorMessage = error instanceof Error ? error.message : String(error);
         let dispatchLedgerRestored = true;
         try {
-            restoreTerminalBridgeDispatchLedger({
-                terminalControl,
-                previousLedger: previousDispatchLedger,
-                reason: "terminal submission aborted before terminal input"
-            });
+            if (!abortDeferredPreInputBeforeTransport()) {
+                restoreTerminalBridgeDispatchLedger({
+                    terminalControl,
+                    previousLedger: previousDispatchLedger,
+                    reason: "terminal submission aborted before terminal input"
+                });
+            }
         }
         catch (ledgerError) {
             dispatchLedgerRestored = false;
@@ -11386,7 +13037,8 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         await terminalBridge.send(executor.kind, terminalControl, terminalPayload, {
             runtime: preSendRuntime,
             requireExactComposerBeforeEnter: observedHandoff !== undefined ||
-                verifiedEmptyCodexHandoff !== undefined,
+                verifiedEmptyCodexHandoff !== undefined ||
+                deferredCodexForegroundBinding !== undefined,
             beforeText: observedHandoff
                 ? async () => {
                     await assertObservedHandoffTransportBoundary({
@@ -11404,7 +13056,22 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                             requireEmptyComposer: true
                         });
                     }
-                    : undefined,
+                    : deferredCodexForegroundBinding
+                        ? async () => {
+                            await assertDeferredCodexForegroundBindingBoundary({
+                                options,
+                                boundary: deferredCodexForegroundBinding,
+                                expectedSourceStatus: "transitioning",
+                                requireNoDispatch: false,
+                                requireEmptyComposer: true
+                            });
+                            beginDeferredCodexForegroundTransferDispatch({
+                                options,
+                                boundary: deferredCodexForegroundBinding,
+                                at: cliNow().toISOString()
+                            });
+                        }
+                        : undefined,
             beforeEnter: observedHandoff
                 ? async () => {
                     await assertObservedHandoffTransportBoundary({
@@ -11422,7 +13089,17 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                             requireEmptyComposer: false
                         });
                     }
-                    : undefined,
+                    : deferredCodexForegroundBinding
+                        ? async () => {
+                            await assertDeferredCodexForegroundBindingBoundary({
+                                options,
+                                boundary: deferredCodexForegroundBinding,
+                                expectedSourceStatus: "transitioning",
+                                requireNoDispatch: false,
+                                requireEmptyComposer: false
+                            });
+                        }
+                        : undefined,
             async onTransportStage(event) {
                 const stageAt = cliNow().toISOString();
                 if (event.stage === "text_injected") {
@@ -11463,6 +13140,14 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     previous_generation_id: stringValue(previousDispatchLedger?.generation_id) ??
                         stringValue(previousDispatchLedger?.message_id)
                 });
+                if (deferredCodexForegroundBinding) {
+                    advanceDeferredCodexForegroundTransferInputStage({
+                        options,
+                        boundary: deferredCodexForegroundBinding,
+                        stage: event.stage,
+                        at: stageAt
+                    });
+                }
                 if (event.stage === "text_injected" && observedHandoff) {
                     await assertObservedHandoffTransportBoundary({
                         options,
@@ -11478,6 +13163,15 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                         requireEmptyComposer: false
                     });
                 }
+                if (event.stage === "text_injected" && deferredCodexForegroundBinding) {
+                    await assertDeferredCodexForegroundBindingBoundary({
+                        options,
+                        boundary: deferredCodexForegroundBinding,
+                        expectedSourceStatus: "transitioning",
+                        requireNoDispatch: false,
+                        requireEmptyComposer: false
+                    });
+                }
                 try {
                     appendEvent(logPath, {
                         ts: stageAt,
@@ -11507,6 +13201,11 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             let boundConversation;
             let bindingError;
             try {
+                if (deferredCodexForegroundBinding &&
+                    !allowsSyntheticTerminalAcceptance(options) &&
+                    codexRolloutAcceptanceAnchor?.version !== 2) {
+                    throw new Error("deferred Codex foreground binding requires a virgin rollout acceptance anchor");
+                }
                 boundIdentity = await pollNativeAgentSessionIdentity({
                     options,
                     executor,
@@ -11514,7 +13213,19 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     pid: terminalAgentPid,
                     expectedSessionId: stringValue(sendTakeover?.terminal_agent_expected_session_id),
                     allowedPreMaterializationIdentity,
-                    allowedAdditionalIdentities
+                    allowedAdditionalIdentities,
+                    ...(deferredCodexForegroundBinding &&
+                        codexRolloutAcceptanceAnchor?.version === 2
+                        ? {
+                            requiredCodexAcceptance: {
+                                anchor: codexRolloutAcceptanceAnchor,
+                                requestHash: terminalRequestHash
+                            },
+                            attempts: Math.max(1, Math.ceil(DEFAULT_TERMINAL_ACCEPTANCE_TIMEOUT_MS /
+                                DEFAULT_TERMINAL_ACCEPTANCE_POLL_INTERVAL_MS)),
+                            delayMs: DEFAULT_TERMINAL_ACCEPTANCE_POLL_INTERVAL_MS
+                        }
+                        : {})
                 });
             }
             catch (error) {
@@ -11541,20 +13252,30 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     if (!bindingStoreDir) {
                         throw new Error("managed Session Store is unavailable before native identity commit");
                     }
-                    await assertNativeThreadHasExclusiveOwnership({
-                        options,
-                        agent: executor.kind,
-                        currentPid: terminalAgentPid,
-                        nativeThreadId: boundIdentity.sessionId,
-                        storeDir: bindingStoreDir,
-                        terminalControl,
-                        excludedManagedSessionId: sessionIdForConversation(boundConversation)
-                    });
-                    persistManagedSessionNativeIdentity({
-                        conversation: boundConversation,
-                        terminalControl,
-                        identity: boundIdentity
-                    });
+                    if (deferredCodexForegroundBinding) {
+                        await commitDeferredCodexForegroundBinding({
+                            options,
+                            boundary: deferredCodexForegroundBinding,
+                            identity: boundIdentity,
+                            acceptedAt: cliNow().toISOString()
+                        });
+                    }
+                    else {
+                        await assertNativeThreadHasExclusiveOwnership({
+                            options,
+                            agent: executor.kind,
+                            currentPid: terminalAgentPid,
+                            nativeThreadId: boundIdentity.sessionId,
+                            storeDir: bindingStoreDir,
+                            terminalControl,
+                            excludedManagedSessionId: sessionIdForConversation(boundConversation)
+                        });
+                        persistManagedSessionNativeIdentity({
+                            conversation: boundConversation,
+                            terminalControl,
+                            identity: boundIdentity
+                        });
+                    }
                     if (codexRolloutAcceptanceAnchor?.version === 2 &&
                         cliEnv().AKK_TEST_EXIT_AFTER_VIRGIN_SESSION_BINDING === "1") {
                         cliExit(86);
@@ -11577,11 +13298,69 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     boundConversation = undefined;
                 }
             }
+            if (!boundIdentity && deferredCodexForegroundBinding) {
+                try {
+                    const transfer = loadDeferredForegroundTransfer(storeDirFromOptions(options), deferredCodexForegroundBinding.transferId);
+                    if (["committed", "resolved"].includes(transfer.status)) {
+                        const recoveredTarget = await resolveCommittedDeferredCodexForegroundTransfer({
+                            options,
+                            boundary: deferredCodexForegroundBinding
+                        });
+                        const binding = recoveredTarget.binding;
+                        if (!binding?.native_thread_id ||
+                            !binding.native_process.process_uuid ||
+                            !binding.native_process.process_birth ||
+                            !isCompleteNativeRollout(binding.native_process.rollout)) {
+                            throw new Error("resolved deferred target lacks exact native identity");
+                        }
+                        const recoveredIdentity = {
+                            sessionId: binding.native_thread_id,
+                            processUuid: binding.native_process.process_uuid,
+                            processBirth: binding.native_process.process_birth,
+                            rollout: binding.native_process.rollout,
+                            evidence: binding.native_process.evidence
+                        };
+                        const recoveredConversation = withNativeAgentSessionIdentity(stagedConversation, recoveredIdentity);
+                        // A committed transfer proves Session ownership, but it cannot
+                        // silently substitute for the Turn's exact staged binding.  Only
+                        // publish the recovered identity to the normal acceptance path
+                        // after the same Turn-vs-Session/native assertion used by the
+                        // primary commit path succeeds.
+                        assertNativeAgentIdentityForTurn({
+                            conversation: recoveredConversation,
+                            currentIdentity: recoveredIdentity,
+                            operation: "recover deferred foreground binding for"
+                        });
+                        boundIdentity = recoveredIdentity;
+                        boundConversation = recoveredConversation;
+                    }
+                }
+                catch (error) {
+                    bindingError = error instanceof Error ? error.message : String(error);
+                    boundIdentity = undefined;
+                    boundConversation = undefined;
+                }
+            }
             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
+                        });
+                    }
+                    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",
@@ -11610,10 +13389,12 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                     error: bindingReason,
                     lastProvenStage: "enter_dispatched"
                 });
-                quarantineManagedSessionBinding({
-                    conversation: unfencedConversation,
-                    reason: bindingReason
-                });
+                if (!deferredCodexForegroundBinding) {
+                    quarantineManagedSessionBinding({
+                        conversation: unfencedConversation,
+                        reason: bindingReason
+                    });
+                }
                 saveTerminalBridgeDispatchLedger(terminalControl, {
                     ...terminalBindingLedgerFields(unfencedConversation),
                     status: "uncertain",
@@ -11835,11 +13616,13 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             const errorMessage = error.message;
             let dispatchLedgerRestored = true;
             try {
-                restoreTerminalBridgeDispatchLedger({
-                    terminalControl,
-                    previousLedger: previousDispatchLedger,
-                    reason: "terminal transport was proved not to have started"
-                });
+                if (!abortDeferredPreInputBeforeTransport(abortedAt)) {
+                    restoreTerminalBridgeDispatchLedger({
+                        terminalControl,
+                        previousLedger: previousDispatchLedger,
+                        reason: "terminal transport was proved not to have started"
+                    });
+                }
             }
             catch (ledgerError) {
                 dispatchLedgerRestored = false;
@@ -11974,6 +13757,23 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         }
         const uncertainAt = cliNow().toISOString();
         const errorMessage = error instanceof Error ? error.message : String(error);
+        if (deferredCodexForegroundBinding) {
+            try {
+                markDeferredCodexForegroundTransferUncertain({
+                    options,
+                    boundary: deferredCodexForegroundBinding,
+                    reason: errorMessage
+                });
+            }
+            catch (transferError) {
+                runtimeLog("error", "deferred_codex_foreground_uncertain_persist_failed", {
+                    transfer_id: deferredCodexForegroundBinding.transferId,
+                    error: transferError instanceof Error
+                        ? transferError.message
+                        : String(transferError)
+                });
+            }
+        }
         const failureBase = stagedConversation;
         const stalledFailureBase = {
             ...failureBase,
@@ -13142,7 +14942,7 @@ function assertTurnBindingCurrent(conversation, operation) {
     // the Store writer lease. This makes the freshly materialized Session
     // authoritative even for the first callback/control after an upgrade.
     const manifest = ensureStoreWritable(storeDir);
-    if (manifest.writer_protocol !== 3) {
+    if (manifest.writer_protocol < STORE_SESSION_AUTHORITY_PROTOCOL) {
         throw new Error(`cannot ${operation} Turn ${turnIdForConversation(conversation)}: ` +
             "its Store has no protocol-3 Session authority");
     }
@@ -13385,7 +15185,7 @@ function quarantineManagedSessionBinding({ conversation, reason }) {
         expectedRevision: managedSessionRevision(current)
     });
 }
-async function pollNativeAgentSessionIdentity({ options, executor, terminalControl, pid, expectedSessionId, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], attempts = 40, delayMs = 50 }) {
+async function pollNativeAgentSessionIdentity({ options, executor, terminalControl, pid, expectedSessionId, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], requiredCodexAcceptance, attempts = 40, delayMs = 50 }) {
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         const identity = await resolveCurrentNativeAgentSessionIdentity({
             options,
@@ -13400,6 +15200,19 @@ async function pollNativeAgentSessionIdentity({ options, executor, terminalContr
         });
         if (identity) {
             if (!expectedSessionId || identity.sessionId === expectedSessionId) {
+                if (requiredCodexAcceptance) {
+                    const acceptance = detectCodexRolloutAcceptance({
+                        anchor: requiredCodexAcceptance.anchor,
+                        currentIdentity: identity,
+                        requestHash: requiredCodexAcceptance.requestHash
+                    });
+                    if (!acceptance) {
+                        if (attempt + 1 < attempts) {
+                            await cliSleep(delayMs);
+                        }
+                        continue;
+                    }
+                }
                 return identity;
             }
             if (nativeIdentityMatchesCodexPreMaterialization(identity, allowedPreMaterializationIdentity)) {
@@ -13486,7 +15299,7 @@ function managedTurnMatchesResolvedTerminal(conversation, terminalConversation,
         terminalControlsShareIncarnation(storedControl, terminalConversation.terminalControl) &&
         matchesConfiguredWorkspace(conversation.workspace, terminalConversation.terminalControl.currentPath));
 }
-function createManagedTerminalTurn({ options, conversationId, agent, pid, messageBody, terminalControl, previousTurn, managedSession, nativeAgentIdentity }) {
+function createManagedTerminalTurn({ options, conversationId, agent, pid, messageBody, terminalControl, previousTurn, managedSession, nativeAgentIdentity, deferredForegroundTransferId = undefined }) {
     const workspace = terminalControl.currentPath ?? cliCwd();
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(workspace));
     const executor = previousTurn
@@ -13554,7 +15367,10 @@ function createManagedTerminalTurn({ options, conversationId, agent, pid, messag
                 : "raw_terminal_send",
             ...terminalEndpointTakeoverFields(terminalControl),
             needs_bootstrap: false,
-            terminal_bridge: true
+            terminal_bridge: true,
+            ...(deferredForegroundTransferId
+                ? { deferred_foreground_transfer_id: deferredForegroundTransferId }
+                : {})
         }
     }, paths);
     const message = createMessage({
@@ -13750,14 +15566,23 @@ async function runReconcileMonitors(options) {
 }
 async function reconcileMonitors(options, { includeCallbackRecovery, reason, conversationId }) {
     const storeDir = storeDirFromOptions(options);
+    const collateralStalls = await withStoreWriterLeaseAsync(storeDir, async () => reconcileTerminalBridgeCollateralStalls(storeDir, conversationId));
     const conversations = listConversations(storeDir).filter((conversation) => conversationId === undefined || conversation.conversation_id === conversationId);
-    const items = [];
+    const items = [...collateralStalls.items];
+    const repairedConversationIds = new Set(collateralStalls.items
+        .filter((item) => item.status === "repaired")
+        .map((item) => stringValue(item.conversation_id))
+        .filter((id) => id !== undefined));
     let ignored = 0;
     let launched = 0;
     let alreadyRunning = 0;
     let skipped = 0;
-    let errors = 0;
+    let errors = collateralStalls.errors.length;
     for (const listedConversation of conversations) {
+        if (repairedConversationIds.has(listedConversation.conversation_id)) {
+            ignored += 1;
+            continue;
+        }
         if (!matchesConfiguredWorkspace(options.workspace, listedConversation.workspace)) {
             ignored += 1;
             continue;
@@ -13991,6 +15816,9 @@ async function reconcileMonitors(options, { includeCallbackRecovery, reason, con
         reconciled: true,
         store_dir: storeDir,
         checked: conversations.length,
+        repaired: collateralStalls.repaired,
+        collateral_stalls_checked: collateralStalls.checked,
+        collateral_stalls_skipped: collateralStalls.skipped,
         ignored,
         launched,
         already_running: alreadyRunning,
@@ -14381,6 +16209,7 @@ async function runTerminalControlCancel({ options, statePath, logPath, agent, te
                 throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
             }
             assertManagedTerminalDispatchOwner({
+                storeDir: writerStoreDir,
                 conversation: currentConversation,
                 terminalControl: currentControl,
                 action: "cancel"
@@ -14457,7 +16286,7 @@ async function runObservedHandoffClose({ options, statePath, logPath, initialCon
     if (stringValue(options.reason) !== "superseded_by_human_context_switch") {
         throw new Error("a handoff close requires reason superseded_by_human_context_switch");
     }
-    const storeDir = storeDirFromOptions(options);
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     const sourceSessionId = sessionIdForConversation(initialConversation);
     const initialSource = loadManagedSession(storeDir, sourceSessionId);
     if (!initialSource.binding || initialSource.status !== "bound") {
@@ -14643,88 +16472,183 @@ async function runClose(options) {
         });
         return;
     }
+    if (stringValue(options.reason) === "superseded_by_human_context_switch") {
+        throw new Error("reason superseded_by_human_context_switch requires the fresh " +
+            "expected_handoff_token advertised by AKK list");
+    }
     const { statePath, logPath } = loaded;
+    const closeStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     const nativeTakeover = isRecord(loaded.conversation.native_session_takeover)
         ? loaded.conversation.native_session_takeover
         : undefined;
     const terminalControl = terminalControlFromTakeover(nativeTakeover);
     const releaseTerminalLock = terminalControl
-        ? acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 })
+        ? acquireTerminalBridgeSendLock(closeStoreDir, terminalControl, { timeoutMs: 30000 })
         : () => { };
-    let releaseStateLock;
-    try {
-        releaseStateLock = acquireFileLock(`${statePath}.lock`);
-        const conversation = loadState(statePath);
-        const now = cliNow().toISOString();
-        const closeReason = options.reason ?? "closed by request";
-        const handoffDisposition = closeReason === "superseded_by_human_context_switch"
-            ? closeReason
-            : undefined;
-        const closed = {
-            ...conversation,
-            status: "closed",
-            closed_at: now,
-            close_reason: closeReason,
-            ...(handoffDisposition
-                ? { disposition: handoffDisposition }
-                : {}),
-            updated_at: now
-        };
-        saveState(statePath, closed);
-        let dispatchLedgerResolved = false;
-        let dispatchLedgerWarning;
-        if (terminalControl) {
-            try {
-                dispatchLedgerResolved = resolveTerminalBridgeDispatchLedger({
-                    terminalControl,
-                    conversation: closed,
-                    expectedMessageId: stringValue(nativeTakeover?.terminal_bridge_message_id),
-                    reason: "conversation explicitly closed by request"
-                });
+    const closeWithFreshState = async () => {
+        const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const conversation = loadState(statePath);
+            assertConversationHasNoNonterminalDeferredForegroundTransfer({
+                storeDir: closeStoreDir,
+                conversation,
+                action: "close"
+            });
+            const currentTakeover = isRecord(conversation.native_session_takeover)
+                ? conversation.native_session_takeover
+                : undefined;
+            const currentTerminalControl = terminalControlFromTakeover(currentTakeover);
+            if (terminalControl &&
+                !terminalControlsShareIncarnation(currentTerminalControl, terminalControl)) {
+                throw new Error("terminal control changed after the close action was listed; refresh AKK list");
             }
-            catch (error) {
-                dispatchLedgerWarning =
-                    error instanceof Error ? error.message : String(error);
-                runtimeLog("error", "terminal_dispatch_ledger_resolve_failed", {
-                    conversation_id: closed.conversation_id,
-                    terminal_target: terminalControl.target,
-                    error: dispatchLedgerWarning
+            if (terminalControl && currentTerminalControl) {
+                await assertGenericCloseDoesNotBypassObservedHandoff({
+                    options,
+                    storeDir: closeStoreDir,
+                    conversation,
+                    terminalControl: currentTerminalControl
                 });
             }
-        }
-        appendEvent(logPath, {
-            ts: now,
-            conversation_id: conversation.conversation_id,
-            event: "conversation_closed",
-            status: "closed",
-            reason: closed.close_reason
-        });
-        runtimeLog("info", "conversation_closed", {
-            conversation_id: conversation.conversation_id,
-            status: "closed",
-            reason: closed.close_reason,
-            state_path: statePath,
-            event_log_path: logPath
-        });
-        printJson({
-            conversation: closed,
-            closed: true,
-            terminal_dispatch_resolved: dispatchLedgerResolved,
-            ...(dispatchLedgerWarning
-                ? {
-                    terminal_dispatch_warning: textSummary(dispatchLedgerWarning),
-                    do_not_retry: true
+            const now = cliNow().toISOString();
+            const closeReason = options.reason ?? "closed by request";
+            const closed = {
+                ...conversation,
+                status: "closed",
+                closed_at: now,
+                close_reason: closeReason,
+                updated_at: now
+            };
+            saveState(statePath, closed);
+            let dispatchLedgerResolved = false;
+            let dispatchLedgerWarning;
+            if (currentTerminalControl) {
+                try {
+                    dispatchLedgerResolved = resolveTerminalBridgeDispatchLedger({
+                        terminalControl: currentTerminalControl,
+                        conversation: closed,
+                        expectedMessageId: stringValue(currentTakeover?.terminal_bridge_message_id),
+                        reason: "conversation explicitly closed by request"
+                    });
                 }
-                : {})
-        });
-    }
-    finally {
-        try {
-            releaseStateLock?.();
+                catch (error) {
+                    dispatchLedgerWarning =
+                        error instanceof Error ? error.message : String(error);
+                    runtimeLog("error", "terminal_dispatch_ledger_resolve_failed", {
+                        conversation_id: closed.conversation_id,
+                        terminal_target: currentTerminalControl.target,
+                        error: dispatchLedgerWarning
+                    });
+                }
+            }
+            appendEvent(logPath, {
+                ts: now,
+                conversation_id: conversation.conversation_id,
+                event: "conversation_closed",
+                status: "closed",
+                reason: closed.close_reason
+            });
+            runtimeLog("info", "conversation_closed", {
+                conversation_id: conversation.conversation_id,
+                status: "closed",
+                reason: closed.close_reason,
+                state_path: statePath,
+                event_log_path: logPath
+            });
+            printJson({
+                conversation: closed,
+                closed: true,
+                terminal_dispatch_resolved: dispatchLedgerResolved,
+                ...(dispatchLedgerWarning
+                    ? {
+                        terminal_dispatch_warning: textSummary(dispatchLedgerWarning),
+                        do_not_retry: true
+                    }
+                    : {})
+            });
         }
         finally {
-            releaseTerminalLock();
+            releaseStateLock();
+        }
+    };
+    try {
+        if (terminalControl) {
+            await withStoreWriterLeaseAsync(closeStoreDir, closeWithFreshState);
+        }
+        else {
+            await closeWithFreshState();
+        }
+    }
+    finally {
+        releaseTerminalLock();
+    }
+}
+async function assertGenericCloseDoesNotBypassObservedHandoff({ options, storeDir, conversation, terminalControl }) {
+    if (!SESSION_SEND_BLOCKING_STATUSES.has(conversation.status)) {
+        return;
+    }
+    const sourceSession = tryLoadManagedSession(storeDir, sessionIdForConversation(conversation));
+    if (sourceSession?.status !== "bound" ||
+        !sourceSession.binding ||
+        !terminalControlsShareIncarnation(sourceSession.binding.terminal_control, terminalControl)) {
+        return;
+    }
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const pid = Number(takeover?.terminal_agent_pid);
+    if (!Number.isSafeInteger(pid) || pid <= 1) {
+        return;
+    }
+    const bridge = createTerminalAgentBridge(options);
+    let terminal;
+    try {
+        terminal = await bridge.resolveStoredTerminal(sourceSession.agent, pid, terminalControl, { pid });
+    }
+    catch (error) {
+        if (!(error instanceof TerminalControlUnavailableError)) {
+            throw error;
         }
+        // An unavailable terminal cannot prove a live A -> B handoff. Preserve the
+        // explicit Store-only close path used to retire unavailable Turn history.
+        return;
+    }
+    const companions = sourceSession.agent === "codex"
+        ? codexAllowedCompanionSetForManagedSession({
+            storeDir,
+            session: sourceSession
+        })
+        : { additional: [] };
+    const identityObservation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: terminal.agent,
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath,
+        preferredSessionId: companions.primary
+            ? sourceSession.binding.native_thread_id
+            : undefined,
+        allowedCompanionIdentity: companions.primary,
+        allowedAdditionalIdentities: companions.additional
+    });
+    const resolvedIdentity = identityObservation.status === "resolved"
+        ? identityObservation.identity
+        : undefined;
+    const observed = await observedExternalHandoffIdentity({
+        options,
+        terminal,
+        sourceSession,
+        resolvedIdentity,
+        requireSafeTerminal: false
+    });
+    if (managedBindingConflictKindForResolvedTerminal({
+        storeDir,
+        session: sourceSession,
+        terminal,
+        identity: observed.identity
+    }) === "live_external_thread_change") {
+        throw new Error(`terminal ${terminalControl.target} changed native thread after the ` +
+            "generic close action was listed; refresh AKK list and use only its " +
+            "fresh snapshot-bound handoff_decision");
     }
 }
 async function runTerminalDispatchClose({ options, terminalConversation }) {
@@ -14737,6 +16661,30 @@ async function runTerminalDispatchClose({ options, terminalConversation }) {
             if (!ledger || ledger.status === "resolved") {
                 throw new Error(`terminal ${terminalControl.target} has no unresolved AKK dispatch fence`);
             }
+            const deferredTransferId = stringValue(ledger.deferred_foreground_transfer_id);
+            if (deferredTransferId) {
+                const ledgerStatePath = path.resolve(required(stringValue(ledger.state_path), "deferred terminal dispatch state path is unavailable"));
+                const ledgerStoreDir = path.resolve(required(stringValue(ledger.store_dir), "deferred terminal dispatch Store is unavailable"));
+                const canonicalLedgerStoreDir = path.resolve(pathsForConversationDir(path.dirname(ledgerStatePath)).storeDir);
+                if (ledgerStoreDir !== path.resolve(storeDir) ||
+                    canonicalLedgerStoreDir !== ledgerStoreDir) {
+                    throw new Error(`terminal ${terminalControl.target} deferred dispatch belongs to ` +
+                        "another or noncanonical Store; generic terminal close cannot resolve it");
+                }
+                const transfer = loadDeferredForegroundTransfer(storeDir, deferredTransferId);
+                if (transfer.state_path === undefined ||
+                    path.resolve(transfer.state_path) !== ledgerStatePath ||
+                    transfer.terminal_id !== terminalConversation.conversationId ||
+                    !terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl)) {
+                    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)) {
+                    throw new Error(`terminal ${terminalControl.target} dispatch is fenced by deferred ` +
+                        `foreground transfer ${transfer.transfer_id} (${transfer.status}); ` +
+                        "generic terminal close cannot resolve it");
+                }
+            }
             if (![
                 "prepared",
                 "text_injected",
@@ -17095,7 +19043,12 @@ function loadTerminalDispatchLedgerOwner(ledger) {
         return undefined;
     }
 }
-function assertManagedTerminalDispatchOwner({ conversation, terminalControl, action }) {
+function assertManagedTerminalDispatchOwner({ storeDir, conversation, terminalControl, action }) {
+    assertConversationHasNoNonterminalDeferredForegroundTransfer({
+        storeDir,
+        conversation,
+        action
+    });
     assertTurnBindingCurrent(conversation, action);
     const nativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
@@ -17133,6 +19086,7 @@ function terminalBindingLedgerFields(conversation) {
     const submission = terminalBridgeSubmission(conversation);
     const messageType = stringValue(submission?.message_type);
     const messageBodyHash = stringValue(submission?.message_body_hash);
+    const deferredForegroundTransferId = stringValue(takeover?.deferred_foreground_transfer_id);
     return {
         ...(bindingId ? { binding_id: bindingId } : {}),
         ...(Number.isSafeInteger(generation)
@@ -17142,12 +19096,30 @@ function terminalBindingLedgerFields(conversation) {
         ...(storeDir ? { store_dir: path.resolve(storeDir) } : {}),
         ...(messageType ? { message_type: messageType } : {}),
         ...(messageBodyHash ? { message_body_hash: messageBodyHash } : {}),
+        ...(deferredForegroundTransferId
+            ? { deferred_foreground_transfer_id: deferredForegroundTransferId }
+            : {}),
         executor_kind: executorForConversation(conversation).kind,
         ...(conversation.openclaw_session
             ? { openclaw_session: conversation.openclaw_session }
             : {})
     };
 }
+function assertConversationHasNoNonterminalDeferredForegroundTransfer({ storeDir, conversation, action }) {
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const transferId = stringValue(takeover?.deferred_foreground_transfer_id);
+    if (!transferId) {
+        return;
+    }
+    const transfer = loadDeferredForegroundTransfer(storeDir, transferId);
+    if (!["resolved", "aborted", "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 reconcilePreparedTerminalDispatchLedger(terminalControl, ledger) {
     if (terminalDispatchLedgerLooksLifecycle(ledger)) {
         return ledger;
@@ -17341,161 +19313,1140 @@ function reconcileLaggingTerminalDispatchLedger(terminalControl, ledger) {
             String(ledger[key]) !== String(bindingFields[key])) {
             return ledger;
         }
-    }
-    const stateStatus = String(submission?.status ?? "");
-    let stateAcceptanceEvidence;
-    if (stateStatus === "agent_accepted") {
-        try {
-            stateAcceptanceEvidence = terminalAcceptanceEvidenceForConversation(conversation, requestText, submission?.acceptance_evidence);
+    }
+    const stateStatus = String(submission?.status ?? "");
+    let stateAcceptanceEvidence;
+    if (stateStatus === "agent_accepted") {
+        try {
+            stateAcceptanceEvidence = terminalAcceptanceEvidenceForConversation(conversation, requestText, submission?.acceptance_evidence);
+        }
+        catch {
+            stateAcceptanceEvidence = undefined;
+        }
+    }
+    let ledgerAcceptanceEvidence;
+    let ledgerAcceptanceError;
+    if (ledger.status === "agent_accepted") {
+        try {
+            ledgerAcceptanceEvidence = terminalAcceptanceEvidenceForConversation(conversation, requestText, ledger.acceptance_evidence);
+        }
+        catch (error) {
+            ledgerAcceptanceError = error instanceof Error
+                ? error.message
+                : String(error);
+        }
+    }
+    if (ledgerAcceptanceEvidence) {
+        if (!stateAcceptanceEvidence) {
+            const acceptedAt = stringValue(ledger.agent_accepted_at) ?? cliNow().toISOString();
+            const acceptedConversation = withTerminalBridgeSubmission({
+                conversation,
+                messageId,
+                requestText,
+                status: "agent_accepted",
+                preparedAt: stringValue(submission?.prepared_at) ??
+                    stringValue(ledger.prepared_at) ??
+                    acceptedAt,
+                textInjectedAt: stringValue(submission?.text_injected_at) ??
+                    stringValue(ledger.text_injected_at),
+                enterDispatchedAt: stringValue(submission?.enter_dispatched_at) ??
+                    stringValue(ledger.enter_dispatched_at),
+                agentAcceptedAt: acceptedAt,
+                acceptanceEvidence: ledgerAcceptanceEvidence
+            });
+            saveState(statePath, acceptedConversation);
+        }
+        return ledger;
+    }
+    if (stateAcceptanceEvidence) {
+        const acceptedAt = stringValue(submission?.agent_accepted_at) ?? cliNow().toISOString();
+        saveTerminalBridgeDispatchLedger(terminalControl, {
+            ...ledger,
+            ...bindingFields,
+            status: "agent_accepted",
+            text_injected_at: submission?.text_injected_at,
+            enter_dispatched_at: submission?.enter_dispatched_at,
+            agent_accepted_at: acceptedAt,
+            acceptance_evidence: stateAcceptanceEvidence,
+            dispatcher_pid: null,
+            reason: "recovered the strongest durable native acceptance receipt"
+        });
+        return loadTerminalBridgeDispatchLedger(terminalControl);
+    }
+    if (ledger.status === "agent_accepted") {
+        const uncertainAt = cliNow().toISOString();
+        const uncertainConversation = withTerminalBridgeSubmission({
+            conversation: {
+                ...conversation,
+                status: "stalled",
+                stalled_at: uncertainAt,
+                stalled_reason: "stored native acceptance evidence is invalid",
+                updated_at: uncertainAt
+            },
+            messageId,
+            requestText,
+            status: "uncertain",
+            preparedAt: stringValue(submission?.prepared_at) ??
+                stringValue(ledger.prepared_at) ??
+                uncertainAt,
+            textInjectedAt: stringValue(submission?.text_injected_at) ??
+                stringValue(ledger.text_injected_at),
+            enterDispatchedAt: stringValue(submission?.enter_dispatched_at) ??
+                stringValue(ledger.enter_dispatched_at),
+            uncertainAt,
+            error: ledgerAcceptanceError ??
+                "stored native acceptance evidence is invalid",
+            lastProvenStage: "enter_dispatched"
+        });
+        saveState(statePath, uncertainConversation);
+        saveTerminalBridgeDispatchLedger(terminalControl, {
+            ...ledger,
+            ...bindingFields,
+            status: "uncertain",
+            uncertain_at: uncertainAt,
+            dispatcher_pid: null,
+            reason: "stored native acceptance evidence is invalid"
+        });
+        return loadTerminalBridgeDispatchLedger(terminalControl);
+    }
+    const stateRank = terminalSubmissionProofRank(stateStatus, stringValue(submission?.last_proven_stage));
+    const ledgerRank = terminalSubmissionProofRank(String(ledger.status), stringValue(ledger.last_proven_stage));
+    const stateIsTerminal = ["not_accepted", "uncertain", "aborted"]
+        .includes(stateStatus);
+    if (!stateIsTerminal && stateRank <= ledgerRank) {
+        return ledger;
+    }
+    if (![
+        "text_injected",
+        "enter_dispatched",
+        "submitted",
+        "not_accepted",
+        "uncertain",
+        "aborted"
+    ].includes(stateStatus)) {
+        return ledger;
+    }
+    saveTerminalBridgeDispatchLedger(terminalControl, {
+        ...ledger,
+        ...bindingFields,
+        status: stateStatus,
+        ...(submission?.text_injected_at
+            ? { text_injected_at: submission.text_injected_at }
+            : {}),
+        ...(submission?.enter_dispatched_at
+            ? { enter_dispatched_at: submission.enter_dispatched_at }
+            : {}),
+        ...(submission?.submitted_at
+            ? { submitted_at: submission.submitted_at }
+            : {}),
+        ...(submission?.not_accepted_at
+            ? { not_accepted_at: submission.not_accepted_at }
+            : {}),
+        ...(submission?.uncertain_at
+            ? { uncertain_at: submission.uncertain_at }
+            : {}),
+        ...(submission?.aborted_at
+            ? { aborted_at: submission.aborted_at }
+            : {}),
+        last_proven_stage: submission?.last_proven_stage,
+        ...(stateIsTerminal ? { dispatcher_pid: null } : {}),
+        reason: "recovered the strongest durable conversation proof level"
+    });
+    return loadTerminalBridgeDispatchLedger(terminalControl);
+}
+function terminalSubmissionProofRank(status, lastProven) {
+    if (status === "agent_accepted" || lastProven === "agent_accepted") {
+        return 3;
+    }
+    if (["enter_dispatched", "submitted", "not_accepted"].includes(status) ||
+        lastProven === "enter_dispatched") {
+        return 2;
+    }
+    if (status === "text_injected" || lastProven === "text_injected") {
+        return 1;
+    }
+    return 0;
+}
+function deferredCodexBoundaryFromTransfer({ terminal, transfer }) {
+    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    if (terminal.agent !== "codex" ||
+        transfer.terminal_id !== terminal.conversationId ||
+        transfer.process_pid !== terminal.pid ||
+        transfer.process_uuid !== liveIncarnation.processUuid ||
+        transfer.process_birth !== liveIncarnation.processBirth ||
+        path.resolve(transfer.workspace) !== path.resolve(terminal.terminalControl.currentPath ?? "") ||
+        !terminalControlEvidenceMatches(transfer.terminal_endpoint, terminal.terminalControl)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} no longer ` +
+            "matches the exact terminal incarnation");
+    }
+    return {
+        terminal,
+        transferId: transfer.transfer_id,
+        targetSessionId: transfer.target_session_id,
+        sourceSessionId: transfer.source_session_id,
+        sourceBoundRevision: transfer.source_expected_revision,
+        sourceBoundBindingToken: transfer.source_binding_token,
+        processUuid: transfer.process_uuid,
+        processBirth: transfer.process_birth,
+        previousDispatchSnapshot: {
+            status: transfer.previous_dispatch_status,
+            fingerprint: transfer.previous_dispatch_fingerprint
+        },
+        sourceReservedRevision: transfer.source_expected_revision + 1,
+        sourceReservedBindingToken: managedSessionBindingToken({
+            session_id: transfer.source_session_id,
+            status: "transitioning",
+            binding: transfer.source_before_binding
+        }),
+        targetPreparedRevision: transfer.target_prepared_revision,
+        targetPreparedBindingToken: transfer.target_prepared_binding_token
+    };
+}
+function loadDeferredForegroundTurnAuthority({ storeDir, terminal, transfer }) {
+    const statePath = path.resolve(required(transfer.state_path, "deferred foreground Turn state path is unavailable"));
+    const canonical = pathsForConversationDir(path.dirname(statePath));
+    if (path.resolve(canonical.storeDir) !== path.resolve(storeDir) ||
+        path.resolve(canonical.statePath) !== statePath) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has a noncanonical ` +
+            "Turn state path");
+    }
+    const conversation = loadState(statePath);
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const submission = terminalBridgeSubmission(conversation);
+    const terminalControl = terminalControlFromTakeover(takeover);
+    const anchor = takeover?.codex_rollout_acceptance_anchor;
+    const target = loadManagedSession(storeDir, transfer.target_session_id);
+    const targetBefore = transfer.target_before_binding;
+    const requestText = stringValue(takeover?.terminal_bridge_request_text);
+    const messageBodyHash = stringValue(submission?.message_body_hash);
+    const executorKind = executorForConversation(conversation).kind;
+    const turnNativeThreadId = stringValue(conversation.native_thread_id);
+    const takeoverNativeThreadId = stringValue(takeover?.terminal_agent_session_id);
+    const submissionNativeThreadId = stringValue(submission?.native_thread_id);
+    const turnRollout = takeover?.terminal_agent_rollout;
+    const committedTargetAuthority = Boolean(["committed", "resolved"].includes(transfer.status) &&
+        transfer.target_accepted_binding &&
+        ((target.status === "transitioning" &&
+            target.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(target) === transfer.target_accepted_revision &&
+            managedSessionBindingToken(target) ===
+                transfer.target_accepted_binding_token) ||
+            (target.status === "bound" &&
+                !target.last_transition_id &&
+                managedSessionRevision(target) ===
+                    Number(transfer.target_accepted_revision) + 1 &&
+                managedSessionBindingToken(target) === managedSessionBindingToken({
+                    session_id: transfer.target_session_id,
+                    status: "bound",
+                    binding: transfer.target_accepted_binding
+                }))) &&
+        JSON.stringify(target.binding) ===
+            JSON.stringify(transfer.target_accepted_binding));
+    const precommitTargetAuthority = Boolean(!["committed", "resolved"].includes(transfer.status) &&
+        target.status === "transitioning" &&
+        target.last_transition_id === transfer.transfer_id);
+    const prebindingTurn = turnNativeThreadId === undefined &&
+        takeoverNativeThreadId === undefined &&
+        submissionNativeThreadId === undefined &&
+        turnRollout === undefined;
+    let acceptedTurn = false;
+    if (turnNativeThreadId &&
+        takeoverNativeThreadId === turnNativeThreadId &&
+        submissionNativeThreadId === turnNativeThreadId &&
+        isCompleteNativeRollout(turnRollout) &&
+        String(submission?.status) === "agent_accepted") {
+        try {
+            validateTerminalSubmissionAcceptanceEvidence(submission?.acceptance_evidence, {
+                source: "codex_rollout",
+                nativeThreadId: turnNativeThreadId,
+                requestHash: transfer.request_hash
+            });
+            acceptedTurn = true;
+        }
+        catch {
+            acceptedTurn = false;
+        }
+    }
+    if (!takeover ||
+        !submission ||
+        !terminalControl ||
+        !targetBefore ||
+        !terminalControlsShareIncarnation(terminalControl, terminal.terminalControl) ||
+        !terminalControlEvidenceMatches(takeover.terminal_endpoint ?? terminalControl, terminal.terminalControl) ||
+        executorKind !== "codex" ||
+        conversation.conversation_id !== transfer.turn_id ||
+        sessionIdForConversation(conversation) !== transfer.target_session_id ||
+        turnIdForConversation(conversation) !== transfer.turn_id ||
+        path.resolve(required(stringValue(conversation.state_path), "deferred foreground Turn state path is missing")) !== statePath ||
+        path.resolve(pathsForConversation(conversation.conversation_id, storeDir).statePath) !== statePath ||
+        path.resolve(required(managedSessionStoreDirForConversation(conversation), "deferred foreground Turn Store is missing")) !== path.resolve(storeDir) ||
+        stringValue(takeover.deferred_foreground_transfer_id) !==
+            transfer.transfer_id ||
+        stringValue(takeover.terminal_bridge_message_id) !== transfer.message_id ||
+        stringValue(submission.session_id) !== transfer.target_session_id ||
+        stringValue(submission.turn_id) !== transfer.turn_id ||
+        stringValue(submission.message_id) !== transfer.message_id ||
+        stringValue(submission.message_type) !== "task" ||
+        stringValue(submission.executor_kind) !== "codex" ||
+        !messageBodyHash ||
+        !/^[0-9a-f]{64}$/u.test(messageBodyHash) ||
+        createHash("sha256").update(String(conversation.user_request)).digest("hex") !==
+            messageBodyHash ||
+        terminalBridgeRequestFingerprint(terminalSubmissionPayload(String(conversation.user_request))) !== transfer.request_hash ||
+        stringValue(takeover.terminal_bridge_request_hash) !==
+            transfer.request_hash ||
+        stringValue(submission.request_hash) !== transfer.request_hash ||
+        !requestText ||
+        terminalBridgeRequestFingerprint(requestText) !== transfer.request_hash ||
+        path.resolve(required(stringValue(submission.store_dir), "deferred foreground submission Store is missing")) !== path.resolve(storeDir) ||
+        stringValue(conversation.terminal_binding_id) !== targetBefore.binding_id ||
+        Number(conversation.terminal_binding_generation) !==
+            targetBefore.generation ||
+        stringValue(takeover.terminal_binding_id) !== targetBefore.binding_id ||
+        Number(takeover.terminal_binding_generation) !== targetBefore.generation ||
+        stringValue(submission.binding_id) !== targetBefore.binding_id ||
+        Number(submission.binding_generation) !== targetBefore.generation ||
+        (!prebindingTurn && !acceptedTurn) ||
+        stringValue(takeover.terminal_agent_expected_session_id) !== undefined ||
+        Number(takeover.terminal_agent_pid) !== transfer.process_pid ||
+        stringValue(takeover.terminal_agent_process_uuid) !==
+            transfer.process_uuid ||
+        stringValue(takeover.terminal_agent_process_birth) !==
+            transfer.process_birth ||
+        target.session_id !== transfer.target_session_id ||
+        (!precommitTargetAuthority && !committedTargetAuthority) ||
+        target.lineage.transition_id !== transfer.transfer_id ||
+        target.lineage.previous_session_id !== transfer.source_session_id ||
+        !target.binding ||
+        target.binding.binding_id !== targetBefore.binding_id ||
+        target.binding.generation !== targetBefore.generation ||
+        target.binding.terminal_id !== targetBefore.terminal_id ||
+        !terminalControlsShareIncarnation(target.binding.terminal_control, targetBefore.terminal_control) ||
+        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)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} Turn authority ` +
+            "does not match its exact request/terminal/process fence");
+    }
+    return {
+        conversation,
+        statePath,
+        logPath: canonical.logPath,
+        takeover,
+        submission,
+        anchor: anchor
+    };
+}
+function assertDeferredForegroundLedgerAuthority({ storeDir, terminal, transfer, ledger, statePath, expectedMessageBodyHash }) {
+    const targetBefore = transfer.target_before_binding;
+    const ledgerMessageBodyHash = stringValue(ledger.message_body_hash);
+    let exactCommittedAcceptance = false;
+    if (["committed", "resolved"].includes(transfer.status) &&
+        ledger.status === "agent_accepted" &&
+        stringValue(ledger.native_thread_id) === transfer.target_native_thread_id &&
+        ledger.dispatcher_pid === null &&
+        stringValue(ledger.agent_accepted_at) === transfer.agent_accepted_at &&
+        transfer.target_native_thread_id) {
+        try {
+            validateTerminalSubmissionAcceptanceEvidence(ledger.acceptance_evidence, {
+                source: "codex_rollout",
+                nativeThreadId: transfer.target_native_thread_id,
+                requestHash: transfer.request_hash
+            });
+            exactCommittedAcceptance = true;
+        }
+        catch {
+            exactCommittedAcceptance = false;
+        }
+    }
+    if (!targetBefore ||
+        terminalDispatchLedgerLooksLifecycle(ledger) ||
+        !terminalDispatchRecordMatchesControl(ledger, terminal.terminalControl) ||
+        stringValue(ledger.deferred_foreground_transfer_id) !==
+            transfer.transfer_id ||
+        stringValue(ledger.generation_id) !== transfer.message_id ||
+        stringValue(ledger.conversation_id) !== transfer.turn_id ||
+        stringValue(ledger.session_id) !== transfer.target_session_id ||
+        stringValue(ledger.turn_id) !== transfer.turn_id ||
+        stringValue(ledger.message_id) !== transfer.message_id ||
+        stringValue(ledger.message_type) !== "task" ||
+        stringValue(ledger.executor_kind) !== "codex" ||
+        !ledgerMessageBodyHash ||
+        !/^[0-9a-f]{64}$/u.test(ledgerMessageBodyHash) ||
+        (expectedMessageBodyHash !== undefined &&
+            ledgerMessageBodyHash !== expectedMessageBodyHash) ||
+        stringValue(ledger.request_hash) !== transfer.request_hash ||
+        stringValue(ledger.binding_id) !== targetBefore.binding_id ||
+        Number(ledger.binding_generation) !== targetBefore.generation ||
+        (exactCommittedAcceptance
+            ? stringValue(ledger.native_thread_id) !==
+                transfer.target_native_thread_id
+            : stringValue(ledger.native_thread_id) !== undefined) ||
+        path.resolve(required(ledger.state_path, "dispatch state path is missing")) !==
+            statePath ||
+        path.resolve(required(ledger.store_dir, "dispatch Store is missing")) !==
+            path.resolve(storeDir) ||
+        (ledger.status !== "resolved" &&
+            !exactCommittedAcceptance &&
+            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");
+    }
+}
+function assertDeferredForegroundResolvedZeroInputLedger({ storeDir, terminal, transfer, ledger, statePath }) {
+    assertDeferredForegroundLedgerAuthority({
+        storeDir,
+        terminal,
+        transfer,
+        ledger,
+        statePath
+    });
+    const abortedAt = stringValue(ledger.aborted_at);
+    const resolvedAt = stringValue(ledger.resolved_at);
+    const forbiddenEvidence = [
+        "dispatch_started_at",
+        "text_injected_at",
+        "enter_dispatched_at",
+        "submitted_at",
+        "agent_accepted_at",
+        "not_accepted_at",
+        "uncertain_at",
+        "acceptance_evidence"
+    ];
+    if (ledger.status !== "resolved" ||
+        ledger.safe_to_retry !== true ||
+        !abortedAt ||
+        !resolvedAt ||
+        !Number.isFinite(Date.parse(abortedAt)) ||
+        !Number.isFinite(Date.parse(resolvedAt)) ||
+        Date.parse(resolvedAt) < Date.parse(abortedAt) ||
+        forbiddenEvidence.some((field) => ledger[field] !== undefined)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved ledger ` +
+            "does not prove a zero-input abort");
+    }
+    // Validate the whole history for malformed/duplicate identities, then
+    // require the append-only copy of this exact generation. The top-level
+    // resolved record alone is insufficient because it can later be replaced.
+    terminalLedgerReceiptHistory(ledger);
+    const rawHistory = ledger.terminal_submission_receipts;
+    if (!Array.isArray(rawHistory)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved ledger ` +
+            "has no append-only abort receipt");
+    }
+    const ownReceipts = rawHistory.filter((receipt) => isRecord(receipt) &&
+        stringValue(receipt.message_id) === transfer.message_id);
+    if (ownReceipts.length !== 1) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} resolved ledger ` +
+            "does not have one exact append-only abort receipt");
+    }
+    const ownReceipt = ownReceipts[0];
+    assertDeferredForegroundLedgerAuthority({
+        storeDir,
+        terminal,
+        transfer,
+        // A receipt uses `aborted`, while the same exact owner fields at the
+        // top-level use `resolved`. Validate its authority in that same domain.
+        ledger: { ...ownReceipt, status: "resolved" },
+        statePath
+    });
+    if (ownReceipt.status !== "aborted" ||
+        ownReceipt.safe_to_retry !== true ||
+        stringValue(ownReceipt.aborted_at) !== abortedAt ||
+        stringValue(ownReceipt.resolved_at) !== resolvedAt ||
+        forbiddenEvidence.some((field) => ownReceipt[field] !== undefined)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} append-only ` +
+            "receipt does not prove a zero-input abort");
+    }
+}
+function deferredCodexDurableInputNotStartedAt(transfer) {
+    if (transfer.status !== "dispatch_started" ||
+        transfer.input_stage !== "dispatch_started" ||
+        !transfer.state_path) {
+        return undefined;
+    }
+    const conversation = loadState(path.resolve(transfer.state_path));
+    const submission = terminalBridgeSubmission(conversation);
+    const abortedAt = stringValue(submission?.aborted_at);
+    if (submission?.status !== "aborted" ||
+        submission.safe_to_retry !== true ||
+        !abortedAt ||
+        !Number.isFinite(Date.parse(abortedAt)) ||
+        stringValue(submission.text_injected_at) !== undefined ||
+        stringValue(submission.enter_dispatched_at) !== undefined ||
+        stringValue(submission.agent_accepted_at) !== undefined) {
+        return undefined;
+    }
+    return abortedAt;
+}
+function abortPreparedDeferredForegroundTurn({ storeDir, terminal, transfer, boundary, stateLockHeld = false, terminalInputNotStartedAt }) {
+    const dispatchIntentWasProvedNotStarted = transfer.status === "dispatch_started" &&
+        transfer.input_stage === "dispatch_started" &&
+        terminalInputNotStartedAt !== undefined &&
+        Number.isFinite(Date.parse(terminalInputNotStartedAt));
+    if (terminalInputNotStartedAt !== undefined &&
+        !dispatchIntentWasProvedNotStarted) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot attach ` +
+            "terminal-input-not-started proof to its current stage");
+    }
+    const observedLedger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
+    // Before this transfer publishes its own ordinary dispatch ledger, the
+    // terminal may still carry the exact resolved history that was snapshot into
+    // the immutable transfer receipt. Treat only that exact fingerprint (or the
+    // exact persisted `none`) as no new dispatch; every other change must prove
+    // this transfer's own ledger below or fail closed.
+    const previousDispatchStillCurrent = deferredCodexPreviousDispatchSnapshotMatches({
+        transfer,
+        terminalControl: terminal.terminalControl,
+        ledger: observedLedger
+    });
+    if (!previousDispatchStillCurrent && !observedLedger) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} previous dispatch ` +
+            "snapshot disappeared before its own ledger was published");
+    }
+    const ledger = previousDispatchStillCurrent
+        ? undefined
+        : observedLedger;
+    if (!transfer.state_path) {
+        if (ledger) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} has a dispatch ` +
+                "before its Turn authority was prepared");
+        }
+        abortDeferredCodexForegroundTransferBeforeInput({
+            options: { storeDir },
+            boundary,
+            reason: "recovered before target Turn preparation"
+        });
+        return;
+    }
+    const statePath = path.resolve(transfer.state_path);
+    const canonical = pathsForConversationDir(path.dirname(statePath));
+    if (path.resolve(canonical.storeDir) !== path.resolve(storeDir) ||
+        path.resolve(canonical.statePath) !== statePath) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has a noncanonical ` +
+            "Turn state path");
+    }
+    if (!fs.existsSync(statePath)) {
+        if (dispatchIntentWasProvedNotStarted) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} lost its Turn ` +
+                "before terminal-input-not-started proof became durable");
+        }
+        if (ledger) {
+            // runTerminalControlSend publishes the exact prepared terminal ledger
+            // before its Turn state.  A crash in that narrow window still proves
+            // zero input, provided every immutable ledger field matches this
+            // transfer. Resolve that owner before aborting/restoring the Sessions.
+            assertDeferredForegroundLedgerAuthority({
+                storeDir,
+                terminal,
+                transfer,
+                ledger,
+                statePath
+            });
+            if (!["prepared", "resolved"].includes(String(ledger.status))) {
+                throw new Error(`deferred foreground transfer ${transfer.transfer_id} has ` +
+                    `${String(ledger.status)} transport evidence but no exact Turn state`);
+            }
+            if (ledger.status === "prepared") {
+                const abortedAt = cliNow().toISOString();
+                saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
+                    ...ledger,
+                    status: "resolved",
+                    aborted_at: abortedAt,
+                    safe_to_retry: true,
+                    resolved_at: abortedAt,
+                    dispatcher_pid: null,
+                    reason: "deferred dispatcher exited after ledger prepare and before Turn persistence"
+                });
+            }
+            else {
+                assertDeferredForegroundResolvedZeroInputLedger({
+                    storeDir,
+                    terminal,
+                    transfer,
+                    ledger,
+                    statePath
+                });
+            }
+            if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_LEDGER_ABORT_WITHOUT_STATE === "1") {
+                // The zero-input top-level and append-only ledger receipts are both
+                // durable, while the transfer still fences both Sessions. A second
+                // writer must accept this exact resolved form and finish Store-only
+                // rollback without creating or replaying a Turn.
+                cliExit(86);
+            }
+        }
+        abortDeferredCodexForegroundTransferBeforeInput({
+            options: { storeDir },
+            boundary,
+            reason: ledger
+                ? "recovered exact prepared ledger before target Turn state became durable"
+                : "recovered before target Turn state became durable"
+        });
+        return;
+    }
+    const releaseStateLock = stateLockHeld
+        ? undefined
+        : acquireFileLock(`${statePath}.lock`);
+    try {
+        const authority = loadDeferredForegroundTurnAuthority({
+            storeDir,
+            terminal,
+            transfer
+        });
+        const submissionStatus = String(authority.submission.status);
+        let durableNotStartedAt = terminalInputNotStartedAt;
+        if (!ledger && submissionStatus !== "aborted") {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} has prepared Turn ` +
+                "state without its exact terminal ledger");
+        }
+        if (ledger) {
+            assertDeferredForegroundLedgerAuthority({
+                storeDir,
+                terminal,
+                transfer,
+                ledger,
+                statePath: authority.statePath,
+                expectedMessageBodyHash: stringValue(authority.submission.message_body_hash)
+            });
+            if (!["prepared", "resolved"].includes(String(ledger.status))) {
+                throw new Error(`deferred foreground transfer ${transfer.transfer_id} has ` +
+                    `${String(ledger.status)} transport evidence and cannot be aborted`);
+            }
+        }
+        if (dispatchIntentWasProvedNotStarted && submissionStatus === "aborted") {
+            const existingAbortedAt = stringValue(authority.submission.aborted_at);
+            if (authority.submission.safe_to_retry !== true ||
+                !existingAbortedAt ||
+                !Number.isFinite(Date.parse(existingAbortedAt)) ||
+                stringValue(authority.submission.text_injected_at) !== undefined ||
+                stringValue(authority.submission.enter_dispatched_at) !== undefined ||
+                stringValue(authority.submission.agent_accepted_at) !== undefined ||
+                (durableNotStartedAt !== undefined &&
+                    durableNotStartedAt !== existingAbortedAt)) {
+                throw new Error(`deferred foreground transfer ${transfer.transfer_id} has ` +
+                    "inconsistent terminal-input-not-started Turn proof");
+            }
+            durableNotStartedAt = existingAbortedAt;
+        }
+        if (submissionStatus === "prepared") {
+            const abortedAt = durableNotStartedAt ?? cliNow().toISOString();
+            const aborted = withTerminalBridgeSubmission({
+                conversation: {
+                    ...authority.conversation,
+                    status: "failed",
+                    failed_at: abortedAt,
+                    failure_reason: "dispatcher exited before the deferred terminal-input boundary",
+                    updated_at: abortedAt
+                },
+                messageId: transfer.message_id,
+                messageType: "task",
+                requestText: String(authority.takeover.terminal_bridge_request_text ?? ""),
+                status: "aborted",
+                preparedAt: stringValue(authority.submission.prepared_at) ?? abortedAt,
+                abortedAt,
+                error: "dispatcher exited before terminal input",
+                safeToRetry: true
+            });
+            saveState(authority.statePath, aborted);
+        }
+        else if (submissionStatus !== "aborted") {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} Turn has ` +
+                `${submissionStatus} input evidence and cannot be aborted`);
+        }
+        if (dispatchIntentWasProvedNotStarted &&
+            ledger?.status === "resolved" &&
+            (ledger.safe_to_retry !== true ||
+                stringValue(ledger.aborted_at) !== durableNotStartedAt ||
+                stringValue(ledger.text_injected_at) !== undefined ||
+                stringValue(ledger.enter_dispatched_at) !== undefined ||
+                stringValue(ledger.agent_accepted_at) !== undefined)) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} has ` +
+                "inconsistent terminal-input-not-started ledger proof");
+        }
+        if (ledger && ledger.status !== "resolved") {
+            const abortedAt = durableNotStartedAt ?? cliNow().toISOString();
+            saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
+                ...ledger,
+                status: "resolved",
+                aborted_at: abortedAt,
+                safe_to_retry: true,
+                resolved_at: abortedAt,
+                dispatcher_pid: null,
+                reason: "deferred dispatcher exited before the durable terminal-input boundary"
+            });
+        }
+    }
+    finally {
+        releaseStateLock?.();
+    }
+    if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_PREINPUT_ABORT_RECEIPTS === "1") {
+        // The exact Turn and append-only submission receipt are both terminal,
+        // while the transfer and Sessions are intentionally still fenced. The
+        // next writer must finish only the Store rollback and never send input.
+        cliExit(86);
+    }
+    abortDeferredCodexForegroundTransferBeforeInput({
+        options: { storeDir },
+        boundary,
+        reason: "recovered exact prepared Turn with zero terminal input",
+        terminalInputNotStartedAt
+    });
+}
+async function recoverAcceptedDeferredForegroundDispatch({ options, storeDir, terminal, transfer, boundary }) {
+    const statePath = path.resolve(required(transfer.state_path, "deferred foreground Turn state path is unavailable"));
+    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const authority = loadDeferredForegroundTurnAuthority({
+            storeDir,
+            terminal,
+            transfer
+        });
+        const ledger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
+        if (!ledger) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no exact ` +
+                "terminal dispatch ledger for acceptance recovery");
+        }
+        assertDeferredForegroundLedgerAuthority({
+            storeDir,
+            terminal,
+            transfer,
+            ledger,
+            statePath: authority.statePath,
+            expectedMessageBodyHash: stringValue(authority.submission.message_body_hash)
+        });
+        if (![
+            "prepared",
+            "text_injected",
+            "enter_dispatched",
+            "uncertain",
+            "agent_accepted"
+        ].includes(String(ledger.status))) {
+            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;
+        }
+        const acceptance = detectCodexRolloutAcceptance({
+            anchor: authority.anchor,
+            currentIdentity: identity,
+            requestHash: transfer.request_hash
+        });
+        if (!acceptance) {
+            return false;
         }
-        catch {
-            stateAcceptanceEvidence = undefined;
+        if (ledger.status === "agent_accepted") {
+            validateTerminalSubmissionAcceptanceEvidence(ledger.acceptance_evidence, {
+                source: "codex_rollout",
+                nativeThreadId: identity.sessionId,
+                requestHash: transfer.request_hash
+            });
         }
-    }
-    let ledgerAcceptanceEvidence;
-    let ledgerAcceptanceError;
-    if (ledger.status === "agent_accepted") {
+        const acceptedAt = cliNow().toISOString();
+        const boundConversation = withNativeAgentSessionIdentity(authority.conversation, identity);
+        const acceptedConversation = withTerminalBridgeSubmission({
+            conversation: boundConversation,
+            messageId: transfer.message_id,
+            messageType: "task",
+            requestText: String(authority.takeover.terminal_bridge_request_text ?? ""),
+            status: "agent_accepted",
+            preparedAt: stringValue(authority.submission.prepared_at) ?? transfer.prepared_at,
+            textInjectedAt: stringValue(authority.submission.text_injected_at) ??
+                transfer.text_injected_at ?? transfer.dispatch_started_at,
+            enterDispatchedAt: stringValue(authority.submission.enter_dispatched_at) ??
+                transfer.enter_dispatched_at ?? transfer.dispatch_started_at,
+            agentAcceptedAt: acceptedAt,
+            acceptanceEvidence: acceptance
+        });
+        let acceptedStatePersisted = false;
+        // Persist the strongest exact request receipt before mutating either
+        // Session. A crash after the transfer resolves can then be recovered from
+        // this agent_accepted Turn without replaying terminal input.
+        saveState(authority.statePath, acceptedConversation);
+        acceptedStatePersisted = true;
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_ACCEPTED_TURN === "1") {
+            cliExit(86);
+        }
+        let transferCommitted = false;
         try {
-            ledgerAcceptanceEvidence = terminalAcceptanceEvidenceForConversation(conversation, requestText, ledger.acceptance_evidence);
+            await commitDeferredCodexForegroundBinding({
+                options,
+                boundary,
+                identity,
+                acceptedAt
+            });
+            transferCommitted = true;
+            assertNativeAgentIdentityForTurn({
+                conversation: acceptedConversation,
+                currentIdentity: identity,
+                operation: "recover deferred foreground binding for"
+            });
+            saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
+                ...ledger,
+                ...terminalBindingLedgerFields(acceptedConversation),
+                status: "agent_accepted",
+                generation_id: transfer.message_id,
+                conversation_id: acceptedConversation.conversation_id,
+                session_id: transfer.target_session_id,
+                turn_id: transfer.turn_id,
+                message_id: transfer.message_id,
+                message_type: "task",
+                request_hash: transfer.request_hash,
+                prepared_at: transfer.prepared_at,
+                text_injected_at: transfer.text_injected_at ?? transfer.dispatch_started_at,
+                enter_dispatched_at: transfer.enter_dispatched_at ?? transfer.dispatch_started_at,
+                agent_accepted_at: acceptedAt,
+                acceptance_evidence: acceptance,
+                dispatcher_pid: null,
+                state_path: authority.statePath,
+                event_log_path: authority.logPath,
+                callback_expected: Boolean(acceptedConversation.gateway_method),
+                reason: "recovered exact deferred foreground request acceptance"
+            });
+            return true;
         }
         catch (error) {
-            ledgerAcceptanceError = error instanceof Error
-                ? error.message
-                : String(error);
+            if (transferCommitted && !acceptedStatePersisted) {
+                const uncertainAt = cliNow().toISOString();
+                const reason = "deferred Session transfer resolved but exact Turn identity " +
+                    `bookkeeping failed: ${error instanceof Error ? error.message : String(error)}`;
+                const uncertainConversation = withTerminalBridgeSubmission({
+                    conversation: {
+                        ...authority.conversation,
+                        status: "stalled",
+                        stalled_at: uncertainAt,
+                        stalled_reason: reason,
+                        updated_at: uncertainAt
+                    },
+                    messageId: transfer.message_id,
+                    messageType: "task",
+                    requestText: String(authority.takeover.terminal_bridge_request_text ?? ""),
+                    status: "uncertain",
+                    preparedAt: stringValue(authority.submission.prepared_at) ?? transfer.prepared_at,
+                    textInjectedAt: stringValue(authority.submission.text_injected_at) ??
+                        transfer.text_injected_at ?? transfer.dispatch_started_at,
+                    enterDispatchedAt: stringValue(authority.submission.enter_dispatched_at) ??
+                        transfer.enter_dispatched_at ?? transfer.dispatch_started_at,
+                    uncertainAt,
+                    error: reason,
+                    lastProvenStage: "enter_dispatched",
+                    safeToRetry: false
+                });
+                saveState(authority.statePath, uncertainConversation);
+                saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
+                    ...ledger,
+                    ...terminalBindingLedgerFields(uncertainConversation),
+                    status: "uncertain",
+                    uncertain_at: uncertainAt,
+                    dispatcher_pid: null,
+                    callback_expected: false,
+                    reason
+                });
+            }
+            else if (transferCommitted) {
+                // Do not downgrade a durable exact acceptance to the older pre-commit
+                // authority merely because ledger bookkeeping failed. The accepted
+                // receipt remains the monotonic source for later ledger reconciliation,
+                // while the Turn itself is stalled so callback/monitor work cannot
+                // proceed past a failed exact binding assertion.
+                const stalledAt = cliNow().toISOString();
+                const reason = "deferred transfer resolved, but exact accepted Turn bookkeeping " +
+                    `failed: ${error instanceof Error ? error.message : String(error)}`;
+                saveState(authority.statePath, {
+                    ...acceptedConversation,
+                    status: "stalled",
+                    stalled_at: stalledAt,
+                    stalled_reason: reason,
+                    updated_at: stalledAt
+                });
+                try {
+                    saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
+                        ...ledger,
+                        ...terminalBindingLedgerFields(acceptedConversation),
+                        status: "uncertain",
+                        uncertain_at: stalledAt,
+                        last_proven_stage: "agent_accepted",
+                        acceptance_evidence: acceptance,
+                        dispatcher_pid: null,
+                        callback_expected: false,
+                        reason
+                    });
+                }
+                catch {
+                    // The exact accepted Turn above remains authoritative even when the
+                    // ledger itself is the bookkeeping failure being reported.
+                }
+                runtimeLog("error", "deferred_acceptance_ledger_bookkeeping_failed", {
+                    transfer_id: transfer.transfer_id,
+                    turn_id: transfer.turn_id,
+                    state_path: authority.statePath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            throw error;
         }
     }
-    if (ledgerAcceptanceEvidence) {
-        if (!stateAcceptanceEvidence) {
-            const acceptedAt = stringValue(ledger.agent_accepted_at) ?? cliNow().toISOString();
-            const acceptedConversation = withTerminalBridgeSubmission({
-                conversation,
-                messageId,
-                requestText,
-                status: "agent_accepted",
-                preparedAt: stringValue(submission?.prepared_at) ??
-                    stringValue(ledger.prepared_at) ??
-                    acceptedAt,
-                textInjectedAt: stringValue(submission?.text_injected_at) ??
-                    stringValue(ledger.text_injected_at),
-                enterDispatchedAt: stringValue(submission?.enter_dispatched_at) ??
-                    stringValue(ledger.enter_dispatched_at),
-                agentAcceptedAt: acceptedAt,
-                acceptanceEvidence: ledgerAcceptanceEvidence
+    finally {
+        releaseStateLock();
+    }
+}
+function persistCommittedDeferredForegroundTurnAcceptance({ storeDir, terminal, transfer }) {
+    const current = loadDeferredForegroundTransfer(storeDir, transfer.transfer_id);
+    if (current.status !== "committed" ||
+        !current.target_accepted_binding ||
+        !current.target_native_thread_id ||
+        !current.agent_accepted_at) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no exact ` +
+            "committed acceptance authority");
+    }
+    const acceptedBinding = current.target_accepted_binding;
+    const rollout = acceptedBinding.native_process.rollout;
+    const processUuid = acceptedBinding.native_process.process_uuid;
+    const processBirth = acceptedBinding.native_process.process_birth;
+    if (acceptedBinding.native_thread_id !== current.target_native_thread_id ||
+        processUuid !== current.process_uuid ||
+        processBirth !== current.process_birth ||
+        !isCompleteNativeRollout(rollout)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} committed binding ` +
+            "is incomplete");
+    }
+    const identity = {
+        sessionId: current.target_native_thread_id,
+        processUuid,
+        processBirth,
+        rollout,
+        evidence: acceptedBinding.native_process.evidence
+    };
+    const statePath = path.resolve(required(current.state_path, "deferred foreground Turn state path is unavailable"));
+    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const authority = loadDeferredForegroundTurnAuthority({
+            storeDir,
+            terminal,
+            transfer: current
+        });
+        const ledger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
+        if (!ledger) {
+            throw new Error(`deferred foreground transfer ${current.transfer_id} has no exact ` +
+                "terminal dispatch ledger for committed recovery");
+        }
+        assertDeferredForegroundLedgerAuthority({
+            storeDir,
+            terminal,
+            transfer: current,
+            ledger,
+            statePath: authority.statePath,
+            expectedMessageBodyHash: stringValue(authority.submission.message_body_hash)
+        });
+        if (![
+            "prepared",
+            "text_injected",
+            "enter_dispatched",
+            "uncertain",
+            "agent_accepted"
+        ].includes(String(ledger.status))) {
+            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
+        });
+        if (!acceptance) {
+            throw new Error(`deferred foreground transfer ${current.transfer_id} cannot re-prove ` +
+                "its exact request acceptance");
+        }
+        if (ledger.status === "agent_accepted") {
+            validateTerminalSubmissionAcceptanceEvidence(ledger.acceptance_evidence, {
+                source: "codex_rollout",
+                nativeThreadId: identity.sessionId,
+                requestHash: current.request_hash
             });
-            saveState(statePath, acceptedConversation);
         }
-        return ledger;
-    }
-    if (stateAcceptanceEvidence) {
-        const acceptedAt = stringValue(submission?.agent_accepted_at) ?? cliNow().toISOString();
-        saveTerminalBridgeDispatchLedger(terminalControl, {
+        const acceptedConversation = withTerminalBridgeSubmission({
+            conversation: withNativeAgentSessionIdentity(authority.conversation, identity),
+            messageId: current.message_id,
+            messageType: "task",
+            requestText: String(authority.takeover.terminal_bridge_request_text ?? ""),
+            status: "agent_accepted",
+            preparedAt: stringValue(authority.submission.prepared_at) ?? current.prepared_at,
+            textInjectedAt: stringValue(authority.submission.text_injected_at) ??
+                current.text_injected_at ?? current.dispatch_started_at,
+            enterDispatchedAt: stringValue(authority.submission.enter_dispatched_at) ??
+                current.enter_dispatched_at ?? current.dispatch_started_at,
+            agentAcceptedAt: current.agent_accepted_at,
+            acceptanceEvidence: acceptance
+        });
+        saveState(authority.statePath, acceptedConversation);
+        saveTerminalBridgeDispatchLedger(terminal.terminalControl, {
             ...ledger,
-            ...bindingFields,
+            ...terminalBindingLedgerFields(acceptedConversation),
             status: "agent_accepted",
-            text_injected_at: submission?.text_injected_at,
-            enter_dispatched_at: submission?.enter_dispatched_at,
-            agent_accepted_at: acceptedAt,
-            acceptance_evidence: stateAcceptanceEvidence,
+            generation_id: current.message_id,
+            conversation_id: acceptedConversation.conversation_id,
+            session_id: current.target_session_id,
+            turn_id: current.turn_id,
+            message_id: current.message_id,
+            message_type: "task",
+            request_hash: current.request_hash,
+            prepared_at: current.prepared_at,
+            text_injected_at: current.text_injected_at ?? current.dispatch_started_at,
+            enter_dispatched_at: current.enter_dispatched_at ?? current.dispatch_started_at,
+            agent_accepted_at: current.agent_accepted_at,
+            acceptance_evidence: acceptance,
             dispatcher_pid: null,
-            reason: "recovered the strongest durable native acceptance receipt"
+            state_path: authority.statePath,
+            event_log_path: authority.logPath,
+            callback_expected: Boolean(acceptedConversation.gateway_method),
+            reason: "recovered committed deferred foreground request acceptance"
         });
-        return loadTerminalBridgeDispatchLedger(terminalControl);
+        return { conversation: acceptedConversation, identity };
     }
-    if (ledger.status === "agent_accepted") {
-        const uncertainAt = cliNow().toISOString();
-        const uncertainConversation = withTerminalBridgeSubmission({
-            conversation: {
-                ...conversation,
-                status: "stalled",
-                stalled_at: uncertainAt,
-                stalled_reason: "stored native acceptance evidence is invalid",
-                updated_at: uncertainAt
-            },
-            messageId,
-            requestText,
-            status: "uncertain",
-            preparedAt: stringValue(submission?.prepared_at) ??
-                stringValue(ledger.prepared_at) ??
-                uncertainAt,
-            textInjectedAt: stringValue(submission?.text_injected_at) ??
-                stringValue(ledger.text_injected_at),
-            enterDispatchedAt: stringValue(submission?.enter_dispatched_at) ??
-                stringValue(ledger.enter_dispatched_at),
-            uncertainAt,
-            error: ledgerAcceptanceError ??
-                "stored native acceptance evidence is invalid",
-            lastProvenStage: "enter_dispatched"
-        });
-        saveState(statePath, uncertainConversation);
-        saveTerminalBridgeDispatchLedger(terminalControl, {
-            ...ledger,
-            ...bindingFields,
-            status: "uncertain",
-            uncertain_at: uncertainAt,
-            dispatcher_pid: null,
-            reason: "stored native acceptance evidence is invalid"
+    finally {
+        releaseStateLock();
+    }
+}
+async function recoverDeferredCodexForegroundTransferBeforeMutation({ options, terminal }) {
+    const storeDir = storeDirFromOptions(options);
+    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
+    // durable, later legitimate Session revisions never need to be revalidated
+    // against this historical transfer.
+    for (const aborted of transfers.filter((entry) => entry.status === "aborted")) {
+        finalizeAbortedDeferredCodexForegroundTransferCleanup({
+            storeDir,
+            transfer: aborted
         });
-        return loadTerminalBridgeDispatchLedger(terminalControl);
     }
-    const stateRank = terminalSubmissionProofRank(stateStatus, stringValue(submission?.last_proven_stage));
-    const ledgerRank = terminalSubmissionProofRank(String(ledger.status), stringValue(ledger.last_proven_stage));
-    const stateIsTerminal = ["not_accepted", "uncertain", "aborted"]
-        .includes(stateStatus);
-    if (!stateIsTerminal && stateRank <= ledgerRank) {
-        return ledger;
+    transfers = listDeferredForegroundTransfers(storeDir);
+    const matching = transfers.filter((transfer) => transfer.terminal_id === terminal.conversationId &&
+        transfer.process_pid === terminal.pid &&
+        terminalControlEvidenceMatches(transfer.terminal_endpoint, terminal.terminalControl));
+    const candidates = matching.filter((transfer) => !["resolved", "aborted", "abort_resolved"].includes(transfer.status));
+    if (candidates.length === 0) {
+        return;
     }
-    if (![
-        "text_injected",
-        "enter_dispatched",
-        "submitted",
-        "not_accepted",
-        "uncertain",
-        "aborted"
-    ].includes(stateStatus)) {
-        return ledger;
+    if (candidates.length !== 1) {
+        throw new Error(`terminal ${terminal.terminalControl.target} has multiple unresolved ` +
+            "deferred foreground transfers; no terminal input was sent");
     }
-    saveTerminalBridgeDispatchLedger(terminalControl, {
-        ...ledger,
-        ...bindingFields,
-        status: stateStatus,
-        ...(submission?.text_injected_at
-            ? { text_injected_at: submission.text_injected_at }
-            : {}),
-        ...(submission?.enter_dispatched_at
-            ? { enter_dispatched_at: submission.enter_dispatched_at }
-            : {}),
-        ...(submission?.submitted_at
-            ? { submitted_at: submission.submitted_at }
-            : {}),
-        ...(submission?.not_accepted_at
-            ? { not_accepted_at: submission.not_accepted_at }
-            : {}),
-        ...(submission?.uncertain_at
-            ? { uncertain_at: submission.uncertain_at }
-            : {}),
-        ...(submission?.aborted_at
-            ? { aborted_at: submission.aborted_at }
-            : {}),
-        last_proven_stage: submission?.last_proven_stage,
-        ...(stateIsTerminal ? { dispatcher_pid: null } : {}),
-        reason: "recovered the strongest durable conversation proof level"
-    });
-    return loadTerminalBridgeDispatchLedger(terminalControl);
-}
-function terminalSubmissionProofRank(status, lastProven) {
-    if (status === "agent_accepted" || lastProven === "agent_accepted") {
-        return 3;
+    let transfer = candidates[0];
+    const boundary = deferredCodexBoundaryFromTransfer({ terminal, transfer });
+    if (transfer.status === "committed") {
+        const accepted = persistCommittedDeferredForegroundTurnAcceptance({
+            storeDir,
+            terminal,
+            transfer
+        });
+        if (cliEnv().AKK_TEST_EXIT_AFTER_DEFERRED_COMMITTED_ACCEPTANCE_BACKFILL ===
+            "1") {
+            // The exact accepted Turn and ledger are durable while both Sessions
+            // remain fenced by the committed transfer. Recovery must accept this
+            // monotonic ledger shape and finish Session resolution without input.
+            cliExit(86);
+        }
+        await resolveCommittedDeferredCodexForegroundTransfer({
+            options,
+            boundary
+        });
+        assertNativeAgentIdentityForTurn({
+            conversation: accepted.conversation,
+            currentIdentity: accepted.identity,
+            operation: "recover committed deferred foreground binding for"
+        });
+        return;
     }
-    if (["enter_dispatched", "submitted", "not_accepted"].includes(status) ||
-        lastProven === "enter_dispatched") {
-        return 2;
+    if (["prepared", "source_reserved", "target_prepared"].includes(transfer.status)) {
+        abortPreparedDeferredForegroundTurn({
+            storeDir,
+            terminal,
+            transfer,
+            boundary
+        });
+        return;
     }
-    if (status === "text_injected" || lastProven === "text_injected") {
-        return 1;
+    if (["dispatch_started", "uncertain"].includes(transfer.status)) {
+        const durableInputNotStartedAt = deferredCodexDurableInputNotStartedAt(transfer);
+        if (durableInputNotStartedAt) {
+            abortPreparedDeferredForegroundTurn({
+                storeDir,
+                terminal,
+                transfer,
+                boundary,
+                terminalInputNotStartedAt: durableInputNotStartedAt
+            });
+            return;
+        }
+        try {
+            if (await recoverAcceptedDeferredForegroundDispatch({
+                options,
+                storeDir,
+                terminal,
+                transfer,
+                boundary
+            })) {
+                return;
+            }
+        }
+        catch (error) {
+            const durable = loadDeferredForegroundTransfer(storeDir, transfer.transfer_id);
+            if (durable.status === "dispatch_started") {
+                transfer = markDeferredCodexForegroundTransferUncertain({
+                    options,
+                    boundary,
+                    reason: "exact deferred acceptance recovery failed: " +
+                        (error instanceof Error ? error.message : String(error))
+                });
+            }
+            throw new Error(`terminal ${terminal.terminalControl.target} deferred foreground ` +
+                `recovery failed closed: ${error instanceof Error
+                    ? error.message
+                    : String(error)}`, { cause: error });
+        }
+        if (transfer.status !== "uncertain") {
+            transfer = markDeferredCodexForegroundTransferUncertain({
+                options,
+                boundary,
+                reason: "dispatcher exited after the conservative terminal-input boundary " +
+                    "without exact native request acceptance"
+            });
+        }
+        throw new Error(`terminal ${terminal.terminalControl.target} has deferred foreground ` +
+            `transfer ${transfer.transfer_id} with an uncertain dispatch; do not ` +
+            "retry or resolve its Turn outside dedicated recovery");
     }
-    return 0;
+    throw new Error(`deferred foreground transfer ${transfer.transfer_id} has unsupported ` +
+        `recovery status ${transfer.status}`);
 }
 async function recoverLifecycleFenceBeforeMutation({ options, terminal }) {
+    await recoverDeferredCodexForegroundTransferBeforeMutation({
+        options,
+        terminal
+    });
     let ledger = loadTerminalBridgeDispatchLedger(terminal.terminalControl);
     if (!ledger || ledger.status === "resolved") {
         ledger = rebuildObservedHandoffLedgerFromTransition({
@@ -18408,17 +21359,20 @@ async function probeManualCodexLifecycleRecoveryIdentity({ options, terminal, tr
     if (!cleared?.screen.digest) {
         throw new Error("Codex composer did not become empty after recovery clear-line");
     }
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
-    const baselineDigest = cleared.screen.digest;
-    await bridge.send(terminal.agent, terminal.terminalControl, "/status", { runtime: recoveryRuntime });
+    const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+    if (!agentVersion) {
+        throw new Error("Codex lifecycle recovery /status requires the exact running version before terminal input");
+    }
+    const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: recoveryRuntime });
+    const baselineDigest = submission.observationBaselineDigest;
     let stable;
     let stableCount = 0;
     let lastObservationReason = "no fresh idle status screen was captured";
     for (let attempt = 0; attempt < 12; attempt += 1) {
-        const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: recoveryRuntime });
+        const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+            runtime: recoveryRuntime,
+            scrollbackLines: submission.observationScrollbackLines
+        });
         if (status.reachable &&
             status.activity_state === "idle" &&
             !status.approval_state.blocked &&
@@ -19447,6 +22401,15 @@ function runCallback(options) {
 }
 function runRetryCallback(options) {
     const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const retryStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
+    withStoreWriterLease(retryStoreDir, () => {
+        const fresh = loadState(statePath);
+        assertConversationHasNoNonterminalDeferredForegroundTransfer({
+            storeDir: retryStoreDir,
+            conversation: fresh,
+            action: "retry callback for"
+        });
+    });
     const callbackDelivery = isRecord(conversation.callback_delivery)
         ? conversation.callback_delivery
         : undefined;