@scotthuang/agent-knock-knock 0.12.6 → 0.12.7

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";
@@ -2600,8 +2601,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 +3330,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 +3354,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 +3411,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 +3498,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 +3748,29 @@ 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;
         const deferredCodexSourceActiveElsewhere = Boolean(deferredCodexSourceNativeThreadId &&
             terminals.some((candidate) => candidate !== terminal &&
                 candidate.agent === "codex" &&
@@ -3750,9 +3779,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 +3835,24 @@ 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));
+                deferredCodexSource?.binding?.native_process.rollout === undefined ||
+                deferredCodexLatentClearResumeFingerprint !== undefined));
         const deferredCodexForegroundEligible = Boolean(mutationsAllowed &&
             !terminalHasNonterminalDeferredTransfer &&
             deferredCodexSource &&
@@ -3799,8 +3860,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 +3881,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 +3898,10 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 processBirth: deferredCodexProcessBirth,
                 sourceSession: deferredCodexSource,
                 dispatchSnapshot: deferredCodexDispatchSnapshot,
+                sourceTurnHistory: deferredCodexCandidateSourceTurnHistory,
+                candidateContextFingerprint: deferredCodexLatentClearResumeFingerprint,
+                sourceRolloutAuthority: deferredCodexSourceRolloutAuthority,
+                sourceAbandonmentFingerprint: deferredCodexSourceAbandonmentFingerprint,
                 ...(deferredCodexCandidateInventory
                     ? { candidateInventory: deferredCodexCandidateInventory }
                     : {})
@@ -4102,6 +4170,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,15 +4215,14 @@ 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
                             }
@@ -4183,9 +4265,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 +5615,13 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 12,
+        version: 14,
         instructions: [
             "Treat terminals[] as the primary resource and use only actions present in available_actions, except the snapshot-bound terminals[].handoff_decision.choices.take_over_current.action and an exact terminals[].blocking_turns[].recovery_action. Either nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
             "An existing managed session's ordinary send targets session_id and creates a new turn. A turn id is never an ordinary send target.",
             "Read-only native-thread listing targets an exact terminal_id. Native-thread new/resume mutations also use the listed expected_binding_token and never create a Turn.",
             "Native inspection is a separate terminal action: use only its closed inspection enum and current exact terminal_id/token; AKK status does not execute a native slash command.",
-            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. A conclusively ended Codex rollout may expose the same snapshot-bound send only after AKK proves zero current rollout and an exact empty composer; it detaches the ended Session and creates an isolated virgin Session. A status-card-only 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, a quiescent rollout-backed source whose complete pinned open-rollout inventory cannot identify one foreground candidate, or a supported Codex /clear foreground hint observed before its new rollout materializes 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. An explicitly closed uncertain Turn may authorize only a future candidate send when its exact resolved close ledger, append-only uncertain receipt, frozen Turn 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.",
@@ -5604,7 +5696,7 @@ 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.",
+                candidate_rollout_deferred_scope: "A quiescent rollout-backed Codex source may use a listed selector/token send when AKK pins the complete exact candidate inventory but cannot prove one foreground UUID, or when a supported /clear foreground hint signals that the sole old rollout is no longer sufficient authority. 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. 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 in the exact Session. A live terminal selector can attach an unmanaged pane, adopt one verified human-selected native context, detach a verified-empty Codex source, or replace an eligible status-card/candidate-rollout source after the submitted request proves its unique exact rollout; an explicit session_id never follows the pane."
             },
             new_thread: {
@@ -5852,7 +5944,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 +6608,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 +7137,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 +7149,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 +7166,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 +7185,68 @@ 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 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
+        });
+        return (!TERMINAL_DISPATCH_RELEASE_STATUSES.has(turn.status) ||
+            managedTurnNeedsAttention(turn) ||
+            (isRecord(turn.callback_delivery) &&
+                !callbackDelivered) ||
+            (Boolean(turn.gateway_method) &&
+                !callbackDelivered &&
+                !explicitlyAbandonedUncertain) ||
+            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 +7255,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 +7265,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 +7497,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, candidateContextFingerprint, sourceRolloutAuthority = "present", sourceAbandonmentFingerprint }) {
     const terminalToken = unmanagedTerminalBindingToken({
         terminalId,
         terminalControl,
@@ -7147,18 +7515,40 @@ 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"
-            : "verified_absent",
+        observation: candidateContextFingerprint
+            ? "latent_codex_thread_reset"
+            : candidateAuthority
+                ? "exact_open_root_inventory"
+                : "verified_absent",
+        ...(sourceTurnHistoryFingerprint
+            ? { source_turn_history_fingerprint: sourceTurnHistoryFingerprint }
+            : {}),
+        ...(candidateContextFingerprint
+            ? { candidate_context_fingerprint: candidateContextFingerprint }
+            : {}),
+        ...(candidateAuthority
+            ? { source_rollout_authority: sourceRolloutAuthority }
+            : {}),
+        ...(sourceAbandonmentFingerprint
+            ? {
+                source_abandonment_fingerprint: sourceAbandonmentFingerprint
+            }
+            : {}),
         ...(candidateAuthority ?? {})
     }))
         .digest("hex");
@@ -7484,7 +7874,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 +7917,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 +7949,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");
         }
@@ -7560,6 +7978,16 @@ async function assertDeferredCodexForegroundBindingBoundary({ options, boundary,
             physicalOnly: boundary.candidateAcceptanceAnchor !== undefined
         })
     });
