@scotthuang/agent-knock-knock 0.12.2 → 0.12.4

package/dist/src/cli-core.js

@@ -20,13 +20,13 @@ import { createManagedSessionId, createNativeThreadTransitionId, humanObservedHa
 import { classifyCodexLifecyclePostcondition, evaluateResumeCandidateAvailability, hasStrongCodexLifecycleIdentity, isFreshCodexPostProbeScreen } from "./native-thread-lifecycle-policy.js";
 import { createNativeThreadResumeSnapshot, nativeThreadCandidateSnapshotFingerprint, nativeThreadResumeSnapshotRowsMatchCandidates, resolveNativeThreadResumeSelection, saveNativeThreadResumeSnapshot, sortNativeThreadCandidates, terminalActionFingerprint, verifiedPreviousResumeCandidate } from "./native-thread-resume-snapshot.js";
 import { listNativeThreadTransitions, listManagedSessions, loadManagedSession, loadNativeThreadTransition, nativeThreadTransitionsDir, saveManagedSession, saveNativeThreadTransition, tryLoadManagedSession } from "./session-store.js";
-import { createTerminalControlProviderRegistry as createProviderRegistry, StaticTerminalControlProvider, TmuxTerminalControlProvider } from "./terminal-control-provider.js";
+import { createTerminalControlProviderRegistry as createProviderRegistry, StaticTerminalControlProvider, TerminalControlUnavailableError, TmuxTerminalControlProvider } from "./terminal-control-provider.js";
 import { HerdrTerminalControlProvider } from "./herdr-terminal-control-provider.js";
 import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { associateTerminalEndpointEvidence, hasCanonicalTerminalEndpoint, sameTerminalControlEvidenceIncarnation, sameTerminalControlIncarnation, terminalControlEvidence, terminalControlEvidenceMatches, terminalEndpointFromControlRef, terminalEndpointIdentityFromEvidence, terminalEndpointIdentityKey, terminalLegacyRuntimeRoute, sameTerminalEndpointIdentity } from "./terminal-control-ref.js";
 import { createProductionTerminalAgentRegistry } from "./terminal-agent-registry.js";
 import { parseProcessElapsedSeconds, StaticTerminalProcessSource, SystemTerminalProcessSource } from "./terminal-process-source.js";
-import { isExactClaudeNativeInspectionIdleComposer, NativeInspectionSubmissionError, TerminalAgentBridge, TerminalInputNotStartedError } from "./terminal-agent-bridge.js";
+import { isExactClaudeIdleComposer, isExactClaudeNativeInspectionIdleComposer, NativeInspectionSubmissionError, TerminalAgentBridge, TerminalInputNotStartedError } from "./terminal-agent-bridge.js";
 import { evaluateApprovalPolicy } from "./approval-policy.js";
 import { evaluateDoctorCapabilities, runDoctorCapabilityProbes } from "./doctor-capabilities.js";
 import { runOpenClawChainDiagnostics } from "./openclaw-doctor.js";
@@ -96,6 +96,7 @@ const SESSION_SEND_BLOCKING_STATUSES = new Set([
     "callback_failed",
     "cancelling"
 ]);
+const TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON = "a newer terminal submission has an uncertain outcome; inspect the shared terminal pane before continuing";
 const TERMINAL_BRIDGE_MONITOR_LOCK_VERSION = 1;
 const MINIMUM_NODE_VERSION = "22.19.0";
 const PRIVATE_LOCK_FILE_MODE = 0o600;
@@ -2627,7 +2628,7 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
     const stalledConversationIds = [];
     for (const listed of listConversations(storeDir)) {
         if (listed.conversation_id === currentConversationId ||
-            !isActiveStatus(listed.status)) {
+            !SESSION_SEND_BLOCKING_STATUSES.has(listed.status)) {
             continue;
         }
         const listedTakeover = isRecord(listed.native_session_takeover)
@@ -2647,7 +2648,7 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
             const currentTakeover = isRecord(current.native_session_takeover)
                 ? current.native_session_takeover
                 : undefined;
-            if (!isActiveStatus(current.status) ||
+            if (!SESSION_SEND_BLOCKING_STATUSES.has(current.status) ||
                 currentTakeover?.terminal_bridge !== true ||
                 !terminalControlsShareIncarnation(terminalControlFromTakeover(currentTakeover), terminalControl)) {
                 continue;
@@ -2657,12 +2658,13 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
                 ...current,
                 status: "stalled",
                 stalled_at: stalledAt,
-                stalled_reason: "a newer terminal submission has an uncertain outcome; inspect the shared terminal pane before continuing",
+                stalled_reason: TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON,
                 native_session_takeover: {
                     ...currentTakeover,
                     terminal_bridge_uncertain_dispatch_fence: {
                         message_id: uncertainMessageId,
-                        observed_at: stalledAt
+                        observed_at: stalledAt,
+                        previous_status: current.status
                     }
                 },
                 updated_at: stalledAt
@@ -2688,6 +2690,303 @@ function stallOtherTerminalBridgeConversationsForUncertainDispatch({ storeDir, t
     }
     return stalledConversationIds;
 }
+function exactTerminalBridgeCollateralStallRepairEvidence({ conversation, storeDir }) {
+    if (conversation.status !== "stalled" ||
+        conversation.stalled_reason !==
+            TERMINAL_BRIDGE_UNCERTAIN_COLLATERAL_STALL_REASON) {
+        return undefined;
+    }
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const fence = isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence)
+        ? takeover.terminal_bridge_uncertain_dispatch_fence
+        : undefined;
+    const uncertainMessageId = stringValue(fence?.message_id);
+    const fenceObservedAt = stringValue(fence?.observed_at);
+    const previousStatus = stringValue(fence?.previous_status);
+    const ownMessageId = stringValue(takeover?.terminal_bridge_message_id);
+    const ownSubmission = terminalBridgeSubmission(conversation);
+    const completionClaim = isRecord(takeover?.terminal_bridge_completion_claim)
+        ? takeover.terminal_bridge_completion_claim
+        : undefined;
+    const callbackDelivery = isRecord(conversation.callback_delivery)
+        ? conversation.callback_delivery
+        : undefined;
+    const callbackMessage = isRecord(callbackDelivery?.message)
+        ? callbackDelivery.message
+        : undefined;
+    const idleSince = stringValue(conversation.idle_since);
+    const deliveredAt = stringValue(callbackDelivery?.delivered_at);
+    const claimedAt = stringValue(completionClaim?.claimed_at);
+    const fenceAtMs = validTimestampMs(fenceObservedAt);
+    const idleAtMs = validTimestampMs(idleSince);
+    const deliveredAtMs = validTimestampMs(deliveredAt);
+    const claimedAtMs = validTimestampMs(claimedAt);
+    if (takeover?.terminal_bridge !== true ||
+        !uncertainMessageId ||
+        !fenceObservedAt ||
+        fenceAtMs === undefined ||
+        uncertainMessageId === ownMessageId ||
+        (previousStatus !== undefined && previousStatus !== "idle") ||
+        conversation.stalled_at !== fenceObservedAt ||
+        conversation.updated_at !== fenceObservedAt ||
+        !idleSince ||
+        idleAtMs === undefined ||
+        idleAtMs > fenceAtMs ||
+        !ownMessageId ||
+        ownSubmission?.status !== "agent_accepted" ||
+        stringValue(ownSubmission.message_id) !== ownMessageId ||
+        stringValue(ownSubmission.session_id) !==
+            sessionIdForConversation(conversation) ||
+        stringValue(ownSubmission.turn_id) !== turnIdForConversation(conversation) ||
+        !completionClaim ||
+        stringValue(completionClaim.terminal_bridge_message_id) !== ownMessageId ||
+        completionClaim.outcome !== "success" ||
+        !claimedAt ||
+        claimedAtMs === undefined ||
+        claimedAtMs > fenceAtMs ||
+        callbackDelivery?.status !== "delivered" ||
+        callbackDelivery.final_status !== "idle" ||
+        callbackDelivery.preserve_conversation_status !== true ||
+        !callbackMessage ||
+        callbackMessage.type !== "done" ||
+        callbackMessage.requires_response !== false ||
+        stringValue(callbackMessage.id) !==
+            stringValue(completionClaim.callback_message_id) ||
+        stringValue(callbackMessage.conversation_id) !==
+            conversation.conversation_id ||
+        stringValue(callbackMessage.session_id) !==
+            sessionIdForConversation(conversation) ||
+        stringValue(callbackMessage.turn_id) !== turnIdForConversation(conversation) ||
+        stringValue(isRecord(callbackMessage.metadata)
+            ? callbackMessage.metadata.terminal_bridge_message_id
+            : undefined) !== ownMessageId ||
+        !deliveredAt ||
+        deliveredAtMs === undefined ||
+        deliveredAtMs > fenceAtMs) {
+        return undefined;
+    }
+    const control = terminalControlForManagedConversation(conversation);
+    if (!control) {
+        return undefined;
+    }
+    // The target state lock is already held by the caller. Rescan owner state
+    // now instead of trusting the unlocked discovery snapshot used to find the
+    // target candidate.
+    const ownerCandidates = listConversations(storeDir).filter((candidate) => {
+        if (candidate.conversation_id === conversation.conversation_id) {
+            return false;
+        }
+        const candidateTakeover = isRecord(candidate.native_session_takeover)
+            ? candidate.native_session_takeover
+            : undefined;
+        const candidateSubmission = terminalBridgeSubmission(candidate);
+        return candidateTakeover?.terminal_bridge === true &&
+            stringValue(candidateTakeover.terminal_bridge_message_id) ===
+                uncertainMessageId &&
+            stringValue(candidateSubmission?.message_id) === uncertainMessageId &&
+            terminalControlsShareIncarnation(terminalControlForManagedConversation(candidate), control);
+    });
+    if (ownerCandidates.length !== 1) {
+        return undefined;
+    }
+    const ownerListed = ownerCandidates[0];
+    const ownerStatePath = stringValue(ownerListed.state_path);
+    if (!ownerStatePath) {
+        return undefined;
+    }
+    let owner;
+    let ownerEvents;
+    let events;
+    try {
+        owner = loadState(ownerStatePath);
+        ownerEvents = readNdjsonLog(stringValue(owner.event_log_path) ?? logPathForStatePath(ownerStatePath));
+        const statePath = stringValue(conversation.state_path);
+        if (!statePath) {
+            return undefined;
+        }
+        events = readNdjsonLog(stringValue(conversation.event_log_path) ??
+            logPathForStatePath(statePath));
+    }
+    catch {
+        return undefined;
+    }
+    const ownerTakeover = isRecord(owner.native_session_takeover)
+        ? owner.native_session_takeover
+        : undefined;
+    const ownerSubmission = terminalBridgeSubmission(owner);
+    const ownerClosedAt = stringValue(owner.closed_at);
+    const ownerClosedAtMs = validTimestampMs(ownerClosedAt);
+    if (owner.conversation_id !== ownerListed.conversation_id ||
+        owner.status !== "closed" ||
+        !ownerClosedAt ||
+        ownerClosedAtMs === undefined ||
+        ownerClosedAtMs < fenceAtMs ||
+        !stringValue(owner.close_reason) ||
+        owner.updated_at !== ownerClosedAt ||
+        ownerTakeover?.terminal_bridge !== true ||
+        stringValue(ownerTakeover.terminal_bridge_message_id) !==
+            uncertainMessageId ||
+        ownerSubmission?.status !== "uncertain" ||
+        stringValue(ownerSubmission.message_id) !== uncertainMessageId ||
+        stringValue(ownerSubmission.session_id) !== sessionIdForConversation(owner) ||
+        stringValue(ownerSubmission.turn_id) !== turnIdForConversation(owner) ||
+        isRecord(ownerTakeover.terminal_bridge_uncertain_dispatch_fence) ||
+        !terminalControlsShareIncarnation(terminalControlForManagedConversation(owner), control)) {
+        return undefined;
+    }
+    const callbackMessageId = stringValue(callbackMessage.id);
+    const hasCompletionClaim = events.some((event) => event.event === "terminal_bridge_completion_claimed" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.terminal_bridge_message_id === ownMessageId &&
+        event.callback_message_id === callbackMessageId &&
+        event.completion_fingerprint === completionClaim.completion_fingerprint &&
+        event.completion_id === completionClaim.completion_id &&
+        event.outcome === "success" &&
+        event.ts === claimedAt);
+    const hasCompletionDetected = events.some((event) => event.event === "terminal_bridge_completion_detected" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.terminal_bridge_message_id === ownMessageId &&
+        event.callback_message_id === callbackMessageId &&
+        event.completion_id === completionClaim.completion_id &&
+        event.completion_outcome === "success" &&
+        validTimestampMs(event.ts) !== undefined &&
+        validTimestampMs(event.ts) <= fenceAtMs);
+    const hasDeliveredCallback = events.some((event) => event.event === "callback_delivery_succeeded" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.message_id === callbackMessageId &&
+        event.status === "idle" &&
+        event.ts === deliveredAt);
+    const hasExactFence = events.some((event) => event.event === "terminal_bridge_stalled_by_uncertain_dispatch" &&
+        event.conversation_id === conversation.conversation_id &&
+        event.uncertain_message_id === uncertainMessageId &&
+        event.ts === fenceObservedAt);
+    const hasExactOwnerClose = ownerEvents.some((event) => event.event === "conversation_closed" &&
+        event.conversation_id === owner.conversation_id &&
+        event.status === "closed" &&
+        event.ts === ownerClosedAt &&
+        event.reason === owner.close_reason);
+    if (!hasCompletionClaim ||
+        !hasCompletionDetected ||
+        !hasDeliveredCallback ||
+        !hasExactFence ||
+        !hasExactOwnerClose) {
+        return undefined;
+    }
+    return {
+        uncertainMessageId,
+        ownerConversationId: owner.conversation_id,
+        restoredStatus: "idle"
+    };
+}
+function reconcileTerminalBridgeCollateralStalls(storeDir, conversationId) {
+    const candidates = listConversations(storeDir).filter((conversation) => {
+        const takeover = isRecord(conversation.native_session_takeover)
+            ? conversation.native_session_takeover
+            : undefined;
+        return (conversationId === undefined ||
+            conversation.conversation_id === conversationId) &&
+            conversation.status === "stalled" &&
+            isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence);
+    });
+    let repaired = 0;
+    let skipped = 0;
+    const errors = [];
+    const items = [];
+    for (const listed of candidates) {
+        const statePath = stringValue(listed.state_path);
+        if (!statePath) {
+            skipped += 1;
+            continue;
+        }
+        let releaseStateLock;
+        try {
+            releaseStateLock = acquireFileLock(`${statePath}.lock`);
+            const current = loadState(statePath);
+            const evidence = exactTerminalBridgeCollateralStallRepairEvidence({
+                conversation: current,
+                storeDir
+            });
+            if (!evidence) {
+                skipped += 1;
+                continue;
+            }
+            const takeover = {
+                ...current.native_session_takeover
+            };
+            delete takeover.terminal_bridge_uncertain_dispatch_fence;
+            const repairedAt = cliNow().toISOString();
+            takeover.terminal_bridge_collateral_stall_repair = {
+                repaired_at: repairedAt,
+                uncertain_message_id: evidence.uncertainMessageId,
+                uncertain_owner_conversation_id: evidence.ownerConversationId,
+                restored_status: evidence.restoredStatus,
+                evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
+            };
+            const repairedConversation = {
+                ...current,
+                status: evidence.restoredStatus,
+                native_session_takeover: takeover,
+                updated_at: repairedAt
+            };
+            delete repairedConversation.stalled_at;
+            delete repairedConversation.stalled_reason;
+            saveState(statePath, repairedConversation);
+            let eventWarning;
+            try {
+                appendEvent(stringValue(current.event_log_path) ?? logPathForStatePath(statePath), {
+                    ts: repairedAt,
+                    conversation_id: current.conversation_id,
+                    event: "terminal_bridge_collateral_stall_repaired",
+                    uncertain_message_id: evidence.uncertainMessageId,
+                    uncertain_owner_conversation_id: evidence.ownerConversationId,
+                    previous_status: "stalled",
+                    restored_status: evidence.restoredStatus,
+                    evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
+                });
+            }
+            catch (error) {
+                eventWarning = error instanceof Error ? error.message : String(error);
+                runtimeLog("warn", "terminal_bridge_collateral_stall_repair_event_failed", {
+                    conversation_id: current.conversation_id,
+                    uncertain_message_id: evidence.uncertainMessageId,
+                    error: eventWarning
+                });
+            }
+            repaired += 1;
+            items.push({
+                conversation_id: current.conversation_id,
+                status: "repaired",
+                reason: "legacy_terminal_bridge_collateral_stall",
+                uncertain_message_id: evidence.uncertainMessageId,
+                uncertain_owner_conversation_id: evidence.ownerConversationId,
+                restored_status: evidence.restoredStatus,
+                ...(eventWarning ? { event_warning: eventWarning } : {})
+            });
+        }
+        catch (error) {
+            skipped += 1;
+            const reason = error instanceof Error ? error.message : String(error);
+            errors.push(`${listed.conversation_id}: ${reason}`);
+            items.push({
+                conversation_id: listed.conversation_id,
+                status: "error",
+                reason
+            });
+        }
+        finally {
+            releaseStateLock?.();
+        }
+    }
+    return {
+        checked: candidates.length,
+        repaired,
+        skipped,
+        errors,
+        items
+    };
+}
 function environmentWithoutGatewayTokens() {
     const environment = { ...cliEnv() };
     delete environment.AKK_GATEWAY_TOKEN;
@@ -2768,17 +3067,21 @@ async function reconcileStoreForList(storeDir, options) {
         }
         throw error;
     }
-    const idle = reconcileIdleConversations(storeDir, options);
     const monitors = await reconcileMonitors(options, {
         includeCallbackRecovery: false,
         reason: "list_reconciliation",
         conversationId: undefined
     });
+    const idle = reconcileIdleConversations(storeDir, options);
     return {
         status: "completed",
         checked: Math.max(idle.checked, monitors.checked),
-        changed: idle.closed + monitors.launched,
+        changed: idle.closed + monitors.launched + monitors.repaired,
         closed: idle.closed,
+        repaired: monitors.repaired,
+        collateral_stalls_checked: monitors.collateral_stalls_checked,
+        collateral_stalls_skipped: monitors.collateral_stalls_skipped,
+        collateral_stall_repairs: monitors.items.filter((item) => item.status === "repaired"),
         monitors_launched: monitors.launched,
         monitors_already_running: monitors.already_running,
         skipped: idle.skipped + monitors.skipped,
@@ -2916,24 +3219,24 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             });
         }
     }
