@scotthuang/agent-knock-knock 0.13.16 → 0.13.18

package/dist/src/terminal-monitor-state-cli-adapter.js

@@ -1,33 +1,27 @@
-import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { validateCodexRolloutAcceptanceAnchor } from "./terminal-submission-acceptance.js";
-import { deferredForegroundActiveEnterDispatchedAt, deferredForegroundActiveMessageId, deferredForegroundActivePreparedAt, deferredForegroundActiveTextInjectedAt, isDeferredForegroundSubmissionRetryPending, listDeferredForegroundTransfers, loadDeferredForegroundTransfer, saveDeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
+import { loadDeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
 import { isFinalDeferredForegroundTransferStatus } from "./deferred-foreground-transfer-policy.js";
-import { executorForConversation, createMessage, effectiveTurnStatus, isExplicitUserAbandonedManagementTurn, isSessionSendBlockingStatus, isTerminalDispatchOwnerReleasedStatus, isWaitingForAgentStatus, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
-import { executorDefinitionForKind } from "./executors.js";
+import { executorForConversation, createMessage, isWaitingForAgentStatus, sessionIdForConversation, turnIdForConversation } from "./protocol.js";
 import { retireAbsentAsyncQuestionNotification } from "./terminal-monitor-interaction-store.js";
 import { redactString } from "./runtime-log.js";
-import { appendEvent, listConversations, loadState, logPathForStatePath, pathsForConversationDir, saveState, statePathForConversationId, withStoreWriterLease, withStoreWriterLeaseAsync } from "./store.js";
-import { readNdjsonLog } from "./transcript.js";
+import { appendEvent, loadState, logPathForStatePath, pathsForConversationDir, saveState, statePathForConversationId, withStoreWriterLease, withStoreWriterLeaseAsync } from "./store.js";
 import { createFileLockCliAdapter } from "./file-lock-cli-adapter.js";
 import { cliEnv, cliExit, cliNow, cliNowMs, cliPid, cliRuntimeLog, cliSleepSync } from "./cli-runtime-context.js";
 import { expandHome } from "./cli-command-runtime.js";
 import { terminalControlFromTakeover } from "./terminal-runtime-cli-adapter.js";
 import { terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
-import { terminalControlEvidenceMatches } from "./terminal-control-ref.js";
-import { applyTerminalBridgeSubmission, terminalAcceptanceEvidenceForConversation, terminalBridgeEnabled, terminalBridgeRequestFingerprint, terminalBridgeSubmission } from "./terminal-dispatch-receipt.js";
-import { terminalMonitorActivityPersistIntervalMs, terminalMonitorApprovalCandidate, terminalMonitorDeadlineAt, validTerminalMonitorTimestampMs } from "./terminal-monitor-decision-policy.js";
+import { applyTerminalBridgeSubmission, terminalBridgeEnabled, terminalBridgeRequestFingerprint, terminalBridgeSubmission } from "./terminal-dispatch-receipt.js";
+import { terminalMonitorActivityPersistIntervalMs, terminalMonitorApprovalCandidate, validTerminalMonitorTimestampMs } from "./terminal-monitor-decision-policy.js";
 import { runTerminalMonitor as runTerminalMonitorService } from "./terminal-monitor-application-service.js";
-import { pollTerminalMonitor, presentTerminalMonitor, reconcileMonitorAcceptance, recordMonitorApprovalNotification, recordMonitorInteractionNotification, validMonitorInteractionProjection as validInteractionProjection, repairLaggingAcceptedMonitorAuthority, recoverPreparedMonitorSubmission, terminalMonitorStoreLeaseTimeout, terminalMonitorStoreOperationTimeout } from "./terminal-monitor-cli-adapter.js";
+import { pollTerminalMonitor, presentTerminalMonitor, reconcileMonitorAcceptance, recordMonitorApprovalNotification, recordMonitorInteractionNotification, repairLaggingAcceptedMonitorAuthority, recoverPreparedMonitorSubmission, terminalMonitorStoreLeaseTimeout, terminalMonitorStoreOperationTimeout } from "./terminal-monitor-cli-adapter.js";
 import { terminalMonitorReconciliationEligibility } from "./terminal-monitor-reconciliation-eligibility.js";
 import { reconcileTerminalMonitorStateCandidate } from "./terminal-monitor-state-reconciliation-service.js";
-import { sameCanonicalStatePath } from "./terminal-dispatch-ledger-codec.js";
-import { terminalSubmissionPayload } from "./terminal-dispatch-execution.js";
-import { loadTerminalSubmissionRetry, decideTerminalSubmissionRetryStartup, projectTerminalSubmissionRetryPending, saveTerminalSubmissionRetry, terminalSubmissionRetryLedgerFields } from "./terminal-submission-retry-service.js";
-import { callbackExpectedForConversation, callbackRouteFingerprintForConversation } from "./callback-route-authority.js";
-import { canonicalJson } from "./canonical-json.js";
+import { callbackExpectedForConversation } from "./callback-route-authority.js";
 import { isRecord, nonBlankString } from "./value-guards.js";
-const COLLATERAL_STALL_REASON = "a newer terminal submission has an uncertain outcome; inspect the shared terminal pane before continuing";
+import { takeoverFor } from "./terminal-monitor-state-contract.js";
+import { TerminalMonitorStartupRecovery } from "./terminal-monitor-startup-recovery.js";
+import { TerminalMonitorCollateralRecovery } from "./terminal-monitor-collateral-recovery.js";
+import { TerminalMonitorAttentionStore, terminalBridgeApprovalInstructions } from "./terminal-monitor-attention-store.js";
 /** Invocation-local monitor state and reconciliation CLI boundary. */
 export function createTerminalMonitorStateCliAdapter(dependencies) {
     const application = new TerminalMonitorStateCliApplication(dependencies);
@@ -43,6 +37,9 @@ export function createTerminalMonitorStateCliAdapter(dependencies) {
     });
 }
 class TerminalMonitorStateCliApplication {
+    #startup;
+    #collateral;
+    #attention;
     #dependencies;
     #stateFileLock = createFileLockCliAdapter({
         now: cliNow,
@@ -52,6 +49,9 @@ class TerminalMonitorStateCliApplication {
     });
     constructor(dependencies) {
         this.#dependencies = dependencies;
+        this.#startup = new TerminalMonitorStartupRecovery(dependencies, this.#stateFileLock);
+        this.#collateral = new TerminalMonitorCollateralRecovery(dependencies, this.#stateFileLock);
+        this.#attention = new TerminalMonitorAttentionStore(dependencies, this.#stateFileLock);
     }
     async runService(input) {
         await runTerminalMonitorService({
@@ -181,8 +181,8 @@ class TerminalMonitorStateCliApplication {
                     logPath: paths.logPath,
                     options
                 }),
-                recoverSubmissionRetry: (storeDir, conversation, paths) => this.#recoverSubmissionRetry(storeDir, conversation, paths),
-                recoverDeferred: (storeDir, conversation, paths) => this.#recoverDeferred(options, storeDir, conversation, paths),
+                recoverSubmissionRetry: (storeDir, conversation, paths) => this.#startup.recoverSubmissionRetry(storeDir, conversation, paths),
+                recoverDeferred: (storeDir, conversation, paths) => this.#startup.recoverDeferred(options, storeDir, conversation, paths),
                 recoverVirgin: async (conversation, paths) => (await this.#dependencies.acceptance.recoverVirgin({
                     options,
                     conversation,
@@ -202,311 +202,6 @@ class TerminalMonitorStateCliApplication {
             }
         };
     }
-    async #recoverSubmissionRetry(storeDir, initialConversation, paths) {
-        const initialAttempt = loadTerminalSubmissionRetry(paths.statePath);
-        if (!initialAttempt) {
-            return initialConversation;
-        }
-        const initialTakeover = takeoverFor(initialConversation);
-        const initialControl = terminalControlFromTakeover(initialTakeover);
-        if (executorForConversation(initialConversation).kind !== "codex" ||
-            !initialControl) {
-            throw new Error("submission retry startup recovery lost its exact Codex terminal authority");
-        }
-        const canonical = pathsForConversationDir(path.dirname(paths.statePath));
-        if (path.resolve(canonical.storeDir) !== path.resolve(storeDir) ||
-            path.resolve(canonical.statePath) !== path.resolve(paths.statePath) ||
-            path.resolve(canonical.logPath) !== path.resolve(paths.logPath)) {
-            throw new Error("submission retry startup recovery is outside its canonical Turn Store");
-        }
-        const releaseTerminal = this.#dependencies.dispatch.repository.acquire(storeDir, initialControl, { timeoutMs: 30000 });
-        try {
-            return await withStoreWriterLeaseAsync(storeDir, async () => {
-                const releaseState = this.#stateFileLock.acquire(`${paths.statePath}.lock`);
-                try {
-                    let conversation = loadState(paths.statePath);
-                    const takeover = takeoverFor(conversation);
-                    const control = terminalControlFromTakeover(takeover);
-                    const attempt = loadTerminalSubmissionRetry(paths.statePath);
-                    if (!attempt) {
-                        return conversation;
-                    }
-                    if (executorForConversation(conversation).kind !== "codex" ||
-                        !control ||
-                        !terminalControlsShareIncarnation(control, initialControl)) {
-                        throw new Error("submission retry startup recovery terminal authority changed");
-                    }
-                    const callbackDelivery = isRecord(conversation.callback_delivery)
-                        ? conversation.callback_delivery
-                        : undefined;
-                    if (callbackDelivery?.status === "delivered" ||
-                        isTerminalDispatchOwnerReleasedStatus(effectiveTurnStatus(conversation))) {
-                        return conversation;
-                    }
-                    const submission = terminalBridgeSubmission(conversation);
-                    const ledger = this.#dependencies.dispatch.repository.load(control);
-                    if (!submission || !ledger) {
-                        throw new Error("submission retry startup recovery lacks its Turn or ledger receipt");
-                    }
-                    if (!["agent_accepted"].includes(String(submission.status)) &&
-                        !["agent_accepted"].includes(String(ledger.status)) &&
-                        !["enter_dispatched", "agent_accepted"].includes(attempt.state)) {
-                        return conversation;
-                    }
-                    const authority = assertTerminalSubmissionRetryStartupAuthority({
-                        storeDir,
-                        paths,
-                        conversation,
-                        takeover,
-                        submission,
-                        ledger,
-                        attempt,
-                        control,
-                        ledgerMatchesControl: this.#dependencies.dispatch.repository
-                            .matchesControl(ledger, control)
-                    });
-                    const startup = decideTerminalSubmissionRetryStartup({
-                        attempt,
-                        submission,
-                        ledger
-                    });
-                    if (startup.action === "refuse") {
-                        throw new Error(startup.reason);
-                    }
-                    if (startup.action === "finalize_accepted") {
-                        return finalizeTerminalSubmissionRetryStartupAccepted({
-                            storeDir,
-                            paths,
-                            conversation,
-                            submission,
-                            ledger,
-                            attempt,
-                            control,
-                            authority,
-                            saveLedger: (next) => this.#dependencies.dispatch.repository
-                                .save(control, next)
-                        });
-                    }
-                    if (startup.action === "repair_terminal_ledger") {
-                        reconcileTerminalSubmissionRetryStartupTerminalLedger({
-                            paths,
-                            conversation,
-                            ledger,
-                            attempt,
-                            startup,
-                            saveLedger: (next) => this.#dependencies.dispatch.repository
-                                .save(control, next)
-                        });
-                        return conversation;
-                    }
-                    if (startup.action === "repair_terminal_state") {
-                        return reconcileTerminalSubmissionRetryStartupTerminalState({
-                            storeDir,
-                            paths,
-                            conversation,
-                            submission,
-                            attempt,
-                            control,
-                            authority,
-                            startup
-                        });
-                    }
-                    if (startup.action === "no_change")
-                        return conversation;
-                    const projection = authority.projection;
-                    if (!projection) {
-                        return conversation;
-                    }
-                    const receiptAlreadyPending = submission.status === "enter_dispatched";
-                    if (receiptAlreadyPending
-                        ? conversation.status !== "waiting_for_agent"
-                        : !["stalled", "waiting_for_agent"].includes(String(conversation.status))) {
-                        return conversation;
-                    }
-                    let repairedTransfer = false;
-                    if (authority.deferredTransferId) {
-                        repairedTransfer = mirrorDeferredSubmissionRetryEnter({
-                            storeDir,
-                            transferId: authority.deferredTransferId,
-                            attempt,
-                            messageId: projection.messageId,
-                            preparedAt: projection.preparedAt,
-                            textInjectedAt: projection.textInjectedAt,
-                            requestHash: authority.requestHash,
-                            sessionId: sessionIdForConversation(conversation),
-                            turnId: turnIdForConversation(conversation),
-                            statePath: paths.statePath
-                        });
-                    }
-                    const stateNeedsRepair = !receiptAlreadyPending;
-                    if (receiptAlreadyPending && !terminalSubmissionRetryStateIsPending({
-                        conversation,
-                        submission,
-                        projection
-                    })) {
-                        return conversation;
-                    }
-                    if (stateNeedsRepair) {
-                        const epochConversation = terminalSubmissionRetryMonitorEpoch(conversation, projection.enterDispatchedAt);
-                        conversation = applyTerminalBridgeSubmission({
-                            conversation: epochConversation,
-                            messageId: projection.messageId,
-                            messageType: authority.messageType,
-                            requestText: authority.requestText,
-                            status: "enter_dispatched",
-                            preparedAt: projection.preparedAt,
-                            textInjectedAt: projection.textInjectedAt,
-                            enterDispatchedAt: projection.enterDispatchedAt,
-                            lastProvenStage: "enter_dispatched"
-                        }, {
-                            dispatcherPid: cliPid(),
-                            storeDir,
-                            terminalControl: control
-                        });
-                        saveState(paths.statePath, conversation);
-                    }
-                    const ledgerNeedsRepair = ledger.status !== "enter_dispatched" ||
-                        nonBlankString(ledger.text_injected_at) !==
-                            projection.textInjectedAt ||
-                        nonBlankString(ledger.enter_dispatched_at) !==
-                            projection.enterDispatchedAt ||
-                        ledger.submission_retry_state !== "enter_dispatched" ||
-                        ledger.submission_retry_revision !== attempt.revision;
-                    if (ledgerNeedsRepair) {
-                        this.#dependencies.dispatch.repository.save(control, {
-                            ...ledger,
-                            ...terminalSubmissionRetryLedgerFields(attempt),
-                            status: "enter_dispatched",
-                            text_injected_at: projection.textInjectedAt,
-                            enter_dispatched_at: projection.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
-                        });
-                    }
-                    if (repairedTransfer || stateNeedsRepair || ledgerNeedsRepair) {
-                        appendEvent(paths.logPath, {
-                            ts: projection.enterDispatchedAt,
-                            conversation_id: conversation.conversation_id,
-                            event: "terminal_submission_retry_startup_reconciled",
-                            message_id: projection.messageId,
-                            terminal_input_sent: false
-                        });
-                    }
-                    return loadState(paths.statePath);
-                }
-                finally {
-                    releaseState();
-                }
-            });
-        }
-        finally {
-            releaseTerminal();
-        }
-    }
-    async #recoverDeferred(options, storeDir, initialConversation, paths) {
-        if (isExplicitUserAbandonedManagementTurn(initialConversation)) {
-            return initialConversation;
-        }
-        const takeover = takeoverFor(initialConversation);
-        const transferId = nonBlankString(takeover?.deferred_foreground_transfer_id);
-        if (!transferId) {
-            return initialConversation;
-        }
-        const initialControl = terminalControlFromTakeover(takeover);
-        const initialPid = Number(takeover?.terminal_agent_pid);
-        if (!initialControl ||
-            !Number.isSafeInteger(initialPid) ||
-            initialPid <= 1) {
-            throw new Error(`deferred foreground Turn ${initialConversation.conversation_id} ` +
-                "lost its exact terminal process authority");
-        }
-        const releaseTerminal = this.#dependencies.dispatch.repository.acquire(storeDir, initialControl, { timeoutMs: 30000 });
-        try {
-            return await withStoreWriterLeaseAsync(storeDir, async () => {
-                const releaseState = this.#stateFileLock.acquire(`${paths.statePath}.lock`);
-                let conversation;
-                try {
-                    conversation = loadState(paths.statePath);
-                    if (isExplicitUserAbandonedManagementTurn(conversation)) {
-                        return conversation;
-                    }
-                }
-                finally {
-                    releaseState();
-                }
-                const currentTakeover = takeoverFor(conversation);
-                const currentTransferId = nonBlankString(currentTakeover.deferred_foreground_transfer_id);
-                const currentControl = terminalControlFromTakeover(currentTakeover);
-                const currentPid = Number(currentTakeover.terminal_agent_pid);
-                if (currentTransferId !== transferId ||
-                    !currentControl ||
-                    !terminalControlsShareIncarnation(currentControl, initialControl) ||
-                    !Number.isSafeInteger(currentPid) ||
-                    currentPid !== initialPid) {
-                    throw new Error(`deferred foreground Turn ${conversation.conversation_id} ` +
-                        "changed its exact terminal process authority during recovery");
-                }
-                const transfer = loadDeferredForegroundTransfer(storeDir, transferId);
-                if (isFinalDeferredForegroundTransferStatus(transfer.status)) {
-                    return conversation;
-                }
-                const terminal = await this.#dependencies.authority
-                    .createBridge(options)
-                    .resolveStoredTerminal("codex", currentPid, currentControl, { pid: currentPid });
-                await this.#dependencies.authority.handoff
-                    .recoverDeferredCodexForegroundTransferBeforeMutation({
-                    options,
-                    terminal: terminal
-                });
-                const releaseFinalState = this.#stateFileLock.acquire(`${paths.statePath}.lock`);
-                try {
-                    conversation = loadState(paths.statePath);
-                    this.#assertExactPendingDeferred(conversation, storeDir, transferId);
-                    return conversation;
-                }
-                finally {
-                    releaseFinalState();
-                }
-            });
-        }
-        finally {
-            releaseTerminal();
-        }
-    }
-    #assertExactPendingDeferred(conversation, storeDir, transferId) {
-        const transfer = loadDeferredForegroundTransfer(storeDir, transferId);
-        if (isFinalDeferredForegroundTransferStatus(transfer.status)) {
-            return;
-        }
-        const takeover = takeoverFor(conversation);
-        const submission = terminalBridgeSubmission(conversation);
-        const anchor = validateCodexRolloutAcceptanceAnchor(takeover?.codex_rollout_acceptance_anchor);
-        const activeMessageId = deferredForegroundActiveMessageId(transfer);
-        const exactRetryPending = isDeferredForegroundSubmissionRetryPending(transfer) &&
-            activeMessageId === transfer.submission_retry_message_id &&
-            nonBlankString(submission?.prepared_at) ===
-                deferredForegroundActivePreparedAt(transfer) &&
-            nonBlankString(submission?.text_injected_at) ===
-                deferredForegroundActiveTextInjectedAt(transfer) &&
-            nonBlankString(submission?.enter_dispatched_at) ===
-                deferredForegroundActiveEnterDispatchedAt(transfer);
-        if (anchor?.version !== 3 ||
-            conversation.status !== "waiting_for_agent" ||
-            submission?.status !== "enter_dispatched" ||
-            nonBlankString(submission.message_id) !==
-                nonBlankString(takeover?.terminal_bridge_message_id) ||
-            nonBlankString(submission.message_id) !== activeMessageId ||
-            !(transfer.status === "dispatch_started" || exactRetryPending)) {
-            throw new Error(`deferred foreground Turn ${conversation.conversation_id} ` +
-                "is not an exact pending candidate-set acceptance");
-        }
-    }
     prepareLaunch(input) {
         const storeDir = pathsForConversationDir(path.dirname(input.statePath))
             .storeDir;
@@ -608,7 +303,7 @@ class TerminalMonitorStateCliApplication {
                 recordApprovalNotification: (request) => recordMonitorApprovalNotification({
                     ...request,
                     ports: {
-                        record: (recordRequest) => this.#recordApprovalNotification({
+                        record: (recordRequest) => this.#attention.recordApprovalNotification({
                             ...recordRequest,
                             statePath: input.statePath,
                             logPath: input.logPath
@@ -626,7 +321,7 @@ class TerminalMonitorStateCliApplication {
                 recordInteractionNotification: (request) => recordMonitorInteractionNotification({
                     ...request,
                     ports: {
-                        record: (recordRequest) => this.#recordInteractionNotification({
+                        record: (recordRequest) => this.#attention.recordInteractionNotification({
                             ...recordRequest,
                             statePath: input.statePath,
                             logPath: input.logPath
@@ -687,7 +382,7 @@ class TerminalMonitorStateCliApplication {
                         now: cliNow,
                         appendEvent: (event) => appendEvent(input.logPath, event),
                         stallCollateral: (stallRequest) => {
-                            this.#stallOtherConversations({
+                            this.#collateral.stallOther({
                                 storeDir: stateStoreDir(),
                                 ...stallRequest
                             });
@@ -758,787 +453,6 @@ class TerminalMonitorStateCliApplication {
             }
         };
     }
-    #stallOtherConversations(input) {
-        const stalledConversationIds = [];
-        for (const listed of listConversations(input.storeDir)) {
-            if (listed.conversation_id === input.currentConversationId ||
-                !isSessionSendBlockingStatus(listed.status)) {
-                continue;
-            }
-            const listedTakeover = takeoverFor(listed);
-            if (listedTakeover?.terminal_bridge !== true ||
-                !terminalControlsShareIncarnation(terminalControlFromTakeover(listedTakeover), input.terminalControl)) {
-                continue;
-            }
-            const statePath = nonBlankString(listed.state_path);
-            if (!statePath) {
-                continue;
-            }
-            const release = this.#stateFileLock.acquire(`${statePath}.lock`);
-            try {
-                const current = loadState(statePath);
-                const currentTakeover = takeoverFor(current);
-                if (!isSessionSendBlockingStatus(current.status) ||
-                    currentTakeover?.terminal_bridge !== true ||
-                    !terminalControlsShareIncarnation(terminalControlFromTakeover(currentTakeover), input.terminalControl)) {
-                    continue;
-                }
-                const stalledAt = cliNow().toISOString();
-                const stalledConversation = {
-                    ...current,
-                    status: "stalled",
-                    stalled_at: stalledAt,
-                    stalled_reason: COLLATERAL_STALL_REASON,
-                    native_session_takeover: {
-                        ...currentTakeover,
-                        terminal_bridge_uncertain_dispatch_fence: {
-                            message_id: input.uncertainMessageId,
-                            observed_at: stalledAt,
-                            previous_status: current.status
-                        }
-                    },
-                    updated_at: stalledAt
-                };
-                saveState(statePath, stalledConversation);
-                try {
-                    appendEvent(logPathForStatePath(statePath), {
-                        ts: stalledAt,
-                        conversation_id: current.conversation_id,
-                        event: "terminal_bridge_stalled_by_uncertain_dispatch",
-                        terminal_control: input.terminalControl,
-                        uncertain_message_id: input.uncertainMessageId
-                    });
-                }
-                catch {
-                    // State plus the terminal ledger are the authoritative fence.
-                }
-                stalledConversationIds.push(current.conversation_id);
-            }
-            finally {
-                release();
-            }
-        }
-        return stalledConversationIds;
-    }
-    stallOther(input) {
-        return this.#stallOtherConversations(input);
-    }
-    #exactCollateralRepairEvidence(conversation, storeDir) {
-        if (conversation.status !== "stalled" ||
-            conversation.stalled_reason !== COLLATERAL_STALL_REASON) {
-            return undefined;
-        }
-        const takeover = takeoverFor(conversation);
-        const fence = isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence)
-            ? takeover.terminal_bridge_uncertain_dispatch_fence
-            : undefined;
-        const uncertainMessageId = nonBlankString(fence?.message_id);
-        const fenceObservedAt = nonBlankString(fence?.observed_at);
-        const previousStatus = nonBlankString(fence?.previous_status);
-        const ownMessageId = nonBlankString(takeover?.terminal_bridge_message_id);
-        const ownSubmission = terminalBridgeSubmission(conversation);
-        const completionClaim = isRecord(takeover?.terminal_bridge_completion_claim)
-            ? takeover.terminal_bridge_completion_claim
-            : undefined;
-        const callbackDelivery = isRecord(conversation.callback_delivery)
-            ? conversation.callback_delivery
-            : undefined;
-        const callbackMessage = isRecord(callbackDelivery?.message)
-            ? callbackDelivery.message
-            : undefined;
-        const idleSince = nonBlankString(conversation.idle_since);
-        const deliveredAt = nonBlankString(callbackDelivery?.delivered_at);
-        const claimedAt = nonBlankString(completionClaim?.claimed_at);
-        const fenceAtMs = validTerminalMonitorTimestampMs(fenceObservedAt);
-        const idleAtMs = validTerminalMonitorTimestampMs(idleSince);
-        const deliveredAtMs = validTerminalMonitorTimestampMs(deliveredAt);
-        const claimedAtMs = validTerminalMonitorTimestampMs(claimedAt);
-        if (takeover?.terminal_bridge !== true ||
-            !uncertainMessageId ||
-            !fenceObservedAt ||
-            fenceAtMs === undefined ||
-            uncertainMessageId === ownMessageId ||
-            (previousStatus !== undefined && previousStatus !== "idle") ||
-            conversation.stalled_at !== fenceObservedAt ||
-            conversation.updated_at !== fenceObservedAt ||
-            !idleSince ||
-            idleAtMs === undefined ||
-            idleAtMs > fenceAtMs ||
-            !ownMessageId ||
-            ownSubmission?.status !== "agent_accepted" ||
-            nonBlankString(ownSubmission.message_id) !== ownMessageId ||
-            nonBlankString(ownSubmission.session_id) !==
-                sessionIdForConversation(conversation) ||
-            nonBlankString(ownSubmission.turn_id) !== turnIdForConversation(conversation) ||
-            !completionClaim ||
-            nonBlankString(completionClaim.terminal_bridge_message_id) !== ownMessageId ||
-            completionClaim.outcome !== "success" ||
-            !claimedAt ||
-            claimedAtMs === undefined ||
-            claimedAtMs > fenceAtMs ||
-            callbackDelivery?.status !== "delivered" ||
-            callbackDelivery.final_status !== "idle" ||
-            callbackDelivery.preserve_conversation_status !== true ||
-            !callbackMessage ||
-            callbackMessage.type !== "done" ||
-            callbackMessage.requires_response !== false ||
-            nonBlankString(callbackMessage.id) !==
-                nonBlankString(completionClaim.callback_message_id) ||
-            nonBlankString(callbackMessage.conversation_id) !==
-                conversation.conversation_id ||
-            nonBlankString(callbackMessage.session_id) !==
-                sessionIdForConversation(conversation) ||
-            nonBlankString(callbackMessage.turn_id) !== turnIdForConversation(conversation) ||
-            nonBlankString(isRecord(callbackMessage.metadata)
-                ? callbackMessage.metadata.terminal_bridge_message_id
-                : undefined) !== ownMessageId ||
-            !deliveredAt ||
-            deliveredAtMs === undefined ||
-            deliveredAtMs > fenceAtMs) {
-            return undefined;
-        }
-        const control = this.#dependencies.authority
-            .terminalControlForConversation(conversation);
-        if (!control) {
-            return undefined;
-        }
-        const ownerCandidates = listConversations(storeDir).filter((candidate) => {
-            if (candidate.conversation_id === conversation.conversation_id) {
-                return false;
-            }
-            const candidateTakeover = takeoverFor(candidate);
-            const candidateSubmission = terminalBridgeSubmission(candidate);
-            return candidateTakeover?.terminal_bridge === true &&
-                nonBlankString(candidateTakeover.terminal_bridge_message_id) ===
-                    uncertainMessageId &&
-                nonBlankString(candidateSubmission?.message_id) === uncertainMessageId &&
-                terminalControlsShareIncarnation(this.#dependencies.authority.terminalControlForConversation(candidate), control);
-        });
-        if (ownerCandidates.length !== 1) {
-            return undefined;
-        }
-        return this.#verifyCollateralOwner({
-            conversation,
-            takeover,
-            ownMessageId,
-            completionClaim,
-            callbackMessage,
-            callbackMessageId: nonBlankString(callbackMessage.id),
-            deliveredAt,
-            claimedAt,
-            fenceObservedAt,
-            fenceAtMs,
-            uncertainMessageId,
-            control,
-            ownerListed: ownerCandidates[0]
-        });
-    }
-    #verifyCollateralOwner(input) {
-        const ownerStatePath = nonBlankString(input.ownerListed.state_path);
-        if (!ownerStatePath) {
-            return undefined;
-        }
-        let owner;
-        let ownerEvents;
-        let events;
-        try {
-            owner = loadState(ownerStatePath);
-            ownerEvents = readNdjsonLog(nonBlankString(owner.event_log_path) ??
-                logPathForStatePath(ownerStatePath));
-            const statePath = nonBlankString(input.conversation.state_path);
-            if (!statePath) {
-                return undefined;
-            }
-            events = readNdjsonLog(nonBlankString(input.conversation.event_log_path) ??
-                logPathForStatePath(statePath));
-        }
-        catch {
-            return undefined;
-        }
-        const ownerTakeover = takeoverFor(owner);
-        const ownerSubmission = terminalBridgeSubmission(owner);
-        const ownerClosedAt = nonBlankString(owner.closed_at);
-        const ownerClosedAtMs = validTerminalMonitorTimestampMs(ownerClosedAt);
-        if (owner.conversation_id !== input.ownerListed.conversation_id ||
-            owner.status !== "closed" ||
-            !ownerClosedAt ||
-            ownerClosedAtMs === undefined ||
-            ownerClosedAtMs < input.fenceAtMs ||
-            !nonBlankString(owner.close_reason) ||
-            owner.updated_at !== ownerClosedAt ||
-            ownerTakeover?.terminal_bridge !== true ||
-            nonBlankString(ownerTakeover.terminal_bridge_message_id) !==
-                input.uncertainMessageId ||
-            ownerSubmission?.status !== "uncertain" ||
-            nonBlankString(ownerSubmission.message_id) !== input.uncertainMessageId ||
-            nonBlankString(ownerSubmission.session_id) !== sessionIdForConversation(owner) ||
-            nonBlankString(ownerSubmission.turn_id) !== turnIdForConversation(owner) ||
-            isRecord(ownerTakeover.terminal_bridge_uncertain_dispatch_fence) ||
-            !terminalControlsShareIncarnation(this.#dependencies.authority.terminalControlForConversation(owner), input.control)) {
-            return undefined;
-        }
-        if (!this.#hasExactCollateralEvents(input, owner, ownerClosedAt, events, ownerEvents)) {
-            return undefined;
-        }
-        return {
-            uncertainMessageId: input.uncertainMessageId,
-            ownerConversationId: owner.conversation_id,
-            restoredStatus: "idle"
-        };
-    }
-    #hasExactCollateralEvents(input, owner, ownerClosedAt, events, ownerEvents) {
-        const hasCompletionClaim = events.some((event) => event.event === "terminal_bridge_completion_claimed" &&
-            event.conversation_id === input.conversation.conversation_id &&
-            event.terminal_bridge_message_id === input.ownMessageId &&
-            event.callback_message_id === input.callbackMessageId &&
-            event.completion_fingerprint === input.completionClaim.completion_fingerprint &&
-            event.completion_id === input.completionClaim.completion_id &&
-            event.outcome === "success" &&
-            event.ts === input.claimedAt);
-        const hasCompletionDetected = events.some((event) => event.event === "terminal_bridge_completion_detected" &&
-            event.conversation_id === input.conversation.conversation_id &&
-            event.terminal_bridge_message_id === input.ownMessageId &&
-            event.callback_message_id === input.callbackMessageId &&
-            event.completion_id === input.completionClaim.completion_id &&
-            event.completion_outcome === "success" &&
-            validTerminalMonitorTimestampMs(event.ts) !== undefined &&
-            validTerminalMonitorTimestampMs(event.ts) <= input.fenceAtMs);
-        const hasDeliveredCallback = events.some((event) => event.event === "callback_delivery_succeeded" &&
-            event.conversation_id === input.conversation.conversation_id &&
-            event.message_id === input.callbackMessageId &&
-            event.status === "idle" &&
-            event.ts === input.deliveredAt);
-        const hasExactFence = events.some((event) => event.event === "terminal_bridge_stalled_by_uncertain_dispatch" &&
-            event.conversation_id === input.conversation.conversation_id &&
-            event.uncertain_message_id === input.uncertainMessageId &&
-            event.ts === input.fenceObservedAt);
-        const hasExactOwnerClose = ownerEvents.some((event) => event.event === "conversation_closed" &&
-            event.conversation_id === owner.conversation_id &&
-            event.status === "closed" &&
-            event.ts === ownerClosedAt &&
-            event.reason === owner.close_reason);
-        return hasCompletionClaim && hasCompletionDetected &&
-            hasDeliveredCallback && hasExactFence && hasExactOwnerClose;
-    }
-    async reconcileCollateral(storeDir, conversationId) {
-        return withStoreWriterLeaseAsync(storeDir, async () => this.#reconcileCollateralLocked(storeDir, conversationId));
-    }
-    #reconcileCollateralLocked(storeDir, conversationId) {
-        const reservedSourceTurnIds = new Set(listDeferredForegroundTransfers(storeDir)
-            .filter((transfer) => transfer.version === 2 &&
-            transfer.source_kind === "candidate_rollout_quiescent" &&
-            !isFinalDeferredForegroundTransferStatus(transfer.status))
-            .flatMap((transfer) => (transfer.source_turn_history ?? []).map((turn) => turn.turn_id)));
-        const candidates = listConversations(storeDir).filter((conversation) => {
-            const takeover = takeoverFor(conversation);
-            return (conversationId === undefined ||
-                conversation.conversation_id === conversationId) &&
-                !reservedSourceTurnIds.has(turnIdForConversation(conversation)) &&
-                conversation.status === "stalled" &&
-                isRecord(takeover?.terminal_bridge_uncertain_dispatch_fence);
-        });
-        const result = {
-            checked: candidates.length,
-            repaired: 0,
-            skipped: 0,
-            errors: [],
-            items: []
-        };
-        for (const listed of candidates) {
-            this.#reconcileCollateralCandidate(storeDir, listed, result);
-        }
-        return result;
-    }
-    #reconcileCollateralCandidate(storeDir, listed, result) {
-        const statePath = nonBlankString(listed.state_path);
-        if (!statePath) {
-            result.skipped += 1;
-            return;
-        }
-        let release;
-        try {
-            release = this.#stateFileLock.acquire(`${statePath}.lock`);
-            const current = loadState(statePath);
-            const evidence = this.#exactCollateralRepairEvidence(current, storeDir);
-            if (!evidence) {
-                result.skipped += 1;
-                return;
-            }
-            const repaired = this.#persistCollateralRepair(statePath, current, evidence);
-            result.repaired += 1;
-            result.items.push(repaired);
-        }
-        catch (error) {
-            result.skipped += 1;
-            const reason = error instanceof Error ? error.message : String(error);
-            result.errors.push(`${listed.conversation_id}: ${reason}`);
-            result.items.push({
-                conversation_id: listed.conversation_id,
-                status: "error",
-                reason
-            });
-        }
-        finally {
-            release?.();
-        }
-    }
-    #persistCollateralRepair(statePath, current, evidence) {
-        const takeover = { ...takeoverFor(current) };
-        delete takeover.terminal_bridge_uncertain_dispatch_fence;
-        const repairedAt = cliNow().toISOString();
-        takeover.terminal_bridge_collateral_stall_repair = {
-            repaired_at: repairedAt,
-            uncertain_message_id: evidence.uncertainMessageId,
-            uncertain_owner_conversation_id: evidence.ownerConversationId,
-            restored_status: evidence.restoredStatus,
-            evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
-        };
-        const conversation = {
-            ...current,
-            status: evidence.restoredStatus,
-            native_session_takeover: takeover,
-            updated_at: repairedAt
-        };
-        delete conversation.stalled_at;
-        delete conversation.stalled_reason;
-        saveState(statePath, conversation);
-        const eventWarning = this.#appendCollateralRepairEvent(statePath, current, evidence, repairedAt);
-        return {
-            conversation_id: current.conversation_id,
-            status: "repaired",
-            reason: "legacy_terminal_bridge_collateral_stall",
-            uncertain_message_id: evidence.uncertainMessageId,
-            uncertain_owner_conversation_id: evidence.ownerConversationId,
-            restored_status: evidence.restoredStatus,
-            ...(eventWarning ? { event_warning: eventWarning } : {})
-        };
-    }
-    #appendCollateralRepairEvent(statePath, current, evidence, repairedAt) {
-        try {
-            appendEvent(nonBlankString(current.event_log_path) ??
-                logPathForStatePath(statePath), {
-                ts: repairedAt,
-                conversation_id: current.conversation_id,
-                event: "terminal_bridge_collateral_stall_repaired",
-                uncertain_message_id: evidence.uncertainMessageId,
-                uncertain_owner_conversation_id: evidence.ownerConversationId,
-                previous_status: "stalled",
-                restored_status: evidence.restoredStatus,
-                evidence: "foreign_uncertain_fence+completion_claim+delivered_callback+closed_owner"
-            });
-            return undefined;
-        }
-        catch (error) {
-            const warning = error instanceof Error ? error.message : String(error);
-            cliRuntimeLog("warn", "terminal_bridge_collateral_stall_repair_event_failed", {
-                conversation_id: current.conversation_id,
-                uncertain_message_id: evidence.uncertainMessageId,
-                error: warning
-            });
-            return warning;
-        }
-    }
-    #recordApprovalNotification(input) {
-        const storeDir = pathsForConversationDir(path.dirname(input.statePath))
-            .storeDir;
-        return withStoreWriterLease(storeDir, () => {
-            const release = this.#stateFileLock.acquire(`${input.statePath}.lock`);
-            try {
-                const conversation = loadState(input.statePath);
-                if (!this.#approvalSnapshotMatches(conversation, input)) {
-                    return {
-                        conversation,
-                        duplicate: false,
-                        stale: true,
-                        recorded: undefined
-                    };
-                }
-                return this.#recordMatchingApproval(this.#approvalPersistenceContext(conversation, input));
-            }
-            finally {
-                release();
-            }
-        });
-    }
-    #approvalSnapshotMatches(conversation, input) {
-        const takeover = takeoverFor(conversation);
-        const currentControl = terminalControlFromTakeover(takeover);
-        return isWaitingForAgentStatus(conversation.status) &&
-            conversation.conversation_id === input.expectedConversation.conversationId &&
-            conversation.status === input.expectedConversation.status &&
-            conversation.updated_at === input.expectedConversation.updatedAt &&
-            takeover?.terminal_bridge === true &&
-            nonBlankString(takeover.terminal_bridge_message_id) ===
-                input.expectedConversation.messageId &&
-            currentControl !== undefined &&
-            terminalControlsShareIncarnation(currentControl, input.terminalControl);
-    }
-    #approvalPersistenceContext(conversation, input) {
-        const nativeTakeover = { ...takeoverFor(conversation) };
-        const screen = isRecord(input.terminalStatus.screen)
-            ? input.terminalStatus.screen
-            : undefined;
-        const approvalScreenDigest = nonBlankString(screen?.digest);
-        const previousApproval = isRecord(nativeTakeover.terminal_bridge_approval)
-            ? nativeTakeover.terminal_bridge_approval
-            : undefined;
-        const previousNotifiedAt = validTerminalMonitorTimestampMs(previousApproval?.notified_at);
-        const callbackDelivery = isRecord(conversation.callback_delivery)
-            ? conversation.callback_delivery
-            : undefined;
-        const callbackMessage = isRecord(callbackDelivery?.message)
-            ? callbackDelivery.message
-            : undefined;
-        const previousCallbackMessageId = nonBlankString(previousApproval?.callback_message_id);
-        const matchingApprovalOutbox = callbackDelivery?.kind === "approval_notification" &&
-            previousCallbackMessageId !== undefined &&
-            callbackMessage?.id === previousCallbackMessageId;
-        const deliveryStatus = nonBlankString(callbackDelivery?.status);
-        const deliveryAttempts = Number(callbackDelivery?.attempts ?? 0);
-        const conflictingActiveOutbox = !matchingApprovalOutbox && (deliveryStatus === "pending" ||
-            (deliveryStatus === "failed" &&
-                Number.isFinite(deliveryAttempts) &&
-                deliveryAttempts <= this.#dependencies.runtime.callbackRetryLimit));
-        return {
-            input,
-            conversation,
-            nativeTakeover,
-            approvalScreenDigest,
-            previousApproval,
-            previousNotifiedAt,
-            previousCallbackMessageId,
-            matchingApprovalOutbox,
-            conflictingActiveOutbox
-        };
-    }
-    #recordMatchingApproval(context) {
-        const duplicate = context.previousApproval?.fingerprint === context.input.fingerprint &&
-            context.previousNotifiedAt !== undefined &&
-            cliNowMs() - context.previousNotifiedAt <=
-                this.#dependencies.runtime.approvalTtlMs;
-        if (!duplicate) {
-            return this.#recordNewApproval(context);
-        }
-        if (context.conflictingActiveOutbox) {
-            return {
-                conversation: context.conversation,
-                duplicate: false,
-                stale: true,
-                deferred: true,
-                previousApproval: context.previousApproval,
-                recorded: undefined
-            };
-        }
-        if (!context.matchingApprovalOutbox) {
-            return this.#recoverApprovalOutbox(context);
-        }
-        return {
-            conversation: context.conversation,
-            duplicate: true,
-            stale: false,
-            previousApproval: context.previousApproval,
-            recorded: undefined
-        };
-    }
-    #recoverApprovalOutbox(context) {
-        const messageId = context.previousCallbackMessageId ?? `msg-${randomUUID()}`;
-        const messageTs = nonBlankString(context.previousApproval?.callback_message_ts) ?? nonBlankString(context.previousApproval?.notified_at) ??
-            cliNow().toISOString();
-        const conversation = context.previousCallbackMessageId
-            ? context.conversation
-            : {
-                ...context.conversation,
-                native_session_takeover: {
-                    ...context.nativeTakeover,
-                    terminal_bridge_approval: {
-                        ...context.previousApproval,
-                        callback_message_id: messageId,
-                        callback_message_ts: messageTs
-                    }
-                }
-            };
-        if (!context.previousCallbackMessageId) {
-            saveState(context.input.statePath, conversation);
-        }
-        const recorded = context.input.onRecorded(conversation, {
-            recoverMissingOutbox: true
-        });
-        appendEvent(context.input.logPath, {
-            ts: cliNow().toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_approval_notification_outbox_recovered",
-            terminal_control: context.input.terminalControl,
-            fingerprint: context.input.fingerprint,
-            callback_message_id: messageId
-        });
-        return {
-            conversation: recorded.prepared?.conversation ?? conversation,
-            duplicate: false,
-            recovered: true,
-            stale: false,
-            previousApproval: context.previousApproval,
-            recorded
-        };
-    }
-    #recordNewApproval(context) {
-        const now = cliNow().toISOString();
-        const callbackMessageId = `msg-${randomUUID()}`;
-        const conversation = {
-            ...context.conversation,
-            native_session_takeover: {
-                ...context.nativeTakeover,
-                terminal_bridge_approval: {
-                    fingerprint: context.input.fingerprint,
-                    screen_digest: context.approvalScreenDigest,
-                    notified_at: now,
-                    terminal_control: context.input.terminalControl,
-                    approval_state: context.input.terminalStatus.approval_state,
-                    callback_message_id: callbackMessageId,
-                    callback_message_ts: now
-                }
-            },
-            updated_at: now
-        };
-        saveState(context.input.statePath, conversation);
-        appendEvent(context.input.logPath, {
-            ts: now,
-            conversation_id: context.conversation.conversation_id,
-            event: "terminal_bridge_approval_notification_recorded",
-            terminal_control: context.input.terminalControl,
-            fingerprint: context.input.fingerprint,
-            screen_digest: context.approvalScreenDigest
-        });
-        const recorded = context.input.onRecorded(conversation);
-        return {
-            conversation: recorded.prepared?.conversation ?? conversation,
-            duplicate: false,
-            stale: false,
-            recorded
-        };
-    }
-    #recordInteractionNotification(input) {
-        const storeDir = pathsForConversationDir(path.dirname(input.statePath))
-            .storeDir;
-        return withStoreWriterLease(storeDir, () => {
-            const release = this.#stateFileLock.acquire(`${input.statePath}.lock`);
-            try {
-                const conversation = loadState(input.statePath);
-                if (!this.#interactionSnapshotMatches(conversation, input)) {
-                    return {
-                        conversation,
-                        duplicate: false,
-                        stale: true,
-                        recorded: undefined
-                    };
-                }
-                return this.#recordMatchingInteraction(this.#interactionPersistenceContext(conversation, input));
-            }
-            finally {
-                release();
-            }
-        });
-    }
-    #interactionSnapshotMatches(conversation, input) {
-        const takeover = takeoverFor(conversation);
-        const currentControl = terminalControlFromTakeover(takeover);
-        const projection = input.terminalStatus.interaction_state;
-        return conversation.status === "waiting_for_agent" &&
-            conversation.conversation_id === input.expectedConversation.conversationId &&
-            conversation.status === input.expectedConversation.status &&
-            conversation.updated_at === input.expectedConversation.updatedAt &&
-            takeover?.terminal_bridge === true &&
-            nonBlankString(takeover.terminal_bridge_message_id) ===
-                input.expectedConversation.messageId &&
-            currentControl !== undefined &&
-            terminalControlsShareIncarnation(currentControl, input.terminalControl) &&
-            projection?.interaction_id === input.interactionId &&
-            projection.questions.length === 1 &&
-            projection.questions[0]?.question_id === input.questionId &&
-            input.terminalStatus.interaction_prompt_fingerprint === input.fingerprint &&
-            input.terminalStatus.interaction_surface_id === input.surfaceId &&
-            validTerminalInteractionSurfaceId(input.surfaceId);
-    }
-    #interactionPersistenceContext(conversation, input) {
-        const nativeTakeover = { ...takeoverFor(conversation) };
-        const screen = isRecord(input.terminalStatus.screen)
-            ? input.terminalStatus.screen
-            : undefined;
-        const interactionScreenDigest = nonBlankString(screen?.digest);
-        const previousNotification = isRecord(nativeTakeover.terminal_bridge_interaction_notification)
-            ? nativeTakeover.terminal_bridge_interaction_notification
-            : undefined;
-        const previousInteractionState = validInteractionProjection(previousNotification?.interaction_state);
-        const callbackField = input.terminalStatus.interaction_state?.kind ===
-            "async_question"
-            ? "callback_notification_delivery"
-            : "callback_delivery";
-        const callbackDelivery = isRecord(conversation[callbackField])
-            ? conversation[callbackField]
-            : undefined;
-        const callbackMessage = isRecord(callbackDelivery?.message)
-            ? callbackDelivery.message
-            : undefined;
-        const callbackMetadata = isRecord(callbackMessage?.metadata)
-            ? callbackMessage.metadata
-            : undefined;
-        const callbackInteractionState = validInteractionProjection(callbackMetadata?.interaction_state);
-        const callbackInteractionReason = callbackInteractionState?.state === "pending" &&
-            callbackInteractionState.capabilities.respond === true &&
-            callbackInteractionState.questions[0]?.response_kind !== "multi_select"
-            ? "interaction_required"
-            : "interaction_manual_required";
-        const previousCallbackMessageId = nonBlankString(previousNotification?.callback_message_id);
-        const matchingInteractionOutbox = callbackDelivery?.kind === "interaction_notification" &&
-            previousCallbackMessageId !== undefined &&
-            callbackMessage?.id === previousCallbackMessageId &&
-            callbackMetadata?.source === "terminal_bridge" &&
-            callbackMetadata?.reason === callbackInteractionReason &&
-            callbackInteractionState !== undefined &&
-            callbackInteractionState.interaction_id ===
-                previousNotification?.interaction_id &&
-            callbackInteractionState.questions.length === 1 &&
-            callbackInteractionState.questions[0]?.question_id ===
-                previousNotification?.question_id &&
-            previousNotification?.surface_id === input.surfaceId &&
-            callbackInteractionState.turn_id === turnIdForConversation(conversation);
-        const deliveryStatus = nonBlankString(callbackDelivery?.status);
-        const deliveryAttempts = Number(callbackDelivery?.attempts ?? 0);
-        const activeOutbox = deliveryStatus === "pending" ||
-            (deliveryStatus === "failed" &&
-                Number.isFinite(deliveryAttempts) &&
-                deliveryAttempts <= this.#dependencies.runtime.callbackRetryLimit);
-        const conflictingActiveOutbox = activeOutbox && !matchingInteractionOutbox;
-        return {
-            input,
-            conversation,
-            nativeTakeover,
-            interactionScreenDigest,
-            previousNotification,
-            previousInteractionState,
-            previousCallbackMessageId,
-            matchingInteractionOutbox,
-            activeOutbox,
-            conflictingActiveOutbox
-        };
-    }
-    #recordMatchingInteraction(context) {
-        const duplicate = context.previousNotification?.terminal_bridge_message_id ===
-            context.input.expectedConversation.messageId &&
-            context.previousNotification?.interaction_id ===
-                context.input.interactionId &&
-            context.previousNotification?.question_id === context.input.questionId &&
-            context.previousNotification?.prompt_fingerprint ===
-                context.input.fingerprint &&
-            context.previousNotification?.surface_id === context.input.surfaceId &&
-            context.previousInteractionState?.interaction_id ===
-                context.input.interactionId &&
-            context.previousInteractionState.questions.length === 1 &&
-            context.previousInteractionState.questions[0]?.question_id ===
-                context.input.questionId;
-        if (context.conflictingActiveOutbox ||
-            (context.activeOutbox && !duplicate)) {
-            return {
-                conversation: context.conversation,
-                duplicate: false,
-                stale: true,
-                deferred: true,
-                recorded: undefined
-            };
-        }
-        if (!duplicate) {
-            return this.#recordNewInteraction(context);
-        }
-        if (!context.matchingInteractionOutbox) {
-            return this.#recoverInteractionOutbox(context);
-        }
-        return {
-            conversation: context.conversation,
-            duplicate: true,
-            stale: false,
-            recorded: undefined
-        };
-    }
-    #recoverInteractionOutbox(context) {
-        const messageId = context.previousCallbackMessageId ?? `msg-${randomUUID()}`;
-        const messageTs = nonBlankString(context.previousNotification?.callback_message_ts) ?? nonBlankString(context.previousNotification?.notified_at) ??
-            cliNow().toISOString();
-        const conversation = context.previousCallbackMessageId
-            ? context.conversation
-            : {
-                ...context.conversation,
-                native_session_takeover: {
-                    ...context.nativeTakeover,
-                    terminal_bridge_interaction_notification: {
-                        ...context.previousNotification,
-                        callback_message_id: messageId,
-                        callback_message_ts: messageTs
-                    }
-                }
-            };
-        if (!context.previousCallbackMessageId) {
-            saveState(context.input.statePath, conversation);
-        }
-        const recorded = context.input.onRecorded(conversation, {
-            recoverMissingOutbox: true
-        });
-        appendEvent(context.input.logPath, {
-            ts: cliNow().toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_interaction_notification_outbox_recovered",
-            terminal_control: context.input.terminalControl,
-            interaction_id: context.input.interactionId,
-            question_id: context.input.questionId,
-            callback_message_id: messageId
-        });
-        return {
-            conversation: recorded.prepared?.conversation ?? conversation,
-            duplicate: false,
-            recovered: true,
-            stale: false,
-            recorded
-        };
-    }
-    #recordNewInteraction(context) {
-        const now = cliNow().toISOString();
-        const callbackMessageId = `msg-${randomUUID()}`;
-        const conversation = {
-            ...context.conversation,
-            native_session_takeover: {
-                ...context.nativeTakeover,
-                terminal_bridge_interaction_notification: {
-                    terminal_bridge_message_id: context.input.expectedConversation.messageId,
-                    interaction_id: context.input.interactionId,
-                    question_id: context.input.questionId,
-                    prompt_fingerprint: context.input.fingerprint,
-                    surface_id: context.input.surfaceId,
-                    screen_digest: context.interactionScreenDigest,
-                    notified_at: now,
-                    terminal_control: context.input.terminalControl,
-                    interaction_state: context.input.terminalStatus.interaction_state,
-                    callback_message_id: callbackMessageId,
-                    callback_message_ts: now
-                }
-            },
-            updated_at: now
-        };
-        saveState(context.input.statePath, conversation);
-        appendEvent(context.input.logPath, {
-            ts: now,
-            conversation_id: context.conversation.conversation_id,
-            event: "terminal_bridge_interaction_notification_recorded",
-            terminal_control: context.input.terminalControl,
-            interaction_id: context.input.interactionId,
-            question_id: context.input.questionId,
-            screen_digest: context.interactionScreenDigest
-        });
-        const recorded = context.input.onRecorded(conversation);
-        return {
-            conversation: recorded.prepared?.conversation ?? conversation,
-            duplicate: false,
-            stale: false,
-            recorded
-        };
-    }
     #markApprovalPromptCleared(input) {
         const storeDir = pathsForConversationDir(path.dirname(input.statePath))
             .storeDir;
