@scotthuang/agent-knock-knock 0.12.17 → 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;
@@ -166,10 +181,16 @@ export class NativeInspectionDismissalError extends Error {
 function terminalSendComposerRequirements(agent, multiline, options) {
     const exactEmptyRetryAuthority = options.requireExactEmptyComposerAfterBeforeText;
     const requireExactEmptyComposerBeforeText = options.requireExactEmptyComposerBeforeText === true;
-    const requireExactComposer = (agent === "codex" && multiline) ||
-        options.requireExactComposerBeforeEnter === true ||
-        requireExactEmptyComposerBeforeText ||
-        exactEmptyRetryAuthority !== undefined;
+    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 ||
@@ -182,6 +203,39 @@ function terminalSendComposerRequirements(agent, multiline, options) {
         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;
@@ -457,17 +511,21 @@ 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,
@@ -478,14 +536,20 @@ export class TerminalAgentBridge {
                 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.
@@ -517,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) {
@@ -564,9 +629,10 @@ 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 composer.
-     * Empty composers receive the request, exact drafts receive Enter only, and
-     * every other stable draft is cleared and replaced by the requested text.
+     * 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) {
@@ -584,6 +650,7 @@ export class TerminalAgentBridge {
                 transport: [
                     "stable_resource_resolution",
                     "screen_capture",
+                    "text_delivery",
                     "key_delivery"
                 ]
             });
@@ -591,189 +658,50 @@ export class TerminalAgentBridge {
         catch (error) {
             throw new TerminalInputNotStartedError(error instanceof Error ? error.message : String(error), { cause: error });
         }
-        const observation = await this.settleCodexComposerObservation(adapter, terminalControl, normalized, options.runtime, {
-            // The same-draft branch may press Enter without any preceding text
-            // delivery of its own, so its initial stable proof must itself cross
-            // Codex's paste/newline suppression window.
-            minimumStableMs: CODEX_PASTE_ENTER_SETTLE_MS,
-            classifyOpaqueLargePasteAsDifferent: true,
-            allowWorkingComposer: true
-        });
-        if (observation.state !== "exact_empty" &&
-            observation.state !== "exact_draft" &&
-            observation.state !== "different_draft") {
-            const reason = "reason" in observation
-                ? observation.reason
-                : `Codex composer is ${observation.state}`;
-            throw new TerminalInputNotStartedError(`the explicit user Send has no stable mutable Codex composer: ${reason}`);
-        }
-        const reservationContext = {
-            terminalControl: observation.terminalControl,
-            text: normalized,
-            composerDigest: observation.digest,
-            composerState: observation.state
-        };
         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 revalidateBeforeFirstMutation = async (expectedState) => {
+        const captureSafePrompt = async (control) => {
             try {
-                await options.beforeMutationReservation(reservationContext);
-                const finalComposer = await this.captureCodexComposerSnapshot(adapter, observation.terminalControl, normalized, options.runtime, {
-                    classifyOpaqueLargePasteAsDifferent: true,
-                    allowWorkingComposer: true
+                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 (finalComposer.state !== expectedState ||
-                    finalComposer.digest !== observation.digest ||
-                    !sameTerminalControlIdentity(observation.terminalControl, finalComposer.terminalControl)) {
-                    const reason = "reason" in finalComposer
-                        ? finalComposer.reason
-                        : `Codex composer is ${finalComposer.state}`;
-                    throw new Error(`the Codex composer changed before explicit user Send: ${reason}`);
+                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");
                 }
-                return finalComposer.terminalControl;
-            }
-            catch (error) {
-                throw notStarted(error);
-            }
-        };
-        const dispatchEnter = async (control, outcomeLabel, mutationAlreadyStarted) => {
-            let endpoint;
-            try {
-                endpoint = this.terminalProvider.endpoint(control);
-            }
-            catch (error) {
-                if (!mutationAlreadyStarted)
-                    throw notStarted(error);
-                throw uncertain(`${outcomeLabel} Enter endpoint is unresolved after terminal input; do not retry automatically`, error);
-            }
-            try {
-                await this.terminalProvider.sendKeys(endpoint, ["C-m"]);
-            }
-            catch (error) {
-                if (!mutationAlreadyStarted &&
-                    error instanceof TerminalControlInputNotSentError) {
-                    throw notStarted(error);
+                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");
                 }
-                throw uncertain(`${outcomeLabel} Enter outcome is uncertain; do not retry automatically`, error);
-            }
-            try {
-                await options.onTransportStage?.({
-                    stage: "enter_dispatched",
-                    agent: adapter.agent,
-                    terminalControl: control,
-                    multiline
-                });
-                return control;
+                return verified;
             }
             catch (error) {
-                throw uncertain(`${outcomeLabel} Enter was dispatched but its durable acknowledgement failed; do not retry automatically`, error);
+                throw notStarted(error);
             }
         };
-        const injectAndSubmit = async (control, mutationAlreadyStarted) => {
-            let endpoint;
-            try {
-                endpoint = this.terminalProvider.endpoint(control);
-            }
-            catch (error) {
-                if (!mutationAlreadyStarted)
-                    throw notStarted(error);
-                throw uncertain("explicit Codex replacement endpoint is unresolved after clearing the prior draft; do not retry automatically", error);
-            }
-            try {
-                await this.terminalProvider.sendText(endpoint, normalized);
-            }
-            catch (error) {
-                if (!mutationAlreadyStarted &&
-                    error instanceof TerminalControlInputNotSentError) {
-                    throw notStarted(error);
-                }
-                throw uncertain(mutationAlreadyStarted
-                    ? "explicit Codex replacement text outcome is uncertain after clearing the prior draft; do not retry automatically"
-                    : "explicit Codex text outcome is uncertain; do not retry automatically", error);
-            }
-            let exactDraftControl;
-            try {
-                await options.onTransportStage?.({
-                    stage: "text_injected",
-                    agent: adapter.agent,
-                    terminalControl: control,
-                    multiline
-                });
-                // This text was injected from an exact-empty composer under the same
-                // terminal lock. Codex may render a large paste only as its exact
-                // character-count placeholder, which is sufficient for this freshly
-                // injected request but never for classifying a pre-existing draft.
-                exactDraftControl = await this.settleCodexMultilineComposer(adapter, control, normalized, options.runtime, {
-                    allowOpaqueLargePastePlaceholder: true,
-                    allowWorkingComposer: true
-                });
-            }
-            catch (error) {
-                throw uncertain("explicit Codex text was injected but its Enter outcome is unresolved; do not retry automatically", error);
-            }
-            return dispatchEnter(exactDraftControl, "explicit Codex Send", true);
+        const initiallySafe = await captureSafePrompt(terminalControl);
+        const reservationContext = {
+            terminalControl: initiallySafe,
+            text: normalized
         };
-        if (observation.state === "exact_draft") {
-            const verifiedForEnter = await revalidateBeforeFirstMutation("exact_draft");
-            const entered = await dispatchEnter(verifiedForEnter, "explicit Codex existing-draft submission", false);
-            return {
-                stage: "enter_dispatched",
-                terminalControl: entered,
-                disposition: "submitted_existing_draft",
-                clearCount: 0,
-                textInjectionCount: 0,
-                enterCount: 1
-            };
-        }
-        if (observation.state === "exact_empty") {
-            try {
-                assertTerminalMutationCapabilities({
-                    provider: this.terminalProvider,
-                    terminal: this.terminalProvider.endpoint(observation.terminalControl),
-                    semantic: ["send_keys", "screen_status"],
-                    transport: [
-                        "stable_resource_resolution",
-                        "screen_capture",
-                        "text_delivery",
-                        "key_delivery"
-                    ]
-                });
-            }
-            catch (error) {
-                throw notStarted(error);
-            }
-            const verifiedForText = await revalidateBeforeFirstMutation("exact_empty");
-            const entered = await injectAndSubmit(verifiedForText, false);
-            return {
-                stage: "enter_dispatched",
-                terminalControl: entered,
-                disposition: "injected_empty_composer",
-                clearCount: 0,
-                textInjectionCount: 1,
-                enterCount: 1
-            };
-        }
         try {
-            assertTerminalMutationCapabilities({
-                provider: this.terminalProvider,
-                terminal: this.terminalProvider.endpoint(observation.terminalControl),
-                semantic: ["send_keys", "screen_status"],
-                transport: [
-                    "stable_resource_resolution",
-                    "screen_capture",
-                    "text_delivery",
-                    "key_delivery"
-                ]
-            });
+            await options.beforeMutationReservation(reservationContext);
         }
         catch (error) {
             throw notStarted(error);
         }
-        const verifiedForClear = await revalidateBeforeFirstMutation("different_draft");
+        // 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);
@@ -790,31 +718,84 @@ export class TerminalAgentBridge {
             }
             throw uncertain("explicit Codex draft-clear outcome is uncertain; do not retry automatically", error);
         }
-        let emptyControl;
+        let postMutationHookError;
         try {
-            await options.onComposerClearDispatched?.(reservationContext);
-            const empty = await this.settleCodexComposerObservation(adapter, verifiedForClear, normalized, options.runtime, {
-                minimumStableMs: CODEX_MULTILINE_SETTLE_POLL_MS,
-                requiredState: "exact_empty",
-                classifyOpaqueLargePasteAsDifferent: true,
-                allowWorkingComposer: true
+            await options.onComposerClearDispatched?.({
+                terminalControl: verifiedForClear,
+                text: normalized
             });
-            if (empty.state !== "exact_empty") {
-                const reason = "reason" in empty
-                    ? empty.reason
-                    : `Codex composer is ${empty.state}`;
-                throw new Error(`Codex composer did not become empty after explicit replacement clear: ${reason}`);
+        }
+        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;
             }
-            emptyControl = empty.terminalControl;
         }
         catch (error) {
-            throw uncertain("explicit Codex composer was cleared but replacement did not start; do not retry automatically", error);
+            throw uncertain("explicit Codex Send Enter was dispatched but its post-mutation acknowledgement failed; do not retry automatically", error);
         }
-        const entered = await injectAndSubmit(emptyControl, true);
         return {
             stage: "enter_dispatched",
-            terminalControl: entered,
-            disposition: "replaced_existing_draft",
+            terminalControl: verifiedForEnter,
+            disposition: "replaced_current_composer",
             clearCount: 1,
             textInjectionCount: 1,
             enterCount: 1
@@ -2208,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) {
@@ -2216,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") {
@@ -2471,24 +2452,6 @@ export function exactCodexReadyStyledComposerCapture(screen) {
         digest: createHash("sha256").update(composerLine).digest("hex")
     };
 }
-/**
- * Closed list-time proof that the bottom Codex composer is either exactly
- * empty or contains one stable replaceable draft. The draft text is never
- * returned; the request-aware classification is repeated under the Send lock.
- */
-export function codexUserExplicitComposerCapture(screen) {
-    // NUL cannot be represented by the terminal composer, so every visible
-    // nonempty value classifies as replaceable without exposing its contents.
-    const composer = currentCodexComposerCapture(screen, "\0", false, true);
-    if (!composer)
-        return undefined;
-    return {
-        state: composer.state === "exact_empty"
-            ? "exact_empty"
-            : "stable_nonempty",
-        digest: composer.digest
-    };
-}
 /**
  * Infer a viewport only from fixed-width visible-buffer rows. Trimmed captures
  * deliberately return undefined: a short content row is not proof of a short