commandmate 0.49.2 → 0.49.3

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

@@ -17,7 +17,7 @@
  * [SEC4-001].
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopilotTool = exports.COPILOT_EXIT_COMMAND = void 0;
+exports.CopilotTool = exports.COPILOT_EXIT_COMMAND = exports.COPILOT_DIALOG_CONFIRM_MS = void 0;
 exports.isCopilotStartupLoading = isCopilotStartupLoading;
 exports.readCopilotModelSwitchOutcomes = readCopilotModelSwitchOutcomes;
 exports.judgeCopilotModelSwitch = judgeCopilotModelSwitch;
@@ -25,7 +25,10 @@ const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const composer_clear_1 = require("../../lib/session/composer-clear");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
+const prompt_wait_dialog_1 = require("./prompt-wait-dialog");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const status_detector_1 = require("../detection/status-detector");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const copilot_executable_1 = require("./copilot-executable");
 const copilot_constants_1 = require("../../config/copilot-constants");
@@ -46,6 +49,19 @@ const COPILOT_POLL_INTERVAL_MS = 1000;
 const COPILOT_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for prompt before sending a message */
 const COPILOT_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/**
+ * How long a dialog has to stay up in {@link CopilotTool.waitForPrompt} before
+ * the wait gives up on it (Issue #4067), on {@link PROMPT_WAIT_DIALOG_CONFIRM_READS}
+ * reads in a row.
+ *
+ * A dialog waits for a person, so waiting out the 15 s (or `/model`'s 30 s)
+ * window behind it only delays the refusal — and the picker and `/model` wait
+ * holding the instance's input lock, so Auto-Yes and other writers wait too.
+ * Both thresholds must hold, so a frame caught mid-paint that reads as a
+ * dialog once does not refuse a send. The count is shared with opencode's and
+ * vibe-local's waits (Issue #4084, {@link createDialogConfirmation}).
+ */
+exports.COPILOT_DIALOG_CONFIRM_MS = prompt_wait_dialog_1.PROMPT_WAIT_DIALOG_CONFIRM_MS;
 /**
  * Copilot CLI slash commands that open a picker.
  *
@@ -263,6 +279,36 @@ function describeBottomRow(output) {
     }
     return 'an empty pane';
 }
+/**
+ * Re-read the pane and throw `recheckComposerBeforeInput`'s `prompt-waiting`
+ * refusal when a dialog is open (Issue #4040). Any other outcome — no dialog,
+ * or a re-read that failed — returns, so the caller's own refusal stands.
+ */
+async function rethrowIfDialogOpen(sessionName) {
+    try {
+        await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
+    }
+    catch (error) {
+        if (error.code === send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE)
+            throw error;
+    }
+}
+/**
+ * Refuse as `prompt-waiting` after {@link CopilotTool.waitForPrompt} saw a
+ * dialog stay up for {@link COPILOT_DIALOG_CONFIRM_MS} (Issue #4067), with the
+ * re-check's `code` and the wording `classifySendFailure` reads as
+ * `prompt-waiting`. Nothing has been typed.
+ *
+ * Refused on the wait's own reads, without reading the pane once more: those
+ * reads already confirmed the dialog, and another capture (tmux's own time-out
+ * is 5 s) would keep the picker and `/model` holding the instance's input lock
+ * past the confirmation time (review of #4067).
+ */
+function refuseConfirmedDialog(sessionName) {
+    logger.warn('input-recheck-prompt-waiting', { sessionName, cliToolId: 'copilot', confirmedMs: exports.COPILOT_DIALOG_CONFIRM_MS });
+    throw Object.assign(new Error(`A prompt dialog stayed open in session ${sessionName} for ${exports.COPILOT_DIALOG_CONFIRM_MS}ms ` +
+        'while the copilot composer was awaited (re-checked under the input lock); nothing was typed (Issue #4067).'), { code: send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE });
+}
 /**
  * Copilot CLI tool implementation
  * Manages GitHub Copilot interactive sessions using tmux
@@ -548,17 +594,18 @@ class CopilotTool extends base_1.BaseCLITool {
      *   `❯` at column 0 while it is Working, the loop captures BEFORE its first
      *   sleep, and `COPILOT_PROMPT_PATTERN` matches immediately. A whole
      *   `sendMessage` measured 338 ms end to end, verification included.
-     * - **Composer gone — a dialog is up: the full 15 s, then it sends anyway.**
-     *   Measured against a session parked on copilot's own `Asked user …` question:
-     *   the window expired and the body was typed into the QUESTION's input line,
-     *   which is single-line, so a four-line message arrived as
-     *   `ping oneping twoping three…`.
+     * - **Composer gone — a dialog is up: the full 15 s.** Measured against a
+     *   session parked on copilot's own `Asked user …` question: until Issue #4040
+     *   the send then went ahead, and the body was typed into the QUESTION's input
+     *   line, which is single-line, so a four-line message arrived as
+     *   `ping oneping twoping three…`. Now the window expiring refuses the send.
      *
      * That second case is #559's objection, and it is real — but it is not a
      * reason to skip this method, because skipping it is what produced the same
-     * outcome in 0 ms instead of 15 s. What keeps it out of production is the layer
-     * above: `sendUserMessage` and the terminal route both consult
-     * `isPromptWaiting` (#1708/#1737) and refuse before reaching here.
+     * outcome in 0 ms instead of 15 s. The layer above refuses most dialogs
+     * first: `sendUserMessage` and the terminal route both consult
+     * `isPromptWaiting` (#1708/#1737), and the shared sender re-reads the pane
+     * under the input lock (#3945).
      *
      * Issue #2623 adds a third case, measured on 1.0.85: **composer on screen,
      * copilot still starting — until loading ends (3–4.5 s).** The composer is drawn
@@ -567,23 +614,44 @@ class CopilotTool extends base_1.BaseCLITool {
      * used to end this wait in 0 ms right there, which is how `send --model` on a
      * session it had just started typed a body that never ran.
      *
-     * Timing out still only logs and lets the send proceed, as before; the caller
-     * that must not proceed ({@link sendModelCommand}) reads the result.
+     * Timing out logs and returns `ready: false`; every caller reads it and types
+     * nothing then — the normal send since Issue #4040 (it used to drop the result
+     * and send anyway), the selection-list branch and {@link sendModelCommand}.
+     *
+     * Issue #4067: a dialog does not wait out the window. A frame the shared
+     * sender's re-check would refuse (`detectSessionStatus().hasActivePrompt`,
+     * {@link recheckComposerBeforeInput}) on {@link PROMPT_WAIT_DIALOG_CONFIRM_READS}
+     * reads in a row spanning {@link COPILOT_DIALOG_CONFIRM_MS} returns
+     * `ready: false, dialog: true`, and every caller refuses it as
+     * `prompt-waiting`. Not counted: the folder-trust dialog (answered above,
+     * #1886), and a frame with the composer drawn — `idle` waits through a
+     * Working turn, which keeps `❯` on screen, and that is not a dialog.
+     *
+     * Issue #4084: no capture is waited for past `timeoutMs` ({@link readBeforeDeadline}):
+     * one still running then, or one that answers after it, is not used.
      *
      * @param sessionName - tmux session name
      * @param timeoutMs - Optional timeout in ms (default: COPILOT_PROMPT_WAIT_TIMEOUT_MS)
      * @param until - What counts as ready (Issue #2623, default `composer`)
-     * @returns Whether the pane got there, and the last frame read (ANSI stripped)
+     * @returns Whether the pane got there, the last frame read (ANSI stripped),
+     *   and whether it gave up on a dialog (Issue #4067)
      */
     async waitForPrompt(sessionName, timeoutMs = COPILOT_PROMPT_WAIT_TIMEOUT_MS, until = 'composer') {
-        const startTime = Date.now();
+        // Issue #4084: one deadline for the whole wait — a capture still running at
+        // it is not waited for, and a frame it returns past it is not used.
+        const deadline = Date.now() + timeoutMs;
         const pollInterval = 500;
         let trustDialogHandled = false;
         let output = '';
-        while (Date.now() - startTime < timeoutMs) {
+        // Issue #4067: the current run of reads that showed a dialog (counted by
+        // the helper opencode and vibe-local share, Issue #4084).
+        const dialog = (0, prompt_wait_dialog_1.createDialogConfirmation)();
+        while (Date.now() < deadline) {
             try {
                 const readMark = (0, instance_input_lock_1.instanceInputReadMark)();
-                const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
+                const rawOutput = await (0, prompt_wait_dialog_1.readBeforeDeadline)(() => (0, tmux_1.capturePane)(sessionName, 50), deadline);
+                if (rawOutput === null)
+                    break;
                 output = (0, cli_patterns_1.stripAnsi)(rawOutput);
                 if (this.isReadyFor(until, output)) {
                     return { ready: true, output };
@@ -591,20 +659,28 @@ class CopilotTool extends base_1.BaseCLITool {
                 // Issue #1886: `startSession` returns early for a session that already
                 // exists, so a pane adopted from outside CommandMate -- or one whose
                 // trust dialog nobody answered -- arrives here still sitting on it.
-                // Unlike codex's, this method only logs on timeout and lets the send
-                // proceed, which types the message body INTO the dialog; the body's
-                // digits are option selections there, so a message containing `2` picks
-                // "Yes, and remember this folder" and writes the operator's
-                // machine-global ~/.copilot/config.json. Answer it here for the same
-                // reason the launch path does, rather than leaving the worse outcome.
+                // Until Issue #4040 the normal send went ahead on a timeout, which
+                // typed the message body INTO the dialog; the body's digits are option
+                // selections there, so a message containing `2` picks "Yes, and
+                // remember this folder" and writes the operator's machine-global
+                // ~/.copilot/config.json. The send now refuses instead, but answering
+                // it here (as the launch path does) is what lets that send go through.
                 if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark))) {
                     trustDialogHandled = true;
                 }
+                if (dialog.observe(this.isRefusableDialog(rawOutput, output))) {
+                    logger.info('copilot-prompt-wait-dialog', { until, reads: dialog.reads, bottomRow: describeBottomRow(output) });
+                    return { ready: false, output, dialog: true };
+                }
             }
             catch {
-                // Capture may fail - continue polling
+                // Capture may fail - continue polling. Not a dialog read: the run restarts.
+                dialog.reset();
             }
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(pollInterval, remaining)));
         }
         logger.info('copilot-prompt-not-detected', { until, bottomRow: describeBottomRow(output) });
         return { ready: false, output };