@@ -1809,6 +723,12 @@ class TerminalMonitorStateCliApplication {
         });
         return { conversation: persistedConversation, prepared };
     }
+    reconcileCollateral(storeDir, conversationId) {
+        return this.#collateral.reconcileCollateral(storeDir, conversationId);
+    }
+    stallOther(input) {
+        return this.#collateral.stallOther(input);
+    }
 }
 function monitorRuntimePort() {
     return {
@@ -1821,443 +741,6 @@ function monitorRuntimePort() {
         exit: cliExit
     };
 }
-function terminalSubmissionRetryStartupAuthorityContext(input) {
-    const sessionId = sessionIdForConversation(input.conversation);
-    const turnId = turnIdForConversation(input.conversation);
-    const messageId = nonBlankString(input.submission.message_id);
-    const requestText = terminalSubmissionPayload(nonBlankString(input.takeover.terminal_bridge_request_text) ?? "");
-    const requestHash = terminalBridgeRequestFingerprint(requestText);
-    const messageType = nonBlankString(input.submission.message_type);
-    const messageBodyHash = createHash("sha256")
-        .update(requestText)
-        .digest("hex");
-    const callbackFingerprint = callbackRouteFingerprintForConversation(input.conversation) ?? null;
-    const deferredReferences = [
-        nonBlankString(input.takeover.deferred_foreground_transfer_id),
-        nonBlankString(input.submission.deferred_foreground_transfer_id),
-        nonBlankString(input.ledger.deferred_foreground_transfer_id),
-        input.attempt.deferred_foreground_transfer_id ?? undefined
-    ];
-    const presentDeferredReferences = deferredReferences.filter((value) => value !== undefined);
-    const deferredTransferId = presentDeferredReferences[0];
-    const submissionTerminalEvidence = input.submission.terminal_endpoint !== undefined
-        ? input.submission.terminal_endpoint
-        : input.submission.terminal_control;
-    const statePath = nonBlankString(input.conversation.state_path);
-    const logPath = nonBlankString(input.conversation.event_log_path);
-    const bindingId = nonBlankString(input.conversation.terminal_binding_id);
-    const bindingGeneration = Number(input.conversation.terminal_binding_generation);
-    return {
-        sessionId,
-        turnId,
-        messageId,
-        requestText,
-        requestHash,
-        messageType,
-        messageBodyHash,
-        callbackFingerprint,
-        deferredReferences,
-        presentDeferredReferences,
-        deferredTransferId,
-        submissionTerminalEvidence,
-        statePath,
-        logPath,
-        bindingId,
-        bindingGeneration
-    };
-}
-function terminalSubmissionRetryStartupIdentityMatches(input, context) {
-    return !(!context.requestText || !context.requestHash || !context.messageId ||
-        (context.messageType !== "task" && context.messageType !== "answer") ||
-        nonBlankString(input.takeover.terminal_bridge_message_id) !==
-            context.messageId ||
-        input.attempt.session_id !== context.sessionId ||
-        input.attempt.turn_id !== context.turnId ||
-        input.attempt.original_message_id !== context.messageId ||
-        input.attempt.active_message_id !== context.messageId ||
-        input.attempt.request_hash !== context.requestHash ||
-        input.attempt.terminal_target !== input.control.target ||
-        input.attempt.callback_route_fingerprint !== context.callbackFingerprint);
-}
-function terminalSubmissionRetryStartupSubmissionPathMatches(input) {
-    return path.resolve(nonBlankString(input.submission.store_dir) ?? "") ===
-        path.resolve(input.storeDir);
-}
-function terminalSubmissionRetryStartupSubmissionMatches(input, context) {
-    return !(nonBlankString(input.submission.session_id) !== context.sessionId ||
-        nonBlankString(input.submission.turn_id) !== context.turnId ||
-        nonBlankString(input.submission.request_hash) !== context.requestHash ||
-        nonBlankString(input.submission.message_body_hash) !==
-            context.messageBodyHash ||
-        nonBlankString(input.submission.executor_kind) !== "codex" ||
-        !terminalSubmissionRetryStartupSubmissionPathMatches(input) ||
-        (input.submission.callback_route_fingerprint ?? null) !==
-            context.callbackFingerprint ||
-        !terminalControlEvidenceMatches(context.submissionTerminalEvidence, input.control));
-}
-function terminalSubmissionRetryStartupLedgerPathMatches(input, context) {
-    return !(path.resolve(nonBlankString(input.ledger.store_dir) ?? "") !==
-        path.resolve(input.storeDir) ||
-        !sameCanonicalStatePath(input.ledger.state_path, input.paths.statePath) ||
-        !sameCanonicalStatePath(context.statePath, input.paths.statePath) ||
-        !sameCanonicalStatePath(input.ledger.event_log_path, input.paths.logPath) ||
-        !sameCanonicalStatePath(context.logPath, input.paths.logPath));
-}
-function terminalSubmissionRetryStartupLedgerMatches(input, context) {
-    return !(nonBlankString(input.ledger.generation_id) !== context.messageId ||
-        nonBlankString(input.ledger.message_id) !== context.messageId ||
-        nonBlankString(input.ledger.conversation_id) !==
-            input.conversation.conversation_id ||
-        nonBlankString(input.ledger.session_id) !== context.sessionId ||
-        nonBlankString(input.ledger.turn_id) !== context.turnId ||
-        nonBlankString(input.ledger.message_type) !== context.messageType ||
-        nonBlankString(input.ledger.message_body_hash) !==
-            context.messageBodyHash ||
-        nonBlankString(input.ledger.executor_kind) !== "codex" ||
-        nonBlankString(input.ledger.request_hash) !== context.requestHash ||
-        !terminalSubmissionRetryStartupLedgerPathMatches(input, context) ||
-        (input.ledger.callback_route_fingerprint ?? null) !==
-            context.callbackFingerprint ||
-        input.ledger.callback_expected !==
-            callbackExpectedForConversation(input.conversation) ||
-        !input.ledgerMatchesControl ||
-        (context.bindingId !== undefined &&
-            nonBlankString(input.ledger.binding_id) !== context.bindingId) ||
-        (Number.isSafeInteger(context.bindingGeneration) &&
-            Number(input.ledger.binding_generation) !== context.bindingGeneration));
-}
-function terminalSubmissionRetryStartupDeferredMatches(input, context) {
-    return !((context.deferredTransferId !== undefined &&
-        (context.presentDeferredReferences.length !==
-            context.deferredReferences.length ||
-            new Set(context.presentDeferredReferences).size !== 1)) ||
-        (context.deferredTransferId === undefined &&
-            input.attempt.deferred_foreground_transfer_id !== null));
-}
-function terminalSubmissionRetryStartupProjectionFields(input) {
-    if (input.attempt.state === "agent_accepted" ||
-        ["agent_accepted", "not_accepted"].includes(String(input.submission.status)) ||
-        ["agent_accepted", "not_accepted"].includes(String(input.ledger.status))) {
-        return {};
-    }
-    return {
-        projection: projectTerminalSubmissionRetryPending({
-            attempt: input.attempt,
-            submission: input.submission,
-            ledger: input.ledger
-        })
-    };
-}
-function assertTerminalSubmissionRetryStartupAuthority(input) {
-    const context = terminalSubmissionRetryStartupAuthorityContext(input);
-    if (!terminalSubmissionRetryStartupIdentityMatches(input, context) ||
-        !terminalSubmissionRetryStartupSubmissionMatches(input, context) ||
-        !terminalSubmissionRetryStartupLedgerMatches(input, context) ||
-        !terminalSubmissionRetryStartupDeferredMatches(input, context)) {
-        throw new Error("submission retry startup recovery authority disagrees across Turn and ledger");
-    }
-    return {
-        requestText: context.requestText,
-        requestHash: context.requestHash,
-        messageType: context.messageType,
-        deferredTransferId: context.deferredTransferId,
-        ...terminalSubmissionRetryStartupProjectionFields(input)
-    };
-}
-function finalizeTerminalSubmissionRetryStartupAccepted(input) {
-    const stateAccepted = input.submission.status === "agent_accepted";
-    const ledgerAccepted = input.ledger.status === "agent_accepted";
-    if (!stateAccepted && !ledgerAccepted) {
-        throw new Error("accepted submission retry sidecar lacks native acceptance evidence");
-    }
-    const stateEvidence = stateAccepted
-        ? terminalAcceptanceEvidenceForConversation(input.conversation, input.authority.requestText, input.submission.acceptance_evidence)
-        : undefined;
-    const ledgerEvidence = ledgerAccepted
-        ? terminalAcceptanceEvidenceForConversation(input.conversation, input.authority.requestText, input.ledger.acceptance_evidence)
-        : undefined;
-    if (stateEvidence && ledgerEvidence &&
-        canonicalJson(stateEvidence) !== canonicalJson(ledgerEvidence)) {
-        throw new Error("accepted submission retry evidence conflicts across Turn and ledger");
-    }
-    const evidence = stateEvidence ?? ledgerEvidence;
-    const stateAcceptedAt = stateAccepted
-        ? nonBlankString(input.submission.agent_accepted_at)
-        : undefined;
-    const ledgerAcceptedAt = ledgerAccepted
-        ? nonBlankString(input.ledger.agent_accepted_at)
-        : undefined;
-    if (!evidence || !stateAcceptedAt && !ledgerAcceptedAt ||
-        stateAcceptedAt && ledgerAcceptedAt && stateAcceptedAt !== ledgerAcceptedAt) {
-        throw new Error("accepted submission retry timestamp conflicts across Turn and ledger");
-    }
-    const acceptedAt = (stateAcceptedAt ?? ledgerAcceptedAt);
-    if (input.authority.deferredTransferId) {
-        const transfer = loadDeferredForegroundTransfer(input.storeDir, input.authority.deferredTransferId);
-        if (transfer.status !== "resolved") {
-            if (isFinalDeferredForegroundTransferStatus(transfer.status)) {
-                throw new Error("accepted submission retry conflicts with an aborted deferred transfer");
-            }
-            return input.conversation;
-        }
-        if (transfer.agent_accepted_at !== acceptedAt ||
-            transfer.message_id !== input.attempt.active_message_id) {
-            throw new Error("accepted submission retry conflicts with its resolved deferred transfer");
-        }
-    }
-    if (input.attempt.state === "agent_accepted" &&
-        input.attempt.agent_accepted_at !== acceptedAt) {
-        throw new Error("accepted submission retry sidecar timestamp conflicts with native evidence");
-    }
-    let conversation = input.conversation;
-    const stateNeedsRepair = !stateAccepted;
-    if (stateNeedsRepair) {
-        const acceptedOwner = {
-            ...conversation,
-            status: "waiting_for_agent",
-            updated_at: acceptedAt
-        };
-        delete acceptedOwner.stalled_at;
-        delete acceptedOwner.stalled_reason;
-        delete acceptedOwner.failed_at;
-        delete acceptedOwner.failure_reason;
-        delete acceptedOwner.idle_since;
-        conversation = applyTerminalBridgeSubmission({
-            conversation: acceptedOwner,
-            messageId: input.attempt.active_message_id,
-            messageType: input.authority.messageType,
-            requestText: input.authority.requestText,
-            status: "agent_accepted",
-            preparedAt: nonBlankString(input.submission.prepared_at),
-            textInjectedAt: nonBlankString(input.submission.text_injected_at) ??
-                nonBlankString(input.ledger.text_injected_at),
-            enterDispatchedAt: nonBlankString(input.submission.enter_dispatched_at) ??
-                nonBlankString(input.ledger.enter_dispatched_at),
-            agentAcceptedAt: acceptedAt,
-            acceptanceEvidence: evidence,
-            lastProvenStage: "agent_accepted"
-        }, {
-            dispatcherPid: cliPid(),
-            storeDir: input.storeDir,
-            terminalControl: input.control
-        });
-        saveState(input.paths.statePath, conversation);
-    }
-    let attempt = input.attempt;
-    const attemptNeedsRepair = attempt.state !== "agent_accepted";
-    if (attemptNeedsRepair) {
-        attempt = saveTerminalSubmissionRetry(input.paths.statePath, {
-            ...attempt,
-            state: "agent_accepted",
-            agent_accepted_at: acceptedAt,
-            updated_at: acceptedAt
-        }, attempt.revision);
-    }
-    const ledgerNeedsRepair = !ledgerAccepted ||
-        input.ledger.submission_retry_state !== "agent_accepted" ||
-        input.ledger.submission_retry_revision !== attempt.revision;
-    if (ledgerNeedsRepair) {
-        input.saveLedger({
-            ...input.ledger,
-            ...terminalSubmissionRetryLedgerFields(attempt),
-            status: "agent_accepted",
-            agent_accepted_at: acceptedAt,
-            acceptance_evidence: evidence,
-            not_accepted_at: undefined,
-            uncertain_at: undefined,
-            safe_to_retry: undefined,
-            dispatcher_pid: null
-        });
-    }
-    if (stateNeedsRepair || attemptNeedsRepair || ledgerNeedsRepair) {
-        appendEvent(input.paths.logPath, {
-            ts: acceptedAt,
-            conversation_id: conversation.conversation_id,
-            event: "terminal_submission_retry_startup_accepted_reconciled",
-            message_id: input.attempt.active_message_id,
-            terminal_input_sent: false
-        });
-    }
-    return loadState(input.paths.statePath);
-}
-function reconcileTerminalSubmissionRetryStartupTerminalLedger(input) {
-    const notAccepted = input.startup.outcome === "not_accepted";
-    input.saveLedger({
-        ...input.ledger,
-        ...terminalSubmissionRetryLedgerFields(input.attempt),
-        status: input.startup.outcome,
-        ...(notAccepted
-            ? {
-                not_accepted_at: input.startup.at,
-                uncertain_at: undefined,
-                error: undefined,
-                safe_to_retry: undefined
-            }
-            : {
-                not_accepted_at: undefined,
-                uncertain_at: input.startup.at,
-                error: input.startup.reason,
-                safe_to_retry: false
-            }),
-        acceptance_evidence: undefined,
-        agent_accepted_at: undefined,
-        dispatcher_pid: null
-    });
-    appendEvent(input.paths.logPath, {
-        ts: input.startup.at,
-        conversation_id: input.conversation.conversation_id,
-        event: `terminal_submission_retry_startup_${input.startup.outcome}_reconciled`,
-        message_id: input.attempt.active_message_id,
-        terminal_input_sent: false,
-        do_not_retry: true
-    });
-}
-function reconcileTerminalSubmissionRetryStartupTerminalState(input) {
-    const stalled = {
-        ...input.conversation,
-        status: "stalled",
-        stalled_at: input.startup.at,
-        stalled_reason: input.startup.reason ??
-            "submission retry native acceptance became uncertain",
-        updated_at: input.startup.at
-    };
-    const conversation = applyTerminalBridgeSubmission({
-        conversation: stalled,
-        messageId: input.attempt.active_message_id,
-        messageType: input.authority.messageType,
-        requestText: input.authority.requestText,
-        status: "uncertain",
-        preparedAt: nonBlankString(input.submission.prepared_at),
-        textInjectedAt: nonBlankString(input.submission.text_injected_at),
-        enterDispatchedAt: nonBlankString(input.submission.enter_dispatched_at),
-        uncertainAt: input.startup.at,
-        error: input.startup.reason,
-        safeToRetry: false,
-        lastProvenStage: "enter_dispatched"
-    }, {
-        dispatcherPid: cliPid(),
-        storeDir: input.storeDir,
-        terminalControl: input.control
-    });
-    saveState(input.paths.statePath, conversation);
-    appendEvent(input.paths.logPath, {
-        ts: input.startup.at,
-        conversation_id: conversation.conversation_id,
-        event: "terminal_submission_retry_startup_uncertain_reconciled",
-        message_id: input.attempt.active_message_id,
-        terminal_input_sent: false,
-        do_not_retry: true
-    });
-    return conversation;
-}
-function mirrorDeferredSubmissionRetryEnter(input) {
-    const transfer = loadDeferredForegroundTransfer(input.storeDir, input.transferId);
-    assertDeferredSubmissionRetryMirrorAuthority(transfer, input);
-    if (isFinalDeferredForegroundTransferStatus(transfer.status)) {
-        return false;
-    }
-    if (transfer.submission_retry_enter_dispatched_at) {
-        if (!isDeferredForegroundSubmissionRetryPending(transfer)) {
-            throw new Error("deferred submission retry startup authority is not exactly pending");
-        }
-        return false;
-    }
-    if (transfer.status !== "uncertain" ||
-        transfer.input_stage !== "text_injected" ||
-        transfer.enter_dispatched_at !== undefined) {
-        throw new Error("deferred submission retry startup recovery found an unsafe stage lag");
-    }
-    const repaired = saveDeferredForegroundTransfer(input.storeDir, {
-        ...transfer,
-        input_stage: "enter_dispatched",
-        enter_dispatched_at: input.attempt.enter_dispatched_at,
-        submission_retry_enter_dispatched_at: input.attempt.enter_dispatched_at
-    }, {
-        expectedRevision: Number(transfer.revision)
-    });
-    if (!isDeferredForegroundSubmissionRetryPending(repaired)) {
-        throw new Error("deferred submission retry startup recovery did not produce exact pending authority");
-    }
-    return true;
-}
-function assertDeferredSubmissionRetryMirrorAuthority(transfer, input) {
-    const exactMode = input.attempt.mode === "exact_draft_enter";
-    if (transfer.transfer_id !== input.transferId ||
-        transfer.turn_id !== input.turnId ||
-        transfer.target_session_id !== input.sessionId ||
-        !sameCanonicalStatePath(transfer.state_path, input.statePath) ||
-        transfer.request_hash !== input.requestHash ||
-        transfer.message_id !== input.messageId ||
-        transfer.prepared_at !== input.preparedAt ||
-        transfer.submission_retry_attempt_id !== input.attempt.attempt_id ||
-        transfer.submission_retry_mode !== input.attempt.mode ||
-        transfer.submission_retry_message_id !== input.messageId ||
-        transfer.submission_retry_prepared_at !== input.preparedAt ||
-        transfer.submission_retry_enter_reserved_at !==
-            input.attempt.enter_reserved_at ||
-        transfer.submission_retry_enter_dispatched_at !== undefined &&
-            transfer.submission_retry_enter_dispatched_at !==
-                input.attempt.enter_dispatched_at ||
-        transfer.submission_retry_enter_dispatched_at !== undefined &&
-            (transfer.input_stage !== "enter_dispatched" ||
-                transfer.enter_dispatched_at !== input.attempt.enter_dispatched_at) ||
-        (exactMode
-            ? transfer.submission_retry_text_reserved_at !== undefined ||
-                transfer.submission_retry_text_injected_at !== undefined ||
-                transfer.text_injected_at !== input.textInjectedAt
-            : transfer.submission_retry_text_reserved_at !==
-                input.attempt.replacement_text_reserved_at ||
-                transfer.submission_retry_text_injected_at !==
-                    input.attempt.replacement_text_injected_at)) {
-        throw new Error("deferred submission retry startup authority disagrees with its attempt");
-    }
-}
-function terminalSubmissionRetryMonitorEpoch(conversation, at) {
-    const takeover = takeoverFor(conversation);
-    const inactivityMinutes = Number(takeover.terminal_bridge_inactivity_timeout_minutes);
-    const hardMinutes = Number(takeover.terminal_bridge_hard_timeout_minutes);
-    const inactivityDeadlineAt = terminalMonitorDeadlineAt(at, inactivityMinutes);
-    const hardDeadlineAt = terminalMonitorDeadlineAt(at, hardMinutes);
-    if (!inactivityDeadlineAt || !hardDeadlineAt) {
-        throw new Error("submission retry startup recovery lacks its configured monitor timeouts");
-    }
-    const next = {
-        ...conversation,
-        status: "waiting_for_agent",
-        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_deadline_at: inactivityDeadlineAt,
-            terminal_bridge_hard_deadline_at: hardDeadlineAt
-        },
-        updated_at: at
-    };
-    delete next.stalled_at;
-    delete next.stalled_reason;
-    delete next.failed_at;
-    delete next.failure_reason;
-    delete next.idle_since;
-    return next;
-}
-function terminalSubmissionRetryStateIsPending(input) {
-    return input.conversation.status === "waiting_for_agent" &&
-        input.submission.status === "enter_dispatched" &&
-        nonBlankString(input.submission.message_id) === input.projection.messageId &&
-        nonBlankString(input.submission.prepared_at) ===
-            input.projection.preparedAt &&
-        nonBlankString(input.submission.text_injected_at) ===
-            input.projection.textInjectedAt &&
-        nonBlankString(input.submission.enter_dispatched_at) ===
-            input.projection.enterDispatchedAt;
-}
-function takeoverFor(conversation) {
-    return isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : {};
-}
 function unprepared(reason) {
     return { prepared: false, alreadyRunning: false, reason };
 }