-    let nativeAgentIdentity;
-    try {
-        nativeAgentIdentity = await resolveCurrentNativeAgentSessionIdentity({
-            options,
-            agent: session.agent,
-            pid: session.pid,
-            cwd: session.cwd ?? terminalControl.currentPath,
-            preferredSessionId: codexIdentityContext?.preferredSessionId,
-            allowedCompanionIdentity: codexIdentityContext?.companions.primary,
-            allowedAdditionalIdentities: codexIdentityContext?.companions.additional
-        });
-    }
-    catch (error) {
+    const nativeIdentityObservation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: session.agent,
+        pid: session.pid,
+        cwd: session.cwd ?? terminalControl.currentPath,
+        preferredSessionId: codexIdentityContext?.preferredSessionId,
+        allowedCompanionIdentity: codexIdentityContext?.companions.primary,
+        allowedAdditionalIdentities: codexIdentityContext?.companions.additional
+    });
+    const nativeAgentIdentity = nativeIdentityObservation.status === "resolved"
+        ? nativeIdentityObservation.identity
+        : undefined;
+    if (nativeIdentityObservation.status === "unavailable") {
         runtimeLog("warn", "terminal_native_session_identity_unavailable", {
             agent: session.agent,
             terminal_target: terminalControl.target,
             pid: session.pid,
-            error: error instanceof Error ? error.message : String(error)
+            error: nativeIdentityObservation.reason
         });
     }
     let nativeProcessUuid = nativeAgentIdentity?.processUuid;
@@ -2999,27 +3302,25 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
     });
     const codexLifecycleIncarnationAvailable = session.agent !== "codex" ||
         Boolean(nativeProcessUuid && nativeProcessBirth);
