@scotthuang/agent-knock-knock 0.12.16 → 0.12.18

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

@@ -40,6 +40,10 @@ const CODEX_NATIVE_STATUS_POPUP_BY_PROFILE = {
     "codex-tui-0.149.1": [
         "  /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
@@ -52,7 +56,8 @@ const CODEX_NATIVE_STATUS_MIN_VIEWPORT_BY_PROFILE = {
     "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.149.1": 80,
+    "codex-tui-generic-v1": 80
 };
 const CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE = {
     "claude-code-2.1.218-native-status": [
@@ -72,6 +77,12 @@ const CLAUDE_NATIVE_STATUS_POPUP_BY_PROFILE = {
         "/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 = {
@@ -86,6 +97,10 @@ const CLAUDE_NATIVE_STATUS_SETTLE_BY_PROFILE = {
     "claude-code-2.1.237-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;
@@ -163,6 +178,64 @@ export class NativeInspectionDismissalError extends Error {
         this.name = "NativeInspectionDismissalError";
     }
 }
+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 TerminalAgentBridge {
     registry;
     terminalProvider;
@@ -318,16 +391,7 @@ export class TerminalAgentBridge {
     async send(agent, terminalControl, text, options = {}) {
         const adapter = this.registry.require(agent);
         const multiline = /[\r\n]/u.test(text.trimEnd());
-        const exactEmptyRetryAuthority = options.requireExactEmptyComposerAfterBeforeText;
-        const requireExactComposer = (adapter.agent === "codex" && multiline) ||
-            options.requireExactComposerBeforeEnter === true ||
-            exactEmptyRetryAuthority !== undefined;
-        if (exactEmptyRetryAuthority !== undefined &&
-            (adapter.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");
-        }
+        const { exactEmptyRetryAuthority, requireExactEmptyComposerBeforeText, requireExactComposer } = terminalSendComposerRequirements(adapter.agent, multiline, options);
         try {
             assertTerminalMutationCapabilities({
                 provider: this.terminalProvider,
@@ -365,6 +429,7 @@ export class TerminalAgentBridge {
         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
@@ -404,22 +469,33 @@ export class TerminalAgentBridge {
             catch (error) {
                 throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
             }
-        }
-        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");
+            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 });
+                }
             }
-            verifiedForText = reverifiedForText;
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (exactEmptyRetryAuthority) {
-                throw new TerminalEnterDispatchReservedError(message, {
-                    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 });
             }
-            throw new TerminalInputNotStartedError(message, { cause: error });
         }
         try {
             await this.terminalProvider.sendText(this.terminalProvider.endpoint(verifiedForText), normalized);
@@ -435,43 +511,55 @@ export class TerminalAgentBridge {
             }
             throw error;
         }
+        const textInjectedAt = this.nowMs();
+        const preserveUserInput = options.userExplicitEnterAfterTextWithoutComposerVeto === true;
+        let postTextHookError;
         let verifiedForEnter;
         try {
-            await options.onTransportStage?.({
+            postTextHookError = await recordTerminalSendStage(options, {
                 stage: "text_injected",
                 agent: adapter.agent,
                 terminalControl: verifiedForText,
                 multiline
-            });
-            // Text and Enter are separate tmux operations. Revalidate between them
-            // and never submit after identity or composer drift. Every failure in
-            // this region is typed proof that this invocation did not call C-m.
+            }, 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
+                    allowOpaqueLargePastePlaceholder: exactEmptyRetryAuthority === undefined,
+                    allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true
                 });
             }
             else if (requireExactComposer) {
-                verifiedForEnter = await this.verifyExactComposerBeforeEnter(adapter, terminalControl, normalized, options.runtime);
+                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);
             }
-            await options.beforeEnter?.({
+            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) {
                 verifiedForEnter = adapter.agent === "codex"
                     ? await this.settleCodexMultilineComposer(adapter, terminalControl, normalized, options.runtime, {
-                        allowOpaqueLargePastePlaceholder: exactEmptyRetryAuthority === undefined
+                        allowOpaqueLargePastePlaceholder: exactEmptyRetryAuthority === undefined,
+                        allowWorkingComposer: options.allowWorkingComposerForUserExplicit === true
                     })
-                    : await this.verifyExactComposerBeforeEnter(adapter, terminalControl, normalized, options.runtime);
+                    : await this.verifyExactComposerBeforeEnter(adapter, terminalControl, normalized, options.runtime, options.allowWorkingComposerForUserExplicit === true);
             }
             else if (options.beforeEnter) {
                 verifiedForEnter = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
@@ -493,12 +581,13 @@ export class TerminalAgentBridge {
         // 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"]);
-            await options.onTransportStage?.({
+            postTextHookError = await recordTerminalSendStage(options, {
                 stage: "enter_dispatched",
                 agent: adapter.agent,
                 terminalControl: verifiedForEnter,
                 multiline
-            });
+            }, preserveUserInput, postTextHookError);
+            throwPostTextHookFailureAfterUserEnter(preserveUserInput, postTextHookError);
         }
         catch (error) {
             if (exactEmptyRetryAuthority) {
@@ -539,6 +628,179 @@ export class TerminalAgentBridge {
         }
         return this.settleCodexComposerObservation(adapter, terminalControl, normalized, options.runtime, { minimumStableMs: CODEX_MULTILINE_SETTLE_POLL_MS });
     }
+    /**
+     * Honor one explicit user Send against the current Codex terminal. The
+     * rendered Composer is not authority: clear the current draft once, inject
+     * the user's request, cross Codex's paste-suppression window, and press Enter
+     * once. Approval/modal and terminal identity remain hard pre-mutation gates.
+     * This primitive is intentionally not used by autonomous managed sends.
+     */
+    async sendUserExplicitCodex(terminalControl, text, options) {
+        const adapter = this.registry.require("codex");
+        const normalized = text.trimEnd();
+        const multiline = /[\r\n]/u.test(normalized);
+        if (!normalized) {
+            throw new TerminalInputNotStartedError("terminal message is empty");
+        }
+        try {
+            assertTerminalMutationCapabilities({
+                provider: this.terminalProvider,
+                terminal: this.terminalProvider.endpoint(terminalControl),
+                semantic: ["send_keys", "screen_status"],
+                transport: [
+                    "stable_resource_resolution",
+                    "screen_capture",
+                    "text_delivery",
+                    "key_delivery"
+                ]
+            });
+        }
+        catch (error) {
+            throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
+        }
+        const notStarted = (error, prefix) => error instanceof TerminalInputNotStartedError
+            ? error
+            : new TerminalInputNotStartedError(`${prefix ? `${prefix}: ` : ""}${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        const uncertain = (message, error) => error instanceof TerminalEnterDispatchReservedError
+            ? error
+            : new TerminalEnterDispatchReservedError(message, { cause: error });
+        const captureSafePrompt = async (control) => {
+            try {
+                const captured = await this.captureInspection(adapter, control, {
+                    runtime: options.runtime,
+                    // Approval/modal authority belongs to the current viewport. Do
+                    // not let historical Esc instructions in scrollback veto Send.
+                    scrollbackLines: 0
+                });
+                if (captured.inspection.approval.blocked ||
+                    captured.inspection.activity.state === "awaiting_approval" ||
+                    codexBlockingModalVisible(captured.screen)) {
+                    throw new Error("the explicit user Send is blocked by a Codex approval or modal prompt");
+                }
+                const verified = await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, options.runtime);
+                if (!sameTerminalControlIdentity(captured.terminalControl, verified)) {
+                    throw new Error("terminal identity changed across the explicit Send approval scan");
+                }
+                return verified;
+            }
+            catch (error) {
+                throw notStarted(error);
+            }
+        };
+        const initiallySafe = await captureSafePrompt(terminalControl);
+        const reservationContext = {
+            terminalControl: initiallySafe,
+            text: normalized
+        };
+        try {
+            await options.beforeMutationReservation(reservationContext);
+        }
+        catch (error) {
+            throw notStarted(error);
+        }
+        // The reservation callback may await Store or terminal locks. Recapture
+        // only approval/modal and identity authority immediately before the first
+        // physical mutation; Composer visibility and contents are never a veto.
+        const verifiedForClear = await captureSafePrompt(initiallySafe);
+        let clearEndpoint;
+        try {
+            clearEndpoint = this.terminalProvider.endpoint(verifiedForClear);
+        }
+        catch (error) {
+            throw notStarted(error);
+        }
+        try {
+            await this.terminalProvider.sendKeys(clearEndpoint, ["C-u"]);
+        }
+        catch (error) {
+            if (error instanceof TerminalControlInputNotSentError) {
+                throw notStarted(error);
+            }
+            throw uncertain("explicit Codex draft-clear outcome is uncertain; do not retry automatically", error);
+        }
+        let postMutationHookError;
+        try {
+            await options.onComposerClearDispatched?.({
+                terminalControl: verifiedForClear,
+                text: normalized
+            });
+        }
+        catch (error) {
+            postMutationHookError = error;
+        }
+        let verifiedForText;
+        try {
+            verifiedForText = await this.verifyTerminalIdentity(adapter.agent, verifiedForClear, options.runtime);
+            if (!sameTerminalControlIdentity(verifiedForClear, verifiedForText)) {
+                throw new Error("terminal identity changed after clearing the Composer");
+            }
+            await this.terminalProvider.sendText(this.terminalProvider.endpoint(verifiedForText), normalized);
+        }
+        catch (error) {
+            throw uncertain("explicit Codex replacement text outcome is uncertain after clearing the prior draft; do not retry automatically", error);
+        }
+        const textInjectedAt = this.nowMs();
+        try {
+            try {
+                await options.onTransportStage?.({
+                    stage: "text_injected",
+                    agent: adapter.agent,
+                    terminalControl: verifiedForText,
+                    multiline
+                });
+            }
+            catch (error) {
+                postMutationHookError ??= error;
+            }
+            await this.sleep(Math.max(0, CODEX_PASTE_ENTER_SETTLE_MS - (this.nowMs() - textInjectedAt)));
+        }
+        catch (error) {
+            throw uncertain("explicit Codex text was injected but its Enter outcome is unresolved; do not retry automatically", error);
+        }
+        let verifiedForEnter;
+        try {
+            verifiedForEnter = await this.verifyTerminalIdentity(adapter.agent, verifiedForText, options.runtime);
+            if (!sameTerminalControlIdentity(verifiedForText, verifiedForEnter)) {
+                throw new Error("terminal identity changed before explicit Send Enter");
+            }
+        }
+        catch (error) {
+            throw uncertain("explicit Codex Enter endpoint is unresolved after terminal input; do not retry automatically", error);
+        }
+        try {
+            await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(verifiedForEnter), ["C-m"]);
+        }
+        catch (error) {
+            throw uncertain("explicit Codex Send Enter outcome is uncertain; do not retry automatically", error);
+        }
+        try {
+            try {
+                await options.onTransportStage?.({
+                    stage: "enter_dispatched",
+                    agent: adapter.agent,
+                    terminalControl: verifiedForEnter,
+                    multiline
+                });
+            }
+            catch (error) {
+                postMutationHookError ??= error;
+            }
+            if (postMutationHookError !== undefined) {
+                throw postMutationHookError;
+            }
+        }
+        catch (error) {
+            throw uncertain("explicit Codex Send Enter was dispatched but its post-mutation acknowledgement failed; do not retry automatically", error);
+        }
+        return {
+            stage: "enter_dispatched",
+            terminalControl: verifiedForEnter,
+            disposition: "replaced_current_composer",
+            clearCount: 1,
+            textInjectionCount: 1,
+            enterCount: 1
+        };
+    }
     /**
      * Submit one already-present exact Codex draft. This primitive never writes
      * text, clears the composer, or emits C-c, and contains exactly one C-m call.
@@ -618,14 +880,16 @@ export class TerminalAgentBridge {
             enterCount: 1
         };
     }
-    async verifyExactComposerBeforeEnter(adapter, terminalControl, expectedText, runtime) {
+    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) ||
+            !(["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`);
         }
@@ -635,6 +899,34 @@ export class TerminalAgentBridge {
         }
         return verifiedImmediatelyBeforeEnter;
     }
+    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.
      *
@@ -1102,7 +1394,8 @@ export class TerminalAgentBridge {
         const observation = await this.settleCodexComposerObservation(adapter, terminalControl, expectedText, runtime, {
             minimumStableMs: CODEX_PASTE_ENTER_SETTLE_MS,
             requiredState: "exact_draft",
-            allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true
+            allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
+            allowWorkingComposer: options.allowWorkingComposer === true
         });
         if (observation.state === "exact_draft") {
             return observation.terminalControl;
@@ -1126,7 +1419,9 @@ export class TerminalAgentBridge {
         let control = terminalControl;
         while (true) {
             const snapshot = await this.captureCodexComposerSnapshot(adapter, control, expectedText, runtime, {
-                allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true
+                allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
+                classifyOpaqueLargePasteAsDifferent: options.classifyOpaqueLargePasteAsDifferent === true,
+                allowWorkingComposer: options.allowWorkingComposer === true
             });
             if (snapshot.state === "identity_drift" ||
                 (snapshot.state === "unavailable" && snapshot.retryable !== true)) {
@@ -1168,7 +1463,9 @@ export class TerminalAgentBridge {
                 // 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
+                    allowOpaqueLargePastePlaceholder: options.allowOpaqueLargePastePlaceholder === true,
+                    classifyOpaqueLargePasteAsDifferent: options.classifyOpaqueLargePasteAsDifferent === true,
+                    allowWorkingComposer: options.allowWorkingComposer === true
                 });
                 if (finalSnapshot.state === snapshot.state &&
                     "digest" in finalSnapshot &&
@@ -1288,14 +1585,15 @@ export class TerminalAgentBridge {
                 digest: screenDigest
             };
         }
-        if (inspection.activity.state === "working") {
+        if (inspection.activity.state === "working" &&
+            options.allowWorkingComposer !== true) {
             return {
                 state: "working",
                 terminalControl: verifiedAfter,
                 digest: screenDigest
             };
         }
-        const composer = currentCodexComposerCapture(styledScreen, expectedText, options.allowOpaqueLargePastePlaceholder === true);
+        const composer = currentCodexComposerCapture(styledScreen, expectedText, options.allowOpaqueLargePastePlaceholder === true, options.classifyOpaqueLargePasteAsDifferent === true);
         if (!composer) {
             return {
                 state: "unavailable",
@@ -1891,7 +2189,7 @@ function assertClosedStatusInspectionPlan(adapter, terminalControl, plan) {
         plan.composer.maximumSettleMs < plan.composer.minimumStableMs ||
         plan.expectedResult.kind !== "native_status" ||
         !exactPresentation) {
-        throw new Error("refusing a non-closed or unverified native inspection plan");
+        throw new Error("refusing a non-closed native inspection plan");
     }
 }
 function assertClosedNativeInspectionDismissal(plan) {
@@ -1899,7 +2197,7 @@ function assertClosedNativeInspectionDismissal(plan) {
         plan.expectedResult.dismissal?.expected !== "idle_empty_composer" ||
         JSON.stringify(plan.expectedResult.dismissal.keys) !==
             JSON.stringify(["Escape"])) {
-        throw new Error("native inspection has no closed verified modal dismissal plan");
+        throw new Error("native inspection has no closed modal dismissal plan");
     }
 }
 function assertNativeInspectionComposerSafe(inspection, displayName = "terminal agent") {
@@ -2245,7 +2543,7 @@ function codexBlockingModalVisible(screen) {
  * Classify only the bottom live Codex composer region. A matching transcript
  * prompt elsewhere in scrollback is deliberately ignored.
  */
-function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLargePastePlaceholder = false) {
+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) {
@@ -2295,7 +2593,9 @@ function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLarg
     const comparable = composerComparableText(bodyRows.join("\n"));
     const opaqueLargePastePlaceholder = /^\[Pasted Content \d+ chars\]$/u.test(comparable);
     if (opaqueLargePastePlaceholder && !allowOpaqueLargePastePlaceholder) {
-        return undefined;
+        return classifyOpaqueLargePasteAsDifferent
+            ? { state: "different_draft", digest }
+            : undefined;
     }
     const exactVisibleDraft = terminalComposerRowsMatchExpected(bodyRows, expectedComparable);
     const exactLargePastePlaceholder = allowOpaqueLargePastePlaceholder &&