@@ -2272,9 +755,6 @@ function approvalCanBeCleared(conversation, takeover, input) {
         validTerminalMonitorTimestampMs(takeover.terminal_bridge_approval_resolved_at) !== undefined &&
         validTerminalMonitorTimestampMs(takeover.terminal_bridge_last_approval_prompt_cleared_at) === undefined;
 }
-function validTerminalInteractionSurfaceId(value) {
-    return typeof value === "string" && /^tis_[0-9a-f]{40}$/u.test(value);
-}
 function detectorDiagnostic(input, existing, now) {
     if (input.limitation && input.fingerprint) {
         return {
@@ -2293,98 +773,6 @@ function sameDetectorDiagnostic(existing, next) {
     return nonBlankString(existing?.status) === nonBlankString(next.status) &&
         nonBlankString(existing?.fingerprint) === nonBlankString(next.fingerprint);
 }
-function terminalBridgeApprovalInstructions(input) {
-    const approval = isRecord(input.terminalStatus.approval_state)
-        ? input.terminalStatus.approval_state
-        : {};
-    const screen = isRecord(input.terminalStatus.screen)
-        ? input.terminalStatus.screen
-        : {};
-    const executor = executorForConversation(input.conversation);
-    const agentName = executorDefinitionForKind(executor.kind).displayName;
-    const label = nonBlankString(approval.label) ??
-        `the current ${agentName} approval prompt`;
-    const keys = Array.isArray(approval.keys)
-        ? approval.keys.filter((value) => typeof value === "string")
-        : [];
-    const decisionMode = nonBlankString(approval.decision_mode);
-    const keyDescription = keys.length > 0
-        ? keys.join(" then ")
-        : nonBlankString(approval.key) ?? "the detected approve key sequence";
-    const promptKind = nonBlankString(approval.prompt_kind);
-    const command = nonBlankString(approval.command);
-    const toolName = nonBlankString(approval.tool_name);
-    const requestDetail = nonBlankString(approval.request_detail);
-    const requestId = nonBlankString(approval.request_id);
-    const decisions = Array.isArray(approval.choices)
-        ? approval.choices.flatMap((choice) => isRecord(choice) &&
-            (choice.decision === "approve_once" || choice.decision === "reject")
-            ? [choice.decision]
-            : [])
-        : ["approve_once"];
-    const excerpt = nonBlankString(screen.excerpt) ??
-        "(No terminal excerpt was available.)";
-    const directReview = executor.kind === "claude" && decisionMode === "keys";
-    return approvalInstructionLines({
-        ...input,
-        approval,
-        agentName,
-        label,
-        keyDescription,
-        promptKind,
-        command,
-        toolName,
-        requestDetail,
-        requestId,
-        decisions,
-        excerpt,
-        directReview
-    }).filter((line) => line !== undefined).join("\n");
-}
-function approvalInstructionLines(input) {
-    const turnId = turnIdForConversation(input.conversation);
-    return [
-        `${input.agentName} is waiting for approval in a terminal-controlled AKK session.`,
-        "",
-        `Turn: ${turnId}`,
-        `Terminal: ${input.terminalControl.kind}:${input.terminalControl.target}`,
-        `Approval option: ${input.label} (${input.keyDescription})`,
-        input.promptKind ? `Request kind: ${input.promptKind}` : undefined,
-        input.toolName ? `Tool: ${input.toolName}` : undefined,
-        input.requestDetail ? `Request: ${input.requestDetail}` : undefined,
-        input.command ? `Command: ${input.command}` : undefined,
-        input.requestId ? `Request id: ${input.requestId}` : undefined,
-        "",
-        "Safe terminal excerpt:",
-        "```text",
-        input.excerpt,
-        "```",
-        "",
-        input.directReview
-            ? `Before asking for approval, have the user personally inspect the live ${input.terminalControl.kind} pane ${input.terminalControl.target}.`
-            : undefined,
-        input.directReview
-            ? "This hookless callback intentionally omits raw command details; do not approve from the summary alone."
-            : undefined,
-        input.directReview ? "" : undefined,
-        `Ask the user whether to approve or deny this ${input.agentName} request.`,
-        "",
-        "If the user approves, call `agent_knock_knock_approve` with only:",
-        `- turn_id: ${turnId}`,
-        "- decision: approve_once",
-        "",
-        input.decisions.includes("reject")
-            ? "If the user rejects this permission but wants the Turn to continue, call `agent_knock_knock_approve` with only:"
-            : "This exact prompt has no adapter-proven reject transport; denial requires manual terminal resolution.",
-        input.decisions.includes("reject") ? `- turn_id: ${turnId}` : undefined,
-        input.decisions.includes("reject") ? "- decision: reject" : undefined,
-        input.decisions.includes("reject") ? "" : undefined,
-        "If the user wants to stop the managed Turn, call `agent_knock_knock_cancel` with:",
-        `- turn_id: ${turnId}`,
-        "",
-        "Do not use raw tmux, shell, or manual key presses for this approval. Do not approve without explicit user confirmation."
-    ];
-}
 function stalledMessage(conversation, reason, executor, terminalBridge) {
     return createMessage({
         conversation,