-    const nativeInspectionHasBlockingTurn = listConversations(storeDirFromOptions(options)).some((turn) => isDiscoverableTmuxConversation(turn) &&
-        terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
-    let nativeInspectionComposerReady = nativeInspectionComposerEmpty(session.agent, terminalState.screen_excerpt);
+    const terminalHasBlockingTurn = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminalControl).length > 0;
+    let automatedInputComposerReady = nativeInspectionComposerEmpty(session.agent, terminalState.screen_excerpt);
     if (session.agent === "codex" &&
-        terminalState.activity_state === "idle" &&
+        (terminalState.activity_state === "idle" ||
+            (terminalState.activity_state === "unknown" &&
+                nativeIdentityObservation.status === "verified_absent")) &&
         terminalState.approval_state.blocked !== true &&
-        nativeInspectionCapability.status === "supported" &&
-        nativeInspectionCapability.statusInspection === true &&
         terminalControl.capabilities.includes("send_keys") &&
         terminalControl.capabilities.includes("screen_status")) {
         try {
             const provider = createTerminalControlProvider(options);
             const resolvedTerminal = await provider.resolve(provider.endpoint(terminalControl));
             const styledScreen = await provider.capture(resolvedTerminal, { scrollbackLines: 40, preserveEscapes: true });
-            nativeInspectionComposerReady = codexStyledComposerEmpty(styledScreen);
+            automatedInputComposerReady = codexStyledComposerEmpty(styledScreen);
         }
         catch {
             // Advertising an input action is optional. The action itself repeats the
             // same styled composer proof under the terminal lock before any input.
-            nativeInspectionComposerReady = false;
+            automatedInputComposerReady = false;
         }
     }
     const entry = {
@@ -3040,6 +3341,14 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         native_agent_process_birth: nativeProcessBirth,
         native_agent_rollout: nativeAgentIdentity?.rollout,
         native_agent_identity_evidence: nativeProcessEvidence,
+        native_agent_identity_observation: {
+            status: nativeIdentityObservation.status,
+            ...(nativeIdentityObservation.status === "unavailable"
+                ? { reason: nativeIdentityObservation.reason }
+                : nativeIdentityObservation.status === "verified_absent"
+                    ? { evidence: nativeIdentityObservation.evidence }
+                    : {})
+        },
         agent_version: agentVersion,
         native_thread_lifecycle: lifecycleCapability,
         native_inspection: nativeInspectionCapability,
@@ -3050,6 +3359,10 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         approval_state: terminalState.approval_state,
         activity_state: terminalState.activity_state,
         activity_reason: terminalState.activity_reason,
+        // Internal action-projection evidence. terminalFirstListProjection strips
+        // this field after gating every automated-input action that can follow a
+        // human native-thread switch.
+        _automated_input_composer_ready: automatedInputComposerReady,
         ...(orphanedDispatch
             ? {
                 orphaned_terminal_dispatch: {
@@ -3066,7 +3379,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             }
             : {}),
         commands: {
-            send: true,
+            send: !terminalHasBlockingTurn,
             approve: terminalControl.capabilities.includes("terminal_approval") &&
                 terminalState.approval_state.approvable === true,
             status: true,
@@ -3074,13 +3387,15 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             close: orphanedDispatch !== undefined,
             new_thread: lifecycleCapability.status === "supported" &&
                 lifecycleCapability.newThread === true &&
-                codexLifecycleIncarnationAvailable,
+                codexLifecycleIncarnationAvailable &&
+                !terminalHasBlockingTurn,
             list_resumable_threads: lifecycleCapability.status === "supported" &&
                 lifecycleCapability.resumeExact === true &&
                 codexLifecycleIncarnationAvailable,
             native_inspect: nativeInspectionCapability.status === "supported" &&
                 nativeInspectionCapability.statusInspection === true &&
-                nativeInspectionComposerReady &&
+                terminalState.activity_state === "idle" &&
+                automatedInputComposerReady &&
                 terminalControl.capabilities.includes("send_keys") &&
                 terminalControl.capabilities.includes("screen_status") &&
                 (session.agent === "codex"
@@ -3088,7 +3403,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
                     : Boolean(nativeAgentIdentity?.sessionId &&
                         nativeAgentIdentity.processUuid)) &&
                 orphanedDispatch === undefined &&
-                !nativeInspectionHasBlockingTurn
+                !terminalHasBlockingTurn
         }
     };
     const availableActions = availableListActions(entry);
@@ -3106,6 +3421,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         return control ? [control] : [];
     });
     const projectedTerminals = terminals.map((terminal) => {
+        const { _automated_input_composer_ready: automatedInputComposerReady, ...publicTerminal } = terminal;
         const terminalControl = isRecord(terminal.terminal_control)
             ? terminal.terminal_control
             : undefined;
@@ -3269,6 +3585,79 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             })
             : undefined;
         const blockingHandoffTurns = conflictingSessionTurns.filter((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+        const terminalBlockingTurns = terminalControl
+            ? terminalIncarnationBlockingTurns(storeDir, terminalControl, allRelated)
+            : [];
+        const externalHandoffSourceSessionIds = new Set(conflictingBoundSessionClaims
+            .filter(({ kind }) => kind === "live_external_thread_change")
+            .map(({ session }) => session.session_id));
+        const handoffSourceBlockingTurns = terminalBlockingTurns.filter((turn) => externalHandoffSourceSessionIds.has(sessionIdForConversation(turn)));
+        const nativeIdentityObservation = isRecord(terminal.native_agent_identity_observation)
+            ? terminal.native_agent_identity_observation
+            : undefined;
+        const verifiedEmptyProcessUuid = stringValue(terminal.native_agent_process_uuid);
+        const verifiedEmptyProcessBirth = stringValue(terminal.native_agent_process_birth);
+        const verifiedEmptyWorkspace = stringValue(terminal.workspace ?? terminal.cwd);
+        const verifiedEmptySourceNativeThreadId = stringValue(soleBindingConflict?.session.binding?.native_thread_id)?.toLowerCase();
+        const verifiedEmptySourceActiveElsewhere = Boolean(verifiedEmptySourceNativeThreadId &&
+            terminals.some((candidate) => candidate !== terminal &&
+                candidate.agent === "codex" &&
+                stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
+                    verifiedEmptySourceNativeThreadId));
+        const verifiedEmptyRawSendAction = isRecord(rawActions.send)
+            ? rawActions.send
+            : {
+                tool: "agent_knock_knock_send",
+                arguments: { selector: stringValue(terminal.id) },
+                missing_required: ["request"]
+            };
+        const verifiedEmptyCodexHandoffEligible = Boolean(mutationsAllowed &&
+            terminal.agent === "codex" &&
+            terminalControl &&
+            discoveredOwnership.state === "none" &&
+            unresolvedSessionClaims.length === 0 &&
+            matchingSessions.length === 0 &&
+            soleBindingConflict?.kind === "unverifiable" &&
+            nativeIdentityObservation?.status === "verified_absent" &&
+            verifiedEmptyProcessUuid &&
+            verifiedEmptyProcessBirth &&
+            verifiedEmptyWorkspace &&
+            exactBoundCodexSourceForVerifiedEmptyHandoff({
+                session: soleBindingConflict.session,
+                terminalId: String(terminal.id),
+                terminalControl,
+                pid: Number(terminal.pid),
+                workspace: verifiedEmptyWorkspace,
+                processUuid: verifiedEmptyProcessUuid,
+                processBirth: verifiedEmptyProcessBirth
+            }) &&
+            ["idle", "unknown"].includes(String(terminal.activity_state)) &&
+            automatedInputComposerReady === true &&
+            !(isRecord(terminal.approval_state) &&
+                terminal.approval_state.blocked === true) &&
+            blockingHandoffTurns.length === 0 &&
+            terminalBlockingTurns.length === 0 &&
+            !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
+            !verifiedEmptySourceActiveElsewhere &&
+            terminal.orphaned_terminal_dispatch === undefined &&
+            terminalControl?.capabilities.includes("send_keys") &&
+            terminalControl.capabilities.includes("screen_status"));
+        const verifiedEmptyCodexSnapshotToken = verifiedEmptyCodexHandoffEligible &&
+            terminalControl &&
+            soleBindingConflict &&
+            verifiedEmptyProcessUuid &&
+            verifiedEmptyProcessBirth &&
+            verifiedEmptyWorkspace
+            ? verifiedEmptyCodexHandoffToken({
+                terminalId: String(terminal.id),
+                terminalControl,
+                pid: Number(terminal.pid),
+                workspace: verifiedEmptyWorkspace,
+                processUuid: verifiedEmptyProcessUuid,
+                processBirth: verifiedEmptyProcessBirth,
+                sourceSession: soleBindingConflict.session
+            })
+            : undefined;
         const reconcileBindingAction = mutationsAllowed &&
             discoveredOwnership.state === "none" &&
             unresolvedSessionClaims.length === 0 &&
@@ -3282,6 +3671,7 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !conflictingSessionTurns.some((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status)) &&
+            terminalBlockingTurns.length === 0 &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session)
             ? {
                 tool: "agent_knock_knock_reconcile_binding",
@@ -3300,9 +3690,11 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             unresolvedSessionClaims.length === 0 &&
             soleBindingConflict?.kind === "live_external_thread_change" &&
             terminal.activity_state === "idle" &&
+            automatedInputComposerReady === true &&
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !conflictingSessionTurns.some((turn) => SESSION_SEND_BLOCKING_STATUSES.has(turn.status)) &&
+            terminalBlockingTurns.length === 0 &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
             externalHandoffTarget?.status === "eligible" &&
             isRecord(rawActions.send) &&
@@ -3314,7 +3706,8 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
             !(isRecord(terminal.approval_state) &&
                 terminal.approval_state.blocked === true) &&
             !managedSessionHasUnresolvedNativeTransition(storeDir, soleBindingConflict.session) &&
-            blockingHandoffTurns.length === 1
+            blockingHandoffTurns.length === 1 &&
+            terminalBlockingTurns.every((turn) => turn.conversation_id === blockingHandoffTurns[0].conversation_id)
             ? blockingHandoffTurns[0]
             : undefined;
         const handoffDecisionToken = handoffDecisionTurn &&
@@ -3354,6 +3747,14 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 }
             }
             : undefined;
