@scotthuang/agent-knock-knock 0.13.1 → 0.13.3

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

@@ -5,7 +5,9 @@ import { hasCanonicalTerminalEndpoint, sameTerminalControlIncarnation, terminalC
 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.153.4 keep Enter in paste/newline mode for
+import { inspectNativeQuestionnaire } from "./terminal-questionnaire-adapter.js";
+import { discoverTerminalModelOptions, inspectTerminalModelControlResidual, observeTerminalModelControl, planTerminalModelControl, probeTerminalModelControl, repairTerminalModelControlResidual, switchTerminalModel } from "./terminal-model-control.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.
@@ -22,6 +24,11 @@ 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;
+const CODEX_MODEL_CONTROL_SLASH_POPUP_BY_PROFILE = {
+    "codex-model-control-0.154.0": [
+        "  /model  choose what model and reasoning effort to use"
+    ]
+};
 // 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.
@@ -60,6 +67,10 @@ const CODEX_NATIVE_STATUS_POPUP_BY_PROFILE = {
         "  /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"
@@ -80,6 +91,7 @@ const CODEX_NATIVE_STATUS_MIN_VIEWPORT_BY_PROFILE = {
     "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 = {
@@ -642,6 +654,367 @@ export class TerminalAgentBridge {
             };
         }
     }
+    async modelOptions(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: ["send_keys", "screen_status"],
+            transport: [
+                "stable_resource_resolution",
+                "screen_capture",
+                "ansi_capture",
+                "text_delivery",
+                "key_delivery"
+            ]
+        });
+        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");
+        }
+        // `claude agents` deliberately reports the same interactive process as
+        // `waiting` / `dialog open` while Claude's native model picker is open.
+        // Keep that lifecycle relaxation private to this model-control operation:
+        // a capture may cross the state boundary read-only, but a terminal key is
+        // authorized only by the immediately preceding, exact profiled picker
+        // frame. The permit is one-shot so no later transport can inherit it.
+        let claudeModelDialogInputPermit;
+        let codexModelInputPermit;
+        const consumeCodexModelInputPermit = () => {
+            const permit = codexModelInputPermit;
+            codexModelInputPermit = undefined;
+            return permit;
+        };
+        const capture = async (input) => {
+            claudeModelDialogInputPermit = undefined;
+            codexModelInputPermit = undefined;
+            const original = input.terminalControl;
+            const verified = await this.verifyModelControlTerminalIdentity(adapter, plan, original, options.runtime, { claudeModelDialog: "allow" });
+            const styledScreen = await this.terminalProvider.capture(this.terminalProvider.endpoint(verified), { scrollbackLines: 160, preserveEscapes: true });
+            const screen = stripTerminalEscapeSequences(styledScreen);
+            const inspection = adapter.inspectScreen({
+                screen,
+                runtime: options.runtime
+            });
+            const modelObservation = adapter.observeModelControl?.(plan, screen);
+            const exactCodexModelSurface = adapter.agent === "codex" &&
+                modelObservation !== undefined &&
+                modelObservation.state !== "none" &&
+                modelObservation.state !== "ambiguous";
+            const exactClaudeModelDialog = adapter.agent === "claude" &&
+                modelObservation?.state === "claude_model_picker";
+            const reverified = await this.verifyModelControlTerminalIdentity(adapter, plan, verified, options.runtime, {
+                claudeModelDialog: exactClaudeModelDialog
+                    ? "require"
+                    : "forbid"
+            });
+            if (!sameTerminalControlIdentity(verified, reverified)) {
+                throw new Error("terminal control identity changed across model-control capture");
+            }
+            if (exactClaudeModelDialog) {
+                claudeModelDialogInputPermit = {
+                    terminalControl: reverified,
+                    fingerprint: modelObservation.fingerprint
+                };
+            }
+            const codexComposer = adapter.agent === "codex"
+                ? currentCodexComposerCapture(styledScreen, input.expectedComposer ?? "", false, false, input.expectedComposer === plan.command
+                    ? CODEX_MODEL_CONTROL_SLASH_POPUP_BY_PROFILE[plan.behaviorProfile]
+                    : undefined)
+                : undefined;
+            let codexInputBlocked = false;
+            if (adapter.agent === "codex") {
+                try {
+                    const questionnaire = inspectNativeQuestionnaire({
+                        agent: "codex",
+                        version: "0.154.0",
+                        screen: styledScreen
+                    });
+                    const asyncQuestionMode = inspectCodexAsyncQuestionInputMode(styledScreen);
+                    codexInputBlocked = !exactCodexModelSurface && (questionnaire.status !== "none" ||
+                        codexActiveWriterViewerVisible(styledScreen) ||
+                        asyncQuestionMode === "expanded" ||
+                        asyncQuestionMode === "ambiguous");
+                }
+                catch {
+                    codexInputBlocked = !exactCodexModelSurface;
+                }
+            }
+            const exactEmptyComposer = adapter.agent === "codex"
+                ? codexComposer?.state === "exact_empty"
+                : isExactClaudeIdleComposer(screen);
+            const claudeProfiledCommand = adapter.agent === "claude" &&
+                input.expectedComposer === plan.command &&
+                exactClaudeModelControlComposerCapture(screen, plan, input.expectedComposer) !== undefined;
+            const claudeBareCommand = adapter.agent === "claude" &&
+                input.expectedComposer !== undefined &&
+                exactTerminalComposerCapture("claude", screen, input.expectedComposer) !== undefined;
+            const exactCommandComposer = input.expectedComposer !== undefined && (adapter.agent === "codex"
+                ? codexComposer?.state === "exact_draft"
+                : claudeProfiledCommand || claudeBareCommand);
+            const exactCommandReady = adapter.agent === "codex"
+                ? codexComposer?.state === "exact_draft" &&
+                    codexComposer.profiledSlashPopup === true
+                : claudeProfiledCommand;
+            const exactBareCommand = adapter.agent === "codex"
+                ? codexComposer?.state === "exact_draft" &&
+                    codexComposer.bareCommand === true
+                : claudeBareCommand && !claudeProfiledCommand;
+            if (adapter.agent === "codex") {
+                const exactModelSurface = modelObservation &&
+                    modelObservation.state !== "none" &&
+                    modelObservation.state !== "ambiguous"
+                    ? {
+                        kind: "model_surface",
+                        fingerprint: modelObservation.fingerprint
+                    }
+                    : undefined;
+                const exactComposerSurface = codexComposer?.state === "exact_empty"
+                    ? {
+                        kind: "composer_empty",
+                        fingerprint: codexComposer.digest
+                    }
+                    : codexComposer?.state === "exact_draft"
+                        ? {
+                            kind: "composer_command",
+                            fingerprint: codexComposer.digest
+                        }
+                        : undefined;
+                const proof = exactModelSurface ?? exactComposerSurface;
+                if (proof) {
+                    codexModelInputPermit = {
+                        terminalControl: reverified,
+                        expectedComposer: input.expectedComposer,
+                        ...proof
+                    };
+                }
+            }
+            return {
+                terminalControl: reverified,
+                screen,
+                // The exact profiled picker is the current input owner. Generic
+                // lifecycle/questionnaire detectors may still see stale transcript
+                // markers behind that overlay, so keep their result from vetoing the
+                // model-control state machine. Unknown or partial pickers receive no
+                // such override and remain fail-closed.
+                activityState: exactCodexModelSurface
+                    ? "unknown"
+                    : inspection.activity.state,
+                approvalBlocked: exactCodexModelSurface
+                    ? false
+                    : inspection.approval.blocked,
+                exactEmptyComposer,
+                exactCommandReady,
+                exactCommandComposer,
+                exactBareCommand,
+                ...(codexComposer?.state === "exact_draft"
+                    ? { exactCommandFingerprint: codexComposer.digest }
+                    : {}),
+                inputBlocked: codexInputBlocked
+            };
+        };
+        return {
+            beforeInput: options.beforeInput,
+            loadCodexCatalog: options.loadCodexCatalog,
+            capture,
+            sendText: async (control, text) => {
+                claudeModelDialogInputPermit = undefined;
+                if (adapter.agent === "codex") {
+                    const permit = consumeCodexModelInputPermit();
+                    if (!permit || permit.kind !== "composer_empty") {
+                        throw new Error("Codex /model text requires one fresh exact empty-composer permit");
+                    }
+                    const fresh = await capture({
+                        terminalControl: control,
+                        expectedComposer: permit.expectedComposer
+                    });
+                    const freshPermit = consumeCodexModelInputPermit();
+                    if (!freshPermit ||
+                        freshPermit.kind !== permit.kind ||
+                        freshPermit.fingerprint !== permit.fingerprint ||
+                        !sameTerminalControlIdentity(permit.terminalControl, freshPermit.terminalControl) ||
+                        fresh.inputBlocked === true ||
+                        fresh.approvalBlocked ||
+                        fresh.activityState === "working" ||
+                        fresh.activityState === "awaiting_approval" ||
+                        !fresh.exactEmptyComposer) {
+                        throw new Error("the exact Codex empty composer changed before /model text delivery");
+                    }
+                    await this.terminalProvider.sendText(this.terminalProvider.endpoint(freshPermit.terminalControl), text);
+                    return;
+                }
+                const verified = await this.verifyTerminalIdentity(adapter.agent, control, options.runtime);
+                await this.terminalProvider.sendText(this.terminalProvider.endpoint(verified), text);
+            },
+            sendKeys: async (control, keys) => {
+                const requestedControl = control;
+                if (adapter.agent === "codex") {
+                    const permit = consumeCodexModelInputPermit();
+                    claudeModelDialogInputPermit = undefined;
+                    if (!permit || !sameTerminalControlIdentity(permit.terminalControl, requestedControl)) {
+                        throw new Error("Codex model-control key requires one fresh exact input-surface permit");
+                    }
+                    const fresh = await capture({
+                        terminalControl: requestedControl,
+                        expectedComposer: permit.expectedComposer
+                    });
+                    const freshPermit = consumeCodexModelInputPermit();
+                    if (!freshPermit ||
+                        freshPermit.kind !== permit.kind ||
+                        freshPermit.fingerprint !== permit.fingerprint ||
+                        !sameTerminalControlIdentity(permit.terminalControl, freshPermit.terminalControl) ||
+                        fresh.inputBlocked === true ||
+                        fresh.approvalBlocked ||
+                        fresh.activityState === "working" ||
+                        fresh.activityState === "awaiting_approval") {
+                        throw new Error("the exact Codex model-control input surface changed before key dispatch");
+                    }
+                    await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(freshPermit.terminalControl), keys);
+                    return;
+                }
+                const permit = claudeModelDialogInputPermit;
+                claudeModelDialogInputPermit = undefined;
+                const requireClaudeModelDialog = permit !== undefined &&
+                    sameTerminalControlIdentity(permit.terminalControl, requestedControl);
+                const verified = await this.verifyModelControlTerminalIdentity(adapter, plan, requestedControl, options.runtime, {
+                    claudeModelDialog: requireClaudeModelDialog
+                        ? "require"
+                        : "forbid"
+                });
+                if (requireClaudeModelDialog) {
+                    const styledScreen = await this.terminalProvider.capture(this.terminalProvider.endpoint(verified), { scrollbackLines: 160, preserveEscapes: true });
+                    const screen = stripTerminalEscapeSequences(styledScreen);
+                    const inspection = adapter.inspectScreen({
+                        screen,
+                        runtime: options.runtime
+                    });
+                    const observation = adapter.observeModelControl?.(plan, screen);
+                    if (inspection.approval.blocked ||
+                        inspection.activity.state === "working" ||
+                        observation?.state !== "claude_model_picker" ||
+                        observation.fingerprint !== permit?.fingerprint) {
+                        throw new Error("the exact Claude model picker changed before key dispatch");
+                    }
+                }
+                await this.terminalProvider.sendKeys(this.terminalProvider.endpoint(verified), keys);
+            },
+            sleep: this.sleep
+        };
+    }
+    async verifyModelControlTerminalIdentity(adapter, plan, terminalControl, runtime, options) {
+        const canUseClaudeModelDialog = adapter.agent === "claude" &&
+            plan.behaviorProfile === "claude-model-control-2.1.266" &&
+            runtime?.requireExactClaudeAgentRow === true &&
+            runtime.exactClaudeAgentState === "idle";
+        if (options.claudeModelDialog === "require") {
+            if (!canUseClaudeModelDialog) {
+                throw new Error("Claude model-dialog identity cannot be required outside its exact profile");
+            }
+            return this.verifyTerminalIdentity(adapter.agent, terminalControl, { ...runtime, exactClaudeAgentState: "status_dialog" });
+        }
+        try {
+            return await this.verifyTerminalIdentity(adapter.agent, terminalControl, runtime);
+        }
+        catch (idleError) {
+            if (options.claudeModelDialog !== "allow" ||
+                !canUseClaudeModelDialog) {
+                throw idleError;
+            }
+            try {
+                return await this.verifyTerminalIdentity(adapter.agent, terminalControl, { ...runtime, exactClaudeAgentState: "status_dialog" });
+            }
+            catch {
+                // Preserve the original current-snapshot failure. Both attempts use
+                // the same PID, process incarnation, native Session, cwd, and terminal
+                // control fence; the second changes only the exact allowed agents row
+                // state from idle to `waiting` / `dialog open`.
+                throw idleError;
+            }
+        }
+    }
     async send(agent, terminalControl, text, options = {}) {
         const adapter = this.registry.require(agent);
         const multiline = /[\r\n]/u.test(text.trimEnd());
@@ -955,6 +1328,13 @@ export class TerminalAgentBridge {
                     // not let historical Esc instructions in scrollback veto Send.
                     scrollbackLines: 0
                 });
