@scotthuang/agent-knock-knock 0.12.13 → 0.12.15

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

@@ -1,18 +1,24 @@
 // Raw CLI infrastructure for ordinary terminal send/respond/approval commands.
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
+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 { captureClaudeTranscriptAnchor, defaultClaudeHome } from "./claude-local-transcript-provider.js";
+import { validateCodexRolloutAcceptanceAnchor } from "./terminal-submission-acceptance.js";
 import { isRecord, nonBlankString as stringValue } from "./value-guards.js";
-import { applyMessageToConversation, budgetAction, createMessage, effectiveTurnStatus, executorForConversation, isTerminalDispatchOwnerReleasedStatus, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
+import { deferredForegroundActiveMessageId, isDeferredForegroundSubmissionRetryPending } from "./deferred-foreground-transfer.js";
+import { applyMessageToConversation, budgetAction, createMessage, effectiveTurnStatus, executorForConversation, isSessionSendBlockingStatus, isTerminalDispatchOwnerReleasedStatus, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
 import { readNdjsonLog } from "./transcript.js";
-import { appendEvent, ensureDir, ensureStoreWritable, listConversations, loadState, messageEvent, pathsForConversationDir, saveState, withStoreWriterLeaseAsync } from "./store.js";
-import { createManagedSessionId, managedSessionBindingToken } from "./managed-session.js";
-import { loadManagedSession, saveManagedSession, tryLoadManagedSession } from "./session-store.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 { terminalControlEvidenceMatches } from "./terminal-control-ref.js";
-import { TerminalInputNotStartedError } from "./terminal-agent-bridge.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, terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
+import { codexCompanionsPresentInOpenRootInventory, 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";
@@ -23,8 +29,10 @@ import { sameCanonicalStatePath, terminalDispatchLedgerLooksLifecycle, terminalD
 import * as dispatchApplication from "./terminal-dispatch-application.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";
 import { deferredForegroundBoundaryProjection } from "./deferred-foreground-preparation-cli-adapter.js";
 import { terminalSubmissionPayload } from "./terminal-dispatch-execution.js";
+import { createTerminalUserSendIntentRepository, TerminalUserSendIntentBoundaryConflictError, TerminalUserSendIntentUncertainError } from "./terminal-user-send-intent.js";
 import { presentTerminalCompleted, presentTerminalDispatchReplay, presentTerminalIdentityFailure, 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";
@@ -88,6 +96,7 @@ const observeCurrentNativeAgentSessionIdentity = rawPort("observeCurrentNativeAg
 const parseJsonOption = rawPort("parseJsonOption");
 const persistManagedSessionNativeIdentity = rawPort("persistManagedSessionNativeIdentity");
 const positiveMinutes = rawPort("positiveMinutes");
+const processIncarnationForPid = rawPort("processIncarnationForPid");
 const prepareDeferredCodexForegroundBinding = rawPort("prepareDeferredCodexForegroundBinding");
 const quarantineManagedSessionBinding = rawPort("quarantineManagedSessionBinding");
 const reattachManagedSessionForNativeIdentity = rawPort("reattachManagedSessionForNativeIdentity");
@@ -96,6 +105,7 @@ const refineManagedSessionNativeIdentity = rawPort("refineManagedSessionNativeId
 const refineTerminalTurnEndpoint = rawPort("refineTerminalTurnEndpoint");
 const required = rawPort("required");
 const resolveCurrentNativeAgentSessionIdentity = rawPort("resolveCurrentNativeAgentSessionIdentity");
+const resolveTerminalBridgeDispatchLedger = rawPort("resolveTerminalBridgeDispatchLedger");
 const resolveTerminalDispatchLedgerPaneIncarnation = rawPort("resolveTerminalDispatchLedgerPaneIncarnation");
 const resolveTerminalConversationFromOptions = rawPort("resolveTerminalConversationFromOptions");
 const stallOtherTerminalBridgeConversationsForUncertainDispatch = rawPort("stallOtherTerminalBridgeConversationsForUncertainDispatch");
@@ -417,6 +427,7 @@ 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),
@@ -426,7 +437,7 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
         status: replayReceipt.status,
         submission_outcome: replayReceipt.submission_outcome,
         background: true,
-        callback_expected: !acceptanceInvalid && Boolean(owner.gateway_method ?? ledger.callback_expected),
+        callback_expected: !acceptanceInvalid && callbackExpected,
         terminal_control: terminalControl,
         executor,
         replayed: replayReceipt.replayed,
@@ -445,7 +456,7 @@ function replayExactActiveTerminalSubmission({ options, terminalControl, request
                 sessionId: sessionIdForConversation(owner),
                 turnId: turnIdForConversation(owner),
                 source: "terminal_control",
-                callbackExpected: Boolean(owner.gateway_method ?? ledger.callback_expected)
+                callbackExpected
             })
             : {
                 action: "inspect",
@@ -682,7 +693,7 @@ function replayExactStoredTerminalSubmission({ options, terminalControl, request
             }
         });
     const acceptanceInvalid = replayReceipt.submission_outcome === "uncertain";
-    const callbackExpected = Boolean(owner.gateway_method);
+    const callbackExpected = callbackExpectedForConversation(owner);
     printJson({
         session_id: sessionIdForConversation(owner),
         turn_id: turnIdForConversation(owner),
@@ -761,140 +772,2987 @@ function assertNoUnresolvedTerminalBridgeSubmission(storeDir, terminalControl, c
         }
     }
 }
-function prepareManagedSend({ options, statePath, logPath, messageBody, stateLockHeld = false, persist = true, rejectTerminalControl = false }) {
-    if (!stateLockHeld) {
-        const releaseLock = acquireFileLock(`${statePath}.lock`);
+function prepareManagedSend({ options, statePath, logPath, messageBody, stateLockHeld = false, persist = true, rejectTerminalControl = false }) {
+    if (!stateLockHeld) {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            return prepareManagedSend({
+                options,
+                statePath,
+                logPath,
+                messageBody,
+                stateLockHeld: true,
+                persist,
+                rejectTerminalControl
+            });
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    const conversation = loadState(statePath);
+    if (conversation.status !== "waiting_for_openclaw" ||
+        options.type !== "answer") {
+        throw new Error(`cannot respond to turn ${turnIdForConversation(conversation)}; ` +
+            `turn is ${conversation.status}`);
+    }
+    const executor = executorForConversation(conversation);
+    const type = "answer";
+    const nativeTakeoverForSend = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const unresolvedSubmission = unresolvedTerminalBridgeSubmission(conversation);
+    if (unresolvedSubmission) {
+        throw new Error(`cannot send to ${conversation.conversation_id}; its previous terminal submission is ` +
+            `${unresolvedSubmission.status}. Inspect the conversation and terminal pane, then close ` +
+            "the AKK conversation before creating a replacement task.");
+    }
+    if (rejectTerminalControl &&
+        terminalControlFromTakeover(nativeTakeoverForSend)) {
+        throw new Error("terminal control changed while waiting to send; refresh status and retry");
+    }
+    const message = createMessage({
+        conversation,
+        id: stringValue(options.messageId),
+        from: "openclaw",
+        to: executor.actor,
+        type,
+        body: messageBody,
+        metadata: {
+            executor_kind: executor.kind,
+            executor_session: executor.session
+        }
+    });
+    const nextConversation = {
+        ...applyMessageToConversation(conversation, message),
+        executor,
+        claude_session: executor.kind === "claude"
+            ? executor.session
+            : conversation.claude_session
+    };
+    if (persist) {
+        saveState(statePath, nextConversation);
+        appendEvent(logPath, messageEvent(message));
+        runtimeLog("info", "message_created", {
+            conversation_id: conversation.conversation_id,
+            agent: executor.kind,
+            executor_session: executor.session,
+            message_type: type,
+            state_path: statePath,
+            event_log_path: logPath,
+            message: textSummary(messageBody)
+        });
+    }
+    return {
+        conversation,
+        executor,
+        nativeTakeoverForSend,
+        message,
+        nextConversation
+    };
+}
+function assertTerminalSubmissionRetryOptions(options) {
+    const turnId = required(stringValue(options.turn), "--turn is required");
+    const allowed = new Set(["turn", "storeDir"]);
+    const conflicts = Object.keys(options).filter((option) => options[option] !== undefined && !allowed.has(option));
+    if (conflicts.length > 0) {
+        throw new Error("send --turn is an exact submission recovery form and cannot be " +
+            `combined with ${conflicts.map((option) => `--${option}`).join(", ")}; ` +
+            "no terminal input was sent");
+    }
+    return turnId;
+}
+function terminalSubmissionRetryBaseRecord(input) {
+    return {
+        schema: TERMINAL_SUBMISSION_RETRY_SCHEMA,
+        version: TERMINAL_SUBMISSION_RETRY_VERSION,
+        revision: 1,
+        attempt_id: input.attemptId,
+        mode: input.mode,
+        state: input.state,
+        store_dir: path.resolve(input.storeDir),
+        state_path: path.resolve(input.statePath),
+        session_id: sessionIdForConversation(input.conversation),
+        turn_id: turnIdForConversation(input.conversation),
+        original_message_id: input.originalMessageId,
+        active_message_id: input.activeMessageId,
+        request_hash: input.requestHash,
+        terminal_target: input.terminalControl.target,
+        callback_route_fingerprint: callbackRouteFingerprintForConversation(input.conversation) ?? null,
+        deferred_foreground_transfer_id: input.deferredTransferId ?? null,
+        reserved_at: input.at,
+        updated_at: input.at
+    };
+}
+function assertTerminalSubmissionRetryAttemptIdentity(input) {
+    const attempt = input.attempt;
+    if (!attempt)
+        return;
+    const callbackFingerprint = callbackRouteFingerprintForConversation(input.conversation) ?? null;
+    if (attempt.store_dir !== path.resolve(input.storeDir) ||
+        attempt.state_path !== path.resolve(input.statePath) ||
+        attempt.session_id !== sessionIdForConversation(input.conversation) ||
+        attempt.turn_id !== turnIdForConversation(input.conversation) ||
+        attempt.original_message_id !== input.originalMessageId ||
+        attempt.request_hash !== input.requestHash ||
+        attempt.terminal_target !== input.terminalControl.target ||
+        attempt.callback_route_fingerprint !== callbackFingerprint ||
+        attempt.deferred_foreground_transfer_id !==
+            (input.deferredTransferId ?? null)) {
+        throw new Error("terminal submission retry authority changed; no terminal input was sent");
+    }
+}
+function terminalSubmissionRetryMessageType(submission) {
+    const messageType = stringValue(submission.message_type);
+    if (messageType !== "task" && messageType !== "answer") {
+        throw new Error("terminal submission retry message type is unavailable; no terminal input was sent");
+    }
+    return messageType;
+}
+function withDeferredTransferSubmissionAuthority(conversation, messageId, transferId) {
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const submission = terminalBridgeSubmission(conversation);
+    if (!takeover || !submission || submission.message_id !== messageId) {
+        throw new Error("cannot upgrade deferred transfer authority on a changed submission");
+    }
+    const existing = stringValue(submission.deferred_foreground_transfer_id);
+    if (existing && existing !== transferId) {
+        throw new Error("deferred transfer receipt authority conflicts");
+    }
+    const receiptsValue = takeover.terminal_bridge_submission_receipts;
+    if (receiptsValue !== undefined && !Array.isArray(receiptsValue)) {
+        throw new Error("terminal submission receipt history is malformed");
+    }
+    const receipts = (Array.isArray(receiptsValue) ? receiptsValue : []).map((receipt) => {
+        if (!isRecord(receipt) || !stringValue(receipt.message_id)) {
+            throw new Error("terminal submission receipt history is malformed");
+        }
+        if (receipt.message_id !== messageId)
+            return receipt;
+        const receiptTransferId = stringValue(receipt.deferred_foreground_transfer_id);
+        if (receiptTransferId && receiptTransferId !== transferId) {
+            throw new Error("deferred transfer receipt history conflicts");
+        }
+        return {
+            ...receipt,
+            deferred_foreground_transfer_id: transferId
+        };
+    });
+    return {
+        ...conversation,
+        native_session_takeover: {
+            ...takeover,
+            deferred_foreground_transfer_id: transferId,
+            terminal_bridge_submission: {
+                ...submission,
+                deferred_foreground_transfer_id: transferId
+            },
+            terminal_bridge_submission_receipts: receipts
+        }
+    };
+}
+function terminalSubmissionRetryUnstalled(conversation) {
+    const next = {
+        ...conversation,
+        status: "waiting_for_agent"
+    };
+    delete next.stalled_at;
+    delete next.stalled_reason;
+    delete next.failed_at;
+    delete next.failure_reason;
+    delete next.idle_since;
+    return next;
+}
+function withTerminalSubmissionRetryMonitorEpoch(conversation, at) {
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : {};
+    const configuredInactivity = Number(takeover.terminal_bridge_inactivity_timeout_minutes);
+    const configuredHard = Number(takeover.terminal_bridge_hard_timeout_minutes);
+    const inactivityMinutes = Number.isFinite(configuredInactivity) &&
+        configuredInactivity > 0
+        ? configuredInactivity
+        : DEFAULT_AGENT_TIMEOUT_MINUTES;
+    const hardMinutes = Number.isFinite(configuredHard) && configuredHard > 0
+        ? configuredHard
+        : DEFAULT_AGENT_HARD_TIMEOUT_MINUTES;
+    return {
+        ...conversation,
+        native_session_takeover: {
+            ...takeover,
+            terminal_bridge_started_at: at,
+            terminal_bridge_monitor_started_at: at,
+            terminal_bridge_last_activity_at: at,
+            terminal_bridge_last_activity_reason: "submission retry Enter dispatched",
+            terminal_bridge_inactivity_timeout_minutes: inactivityMinutes,
+            terminal_bridge_hard_timeout_minutes: hardMinutes,
+            terminal_bridge_inactivity_deadline_at: deadlineAt(at, inactivityMinutes),
+            terminal_bridge_hard_deadline_at: deadlineAt(at, hardMinutes)
+        },
+        updated_at: at
+    };
+}
+function terminalSubmissionRetryAccepted(input) {
+    const currentConversation = assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    const messageId = required(stringValue(input.submission.message_id), "terminal submission retry message id is unavailable");
+    const preparedAt = required(stringValue(input.submission.prepared_at), "terminal submission retry prepared timestamp is unavailable");
+    const acceptedConversation = withTerminalBridgeSubmission({
+        conversation: terminalSubmissionRetryUnstalled(currentConversation),
+        messageId,
+        messageType: terminalSubmissionRetryMessageType(input.submission),
+        requestText: input.requestText,
+        status: "agent_accepted",
+        preparedAt,
+        textInjectedAt: stringValue(input.submission.text_injected_at),
+        enterDispatchedAt: stringValue(input.submission.enter_dispatched_at),
+        agentAcceptedAt: input.at,
+        acceptanceEvidence: input.evidence,
+        lastProvenStage: "agent_accepted"
+    });
+    saveState(input.statePath, acceptedConversation);
+    let acceptedAttempt = input.attempt;
+    if (acceptedAttempt && acceptedAttempt.state !== "agent_accepted") {
+        acceptedAttempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+            ...acceptedAttempt,
+            state: "agent_accepted",
+            agent_accepted_at: input.at,
+            updated_at: input.at
+        }, acceptedAttempt.revision);
+    }
+    mutationDispatchLedger.save(input.scopes, input.resources, {
+        ...input.ledger,
+        ...terminalSubmissionRetryLedgerFields(acceptedAttempt),
+        status: "agent_accepted",
+        text_injected_at: stringValue(input.ledger.text_injected_at),
+        enter_dispatched_at: stringValue(input.ledger.enter_dispatched_at),
+        agent_accepted_at: input.at,
+        acceptance_evidence: input.evidence,
+        dispatcher_pid: null
+    });
+    appendEvent(input.logPath, {
+        ts: input.at,
+        conversation_id: acceptedConversation.conversation_id,
+        event: "terminal_submission_retry_agent_accepted",
+        message_id: messageId,
+        terminal_input_sent: input.terminalInputSent
+    });
+    return { conversation: acceptedConversation, attempt: acceptedAttempt };
+}
+function terminalSubmissionRetryTerminalOutcome(input) {
+    const currentConversation = assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    const messageId = required(stringValue(input.submission.message_id), "terminal submission retry message id is unavailable");
+    const preparedAt = required(stringValue(input.submission.prepared_at), "terminal submission retry prepared timestamp is unavailable");
+    const stalled = {
+        ...currentConversation,
+        status: "stalled",
+        stalled_at: input.at,
+        stalled_reason: input.reason,
+        updated_at: input.at
+    };
+    const conversation = withTerminalBridgeSubmission({
+        conversation: stalled,
+        messageId,
+        messageType: terminalSubmissionRetryMessageType(input.submission),
+        requestText: input.requestText,
+        status: input.outcome,
+        preparedAt,
+        textInjectedAt: stringValue(input.submission.text_injected_at),
+        enterDispatchedAt: stringValue(input.submission.enter_dispatched_at),
+        ...(input.outcome === "not_accepted"
+            ? { notAcceptedAt: input.at }
+            : {
+                uncertainAt: input.at,
+                error: input.reason,
+                safeToRetry: false
+            }),
+        lastProvenStage: "enter_dispatched"
+    });
+    saveState(input.statePath, conversation);
+    mutationDispatchLedger.save(input.scopes, input.resources, {
+        ...input.ledger,
+        ...terminalSubmissionRetryLedgerFields(input.attempt),
+        status: input.outcome,
+        ...(input.outcome === "not_accepted"
+            ? {
+                not_accepted_at: input.at,
+                uncertain_at: undefined,
+                error: undefined,
+                safe_to_retry: undefined
+            }
+            : {
+                not_accepted_at: undefined,
+                uncertain_at: input.at,
+                error: input.reason,
+                safe_to_retry: false
+            }),
+        acceptance_evidence: undefined,
+        agent_accepted_at: undefined,
+        dispatcher_pid: null
+    });
+    appendEvent(input.logPath, {
+        ts: input.at,
+        conversation_id: conversation.conversation_id,
+        event: `terminal_submission_retry_${input.outcome}`,
+        message_id: messageId,
+        terminal_input_sent: true,
+        reason: input.reason,
+        do_not_retry: true
+    });
+    return conversation;
+}
+function finalizeDeferredTerminalSubmissionRetryAccepted(input) {
+    const conversation = loadState(input.statePath);
+    if (conversation.status === "closed") {
+        throw new Error(`cannot finalize submission retry for closed Turn ` +
+            `${turnIdForConversation(conversation)}; no retry state was changed`);
+    }
+    if (input.attempt &&
+        turnIdForConversation(conversation) !== input.attempt.turn_id) {
+        throw new Error("Turn identity changed during submission retry finalization; no retry " +
+            "state was changed");
+    }
+    const submission = required(terminalBridgeSubmission(conversation), "deferred submission retry acceptance lost its Turn receipt");
+    const ledger = required(mutationDispatchLedger.load(input.scopes, input.resources), "deferred submission retry acceptance lost its dispatch ledger");
+    if (submission.status !== "agent_accepted" ||
+        ledger.status !== "agent_accepted") {
+        throw new Error("deferred submission retry acceptance was not durably finalized");
+    }
+    let attempt = input.attempt;
+    if (attempt && attempt.state !== "agent_accepted") {
+        const acceptedAt = stringValue(submission.agent_accepted_at) ??
+            stringValue(ledger.agent_accepted_at) ?? cliNow().toISOString();
+        attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+            ...attempt,
+            state: "agent_accepted",
+            agent_accepted_at: acceptedAt,
+            updated_at: acceptedAt
+        }, attempt.revision);
+    }
+    if (attempt) {
+        mutationDispatchLedger.save(input.scopes, input.resources, {
+            ...ledger,
+            ...terminalSubmissionRetryLedgerFields(attempt)
+        });
+    }
+    return { conversation, attempt };
+}
+function reconcileTerminalSubmissionRetryPending(input) {
+    const currentConversation = assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    const { attempt, submission, ledger } = input;
+    const projection = projectTerminalSubmissionRetryPending({
+        attempt,
+        submission,
+        ledger
+    });
+    const { messageId, preparedAt, textInjectedAt, enterDispatchedAt } = projection;
+    if (input.deferred) {
+        const transfer = input.deferred.scope.loadTransfer(input.deferred.transfer.transfer_id);
+        if (!isDeferredForegroundSubmissionRetryPending(transfer)) {
+            throw new Error("deferred submission retry lacks exact pending transfer authority");
+        }
+        input.deferred.transfer = transfer;
+    }
+    const enteredConversation = withTerminalBridgeSubmission({
+        conversation: withTerminalSubmissionRetryMonitorEpoch(terminalSubmissionRetryUnstalled(currentConversation), enterDispatchedAt),
+        messageId,
+        messageType: terminalSubmissionRetryMessageType(submission),
+        requestText: input.requestText,
+        status: "enter_dispatched",
+        preparedAt,
+        textInjectedAt,
+        enterDispatchedAt,
+        lastProvenStage: "enter_dispatched"
+    });
+    saveState(input.statePath, enteredConversation);
+    mutationDispatchLedger.save(input.scopes, input.resources, {
+        ...ledger,
+        ...terminalSubmissionRetryLedgerFields(attempt),
+        status: "enter_dispatched",
+        text_injected_at: textInjectedAt,
+        enter_dispatched_at: enterDispatchedAt,
+        enter_not_attempted_at: undefined,
+        enter_not_attempted_reason: undefined,
+        uncertain_at: undefined,
+        safe_to_retry: undefined,
+        acceptance_evidence: undefined,
+        agent_accepted_at: undefined,
+        not_accepted_at: undefined,
+        dispatcher_pid: null
+    });
+    appendEvent(input.logPath, {
+        ts: enterDispatchedAt,
+        conversation_id: enteredConversation.conversation_id,
+        event: "terminal_submission_retry_pending_reconciled",
+        message_id: messageId,
+        terminal_input_sent: false
+    });
+    return enteredConversation;
+}
+const TERMINAL_SUBMISSION_RETRY_LEDGER_KEYS = [
+    "submission_retry_attempt_id",
+    "submission_retry_mode",
+    "submission_retry_state",
+    "submission_retry_revision",
+    "submission_retry_original_message_id",
+    "submission_retry_active_message_id",
+    "submission_retry_reserved_at",
+    "submission_retry_replacement_text_reserved_at",
+    "submission_retry_replacement_text_injected_at",
+    "submission_retry_enter_reserved_at",
+    "submission_retry_enter_dispatched_at"
+];
+function assertTerminalSubmissionRetryDeferredMirror(input) {
+    const { attempt, transfer, submission } = input;
+    const replacement = attempt.mode === "replacement_send";
+    const stateRank = terminalSubmissionRetryTransportRank(attempt);
+    const expectedPreparedAt = stringValue(submission.prepared_at);
+    if (transfer.status !== "uncertain" ||
+        transfer.message_id !== attempt.original_message_id ||
+        transfer.submission_retry_attempt_id !== attempt.attempt_id ||
+        transfer.submission_retry_mode !== attempt.mode ||
+        transfer.submission_retry_message_id !== attempt.active_message_id ||
+        transfer.submission_retry_message_id !== transfer.message_id ||
+        transfer.submission_retry_prepared_at !== expectedPreparedAt ||
+        transfer.submission_retry_prepared_at !== transfer.prepared_at ||
+        transfer.submission_retry_text_reserved_at !==
+            (replacement && stateRank >= 1
+                ? attempt.replacement_text_reserved_at
+                : undefined) ||
+        transfer.submission_retry_text_injected_at !==
+            (replacement && stateRank >= 2
+                ? attempt.replacement_text_injected_at
+                : undefined) ||
+        transfer.submission_retry_enter_reserved_at !==
+            (stateRank >= (replacement ? 3 : 0)
+                ? attempt.enter_reserved_at
+                : undefined) ||
+        transfer.submission_retry_enter_dispatched_at !==
+            (stateRank >= (replacement ? 4 : 1)
+                ? attempt.enter_dispatched_at
+                : undefined) ||
+        (attempt.state === "enter_dispatched"
+            ? transfer.input_stage !== "enter_dispatched" ||
+                transfer.enter_dispatched_at !== attempt.enter_dispatched_at
+            : transfer.input_stage !== "text_injected")) {
+        throw new Error("deferred submission retry mirror conflicts with its durable attempt");
+    }
+}
+function assertTerminalSubmissionRetryDeferredMirrorCanReconcile(input) {
+    const { attempt, transfer, submission } = input;
+    const expectedPreparedAt = stringValue(submission.prepared_at);
+    const retryFields = [
+        transfer.submission_retry_attempt_id,
+        transfer.submission_retry_mode,
+        transfer.submission_retry_message_id,
+        transfer.submission_retry_prepared_at,
+        transfer.submission_retry_text_reserved_at,
+        transfer.submission_retry_text_injected_at,
+        transfer.submission_retry_enter_reserved_at,
+        transfer.submission_retry_enter_dispatched_at
+    ];
+    if (transfer.submission_retry_attempt_id === undefined) {
+        const initialAttempt = (attempt.mode === "replacement_send" &&
+            attempt.state === "replacement_reserved") ||
+            (attempt.mode === "exact_draft_enter" &&
+                attempt.state === "enter_reserved");
+        if (!initialAttempt || retryFields.some((value) => value !== undefined)) {
+            throw new Error("deferred submission retry mirror is missing beyond its first recoverable write");
+        }
+        return;
+    }
+    if (transfer.submission_retry_attempt_id !== attempt.attempt_id ||
+        transfer.submission_retry_mode !== attempt.mode ||
+        transfer.submission_retry_message_id !== attempt.active_message_id ||
+        transfer.submission_retry_message_id !== transfer.message_id ||
+        transfer.submission_retry_prepared_at !== expectedPreparedAt ||
+        transfer.submission_retry_prepared_at !== transfer.prepared_at) {
+        throw new Error("deferred submission retry mirror identity conflicts with its durable attempt");
+    }
+    const expectedStages = {
+        submission_retry_text_reserved_at: attempt.mode === "replacement_send"
+            ? attempt.replacement_text_reserved_at
+            : undefined,
+        submission_retry_text_injected_at: attempt.mode === "replacement_send"
+            ? attempt.replacement_text_injected_at
+            : undefined,
+        submission_retry_enter_reserved_at: attempt.enter_reserved_at,
+        submission_retry_enter_dispatched_at: attempt.enter_dispatched_at
+    };
+    for (const field of Object.keys(expectedStages)) {
+        const actual = transfer[field];
+        const expected = expectedStages[field];
+        if (actual !== undefined && actual !== expected) {
+            throw new Error("deferred submission retry mirror stage conflicts with its durable attempt");
+        }
+    }
+    const transferRank = attempt.mode === "replacement_send"
+        ? transfer.submission_retry_enter_dispatched_at !== undefined
+            ? 4
+            : transfer.submission_retry_enter_reserved_at !== undefined
+                ? 3
+                : transfer.submission_retry_text_injected_at !== undefined
+                    ? 2
+                    : transfer.submission_retry_text_reserved_at !== undefined
+                        ? 1
+                        : 0
+        : transfer.submission_retry_enter_dispatched_at !== undefined
+            ? 1
+            : transfer.submission_retry_enter_reserved_at !== undefined
+                ? 0
+                : -1;
+    const attemptRank = terminalSubmissionRetryTransportRank(attempt);
+    if (transferRank > attemptRank || attemptRank - transferRank > 1) {
+        throw new Error("deferred submission retry mirror is ahead or more than one stage behind");
+    }
+}
+function terminalSubmissionRetryTransportRank(attempt) {
+    const order = attempt.mode === "replacement_send"
+        ? [
+            "replacement_reserved", "replacement_text_reserved",
+            "replacement_text_injected", "enter_reserved", "enter_dispatched"
+        ]
+        : ["enter_reserved", "enter_dispatched"];
+    return order.indexOf(attempt.state);
+}
+function reconcileTerminalSubmissionRetryLedgerPrefix(input) {
+    const { attempt, ledger } = input;
+    if (attempt.state === "agent_accepted") {
+        return { ledger, changed: false };
+    }
+    const currentAttemptId = stringValue(ledger.submission_retry_attempt_id);
+    const currentHasRetryFields = TERMINAL_SUBMISSION_RETRY_LEDGER_KEYS.some((key) => ledger[key] !== undefined);
+    if (!currentAttemptId) {
+        if (currentHasRetryFields || attempt.revision !== 1) {
+            throw new Error("terminal submission retry ledger has an unsafe missing retry prefix");
+        }
+        return {
+            ledger: { ...ledger, ...terminalSubmissionRetryLedgerFields(attempt) },
+            changed: true
+        };
+    }
+    const currentState = stringValue(ledger.submission_retry_state);
+    const currentRevision = Number(ledger.submission_retry_revision);
+    const allowedStates = terminalSubmissionRetryLedgerStates(attempt);
+    const same = currentState === attempt.state &&
+        currentRevision === attempt.revision;
+    const immediatelyLagging = currentState === allowedStates.previous &&
+        currentRevision === attempt.revision - 1;
+    if (!same && !immediatelyLagging) {
+        throw new Error("terminal submission retry ledger is ahead, conflicting, or more than one stage behind");
+    }
+    const expectedCurrent = terminalSubmissionRetryLedgerFieldsAtState(attempt, currentState, currentRevision);
+    if (TERMINAL_SUBMISSION_RETRY_LEDGER_KEYS.some((key) => JSON.stringify(ledger[key]) !== JSON.stringify(expectedCurrent[key]))) {
+        throw new Error("terminal submission retry ledger prefix conflicts with its durable attempt");
+    }
+    return same
+        ? { ledger, changed: false }
+        : {
+            ledger: { ...ledger, ...terminalSubmissionRetryLedgerFields(attempt) },
+            changed: true
+        };
+}
+function terminalSubmissionRetryLedgerStates(attempt) {
+    const order = attempt.mode === "replacement_send"
+        ? [
+            "replacement_reserved", "replacement_text_reserved",
+            "replacement_text_injected", "enter_reserved", "enter_dispatched"
+        ]
+        : ["enter_reserved", "enter_dispatched"];
+    const index = order.indexOf(attempt.state);
+    return { previous: index > 0 ? order[index - 1] : undefined };
+}
+function terminalSubmissionRetryLedgerFieldsAtState(attempt, state, revision) {
+    const fields = {
+        ...terminalSubmissionRetryLedgerFields(attempt),
+        submission_retry_state: state,
+        submission_retry_revision: revision
+    };
+    const rank = {
+        replacement_reserved: 0,
+        replacement_text_reserved: 1,
+        replacement_text_injected: 2,
+        enter_reserved: 3,
+        enter_dispatched: 4,
+        agent_accepted: 5
+    };
+    if (rank[state] < rank.replacement_text_reserved) {
+        delete fields.submission_retry_replacement_text_reserved_at;
+    }
+    if (rank[state] < rank.replacement_text_injected) {
+        delete fields.submission_retry_replacement_text_injected_at;
+    }
+    if (rank[state] < rank.enter_reserved) {
+        delete fields.submission_retry_enter_reserved_at;
+    }
+    if (rank[state] < rank.enter_dispatched) {
+        delete fields.submission_retry_enter_dispatched_at;
+    }
+    return fields;
+}
+function printTerminalSubmissionRetryOutcome(input) {
+    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"
+            ? "agent_accepted"
+            : input.outcome === "enter_dispatched" ||
+                input.outcome === "not_accepted"
+                ? "enter_dispatched"
+                : "uncertain",
+        status: input.outcome === "agent_accepted"
+            ? "async_pending"
+            : input.outcome === "enter_dispatched"
+                ? "submission_pending"
+                : input.outcome === "not_accepted"
+                    ? "submission_not_accepted"
+                    : "submission_uncertain",
+        submission_outcome: input.outcome === "enter_dispatched"
+            ? "pending_acceptance"
+            : input.outcome === "not_accepted"
+                ? "not_accepted"
+                : input.outcome === "refused"
+                    ? "uncertain"
+                    : "agent_accepted",
+        replayed: true,
+        terminal_control: input.terminalControl,
+        terminal_input_sent: input.terminalInputSent,
+        callback_expected: ["refused", "not_accepted"].includes(input.outcome)
+            ? false
+            : callbackExpectedForConversation(input.conversation),
+        ...(input.attempt
+            ? {
+                submission_retry_attempt_id: input.attempt.attempt_id,
+                submission_retry_state: input.attempt.state
+            }
+            : {}),
+        do_not_retry: input.outcome !== "agent_accepted",
+        reason: input.reason
+    });
+}
+function loadExactTerminalSubmissionRetryTurn(input) {
+    const conversation = loadState(input.statePath);
+    if (turnIdForConversation(conversation) !== input.exactTurnId) {
+        throw new Error("Turn identity changed during submission retry; no terminal input was " +
+            "sent and no retry state was changed");
+    }
+    return conversation;
+}
+function assertTerminalSubmissionRetryTurnOpen(input) {
+    const conversation = loadExactTerminalSubmissionRetryTurn(input);
+    if (conversation.status === "closed") {
+        throw new Error(`cannot retry submission for closed Turn ${input.exactTurnId}; no ` +
+            "terminal input was sent and no retry state was changed");
+    }
+    return conversation;
+}
+function saveTerminalSubmissionRetryForOpenTurn(statePath, candidate, expectedRevision) {
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId: candidate.turn_id
+    });
+    return saveTerminalSubmissionRetry(statePath, candidate, expectedRevision);
+}
+function loadTerminalSubmissionRetryLockedAuthority(input) {
+    const { options, exactTurnId, statePath, logPath, storeDir, terminalControl } = input.invocation;
+    const route = bindTerminalDispatchRoute(input.scopes, input.resources);
+    assertTerminalDispatchRouteMatches(route, {
+        terminalControl,
+        terminalKey: terminalBridgeRuntimeKey(terminalControl),
+        storeDir,
+        statePath,
+        logPath
+    });
+    let conversation = assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId
+    });
+    const takeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const lockedControl = terminalControlFromTakeover(takeover);
+    if (turnIdForConversation(conversation) !== exactTurnId ||
+        executorForConversation(conversation).kind !== "codex" ||
+        !lockedControl ||
+        !terminalControlsShareIncarnation(lockedControl, terminalControl)) {
+        throw new Error("Turn or terminal authority changed before submission retry; no terminal input was sent");
+    }
+    let submission = terminalBridgeSubmission(conversation);
+    if (!submission) {
+        throw new Error("Turn has no terminal submission receipt to recover; no terminal input was sent");
+    }
+    const currentMessageId = required(stringValue(submission.message_id), "terminal submission retry message id is unavailable");
+    const attempt = loadTerminalSubmissionRetry(statePath);
+    const originalMessageId = attempt?.original_message_id ?? currentMessageId;
+    const requestText = terminalSubmissionPayload(required(stringValue(takeover?.terminal_bridge_request_text), "terminal submission retry request text is unavailable"));
+    const requestHash = required(terminalBridgeRequestFingerprint(requestText), "terminal submission retry request hash is unavailable");
+    const messageType = terminalSubmissionRetryMessageType(submission);
+    const messageBodyHash = createHash("sha256").update(requestText).digest("hex");
+    validateStoredTerminalSubmissionMatch({
+        owner: conversation,
+        receipt: submission,
+        options,
+        terminalControl,
+        requestText,
+        requestHash,
+        expectedStoreDir: storeDir,
+        expectedSessionId: sessionIdForConversation(conversation),
+        expectedTurnId: exactTurnId,
+        expectedMessageType: messageType,
+        expectedStatePath: statePath
+    });
+    const ledger = mutationDispatchLedger.load(input.scopes, input.resources);
+    assertTerminalSubmissionRetryLedgerAuthority({
+        ledger,
+        conversation,
+        exactTurnId,
+        currentMessageId,
+        messageType,
+        messageBodyHash,
+        requestHash,
+        storeDir,
+        statePath,
+        terminalControl
+    });
+    let currentLedger = ledger;
+    const takeoverDeferredTransferId = stringValue(takeover?.deferred_foreground_transfer_id);
+    const ledgerDeferredTransferId = stringValue(currentLedger.deferred_foreground_transfer_id);
+    if (takeoverDeferredTransferId &&
+        takeoverDeferredTransferId === ledgerDeferredTransferId &&
+        stringValue(submission.deferred_foreground_transfer_id) === undefined) {
+        conversation = withDeferredTransferSubmissionAuthority(conversation, currentMessageId, takeoverDeferredTransferId);
+        saveState(statePath, conversation);
+        submission = required(terminalBridgeSubmission(conversation), "deferred terminal submission receipt upgrade failed");
+    }
+    const expectedCallbackFingerprint = callbackRouteFingerprintForConversation(conversation) ?? null;
+    if ((currentLedger.callback_route_fingerprint ?? null) !==
+        expectedCallbackFingerprint ||
+        (submission.callback_route_fingerprint ?? null) !==
+            expectedCallbackFingerprint) {
+        throw new Error("terminal submission callback route changed; no terminal input was sent");
+    }
+    const deferredTransferId = exactTerminalSubmissionRetryDeferredTransferId({
+        takeover,
+        submission,
+        ledger: currentLedger
+    });
+    assertTerminalSubmissionRetryAttemptIdentity({
+        attempt,
+        conversation,
+        storeDir,
+        statePath,
+        originalMessageId,
+        requestHash,
+        terminalControl,
+        deferredTransferId
+    });
+    assertTerminalSubmissionRetryGeneration({
+        attempt,
+        takeover,
+        currentMessageId,
+        originalMessageId
+    });
+    const callbackDelivery = isRecord(conversation.callback_delivery)
+        ? conversation.callback_delivery
+        : undefined;
+    return {
+        conversation,
+        takeover,
+        submission,
+        ledger: currentLedger,
+        attempt,
+        currentMessageId,
+        originalMessageId,
+        requestText,
+        requestHash,
+        deferredTransferId,
+        lifecycleSettled: callbackDelivery?.status === "delivered" ||
+            isTerminalDispatchOwnerReleasedStatus(effectiveTurnStatus(conversation))
+    };
+}
+function assertTerminalSubmissionRetryLedgerAuthority(input) {
+    const { ledger } = input;
+    if (!ledger || terminalDispatchLedgerLooksLifecycle(ledger) ||
+        stringValue(ledger.conversation_id) !== input.conversation.conversation_id ||
+        stringValue(ledger.session_id) !== sessionIdForConversation(input.conversation) ||
+        stringValue(ledger.turn_id) !== input.exactTurnId ||
+        stringValue(ledger.generation_id) !== input.currentMessageId ||
+        stringValue(ledger.message_id) !== input.currentMessageId ||
+        stringValue(ledger.message_type) !== input.messageType ||
+        stringValue(ledger.message_body_hash) !== input.messageBodyHash ||
+        stringValue(ledger.executor_kind) !== "codex" ||
+        stringValue(ledger.request_hash) !== input.requestHash ||
+        path.resolve(stringValue(ledger.store_dir) ?? "") !==
+            path.resolve(input.storeDir) ||
+        !sameCanonicalStatePath(ledger.state_path, input.statePath) ||
+        !terminalDispatchRecordMatchesControl(ledger, input.terminalControl)) {
+        throw new Error("terminal dispatch ledger does not match the exact Turn generation; no terminal input was sent");
+    }
+}
+function exactTerminalSubmissionRetryDeferredTransferId(input) {
+    const references = [
+        stringValue(input.takeover?.deferred_foreground_transfer_id),
+        stringValue(input.submission.deferred_foreground_transfer_id),
+        stringValue(input.ledger.deferred_foreground_transfer_id)
+    ];
+    const hasDeferred = references.some((value) => value !== undefined);
+    if (hasDeferred &&
+        (references.some((value) => value === undefined) ||
+            new Set(references).size !== 1)) {
+        throw new Error("deferred transfer references disagree across Turn and ledger; no terminal input was sent");
+    }
+    return hasDeferred ? references[0] : undefined;
+}
+function assertTerminalSubmissionRetryGeneration(input) {
+    const currentGenerationEligible = input.attempt?.mode === "replacement_send"
+        ? input.attempt.state === "replacement_reserved"
+            ? [input.attempt.original_message_id, input.attempt.active_message_id]
+                .includes(input.currentMessageId)
+            : input.currentMessageId === input.attempt.active_message_id
+        : input.currentMessageId === input.originalMessageId;
+    if (stringValue(input.takeover?.terminal_bridge_message_id) !==
+        input.currentMessageId ||
+        !currentGenerationEligible) {
+        throw new Error("terminal submission retry generation changed; no terminal input was sent");
+    }
+}
+function reconcileTerminalSubmissionRetryDeferredTransfer(input) {
+    const { attempt } = input;
+    if (!attempt)
+        return input.transfer;
+    const application = deferredForegroundApplication(input.invocation.options, input.invocation.live);
+    const boundary = deferredForegroundBoundaryProjection(input.boundary);
+    let transfer = input.transfer;
+    if (transfer.submission_retry_attempt_id === undefined) {
+        if (attempt.mode === "replacement_send" &&
+            attempt.state === "replacement_reserved") {
+            transfer = application.reserveSubmissionRetry({
+                scope: input.scope,
+                boundary,
+                attemptId: attempt.attempt_id,
+                mode: attempt.mode,
+                messageId: attempt.active_message_id,
+                preparedAt: required(stringValue(input.submission.prepared_at), "deferred retry prepared timestamp is unavailable")
+            });
+        }
+        else if (attempt.mode === "exact_draft_enter" &&
+            attempt.state === "enter_reserved") {
+            transfer = application.reserveSubmissionRetry({
+                scope: input.scope,
+                boundary,
+                attemptId: attempt.attempt_id,
+                mode: attempt.mode,
+                messageId: attempt.active_message_id,
+                preparedAt: required(stringValue(input.submission.prepared_at), "deferred retry prepared timestamp is unavailable")
+            });
+            transfer = application.advanceSubmissionRetry({
+                scope: input.scope,
+                boundary,
+                attemptId: attempt.attempt_id,
+                messageId: attempt.active_message_id,
+                stage: "enter_reserved",
+                at: attempt.enter_reserved_at
+            });
+        }
+        else {
+            throw new Error("deferred retry mirror is incomplete after an irreversible boundary; no terminal input was sent");
+        }
+    }
+    if (!transfer.submission_retry_attempt_id)
+        return transfer;
+    if (attempt.mode === "replacement_send" &&
+        [
+            "replacement_text_reserved", "replacement_text_injected",
+            "enter_reserved", "enter_dispatched"
+        ].includes(attempt.state) &&
+        !transfer.submission_retry_text_reserved_at) {
+        transfer = application.advanceSubmissionRetry({
+            scope: input.scope,
+            boundary,
+            attemptId: attempt.attempt_id,
+            messageId: attempt.active_message_id,
+            stage: "text_reserved",
+            at: attempt.replacement_text_reserved_at
+        });
+    }
+    if (["replacement_text_injected", "enter_reserved", "enter_dispatched"]
+        .includes(attempt.state) &&
+        !transfer.submission_retry_text_injected_at) {
+        transfer = application.advanceSubmissionRetry({
+            scope: input.scope,
+            boundary,
+            attemptId: attempt.attempt_id,
+            messageId: attempt.active_message_id,
+            stage: "text_injected",
+            at: attempt.replacement_text_injected_at ??
+                attempt.enter_reserved_at ?? attempt.reserved_at
+        });
+    }
+    if (["enter_reserved", "enter_dispatched"].includes(attempt.state) &&
+        !transfer.submission_retry_enter_reserved_at) {
+        transfer = application.advanceSubmissionRetry({
+            scope: input.scope,
+            boundary,
+            attemptId: attempt.attempt_id,
+            messageId: attempt.active_message_id,
+            stage: "enter_reserved",
+            at: attempt.enter_reserved_at
+        });
+    }
+    if (attempt.state === "enter_dispatched" &&
+        !transfer.submission_retry_enter_dispatched_at) {
+        transfer = application.advanceSubmissionRetry({
+            scope: input.scope,
+            boundary,
+            attemptId: attempt.attempt_id,
+            messageId: attempt.active_message_id,
+            stage: "enter_dispatched",
+            at: attempt.enter_dispatched_at
+        });
+    }
+    return transfer;
+}
+function prepareTerminalSubmissionRetryDeferredContext(input) {
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.invocation.statePath,
+        exactTurnId: input.invocation.exactTurnId
+    });
+    const { deferredTransferId, attempt, submission } = input.authority;
+    if (!deferredTransferId)
+        return { ledger: input.authority.ledger };
+    const scope = bindDeferredForegroundApplicationScope(input.scopes, input.resources);
+    const transfer = scope.loadTransfer(deferredTransferId);
+    const boundary = deferredRecoveryAdapter.deferredCodexBoundaryFromTransfer(deferredForegroundRecoveryAdapterPorts(), { terminal: input.invocation.live, transfer });
+    const projectedBoundary = deferredForegroundBoundaryProjection(boundary);
+    scope.assertBoundary(projectedBoundary);
+    if (attempt && attempt.state !== "agent_accepted") {
+        assertTerminalSubmissionRetryDeferredMirrorCanReconcile({
+            attempt,
+            transfer,
+            submission
+        });
+    }
+    const ledgerMirror = attempt && attempt.state !== "agent_accepted"
+        ? reconcileTerminalSubmissionRetryLedgerPrefix({
+            attempt,
+            ledger: input.authority.ledger
+        })
+        : undefined;
+    const currentTransfer = reconcileTerminalSubmissionRetryDeferredTransfer({
+        invocation: input.invocation,
+        scope,
+        boundary,
+        transfer,
+        attempt,
+        submission
+    });
+    assertTerminalSubmissionRetryDeferredTransferAuthority({
+        invocation: input.invocation,
+        authority: input.authority,
+        transfer: currentTransfer,
+        attempt
+    });
+    deferredForegroundApplication(input.invocation.options, input.invocation.live).assertTransferAuthority(scope, currentTransfer, projectedBoundary);
+    let ledger = input.authority.ledger;
+    if (attempt && attempt.state !== "agent_accepted") {
+        assertTerminalSubmissionRetryDeferredMirror({
+            attempt,
+            transfer: currentTransfer,
+            submission
+        });
+        if (ledgerMirror?.changed) {
+            mutationDispatchLedger.save(input.scopes, input.resources, ledgerMirror.ledger);
+            ledger = ledgerMirror.ledger;
+        }
+    }
+    return {
+        deferred: { scope, transfer: currentTransfer, boundary },
+        ledger
+    };
+}
+function assertTerminalSubmissionRetryDeferredTransferAuthority(input) {
+    const { transfer, attempt } = input;
+    const plannedReplacement = Boolean(attempt?.mode === "replacement_send" &&
+        attempt.state === "replacement_reserved" &&
+        transfer.submission_retry_text_reserved_at === undefined);
+    const activeMessageId = deferredForegroundActiveMessageId(transfer);
+    const currentMessageId = input.authority.currentMessageId;
+    if (transfer.turn_id !== input.invocation.exactTurnId ||
+        transfer.target_session_id !==
+            sessionIdForConversation(input.authority.conversation) ||
+        transfer.request_hash !== input.authority.requestHash ||
+        !sameCanonicalStatePath(transfer.state_path, input.invocation.statePath) ||
+        transfer.message_id !== input.authority.originalMessageId ||
+        (plannedReplacement
+            ? ![input.authority.originalMessageId, attempt.active_message_id]
+                .includes(currentMessageId)
+            : activeMessageId !== currentMessageId) ||
+        (attempt
+            ? transfer.submission_retry_attempt_id !== attempt.attempt_id ||
+                transfer.submission_retry_message_id !== attempt.active_message_id
+            : transfer.submission_retry_attempt_id !== undefined)) {
+        throw new Error("deferred submission retry transfer authority changed; no terminal input was sent");
+    }
+}
+function reconcileTerminalSubmissionRetryDeferredPending(context, state) {
+    if (!context.deferred || state.attempt?.state !== "enter_dispatched" ||
+        state.submission.status === "agent_accepted" ||
+        state.ledger.status === "agent_accepted") {
+        return false;
+    }
+    state.conversation = reconcileTerminalSubmissionRetryPending({
+        conversation: state.conversation,
+        submission: state.submission,
+        ledger: state.ledger,
+        attempt: state.attempt,
+        requestText: context.requestText,
+        statePath: context.invocation.statePath,
+        logPath: context.invocation.logPath,
+        scopes: context.scopes,
+        resources: context.resources,
+        deferred: context.deferred
+    });
+    state.submission = required(terminalBridgeSubmission(state.conversation), "terminal submission retry receipt disappeared during pending reconciliation");
+    state.ledger = required(mutationDispatchLedger.load(context.scopes, context.resources), "terminal submission retry ledger disappeared during pending reconciliation");
+    return true;
+}
+async function recoverPartialTerminalSubmissionRetryAcceptance(context, state) {
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: context.invocation.statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    const partialAcceptance = state.submission.status === "agent_accepted" ||
+        state.ledger.status === "agent_accepted" ||
+        state.attempt?.state === "agent_accepted";
+    if (!partialAcceptance)
+        return false;
+    const { options, terminalControl, live, statePath, logPath, storeDir } = context.invocation;
+    if (context.deferred &&
+        ["uncertain", "dispatch_started"].includes(context.deferred.transfer.status)) {
+        const recovered = await deferredRecoveryAdapter
+            .recoverAcceptedDeferredForegroundDispatch(deferredForegroundRecoveryAdapterPorts(), {
+            options,
+            scope: context.deferred.scope,
+            storeDir,
+            terminal: live,
+            transfer: context.deferred.transfer,
+            boundary: context.deferred.boundary
+        });
+        assertTerminalSubmissionRetryTurnOpen({
+            statePath,
+            exactTurnId: context.invocation.exactTurnId
+        });
+        if (!recovered) {
+            printTerminalSubmissionRetryOutcome({
+                conversation: state.conversation,
+                terminalControl,
+                attempt: state.attempt,
+                outcome: "refused",
+                terminalInputSent: false,
+                reason: "Partial deferred acceptance lacks current native evidence; no terminal input was sent."
+            });
+            return true;
+        }
+        const finalized = finalizeDeferredTerminalSubmissionRetryAccepted({
+            statePath,
+            scopes: context.scopes,
+            resources: context.resources,
+            attempt: state.attempt
+        });
+        state.conversation = finalized.conversation;
+        state.attempt = finalized.attempt;
+        startTerminalBridgeMonitorForConversation({
+            conversation: state.conversation,
+            statePath,
+            logPath,
+            options
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: state.conversation,
+            terminalControl,
+            attempt: state.attempt,
+            outcome: "agent_accepted",
+            terminalInputSent: false,
+            reason: "Deferred native acceptance, source/target Sessions, and monitoring were reconciled without terminal input."
+        });
+        return true;
+    }
+    const durableEvidence = await context.execution.detectAcceptance({
+        executor: "codex",
+        conversation: state.conversation,
+        terminalControl
+    });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    if (!durableEvidence) {
+        printTerminalSubmissionRetryOutcome({
+            conversation: state.conversation,
+            terminalControl,
+            attempt: state.attempt,
+            outcome: "refused",
+            terminalInputSent: false,
+            reason: "Partial acceptance metadata lacks current native evidence; no terminal input was sent."
+        });
+        return true;
+    }
+    const repaired = terminalSubmissionRetryAccepted({
+        conversation: state.conversation,
+        submission: state.submission,
+        ledger: state.ledger,
+        evidence: durableEvidence,
+        requestText: context.requestText,
+        at: stringValue(state.submission.agent_accepted_at) ??
+            stringValue(state.ledger.agent_accepted_at) ?? cliNow().toISOString(),
+        statePath,
+        logPath,
+        scopes: context.scopes,
+        resources: context.resources,
+        attempt: state.attempt,
+        terminalInputSent: false
+    });
+    state.conversation = repaired.conversation;
+    state.attempt = repaired.attempt;
+    startTerminalBridgeMonitorForConversation({
+        conversation: state.conversation,
+        statePath,
+        logPath,
+        options
+    });
+    printTerminalSubmissionRetryOutcome({
+        conversation: state.conversation,
+        terminalControl,
+        attempt: state.attempt,
+        outcome: "agent_accepted",
+        terminalInputSent: false,
+        reason: "Partial durable acceptance was reconciled without terminal input and monitoring was ensured."
+    });
+    return true;
+}
+function terminalSubmissionRetryIsEligible(context, state) {
+    const legacyEligible = !state.attempt &&
+        state.conversation.status === "stalled" &&
+        state.submission.status === "uncertain" &&
+        state.submission.last_proven_stage === "text_injected" &&
+        context.currentMessageId === context.originalMessageId;
+    if (legacyEligible || (state.attempt && state.attempt.state !== "agent_accepted")) {
+        return true;
+    }
+    printTerminalSubmissionRetryOutcome({
+        conversation: state.conversation,
+        terminalControl: context.invocation.terminalControl,
+        attempt: state.attempt,
+        outcome: "refused",
+        terminalInputSent: false,
+        reason: "The Turn is not an eligible incomplete submission recovery; no terminal input was sent."
+    });
+    return false;
+}
+async function recoverTerminalSubmissionRetryAcceptance(context, state) {
+    const { options, terminalControl, live, statePath, logPath, storeDir } = context.invocation;
+    const deferredAccepted = context.deferred
+        ? await deferredRecoveryAdapter.recoverAcceptedDeferredForegroundDispatch(deferredForegroundRecoveryAdapterPorts(), {
+            options,
+            scope: context.deferred.scope,
+            storeDir,
+            terminal: live,
+            transfer: context.deferred.transfer,
+            boundary: context.deferred.boundary
+        })
+        : false;
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    if (deferredAccepted) {
+        const finalized = finalizeDeferredTerminalSubmissionRetryAccepted({
+            statePath,
+            scopes: context.scopes,
+            resources: context.resources,
+            attempt: state.attempt
+        });
+        state.conversation = finalized.conversation;
+        state.attempt = finalized.attempt;
+        startTerminalBridgeMonitorForConversation({
+            conversation: state.conversation,
+            statePath,
+            logPath,
+            options
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: state.conversation,
+            terminalControl,
+            attempt: state.attempt,
+            outcome: "agent_accepted",
+            terminalInputSent: false,
+            reason: "Deferred native acceptance and source/target Session bindings were reconciled without terminal input."
+        });
+        return true;
+    }
+    const acceptedEvidence = context.deferred
+        ? undefined
+        : await context.execution.detectAcceptance({
+            executor: "codex",
+            conversation: state.conversation,
+            terminalControl
+        });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    if (!acceptedEvidence)
+        return false;
+    const repaired = terminalSubmissionRetryAccepted({
+        conversation: state.conversation,
+        submission: state.submission,
+        ledger: state.ledger,
+        evidence: acceptedEvidence,
+        requestText: context.requestText,
+        at: cliNow().toISOString(),
+        statePath,
+        logPath,
+        scopes: context.scopes,
+        resources: context.resources,
+        attempt: state.attempt,
+        terminalInputSent: false
+    });
+    state.conversation = repaired.conversation;
+    state.attempt = repaired.attempt;
+    startTerminalBridgeMonitorForConversation({
+        conversation: state.conversation,
+        statePath,
+        logPath,
+        options
+    });
+    printTerminalSubmissionRetryOutcome({
+        conversation: state.conversation,
+        terminalControl,
+        attempt: state.attempt,
+        outcome: "agent_accepted",
+        terminalInputSent: false,
+        reason: "Native Codex acceptance was reconciled; no terminal input was sent."
+    });
+    return true;
+}
+function finishPendingTerminalSubmissionRetry(context, state, alreadyReconciled) {
+    if (state.attempt?.state !== "enter_dispatched")
+        return false;
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: context.invocation.statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    if (!alreadyReconciled) {
+        state.conversation = reconcileTerminalSubmissionRetryPending({
+            conversation: state.conversation,
+            submission: state.submission,
+            ledger: state.ledger,
+            attempt: state.attempt,
+            requestText: context.requestText,
+            statePath: context.invocation.statePath,
+            logPath: context.invocation.logPath,
+            scopes: context.scopes,
+            resources: context.resources,
+            deferred: context.deferred
+        });
+    }
+    startTerminalBridgeMonitorForConversation({
+        conversation: state.conversation,
+        statePath: context.invocation.statePath,
+        logPath: context.invocation.logPath,
+        options: context.invocation.options
+    });
+    printTerminalSubmissionRetryOutcome({
+        conversation: state.conversation,
+        terminalControl: context.invocation.terminalControl,
+        attempt: state.attempt,
+        outcome: "enter_dispatched",
+        terminalInputSent: false,
+        reason: "The durable retry Enter was reconciled without additional terminal input; native acceptance remains pending."
+    });
+    return true;
+}
+function terminalSubmissionRetryHasInputAuthority(context, state) {
+    if (!context.deferred ||
+        validateCodexRolloutAcceptanceAnchor(context.takeover?.codex_rollout_acceptance_anchor)?.version === 3) {
+        return true;
+    }
+    printTerminalSubmissionRetryOutcome({
+        conversation: state.conversation,
+        terminalControl: context.invocation.terminalControl,
+        attempt: state.attempt,
+        outcome: "refused",
+        terminalInputSent: false,
+        reason: "Deferred submission retry requires a candidate-set Codex acceptance anchor before any terminal input; no terminal input was sent."
+    });
+    return false;
+}
+async function runTerminalSubmissionRetryNoInputRecovery(context, state) {
+    const pendingRetryReconciled = reconcileTerminalSubmissionRetryDeferredPending(context, state);
+    if (await recoverPartialTerminalSubmissionRetryAcceptance(context, state)) {
+        return true;
+    }
+    if (!terminalSubmissionRetryIsEligible(context, state))
+        return true;
+    if (await recoverTerminalSubmissionRetryAcceptance(context, state)) {
+        return true;
+    }
+    if (finishPendingTerminalSubmissionRetry(context, state, pendingRetryReconciled)) {
+        return true;
+    }
+    return !terminalSubmissionRetryHasInputAuthority(context, state);
+}
+async function runTerminalSubmissionRetryDecision(context, state) {
+    const { options, bridge, terminalControl, storeDir, statePath, logPath } = context.invocation;
+    if (context.deferred) {
+        await assertDeferredCodexForegroundBindingBoundary({
+            options,
+            scope: context.deferred.scope,
+            boundary: context.deferred.boundary,
+            expectedSourceStatus: "transitioning",
+            requireNoDispatch: false,
+            requireEmptyComposer: false
+        });
+    }
+    const observation = await bridge.observeCodexComposer(terminalControl, context.requestText, { runtime: terminalRuntimeIdentityForConversation(state.conversation, terminalControl) });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath,
+        exactTurnId: context.invocation.exactTurnId
+    });
+    const decision = decideTerminalSubmissionRetry({
+        agent: "codex",
+        exactTurnTarget: true,
+        accepted: false,
+        composer: observation.state,
+        submissionStatus: stringValue(state.submission.status),
+        lastProvenStage: stringValue(state.submission.last_proven_stage),
+        submissionTextInjectedAt: stringValue(state.submission.text_injected_at),
+        enterDispatchedAt: stringValue(state.submission.enter_dispatched_at),
+        enterNotAttemptedAt: stringValue(state.submission.enter_not_attempted_at),
+        enterNotAttemptedReason: stringValue(state.submission.enter_not_attempted_reason),
+        ledgerStatus: stringValue(state.ledger.status),
+        ledgerTextInjectedAt: stringValue(state.ledger.text_injected_at),
+        ledgerEnterDispatchedAt: stringValue(state.ledger.enter_dispatched_at),
+        ledgerEnterNotAttemptedAt: stringValue(state.ledger.enter_not_attempted_at),
+        ledgerEnterNotAttemptedReason: stringValue(state.ledger.enter_not_attempted_reason),
+        ledgerAgentAcceptedAt: stringValue(state.ledger.agent_accepted_at),
+        originalMessageId: context.originalMessageId,
+        currentMessageId: stringValue(context.takeover?.terminal_bridge_message_id),
+        attempt: state.attempt
+    });
+    if (decision.action === "refuse") {
+        printTerminalSubmissionRetryOutcome({
+            conversation: state.conversation,
+            terminalControl,
+            attempt: state.attempt,
+            outcome: "refused",
+            terminalInputSent: false,
+            reason: `${decision.reason}; no terminal input was sent.`
+        });
+        return;
+    }
+    if (decision.action === "repair_accepted") {
+        throw new Error("retry metadata claims acceptance without native evidence; no terminal input was sent");
+    }
+    if (decision.action === "start_replacement" ||
+        decision.action === "resume_replacement") {
+        await runTerminalSubmissionReplacement({
+            options,
+            bridge,
+            execution: context.execution,
+            observation,
+            decision,
+            conversation: state.conversation,
+            submission: state.submission,
+            ledger: state.ledger,
+            requestText: context.requestText,
+            requestHash: context.requestHash,
+            originalMessageId: context.originalMessageId,
+            terminalControl,
+            storeDir,
+            statePath,
+            logPath,
+            scopes: context.scopes,
+            resources: context.resources,
+            attempt: state.attempt,
+            deferred: context.deferred
+        });
+        return;
+    }
+    await runTerminalSubmissionExactDraftEnter({
+        options,
+        bridge,
+        execution: context.execution,
+        conversation: state.conversation,
+        submission: state.submission,
+        ledger: state.ledger,
+        requestText: context.requestText,
+        requestHash: context.requestHash,
+        originalMessageId: context.originalMessageId,
+        activeMessageId: decision.activeMessageId,
+        terminalControl,
+        storeDir,
+        statePath,
+        logPath,
+        scopes: context.scopes,
+        resources: context.resources,
+        attempt: state.attempt,
+        deferred: context.deferred
+    });
+}
+async function runTerminalSubmissionRetryLocked(input) {
+    const freshConversation = loadExactTerminalSubmissionRetryTurn({
+        statePath: input.invocation.statePath,
+        exactTurnId: input.invocation.exactTurnId
+    });
+    if (freshConversation.status === "closed") {
+        printTerminalSubmissionRetryOutcome({
+            conversation: freshConversation,
+            terminalControl: input.invocation.terminalControl,
+            outcome: "refused",
+            terminalInputSent: false,
+            reason: "The Turn was explicitly closed; no terminal input was sent and no " +
+                "retry state was changed."
+        });
+        return;
+    }
+    const authority = loadTerminalSubmissionRetryLockedAuthority(input);
+    if (authority.lifecycleSettled) {
+        printTerminalSubmissionRetryOutcome({
+            conversation: authority.conversation,
+            terminalControl: input.invocation.terminalControl,
+            attempt: authority.attempt,
+            outcome: "refused",
+            terminalInputSent: false,
+            reason: "The Turn lifecycle is already settled; no terminal input was sent."
+        });
+        return;
+    }
+    const prepared = prepareTerminalSubmissionRetryDeferredContext({
+        invocation: input.invocation,
+        authority,
+        scopes: input.scopes,
+        resources: input.resources
+    });
+    const state = {
+        conversation: authority.conversation,
+        submission: authority.submission,
+        ledger: prepared.ledger,
+        attempt: authority.attempt
+    };
+    const context = {
+        invocation: input.invocation,
+        scopes: input.scopes,
+        resources: input.resources,
+        execution: terminalDispatchExecution(input.invocation.options, input.invocation.bridge),
+        deferred: prepared.deferred,
+        takeover: authority.takeover,
+        currentMessageId: authority.currentMessageId,
+        originalMessageId: authority.originalMessageId,
+        requestText: authority.requestText,
+        requestHash: authority.requestHash
+    };
+    if (await runTerminalSubmissionRetryNoInputRecovery(context, state))
+        return;
+    await runTerminalSubmissionRetryDecision(context, state);
+}
+async function runTerminalSubmissionRetry(options) {
+    const exactTurnId = assertTerminalSubmissionRetryOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const storePaths = pathsForConversationDir(path.dirname(statePath));
+    const storeDir = storePaths.storeDir;
+    if (path.resolve(storePaths.statePath) !== path.resolve(statePath) ||
+        path.basename(storePaths.conversationDir) !== exactTurnId ||
+        turnIdForConversation(loaded.conversation) !== exactTurnId) {
+        throw new Error("send --turn did not resolve one canonical Turn; no terminal input was sent");
+    }
+    const initialTakeover = isRecord(loaded.conversation.native_session_takeover)
+        ? loaded.conversation.native_session_takeover
+        : undefined;
+    const storedControl = terminalControlFromTakeover(initialTakeover);
+    const pid = Number(initialTakeover?.terminal_agent_pid);
+    if (!storedControl || !Number.isSafeInteger(pid) || pid <= 1) {
+        throw new Error(`turn ${exactTurnId} is not attached to a live terminal; no terminal input was sent`);
+    }
+    if (executorForConversation(loaded.conversation).kind !== "codex") {
+        throw new Error("terminal submission retry is supported only for Codex; no terminal input was sent");
+    }
+    const bridge = createTerminalAgentBridge(options);
+    const live = await bridge.resolveStoredTerminal("codex", pid, storedControl, terminalRuntimeIdentityForConversation(loaded.conversation, storedControl));
+    if (!terminalControlsShareIncarnation(live.terminalControl, storedControl)) {
+        throw new Error("terminal control changed before submission retry; no terminal input was sent");
+    }
+    const terminalControl = live.terminalControl;
+    await withCanonicalMutationLocks(terminalWriterMutationLocks(storeDir, terminalControl), async (scopes, resources) => withTerminalDispatchStateScope(scopes, resources, statePath, logPath, async (dispatchScopes, dispatchResources) => runTerminalSubmissionRetryLocked({
+        invocation: {
+            options,
+            exactTurnId,
+            statePath,
+            logPath,
+            storeDir,
+            bridge,
+            live,
+            terminalControl
+        },
+        scopes: dispatchScopes,
+        resources: dispatchResources
+    })));
+}
+async function runTerminalSubmissionExactDraftEnter(input) {
+    let attempt = input.attempt;
+    const reserveEnter = () => {
+        assertTerminalSubmissionRetryTurnOpen({
+            statePath: input.statePath,
+            exactTurnId: turnIdForConversation(input.conversation)
+        });
+        const at = cliNow().toISOString();
+        const persistAttemptLedger = () => {
+            mutationDispatchLedger.save(input.scopes, input.resources, {
+                ...mutationDispatchLedger.load(input.scopes, input.resources),
+                ...terminalSubmissionRetryLedgerFields(attempt)
+            });
+        };
+        const advanceDeferred = (stage, stageAt) => {
+            if (!input.deferred || !attempt)
+                return;
+            input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).advanceSubmissionRetry({
+                scope: input.deferred.scope,
+                boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                attemptId: attempt.attempt_id,
+                messageId: attempt.active_message_id,
+                stage,
+                at: stageAt
+            });
+        };
+        if (!attempt) {
+            attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+                ...terminalSubmissionRetryBaseRecord({
+                    mode: "exact_draft_enter",
+                    state: "enter_reserved",
+                    attemptId: `submission-retry-${randomUUID()}`,
+                    storeDir: input.storeDir,
+                    statePath: input.statePath,
+                    conversation: input.conversation,
+                    originalMessageId: input.originalMessageId,
+                    activeMessageId: input.activeMessageId,
+                    requestHash: input.requestHash,
+                    terminalControl: input.terminalControl,
+                    at,
+                    deferredTransferId: input.deferred?.transfer.transfer_id
+                }),
+                enter_reserved_at: at
+            }, null);
+            if (input.deferred) {
+                input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).reserveSubmissionRetry({
+                    scope: input.deferred.scope,
+                    boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                    attemptId: attempt.attempt_id,
+                    mode: attempt.mode,
+                    messageId: attempt.active_message_id,
+                    preparedAt: required(stringValue(input.submission.prepared_at), "deferred retry prepared timestamp is unavailable")
+                });
+            }
+            advanceDeferred("enter_reserved", at);
+            persistAttemptLedger();
+            return;
+        }
+        if (attempt.mode === "replacement_send" &&
+            attempt.state === "replacement_text_reserved") {
+            attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+                ...attempt,
+                state: "replacement_text_injected",
+                replacement_text_injected_at: at,
+                updated_at: at
+            }, attempt.revision);
+            advanceDeferred("text_injected", at);
+            persistAttemptLedger();
+        }
+        if (attempt.state !== "replacement_text_injected") {
+            throw new Error("submission retry Enter is no longer reservable; no key was sent");
+        }
+        const enterReservedAt = cliNow().toISOString();
+        attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+            ...attempt,
+            state: "enter_reserved",
+            enter_reserved_at: enterReservedAt,
+            updated_at: enterReservedAt
+        }, attempt.revision);
+        advanceDeferred("enter_reserved", enterReservedAt);
+        persistAttemptLedger();
+    };
+    await input.bridge.submitExactCodexDraft(input.terminalControl, input.requestText, {
+        runtime: terminalRuntimeIdentityForConversation(input.conversation, input.terminalControl),
+        beforeEnterReservation: reserveEnter
+    });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    if (!attempt || attempt.state !== "enter_reserved") {
+        throw new Error("terminal bridge dispatched Enter without a durable retry reservation");
+    }
+    const enterAt = cliNow().toISOString();
+    attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+        ...attempt,
+        state: "enter_dispatched",
+        enter_dispatched_at: enterAt,
+        updated_at: enterAt
+    }, attempt.revision);
+    if (input.deferred) {
+        input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).advanceSubmissionRetry({
+            scope: input.deferred.scope,
+            boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+            attemptId: attempt.attempt_id,
+            messageId: attempt.active_message_id,
+            stage: "enter_dispatched",
+            at: enterAt
+        });
+    }
+    const current = loadState(input.statePath);
+    const currentSubmission = required(terminalBridgeSubmission(current), "terminal submission receipt disappeared after retry Enter");
+    const enteredConversation = withTerminalBridgeSubmission({
+        conversation: withTerminalSubmissionRetryMonitorEpoch(terminalSubmissionRetryUnstalled(current), enterAt),
+        messageId: input.activeMessageId,
+        messageType: terminalSubmissionRetryMessageType(currentSubmission),
+        requestText: input.requestText,
+        status: "enter_dispatched",
+        preparedAt: required(stringValue(currentSubmission.prepared_at), "terminal submission retry prepared timestamp is unavailable"),
+        textInjectedAt: stringValue(currentSubmission.text_injected_at) ??
+            attempt.replacement_text_injected_at ?? attempt.reserved_at,
+        enterDispatchedAt: enterAt,
+        lastProvenStage: "enter_dispatched"
+    });
+    saveState(input.statePath, enteredConversation);
+    let enteredLedger = {
+        ...mutationDispatchLedger.load(input.scopes, input.resources),
+        ...terminalSubmissionRetryLedgerFields(attempt),
+        status: "enter_dispatched",
+        text_injected_at: stringValue(currentSubmission.text_injected_at) ??
+            attempt.replacement_text_injected_at ?? attempt.reserved_at,
+        enter_dispatched_at: enterAt,
+        dispatcher_pid: null
+    };
+    mutationDispatchLedger.save(input.scopes, input.resources, enteredLedger);
+    appendEvent(input.logPath, {
+        ts: enterAt,
+        conversation_id: enteredConversation.conversation_id,
+        event: "terminal_submission_retry_enter_dispatched",
+        message_id: input.activeMessageId,
+        terminal_input_sent: true
+    });
+    if (input.deferred) {
+        const transfer = input.deferred.scope.loadTransfer(input.deferred.transfer.transfer_id);
+        const recovered = await deferredRecoveryAdapter
+            .recoverAcceptedDeferredForegroundDispatch(deferredForegroundRecoveryAdapterPorts(), {
+            options: input.options,
+            scope: input.deferred.scope,
+            storeDir: input.storeDir,
+            terminal: input.deferred.boundary.terminal,
+            transfer,
+            boundary: input.deferred.boundary
+        });
+        assertTerminalSubmissionRetryTurnOpen({
+            statePath: input.statePath,
+            exactTurnId: turnIdForConversation(input.conversation)
+        });
+        if (recovered) {
+            const finalized = finalizeDeferredTerminalSubmissionRetryAccepted({
+                statePath: input.statePath,
+                scopes: input.scopes,
+                resources: input.resources,
+                attempt
+            });
+            attempt = required(finalized.attempt, "deferred retry attempt disappeared after accepted finalization");
+            const acceptedConversation = finalized.conversation;
+            startTerminalBridgeMonitorForConversation({
+                conversation: acceptedConversation,
+                statePath: input.statePath,
+                logPath: input.logPath,
+                options: input.options
+            });
+            printTerminalSubmissionRetryOutcome({
+                conversation: acceptedConversation,
+                terminalControl: input.terminalControl,
+                attempt,
+                outcome: "agent_accepted",
+                terminalInputSent: true,
+                reason: "The exact deferred Codex draft was submitted once and its transfer and source/target Sessions were committed."
+            });
+            return;
+        }
+        startTerminalBridgeMonitorForConversation({
+            conversation: enteredConversation,
+            statePath: input.statePath,
+            logPath: input.logPath,
+            options: input.options
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: enteredConversation,
+            terminalControl: input.terminalControl,
+            attempt,
+            outcome: "enter_dispatched",
+            terminalInputSent: true,
+            reason: "The exact deferred Codex draft received one Enter; dedicated transfer acceptance remains pending and another retry is forbidden."
+        });
+        return;
+    }
+    const timeoutMs = positiveMilliseconds(input.options.terminalAcceptanceTimeoutMs ??
+        DEFAULT_TERMINAL_ACCEPTANCE_TIMEOUT_MS, "--terminal-acceptance-timeout-ms");
+    const acceptance = await input.execution.pollAcceptance({
+        executor: "codex",
+        conversation: enteredConversation,
+        terminalControl: input.terminalControl,
+        timeoutMs,
+        pollIntervalMs: Math.max(10, Math.min(timeoutMs, Number(input.options.terminalAcceptancePollIntervalMs ??
+            DEFAULT_TERMINAL_ACCEPTANCE_POLL_INTERVAL_MS))),
+        scrollbackLines: Number(input.options.scrollbackLines ?? 240)
+    });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    if (acceptance.outcome === "agent_accepted") {
+        const repaired = terminalSubmissionRetryAccepted({
+            conversation: enteredConversation,
+            submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after retry acceptance"),
+            ledger: enteredLedger,
+            evidence: acceptance.evidence,
+            requestText: input.requestText,
+            at: cliNow().toISOString(),
+            statePath: input.statePath,
+            logPath: input.logPath,
+            scopes: input.scopes,
+            resources: input.resources,
+            attempt,
+            terminalInputSent: true
+        });
+        startTerminalBridgeMonitorForConversation({
+            conversation: repaired.conversation,
+            statePath: input.statePath,
+            logPath: input.logPath,
+            options: input.options
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: repaired.conversation,
+            terminalControl: input.terminalControl,
+            attempt: repaired.attempt,
+            outcome: "agent_accepted",
+            terminalInputSent: true,
+            reason: "The exact existing Codex draft was submitted once and native acceptance was proven."
+        });
+        return;
+    }
+    if (acceptance.outcome === "not_accepted") {
+        const notAcceptedAt = cliNow().toISOString();
+        const notAcceptedConversation = terminalSubmissionRetryTerminalOutcome({
+            conversation: enteredConversation,
+            submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after retry rejection"),
+            ledger: enteredLedger,
+            requestText: input.requestText,
+            reason: acceptance.reason,
+            at: notAcceptedAt,
+            statePath: input.statePath,
+            logPath: input.logPath,
+            scopes: input.scopes,
+            resources: input.resources,
+            attempt,
+            outcome: "not_accepted"
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: notAcceptedConversation,
+            terminalControl: input.terminalControl,
+            attempt,
+            outcome: "not_accepted",
+            terminalInputSent: true,
+            reason: "The exact draft remains in the Codex composer after one Enter; it was durably recorded as not accepted and another retry is forbidden."
+        });
+        return;
+    }
+    if (acceptance.outcome === "uncertain") {
+        const uncertainConversation = terminalSubmissionRetryTerminalOutcome({
+            conversation: enteredConversation,
+            submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after uncertain retry acceptance"),
+            ledger: enteredLedger,
+            requestText: input.requestText,
+            reason: acceptance.reason,
+            at: cliNow().toISOString(),
+            statePath: input.statePath,
+            logPath: input.logPath,
+            scopes: input.scopes,
+            resources: input.resources,
+            attempt,
+            outcome: "uncertain"
+        });
+        printTerminalSubmissionRetryOutcome({
+            conversation: uncertainConversation,
+            terminalControl: input.terminalControl,
+            attempt,
+            outcome: "refused",
+            terminalInputSent: true,
+            reason: `Exact-draft acceptance is uncertain (${acceptance.reason}); the terminal outcome is durable and another retry is forbidden.`
+        });
+        return;
+    }
+    startTerminalBridgeMonitorForConversation({
+        conversation: enteredConversation,
+        statePath: input.statePath,
+        logPath: input.logPath,
+        options: input.options
+    });
+    printTerminalSubmissionRetryOutcome({
+        conversation: enteredConversation,
+        terminalControl: input.terminalControl,
+        attempt,
+        outcome: "enter_dispatched",
+        terminalInputSent: true,
+        reason: "The exact existing Codex draft received one Enter; acceptance remains pending and another retry is forbidden."
+    });
+}
+async function runTerminalSubmissionReplacement(input) {
+    if (input.observation.state !== "exact_empty") {
+        throw new Error("replacement send lost its positive empty-composer proof; no terminal input was sent");
+    }
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    let attempt = input.attempt;
+    if (!attempt) {
+        const at = cliNow().toISOString();
+        attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, terminalSubmissionRetryBaseRecord({
+            mode: "replacement_send",
+            state: "replacement_reserved",
+            attemptId: `submission-retry-${randomUUID()}`,
+            storeDir: input.storeDir,
+            statePath: input.statePath,
+            conversation: input.conversation,
+            originalMessageId: input.originalMessageId,
+            activeMessageId: input.originalMessageId,
+            requestHash: input.requestHash,
+            terminalControl: input.terminalControl,
+            at,
+            deferredTransferId: input.deferred?.transfer.transfer_id
+        }), null);
+        if (input.deferred) {
+            input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).reserveSubmissionRetry({
+                scope: input.deferred.scope,
+                boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                attemptId: attempt.attempt_id,
+                mode: attempt.mode,
+                messageId: attempt.active_message_id,
+                preparedAt: required(stringValue(input.submission.prepared_at), "deferred retry prepared timestamp is unavailable")
+            });
+        }
+        const reservedLedger = required(mutationDispatchLedger.load(input.scopes, input.resources), "terminal submission retry ledger disappeared after reservation");
+        mutationDispatchLedger.save(input.scopes, input.resources, {
+            ...reservedLedger,
+            ...terminalSubmissionRetryLedgerFields(attempt)
+        });
+    }
+    if (attempt.mode !== "replacement_send" ||
+        attempt.state !== "replacement_reserved") {
+        throw new Error("replacement text transport was already reserved; no additional text was sent");
+    }
+    const currentAttempt = () => required(attempt, "terminal submission retry attempt is unavailable");
+    const saveAttempt = (state, at, fields) => {
+        const current = currentAttempt();
+        attempt = saveTerminalSubmissionRetryForOpenTurn(input.statePath, {
+            ...current,
+            ...fields,
+            state,
+            updated_at: at
+        }, current.revision);
+    };
+    const persistRetryLedger = (fields = {}) => {
+        const current = required(mutationDispatchLedger.load(input.scopes, input.resources), "terminal submission retry ledger disappeared");
+        const next = {
+            ...current,
+            ...terminalSubmissionRetryLedgerFields(attempt),
+            ...fields
+        };
+        mutationDispatchLedger.save(input.scopes, input.resources, next);
+        return next;
+    };
+    let enteredConversation;
+    let enteredLedger;
+    await input.bridge.send("codex", input.terminalControl, input.requestText, {
+        runtime: terminalRuntimeIdentityForConversation(input.conversation, input.terminalControl),
+        requireExactComposerBeforeEnter: true,
+        requireExactEmptyComposerAfterBeforeText: {
+            preliminaryComposerDigest: input.observation.digest
+        },
+        beforeText: () => {
+            assertTerminalSubmissionRetryTurnOpen({
+                statePath: input.statePath,
+                exactTurnId: turnIdForConversation(input.conversation)
+            });
+            const at = cliNow().toISOString();
+            saveAttempt("replacement_text_reserved", at, {
+                replacement_text_reserved_at: at
+            });
+            if (input.deferred) {
+                input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).advanceSubmissionRetry({
+                    scope: input.deferred.scope,
+                    boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                    attemptId: currentAttempt().attempt_id,
+                    messageId: currentAttempt().active_message_id,
+                    stage: "text_reserved",
+                    at
+                });
+            }
+            persistRetryLedger();
+        },
+        beforeEnter: () => {
+            assertTerminalSubmissionRetryTurnOpen({
+                statePath: input.statePath,
+                exactTurnId: turnIdForConversation(input.conversation)
+            });
+            const at = cliNow().toISOString();
+            saveAttempt("enter_reserved", at, { enter_reserved_at: at });
+            if (input.deferred) {
+                input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).advanceSubmissionRetry({
+                    scope: input.deferred.scope,
+                    boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                    attemptId: currentAttempt().attempt_id,
+                    messageId: currentAttempt().active_message_id,
+                    stage: "enter_reserved",
+                    at
+                });
+            }
+            persistRetryLedger();
+        },
+        onTransportStage: ({ stage }) => {
+            assertTerminalSubmissionRetryTurnOpen({
+                statePath: input.statePath,
+                exactTurnId: turnIdForConversation(input.conversation)
+            });
+            const at = cliNow().toISOString();
+            if (stage === "text_injected") {
+                saveAttempt("replacement_text_injected", at, {
+                    replacement_text_injected_at: at
+                });
+            }
+            else {
+                saveAttempt("enter_dispatched", at, {
+                    enter_dispatched_at: at
+                });
+            }
+            if (input.deferred) {
+                input.deferred.transfer = deferredForegroundApplication(input.options, input.deferred.boundary.terminal).advanceSubmissionRetry({
+                    scope: input.deferred.scope,
+                    boundary: deferredForegroundBoundaryProjection(input.deferred.boundary),
+                    attemptId: currentAttempt().attempt_id,
+                    messageId: currentAttempt().active_message_id,
+                    stage,
+                    at
+                });
+            }
+            if (stage === "text_injected") {
+                persistRetryLedger();
+                return;
+            }
+            const current = loadState(input.statePath);
+            const submission = required(terminalBridgeSubmission(current), "terminal submission receipt disappeared after replacement Enter");
+            enteredConversation = withTerminalBridgeSubmission({
+                conversation: withTerminalSubmissionRetryMonitorEpoch(terminalSubmissionRetryUnstalled(current), at),
+                messageId: input.originalMessageId,
+                messageType: terminalSubmissionRetryMessageType(submission),
+                requestText: input.requestText,
+                status: "enter_dispatched",
+                preparedAt: required(stringValue(submission.prepared_at), "terminal submission retry prepared timestamp is unavailable"),
+                textInjectedAt: currentAttempt().replacement_text_injected_at,
+                enterDispatchedAt: at,
+                lastProvenStage: "enter_dispatched"
+            });
+            saveState(input.statePath, enteredConversation);
+            enteredLedger = persistRetryLedger({
+                status: "enter_dispatched",
+                text_injected_at: currentAttempt().replacement_text_injected_at,
+                enter_dispatched_at: at,
+                enter_not_attempted_at: undefined,
+                enter_not_attempted_reason: undefined,
+                uncertain_at: undefined,
+                safe_to_retry: undefined,
+                acceptance_evidence: undefined,
+                agent_accepted_at: undefined,
+                not_accepted_at: undefined,
+                dispatcher_pid: null
+            });
+            appendEvent(input.logPath, {
+                ts: at,
+                conversation_id: enteredConversation.conversation_id,
+                event: "terminal_submission_retry_enter_dispatched",
+                message_id: input.originalMessageId,
+                terminal_input_sent: true
+            });
+        }
+    });
+    assertTerminalSubmissionRetryTurnOpen({
+        statePath: input.statePath,
+        exactTurnId: turnIdForConversation(input.conversation)
+    });
+    if (currentAttempt().state !== "enter_dispatched" ||
+        !enteredConversation || !enteredLedger) {
+        throw new Error("replacement transport returned without durable Enter evidence");
+    }
+    if (input.deferred) {
+        const transfer = input.deferred.scope.loadTransfer(input.deferred.transfer.transfer_id);
+        const recovered = await deferredRecoveryAdapter
+            .recoverAcceptedDeferredForegroundDispatch(deferredForegroundRecoveryAdapterPorts(), {
+            options: input.options,
+            scope: input.deferred.scope,
+            storeDir: input.storeDir,
+            terminal: input.deferred.boundary.terminal,
+            transfer,
+            boundary: input.deferred.boundary
+        });
+        assertTerminalSubmissionRetryTurnOpen({
+            statePath: input.statePath,
+            exactTurnId: turnIdForConversation(input.conversation)
+        });
+        if (recovered) {
+            const finalized = finalizeDeferredTerminalSubmissionRetryAccepted({
+                statePath: input.statePath,
+                scopes: input.scopes,
+                resources: input.resources,
+                attempt
+            });
+            attempt = required(finalized.attempt, "deferred replacement retry attempt disappeared after accepted finalization");
+            const acceptedConversation = finalized.conversation;
+            startTerminalBridgeMonitorForConversation({
+                conversation: acceptedConversation,
+                statePath: input.statePath,
+                logPath: input.logPath,
+                options: input.options
+            });
+            printTerminalSubmissionRetryOutcome({
+                conversation: acceptedConversation,
+                terminalControl: input.terminalControl,
+                attempt,
+                outcome: "agent_accepted",
+                terminalInputSent: true,
+                reason: "The missing deferred Codex submission was completed once and its source/target Sessions were committed."
+            });
+            return;
+        }
+    }
+    else {
+        const timeoutMs = positiveMilliseconds(input.options.terminalAcceptanceTimeoutMs ??
+            DEFAULT_TERMINAL_ACCEPTANCE_TIMEOUT_MS, "--terminal-acceptance-timeout-ms");
+        const acceptance = await input.execution.pollAcceptance({
+            executor: "codex",
+            conversation: enteredConversation,
+            terminalControl: input.terminalControl,
+            timeoutMs,
+            pollIntervalMs: Math.max(10, Math.min(timeoutMs, Number(input.options.terminalAcceptancePollIntervalMs ??
+                DEFAULT_TERMINAL_ACCEPTANCE_POLL_INTERVAL_MS))),
+            scrollbackLines: Number(input.options.scrollbackLines ?? 240)
+        });
+        assertTerminalSubmissionRetryTurnOpen({
+            statePath: input.statePath,
+            exactTurnId: turnIdForConversation(input.conversation)
+        });
+        if (acceptance.outcome === "agent_accepted") {
+            const repaired = terminalSubmissionRetryAccepted({
+                conversation: enteredConversation,
+                submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after replacement acceptance"),
+                ledger: enteredLedger,
+                evidence: acceptance.evidence,
+                requestText: input.requestText,
+                at: cliNow().toISOString(),
+                statePath: input.statePath,
+                logPath: input.logPath,
+                scopes: input.scopes,
+                resources: input.resources,
+                attempt,
+                terminalInputSent: true
+            });
+            startTerminalBridgeMonitorForConversation({
+                conversation: repaired.conversation,
+                statePath: input.statePath,
+                logPath: input.logPath,
+                options: input.options
+            });
+            printTerminalSubmissionRetryOutcome({
+                conversation: repaired.conversation,
+                terminalControl: input.terminalControl,
+                attempt: repaired.attempt,
+                outcome: "agent_accepted",
+                terminalInputSent: true,
+                reason: "The missing Codex submission was completed once and native acceptance was proven."
+            });
+            return;
+        }
+        if (acceptance.outcome === "not_accepted") {
+            const notAcceptedConversation = terminalSubmissionRetryTerminalOutcome({
+                conversation: enteredConversation,
+                submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after replacement rejection"),
+                ledger: enteredLedger,
+                requestText: input.requestText,
+                reason: acceptance.reason,
+                at: cliNow().toISOString(),
+                statePath: input.statePath,
+                logPath: input.logPath,
+                scopes: input.scopes,
+                resources: input.resources,
+                attempt,
+                outcome: "not_accepted"
+            });
+            printTerminalSubmissionRetryOutcome({
+                conversation: notAcceptedConversation,
+                terminalControl: input.terminalControl,
+                attempt,
+                outcome: "not_accepted",
+                terminalInputSent: true,
+                reason: "The replacement text remains in the Codex composer after one Enter; it was not accepted and another retry is forbidden."
+            });
+            return;
+        }
+        if (acceptance.outcome === "uncertain") {
+            const uncertainConversation = terminalSubmissionRetryTerminalOutcome({
+                conversation: enteredConversation,
+                submission: required(terminalBridgeSubmission(enteredConversation), "terminal submission receipt disappeared after uncertain replacement acceptance"),
+                ledger: enteredLedger,
+                requestText: input.requestText,
+                reason: acceptance.reason,
+                at: cliNow().toISOString(),
+                statePath: input.statePath,
+                logPath: input.logPath,
+                scopes: input.scopes,
+                resources: input.resources,
+                attempt,
+                outcome: "uncertain"
+            });
+            printTerminalSubmissionRetryOutcome({
+                conversation: uncertainConversation,
+                terminalControl: input.terminalControl,
+                attempt,
+                outcome: "refused",
+                terminalInputSent: true,
+                reason: `Replacement acceptance is uncertain (${acceptance.reason}); another retry is forbidden.`
+            });
+            return;
+        }
+    }
+    startTerminalBridgeMonitorForConversation({
+        conversation: enteredConversation,
+        statePath: input.statePath,
+        logPath: input.logPath,
+        options: input.options
+    });
+    printTerminalSubmissionRetryOutcome({
+        conversation: enteredConversation,
+        terminalControl: input.terminalControl,
+        attempt,
+        outcome: "enter_dispatched",
+        terminalInputSent: true,
+        reason: "The missing Codex submission received one text injection and one Enter; acceptance remains pending and another retry is forbidden."
+    });
+}
+async function runSend(options) {
+    if (options.respond !== true && stringValue(options.turn)) {
+        return runTerminalSubmissionRetry(options);
+    }
+    const messageBody = required(options.message ?? options.request, "--message is required");
+    // Ordinary send/respond owns Turn creation only. Reject native lifecycle
+    // slash commands before resolving or mutating any Session/Turn state so a
+    // caller cannot bypass lifecycle capabilities, CAS tokens, transition
+    // recovery, or binding-generation updates by writing directly to tmux.
+    terminalSubmissionPayload(messageBody);
+    if (options.agentHardTimeoutMinutes !== undefined) {
+        positiveMinutes(options.agentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
+    }
+    if (options.respond === true) {
+        return runTurnResponse({ options, messageBody });
+    }
+    if ((options.type ?? "task") !== "task") {
+        throw new Error("ordinary send only accepts message type task; use respond --turn to answer an in-flight Turn");
+    }
+    const terminalConversation = await resolveTerminalConversationFromOptions(options);
+    if (terminalConversation) {
+        return runRawTerminalSend(options, messageBody, terminalConversation);
+    }
+    return runManagedSessionSend(options, messageBody);
+}
+function rawTerminalInitialAuthority({ options, terminal, storeDir }) {
+    const claimedSession = soleBoundManagedSessionClaimForTerminal(storeDir, terminal);
+    const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
+    const implicitCodexCandidateAuthority = Boolean(terminal.agent === "codex" &&
+        suppliedExpectedTerminalToken === undefined &&
+        claimedSession?.status === "bound" &&
+        isCompleteNativeRollout(claimedSession.binding?.native_process.rollout));
+    const knownCodexCompanions = claimedSession
+        ? codexAllowedCompanionSetForManagedSession({
+            storeDir,
+            session: claimedSession
+        })
+        : { additional: [] };
+    return {
+        claimedSession,
+        suppliedExpectedTerminalToken,
+        implicitCodexCandidateAuthority,
+        knownCodexCompanions
+    };
+}
+function assertRawTerminalCandidateAuthority({ terminal, nativeIdentityObservation, deferredCodexCandidateInventory, implicitCodexCandidateAuthority }) {
+    if (implicitCodexCandidateAuthority &&
+        !deferredCodexCandidateInventory) {
+        throw new Error("rollout-backed Codex terminal send requires a fresh complete " +
+            "nonempty open-root inventory; refresh AKK list before sending");
+    }
+    if (nativeIdentityObservation.status === "unavailable" &&
+        !deferredCodexCandidateInventory) {
+        throw new Error(`native ${terminal.agent} identity observation is ` +
+            `unavailable: ${nativeIdentityObservation.reason}`);
+    }
+}
+function explicitTerminalSendToken(terminal) {
+    const processIncarnation = processIncarnationForPid(terminal.pid);
+    return unmanagedTerminalBindingToken({
+        terminalId: terminal.conversationId,
+        terminalControl: terminal.terminalControl,
+        agent: terminal.agent,
+        pid: terminal.pid,
+        workspace: terminal.terminalControl.currentPath ?? "",
+        processUuid: processIncarnation.processUuid,
+        processBirth: processIncarnation.processBirth
+    });
+}
+function explicitSendTurnReference(candidate) {
+    try {
+        return turnIdForConversation(candidate);
+    }
+    catch {
+        return stringValue(candidate.conversation_id) ?? "unknown";
+    }
+}
+function hasFreshExplicitTerminalSendToken(options, terminal) {
+    const supplied = stringValue(options.expectedTerminalToken);
+    return Boolean(supplied && supplied === explicitTerminalSendToken(terminal));
+}
+function assertFreshUserExplicitTerminalSendToken(options, terminal) {
+    const expected = stringValue(options.expectedUserExplicitTerminalToken);
+    if (expected && expected !== explicitTerminalSendToken(terminal)) {
+        throw new Error("the explicit terminal send token is stale; refresh AKK list");
+    }
+}
+async function assertFreshUserExplicitTerminalSendTargetWhileLocked(options, terminal) {
+    if (!stringValue(options.expectedUserExplicitTerminalToken))
+        return;
+    const resolved = await createTerminalAgentBridge(options)
+        .resolveConversationId(terminal.conversationId);
+    if (!resolved ||
+        resolved.agent !== terminal.agent ||
+        resolved.pid !== terminal.pid ||
+        !terminalControlsShareIncarnation(resolved.terminalControl, terminal.terminalControl)) {
+        throw new Error("the explicitly selected terminal is no longer the same live process");
+    }
+    assertFreshUserExplicitTerminalSendToken(options, resolved);
+}
+function releaseTerminalDispatchForExplicitSend(input) {
+    let ledger;
+    try {
+        ledger = loadTerminalBridgeDispatchLedger(input.terminal.terminalControl);
+    }
+    catch (error) {
+        return {
+            checked: false,
+            warnings: [
+                `terminal dispatch ownership could not be checked before Session ` +
+                    `release: ${error instanceof Error ? error.message : String(error)}`
+            ]
+        };
+    }
+    if (!ledger || ledger.status === "resolved") {
+        return { checked: true, warnings: [] };
+    }
+    if (terminalDispatchLedgerLooksLifecycle(ledger)) {
+        return { checked: true, lifecycleLedger: ledger, warnings: [] };
+    }
+    if (!terminalDispatchRecordMatchesControl(ledger, input.terminal.terminalControl)) {
+        return { checked: true, warnings: [] };
+    }
+    const conversationId = stringValue(ledger.conversation_id);
+    const expectedMessageId = stringValue(ledger.message_id);
+    if (!conversationId || !expectedMessageId) {
+        return {
+            checked: true,
+            warnings: [
+                "orphaned terminal dispatch was kept because its exact conversation " +
+                    "or message generation could not be verified"
+            ]
+        };
+    }
+    if (input.conversations.some((conversation) => conversation.conversation_id === conversationId)) {
+        return { checked: true, warnings: [] };
+    }
+    try {
+        if (loadTerminalDispatchLedgerOwner(ledger)) {
+            return { checked: true, warnings: [] };
+        }
+    }
+    catch (error) {
+        return {
+            checked: true,
+            warnings: [
+                `orphaned terminal dispatch owner could not be checked: ${error instanceof Error ? error.message : String(error)}`
+            ]
+        };
+    }
+    try {
+        const resolved = resolveTerminalBridgeDispatchLedger(input.terminal.terminalControl, {
+            conversation: { conversation_id: conversationId },
+            expectedMessageId,
+            reason: "orphaned management superseded by explicit user Send"
+        });
+        return resolved
+            ? { checked: true, warnings: [] }
+            : {
+                checked: true,
+                warnings: [
+                    "orphaned terminal dispatch changed before explicit Send cleanup"
+                ]
+            };
+    }
+    catch (error) {
+        return {
+            checked: true,
+            warnings: [
+                `orphaned terminal dispatch could not be released: ${error instanceof Error ? error.message : String(error)}`
+            ]
+        };
+    }
+}
+async function bestEffortReleaseTerminalManagementForExplicitSend(input) {
+    try {
+        return await withStoreWriterLeaseAsync(input.storeDir, async () => releaseTerminalManagementForExplicitSendUnderWriter(input), { timeoutMs: 0 });
+    }
+    catch (error) {
+        return [
+            `AKK management writer was unavailable: ${error instanceof Error ? error.message : String(error)}`
+        ];
+    }
+}
+function releaseTerminalManagementForExplicitSendUnderWriter(input) {
+    const warnings = [];
+    let conversations;
+    try {
+        conversations = listConversations(input.storeDir);
+    }
+    catch (error) {
+        return [
+            `managed Turn inventory could not be read: ${error instanceof Error ? error.message : String(error)}`
+        ];
+    }
+    for (const candidate of conversations) {
+        const reference = explicitSendTurnReference(candidate);
+        try {
+            if (!isSessionSendBlockingStatus(candidate.status))
+                continue;
+            const takeover = isRecord(candidate.native_session_takeover)
+                ? candidate.native_session_takeover
+                : undefined;
+            const control = terminalControlFromTakeover(takeover);
+            if (!control ||
+                !terminalControlsShareIncarnation(control, input.terminal.terminalControl)) {
+                continue;
+            }
+            const paths = pathsForConversation(candidate.conversation_id, input.storeDir);
+            const releaseStateLock = acquireFileLock(`${paths.statePath}.lock`, { timeoutMs: 0 });
+            try {
+                const current = loadState(paths.statePath);
+                if (!isSessionSendBlockingStatus(current.status))
+                    continue;
+                const currentTakeover = isRecord(current.native_session_takeover)
+                    ? current.native_session_takeover
+                    : undefined;
+                const currentControl = terminalControlFromTakeover(currentTakeover);
+                if (!currentControl ||
+                    !terminalControlsShareIncarnation(currentControl, input.terminal.terminalControl)) {
+                    continue;
+                }
+                const now = cliNow().toISOString();
+                const closed = {
+                    ...supersedeUnacceptedCallbackDeliveries(current, {
+                        at: now,
+                        reason: "superseded_by_user_explicit_send"
+                    }),
+                    status: "closed",
+                    closed_at: now,
+                    close_reason: "superseded by explicit user Send",
+                    disposition: "user_abandoned_management",
+                    callback_expected: false,
+                    updated_at: now
+                };
+                delete closed.idle_since;
+                saveExplicitUserCloseState(paths.statePath, closed);
+                try {
+                    const transferCleanup = cleanupDeferredForegroundUserClose({
+                        storeDir: input.storeDir,
+                        conversation: closed,
+                        at: now
+                    });
+                    warnings.push(...transferCleanup.warnings.map((warning) => `Turn ${explicitSendTurnReference(current)} deferred cleanup: ${warning}`));
+                }
+                catch (error) {
+                    warnings.push(`Turn ${explicitSendTurnReference(current)} deferred cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                try {
+                    const expectedMessageId = stringValue(currentTakeover?.terminal_bridge_message_id);
+                    const dispatchResolved = resolveTerminalBridgeDispatchLedger(currentControl, {
+                        conversation: closed,
+                        expectedMessageId,
+                        reason: "management superseded by explicit user Send"
+                    });
+                    if (expectedMessageId && !dispatchResolved) {
+                        warnings.push(`Turn ${explicitSendTurnReference(current)} dispatch cleanup ` +
+                            "did not match its expected ledger");
+                    }
+                }
+                catch (error) {
+                    warnings.push(`Turn ${explicitSendTurnReference(current)} dispatch cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                try {
+                    appendExplicitUserCloseEvent(paths.logPath, {
+                        ts: now,
+                        conversation_id: current.conversation_id,
+                        event: "conversation_closed",
+                        status: "closed",
+                        reason: closed.close_reason,
+                        disposition: "user_abandoned_management",
+                        terminal_input_sent: false,
+                        coding_agent_stopped: false,
+                        tmux_pane_closed: false
+                    });
+                }
+                catch (error) {
+                    warnings.push(`Turn ${explicitSendTurnReference(current)} close event failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            finally {
+                releaseStateLock();
+            }
+        }
+        catch (error) {
+            warnings.push(`Turn ${reference} could not release AKK ` +
+                `management: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    let currentConversations;
+    try {
+        currentConversations = listConversations(input.storeDir);
+    }
+    catch (error) {
+        warnings.push(`managed Turn inventory could not be rechecked before Session release: ${error instanceof Error ? error.message : String(error)}`);
+        return warnings;
+    }
+    const blockingSessionIds = new Set(currentConversations
+        .filter((turn) => isSessionSendBlockingStatus(turn.status))
+        .map((turn) => sessionIdForConversation(turn)));
+    const dispatchRelease = releaseTerminalDispatchForExplicitSend({
+        terminal: input.terminal,
+        conversations: currentConversations
+    });
+    warnings.push(...dispatchRelease.warnings);
+    if (!dispatchRelease.checked) {
+        return warnings;
+    }
+    let sessions;
+    try {
+        sessions = listManagedSessions(input.storeDir);
+    }
+    catch (error) {
+        warnings.push(`managed Session inventory could not be read: ${error instanceof Error ? error.message : String(error)}`);
+        return warnings;
+    }
+    const lifecycleLedger = dispatchRelease.lifecycleLedger;
+    for (const session of sessions) {
+        try {
+            const binding = session.binding;
+            if (!["bound", "quarantined", "transitioning"].includes(session.status) ||
+                session.agent !== input.terminal.agent ||
+                !binding ||
+                binding.native_process.pid !== input.terminal.pid ||
+                !terminalControlAliasMatches(binding.terminal_id, binding.terminal_control, input.terminal.conversationId, input.terminal.terminalControl) ||
+                blockingSessionIds.has(session.session_id)) {
+                continue;
+            }
+            const lifecycleSourceSessionId = stringValue(lifecycleLedger?.source_session_id);
+            const lifecycleTargetSessionId = stringValue(lifecycleLedger?.target_session_id);
+            const lifecycleTransitionId = stringValue(lifecycleLedger?.transition_id);
+            const lifecycleNamesSession = Boolean(lifecycleLedger &&
+                (lifecycleSourceSessionId === session.session_id ||
+                    lifecycleTargetSessionId === session.session_id));
+            if (lifecycleNamesSession) {
+                const transitionRelationship = session.last_transition_id
+                    ? lifecycleTransitionId === session.last_transition_id
+                        ? `transition ${session.last_transition_id}`
+                        : `a lifecycle transition that drifted from Session marker ` +
+                            session.last_transition_id
+                    : `lifecycle transition ${lifecycleTransitionId ?? "with unknown id"}`;
+                warnings.push(`Session ${session.session_id} kept AKK management because ` +
+                    `unresolved ${transitionRelationship} still names it; explicit ` +
+                    "Send does not prove that transition's native outcome");
+                continue;
+            }
+            const detachedAt = cliNow().toISOString();
+            saveManagedSession(input.storeDir, {
+                ...session,
+                status: "detached",
+                detached_at: detachedAt,
+                quarantine_reason: undefined,
+                updated_at: detachedAt
+            }, { expectedRevision: managedSessionRevision(session) });
+        }
+        catch (error) {
+            warnings.push(`Session ${session.session_id} could not release AKK management: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return warnings;
+}
+function explicitTerminalSendIntentRuntimeDir() {
+    const configured = stringValue(cliEnv().AKK_RUNTIME_DIR);
+    return configured
+        ? path.resolve(required(expandHome(configured), "AKK runtime directory"))
+        : 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)
+        ? 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");
+    }
+}
+function terminalUserSendIntentContext(options, messageBody, terminal) {
+    const messageId = required(stringValue(options.messageId), "explicit terminal Send message id is unavailable");
+    const payload = terminalSubmissionPayload(String(messageBody));
+    return {
+        messageId,
+        payload,
+        boundary: {
+            terminalRuntimeKey: terminalBridgeRuntimeKey(terminal.terminalControl),
+            physicalToken: explicitTerminalSendToken(terminal),
+            messageId,
+            requestHash: createHash("sha256").update(payload).digest("hex")
+        },
+        repository: createTerminalUserSendIntentRepository({
+            runtimeDir: explicitTerminalSendIntentRuntimeDir()
+        })
+    };
+}
+class TerminalUserSendReplayForbiddenError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TerminalUserSendReplayForbiddenError";
+    }
+}
+function userExplicitEmergencyTerminalLockPath(terminal) {
+    const userScope = createHash("sha256")
+        .update(path.dirname(defaultStoreDir()))
+        .digest("hex")
+        .slice(0, 16);
+    const terminalKey = createHash("sha256")
+        .update(terminalBridgeRuntimeKey(terminal.terminalControl))
+        .digest("hex");
+    const directory = path.join(os.tmpdir(), `agent-knock-knock-user-send-${userScope}`);
+    ensureDir(directory);
+    return path.join(directory, `terminal-${terminalKey}.lock`);
+}
+function acquireUserExplicitTerminalSendLock(options, terminal, warnings) {
+    let release;
+    try {
+        release = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminal.terminalControl, { timeoutMs: 30_000 });
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === "LOCK_TIMEOUT")
+            throw error;
+        warnings.push(`primary terminal serialization was unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        try {
+            release = acquireFileLock(userExplicitEmergencyTerminalLockPath(terminal), { timeoutMs: 30_000 });
+        }
+        catch (fallbackError) {
+            if (isRecord(fallbackError) &&
+                fallbackError.code === "LOCK_TIMEOUT") {
+                throw fallbackError;
+            }
+            warnings.push(`emergency terminal serialization was unavailable; proceeding ` +
+                `with exact pre-input revalidation: ${fallbackError instanceof Error
+                    ? fallbackError.message
+                    : String(fallbackError)}`);
+            return () => { };
+        }
+    }
+    return () => {
+        try {
+            release?.();
+        }
+        catch (error) {
+            const warning = `terminal serialization cleanup failed: ${error instanceof Error ? error.message : String(error)}`;
+            warnings.push(warning);
+            runtimeLog("warn", "terminal_user_explicit_send_lock_release_failed", {
+                terminal_id: terminal.conversationId,
+                warning
+            });
+        }
+    };
+}
+function printReplayedUserExplicitSend(terminal, intent, deliveryMode) {
+    if (deliveryMode === "managed") {
+        printJson({
+            delivered: false,
+            replayed: true,
+            status: "submission_pending_acceptance",
+            submission_outcome: "pending_acceptance",
+            delivery_receipt: "enter_dispatched",
+            do_not_retry: true,
+            management_mode: "managed",
+            terminal_id: terminal.conversationId,
+            message_id: intent.messageId,
+            scope: "terminal_user_explicit"
+        });
+        return;
+    }
+    printJson({
+        delivered: true,
+        delivered_unmanaged: true,
+        callback_expected: false,
+        management_mode: "unmanaged_fallback",
+        replayed: true,
+        terminal_id: terminal.conversationId,
+        message_id: intent.messageId,
+        scope: "terminal_user_explicit"
+    });
+}
+function reserveUserExplicitSendIntent(options, messageBody, terminal) {
+    const intent = terminalUserSendIntentContext(options, messageBody, terminal);
+    const routingWarning = stringValue(options.terminalUserSendRoutingWarning);
+    const warnings = routingWarning ? [routingWarning] : [];
+    try {
+        const reservation = intent.repository.reserve(intent.boundary);
+        if (reservation.outcome === "replay") {
+            printReplayedUserExplicitSend(terminal, intent, required(reservation.intent.delivery_mode, "completed explicit Send delivery mode is unavailable"));
+            return { outcome: "replayed" };
+        }
+        if (reservation.outcome === "uncertain") {
+            throw new TerminalUserSendReplayForbiddenError(`explicit terminal Send ${intent.messageId} already reached ` +
+                `${reservation.stage}; automatic replay is forbidden`);
+        }
+        return {
+            outcome: "proceed",
+            lease: { intent, durable: true, warnings }
+        };
+    }
+    catch (error) {
+        if (error instanceof TerminalUserSendIntentBoundaryConflictError ||
+            error instanceof TerminalUserSendIntentUncertainError ||
+            error instanceof TerminalUserSendReplayForbiddenError) {
+            throw error;
+        }
+        // Runtime receipts strengthen same-id retry safety; their own damage is
+        // never authority to suppress a fresh physical user Send.
+        warnings.push(`durable user-Send intent unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            outcome: "proceed",
+            lease: { intent, durable: false, warnings }
+        };
+    }
+}
+function cancelProvenZeroInputUserExplicitSendIntent(lease, terminal, reason) {
+    if (!lease.durable)
+        return;
+    try {
+        lease.intent.repository.cancelProvenZeroInput(lease.intent.boundary);
+        lease.durable = false;
+    }
+    catch (error) {
+        const warning = `durable zero-input user-Send reservation cleanup failed: ${error instanceof Error ? error.message : String(error)}`;
+        lease.warnings.push(warning);
+        runtimeLog("warn", "terminal_user_explicit_send_intent_cancel_failed", {
+            terminal_id: terminal.conversationId,
+            message_id: lease.intent.messageId,
+            zero_input_reason: reason instanceof Error
+                ? reason.message
+                : String(reason),
+            error: warning
+        });
+    }
+}
+function completeUserExplicitSendIntentWhileLocked(lease, deliveryMode) {
+    if (!lease.durable)
+        return;
+    try {
+        lease.intent.repository.complete(lease.intent.boundary, deliveryMode);
+    }
+    catch (error) {
+        lease.durable = false;
+        lease.warnings.push(`durable user-Send completion receipt failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function completeManagedUserExplicitSendIntent(options, terminal, lease) {
+    let releaseTerminalLock;
+    if (lease.durable) {
         try {
-            return prepareManagedSend({
-                options,
-                statePath,
-                logPath,
-                messageBody,
-                stateLockHeld: true,
-                persist,
-                rejectTerminalControl
-            });
+            releaseTerminalLock = acquireTerminalBridgeSendLock(storeDirFromOptions(options), terminal.terminalControl, { timeoutMs: 0 });
+            completeUserExplicitSendIntentWhileLocked(lease, "managed");
+        }
+        catch (error) {
+            lease.durable = false;
+            lease.warnings.push(`durable managed Send completion receipt failed: ${error instanceof Error ? error.message : String(error)}`);
         }
         finally {
-            releaseLock();
+            try {
+                releaseTerminalLock?.();
+            }
+            catch (error) {
+                lease.warnings.push(`managed terminal serialization cleanup failed after Send: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
     }
-    const conversation = loadState(statePath);
-    if (conversation.status !== "waiting_for_openclaw" ||
-        options.type !== "answer") {
-        throw new Error(`cannot respond to turn ${turnIdForConversation(conversation)}; ` +
-            `turn is ${conversation.status}`);
+    if (lease.warnings.length > 0) {
+        runtimeLog("warn", "terminal_user_explicit_send_intent_warning", {
+            terminal_id: terminal.conversationId,
+            message_id: lease.intent.messageId,
+            warnings: lease.warnings
+        });
     }
-    const executor = executorForConversation(conversation);
-    const type = "answer";
-    const nativeTakeoverForSend = isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : undefined;
-    const unresolvedSubmission = unresolvedTerminalBridgeSubmission(conversation);
-    if (unresolvedSubmission) {
-        throw new Error(`cannot send to ${conversation.conversation_id}; its previous terminal submission is ` +
-            `${unresolvedSubmission.status}. Inspect the conversation and terminal pane, then close ` +
-            "the AKK conversation before creating a replacement task.");
+}
+async function runUserExplicitTerminalFallback(options, terminal, managedFailure, intentLease) {
+    const storeDir = storeDirFromOptions(options);
+    let releaseTerminalLock;
+    let terminalLockReleased = false;
+    try {
+        releaseTerminalLock = acquireUserExplicitTerminalSendLock(options, terminal, intentLease.warnings);
     }
-    if (rejectTerminalControl &&
-        terminalControlFromTakeover(nativeTakeoverForSend)) {
-        throw new Error("terminal control changed while waiting to send; refresh status and retry");
+    catch (error) {
+        // Both the failed managed path and this failed lock acquisition precede
+        // fallback input. Release the same-id receipt so the user can retry.
+        cancelProvenZeroInputUserExplicitSendIntent(intentLease, terminal, error);
+        runtimeLog("warn", "terminal_user_explicit_send_zero_input", {
+            terminal_id: terminal.conversationId,
+            message_id: intentLease.intent.messageId,
+            error: error instanceof Error ? error.message : String(error),
+            retry_safe: true,
+            intent_warnings: intentLease.warnings
+        });
+        throw error;
     }
-    const message = createMessage({
-        conversation,
-        id: stringValue(options.messageId),
-        from: "openclaw",
-        to: executor.actor,
-        type,
-        body: messageBody,
-        metadata: {
-            executor_kind: executor.kind,
-            executor_session: executor.session
-        }
-    });
-    const nextConversation = {
-        ...applyMessageToConversation(conversation, message),
-        executor,
-        claude_session: executor.kind === "claude"
-            ? executor.session
-            : conversation.claude_session
+    const releaseTerminalLockOnce = () => {
+        if (terminalLockReleased)
+            return;
+        terminalLockReleased = true;
+        releaseTerminalLock();
     };
-    if (persist) {
-        saveState(statePath, nextConversation);
-        appendEvent(logPath, messageEvent(message));
-        runtimeLog("info", "message_created", {
-            conversation_id: conversation.conversation_id,
-            agent: executor.kind,
-            executor_session: executor.session,
-            message_type: type,
-            state_path: statePath,
-            event_log_path: logPath,
-            message: textSummary(messageBody)
+    try {
+        let bridge;
+        let fresh;
+        let runtime;
+        const { payload, messageId } = intentLease.intent;
+        const intentWarnings = intentLease.warnings;
+        try {
+            bridge = createTerminalAgentBridge(options);
+            const resolved = await bridge.resolveConversationId(terminal.conversationId);
+            if (!resolved ||
+                resolved.agent !== terminal.agent ||
+                resolved.pid !== terminal.pid ||
+                !terminalControlsShareIncarnation(resolved.terminalControl, terminal.terminalControl)) {
+                throw new Error("the explicitly selected terminal is no longer the same live process");
+            }
+            fresh = resolved;
+            if (!hasFreshExplicitTerminalSendToken(options, fresh)) {
+                throw new Error("the explicit terminal send token is stale; refresh AKK list");
+            }
+            runtime = terminalRuntimeForLiveIdentity({
+                terminal: fresh,
+                physicalOnly: true
+            });
+            const status = await bridge.status(fresh.agent, fresh.terminalControl, { runtime, scrollbackLines: Number(options.scrollbackLines ?? 120) });
+            assertSafeUserExplicitTerminalSend(status);
+            if (fresh.agent === "codex") {
+                await assertCodexComposerReadyForAutomatedInput({
+                    options,
+                    terminalControl: fresh.terminalControl
+                });
+            }
+        }
+        catch (error) {
+            cancelProvenZeroInputUserExplicitSendIntent(intentLease, terminal, error);
+            runtimeLog("warn", "terminal_user_explicit_send_zero_input", {
+                terminal_id: terminal.conversationId,
+                message_id: messageId,
+                error: error instanceof Error ? error.message : String(error),
+                retry_safe: true,
+                intent_warnings: intentWarnings
+            });
+            throw error;
+        }
+        try {
+            await bridge.send(fresh.agent, fresh.terminalControl, payload, {
+                runtime,
+                requireExactComposerBeforeEnter: true,
+                beforeText: async ({ terminalControl }) => {
+                    const currentStatus = await bridge.status(fresh.agent, terminalControl, {
+                        runtime,
+                        scrollbackLines: Number(options.scrollbackLines ?? 120)
+                    });
+                    assertSafeUserExplicitTerminalSend(currentStatus);
+                    if (fresh.agent === "codex") {
+                        await assertCodexComposerReadyForAutomatedInput({
+                            options,
+                            terminalControl
+                        });
+                    }
+                    else if (!isExactClaudeNativeInspectionIdleComposer(currentStatus.screen.excerpt ?? "")) {
+                        throw new Error("the explicitly selected Claude composer is no longer empty");
+                    }
+                }
+            });
+            completeUserExplicitSendIntentWhileLocked(intentLease, "unmanaged");
+            releaseTerminalLockOnce();
+        }
+        catch (error) {
+            const zeroInput = error instanceof TerminalInputNotStartedError;
+            if (zeroInput) {
+                cancelProvenZeroInputUserExplicitSendIntent(intentLease, fresh, error);
+            }
+            runtimeLog(zeroInput ? "warn" : "error", zeroInput
+                ? "terminal_user_explicit_send_zero_input"
+                : "terminal_user_explicit_send_uncertain", {
+                terminal_id: fresh.conversationId,
+                terminal_target: fresh.terminalControl.target,
+                message_id: messageId,
+                error: error instanceof Error ? error.message : String(error),
+                ...(zeroInput
+                    ? { retry_safe: true }
+                    : { do_not_retry: true }),
+                intent_warnings: intentWarnings
+            });
+            throw error;
+        }
+        let cleanupWarnings;
+        try {
+            cleanupWarnings = await bestEffortReleaseTerminalManagementForExplicitSend({
+                storeDir,
+                terminal: fresh
+            });
+        }
+        catch (error) {
+            cleanupWarnings = [
+                `AKK management release was unavailable: ${error instanceof Error ? error.message : String(error)}`
+            ];
+        }
+        const fallbackReason = managedFailure instanceof Error
+            ? managedFailure.message
+            : String(managedFailure);
+        runtimeLog("warn", "terminal_user_explicit_send_fallback", {
+            terminal_id: fresh.conversationId,
+            terminal_target: fresh.terminalControl.target,
+            message_id: messageId,
+            managed_failure: fallbackReason,
+            delivered_unmanaged: true
+        });
+        printJson({
+            delivered: true,
+            delivered_unmanaged: true,
+            cleanup_warnings: cleanupWarnings,
+            intent_warnings: intentWarnings,
+            callback_expected: false,
+            terminal_id: fresh.conversationId,
+            message_id: messageId,
+            scope: "terminal_user_explicit",
+            management_mode: "unmanaged_fallback",
+            previous_management_release_attempted: true,
+            warning: textSummary(`AKK delivered the user's message after managed-state preparation ` +
+                `failed (${fallbackReason}). No callback Turn was claimed.`),
+            next_action: "refresh AKK list; the live coding agent continues independently of AKK callback state"
         });
     }
-    return {
-        conversation,
-        executor,
-        nativeTakeoverForSend,
-        message,
-        nextConversation
-    };
-}
-async function runSend(options) {
-    const messageBody = required(options.message ?? options.request, "--message is required");
-    // Ordinary send/respond owns Turn creation only. Reject native lifecycle
-    // slash commands before resolving or mutating any Session/Turn state so a
-    // caller cannot bypass lifecycle capabilities, CAS tokens, transition
-    // recovery, or binding-generation updates by writing directly to tmux.
-    terminalSubmissionPayload(messageBody);
-    if (options.agentHardTimeoutMinutes !== undefined) {
-        positiveMinutes(options.agentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
+    finally {
+        releaseTerminalLockOnce();
     }
-    if (options.respond === true) {
-        return runTurnResponse({ options, messageBody });
+}
+async function runRawTerminalSend(options, messageBody, terminalConversation) {
+    const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
+    const userExplicitAuthorityRequested = Boolean(suppliedExpectedTerminalToken && options.managedOnly !== true);
+    const freshExplicitAuthority = userExplicitAuthorityRequested
+        ? hasFreshExplicitTerminalSendToken(options, terminalConversation)
+        : false;
+    if (userExplicitAuthorityRequested &&
+        !freshExplicitAuthority) {
+        throw new Error("the explicit terminal send token is stale; refresh AKK list");
     }
-    if ((options.type ?? "task") !== "task") {
-        throw new Error("ordinary send only accepts message type task; use respond --turn to answer an in-flight Turn");
+    if (!freshExplicitAuthority) {
+        await runManagedRawTerminalSend(options, messageBody, terminalConversation);
+        return;
     }
-    const terminalConversation = await resolveTerminalConversationFromOptions(options);
-    if (terminalConversation) {
-        return runRawTerminalSend(options, messageBody, terminalConversation);
+    assertExpectedHandoffTokenUsesExactTerminalSelector({
+        options,
+        terminal: terminalConversation
+    });
+    const explicitOptions = {
+        ...options,
+        messageId: stringValue(options.messageId) ?? `user-send-${randomUUID()}`
+    };
+    const reservation = reserveUserExplicitSendIntent(explicitOptions, messageBody, terminalConversation);
+    if (reservation.outcome === "replayed")
+        return;
+    const intentLease = reservation.lease;
+    const managedResult = await runManagedRawTerminalSend({
+        ...explicitOptions,
+        expectedUserExplicitTerminalToken: suppliedExpectedTerminalToken,
+        expectedTerminalToken: stringValue(explicitOptions.expectedManagedTerminalToken),
+        expectedManagedTerminalToken: undefined
+    }, messageBody, terminalConversation, true);
+    if (managedResult.outcome !== "zero_input") {
+        if (managedResult.outcome === "replayed" ||
+            managedResult.enterDispatched) {
+            completeManagedUserExplicitSendIntent(explicitOptions, terminalConversation, intentLease);
+        }
+        return;
     }
-    return runManagedSessionSend(options, messageBody);
+    return runUserExplicitTerminalFallback(explicitOptions, terminalConversation, managedResult.failure, intentLease);
 }
-function rawTerminalInitialAuthority({ options, terminal, storeDir }) {
-    const claimedSession = soleBoundManagedSessionClaimForTerminal(storeDir, terminal);
-    const suppliedExpectedTerminalToken = stringValue(options.expectedTerminalToken);
-    const implicitCodexCandidateAuthority = Boolean(terminal.agent === "codex" &&
-        suppliedExpectedTerminalToken === undefined &&
-        claimedSession?.status === "bound" &&
-        isCompleteNativeRollout(claimedSession.binding?.native_process.rollout));
-    const knownCodexCompanions = claimedSession
-        ? codexAllowedCompanionSetForManagedSession({
-            storeDir,
-            session: claimedSession
-        })
-        : { additional: [] };
-    return {
-        claimedSession,
-        suppliedExpectedTerminalToken,
-        implicitCodexCandidateAuthority,
-        knownCodexCompanions
+async function runManagedRawTerminalSend(options, messageBody, terminalConversation, deferZeroInputFailurePresentation = false) {
+    const attempt = {
+        terminalControlSendInvoked: false,
+        result: undefined
     };
-}
-function assertRawTerminalCandidateAuthority({ terminal, nativeIdentityObservation, deferredCodexCandidateInventory, implicitCodexCandidateAuthority }) {
-    if (implicitCodexCandidateAuthority &&
-        !deferredCodexCandidateInventory) {
-        throw new Error("rollout-backed Codex terminal send requires a fresh complete " +
-            "nonempty open-root inventory; refresh AKK list before sending");
+    try {
+        return await runManagedRawTerminalSendAttempt(options, messageBody, terminalConversation, deferZeroInputFailurePresentation, attempt);
     }
-    if (nativeIdentityObservation.status === "unavailable" &&
-        !deferredCodexCandidateInventory) {
-        throw new Error(`native ${terminal.agent} identity observation is ` +
-            `unavailable: ${nativeIdentityObservation.reason}`);
+    catch (error) {
+        if (!deferZeroInputFailurePresentation)
+            throw error;
+        if (attempt.result)
+            return attempt.result;
+        if (!attempt.terminalControlSendInvoked) {
+            return { outcome: "zero_input", failure: error };
+        }
+        throw new Error("managed terminal Send may already have started input; refusing an " +
+            `automatic unmanaged fallback: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
-async function runRawTerminalSend(options, messageBody, terminalConversation) {
+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
     // before taking locks or touching Store state.
@@ -906,7 +3764,9 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
         throw new Error("raw terminal sends require --background so AKK can persist and monitor the submission safely");
     }
     const rawStoreDir = storeDirFromOptions(options);
-    await withCanonicalMutationLocks(terminalWriterMutationLocks(rawStoreDir, terminalConversation.terminalControl), async (scopes, resources) => {
+    let controlSendResult;
+    await withCanonicalMutationLocks(terminalWriterMutationLocks(rawStoreDir, terminalConversation.terminalControl, deferZeroInputFailurePresentation ? { timeoutMs: 0 } : undefined), async (scopes, resources) => {
+        await assertFreshUserExplicitTerminalSendTargetWhileLocked(options, terminalConversation);
         await mutationDispatchLedger.beforeMutation(scopes, resources, options, terminalConversation);
         // Upgrade legacy Stores before resolving their Session authority. The
         // protocol migration, rather than mutable Turn recency, is the only code
@@ -919,6 +3779,8 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
             expectedStoreDir: rawStoreDir,
             expectedMessageType: "task"
         })) {
+            controlSendResult = { outcome: "replayed" };
+            attempt.result = controlSendResult;
             return;
         }
         terminalListCliFacade.assertTerminalIncarnationCanStartTurn(rawStoreDir, terminalConversation.terminalControl);
@@ -1164,7 +4026,8 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
         ensureStoreWritable(managed.conversation.store_dir);
         ensureDir(path.dirname(managed.statePath));
         await withTerminalDispatchStateScope(scopes, resources, managed.statePath, managed.logPath, async (dispatchScopes, dispatchResources) => {
-            await runTerminalControlSend({
+            attempt.terminalControlSendInvoked = true;
+            controlSendResult = await runTerminalControlSend({
                 transaction: {
                     scopes: dispatchScopes,
                     resources: dispatchResources
@@ -1176,59 +4039,64 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
                 message: managed.message,
                 recordMessageAfterSend: true,
                 recordRawAttachmentAfterSend: reusableTurn === undefined,
-                onTerminalPreflightVerified: pendingRawAttachSessionCreate
-                    ? async (route) => {
-                        const exactRoute = withExactTerminalDispatchRoute(route, {
-                            terminalControl: terminalConversation.terminalControl,
-                            terminalKey: terminalBridgeRuntimeKey(terminalConversation.terminalControl),
-                            storeDir: rawStoreDir,
-                            statePath: managed.statePath,
-                            logPath: managed.logPath
-                        }, (boundRoute) => boundRoute);
-                        let createdSession;
-                        if (deferredCodexForegroundBinding) {
-                            const deferredScope = bindDeferredForegroundApplicationScope(dispatchScopes, dispatchResources);
-                            const reserved = await deferredForegroundApplication(options, deferredCodexForegroundBinding.terminal).reserve({
-                                scope: deferredScope,
-                                boundary: deferredForegroundBoundaryProjection(deferredCodexForegroundBinding),
-                                targetSession: pendingRawAttachSessionCreate,
-                                messageId: managed.message.id,
-                                turnId: turnIdForConversation(managed.conversation)
-                            });
-                            createdSession = reserved.createdSession;
-                            managedSession = createdSession;
-                            pendingRawAttachSessionCreate = undefined;
-                            return (rollbackRoute) => {
-                                assertTerminalDispatchRouteMatches(rollbackRoute, exactRoute);
-                                reserved.rollback(deferredScope);
-                            };
-                        }
-                        createdSession = saveManagedSession(exactRoute.storeDir, pendingRawAttachSessionCreate, {
-                            expectedRevision: null
+                deferZeroInputFailurePresentation,
+                onTerminalPreflightVerified: async (route) => {
+                    assertFreshUserExplicitTerminalSendToken(options, {
+                        ...terminalConversation,
+                        terminalControl: route.terminalControl
+                    });
+                    if (!pendingRawAttachSessionCreate)
+                        return;
+                    const exactRoute = withExactTerminalDispatchRoute(route, {
+                        terminalControl: terminalConversation.terminalControl,
+                        terminalKey: terminalBridgeRuntimeKey(terminalConversation.terminalControl),
+                        storeDir: rawStoreDir,
+                        statePath: managed.statePath,
+                        logPath: managed.logPath
+                    }, (boundRoute) => boundRoute);
+                    let createdSession;
+                    if (deferredCodexForegroundBinding) {
+                        const deferredScope = bindDeferredForegroundApplicationScope(dispatchScopes, dispatchResources);
+                        const reserved = await deferredForegroundApplication(options, deferredCodexForegroundBinding.terminal).reserve({
+                            scope: deferredScope,
+                            boundary: deferredForegroundBoundaryProjection(deferredCodexForegroundBinding),
+                            targetSession: pendingRawAttachSessionCreate,
+                            messageId: managed.message.id,
+                            turnId: turnIdForConversation(managed.conversation)
                         });
+                        createdSession = reserved.createdSession;
                         managedSession = createdSession;
                         pendingRawAttachSessionCreate = undefined;
                         return (rollbackRoute) => {
-                            assertTerminalDispatchRouteMatches(rollbackRoute, route);
-                            const current = loadManagedSession(rollbackRoute.storeDir, createdSession.session_id);
-                            if (current.status !== "bound" ||
-                                current.revision !== createdSession.revision ||
-                                managedSessionBindingToken(current) !==
-                                    managedSessionBindingToken(createdSession)) {
-                                throw new Error(`new raw-attach Session ${createdSession.session_id} changed before pre-transport rollback`);
-                            }
-                            const detachedAt = cliNow().toISOString();
-                            managedSession = saveManagedSession(rollbackRoute.storeDir, {
-                                ...current,
-                                status: "detached",
-                                detached_at: detachedAt,
-                                updated_at: detachedAt
-                            }, {
-                                expectedRevision: current.revision
-                            });
+                            assertTerminalDispatchRouteMatches(rollbackRoute, exactRoute);
+                            reserved.rollback(deferredScope);
                         };
                     }
-                    : undefined,
+                    createdSession = saveManagedSession(exactRoute.storeDir, pendingRawAttachSessionCreate, {
+                        expectedRevision: null
+                    });
+                    managedSession = createdSession;
+                    pendingRawAttachSessionCreate = undefined;
+                    return (rollbackRoute) => {
+                        assertTerminalDispatchRouteMatches(rollbackRoute, route);
+                        const current = loadManagedSession(rollbackRoute.storeDir, createdSession.session_id);
+                        if (current.status !== "bound" ||
+                            current.revision !== createdSession.revision ||
+                            managedSessionBindingToken(current) !==
+                                managedSessionBindingToken(createdSession)) {
+                            throw new Error(`new raw-attach Session ${createdSession.session_id} changed before pre-transport rollback`);
+                        }
+                        const detachedAt = cliNow().toISOString();
+                        managedSession = saveManagedSession(rollbackRoute.storeDir, {
+                            ...current,
+                            status: "detached",
+                            detached_at: detachedAt,
+                            updated_at: detachedAt
+                        }, {
+                            expectedRevision: current.revision
+                        });
+                    };
+                },
                 allowedPreMaterializationIdentity,
                 allowedAdditionalIdentities,
                 observedHandoff: handoff.adopted && handoff.transition
@@ -1240,9 +4108,14 @@ async function runRawTerminalSend(options, messageBody, terminalConversation) {
                 verifiedEmptyCodexHandoff: verifiedEmptyHandoff?.boundary,
                 deferredCodexForegroundBinding
             });
-        });
+            attempt.result = controlSendResult;
+        }, deferZeroInputFailurePresentation ? { timeoutMs: 0 } : undefined);
     });
-    return;
+    if (!controlSendResult) {
+        throw new Error("managed terminal Send completed without an outcome");
+    }
+    attempt.result = controlSendResult;
+    return controlSendResult;
 }
 async function runManagedSessionSend(options, messageBody) {
     if (stringValue(options.expectedTerminalToken)) {
@@ -3092,17 +5965,33 @@ function launchAcceptedTerminalMonitor({ request, prepared, conversation, accept
         return undefined;
     }
 }
-function presentTerminalDispatchTransportFailure({ error, request, prepared, application, progress, deferredForegroundScope, bridgeMonitor }) {
+function presentTerminalDispatchTransportFailure({ error, request, prepared, application, progress, deferredForegroundScope, bridgeMonitor, deferZeroInputFailurePresentation }) {
     const { options, executor, message, deferredCodexForegroundBinding } = request;
     const { lockedStoreDir, terminalControl, presentationContext, presentationPorts } = prepared;
     if (!progress.textInjectedAt &&
         error instanceof TerminalInputNotStartedError) {
-        renderTerminalZeroInputAbort(application.recordZeroInputAbort({
-            failureKind: "transport",
-            error,
-            abortedAt: cliNow().toISOString()
-        }), presentationContext, presentationPorts, bridgeMonitor?.pid);
-        return;
+        let aborted;
+        try {
+            aborted = application.recordZeroInputAbort({
+                failureKind: "transport",
+                error,
+                abortedAt: cliNow().toISOString()
+            });
+        }
+        catch (persistenceError) {
+            if (!deferZeroInputFailurePresentation)
+                throw persistenceError;
+            runtimeLog("warn", "terminal_user_explicit_zero_input_abort_unavailable", {
+                terminal_target: prepared.terminalControl.target,
+                error: persistenceError instanceof Error
+                    ? persistenceError.message
+                    : String(persistenceError)
+            });
+        }
+        if (!deferZeroInputFailurePresentation && aborted) {
+            renderTerminalZeroInputAbort(aborted, presentationContext, presentationPorts, bridgeMonitor?.pid);
+        }
+        return "zero_input";
     }
     const uncertainAt = cliNow().toISOString();
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -3123,7 +6012,13 @@ function presentTerminalDispatchTransportFailure({ error, request, prepared, app
             });
         }
     }
-    const uncertainConversation = application.applyUncertain(uncertainAt, error);
+    const uncertainConversation = application.applyUncertain(uncertainAt, error, progress.textInjectedAt && !progress.enterDispatchedAt &&
+        error instanceof TerminalEnterDispatchNotAttemptedError
+        ? {
+            enterNotAttemptedAt: uncertainAt,
+            enterNotAttemptedReason: "pre_key_failure"
+        }
+        : {});
     const stalledConversationIds = stallOtherTerminalBridgeConversationsForUncertainDispatch({
         storeDir: lockedStoreDir,
         terminalControl,
@@ -3145,8 +6040,9 @@ function presentTerminalDispatchTransportFailure({ error, request, prepared, app
         enterDispatched: progress.enterDispatchedAt !== undefined,
         monitorPid: bridgeMonitor?.pid
     }, presentationContext, presentationPorts);
+    return "input_started";
 }
-async function runTerminalDispatchTransport({ request, prepared, application, progress, recordPostTransportBookkeepingFailure, deferredForegroundScope }) {
+async function runTerminalDispatchTransport({ request, prepared, application, progress, recordPostTransportBookkeepingFailure, deferredForegroundScope, deferZeroInputFailurePresentation }) {
     const { executor } = request;
     const { terminalBridge, terminalControl, terminalPayload, preSendRuntime, codexRolloutAcceptanceAnchor, presentationContext, presentationPorts } = prepared;
     let bridgeMonitor;
@@ -3168,7 +6064,11 @@ async function runTerminalDispatchTransport({ request, prepared, application, pr
         const submissionOwner = await resolveTerminalDispatchSubmissionOwner(prepared, request, application, progress.stagedConversation);
         if ("failureReason" in submissionOwner) {
             presentTerminalIdentityFailure(submissionOwner.conversation, submissionOwner.failureReason, presentationContext, presentationPorts, bridgeMonitor?.pid);
-            return { outcome: "handled" };
+            return {
+                outcome: "handled",
+                terminalInput: "input_started",
+                enterDispatched: true
+            };
         }
         const acceptance = submissionOwner.deferredCandidateBindingPending
             ? { outcome: "pending_acceptance" }
@@ -3193,46 +6093,71 @@ async function runTerminalDispatchTransport({ request, prepared, application, pr
         };
     }
     catch (error) {
-        presentTerminalDispatchTransportFailure({
+        const terminalInput = presentTerminalDispatchTransportFailure({
             error,
             request,
             prepared,
             application,
             progress,
             deferredForegroundScope,
-            bridgeMonitor
+            bridgeMonitor,
+            deferZeroInputFailurePresentation
         });
-        return { outcome: "handled" };
+        return {
+            outcome: "handled",
+            terminalInput,
+            enterDispatched: progress.enterDispatchedAt !== undefined,
+            failure: error
+        };
     }
 }
 async function runTerminalControlSend(request) {
-    const { transaction, recordMessageAfterSend = false, onTerminalPreflightVerified, deferredCodexForegroundBinding } = request;
-    const prepared = await prepareTerminalControlSend(request);
+    const { transaction, recordMessageAfterSend = false, onTerminalPreflightVerified, deferredCodexForegroundBinding, deferZeroInputFailurePresentation = false } = request;
+    let prepared;
+    try {
+        prepared = await prepareTerminalControlSend(request);
+    }
+    catch (error) {
+        if (deferZeroInputFailurePresentation) {
+            return { outcome: "zero_input", failure: error };
+        }
+        throw error;
+    }
     if (!prepared) {
-        return;
+        return { outcome: "replayed" };
     }
     const { route, presentationContext, presentationPorts } = prepared;
-    const deferredForegroundScope = deferredCodexForegroundBinding
-        ? bindDeferredForegroundApplicationScope(transaction.scopes, transaction.resources)
-        : undefined;
+    let deferredForegroundScope;
     // A newly discovered raw terminal may not have an authoritative Session
     // yet. Commit that Session only after every pre-input terminal and native
     // acceptance check has passed, but before the Turn or dispatch ledger can
     // become durable. This prevents a failed virgin attach from leaving a
     // zero-identity `bound` Session that fences every later control action.
-    if (deferredCodexForegroundBinding) {
-        deferredForegroundScope?.assertBoundary(deferredForegroundBoundaryProjection(deferredCodexForegroundBinding));
+    let dispatch;
+    try {
+        deferredForegroundScope = deferredCodexForegroundBinding
+            ? bindDeferredForegroundApplicationScope(transaction.scopes, transaction.resources)
+            : undefined;
+        if (deferredCodexForegroundBinding) {
+            deferredForegroundScope?.assertBoundary(deferredForegroundBoundaryProjection(deferredCodexForegroundBinding));
+        }
+        const preTransportRollback = await onTerminalPreflightVerified?.(route);
+        const rollback = terminalDispatchRollbackRepositories({
+            request,
+            prepared,
+            deferredForegroundScope,
+            preTransportRollback: typeof preTransportRollback === "function"
+                ? preTransportRollback
+                : undefined
+        });
+        dispatch = createTerminalDispatchRuntime(request, prepared, rollback);
+    }
+    catch (error) {
+        if (deferZeroInputFailurePresentation) {
+            return { outcome: "zero_input", failure: error };
+        }
+        throw error;
     }
-    const preTransportRollback = await onTerminalPreflightVerified?.(route);
-    const rollback = terminalDispatchRollbackRepositories({
-        request,
-        prepared,
-        deferredForegroundScope,
-        preTransportRollback: typeof preTransportRollback === "function"
-            ? preTransportRollback
-            : undefined
-    });
-    const dispatch = createTerminalDispatchRuntime(request, prepared, rollback);
     const { application, progress, recordPostTransportBookkeepingFailure, validatePreparedMessageEvent } = dispatch;
     try {
         // Preserve legacy argument-evaluation priority inside the setup catch:
@@ -3243,13 +6168,29 @@ async function runTerminalControlSend(request) {
             : undefined);
     }
     catch (error) {
-        renderTerminalZeroInputAbort(application.recordZeroInputAbort({
-            failureKind: "setup",
-            error,
-            abortedAt: cliNow().toISOString(),
-            injectStatePersistenceFailure: cliEnv().AKK_TEST_ABORTED_STATE_PERSISTENCE_FAILURE === "1"
-        }), presentationContext, presentationPorts, undefined);
-        return;
+        let aborted;
+        try {
+            aborted = application.recordZeroInputAbort({
+                failureKind: "setup",
+                error,
+                abortedAt: cliNow().toISOString(),
+                injectStatePersistenceFailure: cliEnv().AKK_TEST_ABORTED_STATE_PERSISTENCE_FAILURE === "1"
+            });
+        }
+        catch (persistenceError) {
+            if (!deferZeroInputFailurePresentation)
+                throw persistenceError;
+            runtimeLog("warn", "terminal_user_explicit_zero_input_abort_unavailable", {
+                terminal_target: route.terminalControl.target,
+                error: persistenceError instanceof Error
+                    ? persistenceError.message
+                    : String(persistenceError)
+            });
+        }
+        if (!deferZeroInputFailurePresentation && aborted) {
+            renderTerminalZeroInputAbort(aborted, presentationContext, presentationPorts, undefined);
+        }
+        return { outcome: "zero_input", failure: error };
     }
     const transport = await runTerminalDispatchTransport({
         request,
@@ -3257,10 +6198,16 @@ async function runTerminalControlSend(request) {
         application,
         progress,
         recordPostTransportBookkeepingFailure,
-        deferredForegroundScope
+        deferredForegroundScope,
+        deferZeroInputFailurePresentation
     });
     if (transport.outcome === "handled") {
-        return;
+        return transport.terminalInput === "zero_input"
+            ? { outcome: "zero_input", failure: transport.failure }
+            : {
+                outcome: "input_started",
+                enterDispatched: transport.enterDispatched
+            };
     }
     const deliveredConversation = transport.conversation;
     const acceptanceResult = transport.acceptance;
@@ -3276,6 +6223,7 @@ async function runTerminalControlSend(request) {
         monitorPid: bridgeMonitor?.pid,
         bookkeepingWarning: progress.bookkeepingWarning
     }, presentationContext, presentationPorts);
+    return { outcome: "input_started", enterDispatched: true };
 }
 export function createTerminalCommandCliFacade(dependencies) {
     const call = (operation) => terminalCommandContext.run(dependencies, operation);