commandmate 0.49.1 → 0.49.3

package/dist/server/src/lib/cli-tools/opencode.js

@@ -52,6 +52,10 @@ const terminal_keys_1 = require("../../types/terminal-keys");
 const tmux_1 = require("../tmux/tmux");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const submit_verified_sender_1 = require("./submit-verified-sender");
+const readiness_1 = require("../detection/tools/opencode/readiness");
+const status_detector_1 = require("../detection/status-detector");
+const prompt_wait_dialog_1 = require("./prompt-wait-dialog");
+const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const opencode_config_1 = require("./opencode-config");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
@@ -110,6 +114,28 @@ exports.OPENCODE_READY_MAX_ATTEMPTS = 60;
  * in the frame regardless of this number. Matches copilot's 50.
  */
 const OPENCODE_READY_CAPTURE_LINES = 50;
+/**
+ * How long a send that has to fall back to the keyboard waits for the input
+ * box (Issue #4040) — the same 15 s as gemini's and codex's send waits. The
+ * launch window (`OPENCODE_READY_*`, 30 s) is the launch's; a send arrives
+ * after it, and a pane still not up 15 s later is refused as `not-sent`
+ * rather than typed into.
+ */
+const OPENCODE_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/** Interval between the send's readiness polls (Issue #4040). */
+const OPENCODE_PROMPT_POLL_INTERVAL_MS = 500;
+/**
+ * Whether {@link OpenCodeTool}'s keyboard-fallback wait counts this frame
+ * towards giving up on a dialog (Issue #4084): an active prompt, or opencode's
+ * `waiting` without one (its permission strip, pickers, palette and overlays
+ * answer with keys, #1896) — and never a turn being generated. There is no
+ * folder-trust dialog here to leave out: this wait answers none.
+ */
+function isOpenCodeWaitDialog(status) {
+    if ((0, status_detector_1.isGeneratingStatus)(status))
+        return false;
+    return status.hasActivePrompt || status.status === 'waiting';
+}
 /**
  * Waits before each read-back of a message just posted to the server (#2035).
  *
@@ -335,7 +361,9 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 });
             }
             const launchedAt = Date.now();
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+            // Issue #3981: in one writer's turn of the input lock; the readiness
+            // wait below stays outside it.
+            await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
             // Issue #1908: poll for opencode's own composer instead of sleeping 15 s.
             await this.waitForReady(sessionName);
             // Issue #1763: subscribe once the server is up. Health-checked first, so
@@ -496,12 +524,16 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * @param imagePath - Absolute path to an attachment, if there is one
      * @returns Whether the message was posted **and** read back
      */
