@scotthuang/agent-knock-knock 0.13.2 → 0.13.4

package/dist/src/terminal-agent-bridge.js

@@ -1,351 +1,18 @@
 import { createHash } from "node:crypto";
 import { formatTerminalConversationId, parseTerminalConversationId, terminalControlCapabilitiesForAdapter, terminalApprovalActionForDecision, terminalApprovalChoices } from "./terminal-agent-adapter.js";
 import { enrichActiveProcessesWithTerminalControl, TerminalControlInputNotSentError } from "./terminal-control-provider.js";
-import { hasCanonicalTerminalEndpoint, sameTerminalControlIncarnation, terminalControlEvidenceMatches, terminalEndpointFromControlRef, terminalEndpointIdentityFromEvidence, terminalEndpointIdentityKey } from "./terminal-control-ref.js";
-import { CLAUDE_INJECTED_PASTE_FRAME_PROFILE, claudeInjectedPasteProofEligible, revalidateClaudeComposerProof, settleClaudeInjectedPasteComposer } from "./claude-injected-paste-proof.js";
-import { TERMINAL_INTERACTION_SCHEMA, TERMINAL_INTERACTION_VERSION, validateAnyTerminalInteractionResponse, validateTerminalInteractionProjection } from "./terminal-interaction-protocol.js";
-import { captureTerminalInteraction } from "./terminal-interaction-core.js";
-// Verified Codex profiles through 0.154.0 keep Enter in paste/newline mode for
-// 120ms after burst input. Cross that boundary rather than landing on it, and
-// also require observable composer stability instead of treating this delay
-// alone as acceptance.
-const CODEX_PASTE_ENTER_SETTLE_MS = 121;
-const CODEX_MULTILINE_SETTLE_POLL_MS = 30;
-// A capture can itself take longer than the old two-second deadline on a busy
-// tmux server. Give repaint discovery a bounded five-second window and, once
-// an exact frame has been observed, always allow the required stable/final
-// captures to complete instead of letting the first I/O consume their budget.
-const CODEX_MULTILINE_SETTLE_TIMEOUT_MS = 5_000;
-const CODEX_MULTILINE_STABLE_CAPTURES = 2;
-const CODEX_EXACT_CANDIDATE_GRACE_CAPTURES = 8;
-const CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES = 240;
-const CODEX_COMPOSER_MARKER = /^[›»](?:\s|$)/u;
-const CODEX_COMPOSER_FOOTER = /^(?:gpt-[\w.-]+(?:\s|$)|[-\w.]+ default ·)/u;
-const CODEX_COMPLETE_COMPOSER_FOOTER = /^(?:gpt-[\w.-]+(?:\s+\S+)?|[-\w.]+ default)\s+·\s+\S.*$/u;
-// Keep every exact slash-completion shape closed per behavior profile so a
-// version adding another matching command cannot silently become an authorized
-// native command surface.
-const CODEX_NATIVE_STATUS_POPUP_BY_PROFILE = {
-    "codex-tui-0.146.0": [
-        "  /status  show current session configuration and token usage"
-    ],
-    "codex-tui-0.146.1": [
-        "  /status  show current session configuration and token usage"
-    ],
-    "codex-tui-0.147.0": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.148.0": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.149.1": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.150.1": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.151.0": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.153.0": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.153.4": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-0.154.0": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ],
-    "codex-tui-generic-v1": [
-        "  /status      show current session configuration and token usage",
-        "  /statusline  configure which items appear in the status line"
-    ]
-};
-// Codex's verified `/status` profiles are exercised against its canonical
-// 80-column status surface. Narrower layouts can truncate the 36-character
-// Session UUID after a dynamically sized label column. Exact provider geometry
-// is required before input; ANSI visible-buffer width is only a conservative
-// fallback diagnostic and never upgrades unknown geometry to safe.
-const CODEX_NATIVE_STATUS_MIN_VIEWPORT_BY_PROFILE = {
-    "codex-tui-0.146.0": 80,
-    "codex-tui-0.146.1": 80,
-    "codex-tui-0.147.0": 80,
-    "codex-tui-0.148.0": 80,
-    "codex-tui-0.149.1": 80,
-    "codex-tui-0.150.1": 80,
-    "codex-tui-0.151.0": 80,
-    "codex-tui-0.153.0": 80,
-    "codex-tui-0.153.4": 80,
-    "codex-tui-0.154.0": 80,
-    "codex-tui-generic-v1": 80
-};
-const CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE = {
-    "claude-code-2.1.218-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.226-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.237-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.251-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.259-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.263-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.266-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-2.1.267-native-status": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ],
-    "claude-code-unverified-native-status-v1": [
-        "/status Show Claude Code status including version, model, account, API connectivity, and tool statuses",
-        "/statusline Set up Claude Code's status line UI",
-        "/ide Manage IDE integrations and show status",
-        "/usage Show session cost, plan usage, and activity stats"
-    ]
-};
-const CLAUDE_NATIVE_STATUS_SETTLE_BY_PROFILE = {
-    "claude-code-2.1.218-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 2_000
-    },
-    "claude-code-2.1.226-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.237-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.251-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.259-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.263-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.266-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-2.1.267-native-status": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    },
-    "claude-code-unverified-native-status-v1": {
-        minimumStableMs: 80,
-        maximumSettleMs: 5_000
-    }
-};
-const CODEX_LARGE_PASTE_CHAR_THRESHOLD = 1_000;
-const TERMINAL_INTERACTION_TTL_MS = 10 * 60 * 1_000;
-const TERMINAL_INTERACTION_IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const TERMINAL_INTERACTION_FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/u;
-/** A terminal send failed at a boundary that proves input never started. */
-export class TerminalInputNotStartedError extends Error {
-    code = "AKK_TERMINAL_INPUT_NOT_STARTED";
-    constructor(message, options = {}) {
-        super(message, options);
-        this.name = "TerminalInputNotStartedError";
-    }
-}
-/**
- * Text is already in the terminal composer, but this bridge invocation proved
- * that it never called the Enter transport boundary.
- *
- * Callers may persist this as narrow recovery evidence. It says nothing about
- * whether the draft remains exact or whether a later human action submitted
- * it; those facts must be re-observed under the terminal lock.
- */
-export class TerminalEnterDispatchNotAttemptedError extends Error {
-    code = "AKK_TERMINAL_ENTER_DISPATCH_NOT_ATTEMPTED";
-    stage = "enter_not_attempted";
-    constructor(message, options = {}) {
-        super(message, options);
-        this.name = "TerminalEnterDispatchNotAttemptedError";
-    }
-}
-/**
- * The caller's one-shot Enter reservation was invoked, so this recovery
- * attempt is permanently consumed even though C-m was not proven dispatched.
- */
-export class TerminalEnterDispatchReservedError extends Error {
-    code = "AKK_TERMINAL_ENTER_DISPATCH_RESERVED";
-    stage = "enter_reserved";
-    doNotRetry = true;
-    constructor(message, options = {}) {
-        super(message, options);
-        this.name = "TerminalEnterDispatchReservedError";
-    }
-}
-/**
- * A fail-closed native-inspection submission result.
- *
- * Only `not_started` proves that a caller may safely retry. Once text has
- * reached the composer, or Enter has been attempted, automated retries could
- * duplicate input or execute a different command after terminal drift.
- */
-export class NativeInspectionSubmissionError extends Error {
-    stage;
-    code = "AKK_NATIVE_INSPECTION_SUBMISSION_FAILED";
-    doNotRetry;
-    constructor(stage, message, options = {}) {
-        super(message, options);
-        this.stage = stage;
-        this.name = "NativeInspectionSubmissionError";
-        this.doNotRetry = stage !== "not_started";
-        this.diagnostic = options.diagnostic;
-    }
-    diagnostic;
-}
-class NativeInspectionDiagnosticError extends Error {
-    diagnostic;
-    constructor(diagnostic, message, options = {}) {
-        super(message, options);
-        this.diagnostic = diagnostic;
-        this.name = "NativeInspectionDiagnosticError";
-    }
-}
-/** A verified modal could not be dismissed across one exact key attempt. */
-export class NativeInspectionDismissalError extends Error {
-    code = "AKK_NATIVE_INSPECTION_DISMISSAL_FAILED";
-    doNotRetry = true;
-    constructor(message, options = {}) {
-        super(message, options);
-        this.name = "NativeInspectionDismissalError";
-    }
-}
-/**
- * A response reservation or terminal input may already have happened. The
- * same interaction must never be dispatched automatically after this error.
- */
-export class TerminalInteractionDispatchReservedError extends Error {
-    stage;
-    code = "AKK_TERMINAL_INTERACTION_DISPATCH_RESERVED";
-    doNotRetry = true;
-    constructor(stage, message, options = {}) {
-        super(message, options);
-        this.stage = stage;
-        this.name = "TerminalInteractionDispatchReservedError";
-    }
-}
-/**
- * A durable response reservation exists, but the bridge proved that no
- * terminal text or key delivery was attempted. The caller must discard the
- * one-shot offer and obtain a fresh status projection before trying again.
- */
-export class TerminalInteractionInputNotStartedError extends Error {
-    code = "AKK_TERMINAL_INTERACTION_INPUT_NOT_STARTED";
-    stage = "input_not_started";
-    doNotRetry = true;
-    requiresFreshOffer = true;
-    constructor(message, options = {}) {
-        super(message, options);
-        this.name = "TerminalInteractionInputNotStartedError";
-    }
-}
-function terminalSendComposerRequirements(agent, multiline, options) {
-    const exactEmptyRetryAuthority = options.requireExactEmptyComposerAfterBeforeText;
-    const requireExactEmptyComposerBeforeText = options.requireExactEmptyComposerBeforeText === true;
-    const userExplicitEnterAfterTextWithoutComposerVeto = options.userExplicitEnterAfterTextWithoutComposerVeto === true;
-    if (userExplicitEnterAfterTextWithoutComposerVeto &&
-        (agent !== "codex" || !requireExactEmptyComposerBeforeText)) {
-        throw new TerminalInputNotStartedError("composer-veto-free Enter requires Codex and an exact-empty pre-text user-explicit boundary");
-    }
-    const requireExactComposer = !userExplicitEnterAfterTextWithoutComposerVeto &&
-        ((agent === "codex" && multiline) ||
-            options.requireExactComposerBeforeEnter === true ||
-            requireExactEmptyComposerBeforeText ||
-            exactEmptyRetryAuthority !== undefined);
-    if (exactEmptyRetryAuthority !== undefined &&
-        (agent !== "codex" ||
-            options.beforeText === undefined ||
-            !/^[0-9a-f]{64}$/u.test(exactEmptyRetryAuthority.preliminaryComposerDigest))) {
-        throw new TerminalInputNotStartedError("exact-empty replacement requires Codex, a reservation hook, and a preliminary composer digest");
-    }
-    return {
-        exactEmptyRetryAuthority,
-        requireExactEmptyComposerBeforeText,
-        requireExactComposer
-    };
-}
-async function recordTerminalSendStage(options, event, preserveUserInput, previousError) {
-    try {
-        await options.onTransportStage?.(event);
-        return previousError;
-    }
-    catch (error) {
-        if (!preserveUserInput)
-            throw error;
-        return previousError ?? error;
-    }
-}
-async function runTerminalSendBeforeEnter(options, context, preserveUserInput, previousError) {
-    try {
-        await options.beforeEnter?.(context);
-        return previousError;
-    }
-    catch (error) {
-        if (!preserveUserInput)
-            throw error;
-        return previousError ?? error;
-    }
-}
-async function waitForUserExplicitCodexEnter(input) {
-    if (!input.enabled)
-        return;
-    await input.sleep(Math.max(0, CODEX_PASTE_ENTER_SETTLE_MS -
-        (input.nowMs() - input.textInjectedAt)));
-}
-function throwPostTextHookFailureAfterUserEnter(enabled, error) {
-    if (!enabled || error === undefined)
-        return;
-    throw new TerminalEnterDispatchReservedError("user-explicit Codex Enter was dispatched but post-text bookkeeping failed; do not retry", { cause: error });
-}
+import { hasCanonicalTerminalEndpoint, sameTerminalControlIncarnation, terminalEndpointFromControlRef, terminalEndpointIdentityKey } from "./terminal-control-ref.js";
+import { terminalInteractionPublicCompatibilityProjection } from "./terminal-interaction-protocol.js";
+import { captureTerminalInteractionRuntimeOffer, exactCurrentModelControlSurface, TerminalInteractionResponseBridge } from "./terminal-interaction-response-bridge.js";
+import { discoverTerminalModelOptions, inspectTerminalModelControlResidual, repairTerminalModelControlResidual, switchTerminalModel, terminalModelControlPlanConforms } from "./terminal-model-control.js";
+import { codexActiveWriterViewerVisible, codexBlockingModalVisible, currentCodexComposerCapture, exactClaudeComposerCapture, exactClaudeInjectedPastePlaceholderCapture, exactClaudeModelControlComposerCapture, exactTerminalComposerCapture, inspectCodexAsyncQuestionInputMode } from "./terminal-composer-classifier.js";
+import { assertTerminalMutationCapabilities, isExactClaudeIdleComposer, stripTerminalEscapeSequences, TerminalNativeInspectionBridge } from "./terminal-native-inspection-bridge.js";
+import { createTerminalModelControlPorts } from "./terminal-model-control-bridge.js";
+import { CODEX_MULTILINE_SETTLE_POLL_MS, CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES, CODEX_PASTE_ENTER_SETTLE_MS, TerminalEnterDispatchNotAttemptedError, TerminalEnterDispatchReservedError, TerminalInputNotStartedError, TerminalTextSubmissionBridge } from "./terminal-text-submission-bridge.js";
+export { TerminalEnterDispatchNotAttemptedError, TerminalEnterDispatchReservedError, TerminalInputNotStartedError } from "./terminal-text-submission-bridge.js";
+export { captureTerminalInteractionRuntimeOffer, TerminalInteractionDispatchReservedError, TerminalInteractionInputNotStartedError } from "./terminal-interaction-response-bridge.js";
+export { inspectCodexAsyncQuestionInputMode } from "./terminal-composer-classifier.js";
+export { exactCodexReadyStyledComposerCapture, isExactClaudeIdleComposer, isExactClaudeNativeInspectionIdleComposer, NativeInspectionDismissalError, NativeInspectionSubmissionError } from "./terminal-native-inspection-bridge.js";
 function terminalApprovalPreflight(input) {
     const { adapter, inspection, decision } = input;
     if (!inspection.approval.approvable) {
@@ -647,274 +314,227 @@ export class TerminalAgentBridge {
             };
         }
     }
