@scotthuang/agent-knock-knock 0.12.37 → 0.13.0

package/dist/src/terminal-command-cli-adapter.js

@@ -1,25 +1,30 @@
 // Raw CLI infrastructure for ordinary terminal send/respond/approval commands.
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { callbackExpectedForConversation, callbackExpectedForConversationWithLegacyFallback, callbackRouteFingerprintForConversation } from "./callback-route-authority.js";
-import { supersedeUnacceptedCallbackDeliveries } from "./callback-outbox-policy.js";
+import { callbackDeliveryAttemptOutcome, supersedeUnacceptedCallbackDeliveries } from "./callback-outbox-policy.js";
 import { captureClaudeTranscriptAnchor, defaultClaudeHome } from "./claude-local-transcript-provider.js";
-import { validateCodexRolloutAcceptanceAnchor } from "./terminal-submission-acceptance.js";
+import { captureCodexCandidateSetRolloutAcceptanceAnchor, validateCodexRolloutAcceptanceAnchor } from "./terminal-submission-acceptance.js";
+import { fingerprint } from "./terminal-submission-facts.js";
 import { isRecord, nonBlankString as stringValue } from "./value-guards.js";
-import { deferredForegroundActiveMessageId, isDeferredForegroundSubmissionRetryPending } from "./deferred-foreground-transfer.js";
+import { deferredForegroundActiveMessageId, isDeferredForegroundSubmissionRetryPending, listDeferredForegroundTransfers } from "./deferred-foreground-transfer.js";
+import { isFinalDeferredForegroundTransferStatus } from "./deferred-foreground-transfer-policy.js";
+import { humanExplicitCallbackDebtDisposition, humanExplicitCallbackDebtRetirementDisposition, humanExplicitCallbackDebtManagedTokenMatches } from "./deferred-foreground-authority-cli-adapter.js";
 import { applyMessageToConversation, budgetAction, createMessage, effectiveTurnStatus, executorForConversation, isSessionSendBlockingStatus, isTerminalDispatchOwnerReleasedStatus, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
 import { readNdjsonLog } from "./transcript.js";
 import { appendEvent, appendExplicitUserCloseEvent, defaultStoreDir, ensureDir, ensureStoreWritable, listConversations, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveExplicitUserCloseState, saveState, withStoreWriterLeaseAsync } from "./store.js";
 import { createManagedSessionId, managedSessionBindingToken, managedSessionRevision, unmanagedTerminalBindingToken } from "./managed-session.js";
-import { listManagedSessions, loadManagedSession, saveManagedSession, tryLoadManagedSession } from "./session-store.js";
+import { listNativeThreadTransitions, listManagedSessions, loadManagedSession, saveManagedSession, tryLoadManagedSession } from "./session-store.js";
 import { isTerminalApprovalDecision } from "./terminal-agent-adapter.js";
 import { terminalControlEvidenceMatches } from "./terminal-control-ref.js";
 import { isExactClaudeNativeInspectionIdleComposer, TerminalEnterDispatchNotAttemptedError, TerminalInputNotStartedError } from "./terminal-agent-bridge.js";
 import { decideTerminalSubmissionRetry, loadTerminalSubmissionRetry, projectTerminalSubmissionRetryPending, saveTerminalSubmissionRetry, terminalSubmissionRetryLedgerFields, TERMINAL_SUBMISSION_RETRY_SCHEMA, TERMINAL_SUBMISSION_RETRY_VERSION } from "./terminal-submission-retry-service.js";
 import { evaluateApprovalPolicy } from "./approval-policy.js";
-import { codexCompanionsPresentInOpenRootInventory, isCompleteNativeRollout, nativeIdentityMatchesCodexPreMaterialization, terminalControlAliasMatches, terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
+import { rolloutFileIdentityMatches } from "./terminal-binding-authority.js";
+import { codexCompanionsPresentInOpenRootInventory, exactBoundCodexSendSource, isCompleteNativeRollout, nativeIdentityMatchesCodexPreMaterialization, terminalControlAliasMatches, terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
 import { decideTerminalSendAuthority } from "./terminal-action-projection.js";
 import { terminalScopedCodexApprovalPromptSnapshot } from "./terminal-scoped-approval-authority.js";
 import { withCanonicalMutationLocks } from "./mutation-transaction.js";
@@ -28,6 +33,7 @@ import { claudeTranscriptApprovalIdentity, terminalMonitorDeadlineAt as deadline
 import * as monitorOwner from "./terminal-monitor-ownership-policy.js";
 import { sameCanonicalStatePath, terminalDispatchLedgerLooksLifecycle, terminalDispatchReceiptHistory as terminalLedgerReceiptHistory } from "./terminal-dispatch-ledger-codec.js";
 import * as dispatchApplication from "./terminal-dispatch-application.js";
+import { decideUserExplicitTerminalInputSafety } from "./terminal-dispatch-policy.js";
 import { bindDeferredForegroundApplicationScope, bindDeferredForegroundWriterScope } from "./deferred-foreground-capability.js";
 import * as deferredRecoveryAdapter from "./deferred-foreground-recovery-cli-adapter.js";
 import { cleanupDeferredForegroundUserClose } from "./deferred-foreground-user-close.js";
@@ -35,11 +41,16 @@ import { deferredForegroundBoundaryProjection } from "./deferred-foreground-prep
 import { terminalSubmissionPayload } from "./terminal-dispatch-execution.js";
 import { createTerminalUserSendIntentRepository, TerminalUserSendIntentBoundaryConflictError, TerminalUserSendIntentUncertainError } from "./terminal-user-send-intent.js";
 import { terminalUserExplicitFallbackWatchId } from "./terminal-watch-store.js";
-import { presentTerminalCompleted, presentTerminalDispatchReplay, presentTerminalIdentityFailure, presentTerminalUncertain, presentTerminalZeroInputAbort as renderTerminalZeroInputAbort } from "./terminal-dispatch-presenter.js";
+import { CODEX_FOREGROUND_IDENTIFICATION_SCROLLBACK_LINES } from "./native-thread-lifecycle-cli-adapter.js";
+import { presentTerminalCompleted, presentTerminalDispatchReplay, presentTerminalIdentityFailure, terminalSendEnterDispatched, terminalSendResultContract, presentTerminalUncertain, presentTerminalZeroInputAbort as renderTerminalZeroInputAbort } from "./terminal-dispatch-presenter.js";
 import * as dispatchReceipt from "./terminal-dispatch-receipt.js";
 import { expandHome, positiveMilliseconds, writeCliJson as printJson } from "./cli-command-runtime.js";
 import { cliEnv, cliExit, cliNow, cliNowMs, cliPid, cliRuntimeLog as runtimeLog } from "./cli-runtime-context.js";
 const terminalCommandContext = new AsyncLocalStorage();
+// An atomic identify-and-send proof is deliberately an in-process,
+// unforgeable side channel. It must never be accepted from CLI arguments or
+// persisted as Session authority.
+const foregroundIdentificationProofs = new WeakMap();
 function terminalCommandRuntime() {
     const runtime = terminalCommandContext.getStore();
     if (!runtime) {
@@ -81,6 +92,7 @@ const deferredForegroundRecoveryAdapterPorts = rawPort("deferredForegroundRecove
 const ensureTerminalBridgeMonitorAfterApproval = rawPort("ensureTerminalBridgeMonitorAfterApproval");
 const exactSafeAbortedRecoveredSessionMatches = rawPort("exactSafeAbortedRecoveredSessionMatches");
 const inspectCodexOpenRootRolloutInventory = rawPort("inspectCodexOpenRootRolloutInventory");
+const identifyCodexForegroundWhileLocked = rawPort("identifyCodexForegroundWhileLocked");
 const isDiscoverableTmuxConversation = rawPort("isDiscoverableTmuxConversation");
 const loadClaudeAgentRows = rawPort("loadClaudeAgentRows");
 const loadConversationFromOptions = rawPort("loadConversationFromOptions");
@@ -143,6 +155,11 @@ const DEFAULT_AGENT_TIMEOUT_MINUTES = 60;
 const DEFAULT_AGENT_HARD_TIMEOUT_MINUTES = 720;
 const DEFAULT_TERMINAL_ACCEPTANCE_TIMEOUT_MS = 5000;
 const DEFAULT_TERMINAL_ACCEPTANCE_POLL_INTERVAL_MS = 50;
+// Human-explicit Send still falls back to one physical terminal dispatch when
+// managed preparation is genuinely unavailable. Give ordinary Store/monitor
+// contention a short chance to clear first so a transient writer lease does
+// not unnecessarily discard managed questionnaire response authority.
+const USER_EXPLICIT_MANAGED_LOCK_GRACE_MS = 1_000;
 const CLAUDE_SCREEN_APPROVAL_TTL_MS = 10 * 60 * 1000;
 function replayReceiptBindingMismatch(receipt, expectation) {
     return Boolean(!terminalDispatchRecordMatchesControl(receipt, expectation.terminalControl) ||
@@ -261,7 +278,7 @@ function replayLoggedMessageMismatch(loggedMessage, owner, expectedMessageType,
         loggedMessage.session_id !== sessionIdForConversation(owner) ||
         loggedMessage.turn_id !== turnIdForConversation(owner));
 }
-function replayExactActiveTerminalSubmission({ options, terminalControl, requestText, expectedStoreDir, expectedSessionId, expectedTurnId, expectedMessageType = "task", expectedStatePath }) {
+function replayExactActiveTerminalSubmission({ options, terminalControl, requestText, expectedStoreDir, expectedSessionId, expectedTurnId, expectedMessageType = "task", expectedStatePath, userExplicitTerminalId }) {
     const messageId = stringValue(options.messageId);
     if (!messageId) {
         return false;
@@ -338,14 +355,15 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
         expectedSessionId,
         expectedTurnId,
         expectedMessageType,
-        expectedStatePath
+        expectedStatePath,
+        userExplicitTerminalId
     })) {
         return true;
     }
     if (durableReceiptCannotDispatchAgain(ledgerReceipt, loadedLedger, loadedLedgerMessageId, messageId)) {
         throw new Error(`terminal idempotency key ${messageId} already has durable ` +
             `${String(ledgerReceipt.status)} proof and cannot be dispatched again; ` +
-            "no terminal input was sent");
+            "no additional terminal input was sent");
     }
     const incarnationLedger = resolveTerminalDispatchLedgerPaneIncarnation(terminalControl, loadedLedger);
     const ledger = replayableReconciledLedger(reconcilePreparedTerminalDispatchLedger(terminalControl, incarnationLedger), expectation, messageId);
@@ -433,46 +451,31 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
         });
     const acceptanceInvalid = replayReceipt.submission_outcome === "uncertain";
     const callbackExpected = callbackExpectedForConversationWithLegacyFallback(owner, ledger.callback_expected);
-    printJson({
-        session_id: sessionIdForConversation(owner),
-        turn_id: turnIdForConversation(owner),
-        conversation: owner,
+    presentTerminalDispatchReplay({
+        owner,
+        receipt: replayReceipt,
+        accepted: replayReceipt.submission_outcome === "agent_accepted",
+        acceptanceInvalid,
+        receiptConversationId: owner.conversation_id,
+        receiptMessageId: messageId,
+        callbackExpected,
+        ...(userExplicitTerminalId
+            ? {
+                userExplicit: {
+                    terminalId: userExplicitTerminalId,
+                    messageId
+                }
+            }
+            : {})
+    }, {
         message: replayedMessage,
-        delivered: replayReceipt.delivered,
-        status: replayReceipt.status,
-        submission_outcome: replayReceipt.submission_outcome,
-        background: true,
-        callback_expected: !acceptanceInvalid && callbackExpected,
-        terminal_control: terminalControl,
         executor,
-        replayed: replayReceipt.replayed,
-        delivery_receipt: replayReceipt.delivery_receipt,
-        ...(replayReceipt.do_not_retry
-            ? { do_not_retry: replayReceipt.do_not_retry }
-            : {}),
-        reason: replayReceipt.delivered
-            ? "AKK replayed the durable native acceptance receipt and sent no additional terminal input."
-            : acceptanceInvalid
-                ? "AKK replayed an invalid native acceptance receipt as uncertain and sent no additional terminal input."
-                : "AKK replayed the original transport proof without upgrading it and sent no additional terminal input.",
-        openclaw_next_action: replayReceipt.delivered
-            ? openClawYieldNextAction({
-                conversationId: owner.conversation_id,
-                sessionId: sessionIdForConversation(owner),
-                turnId: turnIdForConversation(owner),
-                source: "terminal_control",
-                callbackExpected
-            })
-            : {
-                action: "inspect",
-                conversation_id: owner.conversation_id,
-                session_id: sessionIdForConversation(owner),
-                turn_id: turnIdForConversation(owner),
-                do_not_retry: true,
-                reason: acceptanceInvalid
-                    ? "Stored native acceptance evidence is invalid."
-                    : "Only terminal transport is proven."
-            }
+        terminalControl
+    }, {
+        write: printJson,
+        budget: budgetAction,
+        nextAction: openClawYieldNextAction,
+        summarize: textSummary
     });
     return true;
 }
@@ -597,7 +600,7 @@ function validateStoredTerminalSubmissionMatch({ owner, receipt, options, termin
     }
     return loggedMessage;
 }
-function replayExactStoredTerminalSubmission({ options, terminalControl, requestText, requestHash, messageId, expectedStoreDir, expectedSessionId, expectedTurnId, expectedMessageType, expectedStatePath }) {
+function replayExactStoredTerminalSubmission({ options, terminalControl, requestText, requestHash, messageId, expectedStoreDir, expectedSessionId, expectedTurnId, expectedMessageType, expectedStatePath, userExplicitTerminalId }) {
     const allMatches = listConversations(expectedStoreDir).flatMap((owner) => terminalBridgeSubmissionReceipts(owner)
         .filter((receipt) => stringValue(receipt.message_id) === messageId)
         .map((receipt) => ({ owner, receipt })));
@@ -663,7 +666,7 @@ function replayExactStoredTerminalSubmission({ options, terminalControl, request
     }
     if (!["submitted", "enter_dispatched", "agent_accepted"].includes(String(receipt.status))) {
         throw new Error(`terminal idempotency key ${messageId} has durable ${String(receipt.status)} ` +
-            "proof and must not be retried; no terminal input was sent");
+            "proof and must not be retried; no additional terminal input was sent");
     }
     const executor = executorForConversation(owner);
     const nativeThreadId = stringValue(receipt.native_thread_id) ??
@@ -699,52 +702,45 @@ function replayExactStoredTerminalSubmission({ options, terminalControl, request
         });
     const acceptanceInvalid = replayReceipt.submission_outcome === "uncertain";
     const callbackExpected = callbackExpectedForConversation(owner);
-    printJson({
-        session_id: sessionIdForConversation(owner),
-        turn_id: turnIdForConversation(owner),
-        conversation: owner,
+    presentTerminalDispatchReplay({
+        owner,
+        receipt: replayReceipt,
+        accepted: replayReceipt.submission_outcome === "agent_accepted",
+        acceptanceInvalid,
+        receiptConversationId: owner.conversation_id,
+        receiptMessageId: messageId,
+        callbackExpected,
+        ...(userExplicitTerminalId
+            ? {
+                userExplicit: {
+                    terminalId: userExplicitTerminalId,
+                    messageId
+                }
+            }
+            : {})
+    }, {
         message: replayedMessage,
-        delivered: replayReceipt.delivered,
-        status: replayReceipt.status,
-        submission_outcome: replayReceipt.submission_outcome,
-        background: true,
-        callback_expected: !acceptanceInvalid && callbackExpected,
-        terminal_control: terminalControl,
         executor,
-        replayed: true,
-        delivery_receipt: replayReceipt.delivery_receipt,
-        ...(replayReceipt.do_not_retry
-            ? { do_not_retry: replayReceipt.do_not_retry }
-            : {}),
-        reason: replayReceipt.delivered
-            ? "AKK replayed the stored durable native acceptance receipt and sent no additional terminal input."
-            : acceptanceInvalid
-                ? "AKK replayed an invalid stored native acceptance receipt as uncertain and sent no additional terminal input."
-                : "AKK replayed the stored transport proof without upgrading it and sent no additional terminal input.",
-        openclaw_next_action: replayReceipt.delivered
-            ? openClawYieldNextAction({
-                conversationId: owner.conversation_id,
-                sessionId: sessionIdForConversation(owner),
-                turnId: turnIdForConversation(owner),
-                source: "terminal_control",
-                callbackExpected
-            })
-            : {
-                action: "inspect",
-                conversation_id: owner.conversation_id,
-                session_id: sessionIdForConversation(owner),
-                turn_id: turnIdForConversation(owner),
-                do_not_retry: true,
-                reason: acceptanceInvalid
-                    ? "Stored native acceptance evidence is invalid."
-                    : "Only terminal transport is proven."
-            }
+        terminalControl
+    }, {
+        write: printJson,
+        budget: budgetAction,
+        nextAction: openClawYieldNextAction,
+        summarize: textSummary
     });
     return true;
 }
 const terminalBridgeSubmission = dispatchReceipt.terminalBridgeSubmission;
 const terminalBridgeSubmissionReceipts = dispatchReceipt.terminalBridgeSubmissionReceipts;
 const unresolvedTerminalBridgeSubmission = dispatchReceipt.unresolvedTerminalBridgeSubmission;
+function durableTerminalInputDispatched(conversation) {
+    try {
+        return dispatchReceipt.terminalInputDispatchedForConversation(conversation);
+    }
+    catch {
+        return dispatchReceipt.terminalSubmissionIndicatesInputDispatched(terminalBridgeSubmission(conversation));
+    }
+}
 function assertNoUnresolvedTerminalBridgeSubmission(storeDir, terminalControl, currentConversationId, requestText) {
     const requestHash = terminalBridgeRequestFingerprint(requestText);
     for (const candidate of listConversations(storeDir)) {
@@ -1406,12 +1402,24 @@ function terminalSubmissionRetryLedgerFieldsAtState(attempt, state, revision) {
     return fields;
 }
 function printTerminalSubmissionRetryOutcome(input) {
+    const submission = terminalBridgeSubmission(input.conversation);
+    const enterDispatched = input.terminalInputSent ||
+        ["agent_accepted", "enter_dispatched", "not_accepted"].includes(input.outcome) ||
+        terminalSendEnterDispatched(submission) ||
+        ["enter_dispatched", "agent_accepted"].includes(String(input.attempt?.state ?? ""));
+    const terminalInputDispatched = enterDispatched ||
+        durableTerminalInputDispatched(input.conversation);
+    const accepted = input.outcome === "agent_accepted";
+    const pending = input.outcome === "enter_dispatched";
+    const callbackAvailable = !isTerminalDispatchOwnerReleasedStatus(input.conversation.status) &&
+        (accepted || pending) &&
+        callbackExpectedForConversation(input.conversation);
     printJson({
         session_id: sessionIdForConversation(input.conversation),
         turn_id: turnIdForConversation(input.conversation),
         conversation: input.conversation,
-        delivered: input.outcome === "agent_accepted",
-        delivery_receipt: input.outcome === "agent_accepted"
+        delivered: enterDispatched,
+        delivery_receipt: accepted
             ? "agent_accepted"
             : input.outcome === "enter_dispatched" ||
                 input.outcome === "not_accepted"
@@ -1434,9 +1442,16 @@ function printTerminalSubmissionRetryOutcome(input) {
         replayed: true,
         terminal_control: input.terminalControl,
         terminal_input_sent: input.terminalInputSent,
-        callback_expected: ["refused", "not_accepted"].includes(input.outcome)
-            ? false
-            : callbackExpectedForConversation(input.conversation),
+        callback_expected: callbackAvailable,
+        ...terminalSendResultContract({
+            terminalInputDispatched,
+            agentAcceptance: accepted ? "proven" : "unproven",
+            managementMode: "managed",
+            observationMode: callbackAvailable ? "managed_monitor" : "none",
+            callbackAvailable,
+            interactionNotificationAvailable: accepted,
+            interactionResponseAvailable: accepted
+        }),
         ...(input.attempt
             ? {
                 submission_retry_attempt_id: input.attempt.attempt_id,
@@ -2996,6 +3011,54 @@ async function runSend(options) {
     }
     return runManagedSessionSend(options, messageBody);
 }
+function captureDetachedCodexCandidateSessionClaims(input) {
+    const { inventory, terminal } = input;
+    const candidates = new Map(inventory.roots.map((root) => [
+        root.sessionId.toLowerCase(),
+        root
+    ]));
+    const claims = listManagedSessions(input.storeDir).flatMap((session) => {
+        const binding = session.binding;
+        const nativeThreadId = binding?.native_thread_id?.toLowerCase();
+        const candidate = nativeThreadId ? candidates.get(nativeThreadId) : undefined;
+        if (session.status !== "detached" || session.agent !== "codex" ||
+            !binding || !nativeThreadId || !candidate ||
+            !isCompleteNativeRollout(binding.native_process.rollout) ||
+            path.resolve(session.workspace) !==
+                path.resolve(terminal.terminalControl.currentPath ?? "") ||
+            binding.native_process.pid !== inventory.pid ||
+            binding.native_process.process_uuid !== inventory.processUuid ||
+            binding.native_process.process_birth !== inventory.processBirth ||
+            candidate.processUuid !== inventory.processUuid ||
+            candidate.processBirth !== inventory.processBirth ||
+            !terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, terminal.conversationId, terminal.terminalControl) ||
+            !rolloutFileIdentityMatches(binding.native_process.rollout, candidate.rollout)) {
+            return [];
+        }
+        return [{
+                session_id: session.session_id,
+                session_revision: managedSessionRevision(session),
+                session_binding_token: managedSessionBindingToken(session),
+                binding_id: binding.binding_id,
+                binding_generation: binding.generation,
+                native_thread_id: nativeThreadId,
+                process_uuid: inventory.processUuid,
+                process_birth: inventory.processBirth,
+                source_rollout: { ...binding.native_process.rollout },
+                candidate_rollout: { ...candidate.rollout }
+            }];
+    }).sort((left, right) => left.native_thread_id.localeCompare(right.native_thread_id) ||
+        left.session_id.localeCompare(right.session_id));
+    if (claims.length === 0)
+        return undefined;
+    const base = {
+        schema: "agent-knock-knock/codex-detached-candidate-session-claims",
+        version: 1,
+        anchor_fingerprint: input.anchor.anchor_fingerprint,
+        claims
+    };
+    return { ...base, claims_fingerprint: fingerprint(base) };
+}
 function rawTerminalInitialAuthority({ options, terminal, storeDir }) {
     const claimedSession = soleBoundManagedSessionClaimForTerminal(storeDir, terminal);
     const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
@@ -3235,6 +3298,7 @@ function releaseTerminalManagementForExplicitSendUnderWriter(input) {
                     warnings.push(`Turn ${explicitSendTurnReference(current)} dispatch cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
                 }
                 try {
+                    const terminalInputSent = durableTerminalInputDispatched(current);
                     appendExplicitUserCloseEvent(paths.logPath, {
                         ts: now,
                         conversation_id: current.conversation_id,
@@ -3242,7 +3306,8 @@ function releaseTerminalManagementForExplicitSendUnderWriter(input) {
                         status: "closed",
                         reason: closed.close_reason,
                         disposition: "user_abandoned_management",
-                        terminal_input_sent: false,
+                        terminal_input_sent: terminalInputSent,
+                        terminal_input_dispatched: terminalInputSent,
                         coding_agent_stopped: false,
                         tmux_pane_closed: false
                     });
@@ -3339,21 +3404,19 @@ function explicitTerminalSendIntentRuntimeDir() {
         : path.join(path.dirname(defaultStoreDir()), "runtime-v2");
 }
 function assertSafeUserExplicitTerminalSend(status) {
-    if (status?.reachable !== true) {
-        throw new Error("the explicitly selected terminal is unreachable");
-    }
-    const approval = isRecord(status.approval_state)
+    const approval = status && isRecord(status.approval_state)
         ? status.approval_state
         : undefined;
-    if (approval?.scanned !== true) {
-        throw new Error("the explicitly selected terminal approval state could not be verified");
-    }
-    if (approval?.blocked === true) {
-        throw new Error(stringValue(approval.reason) ??
-            "the explicitly selected terminal is waiting at an approval prompt");
-    }
-    if (status.activity_state === "awaiting_approval") {
-        throw new Error("the explicitly selected terminal is waiting at an approval prompt");
+    const decision = decideUserExplicitTerminalInputSafety({
+        reachable: status?.reachable === true,
+        approvalScanned: approval?.scanned === true,
+        approvalBlocked: approval?.blocked === true,
+        approvalReason: stringValue(approval?.reason),
+        awaitingApproval: status?.activity_state === "awaiting_approval",
+        questionnaireActive: status?.interaction_state !== undefined
+    });
+    if (decision.action === "reject") {
+        throw new Error(decision.reason);
     }
 }
 function terminalUserSendIntentContext(options, messageBody, terminal) {
@@ -3432,13 +3495,19 @@ function acquireUserExplicitTerminalSendLock(options, terminal, warnings) {
 function printReplayedUserExplicitSend(options, terminal, intent, deliveryMode) {
     if (deliveryMode === "managed") {
         printJson({
-            delivered: false,
+            delivered: true,
             replayed: true,
             status: "submission_pending_acceptance",
             submission_outcome: "pending_acceptance",
             delivery_receipt: "enter_dispatched",
             do_not_retry: true,
-            management_mode: "managed",
+            ...terminalSendResultContract({
+                terminalInputDispatched: true,
+                agentAcceptance: "unproven",
+                managementMode: "managed",
+                observationMode: "none",
+                callbackAvailable: false
+            }),
             terminal_id: terminal.conversationId,
             message_id: intent.messageId,
             scope: "terminal_user_explicit"
@@ -3454,11 +3523,20 @@ function printReplayedUserExplicitSend(options, terminal, intent, deliveryMode)
         options,
         watchId
     });
+    const callbackAvailable = callbackReceipt?.callback_expected === true;
     printJson({
         delivered: true,
         delivered_unmanaged: true,
+        delivery_receipt: "enter_dispatched",
         ...(callbackReceipt ?? { callback_expected: false }),
-        management_mode: "unmanaged_fallback",
+        ...terminalSendResultContract({
+            terminalInputDispatched: true,
+            agentAcceptance: "unproven",
+            managementMode: "unmanaged",
+            observationMode: callbackAvailable ? "terminal_watch" : "none",
+            callbackAvailable,
+            interactionNotificationAvailable: callbackAvailable
+        }),
         replayed: true,
         terminal_id: terminal.conversationId,
         message_id: intent.messageId,
@@ -3748,9 +3826,11 @@ async function runUserExplicitTerminalFallback(options, terminal, managedFailure
             composer_disposition: composerDisposition,
             delivered_unmanaged: true
         });
+        const callbackAvailable = callbackReceipt?.callback_expected === true;
         printJson({
             delivered: true,
             delivered_unmanaged: true,
+            delivery_receipt: "enter_dispatched",
             cleanup_warnings: cleanupWarnings,
             intent_warnings: intentWarnings,
             callback_warnings: callbackWarnings,
@@ -3758,7 +3838,14 @@ async function runUserExplicitTerminalFallback(options, terminal, managedFailure
             terminal_id: fresh.conversationId,
             message_id: messageId,
             scope: "terminal_user_explicit",
-            management_mode: "unmanaged_fallback",
+            ...terminalSendResultContract({
+                terminalInputDispatched: true,
+                agentAcceptance: "unproven",
+                managementMode: "unmanaged",
+                observationMode: callbackAvailable ? "terminal_watch" : "none",
+                callbackAvailable,
+                interactionNotificationAvailable: callbackAvailable
+            }),
             composer_disposition: composerDisposition,
             composer_cleared_before_send: true,
             // Deprecated compatibility alias. The v22 policy always dispatches
@@ -3783,7 +3870,14 @@ async function runUserExplicitTerminalFallback(options, terminal, managedFailure
     }
 }
 async function runRawTerminalSend(options, messageBody, terminalConversation) {
+    const identifyForeground = options.identifyForeground === true;
     const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
+    if (identifyForeground && terminalConversation.agent !== "codex") {
+        throw new Error("atomic foreground identification currently supports only Codex terminals");
+    }
+    if (identifyForeground && !suppliedExpectedTerminalToken) {
+        throw new Error("atomic foreground identification requires --expected-terminal-token");
+    }
     const userExplicitAuthorityRequested = Boolean(suppliedExpectedTerminalToken && options.managedOnly !== true);
     const freshExplicitAuthority = userExplicitAuthorityRequested
         ? hasFreshExplicitTerminalSendToken(options, terminalConversation)
@@ -3821,6 +3915,14 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
         }
         return;
     }
+    if (identifyForeground) {
+        // The explicit atomic contract never falls back to unmanaged delivery:
+        // doing so would discard the very identity/respond capability the caller
+        // asked this operation to establish. The task payload is proven unsent,
+        // so release its same-id reservation for an explicit later retry.
+        cancelProvenZeroInputUserExplicitSendIntent(intentLease, terminalConversation, managedResult.failure);
+        throw managedResult.failure;
+    }
     return runUserExplicitTerminalFallback(explicitOptions, terminalConversation, managedResult.failure, intentLease);
 }
 async function runManagedRawTerminalSend(options, messageBody, terminalConversation, deferZeroInputFailurePresentation = false) {
@@ -3843,6 +3945,343 @@ async function runManagedRawTerminalSend(options, messageBody, terminalConversat
             `automatic unmanaged fallback: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
+const USER_EXPLICIT_CALLBACK_SUPERSEDE_REASON = "superseded_by_user_explicit_send";
+function sessionHasUnresolvedForegroundMutation(storeDir, sessionId) {
+    try {
+        if (listNativeThreadTransitions(storeDir).some((transition) => (transition.source_session_id === sessionId ||
+            transition.target_session_id === sessionId) &&
+            !["committed", "aborted"].includes(transition.status))) {
+            return true;
+        }
+        return listDeferredForegroundTransfers(storeDir).some((transfer) => (transfer.source_session_id === sessionId ||
+            transfer.target_session_id === sessionId) &&
+            !isFinalDeferredForegroundTransferStatus(transfer.status));
+    }
+    catch {
+        // Corrupt or unreadable lifecycle evidence must never be bypassed.
+        return true;
+    }
+}
+async function supersedeExactHumanExplicitCallbackDebt(input) {
+    const { options, terminal, session, candidateInventory, storeDir, scopes, resources } = input;
+    const expectedManagedToken = stringValue(options.expectedTerminalToken);
+    const binding = session?.binding;
+    if (terminal.agent !== "codex" ||
+        stringValue(options.expectedUserExplicitTerminalToken) === undefined ||
+        !session ||
+        session.status !== "bound" ||
+        !binding ||
+        !humanExplicitCallbackDebtManagedTokenMatches(expectedManagedToken, session) ||
+        !candidateInventory ||
+        !exactBoundCodexSendSource({
+            kind: "candidate",
+            sourceSession: session,
+            context: {
+                terminalId: terminal.conversationId,
+                terminalControl: terminal.terminalControl,
+                pid: terminal.pid,
+                workspace: terminal.terminalControl.currentPath,
+                liveProcessUuid: candidateInventory.processUuid,
+                liveProcessBirth: candidateInventory.processBirth
+            },
+            inventory: candidateInventory,
+            sourceRolloutAuthority: "present"
+        }) ||
+        sessionHasUnresolvedForegroundMutation(storeDir, session.session_id)) {
+        return false;
+    }
+    const bindingTurns = managedTurnsForSession(storeDir, session.session_id)
+        .filter((turn) => turn.terminal_binding_id === binding.binding_id &&
+        turn.terminal_binding_generation === binding.generation);
+    const dispositions = bindingTurns.map((turn) => ({
+        turn,
+        disposition: humanExplicitCallbackDebtRetirementDisposition(turn, session)
+    }));
+    const candidates = dispositions
+        .filter(({ disposition }) => disposition === "supersedable")
+        .map(({ turn }) => turn);
+    if (candidates.length === 0 ||
+        dispositions.some(({ disposition }) => disposition === undefined)) {
+        return false;
+    }
+    let superseded = 0;
+    for (const candidate of candidates) {
+        const paths = pathsForConversation(candidate.conversation_id, storeDir);
+        const expectedDelivery = JSON.stringify(candidate.callback_delivery);
+        await withTerminalDispatchStateScope(scopes, resources, paths.statePath, paths.logPath, async () => {
+            const current = loadState(paths.statePath);
+            if (JSON.stringify(current.callback_delivery) !== expectedDelivery ||
+                humanExplicitCallbackDebtDisposition(current, session) !==
+                    "supersedable") {
+                return;
+            }
+            const at = cliNow().toISOString();
+            const next = supersedeUnacceptedCallbackDeliveries(current, {
+                at,
+                reason: USER_EXPLICIT_CALLBACK_SUPERSEDE_REASON
+            });
+            if (next.callback_delivery === current.callback_delivery)
+                return;
+            saveState(paths.statePath, next);
+            appendEvent(paths.logPath, {
+                ts: at,
+                conversation_id: current.conversation_id,
+                event: "callback_delivery_superseded_by_user_explicit_send",
+                status: current.status,
+                reason: USER_EXPLICIT_CALLBACK_SUPERSEDE_REASON,
+                prior_callback_status: isRecord(current.callback_delivery)
+                    ? current.callback_delivery.status
+                    : undefined,
+                prior_callback_attempt_disposition: callbackDeliveryAttemptOutcome(current.callback_delivery)
+                    ?.disposition,
+                // An uncertain transport may already have reached the controller.
+                // This records that the human-priority Send retired only future
+                // callback retries; it never asserts that delivery did not occur.
+                human_override_of_uncertain_callback: callbackDeliveryAttemptOutcome(current.callback_delivery)
+                    ?.disposition === "uncertain",
+                terminal_input_sent: false,
+                terminal_input_dispatched: false
+            });
+            superseded += 1;
+        });
+    }
+    return superseded === candidates.length;
+}
+function rawTerminalObservedIdentityForPreparation(input) {
+    if (input.atomicForegroundIdentification ||
+        input.sourceLessCandidateInventory !== undefined ||
+        input.observation.status !== "resolved") {
+        return undefined;
+    }
+    return input.observation.identity;
+}
+async function maybePrepareVerifiedEmptyCodexHandoff(input) {
+    if (input.implicitCandidateAuthority ||
+        input.atomicForegroundIdentification) {
+        return undefined;
+    }
+    return maybeDetachVerifiedEmptyCodexSource({
+        options: input.options,
+        terminal: input.terminal,
+        sourceSession: input.sourceSession,
+        observation: input.observation
+    });
+}
+function assertAtomicForegroundCandidateInventory(input) {
+    if (!input.enabled || input.claimedSession === undefined)
+        return;
+    if (input.inventory && input.inventory.roots.length > 0)
+        return;
+    throw new Error("atomic foreground identification requires a fresh nonempty " +
+        "candidate-set acceptance boundary; no task input was sent");
+}
+function assertAtomicForegroundAcceptanceBoundary(input) {
+    if (!input.enabled)
+        return;
+    if (input.deferred?.candidateAcceptanceAnchor || input.postSend)
+        return;
+    throw new Error("atomic foreground identification could not establish an exact " +
+        "task-acceptance boundary; no task input was sent");
+}
+async function prepareRawTerminalDispatchAuthority(input) {
+    const { options, messageBody, terminal, storeDir, scopes, resources } = input;
+    const atomicForegroundIdentification = options.identifyForeground === true;
+    const initialAuthority = rawTerminalInitialAuthority({
+        options,
+        terminal,
+        storeDir
+    });
+    let { claimedSession, knownCodexCompanions } = initialAuthority;
+    const { suppliedExpectedTerminalToken, implicitCodexCandidateAuthority } = initialAuthority;
+    const userExplicitTerminalToken = stringValue(options.expectedUserExplicitTerminalToken);
+    const nativeIdentityObservation = await observeCurrentNativeAgentSessionIdentity({
+        options,
+        agent: terminal.agent,
+        pid: terminal.pid,
+        cwd: terminal.terminalControl.currentPath,
+        preferredSessionId: knownCodexCompanions.primary
+            ? claimedSession?.binding?.native_thread_id
+            : undefined,
+        allowedCompanionIdentity: knownCodexCompanions.primary,
+        allowedAdditionalIdentities: knownCodexCompanions.additional
+    });
+    let deferredCodexCandidateInventory;
+    if (terminal.agent === "codex" &&
+        (userExplicitTerminalToken ||
+            suppliedExpectedTerminalToken ||
+            implicitCodexCandidateAuthority)) {
+        try {
+            const inventory = await inspectCodexOpenRootRolloutInventory({
+                options,
+                pid: terminal.pid,
+                cwd: terminal.terminalControl.currentPath
+            });
+            // An empty set is meaningful only for a source-less human Send: it is
+            // the frozen proof that the first accepting rollout must appear after
+            // Enter. Preserve the older bound/deferred behavior otherwise.
+            if (inventory.roots.length > 0 ||
+                (userExplicitTerminalToken !== undefined && claimedSession === undefined)) {
+                deferredCodexCandidateInventory = inventory;
+            }
+        }
+        catch (error) {
+            if ((userExplicitTerminalToken !== undefined &&
+                claimedSession === undefined) ||
+                implicitCodexCandidateAuthority ||
+                nativeIdentityObservation.status === "unavailable") {
+                throw new Error(`native Codex foreground attribution requires a fresh complete ` +
+                    `open-root inventory: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    assertRawTerminalCandidateAuthority({
+        terminal,
+        nativeIdentityObservation,
+        deferredCodexCandidateInventory,
+        implicitCodexCandidateAuthority
+    });
+    const sourceLessCodexCandidateInventory = terminal.agent === "codex" &&
+        userExplicitTerminalToken !== undefined &&
+        claimedSession === undefined
+        ? deferredCodexCandidateInventory
+        : undefined;
+    let currentNativeIdentity = rawTerminalObservedIdentityForPreparation({
+        atomicForegroundIdentification,
+        sourceLessCandidateInventory: sourceLessCodexCandidateInventory,
+        observation: nativeIdentityObservation
+    });
+    // A fresh nonempty inventory is the stronger physical authority for an
+    // implicit candidate send. Do not let an earlier verified-absent
+    // observation divert this path into the token-only empty handoff.
+    const verifiedEmptyHandoff = await maybePrepareVerifiedEmptyCodexHandoff({
+        options,
+        terminal,
+        sourceSession: claimedSession,
+        observation: nativeIdentityObservation,
+        implicitCandidateAuthority: implicitCodexCandidateAuthority,
+        atomicForegroundIdentification
+    });
+    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;
+    // The status card emitted by identify_foreground is diagnostic evidence,
+    // never handoff authority. Let the existing candidate-set/deferred path
+    // bind only the rollout that later accepts the exact task request.
+    let handoff = atomicForegroundIdentification
+        ? { identity: undefined, adopted: false }
+        : await maybeAdoptObservedExternalThread({
+            options,
+            terminal,
+            // A no-token raw send to an already managed rollout-backed Codex pane
+            // is an internal follow-current delegation, not a sole-root
+            // continuation.
+            sourceSession: implicitCodexCandidateAuthority
+                ? undefined
+                : claimedSession,
+            resolvedIdentity: sourceLessCodexCandidateInventory
+                ? undefined
+                : currentNativeIdentity,
+            storeDir
+        });
+    currentNativeIdentity =
+        handoff.adopted && terminal.agent === "codex" &&
+            !handoff.session?.binding?.native_process.rollout
+            ? physicalNativeIdentityBeforeHandoff
+            : handoff.identity;
+    if (!handoff.adopted) {
+        await supersedeExactHumanExplicitCallbackDebt({
+            options,
+            terminal,
+            session: claimedSession,
+            candidateInventory: deferredCodexCandidateInventory,
+            storeDir,
+            scopes,
+            resources
+        });
+    }
+    assertAtomicForegroundCandidateInventory({
+        enabled: atomicForegroundIdentification,
+        claimedSession,
+        inventory: deferredCodexCandidateInventory
+    });
+    const deferredCodexForegroundBinding = !handoff.adopted
+        ? await prepareDeferredCodexForegroundBinding({
+            options,
+            scope: bindDeferredForegroundWriterScope(scopes, resources),
+            terminal,
+            sourceSession: claimedSession,
+            observation: nativeIdentityObservation,
+            candidateInventory: deferredCodexCandidateInventory,
+            requestText: String(messageBody),
+            allowImplicitFreshAuthority: implicitCodexCandidateAuthority
+        })
+        : undefined;
+    const postSendCodexCandidateAnchor = terminal.agent === "codex" &&
+        userExplicitTerminalToken !== undefined &&
+        sourceLessCodexCandidateInventory !== undefined &&
+        verifiedEmptyHandoff === undefined &&
+        !handoff.adopted &&
+        deferredCodexForegroundBinding === undefined &&
+        claimedSession === undefined
+        ? captureCodexCandidateSetRolloutAcceptanceAnchor({
+            inventory: sourceLessCodexCandidateInventory,
+            now: cliNow()
+        })
+        : undefined;
+    const postSendCodexDetachedSessionClaims = postSendCodexCandidateAnchor &&
+        sourceLessCodexCandidateInventory
+        ? captureDetachedCodexCandidateSessionClaims({
+            storeDir,
+            terminal,
+            inventory: sourceLessCodexCandidateInventory,
+            anchor: postSendCodexCandidateAnchor
+        })
+        : undefined;
+    assertAtomicForegroundAcceptanceBoundary({
+        enabled: atomicForegroundIdentification,
+        deferred: deferredCodexForegroundBinding,
+        postSend: postSendCodexCandidateAnchor
+    });
+    const freshSendAuthority = decideTerminalSendAuthority({
+        ownership: "conflict",
+        verifiedEmpty: Boolean(verifiedEmptyHandoff),
+        externalHandoff: handoff.adopted,
+        deferred: Boolean(deferredCodexForegroundBinding)
+    });
+    if (freshSendAuthority.mode === "deferred" &&
+        deferredCodexForegroundBinding) {
+        claimedSession = undefined;
+        knownCodexCompanions = { additional: [] };
+        currentNativeIdentity = undefined;
+        handoff = { identity: undefined, adopted: false };
+    }
+    else if ((userExplicitTerminalToken ||
+        suppliedExpectedTerminalToken ||
+        implicitCodexCandidateAuthority) &&
+        !postSendCodexCandidateAnchor &&
+        freshSendAuthority.mode === "conflict") {
+        throw new Error("managed continuation authority is unavailable for the current " +
+            "terminal context" +
+            (userExplicitTerminalToken
+                ? "; the physical terminal authority remains valid"
+                : "; refresh AKK list before retrying managed delivery"));
+    }
+    return {
+        nativeIdentityObservation,
+        knownCodexCompanions,
+        currentNativeIdentity,
+        verifiedEmptyHandoff,
+        handoff,
+        deferredCodexForegroundBinding,
+        postSendCodexCandidateAnchor,
+        postSendCodexDetachedSessionClaims
+    };
+}
 async function runManagedRawTerminalSendAttempt(options, messageBody, terminalConversation, deferZeroInputFailurePresentation, attempt) {
     // A token copied from list is authority for exactly the advertised full
     // terminal selector. Reject aliases and implicit/no-selector resolution
@@ -3856,7 +4295,33 @@ async function runManagedRawTerminalSendAttempt(options, messageBody, terminalCo
     }
     const rawStoreDir = storeDirFromOptions(options);
     let controlSendResult;
-    await withCanonicalMutationLocks(terminalWriterMutationLocks(rawStoreDir, terminalConversation.terminalControl, deferZeroInputFailurePresentation ? { timeoutMs: 0 } : undefined), async (scopes, resources) => {
+    const atomicForegroundIdentification = options.identifyForeground === true;
+    foregroundIdentificationProofs.delete(options);
+    const userExplicitLockOptions = deferZeroInputFailurePresentation
+        ? {
+            terminalTimeoutMs: 0,
+            storeWriterTimeoutMs: USER_EXPLICIT_MANAGED_LOCK_GRACE_MS
+        }
+        : undefined;
+    const lockOptions = atomicForegroundIdentification
+        ? {
+            ...userExplicitLockOptions,
+            afterTerminalAcquired: async () => {
+                const expectedTerminalToken = required(stringValue(options.expectedUserExplicitTerminalToken), "atomic foreground identification requires fresh physical terminal authority");
+                const proof = await identifyCodexForegroundWhileLocked({
+                    options,
+                    terminal: terminalConversation,
+                    expectedTerminalToken
+                });
+                if (proof.terminalId !== terminalConversation.conversationId ||
+                    proof.pid !== terminalConversation.pid) {
+                    throw new Error("foreground identification returned evidence for a different terminal");
+                }
+                foregroundIdentificationProofs.set(options, proof);
+            }
+        }
+        : userExplicitLockOptions;
+    await withCanonicalMutationLocks(terminalWriterMutationLocks(rawStoreDir, terminalConversation.terminalControl, lockOptions), async (scopes, resources) => {
         await assertFreshUserExplicitTerminalSendTargetWhileLocked(options, terminalConversation);
         await mutationDispatchLedger.beforeMutation(scopes, resources, options, terminalConversation);
         // Upgrade legacy Stores before resolving their Session authority. The
@@ -3868,129 +4333,24 @@ async function runManagedRawTerminalSendAttempt(options, messageBody, terminalCo
             terminalControl: terminalConversation.terminalControl,
             requestText: String(messageBody),
             expectedStoreDir: rawStoreDir,
-            expectedMessageType: "task"
+            expectedMessageType: "task",
+            ...(stringValue(options.expectedUserExplicitTerminalToken)
+                ? { userExplicitTerminalId: terminalConversation.conversationId }
+                : {})
         })) {
             controlSendResult = { outcome: "replayed" };
             attempt.result = controlSendResult;
             return;
         }
         terminalListCliFacade.assertTerminalIncarnationCanStartTurn(rawStoreDir, terminalConversation.terminalControl);
-        const initialAuthority = rawTerminalInitialAuthority({
-            options,
-            terminal: terminalConversation,
-            storeDir: rawStoreDir
-        });
-        let { claimedSession, knownCodexCompanions } = initialAuthority;
-        const { suppliedExpectedTerminalToken, implicitCodexCandidateAuthority } = initialAuthority;
-        const nativeIdentityObservation = await observeCurrentNativeAgentSessionIdentity({
-            options,
-            agent: terminalConversation.agent,
-            pid: terminalConversation.pid,
-            cwd: terminalConversation.terminalControl.currentPath,
-            preferredSessionId: knownCodexCompanions.primary
-                ? claimedSession?.binding?.native_thread_id
-                : undefined,
-            allowedCompanionIdentity: knownCodexCompanions.primary,
-            allowedAdditionalIdentities: knownCodexCompanions.additional
-        });
-        let deferredCodexCandidateInventory;
-        if (terminalConversation.agent === "codex" &&
-            (suppliedExpectedTerminalToken || implicitCodexCandidateAuthority)) {
-            try {
-                const inventory = await inspectCodexOpenRootRolloutInventory({
-                    options,
-                    pid: terminalConversation.pid,
-                    cwd: terminalConversation.terminalControl.currentPath
-                });
-                if (inventory.roots.length > 0) {
-                    deferredCodexCandidateInventory = inventory;
-                }
-            }
-            catch (error) {
-                if (implicitCodexCandidateAuthority ||
-                    nativeIdentityObservation.status === "unavailable") {
-                    throw new Error(`native Codex foreground attribution requires a fresh complete ` +
-                        `open-root inventory: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        assertRawTerminalCandidateAuthority({
-            terminal: terminalConversation,
-            nativeIdentityObservation,
-            deferredCodexCandidateInventory,
-            implicitCodexCandidateAuthority
-        });
-        let currentNativeIdentity = nativeIdentityObservation.status === "resolved"
-            ? nativeIdentityObservation.identity
-            : undefined;
-        // A fresh nonempty inventory is the stronger physical authority for an
-        // implicit candidate send. Do not let an earlier verified-absent
-        // observation divert this path into the token-only empty handoff.
-        const verifiedEmptyHandoff = implicitCodexCandidateAuthority
-            ? undefined
-            : await maybeDetachVerifiedEmptyCodexSource({
-                options,
-                terminal: terminalConversation,
-                sourceSession: claimedSession,
-                observation: nativeIdentityObservation
-            });
-        if (verifiedEmptyHandoff) {
-            // The old rollout is conclusively closed.  Never carry it forward as
-            // a pre-materialization companion for the new virgin Session.
-            claimedSession = undefined;
-            knownCodexCompanions = { additional: [] };
-            currentNativeIdentity = undefined;
-        }
-        const physicalNativeIdentityBeforeHandoff = currentNativeIdentity;
-        let handoff = await maybeAdoptObservedExternalThread({
+        const { nativeIdentityObservation, knownCodexCompanions, currentNativeIdentity, verifiedEmptyHandoff, handoff, deferredCodexForegroundBinding, postSendCodexCandidateAnchor, postSendCodexDetachedSessionClaims } = await prepareRawTerminalDispatchAuthority({
             options,
+            messageBody,
             terminal: terminalConversation,
-            // A no-token raw send to an already managed rollout-backed Codex pane
-            // is an internal follow-current delegation, never a sole-root strict
-            // continuation or an external-handoff adoption. The dedicated v3
-            // transfer below owns attribution and lineage.
-            sourceSession: implicitCodexCandidateAuthority
-                ? undefined
-                : claimedSession,
-            resolvedIdentity: currentNativeIdentity,
-            storeDir: rawStoreDir
-        });
-        currentNativeIdentity =
-            handoff.adopted &&
-                terminalConversation.agent === "codex" &&
-                !handoff.session?.binding?.native_process.rollout
-                ? physicalNativeIdentityBeforeHandoff
-                : handoff.identity;
-        const deferredCodexForegroundBinding = !handoff.adopted
-            ? await prepareDeferredCodexForegroundBinding({
-                options,
-                scope: bindDeferredForegroundWriterScope(scopes, resources),
-                terminal: terminalConversation,
-                sourceSession: claimedSession,
-                observation: nativeIdentityObservation,
-                candidateInventory: deferredCodexCandidateInventory,
-                requestText: String(messageBody),
-                allowImplicitFreshAuthority: implicitCodexCandidateAuthority
-            })
-            : undefined;
-        const freshSendAuthority = decideTerminalSendAuthority({
-            ownership: "conflict",
-            verifiedEmpty: Boolean(verifiedEmptyHandoff),
-            externalHandoff: handoff.adopted,
-            deferred: Boolean(deferredCodexForegroundBinding)
+            storeDir: rawStoreDir,
+            scopes,
+            resources
         });
-        if (freshSendAuthority.mode === "deferred" &&
-            deferredCodexForegroundBinding) {
-            claimedSession = undefined;
-            knownCodexCompanions = { additional: [] };
-            currentNativeIdentity = undefined;
-            handoff = { identity: undefined, adopted: false };
-        }
-        else if ((suppliedExpectedTerminalToken || implicitCodexCandidateAuthority) &&
-            freshSendAuthority.mode === "conflict") {
-            throw new Error("the expected terminal token no longer authorizes the current " +
-                "terminal context; refresh AKK list");
-        }
         let managedSession = deferredCodexForegroundBinding
             ? undefined
             : handoff.session ??
@@ -4068,7 +4428,7 @@ async function runManagedRawTerminalSendAttempt(options, messageBody, terminalCo
         const materializedNativeIdentity = currentNativeIdentity?.sessionId === logicalNativeIdentity?.sessionId
             ? currentNativeIdentity
             : undefined;
-        if (!(handoff.adopted &&
+        if (options.identifyForeground !== true && !(handoff.adopted &&
             terminalConversation.agent === "codex" &&
             !managedSession.binding?.native_process.rollout)) {
             await verifyCodexPendingManagedSendStatus({
@@ -4197,10 +4557,14 @@ async function runManagedRawTerminalSendAttempt(options, messageBody, terminalCo
                     }
                     : undefined,
                 verifiedEmptyCodexHandoff: verifiedEmptyHandoff?.boundary,
+                postSendCodexCandidateAnchor,
+                postSendCodexDetachedSessionClaims,
                 deferredCodexForegroundBinding
             });
             attempt.result = controlSendResult;
-        }, deferZeroInputFailurePresentation ? { timeoutMs: 0 } : undefined);
+        }, deferZeroInputFailurePresentation
+            ? { timeoutMs: USER_EXPLICIT_MANAGED_LOCK_GRACE_MS }
+            : undefined);
     });
     if (!controlSendResult) {
         throw new Error("managed terminal Send completed without an outcome");
@@ -5438,8 +5802,121 @@ async function runTerminalConversationApprove({ options, terminal }) {
         releaseTerminalLock();
     }
 }
+function terminalSendCandidateAcceptanceAnchor(request) {
+    return request.deferredCodexForegroundBinding?.candidateAcceptanceAnchor ??
+        request.postSendCodexCandidateAnchor;
+}
+function assertTerminalNativeBindingBeforeSend(input) {
+    if (!input.needsPostSendNativeBinding) {
+        input.execution.assertTurnIdentity({
+            conversation: input.conversation,
+            currentIdentity: input.currentNativeIdentity,
+            operation: "send to"
+        });
+        return;
+    }
+    if (input.currentNativeIdentity &&
+        !nativeIdentityMatchesCodexPreMaterialization(input.currentNativeIdentity, input.allowedPreMaterializationIdentity)) {
+        throw new Error("native agent session appeared while preparing an unmaterialized terminal binding; refresh list and retry");
+    }
+}
+function terminalPreSendRuntime(input) {
+    const { request, terminalControl, terminalAgentPid } = input;
+    const { conversation, nextConversation, executor, message, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], deferredCodexForegroundBinding } = request;
+    const candidateAnchor = terminalSendCandidateAcceptanceAnchor(request);
+    return {
+        ...(candidateAnchor
+            ? terminalRuntimeForLiveIdentity({
+                terminal: deferredCodexForegroundBinding?.terminal ?? {
+                    conversationId: conversation.conversation_id,
+                    agent: executor.kind,
+                    pid: terminalAgentPid,
+                    terminalControl
+                },
+                physicalOnly: true
+            })
+            : terminalRuntimeIdentityForConversation(nextConversation, terminalControl)),
+        allowedPreMaterializationNativeIdentity: allowedPreMaterializationIdentity,
+        allowedAdditionalNativeIdentities: allowedAdditionalIdentities,
+        messageId: message.id
+    };
+}
+function assertTerminalPreSendStatus(input) {
+    const { request, status } = input;
+    if (stringValue(request.options.expectedUserExplicitTerminalToken)) {
+        // Managed promotion is only a sidecar for a human-priority Send. It may
+        // relax lifecycle/activity attribution, never the shared physical gate
+        // that proves this TUI is not an approval or questionnaire input mode.
+        assertSafeUserExplicitTerminalSend(status);
+    }
+    const deferredCodexPrompt = Boolean(request.verifiedEmptyCodexHandoff ||
+        request.deferredCodexForegroundBinding ||
+        request.postSendCodexCandidateAnchor);
+    if (!deferredCodexPrompt) {
+        assertSafeTerminalSend(request.executor.kind, status);
+        return;
+    }
+    if (request.executor.kind !== "codex" ||
+        status.reachable !== true ||
+        status.approval_state.blocked === true ||
+        status.interaction_state !== undefined ||
+        !["idle", "unknown"].includes(status.activity_state)) {
+        throw new Error(`Codex deferred foreground send is not at a safe prompt ` +
+            `(${status.activity_state}: ${status.activity_reason})`);
+    }
+}
+function assertAtomicForegroundIdentificationProof(input) {
+    if (input.options.identifyForeground !== true)
+        return;
+    if (input.executor.kind !== "codex") {
+        throw new Error("atomic foreground identification currently supports only Codex terminals");
+    }
+    const proof = foregroundIdentificationProofs.get(input.options);
+    if (!proof) {
+        throw new Error("atomic foreground identification proof is unavailable; no task input was sent");
+    }
+    const expiresAtMs = Date.parse(proof.expiresAt);
+    if (!Number.isFinite(expiresAtMs) || cliNowMs() >= expiresAtMs) {
+        throw new Error("atomic foreground identification proof expired before task dispatch; no task input was sent");
+    }
+    const processIncarnation = processIncarnationForPid(input.terminalAgentPid);
+    if (proof.pid !== input.terminalAgentPid ||
+        proof.processUuid !== processIncarnation.processUuid ||
+        proof.processBirth !== processIncarnation.processBirth) {
+        throw new Error("Codex process incarnation changed after foreground identification; no task input was sent");
+    }
+    const cwd = stringValue(input.terminalControl.currentPath);
+    let realCwd;
+    try {
+        realCwd = cwd ? fs.realpathSync(cwd) : undefined;
+    }
+    catch {
+        realCwd = undefined;
+    }
+    if (!realCwd || realCwd !== proof.realCwd) {
+        throw new Error("Codex terminal cwd changed after foreground identification; no task input was sent");
+    }
+    if (!stringValue(input.status.screen.digest) ||
+        input.status.screen.digest !== proof.postProbeScreenDigest) {
+        throw new Error("Codex screen generation changed after foreground identification; no task input was sent");
+    }
+    const observation = createRuntimeTerminalAgentRegistry(input.options)
+        .require("codex")
+        .observeNativeInspection?.({
+        operation: { kind: "status" },
+        screen: input.status.screen.excerpt ?? "",
+        expectedNativeThreadId: proof.nativeThreadId,
+        expectedAgentVersion: proof.agentVersion,
+        expectedCwd: proof.realCwd
+    });
+    if (observation?.status !== "observed" ||
+        observation.nativeThreadId !== proof.nativeThreadId ||
+        observation.evidenceFingerprint !== proof.evidenceFingerprint) {
+        throw new Error("Codex /status identity changed after foreground identification; no task input was sent");
+    }
+}
 async function prepareTerminalControlSend(request) {
-    const { transaction, options, conversation, nextConversation, executor, message, recordRawAttachmentAfterSend = false, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], verifiedEmptyCodexHandoff, deferredCodexForegroundBinding, continuingTurnResponse = false } = request;
+    const { transaction, options, conversation, executor, message, recordRawAttachmentAfterSend = false, allowedPreMaterializationIdentity, allowedAdditionalIdentities = [], deferredCodexForegroundBinding, continuingTurnResponse = false } = request;
     const bridge = terminalBridgeEnabled(conversation);
     const route = bindTerminalDispatchRoute(transaction.scopes, transaction.resources);
     const { terminalControl, storeDir: lockedStoreDir, statePath, logPath } = route;
@@ -5490,8 +5967,8 @@ async function prepareTerminalControlSend(request) {
         : undefined;
     const terminalAgentPid = Number(sendTakeover?.terminal_agent_pid);
     const expectedManagedNativeThreadId = stringValue(sendTakeover?.terminal_agent_expected_session_id) ?? stringValue(sendTakeover?.terminal_agent_session_id);
-    const currentNativeIdentity = deferredCodexForegroundBinding
-        ?.candidateAcceptanceAnchor
+    const candidateSetAnchor = terminalSendCandidateAcceptanceAnchor(request);
+    const currentNativeIdentity = candidateSetAnchor
         ? undefined
         : await execution.resolveCurrentNativeIdentity({
             agent: executor.kind,
@@ -5508,30 +5985,18 @@ async function prepareTerminalControlSend(request) {
     const pendingManagedNativeBinding = Boolean(!stringValue(sendTakeover?.terminal_agent_session_id) &&
         stringValue(sendTakeover?.terminal_agent_expected_session_id));
     const needsPostSendNativeBinding = virginRawAttach || pendingManagedNativeBinding;
-    if (needsPostSendNativeBinding) {
-        if (currentNativeIdentity &&
-            !nativeIdentityMatchesCodexPreMaterialization(currentNativeIdentity, allowedPreMaterializationIdentity)) {
-            throw new Error("native agent session appeared while preparing an unmaterialized terminal binding; refresh list and retry");
-        }
-    }
-    else {
-        execution.assertTurnIdentity({
-            conversation,
-            currentIdentity: currentNativeIdentity,
-            operation: "send to"
-        });
-    }
-    const preSendRuntime = {
-        ...(deferredCodexForegroundBinding?.candidateAcceptanceAnchor
-            ? terminalRuntimeForLiveIdentity({
-                terminal: deferredCodexForegroundBinding.terminal,
-                physicalOnly: true
-            })
-            : terminalRuntimeIdentityForConversation(nextConversation, terminalControl)),
-        allowedPreMaterializationNativeIdentity: allowedPreMaterializationIdentity,
-        allowedAdditionalNativeIdentities: allowedAdditionalIdentities,
-        messageId: message.id
-    };
+    assertTerminalNativeBindingBeforeSend({
+        execution,
+        conversation,
+        currentNativeIdentity,
+        needsPostSendNativeBinding,
+        allowedPreMaterializationIdentity
+    });
+    const preSendRuntime = terminalPreSendRuntime({
+        request,
+        terminalControl,
+        terminalAgentPid
+    });
     let preSendScreenFingerprint;
     let codexRolloutAcceptanceAnchor;
     let claudeTranscriptAnchor;
@@ -5540,21 +6005,20 @@ async function prepareTerminalControlSend(request) {
         : undefined;
     try {
         const status = await terminalBridge.status(executor.kind, terminalControl, {
-            scrollbackLines: Number(options.scrollbackLines ?? 120),
+            scrollbackLines: options.identifyForeground === true
+                ? foregroundIdentificationProofs.get(options)
+                    ?.observationScrollbackLines ?? 240
+                : Number(options.scrollbackLines ?? 120),
             runtime: preSendRuntime
         });
-        if (verifiedEmptyCodexHandoff || deferredCodexForegroundBinding) {
-            if (executor.kind !== "codex" ||
-                status.reachable !== true ||
-                status.approval_state.blocked === true ||
-                !["idle", "unknown"].includes(status.activity_state)) {
-                throw new Error(`Codex deferred foreground send is not at a safe prompt ` +
-                    `(${status.activity_state}: ${status.activity_reason})`);
-            }
-        }
-        else {
-            assertSafeTerminalSend(executor.kind, status);
-        }
+        assertAtomicForegroundIdentificationProof({
+            options,
+            executor,
+            terminalControl,
+            terminalAgentPid,
+            status
+        });
+        assertTerminalPreSendStatus({ request, status });
         const userExplicitManagedCodexAttempt = Boolean(stringValue(options.expectedUserExplicitTerminalToken));
         if (executor.kind === "claude" &&
             userExplicitManagedCodexAttempt &&
@@ -5596,7 +6060,7 @@ async function prepareTerminalControlSend(request) {
                     boundProcessBirth: stringValue(sendTakeover?.terminal_agent_process_birth),
                     allowedPreMaterializationIdentity,
                     needsPostSendNativeBinding,
-                    candidateSetAnchor: deferredCodexForegroundBinding?.candidateAcceptanceAnchor
+                    candidateSetAnchor
                 });
             }
             else {
@@ -5655,8 +6119,7 @@ async function resolveTerminalDispatchSubmissionOwner(prepared, request, applica
             expectedSessionId: stringValue(sendTakeover?.terminal_agent_expected_session_id),
             allowedPreMaterializationIdentity,
             allowedAdditionalIdentities,
-            ...(deferredBinding &&
-                acceptanceAnchor &&
+            ...(acceptanceAnchor &&
                 [2, 3].includes(acceptanceAnchor.version)
                 ? {
                     requiredCodexAcceptance: {
@@ -5711,15 +6174,26 @@ async function resolveTerminalDispatchSubmissionOwner(prepared, request, applica
                 });
             }
             else {
-                await assertNativeThreadHasExclusiveOwnership({
-                    options,
-                    agent: executor.kind,
-                    currentPid: terminalAgentPid,
-                    nativeThreadId: boundIdentity.sessionId,
-                    storeDir: identityRoute.storeDir,
-                    terminalControl,
-                    excludedManagedSessionId: sessionIdForConversation(boundConversation)
-                });
+                if (executor.kind === "codex") {
+                    await rawPort("prepareManagedSessionNativeIdentityClaim")({
+                        options,
+                        conversation: boundConversation,
+                        identity: boundIdentity,
+                        storeDir: identityRoute.storeDir,
+                        terminalControl
+                    });
+                }
+                else {
+                    await assertNativeThreadHasExclusiveOwnership({
+                        options,
+                        agent: executor.kind,
+                        currentPid: terminalAgentPid,
+                        nativeThreadId: boundIdentity.sessionId,
+                        storeDir: identityRoute.storeDir,
+                        terminalControl,
+                        excludedManagedSessionId: sessionIdForConversation(boundConversation)
+                    });
+                }
                 persistManagedSessionNativeIdentity({
                     conversation: boundConversation,
                     terminalControl,
@@ -5727,7 +6201,8 @@ async function resolveTerminalDispatchSubmissionOwner(prepared, request, applica
                     storeDir: identityRoute.storeDir
                 });
             }
-            if (acceptanceAnchor?.version === 2 &&
+            if (acceptanceAnchor &&
+                [2, 3].includes(acceptanceAnchor.version) &&
                 cliEnv().AKK_TEST_EXIT_AFTER_VIRGIN_SESSION_BINDING === "1") {
                 cliExit(86);
             }
@@ -5787,8 +6262,7 @@ async function resolveTerminalDispatchSubmissionOwner(prepared, request, applica
     if (boundIdentity && boundConversation) {
         return ready(boundConversation);
     }
-    if (deferredBinding &&
-        acceptanceAnchor?.version === 3 &&
+    if (acceptanceAnchor?.version === 3 &&
         bindingError === undefined) {
         return ready(stagedConversation, true);
     }
@@ -5889,7 +6363,7 @@ function terminalDispatchRollbackRepositories({ request, prepared, deferredForeg
     return { rollbackBeforeInput, restoreDeferred };
 }
 function createTerminalDispatchRuntime(request, prepared, rollback) {
-    const { transaction, conversation, nextConversation, executor, message, recordRawAttachmentAfterSend = false } = request;
+    const { transaction, conversation, nextConversation, executor, message, recordRawAttachmentAfterSend = false, postSendCodexDetachedSessionClaims } = request;
     const { bridge, terminalControl, lockedStoreDir, statePath, logPath, bridgeStartedAt, submissionPreparedAt, agentTimeoutMinutes, agentHardTimeoutMinutes, terminalPayload, terminalRequestHash, previousDispatchLedger, preSendScreenFingerprint, codexRolloutAcceptanceAnchor, claudeTranscriptAnchor, claudeHome } = prepared;
     const terminalMessage = message;
     const bridgeConversation = bridge
@@ -5903,6 +6377,7 @@ function createTerminalDispatchRuntime(request, prepared, rollback) {
             monitorLockVersion: monitorOwner.LOCK_VERSION,
             preSendScreenFingerprint,
             codexRolloutAcceptanceAnchor,
+            codexDetachedCandidateSessionClaims: postSendCodexDetachedSessionClaims,
             claudeTranscriptAnchor,
             claudeHome
         })
@@ -6059,16 +6534,38 @@ function terminalDispatchTransportLifecycle({ request, prepared, application, de
             : {}),
         recordStage: (stage, at, afterDurable) => application.recordTransportStage(stage, at, afterDurable)
     });
+    const lifecycleBeforeText = lifecycle.beforeText;
+    const guardedLifecycle = options.identifyForeground === true
+        ? {
+            ...lifecycle,
+            beforeText: async () => {
+                await lifecycleBeforeText?.();
+                const proof = foregroundIdentificationProofs.get(options);
+                const status = await prepared.terminalBridge.status(request.executor.kind, prepared.terminalControl, {
+                    runtime: prepared.preSendRuntime,
+                    scrollbackLines: proof?.observationScrollbackLines ??
+                        CODEX_FOREGROUND_IDENTIFICATION_SCROLLBACK_LINES
+                });
+                assertAtomicForegroundIdentificationProof({
+                    options,
+                    executor: request.executor,
+                    terminalControl: prepared.terminalControl,
+                    terminalAgentPid: prepared.terminalAgentPid,
+                    status
+                });
+            }
+        }
+        : lifecycle;
     const userExplicitTerminalSend = Boolean(stringValue(options.expectedUserExplicitTerminalToken));
     return userExplicitTerminalSend
         ? {
-            ...lifecycle,
+            ...guardedLifecycle,
             requireExactEmptyComposerBeforeText: true,
             ...(request.executor.kind === "codex"
                 ? { userExplicitEnterAfterTextWithoutComposerVeto: true }
                 : {})
         }
-        : lifecycle;
+        : guardedLifecycle;
 }
 async function terminalDispatchAcceptance({ request, prepared, conversation }) {
     const { options, executor } = request;
@@ -6222,7 +6719,8 @@ async function runTerminalDispatchTransport({ request, prepared, application, pr
         if (!progress.enterDispatchedAt) {
             throw new Error("terminal bridge returned without an enter_dispatched receipt");
         }
-        if (codexRolloutAcceptanceAnchor?.version === 2 &&
+        if (codexRolloutAcceptanceAnchor &&
+            [2, 3].includes(codexRolloutAcceptanceAnchor.version) &&
             cliEnv().AKK_TEST_EXIT_AFTER_VIRGIN_ENTER_DISPATCHED === "1") {
             cliExit(86);
         }