+        const blockingHandoffTurnIds = new Set(handoffSourceBlockingTurns.map((turn) => turn.conversation_id));
+        // An active source Turn may be superseded only through the snapshot-bound
+        // handoff decision above. Never expose the generic Store-only close action
+        // for that Turn, because doing so would bypass expected_handoff_token after
+        // the live native thread or Turn generation changed. `blocking_turns` is
+        // reserved for other same-incarnation blockers such as legacy collateral
+        // stalls; clear those first, refresh, and only then decide the handoff.
+        const terminalRecoveryBlockingTurns = terminalBlockingTurns.filter((turn) => !blockingHandoffTurnIds.has(turn.conversation_id));
         const terminalCanAcceptSend = ownership.state === "none" && isRecord(sessionAwareRawActions.send);
         if (ownership.state === "current" &&
             !allRelated.some((conversation) => conversation.conversation_id === ownership.conversation.conversation_id)) {
@@ -3390,9 +3791,12 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const currentTurnValue = ownership.state === "current"
             ? currentManagedTurnForTerminal(ownership.conversation, terminal, sessionAwareRawActions)
             : undefined;
-        const currentTurn = currentTurnValue && !mutationsAllowed
+        const currentTurnProjection = currentTurnValue && !mutationsAllowed
             ? readOnlyManagedTurn(currentTurnValue)
             : currentTurnValue;
+        const currentTurn = currentTurnProjection
+            ? withoutGenericHandoffSourceClose(currentTurnProjection, blockingHandoffTurnIds)
+            : undefined;
         const sortedDisplayed = [...sessionDisplayedRelated]
             .filter((conversation) => conversation.conversation_id !== currentTurn?.conversation_id)
             .sort(compareManagedConversationRecency);
@@ -3400,15 +3804,18 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         const recentTurnValue = recentConversation
             ? historicalManagedTurnForTerminal(recentConversation, terminalCanAcceptSend, terminal)
             : undefined;
-        const recentTurn = recentTurnValue && !mutationsAllowed
+        const recentTurnProjection = recentTurnValue && !mutationsAllowed
             ? readOnlyManagedTurn(recentTurnValue)
             : recentTurnValue;
+        const recentTurn = recentTurnProjection
+            ? withoutGenericHandoffSourceClose(recentTurnProjection, blockingHandoffTurnIds)
+            : undefined;
         const historyConversations = includeAll
             ? sortedDisplayed.filter((conversation) => conversation.conversation_id !== recentConversation?.conversation_id)
             : [];
         const history = historyConversations.map((conversation) => {
             const turn = historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal);
-            return mutationsAllowed ? turn : readOnlyManagedTurn(turn);
+            return withoutGenericHandoffSourceClose(mutationsAllowed ? turn : readOnlyManagedTurn(turn), blockingHandoffTurnIds);
         });
         const visibleTurnIds = new Set([currentTurn, recentTurn, ...history]
             .map((turn) => stringValue(turn?.conversation_id))
@@ -3455,6 +3862,19 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                             }
                         }
                         : {}),
+                    ...(verifiedEmptyCodexSnapshotToken
+                        ? {
+                            send: {
+                                ...verifiedEmptyRawSendAction,
+                                arguments: {
+                                    ...(isRecord(verifiedEmptyRawSendAction.arguments)
+                                        ? verifiedEmptyRawSendAction.arguments
+                                        : {}),
+                                    expected_terminal_token: verifiedEmptyCodexSnapshotToken
+                                }
+                            }
+                        }
+                        : {}),
                     ...(reconcileBindingAction
                         ? { reconcile_binding: reconcileBindingAction }
                         : {})
@@ -3482,8 +3902,19 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                 lifecycle_binding_token: managedSessionBindingToken(authoritativeSession)
             }
             : {};
+        const publicManagementConflict = ownership.state === "conflict" && verifiedEmptyCodexSnapshotToken
+            ? {
+                ...ownership.conflict,
+                kind: "verified_empty_native_session",
+                reason: "the previously bound Codex rollout is conclusively closed " +
+                    "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;
         return {
-            ...terminal,
+            ...publicTerminal,
             ...authoritativeIdentity,
             management_state: ownership.state === "conflict"
                 ? "conflict"
@@ -3491,16 +3922,52 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
                     ? "managed"
                     : "unmanaged",
             ...(ownership.state === "conflict"
-                ? { management_conflict: ownership.conflict }
+                ? { management_conflict: publicManagementConflict }
                 : {}),
             ...(externalHandoffDetected
                 ? {
                     handoff_state: externalHandoffAdoptable
                         ? "external_handoff_adoptable"
-                        : "external_handoff_blocked"
+                        : "external_handoff_blocked",
+                    ...(terminalRecoveryBlockingTurns.length > 0
+                        ? {
+                            handoff_blocked_reason: "the terminal has unresolved managed Turn state; use only a listed blocking_turns recovery action"
+                        }
+                        : handoffDecision
+                            ? {
+                                handoff_blocked_reason: "the source Session has one active Turn; use only the snapshot-bound handoff_decision after explicit confirmation"
+                            }
+                            : handoffSourceBlockingTurns.length > 0
+                                ? {
+                                    handoff_blocked_reason: "the conflicting source Session has unresolved Turn state but no snapshot-bound handoff decision is currently safe; inspect the conflict and refresh"
+                                }
+                                : automatedInputComposerReady !== true
+                                    ? {
+                                        handoff_blocked_reason: "the current terminal composer is not an exact empty idle frame"
+                                    }
+                                    : {})
                 }
                 : {}),
+            ...(verifiedEmptyCodexSnapshotToken
+                ? { handoff_state: "verified_empty_native_session_adoptable" }
+                : {}),
             ...(handoffDecision ? { handoff_decision: handoffDecision } : {}),
+            ...(terminalRecoveryBlockingTurns.length > 0
+                ? {
+                    blocking_turns: terminalRecoveryBlockingTurns.map((turn) => ({
+                        session_id: sessionIdForConversation(turn),
+                        turn_id: turnIdForConversation(turn),
+                        status: turn.status,
+                        recovery_action: {
+                            tool: "agent_knock_knock_close",
+                            arguments: {
+                                turn_id: turnIdForConversation(turn)
+                            },
+                            requires_explicit_user_confirmation: true
+                        }
+                    }))
+                }
+                : {}),
             managed: management,
             available_actions: availableActions
         };
@@ -3743,6 +4210,21 @@ function terminalControlForManagedConversation(conversation) {
         ? conversation.native_session_takeover
         : undefined);
 }
+function terminalIncarnationBlockingTurns(storeDir, terminalControl, conversations = listConversations(storeDir)) {
+    return conversations
+        .filter(isDiscoverableTmuxConversation)
+        .filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminalControl) &&
+        SESSION_SEND_BLOCKING_STATUSES.has(turn.status))
+        .sort(compareManagedConversationRecency);
+}
+function assertTerminalIncarnationCanStartTurn(storeDir, terminalControl) {
+    const blocker = terminalIncarnationBlockingTurns(storeDir, terminalControl)[0];
+    if (!blocker) {
+        return;
+    }
+    throw new Error(`terminal ${terminalControl.target} still has unresolved Turn ` +
+        `${turnIdForConversation(blocker)} (${blocker.status})`);
+}
 function compareManagedConversationRecency(left, right) {
     const leftTime = Date.parse(String(left.updated_at ?? left.created_at ?? ""));
     const rightTime = Date.parse(String(right.updated_at ?? right.created_at ?? ""));
@@ -3962,6 +4444,20 @@ function readOnlyManagedTurn(managedTurn) {
             : {})
     };
 }