-    async trySendViaServer(target, message, imagePath) {
+    async trySendViaServer(target, message, imagePath, trace) {
         const outcome = await this.dispatchViaServer(target, message, imagePath);
         if (outcome === 'delivered')
             return true;
         if (outcome !== 'skipped')
             (0, instance_input_lock_1.noteDispatchFailed)(outcome);
+        // Issue #4040: an `unknown` dispatch may have delivered the message, so a
+        // keyboard fallback that then refuses must not report the send `not-sent`.
+        if (outcome === 'unknown' && trace !== undefined)
+            trace.unknown = true;
         return false;
     }
     /**
@@ -653,10 +685,24 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * `CM_AGENT_HOOKS_INJECT=0`, or on an opencode too old for `--port`, must not
      * become a pane that cannot be sent to.
      *
+     * Issue #4040: that keyboard path now waits for an empty input box first
+     * (`waitForPrompt`, and again under the input lock) and refuses as
+     * `not-sent` / `prompt-not-ready` when none comes up — unless the server
+     * dispatch before it ended `unknown`, in which case the refusal stays
+     * `indeterminate`. A `delivered` send neither waits nor types.
+     *
      * @param worktreeId - Worktree ID
      * @param message - Message to send
      */
     async sendMessage(worktreeId, message, instanceId) {
+        await this.sendMessageAfterDispatch(worktreeId, message, instanceId, { unknown: false });
+    }
+    /**
+     * {@link sendMessage}'s body, carrying whether a server dispatch earlier in
+     * the same send ended `unknown` (Issue #4040): {@link sendMessageWithImage}'s
+     * image dispatch is one, and its path fallback comes back through here.
+     */
+    async sendMessageAfterDispatch(worktreeId, message, instanceId, trace) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Issue #2070: the pane exists, but does the AGENT? An agent that quit,
         // updated itself or crashed leaves its tmux session behind, and the send
@@ -669,14 +715,27 @@ class OpenCodeTool extends base_1.BaseCLITool {
         // typing the message into a shell prompt. The relaunch reserves a port and
         // re-attaches, so the server path is available again by the time it is
         // tried. `sendMessageWithImage` reaches this through its own fallback.
-        await this.requireSession('OpenCode', worktreeId, instanceId, { relaunch: true });
-        if (await this.trySendViaServer((0, runtime_1.opencodeTarget)(worktreeId, instanceId), message)) {
+        //
+        // Issue #4040: when that fallback follows an `unknown` image dispatch, a
+        // refusal here (`SESSION_STARTING`, a pane that is gone) typed nothing but
+        // does not make the send as a whole safe to resend either.
+        try {
+            await this.requireSession('OpenCode', worktreeId, instanceId, { relaunch: true });
+        }
+        catch (error) {
+            throw this.keepUnknownDispatch(error, trace, sessionName) ?? error;
+        }
+        if (await this.trySendViaServer((0, runtime_1.opencodeTarget)(worktreeId, instanceId), message, undefined, trace)) {
             // Issue #405: the transcript grew, so the cached capture is stale — the
             // same reason the keystroke path invalidates below.
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             return;
         }
         try {
+            // Issue #4040: the keyboard fallback types only into an input box that is
+            // up and empty — the first send to a new pane always lands here (no
+            // session id yet), as does every send of a pane with no live server.
+            await this.waitForPrompt(sessionName);
             // Issue #1471: Body/Enter separation + read-back submit verification via the
             // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
             await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
@@ -684,6 +743,8 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 message,
                 cliToolId: 'opencode',
                 composer: this.describeComposer(),
+                // Issue #4040: the same test, of the newest frame read under the input lock.
+                readiness: { label: 'OpenCode', isReady: readiness_1.isOpenCodeComposerReady },
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -691,8 +752,96 @@ class OpenCodeTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to OpenCode: ${errorMessage}`);
+            // Issue #4040: the keyboard typed nothing (no ready input box — or any
+            // other refusal before the first key: a dialog, the lock), but the server
+            // dispatch before it may have delivered the message, so the send as a
+            // whole stays unknown rather than "safe to resend".
+            const kept = this.keepUnknownDispatch(error, trace, sessionName);
+            if (kept)
+                throw kept;
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to OpenCode: ${errorMessage}`, { cause: error });
+        }
+    }
+    /**
+     * The error a refusal with nothing typed becomes after a server dispatch of
+     * the same send ended `unknown` (Issue #4040): the message may already be
+     * there, so `classifySendFailure` must read the send as indeterminate.
+     *
+     * @returns the wrapped error, or `null` when the dispatch was not `unknown`
+     *   or the refusal is not a `not-sent` one (the caller throws its own)
+     */
+    keepUnknownDispatch(error, trace, sessionName) {
+        if (!trace.unknown)
+            return null;
+        const refusal = (0, send_attempt_state_1.classifySendFailure)(error);
+        if (refusal.state !== 'not-sent')
+            return null;
+        logger.warn('opencode-send-not-typed-after-unknown-dispatch', { sessionName, reason: refusal.reason });
+        return new Error(`Failed to send message to OpenCode: the keyboard fallback typed nothing (${refusal.reason}), ` +
+            'but an earlier server dispatch may have delivered the message (Issue #4040)', { cause: error });
+    }
+    /**
+     * Wait for an empty input box before the keyboard fallback types (Issue #4040).
+     *
+     * {@link isOpenCodeComposerReady} is the test: the box on screen, empty, and
+     * no dialog or overlay over it (the `Connect a provider` overlay included —
+     * every option on it writes credentials, so it is never typed into).
+     *
+     * A dialog or overlay ({@link isOpenCodeWaitDialog}) does not keep the send
+     * here for the whole window behind a choice only a person can make — but
+     * since Issue #4084 it ends the wait only once confirmed: seen on 2 reads in a
+     * row spanning {@link PROMPT_WAIT_DIALOG_CONFIRM_MS}, the count copilot's wait
+     * uses (#4067). It used to end the wait on one read, so a frame mid-paint
+     * could cut the wait short. A confirmed dialog is refused at once on the
+     * wait's own reads, as the shared sender's re-check under the lock would have
+     * refused it: `prompt-waiting` when the detector reports an active prompt,
+     * otherwise `prompt-not-ready` (opencode's permission strip, pickers and
+     * palette read as `waiting` without `hasActivePrompt`, #1896). A dialog that
+     * opens after the wait is still refused under the input lock on one read. No
+     * capture is waited for past the window: one still running at the deadline
+     * is not used.
+     *
+     * @throws Error (`OpenCode prompt not ready`) when the box did not come up
+     *   within {@link OPENCODE_PROMPT_WAIT_TIMEOUT_MS}, or a dialog without an
+     *   active prompt was confirmed; nothing was typed
+     * @throws Error coded `prompt-waiting` ({@link confirmedDialogRefusal}) for a
+     *   confirmed dialog the detector reads as an active prompt; nothing was typed
+     */
+    async waitForPrompt(sessionName) {
+        const deadline = Date.now() + OPENCODE_PROMPT_WAIT_TIMEOUT_MS;
+        const dialog = (0, prompt_wait_dialog_1.createDialogConfirmation)();
+        while (Date.now() < deadline) {
+            let refusal = null;
+            try {
+                const output = await (0, prompt_wait_dialog_1.readBeforeDeadline)(() => (0, tmux_1.capturePane)(sessionName, OPENCODE_READY_CAPTURE_LINES), deadline);
+                if (output === null)
+                    break;
+                if ((0, readiness_1.isOpenCodeComposerReady)(output))
+                    return;
+                const status = (0, status_detector_1.detectSessionStatus)(output, 'opencode');
+                if (dialog.observe(isOpenCodeWaitDialog(status))) {
+                    logger.warn('opencode-prompt-wait-dialog', { sessionName, reads: dialog.reads, reason: status.reason });
+                    refusal = status.hasActivePrompt
+                        ? (0, prompt_wait_dialog_1.confirmedDialogRefusal)(sessionName, 'OpenCode')
+                        : new Error(`OpenCode prompt not ready: a dialog or overlay (${status.reason}) stayed up for ` +
+                            `${prompt_wait_dialog_1.PROMPT_WAIT_DIALOG_CONFIRM_MS}ms before sending; nothing was typed (Issue #4084)`);
+                }
+            }
+            catch (error) {
+                // Capture may fail - continue polling. Not a dialog read: the run restarts.
+                dialog.reset();
+                logger.debug('opencode-prompt-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
+            }
+            if (refusal)
+                throw refusal;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(OPENCODE_PROMPT_POLL_INTERVAL_MS, remaining)));
         }
+        logger.info('opencode-prompt-not-detected');
+        throw new Error('OpenCode prompt not ready: timed out waiting for the input prompt before sending');
     }
     /**
      * opencode can attach an image — sometimes (Issue #2035).
@@ -721,7 +870,9 @@ class OpenCodeTool extends base_1.BaseCLITool {
      *
      * The fallback is that same degraded body, reached whenever the server route
      * does not apply, and it is deliberately routed back through
-     * {@link sendMessage} rather than `sendMessageWithSubmitVerification`: the
+     * {@link sendMessage}'s body (`sendMessageAfterDispatch`, carrying whether
+     * the image dispatch ended `unknown` — Issue #4040) rather than
+     * `sendMessageWithSubmitVerification`: the
      * reason the image could not be attached is usually "no session yet", and by
      * the time the text is sent that can already have changed. Going through
      * `sendMessage` gives the text one honest attempt at the API before the
@@ -736,12 +887,15 @@ class OpenCodeTool extends base_1.BaseCLITool {
         const sessionName = this.getSessionName(worktreeId, instanceId);
         await this.requireSession('OpenCode', worktreeId, instanceId, { relaunch: false });
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
-        if (await this.trySendViaServer(target, message, imagePath)) {
+        // Issue #4040: one trace for the whole send, so an `unknown` image dispatch
+        // is not forgotten when the path fallback's own dispatch is refused.
+        const trace = { unknown: false };
+        if (await this.trySendViaServer(target, message, imagePath, trace)) {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             return;
         }
         logger.info('opencode-image-degraded-to-path', { worktreeId, instanceId: instanceId ?? this.id });
-        await this.sendMessage(worktreeId, formatImagePathFallbackMessage(message, imagePath), instanceId);
+        await this.sendMessageAfterDispatch(worktreeId, formatImagePathFallbackMessage(message, imagePath), instanceId, trace);
     }
     /**
      * Kill OpenCode session with graceful shutdown.

package/dist/server/src/lib/cli-tools/prompt-wait-dialog.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Giving up on a dialog in a tool's own prompt wait — the wait before the
+ * input lock (Issue #4067 for copilot, Issue #4084 for opencode and
+ * vibe-local).
+ *
+ * A dialog waits for a person, so the wait does not sit out its whole window
+ * (15 s) behind it. But a frame caught mid-paint can read as a dialog once, so
+ * one read is not enough: the dialog has to be seen on
+ * {@link PROMPT_WAIT_DIALOG_CONFIRM_READS} reads in a row spanning
+ * {@link PROMPT_WAIT_DIALOG_CONFIRM_MS}. A read without a dialog, or a capture
+ * that failed, starts the run again.
+ *
+ * What counts as a dialog is each tool's own test (copilot excludes its
+ * folder-trust dialog and a drawn composer; opencode counts `waiting` without
+ * `hasActivePrompt`; nobody counts a Working frame). This module only counts.
+ *
+ * Only the wait's screen reading is confirmed this way. The prompt guard at
+ * the service entry (which also reads the hooks' structured record) and the
+ * re-check under the input lock still decide on one read.
+ *
+ * @module lib/cli-tools/prompt-wait-dialog
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_WAIT_DIALOG_CONFIRM_READS = exports.PROMPT_WAIT_DIALOG_CONFIRM_MS = void 0;
+exports.createDialogConfirmation = createDialogConfirmation;
+exports.readBeforeDeadline = readBeforeDeadline;
+exports.confirmedDialogRefusal = confirmedDialogRefusal;
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
+/** How long a dialog has to stay up before a prompt wait gives up on it. */
+exports.PROMPT_WAIT_DIALOG_CONFIRM_MS = 2000;
+/** On how many reads in a row (both thresholds must hold). */
+exports.PROMPT_WAIT_DIALOG_CONFIRM_READS = 2;
+/** A fresh, empty run. */
+function createDialogConfirmation() {
+    let since = null;
+    let reads = 0;
+    return {
+        observe(isDialog, now = Date.now()) {
+            if (!isDialog) {
+                since = null;
+                reads = 0;
+                return false;
+            }
+            since ??= now;
+            reads++;
+            return reads >= exports.PROMPT_WAIT_DIALOG_CONFIRM_READS && now - since >= exports.PROMPT_WAIT_DIALOG_CONFIRM_MS;
+        },
+        reset() {
+            since = null;
+            reads = 0;
+        },
+        get reads() {
+            return reads;
+        },
+    };
+}
+/**
+ * Run `read` (a capture), but stop waiting for it at `deadline` (Issue #4084):
+ * a capture that is still running then (tmux's own time-out is 5 s) does not
+ * stretch the wait past its window, and the frame it returns late is not used.
+ *
+ * The clock is checked again once the race has answered, as the wait under the
+ * input lock does (`awaitReadyUnderLock`): when the capture's completion is
+ * handled before the deadline's timer, the race answers with a frame read past
+ * the deadline, and that frame is not used either (nor a failure that late).
+ *
+ * @returns what `read` returned, or `null` when the deadline came first
+ * @throws what `read` threw, when it threw before the deadline
+ */
+async function readBeforeDeadline(read, deadline) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+        return null;
+    let timer;
+    const reading = read();
+    // A late failure is nobody's to handle once the deadline has answered.
+    reading.catch(() => undefined);
+    let result;
+    try {
+        result = await Promise.race([
+            reading,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), remaining);
+            }),
+        ]);
+    }
+    catch (error) {
+        if (Date.now() > deadline)
+            return null;
+        throw error;
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+    // Answered past the deadline, whichever settled first: the wait is over.
+    if (Date.now() > deadline)
+        return null;
+    return result;
+}
+/**
+ * The `prompt-waiting` refusal of a dialog a prompt wait confirmed (Issue
+ * #4084), worded and coded as the re-check under the input lock words it
+ * (`recheckComposerBeforeInput`), which is what `classifySendFailure` and the
+ * send service read. Nothing has been typed. Refused on the wait's own reads,
+ * without reading the pane once more.
+ *
+ * The wording must not say "prompt not ready": the classifier matches that
+ * first.
+ */
+function confirmedDialogRefusal(sessionName, label) {
+    return Object.assign(new Error(`A prompt dialog stayed open in session ${sessionName} for ${exports.PROMPT_WAIT_DIALOG_CONFIRM_MS}ms ` +
+        `while the ${label} input prompt was awaited (re-checked under the input lock); nothing was typed (Issue #4084).`), { code: send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE });
+}