-    async send(agent, terminalControl, text, options = {}) {
+    async modelOptions(agent, terminalControl, agentVersion, plan, options = {}) {
         const adapter = this.registry.require(agent);
-        const multiline = /[\r\n]/u.test(text.trimEnd());
-        const { exactEmptyRetryAuthority, requireExactEmptyComposerBeforeText, requireExactComposer } = terminalSendComposerRequirements(adapter.agent, multiline, options);
-        try {
-            assertTerminalMutationCapabilities({
-                provider: this.terminalProvider,
-                terminal: this.terminalProvider.endpoint(terminalControl),
-                semantic: [
-                    "send_keys",
-                    ...(requireExactComposer || exactEmptyRetryAuthority
-                        ? ["screen_status"]
-                        : [])
-                ],
-                transport: [
-                    "stable_resource_resolution",
-                    "text_delivery",
-                    "key_delivery",
-                    ...(requireExactComposer || exactEmptyRetryAuthority
-                        ? ["screen_capture"]
-                        : [])
-                ]
-            });
-        }
-        catch (error) {
-            throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
-        }
-        const normalized = text.trimEnd();
-        if (!normalized) {
-            throw new TerminalInputNotStartedError("terminal message is empty");
-        }
-        let verifiedForText;
-        try {
-            verifiedForText = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
-        }
-        catch (error) {
-            throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
-        }
-        if (!verifiedForText.capabilities.includes("send_keys")) {
-            throw new TerminalInputNotStartedError(`${adapter.displayName} terminal input capability changed before injection`);
-        }
-        let composerVerifiedImmediatelyBeforeText = false;
-        if (exactEmptyRetryAuthority) {
-            try {
-                // Invoking this retry-only hook consumes the durable attempt. The
-                // independently identity-fenced recapture closes the human-edit race
-                // before any physical text delivery.
-                await options.beforeText?.({
-                    agent: adapter.agent,
-                    terminalControl: verifiedForText,
-                    multiline,
-                    text: normalized
-                });
-                const finalEmpty = await this.captureCodexComposerSnapshot(adapter, verifiedForText, normalized, options.runtime);
-                if (finalEmpty.state !== "exact_empty" ||
-                    finalEmpty.digest !==
-                        exactEmptyRetryAuthority.preliminaryComposerDigest ||
-                    !sameTerminalControlIdentity(verifiedForText, finalEmpty.terminalControl)) {
-                    const reason = "reason" in finalEmpty
-                        ? finalEmpty.reason
-                        : `Codex composer is ${finalEmpty.state}`;
-                    throw new Error(`reserved Codex replacement lost its exact-empty composer: ${reason}`);
-                }
-                verifiedForText = finalEmpty.terminalControl;
-            }
-            catch (error) {
-                throw new TerminalEnterDispatchReservedError(error instanceof Error ? error.message : String(error), { cause: error });
-            }
-        }
-        else {
-            try {
-                await options.beforeText?.({
-                    agent: adapter.agent,
-                    terminalControl: verifiedForText,
-                    multiline,
-                    text: normalized
-                });
-            }
-            catch (error) {
-                throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
-            }
-            if (requireExactEmptyComposerBeforeText) {
-                try {
-                    verifiedForText = await this.verifyExactEmptyComposerBeforeText(adapter, verifiedForText, normalized, options.runtime, options.allowWorkingComposerForUserExplicit === true);
-                    composerVerifiedImmediatelyBeforeText = true;
-                }
-                catch (error) {
-                    throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
-                }
-            }
-        }
-        if (!composerVerifiedImmediatelyBeforeText) {
-            try {
-                const reverifiedForText = await this.verifyTerminalIdentity(adapter.agent, verifiedForText, options.runtime);
-                if (!sameTerminalControlIdentity(verifiedForText, reverifiedForText)) {
-                    throw new Error("terminal identity changed after the final pre-text check");
-                }
-                verifiedForText = reverifiedForText;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                if (exactEmptyRetryAuthority) {
-                    throw new TerminalEnterDispatchReservedError(message, {
-                        cause: error
-                    });
-                }
-                throw new TerminalInputNotStartedError(message, { cause: error });
-            }
-        }
-        try {
-            await this.terminalProvider.sendText(this.terminalProvider.endpoint(verifiedForText), normalized);
-        }
-        catch (error) {
-            if (exactEmptyRetryAuthority) {
-                throw new TerminalEnterDispatchReservedError("reserved Codex replacement text delivery outcome is uncertain; do not retry", { cause: error });
-            }
-            if (error instanceof TerminalControlInputNotSentError) {
-                throw new TerminalInputNotStartedError(error.message, {
-                    cause: error
-                });
-            }
-            throw error;
-        }
-        const textInjectedAt = this.nowMs();
-        const preserveUserInput = options.userExplicitEnterAfterTextWithoutComposerVeto === true;
-        const allowClaudeInjectedPastePlaceholder = claudeInjectedPasteProofEligible({
-            agent: adapter.agent,
-            multiline,
-            composerVerifiedImmediatelyBeforeText,
-            terminalControl: verifiedForText
+        assertTerminalModelControlPlan(adapter, terminalControl, agentVersion, plan);
+        assertTerminalMutationCapabilities({
+            provider: this.terminalProvider,
+            terminal: this.terminalProvider.endpoint(terminalControl),
+            semantic: ["send_keys", "screen_status"],
+            transport: [
+                "stable_resource_resolution",
+                "screen_capture",
+                "ansi_capture",
+                "text_delivery",
+                "key_delivery"
+            ]
         });
-        let postTextHookError;
-        let verifiedForEnter;
-        let claudeComposerProof;
-        try {
-            postTextHookError = await recordTerminalSendStage(options, {
-                stage: "text_injected",
-                agent: adapter.agent,
-                terminalControl: verifiedForText,
-                multiline
-            }, preserveUserInput);
-            // Text and Enter are separate transport operations. Autonomous sends
-            // retain their exact Composer proof. A user-explicit managed Codex Send
-            // crosses only the native paste-suppression window, then keeps terminal
-            // identity as its final physical boundary.
-            if (adapter.agent === "codex" && requireExactComposer) {
-                verifiedForEnter = await this.settleCodexMultilineComposer(adapter, terminalControl, normalized, options.runtime, {
-                    allowOpaqueLargePastePlaceholder: exactEmptyRetryAuthority === undefined,
-                    allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true
-                });
-            }
-            else if (allowClaudeInjectedPastePlaceholder) {
-                claudeComposerProof = await settleClaudeInjectedPasteComposer({
-                    terminalControl: verifiedForText,
-                    expectedText: normalized,
-                    runtime: options.runtime,
-                    allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true,
-                    ports: this.claudeInjectedPasteProofPorts(adapter)
-                });
-                verifiedForEnter = claudeComposerProof.terminalControl;
-            }
-            else if (requireExactComposer) {
-                verifiedForEnter = await this.verifyExactComposerBeforeEnter(adapter, terminalControl, normalized, options.runtime, options.allowWorkingComposerForUserExplicit === true);
-            }
-            else {
-                await waitForUserExplicitCodexEnter({
-                    enabled: preserveUserInput,
-                    textInjectedAt,
-                    nowMs: this.nowMs,
-                    sleep: this.sleep
-                });
-                verifiedForEnter = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
-            }
-            postTextHookError = await runTerminalSendBeforeEnter(options, {
-                agent: adapter.agent,
-                terminalControl: verifiedForEnter,
-                multiline,
-                text: normalized
-            }, preserveUserInput, postTextHookError);
-            // `beforeEnter` may await Store and terminal identity fences. The human
-            // can still edit the composer or change the native thread while that
-            // callback is pending, so recapture before attempting Enter.
-            if (requireExactComposer) {
-                if (adapter.agent === "codex") {
-                    verifiedForEnter = await this.settleCodexMultilineComposer(adapter, terminalControl, normalized, options.runtime, {
-                        allowOpaqueLargePastePlaceholder: exactEmptyRetryAuthority === undefined,
-                        allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true
-                    });
-                }
-                else if (allowClaudeInjectedPastePlaceholder && claudeComposerProof) {
-                    verifiedForEnter = await revalidateClaudeComposerProof({
-                        proof: claudeComposerProof,
-                        expectedText: normalized,
-                        runtime: options.runtime,
-                        allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true,
-                        ports: this.claudeInjectedPasteProofPorts(adapter)
-                    });
-                }
-                else {
-                    verifiedForEnter = await this.verifyExactComposerBeforeEnter(adapter, terminalControl, normalized, options.runtime, options.allowWorkingComposerForUserExplicit === true);
-                }
-            }
-            else if (options.beforeEnter) {
-                verifiedForEnter = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
-            }
+        const result = await discoverTerminalModelOptions({
+            agent,
+            agentVersion,
+            plan,
+            terminalControl,
+            ports: this.modelControlPorts(adapter, plan, options),
+            initialResidual: options.initialResidual
+        });
+        return {
+            terminalControl: result.terminalControl,
+            catalog: result.catalog
+        };
+    }
+    async setModel(agent, terminalControl, agentVersion, plan, expectedCatalogFingerprint, request, options = {}) {
+        const adapter = this.registry.require(agent);
+        assertTerminalModelControlPlan(adapter, terminalControl, agentVersion, plan);
+        assertTerminalMutationCapabilities({
+            provider: this.terminalProvider,
+            terminal: this.terminalProvider.endpoint(terminalControl),
+            semantic: ["send_keys", "screen_status"],
+            transport: [
+                "stable_resource_resolution",
+                "screen_capture",
+                "ansi_capture",
+                "text_delivery",
+                "key_delivery"
+            ]
+        });
+        const result = await switchTerminalModel({
+            agent,
+            agentVersion,
+            plan,
+            terminalControl,
+            expectedCatalogFingerprint,
+            request,
+            ports: this.modelControlPorts(adapter, plan, options)
+        });
+        return {
+            ...result,
+            terminalControl: result.terminalControl
+        };
+    }
+    async inspectModelControlResidual(agent, terminalControl, agentVersion, plan, options = {}) {
+        const adapter = this.registry.require(agent);
+        assertTerminalModelControlPlan(adapter, terminalControl, agentVersion, plan);
+        assertTerminalMutationCapabilities({
+            provider: this.terminalProvider,
+            terminal: this.terminalProvider.endpoint(terminalControl),
+            semantic: ["screen_status"],
+            transport: ["stable_resource_resolution", "screen_capture", "ansi_capture"]
+        });
+        return inspectTerminalModelControlResidual({
+            plan,
+            terminalControl,
+            ports: this.modelControlPorts(adapter, plan, options)
+        });
+    }
+    async repairModelControlResidual(agent, terminalControl, agentVersion, plan, expectedResidualFingerprint, options = {}) {
+        const adapter = this.registry.require(agent);
+        assertTerminalModelControlPlan(adapter, terminalControl, agentVersion, plan);
+        assertTerminalMutationCapabilities({
+            provider: this.terminalProvider,
+            terminal: this.terminalProvider.endpoint(terminalControl),
+            semantic: ["send_keys", "screen_status"],
+            transport: [
+                "stable_resource_resolution",
+                "screen_capture",
+                "ansi_capture",
+                "key_delivery"
+            ]
+        });
+        const result = await repairTerminalModelControlResidual({
+            plan,
+            terminalControl,
+            expectedResidualFingerprint,
+            ports: this.modelControlPorts(adapter, plan, options)
+        });
+        return {
+            ...result,
+            terminalControl: result.terminalControl
+        };
+    }
+    modelControlPorts(adapter, plan, options) {
+        if (!options.beforeInput) {
+            throw new Error("terminal model control requires current-snapshot authority before every input");
         }
-        catch (error) {
-            if (exactEmptyRetryAuthority) {
-                if (error instanceof TerminalEnterDispatchReservedError) {
-                    throw error;
-                }
-                throw new TerminalEnterDispatchReservedError(error instanceof Error ? error.message : String(error), { cause: error });
+        return createTerminalModelControlPorts({
+            adapter,
+            plan,
+            runtime: options.runtime,
+            beforeInput: options.beforeInput,
+            loadCodexCatalog: options.loadCodexCatalog,
+            runtimePorts: {
+                verifyTerminalIdentity: (agent, control, runtime) => this.verifyTerminalIdentity(agent, control, runtime),
+                captureStyled: (control) => this.terminalProvider.capture(this.terminalProvider.endpoint(control), { scrollbackLines: 160, preserveEscapes: true }),
+                sendText: (control, text) => this.terminalProvider.sendText(this.terminalProvider.endpoint(control), text),
+                sendKeys: (control, keys) => this.terminalProvider.sendKeys(this.terminalProvider.endpoint(control), keys),
+                sleep: this.sleep
+            },
+            classifiers: {
+                stripEscapes: stripTerminalEscapeSequences,
+                sameIdentity: sameTerminalControlIdentity,
+                currentCodexComposer: currentCodexComposerCapture,
+                inspectCodexAsyncQuestionInputMode,
+                codexActiveWriterViewerVisible,
+                isExactClaudeIdleComposer,
+                exactClaudeModelControlComposer: exactClaudeModelControlComposerCapture,
+                exactTerminalComposer: exactTerminalComposerCapture
             }
-            if (error instanceof TerminalEnterDispatchNotAttemptedError) {
-                throw error;
+        });
+    }
+    textSubmissionBridge() {
+        return new TerminalTextSubmissionBridge({
+            runtime: {
+                preflight: (terminalControl, operation) => {
+                    const terminal = this.terminalProvider.endpoint(terminalControl);
+                    switch (operation) {
+                        case "send":
+                            assertTerminalMutationCapabilities({
+                                provider: this.terminalProvider,
+                                terminal,
+                                semantic: ["send_keys"],
+                                transport: [
+                                    "stable_resource_resolution",
+                                    "text_delivery",
+                                    "key_delivery"
+                                ]
+                            });
+                            return;
+                        case "send_with_composer":
+                            assertTerminalMutationCapabilities({
+                                provider: this.terminalProvider,
+                                terminal,
+                                semantic: ["send_keys", "screen_status"],
+                                transport: [
+                                    "stable_resource_resolution",
+                                    "text_delivery",
+                                    "key_delivery",
+                                    "screen_capture"
+                                ]
+                            });
+                            return;
+                        case "observe_composer":
+                            assertTerminalMutationCapabilities({
+                                provider: this.terminalProvider,
+                                terminal,
+                                semantic: ["screen_status"],
+                                transport: ["stable_resource_resolution", "screen_capture"]
+                            });
+                    }
+                },
+                verifyIdentity: (agent, control, runtime) => this.verifyTerminalIdentity(agent, control, runtime),
+                captureInspection: (adapter, control, options) => this.captureInspection(adapter, control, options),
+                captureStyled: (control) => this.terminalProvider.capture(this.terminalProvider.endpoint(control), {
+                    scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES,
+                    preserveEscapes: true
+                }),
+                deliverText: (control, text) => this.terminalProvider.sendText(this.terminalProvider.endpoint(control), text),
+                dispatchEnter: (control) => this.terminalProvider.sendKeys(this.terminalProvider.endpoint(control), ["C-m"]),
+                nowMs: () => this.nowMs(),
+                sleep: (milliseconds) => this.sleep(milliseconds)
+            },
+            classifiers: {
+                sameIdentity: sameTerminalControlIdentity,
+                stripEscapes: stripTerminalEscapeSequences,
+                codexBlockingModalVisible,
+                inspectCodexAsyncQuestionInputMode,
+                currentCodexComposer: currentCodexComposerCapture,
+                exactTerminalComposer: exactTerminalComposerCapture,
+                exactClaudeComposer: exactClaudeComposerCapture,
+                exactClaudeInjectedPastePlaceholder: exactClaudeInjectedPastePlaceholderCapture
             }
-            throw new TerminalEnterDispatchNotAttemptedError(error instanceof Error ? error.message : String(error), { cause: error });
-        }
-        // Do not include this transport call (or anything after it) in the typed
-        // pre-Enter proof: a thrown key-delivery error may still have emitted C-m.
-        try {
-            await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(verifiedForEnter), ["C-m"]);
-            postTextHookError = await recordTerminalSendStage(options, {
-                stage: "enter_dispatched",
-                agent: adapter.agent,
-                terminalControl: verifiedForEnter,
-                multiline
-            }, preserveUserInput, postTextHookError);
-            throwPostTextHookFailureAfterUserEnter(preserveUserInput, postTextHookError);
-        }
-        catch (error) {
-            if (exactEmptyRetryAuthority) {
-                throw new TerminalEnterDispatchReservedError("reserved Codex Enter dispatch outcome is uncertain; do not retry", { cause: error });
+        });
+    }
+    interactionResponseBridge() {
+        return new TerminalInteractionResponseBridge(this.terminalProvider, {
+            captureInspection: (agent, control, runtime, scrollbackLines) => this.captureInspection(this.registry.require(agent), control, {
+                runtime,
+                scrollbackLines
+            }),
+            verifyIdentity: (agent, control, runtime) => this.verifyTerminalIdentity(agent, control, runtime),
+            now: () => this.now(),
+            sleep: (milliseconds) => this.sleep(milliseconds)
+        });
+    }
+    nativeInspectionBridge() {
+        return new TerminalNativeInspectionBridge({
+            registry: this.registry,
+            terminalProvider: this.terminalProvider,
+            runtime: {
+                captureInspection: (adapter, control, options) => this.captureInspection(adapter, control, options),
+                verifyIdentity: (agent, control, runtime) => this.verifyTerminalIdentity(agent, control, runtime),
+                statusFromInspection: (adapter, control, inspection, options) => statusFromInspection(adapter, control, inspection, options),
+                nowMs: () => this.nowMs(),
+                sleep: (milliseconds) => this.sleep(milliseconds)
             }
-            throw error;
-        }
-        return {
-            stage: "enter_dispatched",
-            agent: adapter.agent,
-            terminalControl: verifiedForEnter,
-            multiline
-        };
+        });
+    }
+    async send(agent, terminalControl, text, options = {}) {
+        const adapter = this.registry.require(agent);
+        return this.textSubmissionBridge().send(adapter, terminalControl, text, options);
     }
     /** Observe only the current, live Codex composer without exposing its text. */
     async observeCodexComposer(terminalControl, expectedText, options = {}) {
         const adapter = this.registry.require("codex");
-        const normalized = expectedText.trimEnd();
-        if (!normalized) {
-            return {
-                state: "unavailable",
-                reason: "expected Codex draft is empty"
-            };
-        }
-        try {
-            assertTerminalMutationCapabilities({
-                provider: this.terminalProvider,
-                terminal: this.terminalProvider.endpoint(terminalControl),
-                semantic: ["screen_status"],
-                transport: ["stable_resource_resolution", "screen_capture"]
-            });
-        }
-        catch (error) {
-            return {
-                state: "unavailable",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        return this.settleCodexComposerObservation(adapter, terminalControl, normalized, options.runtime, { minimumStableMs: CODEX_MULTILINE_SETTLE_POLL_MS });
+        return this.textSubmissionBridge().observeCodexComposer(adapter, terminalControl, expectedText, options.runtime);
     }
     /**
      * Honor one explicit user Send against the current Codex terminal. The
@@ -1102,6 +722,7 @@ export class TerminalAgentBridge {
      */
     async submitExactCodexDraft(terminalControl, expectedText, options) {
         const adapter = this.registry.require("codex");
+        const textSubmission = this.textSubmissionBridge();
         const normalized = expectedText.trimEnd();
         if (!normalized) {
             throw new TerminalEnterDispatchNotAttemptedError("expected Codex draft is empty");
@@ -1118,7 +739,7 @@ export class TerminalAgentBridge {
                     "key_delivery"
                 ]
             });
-            const observation = await this.settleCodexComposerObservation(adapter, terminalControl, normalized, options.runtime, {
+            const observation = await textSubmission.settleCodexComposerObservation(adapter, terminalControl, normalized, options.runtime, {
                 minimumStableMs: CODEX_PASTE_ENTER_SETTLE_MS,
                 requiredState: "exact_draft"
             });
@@ -1146,7 +767,7 @@ export class TerminalAgentBridge {
                 text: normalized,
                 composerDigest: preliminaryObservation.digest
             });
-            const recaptured = await this.captureCodexComposerSnapshot(adapter, preliminaryObservation.terminalControl, normalized, options.runtime);
+            const recaptured = await textSubmission.captureCodexComposerSnapshot(adapter, preliminaryObservation.terminalControl, normalized, options.runtime);
             if (recaptured.state !== "exact_draft" ||
                 recaptured.digest !== preliminaryObservation.digest ||
                 !sameTerminalControlIdentity(preliminaryObservation.terminalControl, recaptured.terminalControl)) {
@@ -1175,66 +796,6 @@ export class TerminalAgentBridge {
             enterCount: 1
         };
     }
-    async verifyExactComposerBeforeEnter(adapter, terminalControl, expectedText, runtime, allowWorkingComposer = false) {
-        const captured = await this.captureInspection(adapter, terminalControl, {
-            runtime,
-            scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-        });
-        const exactComposer = exactTerminalComposerCapture(adapter.agent, captured.screen, expectedText);
-        if (captured.inspection.approval.blocked ||
-            !(["idle", "unknown"].includes(captured.inspection.activity.state) ||
-                (allowWorkingComposer &&
-                    captured.inspection.activity.state === "working")) ||
-            !exactComposer) {
-            throw new Error(`${adapter.displayName} composer was not exact and idle immediately before Enter`);
-        }
-        const verifiedImmediatelyBeforeEnter = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, runtime);
-        if (!sameTerminalControlIdentity(captured.terminalControl, verifiedImmediatelyBeforeEnter)) {
-            throw new Error("terminal control identity changed after the final exact composer capture");
-        }
-        return verifiedImmediatelyBeforeEnter;
-    }
-    claudeInjectedPasteProofPorts(adapter) {
-        return {
-            nowMs: this.nowMs,
-            sleep: this.sleep,
-            capture: (terminalControl, runtime) => this.captureInspection(adapter, terminalControl, {
-                runtime,
-                scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-            }),
-            verifyIdentity: (terminalControl, runtime) => this.verifyTerminalIdentity(adapter.agent, terminalControl, runtime),
-            exactDraft: exactClaudeComposerCapture,
-            exactInjectedPastePlaceholder: exactClaudeInjectedPastePlaceholderCapture
-        };
-    }
-    async verifyExactEmptyComposerBeforeText(adapter, terminalControl, expectedText, runtime, allowWorkingComposer = false) {
-        if (adapter.agent === "codex") {
-            const snapshot = await this.captureCodexComposerSnapshot(adapter, terminalControl, expectedText, runtime);
-            if (snapshot.state !== "exact_empty") {
-                const reason = "reason" in snapshot
-                    ? snapshot.reason
-                    : `Codex composer is ${snapshot.state}`;
-                throw new Error(`Codex composer was not exactly empty immediately before text: ${reason}`);
-            }
-            return snapshot.terminalControl;
-        }
-        const captured = await this.captureInspection(adapter, terminalControl, {
-            runtime,
-            scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-        });
-        if (captured.inspection.approval.blocked ||
-            !(["idle", "unknown"].includes(captured.inspection.activity.state) ||
-                (allowWorkingComposer &&
-                    captured.inspection.activity.state === "working")) ||
-            !exactTerminalComposerCapture(adapter.agent, captured.screen, "")) {
-            throw new Error(`${adapter.displayName} composer was not exactly empty immediately before text`);
-        }
-        const verified = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, runtime);
-        if (!sameTerminalControlIdentity(captured.terminalControl, verified)) {
-            throw new Error("terminal control identity changed after the final empty composer capture");
-        }
-        return verified;
-    }
     /**
      * Submit one closed, adapter-owned native inspection command.
      *
@@ -1243,182 +804,19 @@ export class TerminalAgentBridge {
      * draft untouched instead of issuing the legacy best-effort C-u cleanup.
      */
     async submitNativeInspection(agent, terminalControl, plan, options = {}) {
-        return this.submitClosedNativeInspection(agent, terminalControl, plan, options, { requireCodexReadyComposer: agent === "codex" });
+        return this.nativeInspectionBridge().submitNativeInspection(agent, terminalControl, plan, options);
     }
     /**
      * Submit Codex's closed, version-profiled `/status` probe.
      *
      * Unlike the generic native-inspection entry point, callers provide only
-     * the detected Codex version, never a command or plan. The bridge proves an
-     * exact empty (or fully dim replace-on-type) ANSI composer before injecting
-     * text, then crosses Codex's paste suppression window under the same exact
-     * composer and terminal-identity fences used by native inspection.
+     * the detected Codex version, never a command or plan.
      */
     async submitCodexStatusProbe(terminalControl, agentVersion, options = {}) {
-        const adapter = this.registry.require("codex");
-        let plan;
-        try {
-            const capability = adapter.probeNativeInspection?.(agentVersion);
-            if (capability?.status !== "supported" ||
-                capability.statusInspection !== true) {
-                throw new NativeInspectionDiagnosticError("unsupported_profile", capability?.reason ??
-                    `Codex ${agentVersion} has no closed /status behavior profile`);
-            }
-            const planned = adapter.planNativeInspection?.({ kind: "status" }, capability);
-            if (!planned) {
-                throw new NativeInspectionDiagnosticError("unsupported_profile", `Codex ${agentVersion} did not produce a closed /status plan`);
-            }
-            plan = planned;
-        }
-        catch (error) {
-            throw nativeInspectionSubmissionError("not_started", error, "unsupported_profile");
-        }
-        const result = await this.submitClosedNativeInspection("codex", terminalControl, plan, options, { requireCodexReadyComposer: true });
-        if (!result.preTextScreenDigest) {
-            throw new Error("Codex /status pre-text composer evidence is missing");
-        }
-        return {
-            ...result,
-            agent: "codex",
-            preTextScreenDigest: result.preTextScreenDigest,
-            observationBaselineDigest: bareDigestFromNativeInspectionScreenFingerprint(result.preEnterScreenDigest),
-            observationScrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-        };
-    }
-    async submitClosedNativeInspection(agent, terminalControl, plan, options, safety = {}) {
-        const adapter = this.registry.require(agent);
-        try {
-            assertClosedStatusInspectionPlan(adapter, terminalControl, plan);
-            assertTerminalMutationCapabilities({
-                provider: this.terminalProvider,
-                terminal: this.terminalProvider.endpoint(terminalControl),
-                semantic: ["send_keys", "screen_status"],
-                transport: [
-                    "stable_resource_resolution",
-                    "screen_capture",
-                    "text_delivery",
-                    "key_delivery",
-                    ...(safety.requireCodexReadyComposer
-                        ? ["ansi_capture"]
-                        : [])
-                ]
-            });
-        }
-        catch (error) {
-            throw nativeInspectionSubmissionError("not_started", error, "capability_unavailable");
-        }
-        let verifiedForText;
-        try {
-            verifiedForText = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
-        }
-        catch (error) {
-            throw nativeInspectionSubmissionError("not_started", error, "identity_unverified");
-        }
-        let preTextScreenDigest;
-        if (safety.requireCodexReadyComposer) {
-            try {
-                const ready = await this.captureCodexReadyComposer(adapter, verifiedForText, plan, options.runtime);
-                verifiedForText = ready.terminalControl;
-                preTextScreenDigest = ready.screenDigest;
-            }
-            catch (error) {
-                throw nativeInspectionSubmissionError("not_started", error, "composer_not_ready");
-            }
-        }
-        try {
-            if (!verifiedForText.capabilities.includes("send_keys")) {
-                throw new TerminalControlInputNotSentError(`${adapter.displayName} native inspection input capability changed`);
-            }
-            await this.terminalProvider.sendText(this.terminalProvider.endpoint(verifiedForText), plan.command);
-        }
-        catch (error) {
-            if (error instanceof TerminalControlInputNotSentError) {
-                throw nativeInspectionSubmissionError("not_started", error, "text_delivery_unproven");
-            }
-            // The transport cannot prove whether an untyped failure happened before
-            // or after tmux accepted the literal input. Fail closed as injected.
-            throw nativeInspectionSubmissionError("text_injected", error, "text_delivery_unproven");
-        }
-        let settled;
-        try {
-            settled = await this.settleNativeInspectionComposer(adapter, terminalControl, plan, options.runtime);
-            await options.beforeEnter?.({
-                agent: adapter.agent,
-                terminalControl: settled.terminalControl,
-                plan,
-                preEnterScreenDigest: settled.screenDigest,
-                materialization: settled.materialization
-            });
-            if (safety.requireCodexReadyComposer) {
-                settled = {
-                    ...settled,
-                    terminalControl: await this.assertFinalCodexStatusViewport(settled.terminalControl, plan, options.runtime)
-                };
-            }
-            // Viewport inspection may await provider I/O and the PTY may receive
-            // human input while that proof is in flight. Keep the exact composer
-            // capture as the final substantive asynchronous evidence before the
-            // single Enter attempt.
-            settled = await this.revalidateNativeInspectionComposer(adapter, settled.terminalControl, plan, settled.materialization, options.runtime);
-        }
-        catch (error) {
-            throw nativeInspectionSubmissionError("text_injected", error, "composer_not_exact");
-        }
-        try {
-            // Exactly one Enter attempt. Any error is submission-uncertain and must
-            // never trigger a fallback executable or a blind second Enter.
-            await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(settled.terminalControl), ["C-m"]);
-        }
-        catch (error) {
-            throw nativeInspectionSubmissionError("enter_uncertain", error, "enter_uncertain");
-        }
-        return {
-            stage: "enter_dispatched",
-            agent: adapter.agent,
-            terminalControl: settled.terminalControl,
-            command: plan.command,
-            behaviorProfile: plan.behaviorProfile,
-            preEnterScreenDigest: settled.screenDigest,
-            preEnterEvidenceInventory: settled.evidenceInventory,
-            materialization: settled.materialization,
-            enterCount: 1,
-            ...(preTextScreenDigest ? { preTextScreenDigest } : {})
-        };
+        return this.nativeInspectionBridge().submitCodexStatusProbe(terminalControl, agentVersion, options);
     }
     async observeNativeInspection(agent, terminalControl, request, options = {}) {
-        const adapter = this.registry.require(agent);
-        if (!adapter.observeNativeInspection) {
-            throw new Error(`${adapter.displayName} native inspection observation is not supported`);
-        }
-        const captured = await this.captureInspection(adapter, terminalControl, {
-            runtime: options.runtime,
-            scrollbackLines: options.scrollbackLines
-        });
-        const screenDigest = nativeInspectionScreenFingerprint(captured.screen);
-        const adapterObservation = adapter.observeNativeInspection({
-            operation: request.operation,
-            previousScreenFingerprint: request.previousScreenFingerprint,
-            preEnterEvidenceInventory: request.preEnterEvidenceInventory,
-            expectedNativeThreadId: request.expectedNativeThreadId,
-            expectedAgentVersion: request.expectedAgentVersion,
-            expectedCwd: request.expectedCwd,
-            screen: captured.screen
-        });
-        const observation = adapter.agent === "claude" &&
-            options.runtime?.requireExactClaudeAgentRow === true &&
-            adapterObservation.status === "observed" &&
-            adapterObservation.evidence === "claude_status_panel"
-            ? {
-                ...adapterObservation,
-                evidence: "claude_status_panel+claude_agents_exact_pid"
-            }
-            : adapterObservation;
-        return {
-            terminalControl: captured.terminalControl,
-            status: statusFromInspection(adapter, captured.terminalControl, captured.inspection, { screen: captured.screen, runtime: options.runtime }),
-            screenDigest,
-            observation
-        };
+        return this.nativeInspectionBridge().observeNativeInspection(agent, terminalControl, request, options);
     }
     /**
      * Dismiss one exact adapter-owned modal result after re-observing the same
@@ -1426,507 +824,7 @@ export class TerminalAgentBridge {
      * attempt and no automated retry across an uncertain dismissal boundary.
      */
     async dismissNativeInspection(agent, terminalControl, plan, request, expectedEvidenceFingerprint, options = {}) {
-        const adapter = this.registry.require(agent);
-        try {
-            assertClosedStatusInspectionPlan(adapter, terminalControl, plan);
-            assertClosedNativeInspectionDismissal(plan);
-        }
-        catch (error) {
-            throw new NativeInspectionDismissalError(error instanceof Error ? error.message : String(error), { cause: error });
-        }
-        const observeExactPanel = async (control) => {
-            const captured = await this.captureInspection(adapter, control, {
-                runtime: options.runtime,
-                scrollbackLines: options.scrollbackLines
-            });
-            const observation = adapter.observeNativeInspection?.({
-                operation: request.operation,
-                previousScreenFingerprint: request.previousScreenFingerprint,
-                preEnterEvidenceInventory: request.preEnterEvidenceInventory,
-                expectedNativeThreadId: request.expectedNativeThreadId,
-                expectedAgentVersion: request.expectedAgentVersion,
-                expectedCwd: request.expectedCwd,
-                screen: captured.screen
-            });
-            if (!observation ||
-                observation.status !== "observed" ||
-                observation.result?.kind !== "native_status" ||
-                observation.evidenceFingerprint !== expectedEvidenceFingerprint) {
-                throw new Error(observation?.reason ??
-                    "the exact fresh native status panel changed before dismissal");
-            }
-            const verified = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, options.runtime);
-            if (!sameTerminalControlIdentity(captured.terminalControl, verified)) {
-                throw new Error("terminal control identity changed before native status dismissal");
-            }
-            return verified;
-        };
-        try {
-            let verified = await observeExactPanel(terminalControl);
-            await options.beforeDismiss?.({
-                agent: adapter.agent,
-                terminalControl: verified,
-                plan,
-                evidenceFingerprint: expectedEvidenceFingerprint
-            });
-            verified = await observeExactPanel(verified);
-            try {
-                await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(verified), plan.expectedResult.dismissal.keys);
-            }
-            catch (error) {
-                throw new NativeInspectionDismissalError("native status modal dismissal outcome is uncertain; do not retry automatically", { cause: error });
-            }
-            return {
-                stage: "dismiss_dispatched",
-                agent: adapter.agent,
-                terminalControl: verified,
-                keys: plan.expectedResult.dismissal.keys,
-                dismissCount: 1
-            };
-        }
-        catch (error) {
-            if (error instanceof NativeInspectionDismissalError) {
-                throw error;
-            }
-            throw new NativeInspectionDismissalError(error instanceof Error ? error.message : String(error), { cause: error });
-        }
-    }
-    async captureCodexReadyComposer(adapter, terminalControl, plan, runtime) {
-        if (adapter.agent !== "codex") {
-            throw new NativeInspectionDiagnosticError("unsupported_profile", "the closed Codex /status probe requires the Codex adapter");
-        }
-        const minimumViewport = CODEX_NATIVE_STATUS_MIN_VIEWPORT_BY_PROFILE[plan.behaviorProfile];
-        if (minimumViewport === undefined) {
-            throw new NativeInspectionDiagnosticError("unsupported_profile", `Codex ${plan.behaviorProfile} has no exact /status viewport profile`);
-        }
-        const captureReady = async (control) => {
-            const verified = await this.verifyTerminalIdentity(adapter.agent, control, runtime);
-            const endpoint = this.terminalProvider.endpoint(verified);
-            const viewportInspector = this.terminalProvider.inspectViewport;
-            let exactViewport;
-            let viewportUnavailableReason = "terminal provider has no exact viewport inspector";
-            if (viewportInspector) {
-                let viewport;
-                try {
-                    viewport = await viewportInspector.call(this.terminalProvider, endpoint);
-                }
-                catch (error) {
-                    throw new NativeInspectionDiagnosticError("viewport_unavailable", `Codex /status viewport inspection failed before terminal input: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-                }
-                if (viewport) {
-                    if (!Number.isSafeInteger(viewport.columns) ||
-                        viewport.columns <= 0 ||
-                        !Number.isSafeInteger(viewport.rows) ||
-                        viewport.rows <= 0) {
-                        throw new NativeInspectionDiagnosticError("viewport_unavailable", "Codex /status viewport inspector returned invalid geometry");
-                    }
-                    exactViewport = viewport.columns;
-                }
-                else {
-                    viewportUnavailableReason =
-                        "terminal provider could not prove exact viewport geometry";
-                }
-            }
-            const styledScreen = await this.terminalProvider.capture(endpoint, { scrollbackLines: 40, preserveEscapes: true });
-            const plainScreen = stripTerminalEscapeSequences(styledScreen);
-            const inspection = adapter.inspectScreen({ screen: plainScreen, runtime });
-            assertNativeInspectionComposerSafe(inspection, adapter.displayName);
-            const composer = exactCodexReadyStyledComposerCapture(styledScreen);
-            if (!composer) {
-                throw new NativeInspectionDiagnosticError("composer_not_ready", "Codex composer contains non-placeholder input or is not at the exact idle prompt");
-            }
-            const inferredViewport = inferCodexVisibleViewportColumns(styledScreen);
-            const observedViewport = exactViewport ?? inferredViewport;
-            if ((observedViewport !== undefined && observedViewport < minimumViewport) ||
-                hasTruncatedCodexStatusSessionLine(plainScreen)) {
-                throw new NativeInspectionDiagnosticError("viewport_too_narrow", `Codex /status requires a proven viewport of at least ` +
-                    `${minimumViewport} columns to preserve the complete Session UUID` +
-                    `${observedViewport === undefined
-                        ? ""
-                        : `; observed ${observedViewport}`}; widen or zoom the pane before retrying`);
-            }
-            if (exactViewport === undefined) {
-                throw new NativeInspectionDiagnosticError("viewport_unavailable", `Codex /status requires exact terminal viewport geometry before input; ` +
-                    viewportUnavailableReason +
-                    `${inferredViewport === undefined
-                        ? ""
-                        : ` (ANSI fallback estimated ${inferredViewport} columns)`}`);
-            }
-            const reverified = await this.verifyTerminalIdentity(adapter.agent, verified, runtime);
-            if (!sameTerminalControlIdentity(verified, reverified)) {
-                throw new NativeInspectionDiagnosticError("identity_unverified", "terminal control identity changed after the Codex pre-text composer capture");
-            }
-            return {
-                terminalControl: reverified,
-                screenDigest: nativeInspectionScreenFingerprint(styledScreen),
-                composerDigest: composer.digest
-            };
-        };
-        const first = await captureReady(terminalControl);
-        const second = await captureReady(first.terminalControl);
-        if (second.composerDigest !== first.composerDigest) {
-            throw new NativeInspectionDiagnosticError("composer_not_ready", "Codex empty composer changed across its stable pre-text captures");
-        }
-        return {
-            terminalControl: second.terminalControl,
-            screenDigest: second.screenDigest
-        };
-    }
-    async assertFinalCodexStatusViewport(terminalControl, plan, runtime) {
-        const minimumViewport = CODEX_NATIVE_STATUS_MIN_VIEWPORT_BY_PROFILE[plan.behaviorProfile];
-        if (minimumViewport === undefined) {
-            throw new NativeInspectionDiagnosticError("unsupported_profile", `Codex ${plan.behaviorProfile} has no exact /status viewport profile`);
-        }
-        const verified = await this.verifyTerminalIdentity("codex", terminalControl, runtime);
-        const viewportInspector = this.terminalProvider.inspectViewport;
-        if (!viewportInspector) {
-            throw new NativeInspectionDiagnosticError("viewport_unavailable", "Codex /status requires exact terminal viewport geometry immediately before Enter");
-        }
-        let viewport;
-        try {
-            viewport = await viewportInspector.call(this.terminalProvider, this.terminalProvider.endpoint(verified));
-        }
-        catch (error) {
-            throw new NativeInspectionDiagnosticError("viewport_unavailable", `Codex /status viewport inspection failed immediately before Enter: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-        }
-        if (!viewport ||
-            !Number.isSafeInteger(viewport.columns) ||
-            viewport.columns <= 0 ||
-            !Number.isSafeInteger(viewport.rows) ||
-            viewport.rows <= 0) {
-            throw new NativeInspectionDiagnosticError("viewport_unavailable", "Codex /status exact terminal viewport became unavailable immediately before Enter");
-        }
-        if (viewport.columns < minimumViewport) {
-            throw new NativeInspectionDiagnosticError("viewport_too_narrow", `Codex /status viewport narrowed to ${viewport.columns} columns before Enter; ` +
-                `at least ${minimumViewport} are required to preserve the complete Session UUID`);
-        }
-        const reverified = await this.verifyTerminalIdentity("codex", verified, runtime);
-        if (!sameTerminalControlIdentity(verified, reverified)) {
-            throw new NativeInspectionDiagnosticError("identity_unverified", "terminal control identity changed after the final Codex viewport proof");
-        }
-        return reverified;
-    }
-    async settleNativeInspectionComposer(adapter, terminalControl, plan, runtime) {
-        const startedAt = this.nowMs();
-        const settleTimeoutMs = plan.composer.maximumSettleMs;
-        let stableDigest;
-        let stableKind;
-        let stableSince;
-        let stableCaptures = 0;
-        let capturesBeyondDeadline = 0;
-        let lastMismatchDiagnostic = "composer_not_exact";
-        while (true) {
-            const captured = await this.captureInspection(adapter, terminalControl, {
-                runtime,
-                scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-            });
-            assertNativeInspectionComposerSafe(captured.inspection);
-            const materialized = exactNativeInspectionComposerCapture(adapter.agent, captured.screen, plan);
-            const now = this.nowMs();
-            if (materialized) {
-                if (materialized.digest === stableDigest &&
-                    materialized.kind === stableKind) {
-                    stableCaptures += 1;
-                }
-                else {
-                    stableDigest = materialized.digest;
-                    stableKind = materialized.kind;
-                    stableSince = now;
-                    stableCaptures = 1;
-                }
-                const stableForMs = stableSince === undefined ? 0 : now - stableSince;
-                if (stableCaptures >= CODEX_MULTILINE_STABLE_CAPTURES &&
-                    stableForMs >= plan.composer.minimumStableMs) {
-                    const evidence = {
-                        kind: materialized.kind,
-                        digest: materialized.digest,
-                        stableForMs,
-                        stableCaptures
-                    };
-                    return this.revalidateNativeInspectionComposer(adapter, captured.terminalControl, plan, evidence, runtime);
-                }
-            }
-            else {
-                lastMismatchDiagnostic = adapter.agent === "codex"
-                    ? codexNativeInspectionComposerMismatchDiagnostic(captured.screen, plan)
-                    : "composer_not_exact";
-                stableDigest = undefined;
-                stableKind = undefined;
-                stableSince = undefined;
-                stableCaptures = 0;
-            }
-            const elapsed = this.nowMs() - startedAt;
-            const remaining = settleTimeoutMs - elapsed;
-            if (remaining <= 0 && !materialized) {
-                break;
-            }
-            if (remaining <= 0) {
-                capturesBeyondDeadline += 1;
-                if (capturesBeyondDeadline > CODEX_EXACT_CANDIDATE_GRACE_CAPTURES) {
-                    break;
-                }
-            }
-            const remainingStableMs = plan.composer.minimumStableMs -
-                (stableSince === undefined ? 0 : this.nowMs() - stableSince);
-            await this.sleep(Math.min(CODEX_MULTILINE_SETTLE_POLL_MS, remaining > 0
-                ? remaining
-                : Math.max(1, remainingStableMs)));
-        }
-        throw new NativeInspectionDiagnosticError(lastMismatchDiagnostic, lastMismatchDiagnostic === "composer_viewport_truncated"
-            ? `${adapter.displayName} /status slash popup was truncated by the viewport; widen or zoom the pane before retrying manually`
-            : `${adapter.displayName} /status composer did not become exact, idle, and stable before the bounded submit deadline`);
-    }
-    async revalidateNativeInspectionComposer(adapter, terminalControl, plan, expected, runtime) {
-        const captured = await this.captureInspection(adapter, terminalControl, {
-            runtime,
-            scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
-        });
-        assertNativeInspectionComposerSafe(captured.inspection);
-        const materialized = exactNativeInspectionComposerCapture(adapter.agent, captured.screen, plan);
-        if (!materialized ||
-            materialized.digest !== expected.digest ||
-            materialized.kind !== expected.kind) {
-            throw new NativeInspectionDiagnosticError("composer_drift", `${adapter.displayName} /status composer changed after its stable pre-submit capture`);
-        }
-        const baseline = adapter.observeNativeInspection?.({
-            operation: plan.operation,
-            screen: captured.screen
-        });
-        if (!baseline ||
-            baseline.status === "ambiguous" ||
-            !Array.isArray(baseline.evidenceInventory)) {
-            throw new NativeInspectionDiagnosticError("evidence_unproven", baseline?.reason ??
-                `${adapter.displayName} /status pre-Enter evidence inventory was not proven`);
-        }
-        const verifiedImmediatelyBeforeEnter = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, runtime);
-        if (!sameTerminalControlIdentity(captured.terminalControl, verifiedImmediatelyBeforeEnter)) {
-            throw new NativeInspectionDiagnosticError("identity_unverified", `terminal control identity changed after the final ${adapter.displayName} /status composer capture`);
-        }
-        return {
-            terminalControl: verifiedImmediatelyBeforeEnter,
-            screenDigest: nativeInspectionScreenFingerprint(captured.screen),
-            evidenceInventory: baseline.evidenceInventory,
-            materialization: expected
-        };
-    }
-    async settleCodexMultilineComposer(adapter, terminalControl, expectedText, runtime, options = {}) {
-        const observation = await this.settleCodexComposerObservation(adapter, terminalControl, expectedText, runtime, {
-            minimumStableMs: CODEX_PASTE_ENTER_SETTLE_MS,
-            requiredState: "exact_draft",
-            allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
-            allowWorkingComposer: options.allowWorkingComposer === true
-        });
-        if (observation.state === "exact_draft") {
-            return observation.terminalControl;
-        }
-        if (observation.state === "working" ||
-            observation.state === "approval_or_modal") {
-            throw new Error("Codex became busy or blocked while its multiline composer was settling");
-        }
-        if (observation.state === "identity_drift") {
-            throw new Error(observation.reason);
-        }
-        throw new Error("Codex multiline composer did not become exact, idle, and stable before the bounded submit deadline");
-    }
-    async settleCodexComposerObservation(adapter, terminalControl, expectedText, runtime, options) {
-        const startedAt = this.nowMs();
-        let candidate;
-        let stableSince;
-        let stableCaptures = 0;
-        let finishObservedExactCandidate = false;
-        let capturesBeyondDeadline = 0;
-        let control = terminalControl;
-        while (true) {
-            const snapshot = await this.captureCodexComposerSnapshot(adapter, control, expectedText, runtime, {
-                allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
-                classifyOpaqueLargePasteAsDifferent: options.classifyOpaqueLargePasteAsDifferent === true,
-                allowWorkingComposer: options.allowWorkingComposer === true
-            });
-            if (snapshot.state === "identity_drift" ||
-                (snapshot.state === "unavailable" && snapshot.retryable !== true)) {
-                return snapshot;
-            }
-            if (this.nowMs() - startedAt > CODEX_MULTILINE_SETTLE_TIMEOUT_MS) {
-                capturesBeyondDeadline += 1;
-                if (capturesBeyondDeadline > CODEX_EXACT_CANDIDATE_GRACE_CAPTURES) {
-                    return {
-                        state: "unavailable",
-                        reason: "Codex exact composer did not stabilize within its bounded capture grace"
-                    };
-                }
-            }
-            control = snapshot.terminalControl;
-            const sameCandidate = candidate !== undefined &&
-                candidate.state === snapshot.state &&
-                candidate.digest === snapshot.digest &&
-                sameTerminalControlIdentity(candidate.terminalControl, snapshot.terminalControl);
-            if (sameCandidate) {
-                stableCaptures += 1;
-            }
-            else {
-                candidate = snapshot;
-                stableSince = this.nowMs();
-                stableCaptures = 1;
-                finishObservedExactCandidate = snapshot.state === "exact_draft";
-            }
-            const stableForMs = stableSince === undefined
-                ? 0
-                : this.nowMs() - stableSince;
-            if (stableCaptures >= CODEX_MULTILINE_STABLE_CAPTURES &&
-                stableForMs >= options.minimumStableMs &&
-                snapshot.state !== "unavailable" &&
-                (options.requiredState === undefined ||
-                    snapshot.state === options.requiredState ||
-                    snapshot.state === "working" ||
-                    snapshot.state === "approval_or_modal")) {
-                // The caller's authorization hook must see evidence from a final,
-                // independently identity-fenced recapture, not the polling capture.
-                const finalSnapshot = await this.captureCodexComposerSnapshot(adapter, snapshot.terminalControl, expectedText, runtime, {
-                    allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
-                    classifyOpaqueLargePasteAsDifferent: options.classifyOpaqueLargePasteAsDifferent === true,
-                    allowWorkingComposer: options.allowWorkingComposer === true
-                });
-                if (finalSnapshot.state === snapshot.state &&
-                    "digest" in finalSnapshot &&
-                    finalSnapshot.digest === snapshot.digest &&
-                    sameTerminalControlIdentity(snapshot.terminalControl, finalSnapshot.terminalControl)) {
-                    return {
-                        ...finalSnapshot,
-                        stableCaptures: stableCaptures + 1
-                    };
-                }
-                if (finalSnapshot.state === "identity_drift" ||
-                    (finalSnapshot.state === "unavailable" &&
-                        finalSnapshot.retryable !== true)) {
-                    return finalSnapshot;
-                }
-                if (options.requiredState !== undefined &&
-                    snapshot.state === options.requiredState) {
-                    return {
-                        state: "unavailable",
-                        reason: "Codex composer changed after its stable final recapture"
-                    };
-                }
-                candidate = finalSnapshot;
-                control = finalSnapshot.terminalControl;
-                stableSince = this.nowMs();
-                stableCaptures = 1;
-                finishObservedExactCandidate = finalSnapshot.state === "exact_draft";
-            }
-            const elapsed = this.nowMs() - startedAt;
-            if (elapsed > CODEX_MULTILINE_SETTLE_TIMEOUT_MS &&
-                !finishObservedExactCandidate) {
-                return {
-                    state: "unavailable",
-                    reason: options.requiredState
-                        ? `Codex composer did not become ${options.requiredState} before the bounded observation deadline`
-                        : "Codex composer did not become stable before the bounded observation deadline"
-                };
-            }
-            if (elapsed > CODEX_MULTILINE_SETTLE_TIMEOUT_MS &&
-                options.requiredState !== undefined &&
-                snapshot.state !== options.requiredState) {
-                if (snapshot.state !== "unavailable") {
-                    return {
-                        ...snapshot,
-                        stableCaptures
-                    };
-                }
-                return {
-                    state: "unavailable",
-                    reason: snapshot.reason
-                };
-            }
-            const remainingStableMs = options.minimumStableMs - stableForMs;
-            await this.sleep(Math.max(1, Math.min(CODEX_MULTILINE_SETTLE_POLL_MS, remainingStableMs > 0
-                ? remainingStableMs
-                : CODEX_MULTILINE_SETTLE_POLL_MS)));
-        }
-    }
-    async captureCodexComposerSnapshot(adapter, terminalControl, expectedText, runtime, options = {}) {
-        let verifiedBefore;
-        try {
-            verifiedBefore = await this.verifyTerminalIdentity(adapter.agent, terminalControl, runtime);
-        }
-        catch (error) {
-            return {
-                state: "identity_drift",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        let styledScreen;
-        try {
-            styledScreen = await this.terminalProvider.capture(this.terminalProvider.endpoint(verifiedBefore), {
-                scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES,
-                preserveEscapes: true
-            });
-        }
-        catch (error) {
-            return {
-                state: "unavailable",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        const screen = stripTerminalEscapeSequences(styledScreen);
-        let inspection;
-        try {
-            inspection = adapter.inspectScreen({ screen, runtime });
-        }
-        catch (error) {
-            return {
-                state: "unavailable",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        let verifiedAfter;
-        try {
-            verifiedAfter = await this.verifyTerminalIdentity(adapter.agent, verifiedBefore, runtime);
-        }
-        catch (error) {
-            return {
-                state: "identity_drift",
-                reason: error instanceof Error ? error.message : String(error)
-            };
-        }
-        if (!sameTerminalControlIdentity(verifiedBefore, verifiedAfter)) {
-            return {
-                state: "identity_drift",
-                reason: "terminal control identity changed across the Codex composer capture"
-            };
-        }
-        const screenDigest = createHash("sha256").update(styledScreen).digest("hex");
-        if (inspection.approval.blocked ||
-            inspection.activity.state === "awaiting_approval" ||
-            codexBlockingModalVisible(screen)) {
-            return {
-                state: "approval_or_modal",
-                terminalControl: verifiedAfter,
-                digest: screenDigest
-            };
-        }
-        if (inspection.activity.state === "working" &&
-            options.allowWorkingComposer !== true) {
-            return {
-                state: "working",
-                terminalControl: verifiedAfter,
-                digest: screenDigest
-            };
-        }
-        const composer = currentCodexComposerCapture(styledScreen, expectedText, options.allowOpaqueLargePastePlaceholder === true, options.classifyOpaqueLargePasteAsDifferent === true);
-        if (!composer) {
-            return {
-                state: "unavailable",
-                reason: "the current live Codex composer could not be proven",
-                retryable: true,
-                terminalControl: verifiedAfter,
-                digest: screenDigest
-            };
-        }
-        return {
-            state: composer.state,
-            terminalControl: verifiedAfter,
-            digest: composer.digest
-        };
+        return this.nativeInspectionBridge().dismissNativeInspection(agent, terminalControl, plan, request, expectedEvidenceFingerprint, options);
     }
     /**
      * Prove that the exact managed draft is still present after Enter dispatch.
@@ -2276,114 +1174,7 @@ export class TerminalAgentBridge {
         };
     }
     async respondInteraction(agent, terminalControl, response, options) {
-        const runtime = {
-            ...options.runtime,
-            agentVersion: options.agentVersion
-        };
-        const optionReason = terminalInteractionOptionPreflightReason(options, runtime);
-        if (optionReason) {
-            return blockedTerminalInteractionResponse(response, optionReason);
-        }
-        const first = await this.captureTerminalInteractionOffer(agent, terminalControl, runtime, options.scrollbackLines).catch((error) => error);
-        if (first instanceof Error) {
-            return blockedTerminalInteractionResponse(response, first.message);
-        }
-        const firstReason = terminalInteractionOfferPreflightReason(first.offer, options, this.now());
-        if (firstReason || !first.offer) {
-            return blockedTerminalInteractionResponse(response, firstReason ?? "native questionnaire has no safe interaction offer", first.offer);
-        }
-        const validatedResponse = validateAnyTerminalInteractionResponse(response, first.offer.projection, {
-            now: this.now(),
-            // The capture immediately above is the authoritative freshness proof.
-            // A wall-clock bucket boundary must not override exact live terminal
-            // evidence before any input has been sent.
-            allowExpiredForLiveRecapture: true
-        });
-        const planReason = terminalInteractionPlanPreflightReason(validatedResponse, first.offer.actionPlan);
-        if (planReason) {
-            return blockedTerminalInteractionResponse(validatedResponse, planReason, first.offer);
-        }
-        const capabilityReason = terminalInteractionCapabilityReason(this.terminalProvider, first.terminalControl, first.offer.actionPlan);
-        if (capabilityReason) {
-            return blockedTerminalInteractionResponse(validatedResponse, capabilityReason, first.offer);
-        }
-        const authorization = await authorizeTerminalInteraction(options.authorize, interactionHookContext(agent, first.terminalControl, first.offer, validatedResponse, runtime));
-        if (!authorization.approved) {
-            return blockedTerminalInteractionResponse(validatedResponse, authorization.reason ?? "terminal interaction response was not authorized", first.offer);
-        }
-        const afterAuthorization = await this.captureTerminalInteractionOffer(agent, first.terminalControl, runtime, options.scrollbackLines).catch((error) => error);
-        if (afterAuthorization instanceof Error) {
-            return blockedTerminalInteractionResponse(validatedResponse, afterAuthorization.message, first.offer);
-        }
-        const afterAuthorizationReason = terminalInteractionOfferPreflightReason(afterAuthorization.offer, options, this.now());
-        if (afterAuthorizationReason) {
-            return blockedTerminalInteractionResponse(validatedResponse, afterAuthorizationReason, first.offer);
-        }
-        if (!sameTerminalInteractionOffer(first, afterAuthorization, {
-            // expires_at is generated from AKK wall-clock freshness buckets, not
-            // from the native prompt. All semantic projection and action-plan fields
-            // still have to match exactly.
-            ignoreExpiresAt: true
-        })) {
-            return blockedTerminalInteractionResponse(validatedResponse, "native questionnaire changed after authorization", first.offer);
-        }
-        await reserveTerminalInteractionDispatch(options.beforeDispatch, interactionHookContext(agent, afterAuthorization.terminalControl, afterAuthorization.offer, validatedResponse, runtime));
-        const finalCapture = await this.captureTerminalInteractionOffer(agent, afterAuthorization.terminalControl, runtime, options.scrollbackLines).catch((error) => {
-            if (options.beforeDispatch) {
-                throw terminalInteractionInputNotStartedError(error, "cannot recapture native questionnaire after dispatch reservation");
-            }
-            return error;
-        });
-        if (finalCapture instanceof Error) {
-            return blockedTerminalInteractionResponse(validatedResponse, finalCapture.message, first.offer);
-        }
-        if (!sameTerminalInteractionOffer(afterAuthorization, finalCapture, {
-            // The projection expiry is bucketed and may roll over during this final,
-            // bounded recapture even though the questionnaire is exact. Prompt,
-            // action plan, terminal identity, and owner remain exact-match fences.
-            ignoreExpiresAt: true
-        })) {
-            if (options.beforeDispatch) {
-                throw new TerminalInteractionInputNotStartedError("native questionnaire changed after dispatch reservation");
-            }
-            return blockedTerminalInteractionResponse(validatedResponse, "native questionnaire changed before dispatch", first.offer);
-        }
-        const verified = await this.verifyTerminalIdentity(agent, finalCapture.terminalControl, runtime).catch((error) => {
-            if (options.beforeDispatch) {
-                throw terminalInteractionInputNotStartedError(error, "terminal identity could not be verified immediately before interaction dispatch");
-            }
-            throw terminalInteractionReservedError("key_uncertain", error, "terminal identity could not be verified immediately before interaction dispatch");
-        });
-        if (!sameTerminalControlIdentity(finalCapture.terminalControl, verified)) {
-            if (options.beforeDispatch) {
-                throw new TerminalInteractionInputNotStartedError("terminal identity changed after the final questionnaire capture");
-            }
-            throw new TerminalInteractionDispatchReservedError("key_uncertain", "terminal identity changed after the final questionnaire capture");
-        }
-        const answer = validatedResponse.answers[0];
-        const outcome = await dispatchTerminalInteractionAnswer({
-            agent,
-            provider: this.terminalProvider,
-            terminalControl: verified,
-            actionPlan: finalCapture.offer.actionPlan,
-            answer,
-            sleep: this.sleep,
-            reverifyTerminalIdentity: async (currentControl) => {
-                const reverified = await this.verifyTerminalIdentity(agent, currentControl, runtime);
-                if (!sameTerminalControlIdentity(currentControl, reverified)) {
-                    throw new Error("terminal identity changed between interaction text and Enter");
-                }
-                return reverified;
-            }
-        });
-        return {
-            responded: true,
-            blocked: false,
-            interactionId: validatedResponse.interaction_id,
-            questionId: answer.question_id,
-            responseKind: answer.response_kind,
-            outcome
-        };
+        return this.interactionResponseBridge().respond(agent, terminalControl, response, options);
     }
     async monitorPoll(options) {
         const adapter = this.registry.require(options.agent);
@@ -2455,25 +1246,6 @@ export class TerminalAgentBridge {
             })
         };
     }
-    async captureTerminalInteractionOffer(agent, terminalControl, runtime, scrollbackLines) {
-        const adapter = this.registry.require(agent);
-        const captured = await this.captureInspection(adapter, terminalControl, {
-            scrollbackLines,
-            runtime
-        });
-        return {
-            terminalControl: captured.terminalControl,
-            inspection: captured.inspection,
-            offer: captureTerminalInteractionRuntimeOffer({
-                agent,
-                terminalControl: captured.terminalControl,
-                screen: captured.screen,
-                runtime,
-                now: this.now(),
-                approvalBlocked: captured.inspection.approval.blocked
-            })
-        };
-    }
     async verifyTerminalIdentity(agent, terminalControl, runtime) {
         let verifiedControl = terminalControl;
         if (this.verifyIdentity) {
@@ -2500,938 +1272,27 @@ export class TerminalAgentBridge {
         return this.terminalProvider.toControlRef(resolvedEndpoint, verifiedControl.capabilities);
     }
 }
-function assertTerminalMutationCapabilities({ provider, terminal, semantic, transport }) {
-    const missingSemantic = semantic.filter((capability) => !provider.supportedCapabilities.includes(capability) ||
-        !terminal.capabilities.includes(capability));
-    const missingTransport = transport.filter((capability) => !provider.providerCapabilities.includes(capability));
-    if (missingSemantic.length === 0 && missingTransport.length === 0) {
-        return;
-    }
-    const missing = [
-        ...missingSemantic.map((value) => `terminal:${value}`),
-        ...missingTransport.map((value) => `provider:${value}`)
-    ];
-    throw new TerminalControlInputNotSentError(`terminal action capability preflight failed for ` +
-        `${terminal.identity.providerKind}:${terminal.route.label}: ` +
-        missing.join(", "));
-}
-function nativeInspectionSubmissionError(stage, error, fallbackDiagnostic) {
-    const diagnostic = error instanceof NativeInspectionSubmissionError
-        ? error.diagnostic
-        : error instanceof NativeInspectionDiagnosticError
-            ? error.diagnostic
-            : fallbackDiagnostic;
-    if (error instanceof NativeInspectionSubmissionError) {
-        const stageRank = {
-            not_started: 0,
-            text_injected: 1,
-            enter_uncertain: 2
-        };
-        if (stageRank[error.stage] >= stageRank[stage]) {
-            return error;
-        }
-        return new NativeInspectionSubmissionError(stage, error.message, {
-            cause: error,
-            diagnostic
-        });
-    }
-    return new NativeInspectionSubmissionError(stage, error instanceof Error ? error.message : String(error), { cause: error, diagnostic });
-}
-function assertClosedStatusInspectionPlan(adapter, terminalControl, plan) {
-    if (!terminalControl.capabilities.includes("send_keys")) {
-        throw new Error(`${adapter.displayName} terminal input is not supported`);
-    }
-    if (!terminalControl.capabilities.includes("screen_status")) {
-        throw new Error(`${adapter.displayName} terminal screen inspection is not supported`);
-    }
-    const codexProfile = adapter.agent === "codex" &&
-        CODEX_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile] !== undefined;
-    const claudeProfile = adapter.agent === "claude" &&
-        CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile] !== undefined;
-    const expectedSettle = codexProfile
-        ? { minimumStableMs: CODEX_PASTE_ENTER_SETTLE_MS, maximumSettleMs: 2_000 }
-        : CLAUDE_NATIVE_STATUS_SETTLE_BY_PROFILE[plan.behaviorProfile];
-    const exactPresentation = codexProfile
-        ? plan.expectedResult.presentation === "inline" &&
-            plan.expectedResult.dismissal === undefined &&
-            plan.composer.minimumStableMs === expectedSettle?.minimumStableMs &&
-            plan.composer.maximumSettleMs === expectedSettle.maximumSettleMs
-        : claudeProfile
-            ? plan.expectedResult.presentation === "modal" &&
-                plan.composer.minimumStableMs === expectedSettle?.minimumStableMs &&
-                plan.composer.maximumSettleMs === expectedSettle.maximumSettleMs &&
-                plan.expectedResult.dismissal?.expected === "idle_empty_composer" &&
-                JSON.stringify(plan.expectedResult.dismissal.keys) ===
-                    JSON.stringify(["Escape"])
-            : false;
-    if (plan.operation.kind !== "status" ||
-        plan.command !== "/status" ||
-        plan.effect !== "read_only" ||
-        plan.requiresIdle !== true ||
-        plan.composer.kind !== "exact" ||
-        !Number.isFinite(plan.composer.minimumStableMs) ||
-        plan.composer.minimumStableMs < 0 ||
-        !Number.isFinite(plan.composer.maximumSettleMs) ||
-        plan.composer.maximumSettleMs < plan.composer.minimumStableMs ||
-        plan.expectedResult.kind !== "native_status" ||
-        !exactPresentation) {
-        throw new Error("refusing a non-closed native inspection plan");
-    }
-}
-function assertClosedNativeInspectionDismissal(plan) {
-    if (plan.expectedResult.presentation !== "modal" ||
-        plan.expectedResult.dismissal?.expected !== "idle_empty_composer" ||
-        JSON.stringify(plan.expectedResult.dismissal.keys) !==
-            JSON.stringify(["Escape"])) {
-        throw new Error("native inspection has no closed modal dismissal plan");
-    }
-}
-function assertNativeInspectionComposerSafe(inspection, displayName = "terminal agent") {
-    if (inspection.approval.blocked ||
-        inspection.activity.state === "awaiting_approval" ||
-        inspection.activity.state === "working") {
-        throw new NativeInspectionDiagnosticError("composer_not_ready", `${displayName} became busy or blocked while its /status composer was settling`);
-    }
-    // Codex's generic activity parser deliberately reports a non-empty slash
-    // composer as unknown. At this stage the caller has already proved an idle,
-    // empty styled composer under the terminal lock; the exact-current composer
-    // capture below is the stronger continuation proof after AKK injected only
-    // the adapter-owned /status command.
+async function terminalSettleDelay(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-function exactNativeInspectionComposerCapture(agent, screen, plan) {
-    return agent === "codex"
-        ? exactCodexNativeInspectionComposerCapture(screen, plan)
-        : exactClaudeNativeInspectionComposerCapture(screen, plan);
+function sameTerminalControlIdentity(left, right) {
+    return sameTerminalControlIncarnation(left, right);
 }
-function exactCodexNativeInspectionComposerCapture(screen, plan) {
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    let currentComposerIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (CODEX_COMPOSER_MARKER.test(lines[index])) {
-            currentComposerIndex = index;
-            break;
-        }
-    }
-    if (currentComposerIndex < 0) {
+export function terminalApprovalFingerprint(agent, terminalControl, inspection, options = {}) {
+    if (!inspection.approval.approvable) {
         return undefined;
     }
-    const composerText = lines[currentComposerIndex]
-        .replace(/^[›»]\s?/u, "")
-        .trimEnd();
-    if (composerText !== plan.command) {
+    const decision = options.decision ?? "approve_once";
+    const choices = terminalApprovalChoices(inspection.approval);
+    const action = terminalApprovalActionForDecision(inspection.approval, decision);
+    if (!action) {
         return undefined;
     }
-    const footerIndex = lines.findIndex((line, candidateIndex) => candidateIndex > currentComposerIndex &&
-        CODEX_COMPOSER_FOOTER.test(line.trim()));
-    const region = lines.slice(currentComposerIndex, footerIndex < 0 ? lines.length : footerIndex);
-    while (region.length > 1 && region.at(-1)?.trim() === "") {
-        region.pop();
-    }
-    const popupRows = region.slice(1).filter((line) => line.trim().length > 0);
-    let kind;
-    if (popupRows.length === 0) {
-        kind = "exact_slash_composer";
-    }
-    else if (JSON.stringify(popupRows.map((line) => line.trimEnd())) ===
-        JSON.stringify(CODEX_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile])) {
-        kind = "exact_slash_popup";
-    }
-    else {
-        return undefined;
-    }
-    return {
-        kind,
-        digest: createHash("sha256").update(region.join("\n")).digest("hex")
-    };
-}
-function exactClaudeNativeInspectionComposerCapture(screen, plan) {
-    const frame = exactClaudeComposerFrame(screen);
-    if (!frame) {
-        return undefined;
-    }
-    const { lines, openIndex, closeIndex, composerRows, trailing } = frame;
-    if (composerRows.length !== 1 ||
-        !/^\s*❯(?:\s|$)/u.test(composerRows[0]) ||
-        composerRows[0].replace(/^\s*❯\s?/u, "").trimEnd() !== plan.command) {
-        return undefined;
-    }
-    let kind;
-    if (trailing.length === 0 || claudeNativeInspectionTrailingIsFooter(trailing)) {
-        kind = "exact_slash_composer";
-    }
-    else {
-        const suggestions = [];
-        for (const line of trailing) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("/")) {
-                suggestions.push(trimmed.replace(/\s+/gu, " "));
-            }
-            else if (suggestions.length > 0) {
-                suggestions[suggestions.length - 1] +=
-                    ` ${trimmed.replace(/\s+/gu, " ")}`;
-            }
-            else {
-                return undefined;
-            }
-        }
-        if (!closedClaudeNativeStatusSuggestionsMatch(suggestions, CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile])) {
-            return undefined;
-        }
-        kind = "exact_slash_popup";
-    }
-    return {
-        kind,
-        digest: createHash("sha256")
-            .update(lines.slice(openIndex, closeIndex + 1).concat(trailing).join("\n"))
-            .digest("hex")
-    };
-}
-/**
- * Claude truncates a suggestion row with a Unicode ellipsis at narrow pane
- * widths. Keep authorization closed by accepting only an exact ordered row or
- * an explicit ellipsis whose preceding text is an exact, non-trivial prefix of
- * that same profiled row. A caller still cannot introduce, omit, or reorder a
- * slash command.
- */
-function closedClaudeNativeStatusSuggestionsMatch(observed, expected) {
-    if (!expected || observed.length !== expected.length) {
-        return false;
-    }
-    return observed.every((row, index) => {
-        const exact = expected[index];
-        if (row === exact) {
-            return true;
-        }
-        if (!row.endsWith("…")) {
-            return false;
-        }
-        const prefix = row.slice(0, -1);
-        const commandEnd = exact.indexOf(" ");
-        return (commandEnd > 0 &&
-            prefix.length >= commandEnd + 12 &&
-            exact.startsWith(prefix));
-    });
-}
-/**
- * Prove Claude Code's exact current idle input frame. This is shared by every
- * automated-input path: a loose or historical `❯` prompt is not authority to
- * inject text into the terminal.
- */
-export function isExactClaudeIdleComposer(screen) {
-    const frame = exactClaudeComposerFrame(screen);
-    if (!frame) {
-        return false;
-    }
-    return (frame.composerRows.length === 1 &&
-        /^\s*❯\s*$/u.test(frame.composerRows[0]) &&
-        (frame.trailing.length === 0 ||
-            claudeNativeInspectionTrailingIsFooter(frame.trailing)));
-}
-/**
- * Compatibility export retained for callers that adopted the native-status
- * name before the same exact-frame proof was reused by lifecycle handoff.
- */
-export function isExactClaudeNativeInspectionIdleComposer(screen) {
-    return isExactClaudeIdleComposer(screen);
-}
-function exactClaudeComposerFrame(screen) {
-    const lines = screen.replace(/\r\n?/gu, "\n").replace(/\u00a0/gu, " ")
-        .split("\n");
-    const dividerIndexes = lines
-        .map((line, index) => /^\s*[─━]{8,}\s*$/u.test(line) ? index : -1)
-        .filter((index) => index >= 0);
-    if (dividerIndexes.length < 2) {
-        return undefined;
-    }
-    const closeIndex = dividerIndexes.at(-1);
-    const openIndex = dividerIndexes.at(-2);
-    return {
-        lines,
-        openIndex,
-        closeIndex,
-        composerRows: lines.slice(openIndex + 1, closeIndex)
-            .filter((line) => line.trim().length > 0),
-        trailing: lines.slice(closeIndex + 1)
-            .filter((line) => line.trim().length > 0)
-    };
-}
-function claudeNativeInspectionTrailingIsFooter(lines) {
-    return lines.length <= 2 && lines.every((line) => /^\s*(?:[⏵⏴⏸]{1,2}|\?)\s*.*(?:manual mode|shift\+tab|accept edits|bypass permissions|for shortcuts|← for agents)/iu
-        .test(line));
-}
-function nativeInspectionScreenFingerprint(screen) {
-    return `sha256:${createHash("sha256").update(screen).digest("hex")}`;
-}
-function bareDigestFromNativeInspectionScreenFingerprint(fingerprint) {
-    const match = /^sha256:([0-9a-f]{64})$/u.exec(fingerprint);
-    if (!match) {
-        throw new Error("native inspection screen fingerprint is malformed");
-    }
-    return match[1];
-}
-function stripTerminalEscapeSequences(value) {
-    return value.replace(/\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/gu, "");
-}
-export function exactCodexReadyStyledComposerCapture(screen) {
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    while (lines.length > 0 &&
-        stripTerminalEscapeSequences(lines.at(-1) ?? "").trim().length === 0) {
-        lines.pop();
-    }
-    const composerLine = [...lines.slice(-12)].reverse().find((line) => CODEX_COMPOSER_MARKER.test(stripTerminalEscapeSequences(line).trimEnd()));
-    if (composerLine === undefined) {
-        return undefined;
-    }
-    let dim = false;
-    const visible = [];
-    for (let index = 0; index < composerLine.length;) {
-        if (composerLine[index] === "\x1b") {
-            const escape = /^(?:\x1B\[([0-9;]*)m|\x1B\][^\x07]*(?:\x07|\x1B\\))/u
-                .exec(composerLine.slice(index));
-            if (escape) {
-                if (escape[1] !== undefined) {
-                    const codes = escape[1] === ""
-                        ? [0]
-                        : escape[1].split(";").map((value) => Number(value));
-                    for (let codeIndex = 0; codeIndex < codes.length; codeIndex += 1) {
-                        const code = codes[codeIndex];
-                        if ([38, 48, 58].includes(code) &&
-                            codes[codeIndex + 1] === 2) {
-                            codeIndex += 4;
-                            continue;
-                        }
-                        if ([38, 48, 58].includes(code) &&
-                            codes[codeIndex + 1] === 5) {
-                            codeIndex += 2;
-                            continue;
-                        }
-                        if (code === 0 || code === 22) {
-                            dim = false;
-                        }
-                        else if (code === 2) {
-                            dim = true;
-                        }
-                    }
-                }
-                index += escape[0].length;
-                continue;
-            }
-        }
-        const codePoint = composerLine.codePointAt(index);
-        if (codePoint === undefined) {
-            break;
-        }
-        const character = String.fromCodePoint(codePoint);
-        visible.push({ character, dim });
-        index += character.length;
-    }
-    const promptIndex = visible.findIndex(({ character }) => character === "›" || character === "»");
-    if (promptIndex < 0) {
-        return undefined;
-    }
-    const content = visible.slice(promptIndex + 1)
-        .filter(({ character }) => !/^\s$/u.test(character));
-    if (content.length > 0 && !content.every((entry) => entry.dim)) {
-        return undefined;
-    }
-    return {
-        digest: createHash("sha256").update(composerLine).digest("hex")
-    };
-}
-/**
- * Infer a viewport only from fixed-width visible-buffer rows. Trimmed captures
- * deliberately return undefined: a short content row is not proof of a short
- * terminal. This keeps the fallback provider-neutral and fail-closed only on
- * positive geometry evidence.
- */
-function inferCodexVisibleViewportColumns(screen) {
-    const rows = screen.replace(/\r\n?/gu, "\n").split("\n")
-        .map(stripTerminalEscapeSequences);
-    const widthOneRows = rows.filter((row) => /^[\x20-\x7e›»·─━╭╮╰╯│]*$/u.test(row));
-    const maxWidth = widthOneRows.reduce((maximum, row) => Math.max(maximum, Array.from(row).length), 0);
-    if (maxWidth < 20) {
-        return undefined;
-    }
-    const paddedAtMax = widthOneRows.filter((row) => row.endsWith(" ") && Array.from(row).length === maxWidth);
-    const composerAtMax = paddedAtMax.some((row) => CODEX_COMPOSER_MARKER.test(row.trimEnd()));
-    return paddedAtMax.length >= 3 && composerAtMax
-        ? maxWidth
-        : undefined;
-}
-function hasTruncatedCodexStatusSessionLine(screen) {
-    return screen.replace(/\r\n?/gu, "\n").split("\n").some((line) => {
-        const match = /^\s*│\s*Session:\s*([^│\s]+).*│?\s*$/iu.exec(line);
-        if (!match) {
-            return false;
-        }
-        return !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu
-            .test(match[1]);
-    });
-}
-function codexNativeInspectionComposerMismatchDiagnostic(screen, plan) {
-    const expectedRows = CODEX_NATIVE_STATUS_POPUP_BY_PROFILE[plan.behaviorProfile];
-    if (!expectedRows) {
-        return "composer_not_exact";
-    }
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    let composerIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (CODEX_COMPOSER_MARKER.test(lines[index])) {
-            composerIndex = index;
-            break;
-        }
-    }
-    if (composerIndex < 0 ||
-        lines[composerIndex].replace(/^[›»]\s?/u, "").trimEnd() !== plan.command) {
-        return "composer_not_exact";
-    }
-    const footerIndex = lines.findIndex((line, index) => index > composerIndex && CODEX_COMPOSER_FOOTER.test(line.trim()));
-    const popupRows = lines.slice(composerIndex + 1, footerIndex < 0 ? lines.length : footerIndex).filter((line) => line.trim().length > 0);
-    if (popupRows.length === 0) {
-        return "composer_not_exact";
-    }
-    const logicalRows = [];
-    let observedTruncation = false;
-    for (const row of popupRows) {
-        const trimmed = row.trim().replace(/\s+/gu, " ");
-        if (trimmed.startsWith("/")) {
-            logicalRows.push(trimmed);
-        }
-        else if (logicalRows.length > 0) {
-            logicalRows[logicalRows.length - 1] += ` ${trimmed}`;
-            observedTruncation = true;
-        }
-        else {
-            return "composer_not_exact";
-        }
-        observedTruncation ||= trimmed.endsWith("…");
-    }
-    const normalizedExpected = expectedRows.map((row) => row.trim().replace(/\s+/gu, " "));
-    const everyKnownPrefix = logicalRows.length <= normalizedExpected.length &&
-        logicalRows.every((row, index) => {
-            const withoutEllipsis = row.endsWith("…")
-                ? row.slice(0, -1).trimEnd()
-                : row;
-            return normalizedExpected[index]?.startsWith(withoutEllipsis) === true;
-        });
-    return observedTruncation && everyKnownPrefix
-        ? "composer_viewport_truncated"
-        : "composer_not_exact";
-}
-function codexBlockingModalVisible(screen) {
-    const tail = screen.replace(/\r\n?/gu, "\n").split("\n").slice(-80)
-        .join("\n");
-    return /\b(?:press|use)\s+(?:esc|escape)\s+to\s+(?:cancel|close|dismiss)\b/iu
-        .test(tail) ||
-        /\besc\s+to\s+cancel\b/iu.test(tail) ||
-        codexActiveWriterViewerVisible(tail) ||
-        ["expanded", "ambiguous"].includes(inspectCodexAsyncQuestionInputMode(tail));
-}
-function codexActiveWriterViewerVisible(styledScreen) {
-    const lines = stripTerminalEscapeSequences(styledScreen)
-        .replace(/\r\n?/gu, "\n")
-        .split("\n")
-        .slice(-80);
-    let titleIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (/^ {2}🔒(?:\s|$)/u.test(lines[index])) {
-            titleIndex = index;
-            break;
-        }
-    }
-    if (titleIndex < 0) {
-        return false;
-    }
-    const laterMainComposer = lines.findIndex((line, index) => index > titleIndex && CODEX_COMPOSER_MARKER.test(line));
-    if (laterMainComposer >= 0) {
-        return false;
-    }
-    const frame = lines.slice(titleIndex, titleIndex + 12)
-        .map((line) => line.trim().replace(/\s+/gu, " "))
-        .filter((line) => line.length > 0)
-        .join(" ");
-    return /🔒\s+This conversation is open in another app\s+\S+ to Retry/iu
-        .test(frame) &&
-        /Close it there and press\s+\S+\s+to continue here\./iu.test(frame) &&
-        /\S+ retry\s+\S+ exit(?:\s+\S+ transcript)?/iu.test(frame);
-}
-const CODEX_ASYNC_QUESTION_FOOTER_LABEL = /\s(submit|skip|main prompt|prev question|next question|queued messages)(?=\s{2,}|\s*$)/giu;
-function codexStructuredAsyncFooterEvidence(lines, evidenceFloor) {
-    let strongest = { index: -1, labelCount: 0 };
-    for (let start = evidenceFloor + 1; start < lines.length; start += 1) {
-        const labels = new Set();
-        for (let end = start; end < Math.min(lines.length, start + 5); end += 1) {
-            const line = lines[end];
-            if (!/^ {2}(?![ ↳?])\S/u.test(line)) {
-                break;
-            }
-            for (const match of line.matchAll(CODEX_ASYNC_QUESTION_FOOTER_LABEL)) {
-                labels.add(match[1].toLowerCase());
-            }
-            if (labels.size > strongest.labelCount) {
-                strongest = { index: end, labelCount: labels.size };
-            }
-            if (labels.size >= 2) {
-                return strongest;
-            }
-        }
-    }
-    return strongest;
-}
-function codexMainComposerFooterIndex(lines, composerIndex) {
-    for (let index = lines.length - 1; index > composerIndex; index -= 1) {
-        // A real statusline starts at column zero. Draft continuations are inset,
-        // even when their text happens to look exactly like a model statusline.
-        if (CODEX_COMPLETE_COMPOSER_FOOTER.test(lines[index].trimEnd())) {
-            return index;
-        }
-    }
-    return -1;
-}
-/**
- * Classify Codex 0.154's non-blocking inline-question surface by current input
- * ownership. The shared `Queued follow-up inputs` heading is not sufficient:
- * ordinary queued messages use it too. An exact collapsed summary, after any
- * ordinary queue preview is removed, proves Send-safe ownership even when the
- * Composer is outside the viewport. Positive editor evidence without a
- * complete shape remains fail-closed because paste plus Enter would otherwise
- * submit the user's task as an answer.
- */
-export function inspectCodexAsyncQuestionInputMode(styledScreen) {
-    const lines = stripTerminalEscapeSequences(styledScreen)
-        .replace(/\r\n?/gu, "\n")
-        .replace(/\u00a0/gu, " ")
-        .split("\n")
-        .slice(-80);
-    while (lines.length > 0 && lines.at(-1)?.trim().length === 0) {
-        lines.pop();
-    }
-    const normalized = lines.map((line) => line.trim().replace(/\s+/gu, " "));
-    let mainComposerIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        // The main Composer marker is column zero. Async option and inline-text
-        // markers are inset by the menu surface, even after ANSI is removed.
-        if (CODEX_COMPOSER_MARKER.test(lines[index])) {
-            mainComposerIndex = index;
-            break;
-        }
-    }
-    let headerIndex = -1;
-    let wrappedHeaderRows = 1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (/^•\s+Queued follow-up inputs\s*$/u.test(lines[index]) ||
-            /^•\s+Queued follow-up inpu…\s*$/u.test(lines[index]) ||
-            (/^•\s+Queued follow-up\s*$/u.test(lines[index]) &&
-                /^ {2}inputs\s*$/u.test(lines[index + 1] ?? ""))) {
-            headerIndex = index;
-            wrappedHeaderRows = /^•\s+Queued follow-up\s*$/u.test(lines[index])
-                ? 2
-                : 1;
-            break;
-        }
-    }
-    const headerBodyIndex = headerIndex < 0
-        ? -1
-        : headerIndex + wrappedHeaderRows;
-    let questionEvidenceStart = headerBodyIndex;
-    if (headerIndex >= 0) {
-        let cursor = headerBodyIndex;
-        while (cursor < lines.length && lines[cursor].trim().length === 0) {
-            cursor += 1;
-        }
-        let sawQueuedPreview = false;
-        while (cursor < lines.length) {
-            if (/^ {2}↳\s/u.test(lines[cursor])) {
-                sawQueuedPreview = true;
-                cursor += 1;
-                while (cursor < lines.length) {
-                    if (lines[cursor].trim().length === 0 ||
-                        /^ {4,}\S/u.test(lines[cursor])) {
-                        cursor += 1;
-                        continue;
-                    }
-                    break;
-                }
-                continue;
-            }
-            break;
-        }
-        if (sawQueuedPreview) {
-            questionEvidenceStart = cursor;
-        }
-    }
-    const mainComposerFooterIndex = mainComposerIndex < 0
-        ? -1
-        : codexMainComposerFooterIndex(lines, mainComposerIndex);
-    const summaryBeforeMainComposer = headerIndex < 0 || mainComposerIndex < 0
-        ? -1
-        : normalized.findIndex((line, index) => index >= questionEvidenceStart && index < mainComposerIndex &&
-            /^\?\s+\d+\s+questions?(?:\s+·\s+\d+s)?$/iu.test(line));
-    if (mainComposerIndex >= 0 && mainComposerFooterIndex < 0) {
-        // A statusline-disabled Composer is the strongest available ownership
-        // anchor. Treat all following wrapped rows as its arbitrary draft instead
-        // of letting question-like user text veto a human-priority Send.
-        return summaryBeforeMainComposer >= 0 ? "collapsed" : "absent";
-    }
-    const evidenceFloor = Math.max(mainComposerFooterIndex, questionEvidenceStart - 1);
-    const structuredFooter = codexStructuredAsyncFooterEvidence(lines, evidenceFloor);
-    if (structuredFooter.labelCount >= 2) {
-        return "expanded";
-    }
-    const clippedFooterIndex = normalized.findIndex((line, index) => index > evidenceFloor && /^ente(?:r)?…$/iu.test(line) &&
-        /^ctrl…$/iu.test(normalized[index + 1] ?? ""));
-    const clippedChoiceIndex = normalized.findIndex((line, index) => index > evidenceFloor &&
-        line === "Expand terminal to read the entire option");
-    if (clippedFooterIndex >= 0 || clippedChoiceIndex >= 0) {
-        return "ambiguous";
-    }
-    if (headerIndex < 0) {
-        const evidence = new Set();
-        normalized.forEach((line, index) => {
-            if (index <= evidenceFloor) {
-                return;
-            }
-            if (/^\d+\s+of(?:\s+\d+)?$/iu.test(line)) {
-                evidence.add("progress");
-            }
-            if (/^›\s+\S/u.test(line)) {
-                evidence.add("selector");
-            }
-            if (/^Type your answer(?:\s*\(optional\))?$/iu.test(line)) {
-                evidence.add("free_text");
-            }
-        });
-        return evidence.size >= 2 ||
-            (evidence.size >= 1 && structuredFooter.labelCount >= 1)
-            ? "ambiguous"
-            : "absent";
-    }
-    const weakQuestionIndex = normalized.findIndex((line, index) => index > evidenceFloor && index >= questionEvidenceStart && (/^\d+\s+of(?:\s+\d+)?$/iu.test(line) ||
-        /^›\s+\S/u.test(line) ||
-        /^Type your answer(?:\s*\(optional\))?$/iu.test(line)));
-    if (mainComposerIndex > headerIndex && weakQuestionIndex > evidenceFloor) {
-        return "ambiguous";
-    }
-    const summaryIndex = normalized.findIndex((line, index) => index >= questionEvidenceStart &&
-        (mainComposerIndex < 0 || index < mainComposerIndex) &&
-        /^\?\s+\d+\s+questions?(?:\s+·\s+\d+s)?$/iu.test(line));
-    if (summaryIndex >= 0) {
-        return weakQuestionIndex >= 0 ? "ambiguous" : "collapsed";
-    }
-    if (mainComposerIndex > headerIndex) {
-        return "absent";
-    }
-    const afterHeader = normalized.slice(questionEvidenceStart)
-        .filter((line) => line.length > 0);
-    const positiveAfterHeader = afterHeader.some((line) => /^\d+\s+of(?:\s+\d+)?$/iu.test(line) ||
-        /^›\s+\d+\.(?:\s|$)/u.test(line) ||
-        /^Type your answer(?:\s*\(optional\))?$/iu.test(line));
-    if (positiveAfterHeader) {
-        return "ambiguous";
-    }
-    // A bare heading (optionally followed by ↳ queued-message previews) is not
-    // question authority. Preserve human-explicit Send in that ordinary state.
-    if (afterHeader.length === 0) {
-        return "absent";
-    }
-    // An expanded editor can temporarily replace its footer with a flash. If
-    // there is question-like content under the shared heading and no proven main
-    // Composer, do not guess which input surface will receive the next paste.
-    return "ambiguous";
-}
-/**
- * Classify only the bottom live Codex composer region. A matching transcript
- * prompt elsewhere in scrollback is deliberately ignored.
- */
-function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLargePastePlaceholder = false, classifyOpaqueLargePasteAsDifferent = false) {
-    const screen = stripTerminalEscapeSequences(styledScreen);
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    while (lines.length > 0 && lines.at(-1)?.trim().length === 0) {
-        lines.pop();
-    }
-    let composerIndex = -1;
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (CODEX_COMPOSER_MARKER.test(lines[index])) {
-            composerIndex = index;
-            break;
-        }
-    }
-    if (composerIndex < 0) {
-        return undefined;
-    }
-    const footerIndex = lines.findIndex((line, index) => index > composerIndex &&
-        CODEX_COMPLETE_COMPOSER_FOOTER.test(line.trim()));
-    if (footerIndex >= 0 &&
-        lines.slice(footerIndex + 1).some((line) => line.trim().length > 0)) {
-        return undefined;
-    }
-    const regionEnd = footerIndex < 0 ? lines.length : footerIndex;
-    const region = lines.slice(composerIndex, regionEnd);
-    while (region.length > 1 && region.at(-1)?.trim().length === 0) {
-        region.pop();
-    }
-    if (region.length === 0 ||
-        region.slice(1).some((line) => line.length > 0 && !line.startsWith("  "))) {
-        return undefined;
-    }
-    const bodyRows = [
-        region[0].replace(/^[›»]\s?/u, ""),
-        ...region.slice(1).map((line) => line.startsWith("  ") ? line.slice(2) : line)
-    ];
-    const digest = createHash("sha256").update(region.join("\n")).digest("hex");
-    const positivelyEmpty = footerIndex >= 0 &&
-        bodyRows.slice(1).every((row) => row.trim().length === 0) &&
-        exactCodexReadyStyledComposerCapture(styledScreen) !== undefined;
-    if (positivelyEmpty) {
-        return { state: "exact_empty", digest };
-    }
-    if (footerIndex < 0) {
-        return undefined;
-    }
-    const expectedComparable = composerComparableText(expectedText);
-    const expectedCharacterCount = Array.from(expectedText).length;
-    const comparable = composerComparableText(bodyRows.join("\n"));
-    const opaqueLargePastePlaceholder = /^\[Pasted Content \d+ chars\]$/u.test(comparable);
-    if (opaqueLargePastePlaceholder && !allowOpaqueLargePastePlaceholder) {
-        return classifyOpaqueLargePasteAsDifferent
-            ? { state: "different_draft", digest }
-            : undefined;
-    }
-    const exactVisibleDraft = terminalComposerRowsMatchExpected(bodyRows, expectedComparable);
-    const exactLargePastePlaceholder = allowOpaqueLargePastePlaceholder &&
-        expectedCharacterCount > CODEX_LARGE_PASTE_CHAR_THRESHOLD &&
-        comparable === composerComparableText(`[Pasted Content ${expectedCharacterCount} chars]`);
-    if (exactVisibleDraft || exactLargePastePlaceholder) {
-        return { state: "exact_draft", digest };
-    }
-    return comparable.length > 0
-        ? { state: "different_draft", digest }
-        : undefined;
-}
-function exactCodexComposerCapture(screen, expectedText) {
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    const expectedComparable = composerComparableText(expectedText);
-    const expectedCharacterCount = Array.from(expectedText).length;
-    const largePasteComparable = composerComparableText(`[Pasted Content ${expectedCharacterCount} chars]`);
-    const matches = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        if (!CODEX_COMPOSER_MARKER.test(lines[index])) {
-            continue;
-        }
-        const footerIndex = lines.findIndex((line, candidateIndex) => candidateIndex > index && CODEX_COMPOSER_FOOTER.test(line.trim()));
-        const region = lines.slice(index, footerIndex < 0 ? lines.length : footerIndex);
-        while (region.length > 1 && region.at(-1)?.trim() === "") {
-            region.pop();
-        }
-        const bodyRows = [
-            region[0].replace(/^[›»]\s?/u, ""),
-            ...region.slice(1).map((line) => line.startsWith("  ") ? line.slice(2) : line)
-        ];
-        const comparable = composerComparableText(bodyRows.join("\n"));
-        const exactVisibleDraft = terminalComposerRowsMatchExpected(bodyRows, expectedComparable);
-        const exactLargePastePlaceholder = expectedCharacterCount > CODEX_LARGE_PASTE_CHAR_THRESHOLD &&
-            comparable === largePasteComparable;
-        if (!exactVisibleDraft && !exactLargePastePlaceholder) {
-            continue;
-        }
-        matches.push({
-            digest: createHash("sha256")
-                .update(region.join("\n"))
-                .digest("hex")
-        });
-    }
-    if (matches.length > 1) {
-        throw new Error("multiple Codex composer regions matched the multiline terminal request");
-    }
-    return matches[0];
-}
-/**
- * Terminal UIs paint wrapped composer content as independent screen rows, so
- * a provider capture cannot distinguish a visual wrap from an authored
- * newline. Align the rows against the exact text AKK injected instead of
- * joining every row with `\n`.
- *
- * Only row boundaries are ambiguous: they may consume an authored newline, an
- * omitted run of ASCII spaces at a word wrap, or no character at a CJK/token
- * wrap. Every visible character remains character-for-character exact, and an
- * empty row can only advance through an authored newline (plus terminal-trimmed
- * spaces before it), so blank-line structure is preserved.
- */
-function terminalComposerRowsMatchExpected(rows, expectedText) {
-    const expected = composerComparableText(expectedText);
-    if (rows.length === 0) {
-        return expected.length === 0;
-    }
-    if (!expected.startsWith(rows[0])) {
-        return false;
-    }
-    let offsets = new Set([rows[0].length]);
-    for (let index = 1; index < rows.length && offsets.size > 0; index += 1) {
-        const row = rows[index];
-        const previousRow = rows[index - 1];
-        const nextOffsets = new Set();
-        for (const offset of offsets) {
-            const candidateStarts = new Set();
-            if (expected[offset] === "\n") {
-                candidateStarts.add(offset + 1);
-            }
-            let whitespaceEnd = offset;
-            while (expected[whitespaceEnd] === " ") {
-                whitespaceEnd += 1;
-            }
-            if (previousRow.length > 0 && row.length > 0) {
-                candidateStarts.add(offset);
-                if (whitespaceEnd > offset) {
-                    candidateStarts.add(whitespaceEnd);
-                }
-            }
-            if (whitespaceEnd > offset &&
-                expected[whitespaceEnd] === "\n") {
-                candidateStarts.add(whitespaceEnd + 1);
-            }
-            for (const candidateStart of candidateStarts) {
-                if (expected.startsWith(row, candidateStart)) {
-                    nextOffsets.add(candidateStart + row.length);
-                }
-            }
-        }
-        offsets = nextOffsets;
-    }
-    return offsets.has(expected.length);
-}
-function exactTerminalComposerCapture(agent, screen, expectedText) {
-    return agent === "codex"
-        ? exactCodexComposerCapture(screen, expectedText)
-        : exactClaudeComposerCapture(screen, expectedText);
-}
-function exactClaudeComposerCapture(screen, expectedText) {
-    const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
-    const dividerIndexes = lines
-        .map((line, index) => /^\s*[─━]{8,}\s*$/u.test(line) ? index : -1)
-        .filter((index) => index >= 0);
-    if (dividerIndexes.length < 2) {
-        return undefined;
-    }
-    const closeIndex = dividerIndexes.at(-1);
-    const openIndex = dividerIndexes.at(-2);
-    const trailing = lines.slice(closeIndex + 1)
-        .filter((line) => line.trim().length > 0);
-    if (trailing.length > 2 ||
-        trailing.some((line) => !/^\s*(?:[⏵⏴⏸]{1,2}|\?)\s*.*(?:manual mode|shift\+tab|accept edits|bypass permissions|for shortcuts|← for agents)/iu
-            .test(line))) {
-        return undefined;
-    }
-    const region = lines.slice(openIndex + 1, closeIndex);
-    while (region.length > 1 && region.at(-1)?.trim() === "") {
-        region.pop();
-    }
-    if (region.length === 0 || !/^\s*❯(?:\s|$)/u.test(region[0])) {
-        return undefined;
-    }
-    const bodyRows = [
-        region[0].replace(/^\s*❯\s?/u, ""),
-        ...region.slice(1).map((line) => line.startsWith("  ") ? line.slice(2) : line)
-    ];
-    if (!terminalComposerRowsMatchExpected(bodyRows, expectedText)) {
-        return undefined;
-    }
-    return {
-        digest: createHash("sha256")
-            .update(lines.slice(openIndex, closeIndex + 1).join("\n"))
-            .digest("hex")
-    };
-}
-function exactClaudeInjectedPastePlaceholderCapture(screen, expectedText) {
-    const expectedNewlineCount = (composerComparableText(expectedText).match(/\n/gu) ?? []).length;
-    if (expectedNewlineCount === 0) {
-        return undefined;
-    }
-    const frame = exactClaudeComposerFrame(screen);
-    if (!frame ||
-        frame.composerRows.length !== 1 ||
-        !claudeInjectedPastePlaceholderTrailingMatches(frame.trailing)) {
-        return undefined;
-    }
-    const placeholder = /^\s*❯\s*\[Pasted text #([1-9]\d*) \+([1-9]\d*) lines\]\s*$/u
-        .exec(frame.composerRows[0]);
-    if (!placeholder) {
-        return undefined;
-    }
-    const pasteId = Number(placeholder[1]);
-    const newlineCount = Number(placeholder[2]);
-    if (!Number.isSafeInteger(pasteId) ||
-        !Number.isSafeInteger(newlineCount) ||
-        newlineCount !== expectedNewlineCount) {
-        return undefined;
-    }
-    return {
-        state: "exact_injected_paste_placeholder",
-        digest: createHash("sha256")
-            .update(frame.lines
-            .slice(frame.openIndex, frame.closeIndex + 1)
-            .concat(frame.trailing)
-            .join("\n"))
-            .digest("hex"),
-        pasteId,
-        newlineCount,
-        frameProfile: CLAUDE_INJECTED_PASTE_FRAME_PROFILE
-    };
-}
-function claudeInjectedPastePlaceholderTrailingMatches(lines) {
-    if (lines.length === 0) {
-        return false;
-    }
-    const hint = "paste again to expand";
-    const first = lines[0].trimStart();
-    if (!first.startsWith(hint)) {
-        return false;
-    }
-    const sameRowStatus = first.slice(hint.length);
-    if (sameRowStatus.length > 0 && !/^\s{2,}\S/u.test(sameRowStatus)) {
-        return false;
-    }
-    const footerRows = [
-        ...(sameRowStatus.trim().length > 0 ? [sameRowStatus.trim()] : []),
-        ...lines.slice(1).map((line) => line.trim())
-    ];
-    return footerRows.length === 0 ||
-        claudeNativeInspectionTrailingIsFooter(footerRows) ||
-        claudeInjectedPasteAuxiliaryFooterMatches(footerRows);
-}
-function claudeInjectedPasteAuxiliaryFooterMatches(lines) {
-    if (lines.length === 0 || lines.length > 2) {
-        return false;
-    }
-    const autoUpdate = lines.filter((line) => line === "✘ Auto-update failed · Run claude doctor").length;
-    const effort = lines.filter((line) => /^[●○◐◉] (?:low|medium|high|xhigh|max|ultracode) · \/effort$/u
-        .test(line)).length;
-    return autoUpdate <= 1 && effort <= 1 &&
-        autoUpdate + effort === lines.length;
-}
-function composerComparableText(value) {
-    return value.replace(/\r\n?/gu, "\n");
-}
-async function terminalSettleDelay(milliseconds) {
-    await new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-function sameTerminalControlIdentity(left, right) {
-    return sameTerminalControlIncarnation(left, right);
-}
-export function terminalApprovalFingerprint(agent, terminalControl, inspection, options = {}) {
-    if (!inspection.approval.approvable) {
-        return undefined;
-    }
-    const decision = options.decision ?? "approve_once";
-    const choices = terminalApprovalChoices(inspection.approval);
-    const action = terminalApprovalActionForDecision(inspection.approval, decision);
-    if (!action) {
-        return undefined;
-    }
-    const decisionMode = action.mode ?? "keys";
-    const promptEvidence = inspection.approval.promptEvidence;
-    if (decisionMode === "keys" &&
-        !isTerminalApprovalPromptEvidence(promptEvidence)) {
-        return undefined;
+    const decisionMode = action.mode ?? "keys";
+    const promptEvidence = inspection.approval.promptEvidence;
+    if (decisionMode === "keys" &&
+        !isTerminalApprovalPromptEvidence(promptEvidence)) {
+        return undefined;
     }
     const terminal = terminalEndpointFromControlRef(terminalControl);
     // Legacy control records without canonical endpoint evidence bind v2 to
@@ -3527,414 +1388,19 @@ function isTerminalApprovalPromptEvidence(value) {
         typeof evidence.sha256 === "string" &&
         /^[0-9a-f]{64}$/u.test(evidence.sha256);
 }
-function terminalInteractionTurnId(runtime) {
-    // Questionnaire mutation is managed-Turn-only. A raw terminal's
-    // conversationId is a discovery label, not durable response authority.
-    const candidate = runtime?.turnId;
-    return typeof candidate === "string" &&
-        TERMINAL_INTERACTION_IDENTIFIER_PATTERN.test(candidate)
-        ? candidate
-        : undefined;
-}
-function terminalInteractionSubject(runtime) {
-    if (runtime?.interactionSubject) {
-        return runtime.interactionSubject;
-    }
-    const turnId = terminalInteractionTurnId(runtime);
-    const messageId = runtime?.messageId;
-    return turnId && typeof messageId === "string" &&
-        TERMINAL_INTERACTION_IDENTIFIER_PATTERN.test(messageId)
-        ? { kind: "managed_turn", turn_id: turnId, message_id: messageId }
-        : undefined;
-}
-function terminalInteractionExpiry(now) {
-    const nowMs = now.getTime();
-    if (!Number.isFinite(nowMs)) {
-        return undefined;
-    }
-    const windowStart = Math.floor(nowMs / TERMINAL_INTERACTION_TTL_MS) *
-        TERMINAL_INTERACTION_TTL_MS;
-    return new Date(windowStart + TERMINAL_INTERACTION_TTL_MS).toISOString();
-}
-function terminalInteractionCanonicalIdentity(terminalControl) {
-    if (!hasCanonicalTerminalEndpoint(terminalControl)) {
-        return undefined;
-    }
-    const terminal = terminalEndpointFromControlRef(terminalControl);
-    if (!Number.isInteger(terminal.processAnchorPid) ||
-        Number(terminal.processAnchorPid) <= 0) {
-        return undefined;
-    }
-    // Surface identity is shared by independent observers. Keep physical
-    // terminal identity separate from runtime-native identity so an optional
-    // observer-only fence (for example processStartedAt) cannot split one live
-    // questionnaire into different Monitor and Watch surfaces. Dispatch still
-    // revalidates the complete runtime immediately before any terminal input.
-    return {
-        terminal_identity: terminalEndpointIdentityKey(terminal),
-        terminal_process_anchor_pid: terminal.processAnchorPid
-    };
-}
-function terminalInteractionNativeTaskIdentity(runtime) {
-    // Include only native-task fields that both managed Turn and exact Watch
-    // observations can derive from their durable anchors. Optional runtime
-    // verification fields remain on `runtime`; they are identity fences, not
-    // cross-observer surface identity.
-    return {
-        agent_pid: runtime.pid,
-        native_session_id: runtime.nativeSessionId,
-        native_process_uuid: runtime.nativeProcessUuid,
-        native_process_birth: runtime.nativeProcessBirth,
-        native_rollout: runtime.nativeRollout,
-        expected_native_session_id: runtime.expectedNativeSessionId,
-        expected_empty_native_session: runtime.expectedEmptyNativeSession === true
-    };
-}
-function legacyManagedInteractionProjection(projection) {
-    if (projection.subject.kind !== "managed_turn") {
-        throw new TypeError("only managed interaction subjects have a v1 projection");
-    }
-    return validateTerminalInteractionProjection({
-        schema: TERMINAL_INTERACTION_SCHEMA,
-        version: TERMINAL_INTERACTION_VERSION,
-        interaction_id: projection.interaction_id,
-        turn_id: projection.subject.turn_id,
-        agent: projection.agent,
-        kind: projection.kind,
-        state: projection.state,
-        step: projection.step,
-        questions: projection.questions,
-        expires_at: projection.expires_at,
-        capabilities: projection.capabilities
-    });
-}
-export function captureTerminalInteractionRuntimeOffer(input) {
-    const subject = terminalInteractionSubject(input.runtime);
-    const agentVersion = input.runtime?.agentVersion;
-    const expiry = terminalInteractionExpiry(input.now);
-    const canonicalIdentity = input.runtime
-        ? terminalInteractionCanonicalIdentity(input.terminalControl) ??
-            terminalInteractionTrustedWatchIdentity(input.terminalControl, input.runtime, input.trustedTerminalEvidence)
-        : undefined;
-    if (!subject ||
-        typeof agentVersion !== "string" ||
-        agentVersion.length === 0 ||
-        !expiry ||
-        !canonicalIdentity ||
-        input.approvalBlocked === true) {
-        return undefined;
-    }
-    const coreOffer = captureTerminalInteraction({
-        subject,
-        agent: input.agent,
-        agentVersion,
-        canonicalTerminalIdentity: canonicalIdentity,
-        nativeTaskIdentity: terminalInteractionNativeTaskIdentity(input.runtime),
-        screen: input.screen,
-        now: input.now,
-        expiresAt: expiry,
-        responseUncertain: input.runtime?.interactionDispatchState === "reserved" ||
-            input.runtime?.interactionDispatchState === "uncertain",
-        responseAuthority: input.runtime?.interactionResponseAuthority ?? "executable",
-        includeLegacyTurnId: subject.kind === "managed_turn"
-    });
-    if (!coreOffer) {
-        return undefined;
-    }
-    return {
-        projection: subject.kind === "managed_turn"
-            ? legacyManagedInteractionProjection(coreOffer.projection)
-            : coreOffer.projection,
-        promptFingerprint: coreOffer.promptFingerprint,
-        surfaceId: coreOffer.surfaceId,
-        actionPlan: coreOffer.actionPlan,
-        nativeInspection: coreOffer.nativeInspection
-    };
-}
-function terminalInteractionTrustedWatchIdentity(terminalControl, runtime, evidence) {
-    if (runtime.interactionSubject?.kind !== "terminal_watch" ||
-        !evidence ||
-        !terminalControlEvidenceMatches(evidence, terminalControl)) {
-        return undefined;
-    }
-    const identity = terminalEndpointIdentityFromEvidence(evidence);
-    if (!identity || !Number.isSafeInteger(evidence.process_anchor_pid) ||
-        Number(evidence.process_anchor_pid) <= 0) {
-        return undefined;
-    }
-    return {
-        terminal_identity: terminalEndpointIdentityKey(identity),
-        terminal_process_anchor_pid: evidence.process_anchor_pid
-    };
-}
-function terminalInteractionOptionPreflightReason(options, runtime) {
-    if (typeof options.agentVersion !== "string" ||
-        !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/u.test(options.agentVersion)) {
-        return "an exact semantic agent version is required";
-    }
-    if (options.runtime?.agentVersion !== undefined &&
-        options.runtime.agentVersion !== options.agentVersion) {
-        return "runtime agent version does not match the requested interaction profile";
-    }
-    if (!terminalInteractionSubject(runtime)) {
-        return "a protocol-safe exact interaction subject is required";
-    }
-    if (!TERMINAL_INTERACTION_FINGERPRINT_PATTERN.test(options.expectedFingerprint)) {
-        return "a valid interaction prompt fingerprint is required";
-    }
-    if (!Number.isFinite(Date.parse(options.expectedExpiresAt))) {
-        return "a valid interaction expiry is required";
-    }
-    return undefined;
-}
-function terminalInteractionOfferPreflightReason(offer, options, now) {
-    if (!offer) {
-        return "native questionnaire has no identity-fenced interaction offer";
-    }
-    if (offer.projection.state !== "pending" ||
-        !offer.projection.capabilities.respond ||
-        offer.actionPlan.kind === "manual_only") {
-        return `native questionnaire requires manual response: ${offer.nativeInspection.status === "manual_required"
-            ? offer.nativeInspection.reason
-            : "unsupported action plan"}`;
-    }
-    if (offer.promptFingerprint !== options.expectedFingerprint) {
-        return "native questionnaire fingerprint changed before execution";
-    }
-    if (offer.projection.expires_at !== options.expectedExpiresAt &&
-        Date.parse(options.expectedExpiresAt) > now.getTime()) {
-        return "native questionnaire expiry changed before execution";
-    }
-    return undefined;
-}
-function terminalInteractionCapabilityReason(provider, terminalControl, plan) {
-    const requiresText = plan.kind === "free_text";
-    const missing = [
-        !terminalControl.capabilities.includes("screen_status")
-            ? "terminal:screen_status"
-            : undefined,
-        !terminalControl.capabilities.includes("send_keys")
-            ? "terminal:send_keys"
-            : undefined,
-        !provider.providerCapabilities.includes("stable_resource_resolution")
-            ? "provider:stable_resource_resolution"
-            : undefined,
-        !provider.providerCapabilities.includes("screen_capture")
-            ? "provider:screen_capture"
-            : undefined,
-        !provider.providerCapabilities.includes("key_delivery")
-            ? "provider:key_delivery"
-            : undefined,
-        requiresText && !provider.providerCapabilities.includes("text_delivery")
-            ? "provider:text_delivery"
-            : undefined
-    ].filter((value) => value !== undefined);
-    return missing.length > 0
-        ? `terminal interaction capability preflight failed: ${missing.join(", ")}`
+function statusFromInspection(adapter, terminalControl, inspection, options = {}) {
+    const exactModelSurface = options.screen !== undefined &&
+        exactCurrentModelControlSurface(adapter.agent, options.runtime?.agentVersion, options.screen);
+    const modelSurfaceReason = exactModelSurface
+        ? `exact ${adapter.displayName} native model-control surface is open`
         : undefined;
-}
-function terminalInteractionPlanPreflightReason(response, plan) {
-    const answer = response.answers[0];
-    if (plan.kind !== "free_text" || answer?.response_kind !== "free_text") {
-        return undefined;
-    }
-    const textStage = plan.stages[0];
-    if (textStage?.kind !== "answer_text" ||
-        !Number.isSafeInteger(textStage.max_characters) ||
-        textStage.max_characters < 1) {
-        return "native free-text interaction has no verified input limit";
-    }
-    return answer.text.length <= textStage.max_characters
-        ? undefined
-        : `free-text answer exceeds the verified native limit of ${textStage.max_characters} characters`;
-}
-function blockedTerminalInteractionResponse(response, reason, offer) {
-    const answer = Array.isArray(response.answers) ? response.answers[0] : undefined;
-    return {
-        responded: false,
-        blocked: true,
-        reason,
-        interactionId: response.interaction_id,
-        questionId: answer?.question_id ?? offer?.projection.questions[0]?.question_id,
-        responseKind: answer?.response_kind
-    };
-}
-function interactionHookContext(agent, terminalControl, offer, response, runtime) {
-    return {
-        agent,
-        terminalControl,
-        fingerprint: offer.promptFingerprint,
-        projection: offer.projection,
-        response,
-        runtime
-    };
-}
-async function authorizeTerminalInteraction(authorize, context) {
-    return authorize ? authorize(context) : { approved: true };
-}
-async function reserveTerminalInteractionDispatch(beforeDispatch, context) {
-    if (!beforeDispatch) {
-        return;
-    }
-    try {
-        await beforeDispatch(context);
-    }
-    catch (error) {
-        if (error instanceof TerminalInteractionInputNotStartedError) {
-            throw error;
-        }
-        throw terminalInteractionReservedError("reservation_uncertain", error, "terminal interaction dispatch reservation failed");
-    }
-}
-function sameTerminalInteractionOffer(left, right, options = {}) {
-    const leftProjection = options.ignoreExpiresAt && left.offer
-        ? terminalInteractionProjectionWithoutExpiry(left.offer.projection)
-        : left.offer?.projection;
-    const rightProjection = options.ignoreExpiresAt && right.offer
-        ? terminalInteractionProjectionWithoutExpiry(right.offer.projection)
-        : right.offer?.projection;
-    return Boolean(left.offer &&
-        right.offer &&
-        sameTerminalControlIdentity(left.terminalControl, right.terminalControl) &&
-        left.offer.promptFingerprint === right.offer.promptFingerprint &&
-        JSON.stringify(leftProjection) === JSON.stringify(rightProjection) &&
-        JSON.stringify(left.offer.actionPlan) === JSON.stringify(right.offer.actionPlan));
-}
-function terminalInteractionProjectionWithoutExpiry(projection) {
-    const { expires_at: _expiresAt, ...semanticProjection } = projection;
-    return semanticProjection;
-}
-function terminalInteractionInputNotStartedError(error, message) {
-    if (error instanceof TerminalInteractionInputNotStartedError) {
-        return error;
-    }
-    const detail = error instanceof Error ? error.message : String(error);
-    return new TerminalInteractionInputNotStartedError(`${message}: ${detail}`, { cause: error });
-}
-function terminalInteractionReservedError(stage, error, message) {
-    if (error instanceof TerminalInteractionDispatchReservedError) {
-        return error;
-    }
-    const detail = error instanceof Error ? error.message : String(error);
-    return new TerminalInteractionDispatchReservedError(stage, `${message}: ${detail}`, { cause: error });
-}
-function terminalInteractionChoiceAction(agent, plan, answer) {
-    const choice = plan.choices.find((candidate) => candidate.option_id === answer.selected_option_ids[0]);
-    if (!choice) {
-        throw new TerminalInteractionInputNotStartedError("single-select interaction has no closed adapter action");
-    }
-    const keys = choice.stages.flatMap((stage) => stage.kind === "key" ? [stage.key] : []);
-    const directChoice = choice.outcome === "submit_or_advance" &&
-        choice.stages.length === 1 &&
-        keys.length === 1 &&
-        /^[1-5]$/u.test(keys[0]);
-    const directCustomTextChoice = agent === "claude" &&
-        choice.outcome === "open_custom_text" &&
-        choice.stages.length === 1 &&
-        keys.length === 1 &&
-        /^[1-5]$/u.test(keys[0]);
-    const navigatedCustomTextChoice = agent === "codex" &&
-        choice.outcome === "open_custom_text" &&
-        choice.stages.length >= 1 &&
-        choice.stages.length <= 4 &&
-        keys.length === choice.stages.length &&
-        keys.at(-1) === "C-m" &&
-        keys.slice(0, -1).every((key) => key === "Down");
-    if (!directChoice && !directCustomTextChoice && !navigatedCustomTextChoice) {
-        throw new TerminalInteractionInputNotStartedError("single-select interaction has no closed adapter action");
-    }
-    return {
-        keys,
-        outcome: choice.outcome === "open_custom_text"
-            ? "custom_text_opened"
-            : "submitted_or_advanced"
-    };
-}
-function terminalInteractionConfirmKey(plan, answer) {
-    const stages = answer.confirm ? plan.confirm_stages : plan.cancel_stages;
-    const stage = stages[0];
-    if (stages.length !== 1 ||
-        stage?.kind !== "key" ||
-        !["C-m", "Escape", "1", "2"].includes(stage.key) ||
-        JSON.stringify(plan.confirm_stages) === JSON.stringify(plan.cancel_stages)) {
-        throw new TerminalInteractionInputNotStartedError("confirmation interaction has no closed adapter action");
-    }
-    return stage.key;
-}
-async function sendTerminalInteractionKeys(provider, terminalControl, keys) {
-    try {
-        await provider.sendKeys(provider.endpoint(terminalControl), keys);
-    }
-    catch (error) {
-        throw terminalInteractionReservedError("key_uncertain", error, "terminal interaction key dispatch is uncertain");
-    }
-}
-async function dispatchTerminalInteractionFreeText(input) {
-    const [textStage, enterStage] = input.plan.stages;
-    if (input.plan.stages.length !== 2 ||
-        textStage?.kind !== "answer_text" ||
-        textStage.single_line !== true ||
-        textStage.max_characters < input.answer.text.length ||
-        enterStage?.kind !== "key" ||
-        enterStage.key !== "C-m") {
-        throw new TerminalInteractionInputNotStartedError("free-text interaction has no closed adapter action");
-    }
-    try {
-        await input.provider.sendText(input.provider.endpoint(input.terminalControl), input.answer.text);
-    }
-    catch (error) {
-        throw terminalInteractionReservedError("text_uncertain", error, "terminal interaction text dispatch is uncertain");
-    }
-    if (input.agent === "codex") {
-        try {
-            await input.sleep(CODEX_PASTE_ENTER_SETTLE_MS);
-        }
-        catch (error) {
-            throw terminalInteractionReservedError("text_uncertain", error, "terminal interaction paste-settle outcome is uncertain");
-        }
-    }
-    let enterControl;
-    try {
-        enterControl = await input.reverifyTerminalIdentity(input.terminalControl);
-        if (!sameTerminalControlIdentity(input.terminalControl, enterControl)) {
-            throw new Error("terminal identity changed between interaction text and Enter");
+    const approval = exactModelSurface
+        ? {
+            blocked: false,
+            approvable: false,
+            reason: modelSurfaceReason
         }
-    }
-    catch (error) {
-        throw terminalInteractionReservedError("text_uncertain", error, "terminal identity after interaction text dispatch is uncertain");
-    }
-    await sendTerminalInteractionKeys(input.provider, enterControl, [enterStage.key]);
-    return "submitted_or_advanced";
-}
-async function dispatchTerminalInteractionAnswer(input) {
-    if (input.actionPlan.kind === "single_select" &&
-        input.answer.response_kind === "single_select") {
-        const action = terminalInteractionChoiceAction(input.agent, input.actionPlan, input.answer);
-        await sendTerminalInteractionKeys(input.provider, input.terminalControl, action.keys);
-        return action.outcome;
-    }
-    if (input.actionPlan.kind === "confirm" &&
-        input.answer.response_kind === "confirm") {
-        const key = terminalInteractionConfirmKey(input.actionPlan, input.answer);
-        await sendTerminalInteractionKeys(input.provider, input.terminalControl, [key]);
-        return input.answer.confirm ? "confirmed" : "cancelled";
-    }
-    if (input.actionPlan.kind === "free_text" &&
-        input.answer.response_kind === "free_text") {
-        return dispatchTerminalInteractionFreeText({
-            agent: input.agent,
-            provider: input.provider,
-            terminalControl: input.terminalControl,
-            plan: input.actionPlan,
-            answer: input.answer,
-            reverifyTerminalIdentity: input.reverifyTerminalIdentity,
-            sleep: input.sleep
-        });
-    }
-    throw new TerminalInteractionInputNotStartedError("terminal interaction answer does not have a closed adapter action");
-}
-function statusFromInspection(adapter, terminalControl, inspection, options = {}) {
-    const approval = dispatchableApprovalInspection(adapter, inspection.approval);
+        : dispatchableApprovalInspection(adapter, inspection.approval);
     const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, {
         ...inspection,
         approval
@@ -3952,7 +1418,7 @@ function statusFromInspection(adapter, terminalControl, inspection, options = {}
                 }] : [];
         })
         : [];
-    const interaction = options.screen === undefined
+    const interaction = options.screen === undefined || exactModelSurface
         ? undefined
         : captureTerminalInteractionRuntimeOffer({
             agent: adapter.agent,
@@ -3968,10 +1434,10 @@ function statusFromInspection(adapter, terminalControl, inspection, options = {}
         agent: adapter.agent,
         reachable: true,
         capabilities: adapter.capabilities,
-        activity_state: inspection.activity.state,
-        activity_reason: inspection.activity.reason,
-        screen_state: inspection.activity.state,
-        screen_reason: inspection.activity.reason,
+        activity_state: exactModelSurface ? "unknown" : inspection.activity.state,
+        activity_reason: modelSurfaceReason ?? inspection.activity.reason,
+        screen_state: exactModelSurface ? "unknown" : inspection.activity.state,
+        screen_reason: modelSurfaceReason ?? inspection.activity.reason,
         approval_state: {
             scanned: true,
             blocked: approval.blocked,
@@ -4009,7 +1475,7 @@ function statusFromInspection(adapter, terminalControl, inspection, options = {}
             approval: approvalOutput(approval)
         },
         ...(interaction === undefined ? {} : {
-            interaction_state: interaction.projection,
+            interaction_state: terminalInteractionPublicCompatibilityProjection(interaction.projection),
             interaction_prompt_fingerprint: interaction.promptFingerprint,
             interaction_surface_id: interaction.surfaceId
         })
@@ -4116,4 +1582,33 @@ function unsupportedScreenStatus(adapter, terminalControl) {
         capability_limitation: reason
     };
 }
+function assertTerminalModelControlPlan(adapter, terminalControl, agentVersion, plan) {
+    if (!terminalControl.capabilities.includes("send_keys") ||
+        !terminalControl.capabilities.includes("screen_status")) {
+        throw new Error("terminal model control requires exact screen-status and key-delivery capabilities");
+    }
+    const capabilities = adapter.probeModelControl?.(agentVersion);
+    if (capabilities?.status !== "supported" ||
+        capabilities.modelSelection !== true ||
+        capabilities.reasoningEffortSelection !== true ||
+        capabilities.agentVersion !== agentVersion) {
+        throw new Error(capabilities?.reason ??
+            `${adapter.displayName} has no verified model-control profile`);
+    }
+    const expected = adapter.planModelControl?.(capabilities);
+    if (!expected ||
+        expected.command !== "/model" ||
+        expected.requiresIdle !== true ||
+        expected.requiresExactEmptyComposer !== true ||
+        JSON.stringify(expected) !== JSON.stringify(plan)) {
+        throw new Error("the terminal adapter did not produce the exact current model-control plan");
+    }
+    if (!terminalModelControlPlanConforms({
+        agent: adapter.agent,
+        agentVersion,
+        plan
+    })) {
+        throw new Error("refusing an unprofiled terminal model-control plan");
+    }
+}
 //# sourceMappingURL=terminal-agent-bridge.js.map