+function withoutGenericHandoffSourceClose(managedTurn, blockingHandoffTurnIds) {
+    const conversationId = stringValue(managedTurn.conversation_id);
+    if (!conversationId || !blockingHandoffTurnIds.has(conversationId)) {
+        return managedTurn;
+    }
+    const availableActions = isRecord(managedTurn.available_actions)
+        ? managedTurn.available_actions
+        : {};
+    const { close: _genericClose, ...safeActions } = availableActions;
+    return {
+        ...managedTurn,
+        available_actions: safeActions
+    };
+}
 function historicalManagedTurnForTerminal(conversation, terminalCanAcceptSend, terminal) {
     const managedTurn = managedTurnListEntry(summarizeConversation(conversation), {
         terminalBridge: terminalBridgeEnabled(conversation),
@@ -4199,13 +4695,13 @@ function managedListApprovalState(conversation) {
 }
 function listActionContracts() {
     return {
-        version: 8,
+        version: 10,
         instructions: [
-            "Treat terminals[] as the primary resource and use only actions present in available_actions, except the snapshot-bound terminals[].handoff_decision.choices.take_over_current.action. That nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
+            "Treat terminals[] as the primary resource and use only actions present in available_actions, except the snapshot-bound terminals[].handoff_decision.choices.take_over_current.action and an exact terminals[].blocking_turns[].recovery_action. Either nested action requires explicit user confirmation; after it succeeds, refresh list before any follow-current send.",
             "An existing managed session's ordinary send targets session_id and creates a new turn. A turn id is never an ordinary send target.",
             "Read-only native-thread listing targets an exact terminal_id. Native-thread new/resume mutations also use the listed expected_binding_token and never create a Turn.",
             "Native inspection is a separate terminal action: use only its closed inspection enum and current exact terminal_id/token; AKK status does not execute a native slash command.",
-            "A verified, idle human native-thread switch may expose a terminal-scoped send with expected_terminal_token; that action atomically adopts the live context before creating its Turn. 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. 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.",
@@ -4239,11 +4735,28 @@ function listActionContracts() {
                 meaning: "currently_safe_actions",
                 authoritative_for_tool_calls: true
             },
+            native_agent_identity_observation: {
+                meaning: "the latest bounded native identity probe; verified_absent is distinct from an unavailable resolver",
+                authoritative_for_tool_calls: false
+            },
+            management_conflict: {
+                verified_empty_native_session: "a previously bound Codex rollout is conclusively closed; only the exact snapshot-bound send in available_actions may detach it and create an isolated virgin Session"
+            },
+            handoff_state: {
+                meaning: "why a conflict-scoped follow-current send is available or blocked",
+                verified_empty_native_session_adoptable: "the exact current terminal snapshot permits the listed conflict send; availability is revalidated before terminal input"
+            },
             handoff_decision: {
                 meaning: "an explicit human choice required before superseding an active source Turn",
                 authoritative_action_path: "terminals[].handoff_decision.choices.take_over_current.action",
                 requires_explicit_user_confirmation: true,
                 after_success: "refresh list before using a follow-current send action"
+            },
+            blocking_turns: {
+                meaning: "terminal-incarnation-wide collateral unresolved managed Turns that suppress send, lifecycle, and native-inspection actions; an active human-handoff source Turn is never listed here and remains governed only by handoff_decision",
+                authoritative_action_path: "terminals[].blocking_turns[].recovery_action",
+                requires_explicit_user_confirmation: true,
+                after_success: "refresh list before using any terminal action"
             }
         },
         actions: {
@@ -4262,7 +4775,7 @@ function listActionContracts() {
                     "agentHardTimeoutMinutes"
                 ],
                 unsupported: ["timeoutSeconds"],
-                ordinary_use: "Create a new managed turn in the exact Session. A live terminal selector can attach an unmanaged pane or adopt one verified human-selected native context; an explicit session_id never follows the pane."
+                ordinary_use: "Create a new managed turn in the exact Session. A live terminal selector can attach an unmanaged pane, adopt one verified human-selected native context, or use the exact listed conflict send to detach a verified-empty Codex source before an isolated virgin attach; an explicit session_id never follows the pane."
             },
             new_thread: {
                 tool: "agent_knock_knock_new_thread",
@@ -5350,14 +5863,9 @@ async function verifyCodexPendingManagedSendStatus({ options, terminal, session,
     if (!codexComposerVisible(initialStatus.screen.excerpt)) {
         throw new Error("Codex status-card verification requires a visible idle composer");
     }
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
     const observed = await probeCodexCurrentThread({
         options,
         terminal,
-        initialStatus,
         currentIdentity: logicalIdentity,
         runtimeOverride: runtime
     });
@@ -5652,6 +6160,218 @@ async function reattachManagedSessionForNativeIdentity({ options, terminal, iden
     }, { expectedRevision: managedSessionRevision(existing) });
 }
 const HUMAN_OBSERVED_HANDOFF_FINGERPRINT = nativeThreadCommandFingerprint("adopt_external_thread:human_observed:no_terminal_input:v1");
+function exactBoundCodexSourceForVerifiedEmptyHandoff({ session, terminalId, terminalControl, pid, workspace, processUuid, processBirth }) {
+    const binding = session.binding;
+    return Boolean(session.agent === "codex" &&
+        session.status === "bound" &&
+        binding &&
+        isExactNativeThreadId(binding.native_thread_id) &&
+        isCompleteNativeRollout(binding.native_process.rollout) &&
+        binding.native_process.process_uuid &&
+        binding.native_process.process_birth &&
+        binding.native_process.pid === pid &&
+        terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminalId, terminalControl) &&
+        workspace &&
+        path.resolve(session.workspace) === path.resolve(workspace) &&
+        processIncarnationRelationship({
+            binding,
+            livePid: pid,
+            liveProcessUuid: processUuid,
+            liveProcessBirth: processBirth
+        }) === "same");
+}
+function verifiedEmptyCodexHandoffToken({ terminalId, terminalControl, pid, workspace, processUuid, processBirth, sourceSession }) {
+    const terminalToken = unmanagedTerminalBindingToken({
+        terminalId,
+        terminalControl,
+        agent: "codex",
+        pid,
+        workspace,
+        processUuid,
+        processBirth
+    });
+    return createHash("sha256")
+        .update(JSON.stringify({
+        version: 1,
+        kind: "verified_empty_codex_handoff",
+        terminal_token: terminalToken,
+        source_session_id: sourceSession.session_id,
+        source_revision: managedSessionRevision(sourceSession),
+        source_binding_token: managedSessionBindingToken(sourceSession),
+        observation: "verified_absent"
+    }))
+        .digest("hex");
+}
+async function assertVerifiedEmptyCodexHandoffBoundary({ options, terminal, sourceSession, expectedSourceStatus, requireNoDispatch, requireEmptyComposer = true }) {
+    const currentSource = loadManagedSession(storeDirFromOptions(options), sourceSession.session_id);
+    if (currentSource.status !== expectedSourceStatus ||
+        currentSource.revision !== sourceSession.revision ||
+        managedSessionBindingToken(currentSource) !==
+            managedSessionBindingToken(sourceSession)) {
+        throw new Error("the verified-empty source Session changed; refresh AKK list");
+    }
+    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    if (!exactBoundCodexSourceForVerifiedEmptyHandoff({
+        session: {
+            ...currentSource,
+            // The exact source binding remains authoritative after the monotonic
+            // detach; only the Session status changes.
+            status: "bound"
+        },
+        terminalId: terminal.conversationId,
+        terminalControl: terminal.terminalControl,
+        pid: terminal.pid,
+        workspace: terminal.terminalControl.currentPath,
+        processUuid: liveIncarnation.processUuid,
+        processBirth: liveIncarnation.processBirth
+    })) {
+        throw new Error("the verified-empty source binding no longer matches the terminal");
+    }
+    const observation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: "codex",
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath
+    });
+    if (observation.status === "unavailable") {
+        throw new Error(`Codex native identity observation is unavailable: ${observation.reason}`);
+    }
+    if (observation.status !== "verified_absent") {
+        throw new Error(`Codex materialized native thread ${observation.identity.sessionId}; ` +
+            "refresh AKK list before sending");
+    }
+    const status = await createTerminalAgentBridge(options).status("codex", terminal.terminalControl, {
+        runtime: terminalRuntimeForLiveIdentity({
+            terminal,
+            expectedEmptyNativeSession: true
+        })
+    });
+    if (status.reachable !== true ||
+        status.approval_state.blocked === true ||
+        !["idle", "unknown"].includes(status.activity_state)) {
+        throw new Error(`terminal ${terminal.terminalControl.target} is not at a verified ` +
+            `empty Codex prompt (${status.activity_state}: ${status.activity_reason})`);
+    }
+    if (requireNoDispatch) {
+        assertTerminalLifecycleReady({
+            options,
+            terminal,
+            // A fully styled empty/placeholder composer below is stronger prompt
+            // evidence than the plain-screen parser's conservative `unknown`.
+            terminalStatus: { ...status, activity_state: "idle" }
+        });
+    }
+    if (managedSessionHasUnresolvedNativeTransition(storeDirFromOptions(options), currentSource)) {
+        throw new Error(`managed Session ${currentSource.session_id} has an unresolved native-thread transition`);
+    }
+    if (requireEmptyComposer) {
+        await assertCodexComposerReadyForAutomatedInput({
+            options,
+            terminalControl: terminal.terminalControl
+        });
+    }
+}
+async function maybeDetachVerifiedEmptyCodexSource({ options, terminal, sourceSession, observation }) {
+    if (terminal.agent !== "codex" ||
+        !sourceSession?.binding ||
+        observation.status !== "verified_absent") {
+        return undefined;
+    }
+    const processUuid = sourceSession.binding.native_process.process_uuid;
+    const processBirth = sourceSession.binding.native_process.process_birth;
+    const workspace = terminal.terminalControl.currentPath;
+    const liveIncarnation = codexProcessIncarnationForPid(terminal.pid);
+    if (!processUuid ||
+        !processBirth ||
+        !workspace ||
+        !exactBoundCodexSourceForVerifiedEmptyHandoff({
+            session: sourceSession,
+            terminalId: terminal.conversationId,
+            terminalControl: terminal.terminalControl,
+            pid: terminal.pid,
+            workspace,
+            processUuid: liveIncarnation.processUuid,
+            processBirth: liveIncarnation.processBirth
+        })) {
+        return undefined;
+    }
+    const expectedToken = verifiedEmptyCodexHandoffToken({
+        terminalId: terminal.conversationId,
+        terminalControl: terminal.terminalControl,
+        pid: terminal.pid,
+        workspace,
+        processUuid,
+        processBirth,
+        sourceSession
+    });
+    if (stringValue(options.expectedTerminalToken) !== expectedToken) {
+        throw new Error("verified-empty Codex handoff requires the fresh exact terminal token " +
+            "advertised by AKK list");
+    }
+    await assertVerifiedEmptyCodexHandoffBoundary({
+        options,
+        terminal,
+        sourceSession,
+        expectedSourceStatus: "bound",
+        requireNoDispatch: true
+    });
+    await assertNativeThreadHasExclusiveOwnership({
+        options,
+        agent: "codex",
+        currentPid: terminal.pid,
+        nativeThreadId: sourceSession.binding.native_thread_id,
+        storeDir: storeDirFromOptions(options),
+        terminalControl: terminal.terminalControl,
+        excludedManagedSessionId: sourceSession.session_id
+    });
+    const detachedAt = cliNow().toISOString();
+    const detached = saveManagedSession(storeDirFromOptions(options), {
+        ...sourceSession,
+        status: "detached",
+        detached_at: detachedAt,
+        updated_at: detachedAt
+    }, {
+        expectedRevision: managedSessionRevision(sourceSession)
+    });
+    runtimeLog("info", "verified_empty_codex_source_detached", {
+        terminal_id: terminal.conversationId,
+        source_session_id: sourceSession.session_id,
+        native_thread_id: sourceSession.binding.native_thread_id,
+        process_uuid: processUuid,
+        process_birth: processBirth,
+        terminal_input_sent: false
+    });
+    return {
+        detached,
+        boundary: {
+            terminal,
+            detachedSourceSessionId: detached.session_id,
+            detachedSourceRevision: managedSessionRevision(detached),
+            detachedSourceBindingToken: managedSessionBindingToken(detached),
+            processUuid,
+            processBirth
+        }
+    };
+}
+async function assertVerifiedEmptyCodexTransportBoundary({ options, boundary, requireEmptyComposer }) {
+    const source = loadManagedSession(storeDirFromOptions(options), boundary.detachedSourceSessionId);
+    if (source.status !== "detached" ||
+        managedSessionRevision(source) !== boundary.detachedSourceRevision ||
+        managedSessionBindingToken(source) !==
+            boundary.detachedSourceBindingToken ||
+        source.binding?.native_process.process_uuid !== boundary.processUuid ||
+        source.binding.native_process.process_birth !== boundary.processBirth) {
+        throw new Error("verified-empty Codex source authority changed before text injection");
+    }
+    await assertVerifiedEmptyCodexHandoffBoundary({
+        options,
+        terminal: boundary.terminal,
+        sourceSession: source,
+        expectedSourceStatus: "detached",
+        requireNoDispatch: false,
+        requireEmptyComposer
+    });
+}
 function observedHandoffAuthorityToken({ terminal, identity, sourceSession, target }) {
     const exact = exactLifecycleProcessIdentity(terminal, identity);
     const terminalToken = unmanagedTerminalBindingToken({
@@ -5709,10 +6429,12 @@ function assertExpectedHandoffTokenUsesExactTerminalSelector({ options, terminal
             "conversation selector advertised by AKK list");
     }
 }
-async function observedExternalHandoffIdentity({ options, terminal, sourceSession, resolvedIdentity }) {
+async function observedExternalHandoffIdentity({ options, terminal, sourceSession, resolvedIdentity, requireSafeTerminal = true }) {
     const bridge = createTerminalAgentBridge(options);
     const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: terminalRuntimeForLiveIdentity({ terminal, physicalOnly: true }) });
-    assertSafeTerminalSend(terminal.agent, status);
+    if (requireSafeTerminal) {
+        assertSafeTerminalSend(terminal.agent, status);
+    }
     if (terminal.agent !== "codex") {
         return { identity: resolvedIdentity, status };
     }
@@ -6284,10 +7006,7 @@ function assertTerminalLifecycleReady({ options, terminal, terminalStatus }) {
         throw new Error(`terminal ${terminal.terminalControl.target} is not at a verified idle prompt ` +
             `(${terminalStatus.activity_state}: ${terminalStatus.activity_reason})`);
     }
-    const blockers = listConversations(storeDirFromOptions(options))
-        .filter(isDiscoverableTmuxConversation)
-        .filter((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminal.terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+    const blockers = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminal.terminalControl);
     if (blockers.length > 0) {
         throw new Error(`terminal ${terminal.terminalControl.target} still has unresolved Turn ` +
             `${turnIdForConversation(blockers[0])} (${blockers[0].status})`);
@@ -6967,10 +7686,7 @@ function assertTerminalNativeInspectionReady({ options, terminal, terminalStatus
         throw new Error(`terminal ${terminal.terminalControl.target} is not at a verified idle prompt ` +
             `(${terminalStatus.activity_state}: ${terminalStatus.activity_reason})`);
     }
-    const blocker = listConversations(storeDirFromOptions(options))
-        .filter(isDiscoverableTmuxConversation)
-        .find((turn) => terminalControlsShareIncarnation(terminalControlForManagedConversation(turn), terminal.terminalControl) &&
-        SESSION_SEND_BLOCKING_STATUSES.has(turn.status));
+    const blocker = terminalIncarnationBlockingTurns(storeDirFromOptions(options), terminal.terminalControl)[0];
     if (blocker) {
         throw new Error(`terminal ${terminal.terminalControl.target} still has unresolved Turn ` +
             `${turnIdForConversation(blocker)} (${blocker.status})`);
@@ -7414,6 +8130,7 @@ async function waitForVerifiedThreadTransition({ options, terminal, beforeIdenti
     const bridge = createTerminalAgentBridge(options);
     let probeSent = false;
     let postProbeBaselineDigest;
+    let postProbeObservationScrollbackLines;
     let stableIdentity;
     let stableCount = 0;
     const physicalBeforeFence = codexIdentityFence(physicalBeforeIdentity);
@@ -7481,22 +8198,37 @@ async function waitForVerifiedThreadTransition({ options, terminal, beforeIdenti
         }
         else {
             const afterProbe = plan.steps.find((step) => step.kind === "identity_probe_after");
-            if (!afterProbe || afterProbe.effect !== "read_only") {
+            if (!afterProbe ||
+                afterProbe.effect !== "read_only" ||
+                afterProbe.command !== "/status") {
                 throw new Error("the Codex lifecycle plan has no exact post-transition identity probe");
             }
+            const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+            if (!agentVersion) {
+                throw new Error("Codex lifecycle postcondition /status requires the exact running version before terminal input");
+            }
             const physicalRuntime = terminalRuntimeForLiveIdentity({
                 terminal,
                 physicalOnly: true
             });
-            const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: physicalRuntime });
+            const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+                runtime: physicalRuntime,
+                ...(postProbeObservationScrollbackLines === undefined
+                    ? {}
+                    : {
+                        scrollbackLines: postProbeObservationScrollbackLines
+                    })
+            });
             const screenDigest = stringValue(status.screen.digest);
             if (!probeSent &&
                 status.reachable &&
                 status.activity_state === "idle" &&
                 screenDigest !== undefined &&
                 screenDigest !== initialScreenDigest) {
-                postProbeBaselineDigest = screenDigest;
-                await bridge.send(terminal.agent, terminal.terminalControl, afterProbe.command, { runtime: physicalRuntime });
+                const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: physicalRuntime });
+                postProbeBaselineDigest = submission.observationBaselineDigest;
+                postProbeObservationScrollbackLines =
+                    submission.observationScrollbackLines;
                 probeSent = true;
             }
             else if (status.reachable &&
@@ -7625,7 +8357,7 @@ function assertVerifiedClaudeLifecycleBeforeObservation({ options, terminal, ide
             `for the current process incarnation${observed?.reason ? `: ${observed.reason}` : ""}`);
     }
 }
-async function probeCodexCurrentThread({ options, terminal, initialStatus, currentIdentity, runtimeIdentity, runtimeOverride }) {
+async function probeCodexCurrentThread({ options, terminal, currentIdentity, runtimeIdentity, runtimeOverride }) {
     if (terminal.agent !== "codex") {
         throw new Error("the current native thread identity is unavailable");
     }
@@ -7637,24 +8369,31 @@ async function probeCodexCurrentThread({ options, terminal, initialStatus, curre
                 terminal,
                 expectedEmptyNativeSession: true
             }));
-    // The plain activity parser intentionally recognizes Codex's composer even
-    // when a footer follows it, so "idle" alone is not authority to press Enter.
-    // Re-read the styled pane immediately before the slash probe and accept only
-    // an empty composer (or Codex's fully dim replace-on-type placeholder).
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
-    await bridge.send(terminal.agent, terminal.terminalControl, "/status", { runtime: probeRuntime });
+    const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+    if (!agentVersion) {
+        throw new Error("Codex /status requires the exact running version before terminal input");
+    }
+    // Internal status probes use the same closed submission boundary as native
+    // inspection: exact viewport and styled-empty composer proof, Codex's paste
+    // suppression settle, identity revalidation, and exactly one Enter.
+    const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: probeRuntime });
+    let lastObservationReason = "no fresh idle Codex /status card was captured after the one Enter dispatch";
+    let sawIncompleteSessionUuid = false;
     for (let attempt = 0; attempt < 50; attempt += 1) {
-        const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: probeRuntime });
+        const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+            runtime: probeRuntime,
+            scrollbackLines: submission.observationScrollbackLines
+        });
         if (status.reachable &&
-            status.screen.digest !== initialStatus.screen.digest) {
+            status.screen.digest !== submission.observationBaselineDigest) {
             const observed = terminal.adapter.observeThreadLifecycle?.({
                 operation: { kind: "new_thread" },
                 phase: "before",
                 screen: status.screen.excerpt ?? ""
             });
+            lastObservationReason = observed?.reason ?? lastObservationReason;
+            sawIncompleteSessionUuid ||= observed?.status === "missing" &&
+                /complete Session UUID/iu.test(observed.reason ?? "");
             if (observed?.status === "observed" &&
                 observed.nativeThreadId &&
                 status.activity_state === "idle") {
@@ -7671,7 +8410,12 @@ async function probeCodexCurrentThread({ options, terminal, initialStatus, curre
         }
         await cliSleep(100);
     }
-    throw new Error("Codex /status did not expose a complete current Session UUID");
+    throw new Error(sawIncompleteSessionUuid
+        ? "Codex /status Enter was dispatched exactly once, but the status card " +
+            "was truncated before the complete current Session UUID; widen or zoom " +
+            "the pane, refresh AKK list, and do not retry the probe automatically"
+        : "Codex /status Enter was dispatched exactly once, but no fresh exact " +
+            `current Session UUID was proven; do not retry automatically: ${lastObservationReason}`);
 }
 async function runNewThread(options) {
     const requireRestorableOrigin = options.requireRestorableOrigin;
@@ -8028,7 +8772,6 @@ async function runNativeThreadTransition(options, operation) {
                 const statusIdentity = await probeCodexCurrentThread({
                     options,
                     terminal,
-                    initialStatus: terminalStatus,
                     currentIdentity: beforeIdentity,
                     runtimeIdentity: snapshot.runtimeIdentity,
                     runtimeOverride: beforeRuntime
@@ -8692,17 +9435,21 @@ async function reconcileStoreForStatus(storeDir, options, conversationId) {
         }
         throw error;
     }
-    const idle = reconcileIdleConversations(storeDir, options, cliNow(), conversationId);
     const monitors = await reconcileMonitors(options, {
         includeCallbackRecovery: false,
         reason: "status_reconciliation",
         conversationId
     });
+    const idle = reconcileIdleConversations(storeDir, options, cliNow(), conversationId);
     return {
         status: "completed",
         checked: Math.max(idle.checked, monitors.checked),
-        changed: idle.closed + monitors.launched,
+        changed: idle.closed + monitors.launched + monitors.repaired,
         closed: idle.closed,
+        repaired: monitors.repaired,
+        collateral_stalls_checked: monitors.collateral_stalls_checked,
+        collateral_stalls_skipped: monitors.collateral_stalls_skipped,
+        collateral_stall_repairs: monitors.items.filter((item) => item.status === "repaired"),
         monitors_launched: monitors.launched,
         monitors_already_running: monitors.already_running,
         skipped: idle.skipped + monitors.skipped,
@@ -9229,14 +9976,15 @@ async function runSend(options) {
                 })) {
                     return;
                 }
-                const claimedSession = soleBoundManagedSessionClaimForTerminal(rawStoreDir, terminalConversation);
-                const knownCodexCompanions = claimedSession
+                assertTerminalIncarnationCanStartTurn(rawStoreDir, terminalConversation.terminalControl);
+                let claimedSession = soleBoundManagedSessionClaimForTerminal(rawStoreDir, terminalConversation);
+                let knownCodexCompanions = claimedSession
                     ? codexAllowedCompanionSetForManagedSession({
                         storeDir: rawStoreDir,
                         session: claimedSession
                     })
                     : { additional: [] };
-                let currentNativeIdentity = await resolveCurrentNativeAgentSessionIdentity({
+                const nativeIdentityObservation = await observeCurrentNativeAgentSessionIdentity({
                     options,
                     agent: terminalConversation.agent,
                     pid: terminalConversation.pid,
@@ -9247,6 +9995,26 @@ async function runSend(options) {
                     allowedCompanionIdentity: knownCodexCompanions.primary,
                     allowedAdditionalIdentities: knownCodexCompanions.additional
                 });
+                if (nativeIdentityObservation.status === "unavailable") {
+                    throw new Error(`native ${terminalConversation.agent} identity observation is ` +
+                        `unavailable: ${nativeIdentityObservation.reason}`);
+                }
+                let currentNativeIdentity = nativeIdentityObservation.status === "resolved"
+                    ? nativeIdentityObservation.identity
+                    : undefined;
+                const verifiedEmptyHandoff = 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.
+                    claimedSession = undefined;
+                    knownCodexCompanions = { additional: [] };
+                    currentNativeIdentity = undefined;
+                }
                 const physicalNativeIdentityBeforeHandoff = currentNativeIdentity;
                 const handoff = await maybeAdoptObservedExternalThread({
                     options,
@@ -9415,7 +10183,8 @@ async function runSend(options) {
                                 terminal: terminalConversation,
                                 transition: handoff.transition
                             }
-                            : undefined
+                            : undefined,
+                        verifiedEmptyCodexHandoff: verifiedEmptyHandoff?.boundary
                     });
                 }
                 finally {
@@ -9498,6 +10267,7 @@ async function runSend(options) {
             })) {
                 return;
             }
+            assertTerminalIncarnationCanStartTurn(storeDir, resolvedTerminal.terminalControl);
             let currentSession = tryLoadManagedSession(storeDir, sessionId);
             const knownCodexCompanions = currentSession
                 ? codexAllowedCompanionSetForManagedSession({
@@ -10374,7 +11144,7 @@ async function runTerminalConversationApprove({ options, conversationId, agent,
         releaseTerminalLock();
     }
 }
-async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, storeWriterLeaseHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false, onTerminalPreflightVerified = undefined, allowedPreMaterializationIdentity = undefined, allowedAdditionalIdentities = [], observedHandoff = undefined, continuingTurnResponse = false }) {
+async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, terminalSendLockHeld = false, terminalStateLockHeld = false, storeWriterLeaseHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false, onTerminalPreflightVerified = undefined, allowedPreMaterializationIdentity = undefined, allowedAdditionalIdentities = [], observedHandoff = undefined, verifiedEmptyCodexHandoff = undefined, continuingTurnResponse = false }) {
     const bridge = terminalBridgeEnabled(conversation);
     if (!terminalSendLockHeld) {
         const releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 });
@@ -10397,6 +11167,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 allowedPreMaterializationIdentity,
                 allowedAdditionalIdentities,
                 observedHandoff,
+                verifiedEmptyCodexHandoff,
                 continuingTurnResponse
             });
         }
@@ -10437,6 +11208,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 allowedPreMaterializationIdentity,
                 allowedAdditionalIdentities,
                 observedHandoff,
+                verifiedEmptyCodexHandoff,
                 continuingTurnResponse
             });
         }
@@ -10464,6 +11236,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             allowedPreMaterializationIdentity,
             allowedAdditionalIdentities,
             observedHandoff,
+            verifiedEmptyCodexHandoff,
             continuingTurnResponse
         }));
     }