package/dist/server/src/lib/cli-tools/session-name.js

@@ -44,8 +44,16 @@ const legacy_session_alias_1 = require("../tmux/legacy-session-alias");
 const SESSION_NAME_PREFIX = 'mcbd-';
 /** Shape of a session-name namespace: 8 lowercase hex digits (Issue #2866). */
 exports.SESSION_NAMESPACE_PATTERN = /^[0-9a-f]{8}$/;
-/** CLI tool ids, longest first, so a longer id is never read as a shorter one. */
-const CLI_TOOL_IDS_LONGEST_FIRST = [...types_1.CLI_TOOL_IDS].sort((a, b) => b.length - a.length);
+/**
+ * CLI tool ids, longest first, so a longer id is never read as a shorter one.
+ *
+ * Read when called, not when this module loads (Issue #3981): modules loaded
+ * early (`session-starting-state`) import this one, and a module-load read of
+ * `CLI_TOOL_IDS` reaches a test's getter mock before it can answer.
+ */
+function cliToolIdsLongestFirst() {
+    return [...types_1.CLI_TOOL_IDS].sort((a, b) => b.length - a.length);
+}
 /**
  * The namespace this process names its sessions with, or null (legacy names).
  *
@@ -150,7 +158,7 @@ function parseSessionName(name) {
         namespace = body.slice(0, dash);
         body = body.slice(dash + 1);
     }
-    const cliToolId = CLI_TOOL_IDS_LONGEST_FIRST.find((id) => body.startsWith(`${id}-`));
+    const cliToolId = cliToolIdsLongestFirst().find((id) => body.startsWith(`${id}-`));
     if (!cliToolId)
         return null;
     const rest = body.slice(cliToolId.length + 1);

package/dist/server/src/lib/cli-tools/submit-composer-read.js

@@ -10,11 +10,13 @@ exports.withoutTrailingBlankRows = withoutTrailingBlankRows;
 exports.findPasteTokens = findPasteTokens;
 exports.readSubmitComposer = readSubmitComposer;
 exports.classifySubmit = classifySubmit;
+exports.classifySubmitWithRule = classifySubmitWithRule;
 exports.isSubmitted = isSubmitted;
 exports.classifyPasteLanded = classifyPasteLanded;
 exports.compactText = compactText;
 const composer_spec_1 = require("./composer-spec");
 const cli_patterns_1 = require("../detection/cli-patterns");
+const composer_own_text_1 = require("../detection/tools/opencode/composer-own-text");
 const composer_text_1 = require("../../lib/detection/composer-text");
 /**
  * Version-resilient pasted-text placeholder.
@@ -38,6 +40,13 @@ const PASTE_PLACEHOLDER_PATTERN = /\[Pasted text[\s#]/;
  * substitution, so a genuinely-submitted message never fails spuriously.
  */
 const REPLACEMENT_COMMAND_PATTERN = /^\/[A-Za-z]/;