+                const asyncQuestionInputMode = inspectCodexAsyncQuestionInputMode(captured.screen);
+                if (asyncQuestionInputMode === "expanded" ||
+                    asyncQuestionInputMode === "ambiguous") {
+                    throw new Error(asyncQuestionInputMode === "expanded"
+                        ? "the Codex async question editor currently owns terminal input; answer, skip, or return to the main prompt before retrying the explicit user Send"
+                        : "Codex shows an async-question surface but AKK cannot prove that the main prompt owns terminal input; return to a complete main prompt before retrying the explicit user Send");
+                }
                 if (captured.inspection.approval.blocked ||
                     captured.inspection.activity.state === "awaiting_approval" ||
                     codexBlockingModalVisible(captured.screen)) {
@@ -2743,9 +3123,80 @@ function exactClaudeComposerFrame(screen) {
             .filter((line) => line.trim().length > 0)
     };
 }
+function exactClaudeModelControlComposerCapture(screen, plan, expectedText) {
+    if (plan.behaviorProfile !== "claude-model-control-2.1.266" ||
+        expectedText !== plan.command ||
+        expectedText !== "/model")
+        return undefined;
+    const frame = exactClaudeComposerFrame(screen);
+    if (!frame ||
+        frame.composerRows.length !== 1 ||
+        frame.composerRows[0].replace(/^\s*❯\s?/u, "").trimEnd() !== expectedText ||
+        frame.trailing.length > 2 ||
+        !claudeNativeInspectionTrailingIsFooter(frame.trailing))
+        return undefined;
+    const beforeComposer = frame.lines.slice(0, frame.openIndex);
+    while (beforeComposer.length > 0 &&
+        beforeComposer.at(-1)?.trim() === "") {
+        beforeComposer.pop();
+    }
+    let popupStart = beforeComposer.length;
+    while (popupStart > 0) {
+        const line = beforeComposer[popupStart - 1];
+        if (/^\s*(?:(?:❯|›)\s*)?\/[a-z][a-z0-9-]*(?:\s{2,}|\s*$)/iu.test(line) ||
+            /^\s{2,}\S/u.test(line)) {
+            popupStart -= 1;
+            continue;
+        }
+        break;
+    }
+    const popupRows = beforeComposer.slice(popupStart);
+    if (popupRows.length === 0 || popupRows.length > 32)
+        return undefined;
+    const suggestions = [];
+    for (const [lineIndex, line] of popupRows.entries()) {
+        const match = /^\s*(?:(❯|›)\s*)?(\/[a-z][a-z0-9-]*)(?:\s{2,}|\s*$)(.*)$/iu
+            .exec(line);
+        if (match) {
+            suggestions.push({
+                lineIndex,
+                selected: Boolean(match[1]),
+                command: match[2],
+                normalized: `${match[2]} ${match[3]}`.trim().replace(/\s+/gu, " ")
+            });
+            continue;
+        }
+        if (suggestions.length === 0 || !/^\s{2,}\S/u.test(line)) {
+            return undefined;
+        }
+        const previous = suggestions.at(-1);
+        previous.normalized = `${previous.normalized} ${line.trim()}`
+            .replace(/\s+/gu, " ");
+    }
+    if (suggestions.length === 0 || suggestions[0].lineIndex !== 0) {
+        return undefined;
+    }
+    const selected = suggestions.filter((row) => row.selected);
+    if (selected.length > 1 ||
+        selected.length === 1 && selected[0].lineIndex !== 0 ||
+        suggestions.slice(1).some((row) => row.command === "/model"))
+        return undefined;
+    const first = suggestions[0].normalized;
+    if (!/^\/model Set the AI model for Claude Code \(currently [A-Za-z0-9][A-Za-z0-9._:/+\[\]\- ]{0,127}\)$/u.test(first)) {
+        return undefined;
+    }
+    return {
+        digest: createHash("sha256")
+            .update(frame.lines.slice(frame.openIndex).join("\n"))
+            .digest("hex")
+    };
+}
 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));
