@scotthuang/agent-knock-knock 0.13.2 → 0.13.4

package/dist/src/terminal-text-submission-bridge.js

@@ -0,0 +1,632 @@
+import { createHash } from "node:crypto";
+import { claudeInjectedPasteProofEligible, revalidateClaudeComposerProof, settleClaudeInjectedPasteComposer } from "./claude-injected-paste-proof.js";
+import { TerminalControlInputNotSentError } from "./terminal-control-provider.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.
+export const CODEX_PASTE_ENTER_SETTLE_MS = 121;
+export 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;
+export const CODEX_MULTILINE_STABLE_CAPTURES = 2;
+export const CODEX_EXACT_CANDIDATE_GRACE_CAPTURES = 8;
+export const CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES = 240;
+/** 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";
+    }
+}
+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 });
+}
+export class TerminalTextSubmissionBridge {
+    runtime;
+    classifiers;
+    constructor(input) {
+        this.runtime = input.runtime;
+        this.classifiers = input.classifiers;
+    }
+    async send(adapter, terminalControl, text, options = {}) {
+        const multiline = /[\r\n]/u.test(text.trimEnd());
+        const { exactEmptyRetryAuthority, requireExactEmptyComposerBeforeText, requireExactComposer } = terminalSendComposerRequirements(adapter.agent, multiline, options);
+        try {
+            this.runtime.preflight(terminalControl, requireExactComposer || exactEmptyRetryAuthority
+                ? "send_with_composer"
+                : "send");
+        }
+        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.runtime.verifyIdentity(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 {
+                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 ||
+                    !this.classifiers.sameIdentity(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.runtime.verifyIdentity(adapter.agent, verifiedForText, options.runtime);
+                if (!this.classifiers.sameIdentity(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.runtime.deliverText(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.runtime.nowMs();
+        const preserveUserInput = options.userExplicitEnterAfterTextWithoutComposerVeto === true;
+        const allowClaudeInjectedPastePlaceholder = claudeInjectedPasteProofEligible({
+            agent: adapter.agent,
+            multiline,
+            composerVerifiedImmediatelyBeforeText,
+            terminalControl: verifiedForText
+        });
+        let postTextHookError;
+        let verifiedForEnter;
+        let claudeComposerProof;
+        try {
+            postTextHookError = await recordTerminalSendStage(options, {
+                stage: "text_injected",
+                agent: adapter.agent,
+                terminalControl: verifiedForText,
+                multiline
+            }, preserveUserInput);
+            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.runtime.nowMs,
+                    sleep: this.runtime.sleep
+                });
+                verifiedForEnter = await this.runtime.verifyIdentity(adapter.agent, terminalControl, options.runtime);
+            }
+            postTextHookError = await runTerminalSendBeforeEnter(options, {
+                agent: adapter.agent,
+                terminalControl: verifiedForEnter,
+                multiline,
+                text: normalized
+            }, preserveUserInput, postTextHookError);
+            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.runtime.verifyIdentity(adapter.agent, terminalControl, options.runtime);
+            }
+        }
+        catch (error) {
+            if (exactEmptyRetryAuthority) {
+                if (error instanceof TerminalEnterDispatchReservedError) {
+                    throw error;
+                }
+                throw new TerminalEnterDispatchReservedError(error instanceof Error ? error.message : String(error), { cause: error });
+            }
+            if (error instanceof TerminalEnterDispatchNotAttemptedError) {
+                throw error;
+            }
+            throw new TerminalEnterDispatchNotAttemptedError(error instanceof Error ? error.message : String(error), { cause: error });
+        }
+        try {
+            await this.runtime.dispatchEnter(verifiedForEnter);
+            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 });
+            }
+            throw error;
+        }
+        return {
+            stage: "enter_dispatched",
+            agent: adapter.agent,
+            terminalControl: verifiedForEnter,
+            multiline
+        };
+    }
+    async observeCodexComposer(adapter, terminalControl, expectedText, runtime) {
+        const normalized = expectedText.trimEnd();
+        if (!normalized) {
+            return {
+                state: "unavailable",
+                reason: "expected Codex draft is empty"
+            };
+        }
+        try {
+            this.runtime.preflight(terminalControl, "observe_composer");
+        }
+        catch (error) {
+            return {
+                state: "unavailable",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+        return this.settleCodexComposerObservation(adapter, terminalControl, normalized, runtime, { minimumStableMs: CODEX_MULTILINE_SETTLE_POLL_MS });
+    }
+    async settleCodexComposerObservation(adapter, terminalControl, expectedText, runtime, options) {
+        const startedAt = this.runtime.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.runtime.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 &&
+                this.classifiers.sameIdentity(candidate.terminalControl, snapshot.terminalControl);
+            if (sameCandidate) {
+                stableCaptures += 1;
+            }
+            else {
+                candidate = snapshot;
+                stableSince = this.runtime.nowMs();
+                stableCaptures = 1;
+                finishObservedExactCandidate = snapshot.state === "exact_draft";
+            }
+            const stableForMs = stableSince === undefined
+                ? 0
+                : this.runtime.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")) {
+                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 &&
+                    this.classifiers.sameIdentity(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.runtime.nowMs();
+                stableCaptures = 1;
+                finishObservedExactCandidate = finalSnapshot.state === "exact_draft";
+            }
+            const elapsed = this.runtime.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.runtime.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.runtime.verifyIdentity(adapter.agent, terminalControl, runtime);
+        }
+        catch (error) {
+            return {
+                state: "identity_drift",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+        let styledScreen;
+        try {
+            styledScreen = await this.runtime.captureStyled(verifiedBefore);
+        }
+        catch (error) {
+            return {
+                state: "unavailable",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+        const screen = this.classifiers.stripEscapes(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.runtime.verifyIdentity(adapter.agent, verifiedBefore, runtime);
+        }
+        catch (error) {
+            return {
+                state: "identity_drift",
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+        if (!this.classifiers.sameIdentity(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" ||
+            this.classifiers.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 = this.classifiers.currentCodexComposer(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
+        };
+    }
+    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 verifyExactComposerBeforeEnter(adapter, terminalControl, expectedText, runtime, allowWorkingComposer = false) {
+        const captured = await this.runtime.captureInspection(adapter, terminalControl, {
+            runtime,
+            scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
+        });
+        const exactComposer = this.classifiers.exactTerminalComposer(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.runtime.verifyIdentity(adapter.agent, captured.terminalControl, runtime);
+        if (!this.classifiers.sameIdentity(captured.terminalControl, verifiedImmediatelyBeforeEnter)) {
+            throw new Error("terminal control identity changed after the final exact composer capture");
+        }
+        return verifiedImmediatelyBeforeEnter;
+    }
+    claudeInjectedPasteProofPorts(adapter) {
+        return {
+            nowMs: this.runtime.nowMs,
+            sleep: this.runtime.sleep,
+            capture: (terminalControl, runtime) => this.runtime.captureInspection(adapter, terminalControl, {
+                runtime,
+                scrollbackLines: CODEX_MULTILINE_SETTLE_SCROLLBACK_LINES
+            }),
+            verifyIdentity: (terminalControl, runtime) => this.runtime.verifyIdentity(adapter.agent, terminalControl, runtime),
+            exactDraft: this.classifiers.exactClaudeComposer,
+            exactInjectedPastePlaceholder: this.classifiers.exactClaudeInjectedPastePlaceholder
+        };
+    }
+    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.runtime.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")) ||
+            !this.classifiers.exactTerminalComposer(adapter.agent, captured.screen, "")) {
+            throw new Error(`${adapter.displayName} composer was not exactly empty immediately before text`);
+        }
+        const verified = await this.runtime.verifyIdentity(adapter.agent, captured.terminalControl, runtime);
+        if (!this.classifiers.sameIdentity(captured.terminalControl, verified)) {
+            throw new Error("terminal control identity changed after the final empty composer capture");
+        }
+        return verified;
+    }
+}
+//# sourceMappingURL=terminal-text-submission-bridge.js.map