@@ -620,6 +696,32 @@ class CopilotTool extends base_1.BaseCLITool {
      * @param until - What counts as ready
      * @param output - ANSI-stripped pane capture
      */
+    /**
+     * {@link isReadyFor}`('composer')` for the shared sender's read under the
+     * input lock (Issue #4040). Not `idle`: copilot draws `❯` while Working and
+     * takes a body then, as it always has.
+     */
+    inputReadiness = {
+        label: 'copilot',
+        isReady: (frame) => this.isReadyFor('composer', (0, cli_patterns_1.stripAnsi)(frame)),
+    };
+    /**
+     * Whether {@link waitForPrompt} counts this frame towards giving up on a
+     * dialog (Issue #4067): the shared sender's re-check would refuse it
+     * (`hasActivePrompt`), it is not the folder-trust dialog `waitForPrompt`
+     * answers itself (#1886), and no composer is drawn — a Working turn keeps
+     * `❯` up and is waited through, not refused.
+     *
+     * @param rawOutput - The capture as read (ANSI allowed), for the detector
+     * @param output - The same capture, ANSI stripped
+     */
+    isRefusableDialog(rawOutput, output) {
+        if ((0, cli_patterns_1.isCopilotFolderTrustDialog)(output))
+            return false;
+        if (this.isReadyFor('composer', output))
+            return false;
+        return (0, status_detector_1.detectSessionStatus)(rawOutput, 'copilot').hasActivePrompt;
+    }
     isReadyFor(until, output) {
         if (!cli_patterns_1.COPILOT_PROMPT_PATTERN.test(output))
             return false;
@@ -700,6 +802,10 @@ class CopilotTool extends base_1.BaseCLITool {
                     // then refuses on the same terms right before the keys: a dialog is
                     // `prompt-waiting`, a pane that cannot be read `recheck-failed`.
                     const prompt = await this.waitForPrompt(sessionName);
+                    // Issue #4067: a dialog that stayed up is refused at once — the lock
+                    // is not held for the rest of the window behind it.
+                    if (prompt.dialog)
+                        refuseConfirmedDialog(sessionName);
                     await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
                     if (!prompt.ready) {
                         // review-3: neither the request nor the pane goes into the message.
@@ -723,8 +829,25 @@ class CopilotTool extends base_1.BaseCLITool {
                 logger.info('sent-selection-list-command-to-copilot', { command: slashCmd });
                 return;
             }
-            // Verify Copilot is at prompt state before sending
-            await this.waitForPrompt(sessionName);
+            // Verify Copilot is at prompt state before sending. Issue #4040: a
+            // composer that never came up is not typed into — refused as the
+            // selection-list branch refuses (review-3: neither the body nor the pane
+            // goes into the message, which `classifySendFailure` reads).
+            const prompt = await this.waitForPrompt(sessionName);
+            if (!prompt.ready) {
+                // Issue #4067: the wait gave up on a dialog after its confirmation time
+                // rather than the whole 15 s window.
+                if (prompt.dialog)
+                    refuseConfirmedDialog(sessionName);
+                // A dialog that opened during the wait and is still up is refused as
+                // the shared sender's re-check refuses it — `prompt-waiting` (409
+                // PROMPT_WAITING), not `prompt-not-ready`. A re-read that fails is
+                // left to the refusal below.
+                await rethrowIfDialogOpen(sessionName);
+                logger.warn('copilot-message-not-sent:prompt-not-ready', { bottomRow: describeBottomRow(prompt.output) });
+                throw new Error(`copilot prompt not ready within ${COPILOT_PROMPT_WAIT_TIMEOUT_MS}ms, ` +
+                    'so the message was not sent; nothing was typed');
+            }
             // Issue #1471: Body/Enter separation + read-back submit verification via the
             // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
             // Copilot's own text-input / post-Enter delays are preserved. The selection
@@ -736,6 +859,8 @@ class CopilotTool extends base_1.BaseCLITool {
                 composer: this.describeComposer(),
                 textInputWaitMs: copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS,
                 verifyDelayMs: copilot_constants_1.COPILOT_SEND_ENTER_DELAY_MS,
+                // Issue #4040: the same test, of the newest frame read under the lock.
+                readiness: this.inputReadiness,
             });
             // Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -822,6 +947,10 @@ class CopilotTool extends base_1.BaseCLITool {
         await (0, instance_input_lock_1.waitOutCarriedPasteMark)(ticket);
         const idle = await this.waitForPrompt(sessionName, copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS, 'idle');
         if (!idle.ready) {
+            // Issue #4067: a dialog is refused after its confirmation time, not after
+            // the 30 s window under the lock.
+            if (idle.dialog)
+                refuseConfirmedDialog(sessionName);
             // The pane's text goes to the log, not the message: the message is read by
             // `classifySendFailure`, which a screen quoting its keywords would steer (#3954).
             logger.warn('copilot-model-switch-not-idle', { model: modelName, bottomRow: describeBottomRow(idle.output) });

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).
  *
@@ -498,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;
     }
     /**
@@ -655,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
@@ -671,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)({
@@ -686,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);
@@ -693,10 +752,97 @@ class OpenCodeTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
+            // 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).
      *
@@ -724,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
@@ -739,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 });
+}