+    return lines.length <= 2 && lines.every(isClaudeNativeComposerFooterLine);
+}
+function isClaudeNativeComposerFooterLine(line) {
+    return /^\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")}`;
@@ -2911,13 +3362,227 @@ function codexBlockingModalVisible(screen) {
         .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);
+        /\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) {
+function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLargePastePlaceholder = false, classifyOpaqueLargePasteAsDifferent = false, exactSlashPopupRows) {
     const screen = stripTerminalEscapeSequences(styledScreen);
     const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
     while (lines.length > 0 && lines.at(-1)?.trim().length === 0) {
@@ -2959,10 +3624,29 @@ function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLarg
     if (positivelyEmpty) {
         return { state: "exact_empty", digest };
     }
-    if (footerIndex < 0) {
+    const expectedComparable = composerComparableText(expectedText);
+    const exactStyledProfiledCommand = exactSlashPopupRows !== undefined &&
+        exactCodexStyledCommandComposerCapture(styledScreen, expectedText) !== undefined;
+    const exactFooterlessProfiledCommand = footerIndex < 0 &&
+        exactStyledProfiledCommand;
+    // Codex 0.154 replaces the ordinary model/cwd footer with its slash
+    // completion surface. Real terminal renderers may retain one or more blank
+    // layout rows between the Composer and that surface. The exact styled
+    // command is sufficient only for reversible cleanup; Enter additionally
+    // requires the unique, ordered, version-profiled completion rows below.
+    const popupRows = region.slice(1).map((row) => row.trimEnd());
+    const exactPopupLayout = exactSlashPopupRows !== undefined && (JSON.stringify(popupRows) === JSON.stringify(exactSlashPopupRows) ||
+        popupRows.length === exactSlashPopupRows.length + 1 &&
+            popupRows[0] === "" &&
+            JSON.stringify(popupRows.slice(1)) ===
+                JSON.stringify(exactSlashPopupRows));
+    const exactProfiledSlashPopup = exactSlashPopupRows !== undefined &&
+        composerComparableText(bodyRows[0] ?? "").trimEnd() ===
+            expectedComparable &&
+        exactPopupLayout;
+    if (footerIndex < 0 && !exactFooterlessProfiledCommand) {
         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);
@@ -2971,17 +3655,67 @@ function currentCodexComposerCapture(styledScreen, expectedText, allowOpaqueLarg
             ? { state: "different_draft", digest }
             : undefined;
     }
-    const exactVisibleDraft = terminalComposerRowsMatchExpected(bodyRows, expectedComparable);
+    // Herdr's ANSI visible buffer preserves Codex's fixed-width Composer paint:
+    // the typed command is followed by layout padding through the viewport edge.
+    // Accept that padding only when the closed 0.154 profile, full-row
+    // background paint, exact command text, and complete model/cwd footer all
+    // agree. Plain padded text remains untrusted.
+    const exactVisibleDraft = footerIndex >= 0 && (terminalComposerRowsMatchExpected(bodyRows, expectedComparable) ||
+        exactStyledProfiledCommand);
     const exactLargePastePlaceholder = allowOpaqueLargePastePlaceholder &&
         expectedCharacterCount > CODEX_LARGE_PASTE_CHAR_THRESHOLD &&
         comparable === composerComparableText(`[Pasted Content ${expectedCharacterCount} chars]`);
-    if (exactVisibleDraft || exactLargePastePlaceholder) {
-        return { state: "exact_draft", digest };
+    if (exactVisibleDraft ||
+        exactLargePastePlaceholder ||
+        exactProfiledSlashPopup ||
+        exactFooterlessProfiledCommand) {
+        return {
+            state: "exact_draft",
+            digest,
+            ...(exactProfiledSlashPopup ? { profiledSlashPopup: true } : {}),
+            ...(exactVisibleDraft && footerIndex >= 0
+                ? { bareCommand: true }
+                : {})
+        };
     }
     return comparable.length > 0
         ? { state: "different_draft", digest }
         : undefined;
 }
+/**
+ * Prove the live footerless Codex slash Composer without trusting transcript
+ * text alone. The 0.154 TUI paints this row across the current viewport while
+ * its completion popup replaces the ordinary model/cwd footer.
+ */
+function exactCodexStyledCommandComposerCapture(styledScreen, expectedText) {
+    const rows = styledScreen.replace(/\r\n?/gu, "\n").split("\n");
+    const viewportColumns = inferCodexVisibleViewportColumns(styledScreen);
+    if (!viewportColumns)
+        return undefined;
+    let composerLine;
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+        const plain = stripTerminalEscapeSequences(rows[index]);
+        if (CODEX_COMPOSER_MARKER.test(plain)) {
+            composerLine = rows[index];
+            break;
+        }
+    }
+    if (!composerLine)
+        return undefined;
+    const plain = stripTerminalEscapeSequences(composerLine);
+    const exactCommand = plain.trimEnd().replace(/^[›»]\s?/u, "") ===
+        expectedText;
+    const spansViewport = Array.from(plain).length === viewportColumns &&
+        plain.endsWith(" ");
+    const hasBackground = [...composerLine.matchAll(/\x1b\[([0-9;]*)m/gu)]
+        .some((match) => match[1].split(";").map(Number).includes(48));
+    if (!exactCommand || !spansViewport || !hasBackground) {
+        return undefined;
+    }
+    return {
+        digest: createHash("sha256").update(composerLine).digest("hex")
+    };
+}
 function exactCodexComposerCapture(screen, expectedText) {
     const lines = screen.replace(/\r\n?/gu, "\n").split("\n");
     const expectedComparable = composerComparableText(expectedText);
@@ -3398,6 +4132,9 @@ export function captureTerminalInteractionRuntimeOffer(input) {
         input.approvalBlocked === true) {
         return undefined;
     }
+    if (exactCurrentModelControlSurface(input.agent, agentVersion, input.screen)) {
+        return undefined;
+    }
     const coreOffer = captureTerminalInteraction({
         subject,
         agent: input.agent,
@@ -3425,6 +4162,21 @@ export function captureTerminalInteractionRuntimeOffer(input) {
         nativeInspection: coreOffer.nativeInspection
     };
 }
+function exactCurrentModelControlSurface(agent, agentVersion, screen) {
+    if (!agentVersion)
+        return false;
+    try {
+        const capabilities = probeTerminalModelControl(agent, agentVersion);
+        if (capabilities.status !== "supported")
+            return false;
+        const observation = observeTerminalModelControl(planTerminalModelControl(capabilities), screen);
+        return observation.state !== "none" &&
+            observation.state !== "ambiguous";
+    }
+    catch {
+        return false;
+    }
+}
 function terminalInteractionTrustedWatchIdentity(terminalControl, runtime, evidence) {
     if (runtime.interactionSubject?.kind !== "terminal_watch" ||
         !evidence ||
@@ -3708,7 +4460,18 @@ async function dispatchTerminalInteractionAnswer(input) {
     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);
+    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;
+    const approval = exactModelSurface
+        ? {
+            blocked: false,
+            approvable: false,
+            reason: modelSurfaceReason
+        }
+        : dispatchableApprovalInspection(adapter, inspection.approval);
     const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, {
         ...inspection,
         approval
@@ -3726,7 +4489,7 @@ function statusFromInspection(adapter, terminalControl, inspection, options = {}
                 }] : [];
         })
         : [];
-    const interaction = options.screen === undefined
+    const interaction = options.screen === undefined || exactModelSurface
         ? undefined
         : captureTerminalInteractionRuntimeOffer({
             agent: adapter.agent,
@@ -3742,10 +4505,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,
@@ -3890,4 +4653,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 (adapter.agent === "codex"
+        ? plan.behaviorProfile !== "codex-model-control-0.154.0" ||
+            plan.scope !== "current_and_new_sessions"
+        : plan.behaviorProfile !== "claude-model-control-2.1.266" ||
+            plan.scope !== "current_session") {
+        throw new Error("refusing an unprofiled terminal model-control plan");
+    }
+}
 //# sourceMappingURL=terminal-agent-bridge.js.map