@scotthuang/agent-knock-knock 0.12.6 → 0.12.8

package/dist/src/cli-core.js

@@ -6,6 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { createCodexTerminalAgentAdapter, detectCodexDurableCompletion } from "./codex-terminal-agent-adapter.js";
+import { codexLifecycleBehaviorProfile } from "./codex-lifecycle-compatibility.js";
 import { createClaudeTerminalAgentAdapter } from "./claude-terminal-agent-adapter.js";
 import { captureClaudeTranscriptAnchor, defaultClaudeHome, detectClaudeTranscriptAcceptance, detectClaudeTranscriptCompletion, detectClaudeTranscriptPendingApproval, listClaudeThreadLifecycleCandidates, revalidateClaudeThreadLifecycleCandidate } from "./claude-local-transcript-provider.js";
 import { captureCodexCandidateSetRolloutAcceptanceAnchor, captureCodexRolloutAcceptanceAnchor, detectCodexBoundRolloutCompletion, detectCodexCandidateSetRolloutAcceptance, detectCodexRolloutAcceptance, terminalSubmissionReplayReceipt, validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence } from "./terminal-submission-acceptance.js";
@@ -1424,7 +1425,7 @@ function isTerminalControlCapability(value) {
 }
 function assertSafeAbortedTerminalRetryBinding({ owner, receipt, storeDir, terminalControl, messageId }) {
     if (!(receipt.status === "aborted" && receipt.safe_to_retry === true)) {
-        return;
+        return undefined;
     }
     const sessionId = sessionIdForConversation(owner);
     const managedSession = tryLoadManagedSession(storeDir, sessionId);
@@ -1440,26 +1441,192 @@ function assertSafeAbortedTerminalRetryBinding({ owner, receipt, storeDir, termi
         stringValue(ownerTakeover?.terminal_agent_session_id) ??
         stringValue(ownerTakeover?.terminal_agent_expected_session_id);
     const ownerAgentPid = Number(ownerTakeover?.terminal_agent_pid);
-    if (!managedSession ||
-        managedSession.status !== "bound" ||
-        !binding ||
-        !receiptBindingId ||
-        !Number.isSafeInteger(receiptBindingGeneration) ||
-        !receiptNativeThreadId ||
-        receiptBindingId !== stringValue(owner.terminal_binding_id) ||
-        receiptBindingGeneration !== Number(owner.terminal_binding_generation) ||
-        receiptNativeThreadId !== ownerNativeThreadId ||
-        binding.binding_id !== receiptBindingId ||
-        binding.generation !== receiptBindingGeneration ||
-        binding.native_thread_id !== receiptNativeThreadId ||
-        !Number.isSafeInteger(ownerAgentPid) ||
-        binding.native_process.pid !== ownerAgentPid ||
-        !ownerControl ||
-        !terminalControlsShareIncarnation(ownerControl, terminalControl) ||
-        !terminalControlsShareIncarnation(binding.terminal_control, terminalControl)) {
+    if (managedSession &&
+        managedSession.status === "bound" &&
+        binding &&
+        receiptBindingId &&
+        Number.isSafeInteger(receiptBindingGeneration) &&
+        receiptNativeThreadId &&
+        receiptBindingId === stringValue(owner.terminal_binding_id) &&
+        receiptBindingGeneration === Number(owner.terminal_binding_generation) &&
+        receiptNativeThreadId === ownerNativeThreadId &&
+        binding.binding_id === receiptBindingId &&
+        binding.generation === receiptBindingGeneration &&
+        binding.native_thread_id === receiptNativeThreadId &&
+        Number.isSafeInteger(ownerAgentPid) &&
+        binding.native_process.pid === ownerAgentPid &&
+        ownerControl &&
+        terminalControlsShareIncarnation(ownerControl, terminalControl) &&
+        terminalControlsShareIncarnation(binding.terminal_control, terminalControl)) {
+        return managedSession;
+    }
+    const recoveredSource = safeAbortedDeferredRetrySourceSession({
+        owner,
+        receipt,
+        storeDir,
+        terminalControl,
+        messageId
+    });
+    if (!recoveredSource) {
         throw new Error(`terminal idempotency key ${messageId} belongs to a safe-aborted Turn ` +
             "whose Session binding is no longer current; no terminal input was sent");
     }
+    return recoveredSource;
+}
+function safeAbortedDeferredRetrySourceSession({ owner, receipt, storeDir, terminalControl, messageId }) {
+    const takeover = isRecord(owner.native_session_takeover)
+        ? owner.native_session_takeover
+        : undefined;
+    const transferId = stringValue(takeover?.deferred_foreground_transfer_id);
+    const ownerControl = terminalControlFromTakeover(takeover);
+    if (!transferId || !takeover || !ownerControl) {
+        return undefined;
+    }
+    const transfer = loadDeferredForegroundTransfer(storeDir, transferId);
+    const target = tryLoadManagedSession(storeDir, transfer.target_session_id);
+    const source = tryLoadManagedSession(storeDir, transfer.source_session_id);
+    const submission = terminalBridgeSubmission(owner);
+    const matchingReceipts = terminalBridgeSubmissionReceipts(owner).filter((candidate) => stringValue(candidate.message_id) === messageId);
+    const canonical = pathsForConversation(owner.conversation_id, storeDir);
+    const targetBinding = transfer.abort_target_after_binding;
+    const sourceBinding = transfer.abort_source_after_binding;
+    const transferDispatchStartedAt = stringValue(transfer.dispatch_started_at);
+    const terminalInputNotStartedAt = stringValue(transfer.terminal_input_not_started_at);
+    const abortedBeforeDispatchIntent = transfer.input_stage === "none" &&
+        transferDispatchStartedAt === undefined &&
+        terminalInputNotStartedAt === undefined;
+    const dispatchIntentProvedNotStarted = transfer.input_stage === "dispatch_started" &&
+        transferDispatchStartedAt !== undefined &&
+        terminalInputNotStartedAt !== undefined &&
+        validTimestampMs(transferDispatchStartedAt) &&
+        validTimestampMs(terminalInputNotStartedAt) &&
+        Date.parse(terminalInputNotStartedAt) >=
+            Date.parse(transferDispatchStartedAt);
+    const forbiddenInputEvidence = [
+        "text_injected_at",
+        "enter_dispatched_at",
+        "submitted_at",
+        "agent_accepted_at",
+        "not_accepted_at",
+        "uncertain_at",
+        "acceptance_evidence"
+    ];
+    if (transfer.version !== 2 ||
+        transfer.status !== "abort_resolved" ||
+        (!abortedBeforeDispatchIntent && !dispatchIntentProvedNotStarted) ||
+        transfer.text_injected_at !== undefined ||
+        transfer.enter_dispatched_at !== undefined ||
+        transfer.agent_accepted_at !== undefined ||
+        transfer.target_session_id !== sessionIdForConversation(owner) ||
+        transfer.turn_id !== turnIdForConversation(owner) ||
+        transfer.turn_id !== owner.conversation_id ||
+        transfer.message_id !== messageId ||
+        transfer.terminal_id !== stringValue(takeover.native_session_id) ||
+        transfer.process_pid !== Number(takeover.terminal_agent_pid) ||
+        transfer.process_uuid !== stringValue(takeover.terminal_agent_process_uuid) ||
+        transfer.process_birth !== stringValue(takeover.terminal_agent_process_birth) ||
+        path.resolve(transfer.workspace) !== path.resolve(owner.workspace) ||
+        !terminalControlsShareIncarnation(ownerControl, terminalControl) ||
+        !terminalControlEvidenceMatches(transfer.terminal_endpoint, terminalControl) ||
+        owner.status !== "failed" ||
+        isRecord(owner.callback_delivery) ||
+        isRecord(owner.terminal_bridge_completion_claim) ||
+        isRecord(takeover.terminal_bridge_completion_claim) ||
+        stringValue(takeover.terminal_bridge_message_id) !== messageId ||
+        stringValue(takeover.terminal_bridge_request_hash) !==
+            transfer.request_hash ||
+        stringValue(takeover.terminal_bridge_request_hash) !==
+            stringValue(receipt.request_hash) ||
+        stringValue(takeover.deferred_foreground_transfer_id) !==
+            transfer.transfer_id ||
+        path.resolve(stringValue(owner.state_path) ?? "") !==
+            path.resolve(canonical.statePath) ||
+        path.resolve(stringValue(owner.event_log_path) ?? "") !==
+            path.resolve(canonical.logPath) ||
+        path.resolve(managedSessionStoreDirForConversation(owner) ?? "") !==
+            path.resolve(storeDir) ||
+        !submission ||
+        matchingReceipts.length !== 1 ||
+        canonicalJson(matchingReceipts[0]) !== canonicalJson(submission) ||
+        canonicalJson(submission) !== canonicalJson(receipt) ||
+        submission.status !== "aborted" ||
+        submission.safe_to_retry !== true ||
+        stringValue(submission.last_proven_stage) !== "prepared" ||
+        !validTimestampMs(submission.prepared_at) ||
+        !validTimestampMs(submission.aborted_at) ||
+        Date.parse(String(submission.aborted_at)) <
+            Date.parse(String(submission.prepared_at)) ||
+        (dispatchIntentProvedNotStarted &&
+            stringValue(submission.aborted_at) !== terminalInputNotStartedAt) ||
+        forbiddenInputEvidence.some((field) => submission[field] !== undefined) ||
+        stringValue(submission.session_id) !== transfer.target_session_id ||
+        stringValue(submission.turn_id) !== transfer.turn_id ||
+        stringValue(submission.message_id) !== transfer.message_id ||
+        stringValue(submission.request_hash) !== transfer.request_hash ||
+        stringValue(submission.binding_id) !==
+            transfer.target_before_binding?.binding_id ||
+        Number(submission.binding_generation) !==
+            transfer.target_before_binding?.generation ||
+        stringValue(submission.native_thread_id) !== undefined ||
+        !target ||
+        target.status !== "detached" ||
+        target.last_transition_id !== transfer.transfer_id ||
+        target.lineage.transition_id !== transfer.transfer_id ||
+        target.lineage.previous_session_id !== transfer.source_session_id ||
+        transfer.abort_target_after_status !== "detached" ||
+        !targetBinding ||
+        managedSessionRevision(target) !== transfer.abort_target_after_revision ||
+        managedSessionBindingToken(target) !==
+            transfer.abort_target_after_binding_token ||
+        JSON.stringify(target.binding) !== JSON.stringify(targetBinding) ||
+        !source ||
+        source.status !== "bound" ||
+        source.last_transition_id !== transfer.source_previous_last_transition_id ||
+        transfer.abort_source_after_status !== "bound" ||
+        !sourceBinding ||
+        managedSessionRevision(source) !== transfer.abort_source_after_revision ||
+        managedSessionBindingToken(source) !==
+            transfer.abort_source_after_binding_token ||
+        JSON.stringify(source.binding) !== JSON.stringify(sourceBinding) ||
+        JSON.stringify(sourceBinding) !==
+            JSON.stringify(transfer.source_before_binding)) {
+        return undefined;
+    }
+    const ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+    if (!ledger) {
+        return undefined;
+    }
+    assertDeferredForegroundResolvedZeroInputLedger({
+        storeDir,
+        terminal: { terminalControl },
+        transfer,
+        ledger,
+        statePath: canonical.statePath
+    });
+    if (dispatchIntentProvedNotStarted &&
+        stringValue(ledger.aborted_at) !== terminalInputNotStartedAt) {
+        return undefined;
+    }
+    return source;
+}
+function exactSafeAbortedRecoveredSessionMatches({ owner, receipt, storeDir, terminalControl, messageId, expectedSessionId }) {
+    const exactReceipt = receipt ?? (() => {
+        const matches = terminalBridgeSubmissionReceipts(owner).filter((candidate) => stringValue(candidate.message_id) === messageId);
+        return matches.length === 1 ? matches[0] : undefined;
+    })();
+    if (!exactReceipt ||
+        exactReceipt.status !== "aborted" ||
+        exactReceipt.safe_to_retry !== true) {
+        return false;
+    }
+    const recoveredSession = assertSafeAbortedTerminalRetryBinding({
+        owner,
+        receipt: exactReceipt,
+        storeDir,
+        terminalControl,
+        messageId
+    });
+    return recoveredSession?.session_id === expectedSessionId;
 }
 function stableDelegateTerminalRoute({ options, request, workspace, requestedAgent }) {
     const messageId = stringValue(options.messageId);
@@ -1547,23 +1714,38 @@ function stableDelegateTerminalRoute({ options, request, workspace, requestedAge
     }
     if (selected.receipt.status === "aborted" &&
         selected.receipt.safe_to_retry === true) {
-        const sessionId = sessionIdForConversation(selected.owner);
         const ownerControl = terminalControlFromTakeover(isRecord(selected.owner.native_session_takeover)
             ? selected.owner.native_session_takeover
             : undefined);
         if (!ownerControl) {
             throw new Error(`terminal idempotency key ${messageId} has no durable terminal route`);
         }
-        assertSafeAbortedTerminalRetryBinding({
+        const retrySession = assertSafeAbortedTerminalRetryBinding({
             owner: selected.owner,
             receipt: selected.receipt,
             storeDir,
             terminalControl: ownerControl,
             messageId
         });
+        if (!retrySession) {
+            throw new Error(`terminal idempotency key ${messageId} has no restored retry Session`);
+        }
+        if (retrySession.agent === "codex" &&
+            isCompleteNativeRollout(retrySession.binding?.native_process.rollout)) {
+            // A safe-aborted retry has proved that the original binding is unchanged,
+            // but one open Codex rollout still does not prove the TUI foreground.
+            // Preserve the stable terminal route so runSend captures fresh implicit
+            // candidate authority and retries through the v3 transfer instead of the
+            // forbidden strict Session path.
+            return {
+                kind: "terminal",
+                conversationId: selected.conversationId,
+                workspace: selected.workspace
+            };
+        }
         return {
             kind: "session",
-            sessionId,
+            sessionId: retrySession.session_id,
             workspace: selected.workspace
         };
     }
@@ -2102,6 +2284,18 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
     const loadedLedgerOwner = loadedLedger && loadedLedgerMessageId === messageId
         ? loadTerminalDispatchLedgerOwner(loadedLedger)
         : undefined;
+    const loadedLedgerSessionId = stringValue(loadedLedger?.session_id);
+    const loadedLedgerMatchesRecoveredSession = Boolean(expectedSessionId &&
+        loadedLedgerSessionId !== undefined &&
+        loadedLedgerSessionId !== expectedSessionId &&
+        loadedLedgerOwner &&
+        exactSafeAbortedRecoveredSessionMatches({
+            owner: loadedLedgerOwner,
+            storeDir: expectedStoreDir,
+            terminalControl,
+            messageId,
+            expectedSessionId
+        }));
     const expectedMessageBodyHash = createHash("sha256")
         .update(requestText)
         .digest("hex");
@@ -2135,8 +2329,9 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
         (!terminalDispatchRecordMatchesControl(loadedLedger, terminalControl) ||
             (loadedLedgerStoreDir !== undefined &&
                 path.resolve(loadedLedgerStoreDir) !== path.resolve(expectedStoreDir)) ||
-            (expectedSessionId && stringValue(loadedLedger.session_id) !== undefined &&
-                stringValue(loadedLedger.session_id) !== expectedSessionId) ||
+            (expectedSessionId && loadedLedgerSessionId !== undefined &&
+                loadedLedgerSessionId !== expectedSessionId &&
+                !loadedLedgerMatchesRecoveredSession) ||
             (expectedTurnId && stringValue(loadedLedger.turn_id) !== undefined &&
                 stringValue(loadedLedger.turn_id) !== expectedTurnId) ||
             (expectedStatePath && loadedLedgerStatePath !== undefined &&
@@ -2168,6 +2363,7 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
         return true;
     }
     if (ledgerReceipt &&
+        !(ledgerReceipt.status === "aborted" && ledgerReceipt.safe_to_retry === true) &&
         (loadedLedgerMessageId !== messageId ||
             !["submitted", "enter_dispatched", "agent_accepted"].includes(String(ledgerReceipt.status)) ||
             !["submitted", "enter_dispatched", "agent_accepted"].includes(String(loadedLedger?.status)))) {
@@ -2325,6 +2521,16 @@ function validateStoredTerminalSubmissionMatch({ owner, receipt, options, termin
     const receiptStoreDir = stringValue(receipt.store_dir) ?? ownerStoreDir;
     const receiptSessionId = stringValue(receipt.session_id) ??
         sessionIdForConversation(owner);
+    const receiptMatchesRecoveredSession = Boolean(expectedSessionId &&
+        receiptSessionId !== expectedSessionId &&
+        exactSafeAbortedRecoveredSessionMatches({
+            owner,
+            receipt,
+            storeDir: expectedStoreDir,
+            terminalControl,
+            messageId,
+            expectedSessionId
+        }));
     const receiptTurnId = stringValue(receipt.turn_id) ??
         turnIdForConversation(owner);
     const receiptOpenClawSession = stringValue(receipt.openclaw_session) ??
@@ -2351,7 +2557,8 @@ function validateStoredTerminalSubmissionMatch({ owner, receipt, options, termin
         !terminalControlEvidenceMatches(receiptTerminalEvidence, terminalControl) ||
         receiptSessionId !== sessionIdForConversation(owner) ||
         receiptTurnId !== turnIdForConversation(owner) ||
-        (expectedSessionId && receiptSessionId !== expectedSessionId) ||
+        (expectedSessionId && receiptSessionId !== expectedSessionId &&
+            !receiptMatchesRecoveredSession) ||
         (expectedTurnId && receiptTurnId !== expectedTurnId) ||
         (expectedStatePath && !sameCanonicalStatePath(owner.state_path, expectedStatePath)) ||
         (requestedOpenClawSession && receiptOpenClawSession !== requestedOpenClawSession) ||
@@ -2426,13 +2633,28 @@ function replayExactStoredTerminalSubmission({ options, terminalControl, request
     const match = matches[0];
     if (!match) {
         for (const { owner, receipt } of validatedMatches) {
-            assertSafeAbortedTerminalRetryBinding({
-                owner,
-                receipt,
-                storeDir: expectedStoreDir,
-                terminalControl,
-                messageId
-            });
+            if (expectedSessionId) {
+                if (!exactSafeAbortedRecoveredSessionMatches({
+                    owner,
+                    receipt,
+                    storeDir: expectedStoreDir,
+                    terminalControl,
+                    messageId,
+                    expectedSessionId
+                })) {
+                    throw new Error(`terminal idempotency key ${messageId} does not match its ` +
+                        "restored retry Session; no terminal input was sent");
+                }
+            }
+            else {
+                assertSafeAbortedTerminalRetryBinding({
+                    owner,
+                    receipt,
+                    storeDir: expectedStoreDir,
+                    terminalControl,
+                    messageId
+                });
+            }
         }
         // A prepared-stage failure with a restored ledger proves that tmux was
         // untouched. The same exact id may therefore start a fresh attempt; all
@@ -2600,8 +2822,8 @@ function assertNoUnresolvedTerminalBridgeSubmission(storeDir, terminalControl, c
     for (const candidate of listConversations(storeDir)) {
         const submission = terminalBridgeSubmission(candidate);
         if (candidate.conversation_id === currentConversationId ||
-            !isActiveStatus(candidate.status) ||
             !submission ||
+            TERMINAL_DISPATCH_RELEASE_STATUSES.has(effectiveTurnStatus(candidate)) ||
             ![
                 "prepared",
                 "text_injected",
@@ -3329,6 +3551,12 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         statusInspection: false,
         reason: "native inspection is unavailable"
     };
+    const codexLatentClearResumeObservationValue = session.agent === "codex"
+        ? codexLatentClearResumeObservation({
+            screen: terminalState.screen_excerpt,
+            agentVersion
+        })
+        : undefined;
     const lifecycleBindingToken = unmanagedTerminalBindingToken({
         terminalId: bridge.terminalConversationId(session),
         terminalControl,
@@ -3347,7 +3575,8 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     if (session.agent === "codex" &&
         (terminalState.activity_state === "idle" ||
             (terminalState.activity_state === "unknown" &&
-                nativeIdentityObservation.status === "verified_absent")) &&
+                (nativeIdentityObservation.status === "verified_absent" ||
+                    codexOpenRootRolloutInventory !== undefined))) &&
         terminalState.approval_state.blocked !== true &&
         terminalControl.capabilities.includes("send_keys") &&
         terminalControl.capabilities.includes("screen_status")) {
@@ -3403,6 +3632,14 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         // this field after gating every automated-input action that can follow a
         // human native-thread switch.
         _automated_input_composer_ready: automatedInputComposerReady,
+        ...(codexLatentClearResumeObservationValue
+            ? {
+                _codex_latent_clear_resume: {
+                    source_native_thread_id: codexLatentClearResumeObservationValue.sourceNativeThreadId,
+                    fingerprint: codexLatentClearResumeObservationValue.fingerprint
+                }
+            }
+            : {}),
         ...(codexOpenRootRolloutInventory
             ? {
                 _codex_open_root_rollout_inventory: codexOpenRootRolloutInventory
@@ -3482,7 +3719,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         return control ? [control] : [];
     });
     const projectedTerminals = terminals.map((terminal) => {
-        const { _automated_input_composer_ready: automatedInputComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, ...publicTerminal } = terminal;
+        const { _automated_input_composer_ready: automatedInputComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, ...publicTerminal } = terminal;
         const codexOpenRootRolloutInventory = isRecord(codexOpenRootRolloutInventoryValue)
             ? codexOpenRootRolloutInventoryValue
             : undefined;
@@ -3732,16 +3969,40 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             codexOpenRootRolloutInventory.roots.length > 0
             ? codexOpenRootRolloutInventory
             : undefined;
-        const deferredCodexSource = authoritativeSession &&
+        const abandonedConflictSource = !authoritativeSession &&
+            soleBindingConflict?.kind === "unverifiable" &&
+            matchingSessions.length === 0 &&
+            conflictingBoundSessionClaims.length === 1 &&
+            unresolvedSessionClaims.length === 0 &&
+            terminal.agent === "codex"
+            ? soleBindingConflict.session
+            : undefined;
+        const deferredCodexSource = (authoritativeSession ??
+            abandonedConflictSource) &&
             terminal.agent === "codex" &&
             (nativeIdentityObservation?.status === "verified_absent" ||
                 deferredCodexCandidateInventory !== undefined)
-            ? authoritativeSession
+            ? authoritativeSession ?? abandonedConflictSource
             : 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 deferredCodexLatentClearResumeFingerprint = isRecord(codexLatentClearResumeValue) &&
+            stringValue(codexLatentClearResumeValue.source_native_thread_id)?.toLowerCase() === deferredCodexSourceNativeThreadId
+            ? stringValue(codexLatentClearResumeValue.fingerprint)
+            : undefined;
+        if (deferredCodexLatentClearResumeFingerprint) {
+            // The resume hint is useful operational context, but it is not durable
+            // foreground authority: it can scroll away while the latent thread is
+            // still current. Candidate routing and its token rely on the complete
+            // rollout inventory and Store authority below instead.
+            runtimeLog("info", "terminal_codex_latent_clear_hint_observed", {
+                terminal_id: String(terminal.id),
+                source_session_id: deferredCodexSource?.session_id,
+                source_native_thread_id: deferredCodexSourceNativeThreadId
+            });
+        }
         const deferredCodexSourceActiveElsewhere = Boolean(deferredCodexSourceNativeThreadId &&
             terminals.some((candidate) => candidate !== terminal &&
                 candidate.agent === "codex" &&
@@ -3750,9 +4011,30 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const deferredCodexDispatchSnapshot = terminalControl
             ? tryDeferredCodexForegroundDispatchSnapshot(terminalControl)
             : undefined;
-        const deferredCodexCandidateSourceTurnHistory = deferredCodexCandidateInventory && deferredCodexSource
+        const deferredCodexCandidateSourceTurnHistory = deferredCodexCandidateInventory &&
+            deferredCodexSource?.binding?.native_process.rollout
             ? deferredCandidateSourceTurnHistory(storeDir, deferredCodexSource)
             : undefined;
+        const deferredCodexSourceRolloutPresent = Boolean(deferredCodexCandidateInventory &&
+            deferredCodexSource?.binding?.native_process.rollout &&
+            deferredCodexCandidateInventory.roots.some((root) => root.sessionId.toLowerCase() ===
+                deferredCodexSource.binding?.native_thread_id?.toLowerCase() &&
+                exactNativeRolloutMatches(root.rollout, deferredCodexSource.binding.native_process.rollout)));
+        const deferredCodexSourceRolloutAuthority = abandonedConflictSource && !deferredCodexSourceRolloutPresent
+            ? "explicitly_abandoned_predecessor"
+            : "present";
+        const deferredCodexSourceAbandonmentFingerprint = deferredCodexSourceRolloutAuthority ===
+            "explicitly_abandoned_predecessor" &&
+            deferredCodexSource &&
+            deferredCodexCandidateSourceTurnHistory &&
+            deferredCodexDispatchSnapshot
+            ? explicitlyAbandonedCandidateSourceFingerprint({
+                storeDir,
+                session: deferredCodexSource,
+                sourceTurnHistory: deferredCodexCandidateSourceTurnHistory,
+                dispatchSnapshot: deferredCodexDispatchSnapshot
+            })
+            : undefined;
         const deferredCodexStatusCardSourceEligible = Boolean(deferredCodexSource &&
             terminalControl &&
             deferredCodexProcessUuid &&
@@ -3785,13 +4067,25 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 workspace: deferredCodexWorkspace,
                 processUuid: deferredCodexProcessUuid,
                 processBirth: deferredCodexProcessBirth,
-                inventory: deferredCodexCandidateInventory
+                inventory: deferredCodexCandidateInventory,
+                sourceRolloutAuthority: deferredCodexSourceRolloutAuthority
+            }) &&
+            (deferredCodexSourceRolloutAuthority === "present" ||
+                Boolean(deferredCodexSourceAbandonmentFingerprint)) &&
+            codexCandidateInventoryHasNoOtherManagedClaim({
+                storeDir,
+                inventory: deferredCodexCandidateInventory,
+                sourceSessionId: deferredCodexSource.session_id,
+                includeDetached: deferredCodexSourceRolloutAuthority ===
+                    "explicitly_abandoned_predecessor"
             }) &&
             candidateSourceTransitionHistoryIsTerminal(storeDir, deferredCodexSource));
-        const deferredCodexCandidateRouteNeeded = Boolean(deferredCodexCandidateInventory &&
-            (deferredCodexCandidateInventory.status === "unbound" ||
-                nativeIdentityObservation?.status === "unavailable" ||
-                deferredCodexSource?.binding?.native_process.rollout === undefined));
+        // A complete one-root inventory proves only which rollout files are
+        // materialized, not which logical thread the Codex TUI currently owns.
+        // `/clear` can select a new thread before its rollout exists, so every
+        // otherwise eligible nonempty inventory uses the same post-submission
+        // candidate-set attribution as a multi-root inventory.
+        const deferredCodexCandidateRouteNeeded = deferredCodexCandidateInventory !== undefined;
         const deferredCodexForegroundEligible = Boolean(mutationsAllowed &&
             !terminalHasNonterminalDeferredTransfer &&
             deferredCodexSource &&
@@ -3799,8 +4093,12 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             hasCanonicalTerminalEndpoint(terminalControl) &&
             discoveredOwnership.state === "none" &&
             unresolvedSessionClaims.length === 0 &&
-            matchingSessions.length === 1 &&
-            conflictingBoundSessionClaims.length === 0 &&
+            ((matchingSessions.length === 1 &&
+                conflictingBoundSessionClaims.length === 0) ||
+                (deferredCodexSourceRolloutAuthority ===
+                    "explicitly_abandoned_predecessor" &&
+                    matchingSessions.length === 0 &&
+                    conflictingBoundSessionClaims.length === 1)) &&
             deferredCodexProcessUuid &&
             deferredCodexProcessBirth &&
             deferredCodexWorkspace &&
@@ -3816,8 +4114,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 terminal.approval_state.blocked === true) &&
             !deferredCodexSourceActiveElsewhere &&
             terminalControl.capabilities.includes("send_keys") &&
-            terminalControl.capabilities.includes("screen_status") &&
-            isRecord(rawActions.send));
+            terminalControl.capabilities.includes("screen_status"));
         const deferredCodexForegroundToken = deferredCodexForegroundEligible &&
             deferredCodexSource &&
             terminalControl &&
@@ -3834,6 +4131,9 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 processBirth: deferredCodexProcessBirth,
                 sourceSession: deferredCodexSource,
                 dispatchSnapshot: deferredCodexDispatchSnapshot,
+                sourceTurnHistory: deferredCodexCandidateSourceTurnHistory,
+                sourceRolloutAuthority: deferredCodexSourceRolloutAuthority,
+                sourceAbandonmentFingerprint: deferredCodexSourceAbandonmentFingerprint,
                 ...(deferredCodexCandidateInventory
                     ? { candidateInventory: deferredCodexCandidateInventory }
                     : {})
@@ -3998,7 +4298,11 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 });
             }
         }
-        const terminalCanAcceptSend = ownership.state === "none" && isRecord(sessionAwareRawActions.send);
+        const rolloutBackedCodexSession = Boolean(authoritativeSession?.agent === "codex" &&
+            isCompleteNativeRollout(authoritativeSession.binding?.native_process.rollout));
+        const terminalCanAcceptSend = ownership.state === "none" &&
+            Boolean(deferredCodexForegroundToken ||
+                (!rolloutBackedCodexSession && isRecord(sessionAwareRawActions.send)));
         if (ownership.state === "current" &&
             !allRelated.some((conversation) => conversation.conversation_id === ownership.conversation.conversation_id)) {
             allRelated.push(ownership.conversation);
@@ -4043,7 +4347,8 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
             : undefined;
         const nonOwnerRawActions = authoritativeSession
-            ? Object.fromEntries(Object.entries(sessionAwareRawActions).filter(([actionName]) => actionName !== "approve"))
+            ? Object.fromEntries(Object.entries(sessionAwareRawActions).filter(([actionName]) => actionName !== "approve" &&
+                !(rolloutBackedCodexSession && actionName === "send")))
             : sessionAwareRawActions;
         const sortedDisplayed = [...sessionDisplayedRelated]
             .filter((conversation) => conversation.conversation_id !== currentTurn?.conversation_id)
@@ -4102,6 +4407,21 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             : ownership.state === "conflict"
                 ? {
                     ...safeTerminalActionsDuringConflict(sessionAwareRawActions),
+                    ...(deferredCodexForegroundToken &&
+                        deferredCodexSourceRolloutAuthority ===
+                            "explicitly_abandoned_predecessor"
+                        ? {
+                            send: {
+                                ...verifiedEmptyRawSendAction,
+                                arguments: {
+                                    ...(isRecord(verifiedEmptyRawSendAction.arguments)
+                                        ? verifiedEmptyRawSendAction.arguments
+                                        : {}),
+                                    expected_terminal_token: deferredCodexForegroundToken
+                                }
+                            }
+                        }
+                        : {}),
                     ...(externalHandoffAdoptable
                         ? {
                             send: {
@@ -4132,21 +4452,21 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                         ? { reconcile_binding: reconcileBindingAction }
                         : {})
                 }
-                : deferredCodexForegroundToken &&
-                    isRecord(rawActions.send)
+                : deferredCodexForegroundToken
                     ? {
                         ...nonOwnerRawActions,
                         send: {
-                            ...rawActions.send,
+                            ...verifiedEmptyRawSendAction,
                             arguments: {
-                                ...(isRecord(rawActions.send.arguments)
-                                    ? rawActions.send.arguments
+                                ...(isRecord(verifiedEmptyRawSendAction.arguments)
+                                    ? verifiedEmptyRawSendAction.arguments
                                     : {}),
                                 expected_terminal_token: deferredCodexForegroundToken
                             }
                         }
                     }
                     : managedSessionId &&
+                        !rolloutBackedCodexSession &&
                         sessionBindingMatchesLiveTerminal &&
                         isRecord(sessionAwareRawActions.send)
                         ? {
@@ -4183,9 +4503,19 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                     "while the same terminal process is at an exact empty prompt",
                 recovery: "use only the exact snapshot-bound send action listed for this terminal"
             }
-            : ownership.state === "conflict"
-                ? ownership.conflict
-                : undefined;
+            : ownership.state === "conflict" &&
+                deferredCodexForegroundToken &&
+                deferredCodexSourceRolloutAuthority ===
+                    "explicitly_abandoned_predecessor"
+                ? {
+                    ...ownership.conflict,
+                    kind: "explicitly_abandoned_predecessor_adoptable",
+                    reason: "the explicitly abandoned Codex predecessor rollout is no longer open and the current exact rollout inventory is unclaimed",
+                    recovery: "use only the exact snapshot-bound follow-current send action listed for this terminal"
+                }
+                : ownership.state === "conflict"
+                    ? ownership.conflict
+                    : undefined;
         return {
             ...publicTerminal,
             ...authoritativeIdentity,
@@ -5523,13 +5853,14 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 12,
+        version: 15,
         instructions: [
             "Treat terminals[] as the primary resource and use only actions present in available_actions, except the snapshot-bound terminals[].handoff_decision.choices.take_over_current.action and an exact terminals[].blocking_turns[].recovery_action. Either nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
-            "An existing managed session's ordinary send targets session_id and creates a new turn. A turn id is never an ordinary send target.",
+            "The session_exact scope uses session_id only when it is prefilled by the listed send action. A rollout-backed managed Codex pane instead uses the terminal_follow_current scope with its exact selector plus expected_terminal_token because even one materialized rollout does not prove the current TUI foreground thread. A turn id is never an ordinary send target.",
+            "A user-explicit raw terminal selector, or a uniquely delegated raw send with no selector, may omit expected_terminal_token for convenience. If that terminal already has one rollout-backed managed Codex source, AKK captures an equivalent fresh candidate authority under the terminal and Store locks and still uses the same v3 follow-current transfer; it never degrades to sole-root strict continuation. Unmanaged first attach retains its existing behavior.",
             "Read-only native-thread listing targets an exact terminal_id. Native-thread new/resume mutations also use the listed expected_binding_token and never create a Turn.",
             "Native inspection is a separate terminal action: use only its closed inspection enum and current exact terminal_id/token; AKK status does not execute a native slash command.",
-            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. A conclusively ended Codex rollout may expose the same snapshot-bound send only after AKK proves zero current rollout and an exact empty composer; it detaches the ended Session and creates an isolated virgin Session. A status-card-only zero-rollout source, or a quiescent rollout-backed source whose complete pinned open-rollout inventory cannot identify one foreground candidate, may also expose this exact action. AKK freezes any released predecessor Turn history, submits the ordinary task once, and binds a separate provisional Session only after one post-anchor rollout uniquely accepts that exact request. The accepted UUID may equal or differ from the predecessor without merging their Session lineages, and narrow panes do not require /status. Until that promotion commits, strict session_id send, respond, approve, cancel, native lifecycle, and native_inspect remain unavailable, and the provisional binding has no callback authority. If dispatch, acceptance, or post-submit binding is uncertain, do not retry automatically. Other binding conflicts remain fail-closed and may expose only exact low-level reconcile_binding recovery.",
+            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. A conclusively ended Codex rollout may expose the same snapshot-bound send only after AKK proves zero current rollout and an exact empty composer; it detaches the ended Session and creates an isolated virgin Session. A status-card-only zero-rollout source or any otherwise eligible quiescent rollout-backed source with a complete nonempty pinned open-rollout inventory may also expose this exact action. One materialized rollout does not prove the current Codex TUI foreground thread, and a /clear resume hint is diagnostic only. AKK freezes any released predecessor Turn history, submits the ordinary task once, and binds a separate provisional Session only after one post-anchor rollout uniquely accepts that exact request. The accepted UUID may equal or differ from the predecessor without merging their Session lineages, and narrow panes do not require /status. Until that promotion commits, strict session_id send, respond, approve, cancel, native lifecycle, and native_inspect remain unavailable, and the provisional binding has no callback authority. If dispatch, acceptance, or post-submit binding is uncertain, do not retry automatically. An explicitly closed uncertain Turn may authorize only a future candidate send when its exact resolved close ledger, append-only uncertain receipt, frozen predecessor history, and complete current rollout inventory prove that the old bound rollout is absent and every candidate is unclaimed; close never forges the lost callback, and uncertain submissions cannot be renewed. 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.",
@@ -5554,7 +5885,7 @@ function listActionContracts() {
             managed: {
                 current_turn: "the authoritative dispatch-ledger owner, never inferred from history",
                 recent_turn: "the latest visible non-owning turn in the current managed session",
-                session_id: "the continuing agent context and authoritative ordinary-send target",
+                session_id: "the continuing agent context; it is an ordinary-send target only when the listed send action explicitly prefills it, and rollout-backed Codex uses selector/token instead",
                 binding_id: "the immutable terminal-binding generation currently authorized for this Session",
                 binding_token: "an optimistic concurrency token required by native-thread mutations",
                 history: "older turns, present only with --all"
@@ -5592,7 +5923,17 @@ function listActionContracts() {
                 tool: "agent_knock_knock_send",
                 target_argument: "session_id",
                 initial_attach_target_argument: "selector",
-                initial_attach_scope: "A discovery selector explicitly named by the user, or the selector prefilled by an unmanaged raw-terminal row's available send action; never infer, guess, or reuse one.",
+                managed_scopes: {
+                    session_exact: {
+                        target_arguments: ["session_id"],
+                        follows_current_terminal: false
+                    },
+                    terminal_follow_current: {
+                        target_arguments: ["selector", "expected_terminal_token"],
+                        follows_current_terminal: true
+                    }
+                },
+                initial_attach_scope: "A discovery selector explicitly named by the user, the selector prefilled by an unmanaged raw-terminal row's available send action, or an omitted selector delegated only when exactly one eligible raw pane exists; never infer, guess, or reuse a selector or token. For an already managed rollout-backed Codex pane, an explicit or unique raw delegation without a token internally captures fresh v3 candidate authority under lock; it never becomes a strict Session continuation.",
                 required: ["request"],
                 optional: [
                     "selector",
@@ -5604,8 +5945,8 @@ function listActionContracts() {
                 ],
                 unsupported: ["timeoutSeconds"],
                 status_card_only_deferred_scope: "A zero-Turn Codex status-card binding has no rollout; only its listed selector/token send creates an isolated provisional Session and binds it after exact request acceptance. Until promotion commits, strict managed controls, native lifecycle, native_inspect, and callback authority remain unavailable; an uncertain dispatch, acceptance, or post-submit binding must not be retried automatically.",
-                candidate_rollout_deferred_scope: "A quiescent rollout-backed Codex source may use a listed selector/token send only when AKK pins the complete exact candidate inventory but cannot prove one foreground UUID. Released predecessor Turn history stays read-only while a separate provisional Session sends once and waits for one unique post-anchor request acceptance. Same-UUID and different-UUID results keep separate Session lineages; zero, multiple, drifted, or uncertain acceptance is never retried blindly.",
-                ordinary_use: "Create a new managed turn in the exact Session. A live terminal selector can attach an unmanaged pane, adopt one verified human-selected native context, detach a verified-empty Codex source, or replace an eligible status-card/candidate-rollout source after the submitted request proves its unique exact rollout; an explicit session_id never follows the pane."
+                candidate_rollout_deferred_scope: "A quiescent rollout-backed Codex source uses a listed selector/token send whenever AKK can pin a complete nonempty candidate inventory. Inventory status resolved means only that one rollout is materialized; it does not prove the current TUI foreground thread. Released predecessor Turn history stays read-only while a separate provisional Session sends once and waits for one unique post-anchor request acceptance. A /clear resume hint is diagnostic only and is not token or routing authority. Same-UUID and different-UUID results keep separate Session lineages; zero, multiple, drifted, or uncertain acceptance is never retried blindly. Explicit close can abandon an uncertain receipt for future-send liveness only while the exact resolved close ledger, append-only receipt, frozen history, absent old rollout, and unclaimed candidate set remain authoritative; it never synthesizes callback delivery.",
+                ordinary_use: "Create a new managed Turn through the exact action listed for the pane. An explicit session_id never follows the pane and is unavailable for rollout-backed Codex Sessions; their listed selector/token action binds only the unique exact rollout that accepts the submitted request. A user-explicit or uniquely delegated raw send without a token receives the same fresh under-lock candidate authority when it resolves to an already managed rollout-backed Codex source. A live terminal selector can also attach an unmanaged pane, adopt one verified human-selected native context, detach a verified-empty Codex source, or replace an eligible status-card/candidate-rollout source."
             },
             new_thread: {
                 tool: "agent_knock_knock_new_thread",
@@ -5852,7 +6193,9 @@ function availableListActions(entry, { conversation } = {}) {
             requires_user_intent: true
         };
     }
-    if (terminalBridgeReady && entry.status === "stalled") {
+    if (terminalBridgeReady &&
+        entry.status === "stalled" &&
+        terminalBridgeSubmission(conversation)?.status !== "uncertain") {
         actions.renew = {
             tool: "agent_knock_knock_renew",
             arguments: targetArguments
@@ -6514,6 +6857,14 @@ function codexAllowedCompanionSetForManagedSession({ storeDir, session }) {
     });
     return { primary: selectedPrimary, additional };
 }
+function codexCompanionsPresentInOpenRootInventory(companions, inventory) {
+    const present = [companions.primary, ...companions.additional].filter((candidate) => Boolean(candidate &&
+        inventory.roots.some((root) => nativeIdentityMatchesCodexPreMaterialization(root, candidate))));
+    return {
+        primary: present[0],
+        additional: present.slice(1)
+    };
+}
 function codexManagedIdentityResolutionContext({ storeDir, terminal }) {
     const claimedSession = soleBoundManagedSessionClaimForTerminal(storeDir, terminal);
     const companions = claimedSession
@@ -7035,8 +7386,11 @@ function exactBoundCodexStatusCardSourceForDeferredSend({ session, terminalId, t
             liveProcessBirth: processBirth
         }) === "same");
 }
-function exactCodexCandidateInventoryForDeferredSend({ inventory, sourceSession, pid, workspace, processUuid, processBirth }) {
+function exactCodexCandidateInventoryForDeferredSend({ inventory, sourceSession, pid, workspace, processUuid, processBirth, sourceRolloutAuthority = "present" }) {
     const sourceNativeThreadId = sourceSession.binding?.native_thread_id;
+    const sourceRollout = sourceSession.binding?.native_process.rollout;
+    const sourceRootPresent = Boolean(sourceNativeThreadId && inventory.roots.some((root) => root.sessionId.toLowerCase() === sourceNativeThreadId.toLowerCase()));
+    const sourceRolloutPresent = Boolean(sourceRollout && inventory.roots.some((root) => exactNativeRolloutMatches(root.rollout, sourceRollout)));
     return Boolean(inventory.roots.length > 0 &&
         inventory.pid === pid &&
         inventory.processUuid === processUuid &&
@@ -7044,11 +7398,14 @@ function exactCodexCandidateInventoryForDeferredSend({ inventory, sourceSession,
         inventory.cwd &&
         path.resolve(inventory.cwd) === path.resolve(workspace) &&
         /^[0-9a-f]{64}$/u.test(inventory.inventoryFingerprint) &&
-        (sourceSession.binding?.native_process.rollout === undefined ||
-            (sourceNativeThreadId &&
-                inventory.roots.some((root) => root.sessionId.toLowerCase() === sourceNativeThreadId.toLowerCase()))));
-}
-function exactBoundCodexCandidateSourceForDeferredSend({ session, terminalId, terminalControl, pid, workspace, processUuid, processBirth, inventory }) {
+        (sourceRolloutAuthority === "explicitly_abandoned_predecessor"
+            ? isExactNativeThreadId(sourceNativeThreadId) &&
+                isCompleteNativeRollout(sourceRollout) &&
+                !sourceRootPresent &&
+                !sourceRolloutPresent
+            : sourceRollout === undefined || sourceRootPresent));
+}
+function exactBoundCodexCandidateSourceForDeferredSend({ session, terminalId, terminalControl, pid, workspace, processUuid, processBirth, inventory, sourceRolloutAuthority = "present" }) {
     const binding = session.binding;
     const sourceNativeThreadId = binding?.native_thread_id;
     const sourceRollout = binding?.native_process.rollout;
@@ -7058,8 +7415,11 @@ function exactBoundCodexCandidateSourceForDeferredSend({ session, terminalId, te
         binding &&
         isExactNativeThreadId(sourceNativeThreadId) &&
         isCompleteNativeRollout(sourceRollout) &&
-        inventoryRoot &&
-        exactNativeRolloutMatches(inventoryRoot.rollout, sourceRollout) &&
+        (sourceRolloutAuthority === "explicitly_abandoned_predecessor"
+            ? inventoryRoot === undefined &&
+                !inventory.roots.some((root) => exactNativeRolloutMatches(root.rollout, sourceRollout))
+            : inventoryRoot !== undefined &&
+                exactNativeRolloutMatches(inventoryRoot.rollout, sourceRollout)) &&
         terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminalId, terminalControl) &&
         path.resolve(session.workspace) === path.resolve(workspace) &&
         processIncarnationRelationship({
@@ -7074,22 +7434,159 @@ function exactBoundCodexCandidateSourceForDeferredSend({ session, terminalId, te
             pid,
             workspace,
             processUuid,
-            processBirth
+            processBirth,
+            sourceRolloutAuthority
         }));
 }
+function codexCandidateInventoryHasNoOtherManagedClaim({ storeDir, inventory, sourceSessionId, includeDetached = true }) {
+    const candidateIds = new Set(inventory.roots.map((root) => root.sessionId.toLowerCase()));
+    return !listManagedSessions(storeDir).some((session) => session.session_id !== sourceSessionId &&
+        (includeDetached || session.status !== "detached") &&
+        isExactNativeThreadId(session.binding?.native_thread_id) &&
+        candidateIds.has(session.binding.native_thread_id.toLowerCase()));
+}
+function exactReleasedSafeAbortedCandidateTurn({ storeDir, session, turn }) {
+    const binding = session.binding;
+    const takeover = isRecord(turn.native_session_takeover)
+        ? turn.native_session_takeover
+        : undefined;
+    const submission = terminalBridgeSubmission(turn);
+    const terminalControl = terminalControlFromTakeover(takeover);
+    const messageId = stringValue(submission?.message_id);
+    const preparedAt = stringValue(submission?.prepared_at);
+    const abortedAt = stringValue(submission?.aborted_at);
+    if (session.status !== "bound" ||
+        session.agent !== "codex" ||
+        !binding ||
+        !isExactNativeThreadId(binding.native_thread_id) ||
+        !TERMINAL_DISPATCH_RELEASE_STATUSES.has(turn.status) ||
+        managedTurnNeedsAttention(turn) ||
+        isRecord(turn.callback_delivery) ||
+        isRecord(turn.terminal_bridge_completion_claim) ||
+        !takeover ||
+        isRecord(takeover.terminal_bridge_completion_claim) ||
+        !submission ||
+        !terminalControl ||
+        !messageId ||
+        submission.status !== "aborted" ||
+        submission.safe_to_retry !== true ||
+        stringValue(submission.last_proven_stage) !== "prepared" ||
+        !preparedAt ||
+        !abortedAt ||
+        !validTimestampMs(preparedAt) ||
+        !validTimestampMs(abortedAt) ||
+        Date.parse(abortedAt) < Date.parse(preparedAt) ||
+        [
+            "text_injected_at",
+            "enter_dispatched_at",
+            "submitted_at",
+            "agent_accepted_at",
+            "not_accepted_at",
+            "uncertain_at",
+            "acceptance_evidence"
+        ].some((field) => submission[field] !== undefined) ||
+        stringValue(takeover.terminal_bridge_message_id) !== messageId ||
+        stringValue(takeover.terminal_bridge_request_hash) !==
+            stringValue(submission.request_hash) ||
+        terminalBridgeRequestFingerprint(stringValue(takeover.terminal_bridge_request_text) ?? "") !== stringValue(submission.request_hash) ||
+        executorForConversation(turn).kind !== "codex" ||
+        sessionIdForConversation(turn) !== session.session_id ||
+        stringValue(submission.session_id) !== session.session_id ||
+        stringValue(submission.turn_id) !== turnIdForConversation(turn) ||
+        stringValue(submission.executor_kind) !== "codex" ||
+        stringValue(submission.openclaw_session) !== turn.openclaw_session ||
+        stringValue(turn.terminal_binding_id) !== binding.binding_id ||
+        Number(turn.terminal_binding_generation) !== binding.generation ||
+        stringValue(takeover.terminal_binding_id) !== binding.binding_id ||
+        Number(takeover.terminal_binding_generation) !== binding.generation ||
+        stringValue(submission.binding_id) !== binding.binding_id ||
+        Number(submission.binding_generation) !== binding.generation ||
+        stringValue(turn.native_thread_id) !== binding.native_thread_id ||
+        stringValue(takeover.terminal_agent_session_id) !==
+            binding.native_thread_id ||
+        stringValue(submission.native_thread_id) !== binding.native_thread_id ||
+        Number(takeover.terminal_agent_pid) !== binding.native_process.pid ||
+        stringValue(takeover.terminal_agent_process_uuid) !==
+            binding.native_process.process_uuid ||
+        stringValue(takeover.terminal_agent_process_birth) !==
+            binding.native_process.process_birth ||
+        !terminalControlsShareIncarnation(terminalControl, binding.terminal_control) ||
+        !terminalControlEvidenceMatches(submission.terminal_endpoint ?? terminalControl, binding.terminal_control) ||
+        path.resolve(turn.workspace) !== path.resolve(session.workspace)) {
+        return false;
+    }
+    const canonical = pathsForConversation(turn.conversation_id, storeDir);
+    if (path.resolve(stringValue(turn.state_path) ?? "") !==
+        path.resolve(canonical.statePath) ||
+        path.resolve(stringValue(turn.event_log_path) ?? "") !==
+            path.resolve(canonical.logPath) ||
+        path.resolve(managedSessionStoreDirForConversation(turn) ?? "") !==
+            path.resolve(storeDir) ||
+        path.resolve(stringValue(submission.store_dir) ?? "") !==
+            path.resolve(storeDir)) {
+        return false;
+    }
+    const matchingReceipts = terminalBridgeSubmissionReceipts(turn).filter((receipt) => stringValue(receipt.message_id) === messageId);
+    return matchingReceipts.length === 1 &&
+        canonicalJson(matchingReceipts[0]) === canonicalJson(submission);
+}
 function deferredCandidateSourceTurnHistory(storeDir, session) {
+    const binding = session.binding;
+    if (!binding?.native_thread_id) {
+        return undefined;
+    }
+    const turns = managedTurnsForSession(storeDir, session.session_id);
+    if (turns.some((turn) => {
+        const callbackDelivered = isRecord(turn.callback_delivery) &&
+            turn.callback_delivery.status === "delivered";
+        const explicitlyAbandonedUncertain = exactExplicitlyAbandonedUncertainCandidateTurn({
+            storeDir,
+            session,
+            turn
+        });
+        const safelyAbortedBeforeInput = exactReleasedSafeAbortedCandidateTurn({
+            storeDir,
+            session,
+            turn
+        });
+        return (!TERMINAL_DISPATCH_RELEASE_STATUSES.has(turn.status) ||
+            managedTurnNeedsAttention(turn) ||
+            (isRecord(turn.callback_delivery) &&
+                !callbackDelivered) ||
+            (Boolean(turn.gateway_method) &&
+                !callbackDelivered &&
+                !explicitlyAbandonedUncertain &&
+                !safelyAbortedBeforeInput) ||
+            stringValue(turn.terminal_binding_id) !== binding.binding_id ||
+            Number(turn.terminal_binding_generation) !== binding.generation ||
+            (stringValue(turn.native_thread_id) ??
+                stringValue(isRecord(turn.native_session_takeover)
+                    ? turn.native_session_takeover.terminal_agent_session_id
+                    : undefined)) !== binding.native_thread_id);
+    })) {
+        return undefined;
+    }
+    return turns
+        .map((turn) => ({
+        turn_id: turnIdForConversation(turn),
+        status: turn.status,
+        updated_at: required(stringValue(turn.updated_at), `managed Turn ${turnIdForConversation(turn)} updated_at is unavailable`),
+        binding_id: binding.binding_id,
+        binding_generation: binding.generation,
+        native_thread_id: binding.native_thread_id,
+        turn_fingerprint: createHash("sha256")
+            .update(JSON.stringify(turn))
+            .digest("hex")
+    }))
+        .sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+}
+function frozenCandidateSourceTurnHistory(storeDir, session) {
     const binding = session.binding;
     if (!binding?.native_thread_id) {
         return undefined;
     }
     const turns = managedTurnsForSession(storeDir, session.session_id);
     if (turns.some((turn) => !TERMINAL_DISPATCH_RELEASE_STATUSES.has(turn.status) ||
-        managedTurnNeedsAttention(turn) ||
-        (isRecord(turn.callback_delivery) &&
-            turn.callback_delivery.status !== "delivered") ||
-        (Boolean(turn.gateway_method) &&
-            (!isRecord(turn.callback_delivery) ||
-                turn.callback_delivery.status !== "delivered")) ||
         stringValue(turn.terminal_binding_id) !== binding.binding_id ||
         Number(turn.terminal_binding_generation) !== binding.generation ||
         (stringValue(turn.native_thread_id) ??
@@ -7098,8 +7595,7 @@ function deferredCandidateSourceTurnHistory(storeDir, session) {
                 : undefined)) !== binding.native_thread_id)) {
         return undefined;
     }
-    return turns
-        .map((turn) => ({
+    return turns.map((turn) => ({
         turn_id: turnIdForConversation(turn),
         status: turn.status,
         updated_at: required(stringValue(turn.updated_at), `managed Turn ${turnIdForConversation(turn)} updated_at is unavailable`),
@@ -7109,8 +7605,220 @@ function deferredCandidateSourceTurnHistory(storeDir, session) {
         turn_fingerprint: createHash("sha256")
             .update(JSON.stringify(turn))
             .digest("hex")
-    }))
-        .sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+    })).sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+}
+function exactExplicitlyAbandonedUncertainCandidateTurn({ storeDir, session, turn }) {
+    return explicitlyAbandonedUncertainCandidateTurnFingerprint({
+        storeDir,
+        session,
+        turn
+    }) !== undefined;
+}
+function explicitlyAbandonedUncertainCandidateTurnProof({ storeDir, session, turn, ledgerOverride, requireResolvedTopLevel = true }) {
+    if (turn.status !== "closed" ||
+        isRecord(turn.callback_delivery) ||
+        isRecord(turn.terminal_bridge_completion_claim) ||
+        !stringValue(turn.closed_at) ||
+        !stringValue(turn.close_reason)) {
+        return undefined;
+    }
+    const takeover = isRecord(turn.native_session_takeover)
+        ? turn.native_session_takeover
+        : undefined;
+    const submission = terminalBridgeSubmission(turn);
+    const terminalControl = terminalControlFromTakeover(takeover);
+    const messageId = stringValue(submission?.message_id);
+    if (!takeover ||
+        isRecord(takeover.terminal_bridge_completion_claim) ||
+        !terminalControl ||
+        submission?.status !== "uncertain" ||
+        submission.safe_to_retry === true ||
+        !messageId ||
+        stringValue(takeover.terminal_bridge_message_id) !== messageId ||
+        stringValue(submission.session_id) !== session.session_id ||
+        stringValue(submission.turn_id) !== turnIdForConversation(turn)) {
+        return undefined;
+    }
+    const canonical = pathsForConversation(turn.conversation_id, storeDir);
+    if (path.resolve(stringValue(turn.state_path) ?? "") !==
+        path.resolve(canonical.statePath) ||
+        path.resolve(stringValue(turn.event_log_path) ?? "") !==
+            path.resolve(canonical.logPath) ||
+        path.resolve(managedSessionStoreDirForConversation(turn) ?? "") !==
+            path.resolve(storeDir)) {
+        return undefined;
+    }
+    let ledger;
+    try {
+        ledger = ledgerOverride ?? loadTerminalBridgeDispatchLedger(terminalControl);
+    }
+    catch {
+        return undefined;
+    }
+    if (!ledger ||
+        !terminalDispatchRecordMatchesControl(ledger, terminalControl) ||
+        (requireResolvedTopLevel &&
+            (ledger.status !== "resolved" ||
+                ledger.reason !== "conversation explicitly closed by request" ||
+                !validTimestampMs(ledger.resolved_at) ||
+                stringValue(ledger.conversation_id) !== turn.conversation_id ||
+                stringValue(ledger.session_id) !== session.session_id ||
+                stringValue(ledger.turn_id) !== turnIdForConversation(turn) ||
+                stringValue(ledger.message_id) !== messageId ||
+                stringValue(ledger.request_hash) !==
+                    stringValue(submission.request_hash) ||
+                stringValue(ledger.binding_id) !==
+                    stringValue(turn.terminal_binding_id) ||
+                Number(ledger.binding_generation) !==
+                    Number(turn.terminal_binding_generation) ||
+                path.resolve(stringValue(ledger.state_path) ?? "") !==
+                    path.resolve(canonical.statePath) ||
+                path.resolve(stringValue(ledger.event_log_path) ?? "") !==
+                    path.resolve(canonical.logPath) ||
+                path.resolve(stringValue(ledger.store_dir) ?? "") !==
+                    path.resolve(storeDir)))) {
+        return undefined;
+    }
+    let receipt;
+    try {
+        const matchingReceipts = terminalLedgerReceiptHistory(ledger).filter((candidate) => stringValue(candidate.message_id) === messageId);
+        receipt = matchingReceipts.length === 1
+            ? matchingReceipts[0]
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (!receipt ||
+        receipt.status !== "uncertain" ||
+        receipt.safe_to_retry === true ||
+        !validTimestampMs(receipt.uncertain_at) ||
+        !terminalDispatchRecordMatchesControl(receipt, terminalControl) ||
+        stringValue(receipt.conversation_id) !== turn.conversation_id ||
+        stringValue(receipt.session_id) !== session.session_id ||
+        stringValue(receipt.turn_id) !== turnIdForConversation(turn) ||
+        stringValue(receipt.request_hash) !== stringValue(submission.request_hash) ||
+        stringValue(receipt.binding_id) !== stringValue(turn.terminal_binding_id) ||
+        Number(receipt.binding_generation) !==
+            Number(turn.terminal_binding_generation) ||
+        path.resolve(stringValue(receipt.state_path) ?? "") !==
+            path.resolve(canonical.statePath) ||
+        path.resolve(stringValue(receipt.event_log_path) ?? "") !==
+            path.resolve(canonical.logPath) ||
+        path.resolve(stringValue(receipt.store_dir) ?? "") !== path.resolve(storeDir)) {
+        return undefined;
+    }
+    let closeEvent;
+    try {
+        closeEvent = readExistingEvents(canonical.logPath).find((event) => event.event === "conversation_closed" &&
+            event.conversation_id === turn.conversation_id &&
+            event.status === "closed" &&
+            event.ts === turn.closed_at &&
+            event.reason === turn.close_reason);
+    }
+    catch {
+        return undefined;
+    }
+    if (!closeEvent) {
+        return undefined;
+    }
+    // Hash the immutable close event and append-only uncertain receipt, not the
+    // mutable top-level terminal ledger that the next dispatch will replace.
+    return {
+        turnId: turnIdForConversation(turn),
+        messageId,
+        turnFingerprint: createHash("sha256")
+            .update(JSON.stringify(turn))
+            .digest("hex"),
+        closeEvent,
+        uncertainReceipt: receipt
+    };
+}
+function explicitlyAbandonedUncertainCandidateTurnFingerprint(args) {
+    const proof = explicitlyAbandonedUncertainCandidateTurnProof(args);
+    return proof
+        ? terminalActionFingerprint({
+            kind: "explicitly_abandoned_uncertain_codex_turn",
+            source_session_id: args.session.session_id,
+            source_revision: managedSessionRevision(args.session),
+            source_binding_token: managedSessionBindingToken(args.session),
+            turn_id: proof.turnId,
+            turn_fingerprint: proof.turnFingerprint,
+            close_event: proof.closeEvent,
+            uncertain_receipt: proof.uncertainReceipt
+        })
+        : undefined;
+}
+function explicitlyAbandonedCandidateSourceFingerprint({ storeDir, session, sourceTurnHistory, dispatchSnapshot, sourceRevision = managedSessionRevision(session), sourceBindingToken = managedSessionBindingToken(session), ledgerOverride, requireResolvedTopLevel = true }) {
+    if (dispatchSnapshot.status !== "resolved") {
+        return undefined;
+    }
+    const abandonedTurnProofs = managedTurnsForSession(storeDir, session.session_id).flatMap((turn) => {
+        const proof = explicitlyAbandonedUncertainCandidateTurnProof({
+            storeDir,
+            session,
+            turn,
+            ledgerOverride,
+            requireResolvedTopLevel
+        });
+        return proof
+            ? [{
+                    turn_id: proof.turnId,
+                    message_id: proof.messageId,
+                    turn_fingerprint: proof.turnFingerprint,
+                    close_event: proof.closeEvent,
+                    uncertain_receipt: proof.uncertainReceipt
+                }]
+            : [];
+    }).sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+    if (abandonedTurnProofs.length === 0) {
+        return undefined;
+    }
+    return terminalActionFingerprint({
+        kind: "explicitly_abandoned_codex_predecessor",
+        source_session_id: session.session_id,
+        source_revision: sourceRevision,
+        source_binding_token: sourceBindingToken,
+        source_turn_history: sourceTurnHistory,
+        previous_dispatch_snapshot: dispatchSnapshot,
+        abandoned_turns: abandonedTurnProofs
+    });
+}
+function assertFrozenExplicitlyAbandonedPredecessorAuthority({ storeDir, transfer, terminalControl }) {
+    if (transfer.source_rollout_authority !==
+        "explicitly_abandoned_predecessor") {
+        return;
+    }
+    const source = loadManagedSession(storeDir, transfer.source_session_id);
+    const sourceAsBound = {
+        ...source,
+        status: "bound",
+        binding: transfer.source_before_binding,
+        last_transition_id: transfer.source_previous_last_transition_id
+    };
+    const history = frozenCandidateSourceTurnHistory(storeDir, sourceAsBound);
+    const ledger = loadTerminalBridgeDispatchLedger(terminalControl);
+    const fingerprint = history && ledger
+        ? explicitlyAbandonedCandidateSourceFingerprint({
+            storeDir,
+            session: sourceAsBound,
+            sourceTurnHistory: history,
+            dispatchSnapshot: {
+                status: transfer.previous_dispatch_status,
+                fingerprint: transfer.previous_dispatch_fingerprint
+            },
+            sourceRevision: transfer.source_expected_revision,
+            sourceBindingToken: transfer.source_binding_token,
+            ledgerOverride: ledger,
+            requireResolvedTopLevel: false
+        })
+        : undefined;
+    if (!history ||
+        JSON.stringify(history) !== JSON.stringify(transfer.source_turn_history) ||
+        fingerprint !== transfer.source_abandonment_fingerprint) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} lost its exact ` +
+            "explicitly abandoned predecessor authority");
+    }
 }
 function candidateSourceTransitionHistoryIsTerminal(storeDir, session) {
     if (managedSessionHasUnresolvedNativeTransition(storeDir, session)) {
@@ -7129,7 +7837,7 @@ function candidateSourceTransitionHistoryIsTerminal(storeDir, session) {
         return false;
     }
 }
-function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession, dispatchSnapshot, candidateInventory }) {
+function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession, dispatchSnapshot, candidateInventory, sourceTurnHistory, sourceRolloutAuthority = "present", sourceAbandonmentFingerprint }) {
     const terminalToken = unmanagedTerminalBindingToken({
         terminalId,
         terminalControl,
@@ -7147,18 +7855,35 @@ function deferredCodexForegroundBindingToken({ terminalId, terminalControl, pid,
             candidate_native_thread_ids: candidateInventory.roots.map((root) => root.sessionId)
         }
         : undefined;
+    const sourceTurnHistoryFingerprint = sourceTurnHistory
+        ? createHash("sha256")
+            .update(JSON.stringify(sourceTurnHistory))
+            .digest("hex")
+        : undefined;
     return createHash("sha256")
         .update(JSON.stringify({
-        version: candidateAuthority ? 3 : 2,
+        version: candidateAuthority ? 5 : 2,
         kind: "deferred_codex_foreground_binding",
         terminal_token: terminalToken,
+        composer_state: "styled_empty",
         source_session_id: sourceSession.session_id,
         source_revision: managedSessionRevision(sourceSession),
         source_binding_token: managedSessionBindingToken(sourceSession),
         terminal_dispatch_snapshot: dispatchSnapshot,
         observation: candidateAuthority
-            ? "exact_unbound_open_root_inventory"
+            ? "exact_open_root_inventory"
             : "verified_absent",
+        ...(sourceTurnHistoryFingerprint
+            ? { source_turn_history_fingerprint: sourceTurnHistoryFingerprint }
+            : {}),
+        ...(candidateAuthority
+            ? { source_rollout_authority: sourceRolloutAuthority }
+            : {}),
+        ...(sourceAbandonmentFingerprint
+            ? {
+                source_abandonment_fingerprint: sourceAbandonmentFingerprint
+            }
+            : {}),
         ...(candidateAuthority ?? {})
     }))
         .digest("hex");
@@ -7484,7 +8209,8 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
                 pid: boundary.terminal.pid,
                 workspace: required(boundary.terminal.terminalControl.currentPath, "deferred Codex terminal workspace is unavailable"),
                 processUuid: boundary.processUuid,
-                processBirth: boundary.processBirth
+                processBirth: boundary.processBirth,
+                sourceRolloutAuthority: boundary.sourceRolloutAuthority
             })) {
             throw new Error("the exact Codex open-root inventory changed; refresh AKK list before sending");
         }
@@ -7526,7 +8252,27 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
         }
     }
     else {
-        const history = deferredCandidateSourceTurnHistory(storeDir, sourceAsBound);
+        const history = expectedSourceStatus === "bound"
+            ? deferredCandidateSourceTurnHistory(storeDir, sourceAsBound)
+            : frozenCandidateSourceTurnHistory(storeDir, sourceAsBound);
+        const currentAbandonmentFingerprint = boundary.sourceRolloutAuthority ===
+            "explicitly_abandoned_predecessor" &&
+            history
+            ? explicitlyAbandonedCandidateSourceFingerprint({
+                storeDir,
+                session: sourceAsBound,
+                sourceTurnHistory: history,
+                dispatchSnapshot: boundary.previousDispatchSnapshot,
+                sourceRevision: boundary.sourceBoundRevision,
+                sourceBindingToken: boundary.sourceBoundBindingToken,
+                ...(expectedSourceStatus === "transitioning"
+                    ? {
+                        ledgerOverride: loadTerminalBridgeDispatchLedger(boundary.terminal.terminalControl),
+                        requireResolvedTopLevel: false
+                    }
+                    : {})
+            })
+            : undefined;
         if (!boundary.candidateAcceptanceAnchor ||
             !history ||
             JSON.stringify(history) !== JSON.stringify(boundary.sourceTurnHistory) ||
@@ -7538,8 +8284,15 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
                 workspace: required(boundary.terminal.terminalControl.currentPath, "deferred Codex terminal workspace is unavailable"),
                 processUuid: boundary.processUuid,
                 processBirth: boundary.processBirth,
-                inventory: required(candidateInventoryForBoundary, "deferred Codex candidate inventory is unavailable")
+                inventory: required(candidateInventoryForBoundary, "deferred Codex candidate inventory is unavailable"),
+                sourceRolloutAuthority: boundary.sourceRolloutAuthority
             }) ||
+            (boundary.sourceRolloutAuthority ===
+                "explicitly_abandoned_predecessor" &&
+                (!boundary.sourceAbandonmentFingerprint ||
+                    currentAbandonmentFingerprint !==
+                        boundary.sourceAbandonmentFingerprint ||
+                    boundary.previousDispatchSnapshot.status !== "resolved")) ||
             !candidateSourceTransitionHistoryIsTerminal(storeDir, sourceAsBound)) {
             throw new Error("the deferred Codex candidate source history or rollout authority changed");
         }
@@ -7575,15 +8328,22 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
     }
     return source;
 }
-async function prepareDeferredCodexForegroundBinding({ options, terminal, sourceSession, observation, candidateInventory, requestText }) {
+async function prepareDeferredCodexForegroundBinding({ options, terminal, sourceSession, observation, candidateInventory, requestText, allowImplicitFreshAuthority = false }) {
     const expectedToken = stringValue(options.expectedTerminalToken);
     const candidateMode = Boolean(candidateInventory?.roots.length);
     if (terminal.agent !== "codex" ||
         !sourceSession?.binding ||
         (observation.status !== "verified_absent" && !candidateMode) ||
-        !expectedToken) {
+        (!expectedToken && !allowImplicitFreshAuthority)) {
         return undefined;
     }
+    if (allowImplicitFreshAuthority &&
+        (expectedToken !== undefined ||
+            !candidateMode ||
+            !isCompleteNativeRollout(sourceSession.binding.native_process.rollout))) {
+        throw new Error("implicit Codex candidate authority requires one fresh complete " +
+            "nonempty rollout inventory for a rollout-backed source");
+    }
     const processUuid = sourceSession.binding.native_process.process_uuid;
     const processBirth = sourceSession.binding.native_process.process_birth;
     const workspace = terminal.terminalControl.currentPath;
@@ -7596,6 +8356,27 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         "candidate_rollout_quiescent"
         ? deferredCandidateSourceTurnHistory(storeDir, sourceSession)
         : undefined;
+    const dispatchSnapshot = deferredCodexForegroundDispatchSnapshot(terminal.terminalControl);
+    const sourceRolloutPresent = Boolean(candidateInventory &&
+        sourceSession.binding.native_process.rollout &&
+        candidateInventory.roots.some((root) => root.sessionId.toLowerCase() ===
+            sourceSession.binding?.native_thread_id?.toLowerCase() &&
+            exactNativeRolloutMatches(root.rollout, sourceSession.binding.native_process.rollout)));
+    const sourceRolloutAuthority = sourceKind === "candidate_rollout_quiescent" &&
+        candidateInventory &&
+        sourceSession.binding.native_process.rollout &&
+        !sourceRolloutPresent
+        ? "explicitly_abandoned_predecessor"
+        : "present";
+    const sourceAbandonmentFingerprint = sourceRolloutAuthority === "explicitly_abandoned_predecessor" &&
+        candidateSourceTurnHistory
+        ? explicitlyAbandonedCandidateSourceFingerprint({
+            storeDir,
+            session: sourceSession,
+            sourceTurnHistory: candidateSourceTurnHistory,
+            dispatchSnapshot
+        })
+        : undefined;
     const exactSource = !workspace
         ? false
         : sourceKind === "candidate_rollout_quiescent"
@@ -7610,7 +8391,8 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
                     workspace,
                     processUuid: liveIncarnation.processUuid,
                     processBirth: liveIncarnation.processBirth,
-                    inventory: candidateInventory
+                    inventory: candidateInventory,
+                    sourceRolloutAuthority
                 })
             : exactBoundCodexStatusCardSourceForDeferredSend({
                 session: sourceSession,
@@ -7631,7 +8413,10 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         !exactSource) {
         return undefined;
     }
-    const dispatchSnapshot = deferredCodexForegroundDispatchSnapshot(terminal.terminalControl);
+    if (sourceRolloutAuthority === "explicitly_abandoned_predecessor" &&
+        !sourceAbandonmentFingerprint) {
+        return undefined;
+    }
     const token = deferredCodexForegroundBindingToken({
         terminalId: terminal.conversationId,
         terminalControl: terminal.terminalControl,
@@ -7641,12 +8426,27 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         processBirth,
         sourceSession,
         dispatchSnapshot,
+        sourceTurnHistory: candidateSourceTurnHistory,
+        sourceRolloutAuthority,
+        sourceAbandonmentFingerprint,
         ...(candidateMode ? { candidateInventory } : {})
     });
-    if (expectedToken !== token) {
+    if (!allowImplicitFreshAuthority && expectedToken !== token) {
         throw new Error("deferred Codex foreground binding requires the fresh exact terminal " +
             "token advertised by AKK list");
     }
+    if (allowImplicitFreshAuthority) {
+        runtimeLog("info", "deferred_codex_implicit_candidate_authority", {
+            terminal_id: terminal.conversationId,
+            terminal_target: terminal.terminalControl.target,
+            source_session_id: sourceSession.session_id,
+            inventory_status: candidateInventory?.status,
+            inventory_fingerprint: candidateInventory?.inventoryFingerprint,
+            candidate_count: candidateInventory?.roots.length,
+            authority_scope: "terminal_follow_current",
+            terminal_input_sent: false
+        });
+    }
     const targetSessionId = createManagedSessionId();
     const transferId = createDeferredForegroundTransferId();
     const candidateAcceptanceAnchor = candidateMode
@@ -7666,6 +8466,10 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         processBirth,
         previousDispatchSnapshot: dispatchSnapshot,
         sourceKind,
+        sourceRolloutAuthority,
+        ...(sourceAbandonmentFingerprint
+            ? { sourceAbandonmentFingerprint }
+            : {}),
         ...(sourceSession.last_transition_id
             ? { sourcePreviousLastTransitionId: sourceSession.last_transition_id }
             : {}),
@@ -7690,6 +8494,52 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         terminalControl: terminal.terminalControl,
         excludedManagedSessionId: sourceSession.session_id
     });
+    if (candidateInventory &&
+        !codexCandidateInventoryHasNoOtherManagedClaim({
+            storeDir,
+            inventory: candidateInventory,
+            sourceSessionId: sourceSession.session_id,
+            includeDetached: sourceRolloutAuthority === "explicitly_abandoned_predecessor"
+        })) {
+        throw new Error("a Codex rollout candidate is already claimed by another Session");
+    }
+    if (candidateInventory &&
+        sourceRolloutAuthority === "explicitly_abandoned_predecessor") {
+        for (const root of candidateInventory.roots) {
+            await assertNativeThreadHasExclusiveOwnership({
+                options,
+                agent: "codex",
+                currentPid: terminal.pid,
+                nativeThreadId: root.sessionId,
+                storeDir,
+                terminalControl: terminal.terminalControl,
+                excludedManagedSessionId: root.sessionId.toLowerCase() ===
+                    sourceSession.binding.native_thread_id?.toLowerCase()
+                    ? sourceSession.session_id
+                    : undefined
+            });
+        }
+    }
+    // The source semantic proof is about to be replaced by the transfer's own
+    // top-level dispatch generation. Recheck it immediately before publishing
+    // the prepared transfer so every later phase can rely on the immutable
+    // fingerprint plus the Store protocol-5 source-Turn fence.
+    if (sourceRolloutAuthority === "explicitly_abandoned_predecessor") {
+        const freshHistory = deferredCandidateSourceTurnHistory(storeDir, sourceSession);
+        const freshAbandonmentFingerprint = freshHistory
+            ? explicitlyAbandonedCandidateSourceFingerprint({
+                storeDir,
+                session: sourceSession,
+                sourceTurnHistory: freshHistory,
+                dispatchSnapshot
+            })
+            : undefined;
+        if (JSON.stringify(freshHistory) !==
+            JSON.stringify(candidateSourceTurnHistory) ||
+            freshAbandonmentFingerprint !== sourceAbandonmentFingerprint) {
+            throw new Error("the explicitly abandoned Codex predecessor authority changed; refresh AKK list");
+        }
+    }
     const existingTransfer = listDeferredForegroundTransfers(storeDir).find((candidate) => !["resolved", "abort_resolved"].includes(candidate.status) &&
         (candidate.source_session_id === sourceSession.session_id ||
             (candidate.terminal_id === terminal.conversationId &&
@@ -7716,6 +8566,12 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         source_previous_last_transition_id: sourceSession.last_transition_id,
         source_before_binding: sourceSession.binding,
         source_kind: sourceKind,
+        ...(sourceRolloutAuthority === "explicitly_abandoned_predecessor"
+            ? { source_rollout_authority: sourceRolloutAuthority }
+            : {}),
+        ...(sourceAbandonmentFingerprint
+            ? { source_abandonment_fingerprint: sourceAbandonmentFingerprint }
+            : {}),
         ...(candidateSourceTurnHistory
             ? { source_turn_history: candidateSourceTurnHistory }
             : {}),
@@ -7749,6 +8605,10 @@ function assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary })
         (transfer.version === 1
             ? "status_card_only"
             : transfer.source_kind) !== boundary.sourceKind ||
+        (transfer.source_rollout_authority ?? "present") !==
+            boundary.sourceRolloutAuthority ||
+        transfer.source_abandonment_fingerprint !==
+            boundary.sourceAbandonmentFingerprint ||
         JSON.stringify(transfer.source_turn_history) !==
             JSON.stringify(boundary.sourceTurnHistory) ||
         transfer.source_previous_last_transition_id !==
@@ -8135,6 +8995,11 @@ async function commitDeferredCodexForegroundBinding({ options, boundary, identit
     const storeDir = storeDirFromOptions(options);
     let transfer = loadDeferredForegroundTransfer(storeDir, boundary.transferId);
     assertDeferredForegroundTransferMatchesBoundary({ transfer, boundary });
+    assertFrozenExplicitlyAbandonedPredecessorAuthority({
+        storeDir,
+        transfer,
+        terminalControl: boundary.terminal.terminalControl
+    });
     if (!["dispatch_started", "uncertain"].includes(transfer.status) ||
         transfer.input_stage === "none" ||
         identity.processUuid !== transfer.process_uuid ||
@@ -8184,7 +9049,11 @@ async function commitDeferredCodexForegroundBinding({ options, boundary, identit
             ? transfer.target_session_id
             : sameNativeThread
                 ? transfer.source_session_id
-                : transfer.target_session_id
+                : transfer.target_session_id,
+        allowedManagedSessionIds: transfer.source_rollout_authority ===
+            "explicitly_abandoned_predecessor"
+            ? [transfer.source_session_id]
+            : []
     });
     const retirement = sameNativeThread
         ? "binding_scrubbed_same_native_thread"
@@ -8360,7 +9229,11 @@ async function resolveCommittedDeferredCodexForegroundTransfer({ options, bounda
         nativeThreadId: transfer.target_native_thread_id,
         storeDir,
         terminalControl: boundary.terminal.terminalControl,
-        excludedManagedSessionId: target.session_id
+        excludedManagedSessionId: target.session_id,
+        allowedManagedSessionIds: transfer.source_rollout_authority ===
+            "explicitly_abandoned_predecessor"
+            ? [transfer.source_session_id]
+            : []
     });
     transfer = saveDeferredForegroundTransfer(storeDir, {
         ...transfer,
@@ -8563,7 +9436,13 @@ async function maybeAdoptObservedExternalThread({ options, terminal, sourceSessi
         options,
         terminal,
         sourceSession,
-        resolvedIdentity
+        resolvedIdentity,
+        // Snapshot-bound terminal actions apply their own stricter boundary
+        // before any input.  In particular, a post-/clear Codex composer can be
+        // safely empty while the passive activity classifier is still unknown;
+        // do not force the unrelated external-handoff idle check before the
+        // deferred candidate boundary gets a chance to revalidate it.
+        requireSafeTerminal: !stringValue(options.expectedTerminalToken)
     });
     const identity = observed.identity;
     const conflictKind = managedBindingConflictKindForResolvedTerminal({
@@ -9207,7 +10086,7 @@ function verifiedWorkspaceRelationship(targetWorkspace, candidateWorkspace) {
         return "unknown";
     }
 }
-async function assertNativeThreadHasExclusiveOwnership({ options, agent, currentPid, nativeThreadId, storeDir, terminalControl, excludedManagedSessionId }) {
+async function assertNativeThreadHasExclusiveOwnership({ options, agent, currentPid, nativeThreadId, storeDir, terminalControl, excludedManagedSessionId, allowedManagedSessionIds = [] }) {
     const normalizedNativeThreadId = nativeThreadId.toLowerCase();
     if (!isExactNativeThreadId(normalizedNativeThreadId)) {
         throw new Error("native thread ownership requires an exact thread UUID");
@@ -9232,6 +10111,7 @@ async function assertNativeThreadHasExclusiveOwnership({ options, agent, current
         throw new Error(`native thread ownership is unverifiable: ${activeOwnerScan.uncertaintyReasons.join("; ")}`);
     }
     const conflictingSessions = listManagedSessions(storeDir).filter((session) => session.session_id !== excludedManagedSessionId &&
+        !allowedManagedSessionIds.includes(session.session_id) &&
         session.agent === agent &&
         session.binding?.native_thread_id?.toLowerCase() === normalizedNativeThreadId);
     if (conflictingSessions.length > 0) {
@@ -12022,6 +12902,11 @@ async function runSend(options) {
                 }
                 assertTerminalIncarnationCanStartTurn(rawStoreDir, terminalConversation.terminalControl);
                 let claimedSession = soleBoundManagedSessionClaimForTerminal(rawStoreDir, terminalConversation);
+                const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
+                const implicitCodexCandidateAuthority = Boolean(terminalConversation.agent === "codex" &&
+                    suppliedExpectedTerminalToken === undefined &&
+                    claimedSession?.status === "bound" &&
+                    isCompleteNativeRollout(claimedSession.binding?.native_process.rollout));
                 let knownCodexCompanions = claimedSession
                     ? codexAllowedCompanionSetForManagedSession({
                         storeDir: rawStoreDir,
@@ -12041,7 +12926,7 @@ async function runSend(options) {
                 });
                 let deferredCodexCandidateInventory;
                 if (terminalConversation.agent === "codex" &&
-                    stringValue(options.expectedTerminalToken)) {
+                    (suppliedExpectedTerminalToken || implicitCodexCandidateAuthority)) {
                     try {
                         const inventory = await inspectCodexOpenRootRolloutInventory({
                             options,
@@ -12053,12 +12938,18 @@ async function runSend(options) {
                         }
                     }
                     catch (error) {
-                        if (nativeIdentityObservation.status === "unavailable") {
-                            throw new Error(`native Codex identity observation is unavailable and its exact ` +
-                                `open-root inventory could not be proven: ${error instanceof Error ? error.message : String(error)}`);
+                        if (implicitCodexCandidateAuthority ||
+                            nativeIdentityObservation.status === "unavailable") {
+                            throw new Error(`native Codex foreground attribution requires a fresh complete ` +
+                                `open-root inventory: ${error instanceof Error ? error.message : String(error)}`);
                         }
                     }
                 }
+                if (implicitCodexCandidateAuthority &&
+                    !deferredCodexCandidateInventory) {
+                    throw new Error("rollout-backed Codex terminal send requires a fresh complete " +
+                        "nonempty open-root inventory; refresh AKK list before sending");
+                }
                 if (nativeIdentityObservation.status === "unavailable" &&
                     !deferredCodexCandidateInventory) {
                     throw new Error(`native ${terminalConversation.agent} identity observation is ` +
@@ -12067,12 +12958,17 @@ async function runSend(options) {
                 let currentNativeIdentity = nativeIdentityObservation.status === "resolved"
                     ? nativeIdentityObservation.identity
                     : undefined;
-                const verifiedEmptyHandoff = await maybeDetachVerifiedEmptyCodexSource({
-                    options,
-                    terminal: terminalConversation,
-                    sourceSession: claimedSession,
-                    observation: nativeIdentityObservation
-                });
+                // A fresh nonempty inventory is the stronger physical authority for an
+                // implicit candidate send. Do not let an earlier verified-absent
+                // observation divert this path into the token-only empty handoff.
+                const verifiedEmptyHandoff = implicitCodexCandidateAuthority
+                    ? undefined
+                    : await maybeDetachVerifiedEmptyCodexSource({
+                        options,
+                        terminal: terminalConversation,
+                        sourceSession: claimedSession,
+                        observation: nativeIdentityObservation
+                    });
                 if (verifiedEmptyHandoff) {
                     // The old rollout is conclusively closed.  Never carry it forward as
                     // a pre-materialization companion for the new virgin Session.
@@ -12084,7 +12980,13 @@ async function runSend(options) {
                 let handoff = await maybeAdoptObservedExternalThread({
                     options,
                     terminal: terminalConversation,
-                    sourceSession: claimedSession,
+                    // A no-token raw send to an already managed rollout-backed Codex pane
+                    // is an internal follow-current delegation, never a sole-root strict
+                    // continuation or an external-handoff adoption. The dedicated v3
+                    // transfer below owns attribution and lineage.
+                    sourceSession: implicitCodexCandidateAuthority
+                        ? undefined
+                        : claimedSession,
                     resolvedIdentity: currentNativeIdentity,
                     storeDir: rawStoreDir
                 });
@@ -12101,7 +13003,8 @@ async function runSend(options) {
                         sourceSession: claimedSession,
                         observation: nativeIdentityObservation,
                         candidateInventory: deferredCodexCandidateInventory,
-                        requestText: String(messageBody)
+                        requestText: String(messageBody),
+                        allowImplicitFreshAuthority: implicitCodexCandidateAuthority
                     })
                     : undefined;
                 if (deferredCodexForegroundBinding) {
@@ -12110,7 +13013,7 @@ async function runSend(options) {
                     currentNativeIdentity = undefined;
                     handoff = { identity: undefined, adopted: false };
                 }
-                else if (stringValue(options.expectedTerminalToken) &&
+                else if ((suppliedExpectedTerminalToken || implicitCodexCandidateAuthority) &&
                     !verifiedEmptyHandoff &&
                     !handoff.adopted) {
                     throw new Error("the expected terminal token no longer authorizes the current " +
@@ -12378,6 +13281,17 @@ async function runSend(options) {
     const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDir, resolvedTerminal.terminalControl, { timeoutMs: 30000 });
     try {
         await withStoreWriterLeaseAsync(storeDir, async () => {
+            const lockedStrictSession = tryLoadManagedSession(storeDir, sessionId);
+            if (lockedStrictSession?.agent === "codex" &&
+                lockedStrictSession.session_id === sessionId &&
+                lockedStrictSession.status === "bound" &&
+                isCompleteNativeRollout(lockedStrictSession.binding?.native_process.rollout)) {
+                throw new Error(`Codex rollout-backed managed Session ${sessionId} cannot use a ` +
+                    "strict session_id send because an open rollout does not prove the " +
+                    "current TUI foreground thread. Refresh AKK list and use its exact " +
+                    "selector plus expected_terminal_token. No Turn was created and no " +
+                    "terminal input was sent.");
+            }
             await recoverLifecycleFenceBeforeMutation({
                 options,
                 terminal: resolvedTerminal
@@ -12398,12 +13312,27 @@ async function runSend(options) {
             }
             assertTerminalIncarnationCanStartTurn(storeDir, resolvedTerminal.terminalControl);
             let currentSession = tryLoadManagedSession(storeDir, sessionId);
-            const knownCodexCompanions = currentSession
+            let knownCodexCompanions = currentSession
                 ? codexAllowedCompanionSetForManagedSession({
                     storeDir,
                     session: currentSession
                 })
                 : { additional: [] };
+            if (currentSession?.agent === "codex" &&
+                knownCodexCompanions.primary) {
+                try {
+                    const inventory = await inspectCodexOpenRootRolloutInventory({
+                        options,
+                        pid: resolvedTerminal.pid,
+                        cwd: resolvedTerminal.terminalControl.currentPath
+                    });
+                    knownCodexCompanions = codexCompanionsPresentInOpenRootInventory(knownCodexCompanions, inventory);
+                }
+                catch {
+                    // Inventory proof is an optimization only. Preserve the existing
+                    // closed /status fence when exact open-root membership is unavailable.
+                }
+            }
             const lockedNativeIdentity = await resolveCurrentNativeAgentSessionIdentity({
                 options,
                 agent: resolvedTerminal.agent,
@@ -16596,6 +17525,11 @@ async function runRenew(options) {
     if (conversation.status !== "stalled") {
         throw new Error(`cannot renew ${conversation.conversation_id}; conversation is ${conversation.status}, not stalled`);
     }
+    if (terminalBridgeSubmission(conversation)?.status === "uncertain") {
+        throw new Error(`cannot renew ${conversation.conversation_id}; its terminal submission ` +
+            "is uncertain and cannot be attributed by monitoring. Inspect the pane " +
+            "and explicitly close the Turn to abandon the unresolved result.");
+    }
     const nativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
@@ -16622,6 +17556,9 @@ async function runRenew(options) {
         if (current.status !== "stalled") {
             throw new Error(`cannot renew ${current.conversation_id}; conversation is ${current.status}, not stalled`);
         }
+        if (terminalBridgeSubmission(current)?.status === "uncertain") {
+            throw new Error(`cannot renew ${current.conversation_id}; its terminal submission is uncertain`);
+        }
         const currentTakeover = isRecord(current.native_session_takeover)
             ? current.native_session_takeover
             : undefined;
@@ -20276,6 +21213,32 @@ function terminalLedgerReceiptCandidate(ledger) {
 }
 function mergeTerminalLedgerReceipt(previous, next) {
     const messageId = required(stringValue(previous.message_id), "terminal dispatch receipt message id is required");
+    const safeAbortRetryGeneration = Boolean(previous.status === "aborted" &&
+        previous.safe_to_retry === true &&
+        stringValue(next.message_id) === messageId &&
+        stringValue(next.previous_generation_id) === messageId &&
+        [
+            "text_injected",
+            "enter_dispatched",
+            "submitted",
+            "agent_accepted",
+            "not_accepted",
+            "uncertain",
+            "aborted"
+        ].includes(String(next.status)) &&
+        validTimestampMs(previous.aborted_at) !== undefined &&
+        validTimestampMs(next.prepared_at) !== undefined &&
+        Date.parse(String(next.prepared_at)) >=
+            Date.parse(String(previous.aborted_at)));
+    if (safeAbortRetryGeneration) {
+        // A proved zero-input abort intentionally allows the same OpenClaw
+        // idempotency key to start one fresh Turn/Session generation. The old
+        // Turn and, for v3, its abort_resolved transfer retain that immutable
+        // proof; the terminal-wide singleton receipt advances to the retry so its
+        // different binding/Turn identity cannot collide with the abandoned
+        // zero-input generation.
+        return next;
+    }
     for (const field of TERMINAL_LEDGER_RECEIPT_IMMUTABLE_FIELDS) {
         const previousValue = previous[field];
         const nextValue = next[field];
@@ -20997,6 +21960,12 @@ function deferredCodexBoundaryFromTransfer({ terminal, transfer }) {
         sourceKind: transfer.version === 1
             ? "status_card_only"
             : required(transfer.source_kind, "deferred foreground source kind is unavailable"),
+        sourceRolloutAuthority: transfer.source_rollout_authority ?? "present",
+        ...(transfer.source_abandonment_fingerprint
+            ? {
+                sourceAbandonmentFingerprint: transfer.source_abandonment_fingerprint
+            }
+            : {}),
         ...(transfer.source_turn_history
             ? { sourceTurnHistory: transfer.source_turn_history }
             : {}),
@@ -21565,6 +22534,11 @@ async function recoverAcceptedDeferredForegroundDispatch({ options, storeDir, te
             statePath: authority.statePath,
             expectedMessageBodyHash: stringValue(authority.submission.message_body_hash)
         });
+        assertFrozenExplicitlyAbandonedPredecessorAuthority({
+            storeDir,
+            transfer,
+            terminalControl: terminal.terminalControl
+        });
         if (![
             "prepared",
             "text_injected",
@@ -23109,6 +24083,56 @@ function codexComposerVisible(screen) {
         .slice(-8)
         .some((line) => /^[›»](?:\s|$)/u.test(line.trimEnd()));
 }
+function codexLatentClearResumeObservation({ screen, agentVersion }) {
+    const behaviorProfile = codexLifecycleBehaviorProfile(agentVersion);
+    if (!behaviorProfile) {
+        return undefined;
+    }
+    const withoutEscapes = (line) => line.replace(/\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/gu, "");
+    const resumePrefix = /^\s*To continue this session, run codex resume\s+(.+?)\s*$/iu;
+    const exactUuid = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/iu;
+    const lines = String(screen ?? "")
+        .split(/\r?\n/u)
+        .slice(-24)
+        .map(withoutEscapes);
+    const resumeIds = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const prefixMatch = resumePrefix.exec(lines[index]);
+        if (!prefixMatch) {
+            continue;
+        }
+        // Codex wraps the UUID after a hyphen in narrow panes. Only join the
+        // immediately following line, strip layout whitespace, and still require
+        // the resulting value to be one exact UUID. This keeps a prose lookalike
+        // or an unrelated scrollback line from becoming routing authority.
+        const firstFragment = prefixMatch[1].replace(/\s+/gu, "");
+        const fragments = [
+            firstFragment,
+            ...(firstFragment.endsWith("-")
+                ? [`${prefixMatch[1]}${lines[index + 1] ?? ""}`.replace(/\s+/gu, "")]
+                : [])
+        ];
+        const matched = fragments.flatMap((candidate) => {
+            const uuidMatch = exactUuid.exec(candidate);
+            return uuidMatch ? [uuidMatch[1].toLowerCase()] : [];
+        })[0];
+        if (matched) {
+            resumeIds.push(matched);
+        }
+    }
+    const sourceNativeThreadId = resumeIds.at(-1);
+    if (!sourceNativeThreadId) {
+        return undefined;
+    }
+    return {
+        sourceNativeThreadId,
+        fingerprint: terminalActionFingerprint({
+            kind: "codex_latent_clear_resume_hint",
+            behavior_profile: behaviorProfile,
+            source_native_thread_id: sourceNativeThreadId
+        })
+    };
+}
 function nativeInspectionComposerEmpty(agent, screen) {
     return agent === "codex"
         ? codexComposerEmpty(screen)