+    if (requireEmptyComposer && boundary.candidateContextFingerprint) {
+        const currentContextFingerprint = codexLatentClearResumeFingerprint({
+            screen: status.screen.excerpt,
+            sourceNativeThreadId: source.binding?.native_thread_id,
+            agentVersion: agentVersionForRunningProcess("codex", boundary.terminal.pid, options)
+        });
+        if (currentContextFingerprint !== boundary.candidateContextFingerprint) {
+            throw new Error("the Codex /clear foreground hint changed; refresh AKK list before sending");
+        }
+    }
     if (status.reachable !== true ||
         status.approval_state.blocked === true ||
         !["idle", "unknown"].includes(status.activity_state)) {
@@ -7596,6 +8024,35 @@ 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 candidateContextFingerprint = candidateMode &&
+        sourceKind === "candidate_rollout_quiescent"
+        ? await observeCodexLatentClearResumeFingerprint({
+            options,
+            terminal,
+            sourceNativeThreadId: sourceSession.binding.native_thread_id
+        })
+        : undefined;
     const exactSource = !workspace
         ? false
         : sourceKind === "candidate_rollout_quiescent"
@@ -7610,7 +8067,8 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
                     workspace,
                     processUuid: liveIncarnation.processUuid,
                     processBirth: liveIncarnation.processBirth,
-                    inventory: candidateInventory
+                    inventory: candidateInventory,
+                    sourceRolloutAuthority
                 })
             : exactBoundCodexStatusCardSourceForDeferredSend({
                 session: sourceSession,
@@ -7631,7 +8089,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,6 +8102,10 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         processBirth,
         sourceSession,
         dispatchSnapshot,
+        sourceTurnHistory: candidateSourceTurnHistory,
+        candidateContextFingerprint,
+        sourceRolloutAuthority,
+        sourceAbandonmentFingerprint,
         ...(candidateMode ? { candidateInventory } : {})
     });
     if (expectedToken !== token) {
@@ -7666,6 +8131,13 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         processBirth,
         previousDispatchSnapshot: dispatchSnapshot,
         sourceKind,
+        sourceRolloutAuthority,
+        ...(sourceAbandonmentFingerprint
+            ? { sourceAbandonmentFingerprint }
+            : {}),
+        ...(candidateContextFingerprint
+            ? { candidateContextFingerprint }
+            : {}),
         ...(sourceSession.last_transition_id
             ? { sourcePreviousLastTransitionId: sourceSession.last_transition_id }
             : {}),
@@ -7690,6 +8162,51 @@ async function prepareDeferredCodexForegroundBinding({ options, terminal, source
         terminalControl: terminal.terminalControl,
         excludedManagedSessionId: sourceSession.session_id
     });
+    if (sourceRolloutAuthority === "explicitly_abandoned_predecessor" &&
+        !codexCandidateInventoryHasNoOtherManagedClaim({
+            storeDir,
+            inventory: required(candidateInventory, "Codex candidate inventory is unavailable"),
+            sourceSessionId: sourceSession.session_id
+        })) {
+        throw new Error("the post-/clear 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 +8233,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 +8272,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 +8662,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 +8716,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 +8896,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 +9103,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 +9753,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 +9778,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) {
@@ -12398,12 +12945,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,
@@ -12433,6 +12995,11 @@ async function runSend(options) {
             if (!bindingMatchesLiveTerminal(currentSession, resolvedTerminal, lockedNativeIdentity, storeDir)) {
                 throw new Error("managed session identity changed while waiting to send; refresh list and retry");
             }
+            await assertStrictCodexSessionHasNoLatentClear({
+                options,
+                terminal: resolvedTerminal,
+                session: currentSession
+            });
             const logicalLockedNativeIdentity = logicalIdentityForManagedSession({
                 storeDir,
                 session: currentSession,
@@ -16596,6 +17163,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 +17194,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;
@@ -20997,6 +21572,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 +22146,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 +23695,97 @@ 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 codexLatentClearResumeFingerprint({ screen, sourceNativeThreadId, agentVersion }) {
+    if (!isExactNativeThreadId(sourceNativeThreadId)) {
+        return undefined;
+    }
+    const observation = codexLatentClearResumeObservation({
+        screen,
+        agentVersion
+    });
+    return observation?.sourceNativeThreadId === sourceNativeThreadId.toLowerCase()
+        ? observation.fingerprint
+        : undefined;
+}
+async function observeCodexLatentClearResumeFingerprint({ options, terminal, sourceNativeThreadId }) {
+    if (terminal.agent !== "codex" || !isExactNativeThreadId(sourceNativeThreadId)) {
+        return undefined;
+    }
+    const agentVersion = agentVersionForRunningProcess("codex", terminal.pid, options);
+    if (!codexLifecycleBehaviorProfile(agentVersion)) {
+        return undefined;
+    }
+    const status = await createTerminalAgentBridge(options).status("codex", terminal.terminalControl, { runtime: terminalRuntimeForLiveIdentity({ terminal, physicalOnly: true }) });
+    return codexLatentClearResumeFingerprint({
+        screen: status.screen.excerpt,
+        sourceNativeThreadId,
+        agentVersion
+    });
+}
+async function assertStrictCodexSessionHasNoLatentClear({ options, terminal, session }) {
+    if (session.agent !== "codex") {
+        return;
+    }
+    const fingerprint = await observeCodexLatentClearResumeFingerprint({
+        options,
+        terminal,
+        sourceNativeThreadId: session.binding?.native_thread_id
+    });
+    if (fingerprint) {
+        throw new Error("Codex /clear changed the foreground logical thread; refresh AKK list " +
+            "and use its snapshot-bound follow-current send. No task input was sent.");
+    }
+}
 function nativeInspectionComposerEmpty(agent, screen) {
     return agent === "codex"
         ? codexComposerEmpty(screen)