@@ -10645,7 +11418,18 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             scrollbackLines: Number(options.scrollbackLines ?? 120),
             runtime: preSendRuntime
         });
-        assertSafeTerminalSend(executor.kind, status);
+        if (verifiedEmptyCodexHandoff) {
+            if (executor.kind !== "codex" ||
+                status.reachable !== true ||
+                status.approval_state.blocked === true ||
+                !["idle", "unknown"].includes(status.activity_state)) {
+                throw new Error(`Codex verified-empty handoff is not at a safe prompt ` +
+                    `(${status.activity_state}: ${status.activity_reason})`);
+            }
+        }
+        else {
+            assertSafeTerminalSend(executor.kind, status);
+        }
         if (executor.kind === "codex" && needsPostSendNativeBinding) {
             if (pendingManagedNativeBinding || allowedPreMaterializationIdentity) {
                 const expectedForegroundId = stringValue(sendTakeover?.terminal_agent_expected_session_id);
@@ -11015,7 +11799,8 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     try {
         await terminalBridge.send(executor.kind, terminalControl, terminalPayload, {
             runtime: preSendRuntime,
-            requireExactComposerBeforeEnter: observedHandoff !== undefined,
+            requireExactComposerBeforeEnter: observedHandoff !== undefined ||
+                verifiedEmptyCodexHandoff !== undefined,
             beforeText: observedHandoff
                 ? async () => {
                     await assertObservedHandoffTransportBoundary({
@@ -11025,7 +11810,15 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                         requireEmptyComposer: true
                     });
                 }
-                : undefined,
+                : verifiedEmptyCodexHandoff
+                    ? async () => {
+                        await assertVerifiedEmptyCodexTransportBoundary({
+                            options,
+                            boundary: verifiedEmptyCodexHandoff,
+                            requireEmptyComposer: true
+                        });
+                    }
+                    : undefined,
             beforeEnter: observedHandoff
                 ? async () => {
                     await assertObservedHandoffTransportBoundary({
@@ -11035,7 +11828,15 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                         requireEmptyComposer: false
                     });
                 }
-                : undefined,
+                : verifiedEmptyCodexHandoff
+                    ? async () => {
+                        await assertVerifiedEmptyCodexTransportBoundary({
+                            options,
+                            boundary: verifiedEmptyCodexHandoff,
+                            requireEmptyComposer: false
+                        });
+                    }
+                    : undefined,
             async onTransportStage(event) {
                 const stageAt = cliNow().toISOString();
                 if (event.stage === "text_injected") {
@@ -11084,6 +11885,13 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                         requireEmptyComposer: false
                     });
                 }
+                if (event.stage === "text_injected" && verifiedEmptyCodexHandoff) {
+                    await assertVerifiedEmptyCodexTransportBoundary({
+                        options,
+                        boundary: verifiedEmptyCodexHandoff,
+                        requireEmptyComposer: false
+                    });
+                }
                 try {
                     appendEvent(logPath, {
                         ts: stageAt,
@@ -12523,6 +13331,29 @@ async function resolveCurrentNativeAgentSessionIdentity({ options, agent, pid, c
         evidence: "claude_agents_exact_pid"
     };
 }
+/**
+ * Preserve the security-significant difference between a successful native
+ * identity probe that found no current Session and a probe that could not be
+ * completed.  `undefined` from the Codex provider is authoritative only after
+ * both the process-incarnation and open-rollout inspections succeeded.
+ */
+async function observeCurrentNativeAgentSessionIdentity(request) {
+    try {
+        const identity = await resolveCurrentNativeAgentSessionIdentity(request);
+        return identity
+            ? { status: "resolved", identity }
+            : {
+                status: "verified_absent",
+                evidence: "native_identity_resolver_verified_absent"
+            };
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
 function nativeAgentIdentityMatchesTurn(conversation, currentIdentity) {
     const takeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
@@ -13333,14 +14164,23 @@ async function runReconcileMonitors(options) {
 }
 async function reconcileMonitors(options, { includeCallbackRecovery, reason, conversationId }) {
     const storeDir = storeDirFromOptions(options);
+    const collateralStalls = await withStoreWriterLeaseAsync(storeDir, async () => reconcileTerminalBridgeCollateralStalls(storeDir, conversationId));
     const conversations = listConversations(storeDir).filter((conversation) => conversationId === undefined || conversation.conversation_id === conversationId);
-    const items = [];
+    const items = [...collateralStalls.items];
+    const repairedConversationIds = new Set(collateralStalls.items
+        .filter((item) => item.status === "repaired")
+        .map((item) => stringValue(item.conversation_id))
+        .filter((id) => id !== undefined));
     let ignored = 0;
     let launched = 0;
     let alreadyRunning = 0;
     let skipped = 0;
-    let errors = 0;
+    let errors = collateralStalls.errors.length;
     for (const listedConversation of conversations) {
+        if (repairedConversationIds.has(listedConversation.conversation_id)) {
+            ignored += 1;
+            continue;
+        }
         if (!matchesConfiguredWorkspace(options.workspace, listedConversation.workspace)) {
             ignored += 1;
             continue;
@@ -13574,6 +14414,9 @@ async function reconcileMonitors(options, { includeCallbackRecovery, reason, con
         reconciled: true,
         store_dir: storeDir,
         checked: conversations.length,
+        repaired: collateralStalls.repaired,
+        collateral_stalls_checked: collateralStalls.checked,
+        collateral_stalls_skipped: collateralStalls.skipped,
         ignored,
         launched,
         already_running: alreadyRunning,
@@ -14040,7 +14883,7 @@ async function runObservedHandoffClose({ options, statePath, logPath, initialCon
     if (stringValue(options.reason) !== "superseded_by_human_context_switch") {
         throw new Error("a handoff close requires reason superseded_by_human_context_switch");
     }
-    const storeDir = storeDirFromOptions(options);
+    const storeDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     const sourceSessionId = sessionIdForConversation(initialConversation);
     const initialSource = loadManagedSession(storeDir, sourceSessionId);
     if (!initialSource.binding || initialSource.status !== "bound") {
@@ -14226,89 +15069,179 @@ async function runClose(options) {
         });
         return;
     }
+    if (stringValue(options.reason) === "superseded_by_human_context_switch") {
+        throw new Error("reason superseded_by_human_context_switch requires the fresh " +
+            "expected_handoff_token advertised by AKK list");
+    }
     const { statePath, logPath } = loaded;
+    const closeStoreDir = pathsForConversationDir(path.dirname(statePath)).storeDir;
     const nativeTakeover = isRecord(loaded.conversation.native_session_takeover)
         ? loaded.conversation.native_session_takeover
         : undefined;
     const terminalControl = terminalControlFromTakeover(nativeTakeover);
     const releaseTerminalLock = terminalControl
-        ? acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminalControl, { timeoutMs: 30000 })
+        ? acquireTerminalBridgeSendLock(closeStoreDir, terminalControl, { timeoutMs: 30000 })
         : () => { };
-    let releaseStateLock;
-    try {
-        releaseStateLock = acquireFileLock(`${statePath}.lock`);
-        const conversation = loadState(statePath);
-        const now = cliNow().toISOString();
-        const closeReason = options.reason ?? "closed by request";
-        const handoffDisposition = closeReason === "superseded_by_human_context_switch"
-            ? closeReason
-            : undefined;
-        const closed = {
-            ...conversation,
-            status: "closed",
-            closed_at: now,
-            close_reason: closeReason,
-            ...(handoffDisposition
-                ? { disposition: handoffDisposition }
-                : {}),
-            updated_at: now
-        };
-        saveState(statePath, closed);
-        let dispatchLedgerResolved = false;
-        let dispatchLedgerWarning;
-        if (terminalControl) {
-            try {
-                dispatchLedgerResolved = resolveTerminalBridgeDispatchLedger({
-                    terminalControl,
-                    conversation: closed,
-                    expectedMessageId: stringValue(nativeTakeover?.terminal_bridge_message_id),
-                    reason: "conversation explicitly closed by request"
-                });
+    const closeWithFreshState = async () => {
+        const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const conversation = loadState(statePath);
+            const currentTakeover = isRecord(conversation.native_session_takeover)
+                ? conversation.native_session_takeover
+                : undefined;
+            const currentTerminalControl = terminalControlFromTakeover(currentTakeover);
+            if (terminalControl &&
+                !terminalControlsShareIncarnation(currentTerminalControl, terminalControl)) {
+                throw new Error("terminal control changed after the close action was listed; refresh AKK list");
             }
-            catch (error) {
-                dispatchLedgerWarning =
-                    error instanceof Error ? error.message : String(error);
-                runtimeLog("error", "terminal_dispatch_ledger_resolve_failed", {
-                    conversation_id: closed.conversation_id,
-                    terminal_target: terminalControl.target,
-                    error: dispatchLedgerWarning
+            if (terminalControl && currentTerminalControl) {
+                await assertGenericCloseDoesNotBypassObservedHandoff({
+                    options,
+                    storeDir: closeStoreDir,
+                    conversation,
+                    terminalControl: currentTerminalControl
                 });
             }
-        }
-        appendEvent(logPath, {
-            ts: now,
-            conversation_id: conversation.conversation_id,
-            event: "conversation_closed",
-            status: "closed",
-            reason: closed.close_reason
-        });
-        runtimeLog("info", "conversation_closed", {
-            conversation_id: conversation.conversation_id,
-            status: "closed",
-            reason: closed.close_reason,
-            state_path: statePath,
-            event_log_path: logPath
-        });
-        printJson({
-            conversation: closed,
-            closed: true,
-            terminal_dispatch_resolved: dispatchLedgerResolved,
-            ...(dispatchLedgerWarning
-                ? {
-                    terminal_dispatch_warning: textSummary(dispatchLedgerWarning),
-                    do_not_retry: true
+            const now = cliNow().toISOString();
+            const closeReason = options.reason ?? "closed by request";
+            const closed = {
+                ...conversation,
+                status: "closed",
+                closed_at: now,
+                close_reason: closeReason,
+                updated_at: now
+            };
+            saveState(statePath, closed);
+            let dispatchLedgerResolved = false;
+            let dispatchLedgerWarning;
+            if (currentTerminalControl) {
+                try {
+                    dispatchLedgerResolved = resolveTerminalBridgeDispatchLedger({
+                        terminalControl: currentTerminalControl,
+                        conversation: closed,
+                        expectedMessageId: stringValue(currentTakeover?.terminal_bridge_message_id),
+                        reason: "conversation explicitly closed by request"
+                    });
                 }
-                : {})
-        });
-    }
-    finally {
-        try {
-            releaseStateLock?.();
+                catch (error) {
+                    dispatchLedgerWarning =
+                        error instanceof Error ? error.message : String(error);
+                    runtimeLog("error", "terminal_dispatch_ledger_resolve_failed", {
+                        conversation_id: closed.conversation_id,
+                        terminal_target: currentTerminalControl.target,
+                        error: dispatchLedgerWarning
+                    });
+                }
+            }
+            appendEvent(logPath, {
+                ts: now,
+                conversation_id: conversation.conversation_id,
+                event: "conversation_closed",
+                status: "closed",
+                reason: closed.close_reason
+            });
+            runtimeLog("info", "conversation_closed", {
+                conversation_id: conversation.conversation_id,
+                status: "closed",
+                reason: closed.close_reason,
+                state_path: statePath,
+                event_log_path: logPath
+            });
+            printJson({
+                conversation: closed,
+                closed: true,
+                terminal_dispatch_resolved: dispatchLedgerResolved,
+                ...(dispatchLedgerWarning
+                    ? {
+                        terminal_dispatch_warning: textSummary(dispatchLedgerWarning),
+                        do_not_retry: true
+                    }
+                    : {})
+            });
         }
         finally {
-            releaseTerminalLock();
+            releaseStateLock();
+        }
+    };
+    try {
+        if (terminalControl) {
+            await withStoreWriterLeaseAsync(closeStoreDir, closeWithFreshState);
+        }
+        else {
+            await closeWithFreshState();
         }
     }
+    finally {
+        releaseTerminalLock();
+    }
+}
+async function assertGenericCloseDoesNotBypassObservedHandoff({ options, storeDir, conversation, terminalControl }) {
+    if (!SESSION_SEND_BLOCKING_STATUSES.has(conversation.status)) {
+        return;
+    }
+    const sourceSession = tryLoadManagedSession(storeDir, sessionIdForConversation(conversation));
+    if (sourceSession?.status !== "bound" ||
+        !sourceSession.binding ||
+        !terminalControlsShareIncarnation(sourceSession.binding.terminal_control, terminalControl)) {
+        return;
+    }
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const pid = Number(takeover?.terminal_agent_pid);
+    if (!Number.isSafeInteger(pid) || pid <= 1) {
+        return;
+    }
+    const bridge = createTerminalAgentBridge(options);
+    let terminal;
+    try {
+        terminal = await bridge.resolveStoredTerminal(sourceSession.agent, pid, terminalControl, { pid });
+    }
+    catch (error) {
+        if (!(error instanceof TerminalControlUnavailableError)) {
+            throw error;
+        }
+        // An unavailable terminal cannot prove a live A -> B handoff. Preserve the
+        // explicit Store-only close path used to retire unavailable Turn history.
+        return;
+    }
+    const companions = sourceSession.agent === "codex"
+        ? codexAllowedCompanionSetForManagedSession({
+            storeDir,
+            session: sourceSession
+        })
+        : { additional: [] };
+    const identityObservation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: terminal.agent,
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath,
+        preferredSessionId: companions.primary
+            ? sourceSession.binding.native_thread_id
+            : undefined,
+        allowedCompanionIdentity: companions.primary,
+        allowedAdditionalIdentities: companions.additional
+    });
+    const resolvedIdentity = identityObservation.status === "resolved"
+        ? identityObservation.identity
+        : undefined;
+    const observed = await observedExternalHandoffIdentity({
+        options,
+        terminal,
+        sourceSession,
+        resolvedIdentity,
+        requireSafeTerminal: false
+    });
+    if (managedBindingConflictKindForResolvedTerminal({
+        storeDir,
+        session: sourceSession,
+        terminal,
+        identity: observed.identity
+    }) === "live_external_thread_change") {
+        throw new Error(`terminal ${terminalControl.target} changed native thread after the ` +
+            "generic close action was listed; refresh AKK list and use only its " +
+            "fresh snapshot-bound handoff_decision");
+    }
 }
 async function runTerminalDispatchClose({ options, terminalConversation }) {
     const terminalControl = terminalConversation.terminalControl;
@@ -17991,17 +18924,20 @@ async function probeManualCodexLifecycleRecoveryIdentity({ options, terminal, tr
     if (!cleared?.screen.digest) {
         throw new Error("Codex composer did not become empty after recovery clear-line");
     }
-    await assertCodexComposerReadyForAutomatedInput({
-        options,
-        terminalControl: terminal.terminalControl
-    });
-    const baselineDigest = cleared.screen.digest;
-    await bridge.send(terminal.agent, terminal.terminalControl, "/status", { runtime: recoveryRuntime });
+    const agentVersion = agentVersionForRunningProcess(terminal.agent, terminal.pid, options);
+    if (!agentVersion) {
+        throw new Error("Codex lifecycle recovery /status requires the exact running version before terminal input");
+    }
+    const submission = await bridge.submitCodexStatusProbe(terminal.terminalControl, agentVersion, { runtime: recoveryRuntime });
+    const baselineDigest = submission.observationBaselineDigest;
     let stable;
     let stableCount = 0;
     let lastObservationReason = "no fresh idle status screen was captured";
     for (let attempt = 0; attempt < 12; attempt += 1) {
-        const status = await bridge.status(terminal.agent, terminal.terminalControl, { runtime: recoveryRuntime });
+        const status = await bridge.status(terminal.agent, terminal.terminalControl, {
+            runtime: recoveryRuntime,
+            scrollbackLines: submission.observationScrollbackLines
+        });
         if (status.reachable &&
             status.activity_state === "idle" &&
             !status.approval_state.blocked &&
@@ -18232,14 +19168,7 @@ function claudeComposerVisible(screen) {
         .some((line) => /^\s*❯(?:\s|$)/u.test(line));
 }
 function claudeComposerEmpty(screen) {
-    const lines = String(screen ?? "").split(/\r?\n/u);
-    while (lines.length > 0 && lines.at(-1)?.trim() === "") {
-        lines.pop();
-    }
-    const composers = lines
-        .slice(-8)
-        .filter((line) => /^\s*❯(?:\s|$)/u.test(line));
-    return composers.length === 1 && /^\s*❯\s*$/u.test(composers[0]);
+    return isExactClaudeIdleComposer(String(screen ?? ""));
 }
 function assertManualLifecycleProcessIncarnation(transition, live) {
     if (live.processUuid !== transition.before_process_uuid ||