+/**
+ * opencode's empty-buffer placeholder on a box row's own text (Issue #4067):
+ * `OPENCODE_IDLE_COMPOSER_PATTERN` with the gutter already removed by
+ * `readOpenCodeComposerOwnRows`. Start-anchored like that pattern, so the
+ * phrase quoted inside a typed body is not taken for it.
+ */
+const OPENCODE_OWN_PLACEHOLDER = /^Ask anything(?:\.\.\.|\u2026)/;
 /**
  * Prompt input-line markers across the marker-drawing TUIs.
  * claude/gemini/copilot: `>` or `❯`; codex: `›`; antigravity: `>`;
@@ -94,17 +103,26 @@ exports.VERIFY_WINDOW_LINES = 12;
  */
 function readComposer(reader, lines, windowLines) {
     if (reader === 'opencode-box') {
-        const rows = (0, cli_patterns_1.findOpenCodeComposerRows)(lines);
-        if (rows === null)
+        // Each buffer row's own text: gutter removed and cut at the box's right
+        // edge (Issue #4067), so the sidebar drawn on the same rows (#2047/#2095 —
+        // its working directory starts with `/`) is never read as the body. The
+        // same cut as the send readiness (`isOpenCodeComposerReady`).
+        const box = (0, composer_own_text_1.readOpenCodeComposerBox)(lines);
+        if (box === null)
             return { kind: 'absent' };
+        const { rows } = box;
+        // An overlay over the box (its bottom border cut in two): its rows are read
+        // to the border's far end, and the reading is marked so B and F do not
+        // stand on it (review of #4067).
+        const obscured = box.obscured ? { obscured: true } : {};
         // The placeholder is painted only while the buffer is empty, and only
-        // inside the box — hence matched on the raw, still-guttered row (#1883).
-        if (rows.some((row) => cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(row)))
-            return { kind: 'empty' };
-        const first = rows.map(cli_patterns_1.stripOpenCodeGutter).find((row) => row.length > 0);
+        // inside the box (#1883) — read on the row's own text, which is inside it.
+        if (rows.some((row) => OPENCODE_OWN_PLACEHOLDER.test(row)))
+            return { kind: 'empty', ...obscured };
+        const first = rows.find((row) => row.length > 0);
         if (first === undefined)
-            return { kind: 'empty' };
-        return { kind: 'text', text: first, rows };
+            return { kind: 'empty', ...obscured };
+        return { kind: 'text', text: first, rows, ...obscured };
     }
     if (reader !== 'input-line-marker')
         return { kind: 'absent' };
@@ -431,6 +449,11 @@ function readSubmitComposer(output, cliToolId, reader, lines, windowLines, messa
  *      pre-#1501 permissive default, so normal sends never spuriously fail) —
  *      except in a codex composer above the read window -> indeterminate
  *      (Issue #3906).
+ *   None of B–F holds for opencode's box with an overlay drawn over it (its
+ *   bottom border cut in two) -> indeterminate (`B-obscured` when nothing is
+ *   seen, `F-obscured` for any text — the body, a token or a `/…` included;
+ *   review of #4067): what the box holds under the overlay is not seen, and an
+ *   Enter or a clear would go to the overlay.
  *
  * C–F are scoped to the composer only, so the user-message echo that a TUI
  * prints into its history above the prompt never causes a false verdict.
@@ -452,6 +475,15 @@ function readSubmitComposer(output, cliToolId, reader, lines, windowLines, messa
  *   the tool's own, so every existing three-argument caller is unchanged.
  */
 function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
+    return classifySubmitWithRule(output, cliToolId, message, composerSpec).state;
+}
+/**
+ * {@link classifySubmit} with the rule that decided the frame (Issue #4035).
+ * The sender logs the rule with every verdict, and treats a `submitted` from B
+ * or F — the screen saying only "the body is not in the composer" — as weaker
+ * evidence than A on a tool whose own hook reports the prompt.
+ */
+function classifySubmitWithRule(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
     const clean = (0, cli_patterns_1.stripAnsi)(output);
     const lines = withoutTrailingBlankRows(clean.split('\n'));
     const windowLines = lines.slice(-exports.VERIFY_WINDOW_LINES);
@@ -461,34 +493,45 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
     //    pinned to the bottom of the pane, and widening it to opencode's whole
     //    frame would match `esc interrupt` printed inside a reply.
     if ((0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
-        return 'submitted';
+        return { state: 'submitted', rule: 'A' };
     }
     const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines, message);
     // B. No composer visible (scrolled off / dialog / still starting), or the
     //    composer is empty => the message left the box => submitted.
+    //    Not on opencode's box with an overlay drawn over it (review of #4067):
+    //    nothing seen there is not the box being empty -> indeterminate.
     if (composer.kind !== 'text') {
-        return 'submitted';
+        if (composer.kind === 'empty' && composer.obscured)
+            return { state: 'indeterminate', rule: 'B-obscured' };
+        return { state: 'submitted', rule: composer.kind === 'absent' ? 'B-absent' : 'B-empty' };
     }
+    //    Text in opencode's box under an overlay (review of #4067): the reading
+    //    runs to the border's far end, the overlay's text included, so none of
+    //    C–F is read from it. C/D would resend Enter and E clear the line — keys
+    //    that would go to the palette or picker on top, not to the box ->
+    //    indeterminate (no Enter, no clear; read again).
+    if (composer.obscured)
+        return { state: 'indeterminate', rule: 'F-obscured' };
     // C. A paste placeholder is still folded into the composer => body is there.
     if (composer.rows.some((row) => PASTE_PLACEHOLDER_PATTERN.test(row) || findPasteTokens(row).tokens.length > 0)) {
-        return 'pending';
+        return { state: 'pending', rule: 'C' };
     }
     // D. The typed body is still sitting in the composer => resend Enter.
     if (inputMatchesBody(composer.text, message)) {
-        return 'pending';
+        return { state: 'pending', rule: 'D' };
     }
     // E. A different slash command is in the composer => a completion popup
     //    replaced what we typed. (Scoped to `/…` so idle-prompt placeholders that
     //    some TUIs paint on an empty composer are never mistaken for this.)
     if (REPLACEMENT_COMMAND_PATTERN.test(composer.text)) {
-        return 'replaced';
+        return { state: 'replaced', rule: 'E' };
     }
     // F. Non-empty, non-command steady-state text (idle placeholder / hint) =>
     //    submitted, preserving the pre-#1501 permissive default. Not for a codex
     //    composer above the window (Issue #3906): before #3906 that frame was
     //    read as no composer at all; text there that is not the body says
     //    neither that the message left nor that Enter would send it.
-    return composer.outsideWindow ? 'indeterminate' : 'submitted';
+    return composer.outsideWindow ? { state: 'indeterminate', rule: 'F-outside' } : { state: 'submitted', rule: 'F' };
 }
 /**
  * Backward-compatible boolean view of {@link classifySubmit}: submitted vs not.

package/dist/server/src/lib/cli-tools/submit-verified-sender-composer.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * The shared sender's pure reads of a captured composer (Issue #4056: split out
+ * of `submit-verified-sender.ts`). No tmux, no keys, no logging.
+ *
+ * Imports nothing from `submit-verified-sender.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeComposer = describeComposer;
+exports.composerHoldsText = composerHoldsText;
+exports.composerShowsForeignPasteToken = composerShowsForeignPasteToken;
+exports.visibleTypedBody = visibleTypedBody;
+exports.codexComposerShowsWholeBody = codexComposerShowsWholeBody;
+exports.needsPromptReport = needsPromptReport;
+const cli_patterns_1 = require("../detection/cli-patterns");
+const submit_composer_read_1 = require("./submit-composer-read");
+function describeComposer(output, cliToolId, composerSpec, message) {
+    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
+    if (composer.kind === 'absent')
+        return 'no composer on screen';
+    if (composer.kind === 'empty')
+        return 'an empty composer';
+    const text = composer.text.length > 80 ? `${composer.text.slice(0, 80)}…` : composer.text;
+    return JSON.stringify(text);
+}
+/** Whether the composer in `output` holds any text at all, read as the sender reads it. */
+function composerHoldsText(output, cliToolId, composerSpec, message) {
+    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    return ((0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message)
+        .kind === 'text');
+}
+/**
+ * Whether the composer shows a paste placeholder whose count is not this body's
+ * (Issue #3945): one counting fewer or more, or more than one placeholder.
+ */
+function composerShowsForeignPasteToken(output, cliToolId, message, composerSpec) {
+    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
+    if (composer.kind !== 'text')
+        return false;
+    if (!composer.rows.some((row) => (0, submit_composer_read_1.findPasteTokens)(row).tokens.length > 0))
+        return false;
+    return (0, submit_composer_read_1.classifyPasteLanded)(output, cliToolId, message, composerSpec) !== 'landed';
+}
+/**
+ * The part of a typed body the composer reader can see (Issue #3366).
+ *
+ * The codex reader takes the composer as one run of non-blank rows, so a blank
+ * line inside the body ends what it returns: what it can show is the body up to
+ * its first blank line after the first non-blank one. Leading blank lines are
+ * kept — they are drawn as composer rows of their own and compact to nothing.
+ */
+function visibleTypedBody(message) {
+    const lines = message.split('\n');
+    const first = lines.findIndex((line) => line.trim() !== '');
+    if (first < 0)
+        return '';
+    const blank = lines.findIndex((line, index) => index > first && line.trim() === '');
+    return lines.slice(0, blank < 0 ? lines.length : blank).join('\n');
+}
+/** Whether the whole codex composer, read past the bounded readers (Issue #3906), is exactly `message`. */
+function codexComposerShowsWholeBody(output, message, composerSpec) {
+    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, 'codex', composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
+    return composer.kind === 'text' && composer.region !== undefined && (0, submit_composer_read_1.compactText)(composer.region) === (0, submit_composer_read_1.compactText)(message);
+}
+/**
+ * Whether a verdict is one the agent's own report must back (Issue #4035):
+ * `submitted` from B or F — the screen saying only that the body is not in the
+ * composer. A (generating) stands on its own. A body starting with `/` or `!`
+ * is run by the TUI itself, which is not measured to report it as a prompt.
+ */
+function needsPromptReport(state, rule, message) {
+    if (state !== 'submitted' || rule === 'A')
+        return false;
+    return !/^\s*[/!]/.test(message);
+}