commandmate 0.49.0 → 0.49.2

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

@@ -24,6 +24,7 @@ exports.judgeCopilotModelSwitch = judgeCopilotModelSwitch;
 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 tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const copilot_executable_1 = require("./copilot-executable");
@@ -37,6 +38,7 @@ const logger_1 = require("../../lib/logger");
 const install_hints_1 = require("./install-hints");
 const launch_window_1 = require("./launch-window");
 const launch_screen_1 = require("../../lib/session/launch-screen");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const logger = (0, logger_1.createLogger)('cli-tools/copilot');
 /** Interval for polling prompt detection */
 const COPILOT_POLL_INTERVAL_MS = 1000;
@@ -224,6 +226,33 @@ function judgeCopilotModelSwitch(before, output, modelName) {
     return { kind: 'pending' };
 }
 /** The pane's bottom non-blank row, squeezed, for an error message a person reads. */
+/**
+ * Throw unless `ticket` still owns the composer (Issue #3945): right before a
+ * key this module types itself, so a send whose session was replaced while it
+ * waited cannot type into the new one.
+ */
+function assertCopilotInputOwner(ticket, step) {
+    if (ticket.isCurrent())
+        return;
+    throw new Error(`Session ${ticket.sessionName} was handed to another writer before ${step}; input lock lost, nothing was typed (Issue #3945).`);
+}
+/**
+ * Type `text` + Enter as the composer's owner. A failure that may have put part
+ * of it on the pane (anything but a `send-keys` tmux never started,
+ * `TmuxSendError.delivery`) leaves the carried paste mark, as the shared
+ * sender's typed body does (review-2): the next send waits out what may still
+ * be drawn.
+ */
+async function typeLeavingMarkOnFailure(sessionName, text, ticket) {
+    try {
+        await (0, tmux_1.sendKeys)(sessionName, text, true);
+    }
+    catch (error) {
+        if (error?.delivery !== 'not-started')
+            (0, instance_input_lock_1.leaveCarriedPasteMark)(ticket);
+        throw error;
+    }
+}
 function describeBottomRow(output) {
     const lines = (0, cli_patterns_1.stripAnsi)(output).split('\n');
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -351,8 +380,9 @@ class CopilotTool extends base_1.BaseCLITool {
             // leaves it (`cli-tools/launch-window`).
             (0, launch_window_1.beginLaunchWindow)(sessionName);
             try {
-                // Start Copilot CLI in interactive mode
-                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Start Copilot CLI in interactive mode. 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 #1907: no blind sleep before this. The 4-second one that used to
                 // sit here was a guess at how long copilot takes to paint (measured on
                 // 1.0.80: banner at ~1.3 s, folder-trust dialog at ~2.5 s), and it was
@@ -397,15 +427,25 @@ class CopilotTool extends base_1.BaseCLITool {
      * `waiting`, and the send guard refuses a `waiting` session for as long as
      * that entry lives.
      *
+     * Issue #3952: the digit is typed as the composer's writer. A send that holds
+     * the composer is waited out, and the dialog is read again after it: when it
+     * is gone nothing is typed and false comes back, so the caller looks again on
+     * its next poll. Inside the selection-list branch's lock it joins that lock.
+     *
      * @param sessionName - tmux session name
      * @param output - ANSI-stripped pane capture
+     * @param readMark - {@link instanceInputReadMark} taken before `output` was read
      * @returns True when the dialog was found and answered
      */
-    async answerFolderTrustDialog(sessionName, output) {
+    async answerFolderTrustDialog(sessionName, output, readMark) {
         if (!(0, cli_patterns_1.isCopilotFolderTrustDialog)(output)) {
             return false;
         }
-        await (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false);
+        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => (0, cli_patterns_1.isCopilotFolderTrustDialog)((0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, 50))), () => (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false));
+        if (!outcome.answered) {
+            logger.info('copilot-folder-trust-answer-skipped', { reason: outcome.reason });
+            return false;
+        }
         (0, launch_window_1.recordLaunchDialogPress)(sessionName);
         (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         logger.info('copilot-folder-trust-answered');
@@ -477,6 +517,7 @@ class CopilotTool extends base_1.BaseCLITool {
         let trustDialogHandled = false;
         for (let i = 0; i < COPILOT_INIT_MAX_ATTEMPTS; i++) {
             try {
+                const readMark = (0, instance_input_lock_1.instanceInputReadMark)();
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
                 // Check if copilot's own composer is on screen
@@ -484,7 +525,7 @@ class CopilotTool extends base_1.BaseCLITool {
                     logger.info('copilot-prompt-detected');
                     return;
                 }
-                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output))) {
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark))) {
                     trustDialogHandled = true;
                 }
             }
@@ -541,6 +582,7 @@ class CopilotTool extends base_1.BaseCLITool {
         let output = '';
         while (Date.now() - startTime < timeoutMs) {
             try {
+                const readMark = (0, instance_input_lock_1.instanceInputReadMark)();
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 output = (0, cli_patterns_1.stripAnsi)(rawOutput);
                 if (this.isReadyFor(until, output)) {
@@ -555,7 +597,7 @@ class CopilotTool extends base_1.BaseCLITool {
                 // "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.
-                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output))) {
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark))) {
                     trustDialogHandled = true;
                 }
             }
@@ -641,19 +683,48 @@ class CopilotTool extends base_1.BaseCLITool {
         // same pane when the tool is gone; costs one `capture-pane` when it is not.
         await this.requireSession('Copilot', worktreeId, instanceId, { relaunch: true });
         try {
-            // Verify Copilot is at prompt state before sending
-            await this.waitForPrompt(sessionName);
             // Check if this is a slash command that triggers a selection list
             const slashCmd = this.extractSlashCommand(message);
             if (slashCmd && SELECTION_LIST_COMMANDS.has(slashCmd)) {
                 // For selection list commands: send text + Enter, then wait for
                 // the selection list to appear. Do NOT send additional input after.
-                await (0, tmux_1.sendKeys)(sessionName, message, true);
-                await this.waitForSelectionList(sessionName);
+                //
+                // Issue #3945: this types into the composer without the shared sender,
+                // so it takes the instance's input lock itself — from the readiness
+                // read (fresh, under the lock) to the picker that answers it — and
+                // waits out a carried paste mark first, as a normal send does.
+                await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, async (ticket) => {
+                    await (0, instance_input_lock_1.waitOutCarriedPasteMark)(ticket);
+                    // review-2: a composer that never came up (a dialog, an unreadable
+                    // pane, a time-out) is not typed into. The shared sender's re-check
+                    // 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);
+                    await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
+                    if (!prompt.ready) {
+                        // review-3: neither the request nor the pane goes into the message.
+                        // `classifySendFailure` reads the wording, and its "may have been
+                        // typed" rules come first — a body or a screen saying `submit could
+                        // not be confirmed` would turn this refusal into `indeterminate`.
+                        logger.warn('copilot-selection-list-not-sent:prompt-not-ready', {
+                            command: slashCmd,
+                            bottomRow: describeBottomRow(prompt.output),
+                        });
+                        throw new Error(`copilot prompt not ready within ${COPILOT_PROMPT_WAIT_TIMEOUT_MS}ms, ` +
+                            'so the selection-list command was not sent; nothing was typed');
+                    }
+                    assertCopilotInputOwner(ticket, 'the selection-list command');
+                    // Issue #3953: the send's stamp, as the shared sender takes it.
+                    (0, instance_input_lock_1.noteInputStart)();
+                    await typeLeavingMarkOnFailure(sessionName, message, ticket);
+                    await this.waitForSelectionList(sessionName);
+                });
                 (0, tmux_capture_cache_1.invalidateCache)(sessionName);
                 logger.info('sent-selection-list-command-to-copilot', { command: slashCmd });
                 return;
             }
+            // Verify Copilot is at prompt state before sending
+            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).
             // Copilot's own text-input / post-Enter delays are preserved. The selection
@@ -672,7 +743,8 @@ class CopilotTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to Copilot: ${errorMessage}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to Copilot: ${errorMessage}`, { cause: error });
         }
     }
     /**
@@ -731,32 +803,52 @@ class CopilotTool extends base_1.BaseCLITool {
         const sessionName = this.getSessionName(worktreeId, instanceId);
         await this.requireSession('Copilot', worktreeId, instanceId, { relaunch: false });
         try {
-            const idle = await this.waitForPrompt(sessionName, copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS, 'idle');
-            if (!idle.ready) {
-                throw new Error(`copilot did not become idle within ${copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS}ms, so /model was not sent ` +
-                    `(bottom row: ${describeBottomRow(idle.output)})`);
-            }
-            const before = readCopilotModelSwitchOutcomes(idle.output, modelName);
-            // Send /model <modelName> command with Enter. An argument means an
-            // in-place switch, never a picker (Issue #1895).
-            await (0, tmux_1.sendKeys)(sessionName, `/model ${modelName}`, true);
-            const verdict = await this.waitForModelSwitchOutcome(sessionName, modelName, before);
-            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            if (verdict.kind === 'rejected') {
-                logger.warn('copilot-model-rejected', { model: modelName, reason: verdict.reason });
-                throw new Error(`copilot refused it: ${verdict.reason}`);
-            }
-            if (verdict.kind === 'pending') {
-                logger.warn('copilot-model-switch-unconfirmed', { model: modelName, bottomRow: verdict.bottomRow });
-                throw new Error(`copilot printed no answer to /model within ${copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS}ms ` +
-                    `(bottom row: ${verdict.bottomRow}); the switch may still take effect, and nothing further was typed`);
-            }
-            logger.info('copilot-model-switched', { model: modelName });
+            // Issue #3945: `/model` is typed into the composer, so it is one writer's
+            // turn like the selection-list branch — from the idle read to the answer.
+            await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, (ticket) => this.switchModelUnderInputLock(sessionName, modelName, ticket));
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to switch Copilot model to ${modelName}: ${errorMessage}`);
+            // Issue #3952: the re-check's `code` is kept, so the caller records a
+            // dialog or an unreadable pane as such rather than as a refused model.
+            const code = error?.code;
+            throw Object.assign(new Error(`Failed to switch Copilot model to ${modelName}: ${errorMessage}`), typeof code === 'string' ? { code } : {});
+        }
+    }
+    /** {@link sendModelCommand}'s keys and waits, as the composer's only writer (Issue #3945). */
+    async switchModelUnderInputLock(sessionName, modelName, ticket) {
+        // A previous send's body may still arrive (review-1 #5): `/model` waits it
+        // out like a normal send, and the idle read below is the one after the wait.
+        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) {
+            // 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) });
+            throw new Error(`copilot did not become idle within ${copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS}ms, so /model was not sent`);
+        }
+        const before = readCopilotModelSwitchOutcomes(idle.output, modelName);
+        // Issue #3952: "idle, so no dialog" holds for the frame that was read, not
+        // for the moment the keys go out. The pane is read once more right before
+        // them, as every send is: a dialog is `prompt-waiting`, a pane that cannot
+        // be read `recheck-failed`, and nothing is typed in either case.
+        await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
+        // Send /model <modelName> command with Enter. An argument means an
+        // in-place switch, never a picker (Issue #1895).
+        assertCopilotInputOwner(ticket, '/model');
+        await typeLeavingMarkOnFailure(sessionName, `/model ${modelName}`, ticket);
+        const verdict = await this.waitForModelSwitchOutcome(sessionName, modelName, before);
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+        if (verdict.kind === 'rejected') {
+            logger.warn('copilot-model-rejected', { model: modelName, reason: verdict.reason });
+            throw new Error(`copilot refused it: ${verdict.reason}`);
+        }
+        if (verdict.kind === 'pending') {
+            logger.warn('copilot-model-switch-unconfirmed', { model: modelName, bottomRow: verdict.bottomRow });
+            throw new Error(`copilot printed no answer to /model within ${copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS}ms; ` +
+                'the switch may still take effect, and nothing further was typed');
         }
+        logger.info('copilot-model-switched', { model: modelName });
     }
     /**
      * Poll until `/model <modelName>` has answered (Issue #2623).

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

@@ -25,6 +25,7 @@ const launch_screen_1 = require("../../lib/session/launch-screen");
 const errors_1 = require("../../lib/errors");
 const launch_dialog_1 = require("./launch-dialog");
 const launch_window_1 = require("./launch-window");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
 /** Wait for Gemini CLI to initialize after launch (banner + auth + dialog) */
 const GEMINI_INIT_WAIT_MS = 6000;
@@ -106,7 +107,12 @@ class GeminiTool extends base_1.BaseCLITool {
             // trust dialog is this launch's to answer; the Auto-Yes poller leaves it.
             (0, launch_window_1.beginLaunchWindow)(sessionName);
             try {
-                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Issue #3975: the launch line is one writer's turn, so a send's body
+                // already in the pane is not run as part of it. Only the keys: the
+                // waits below stay outside the lock, where a send waiting for the
+                // prompt cannot be held behind them.
+                // Issue #3981: through the one launch-key writer every tool shares.
+                await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
                 // Wait for Gemini to initialize (minimum wait for banner/auth)
                 await new Promise((resolve) => setTimeout(resolve, GEMINI_INIT_WAIT_MS));
                 // Poll until Gemini interactive prompt is ready
@@ -139,6 +145,8 @@ class GeminiTool extends base_1.BaseCLITool {
         const loggedDecisions = new Set();
         for (let i = 0; i < GEMINI_INIT_MAX_ATTEMPTS; i++) {
             try {
+                // Issue #3975: taken before the read the trust Enter is decided on.
+                const readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)();
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT);
                 // Strip ANSI escape codes before pattern matching
                 // (Gemini TUI uses 24-bit color codes that break regex matching)
@@ -152,14 +160,26 @@ class GeminiTool extends base_1.BaseCLITool {
                 if (!trustDialogHandled) {
                     const decision = (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, output);
                     if (decision.action === 'press') {
-                        await (0, tmux_1.sendSpecialKey)(sessionName, decision.key);
-                        trustDialogHandled = true;
-                        trustPressedAt = Date.now();
-                        // Issue #3790: the poller leaves the answered dialog alone even if
-                        // the window closes before gemini redraws it.
-                        (0, launch_window_1.recordLaunchDialogPress)(sessionName, trustPressedAt);
-                        logger.info('auto-trusted-folder-for-gemini');
-                        // Continue polling for prompt after trust dialog
+                        // Issue #3975: the Enter as an `exclusive` writer, so it never lands
+                        // inside a send's body, paste or Enter; a send that came between
+                        // the read and the lock makes the dialog be read again first.
+                        const pressed = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => {
+                            const again = (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT)));
+                            return again.action === 'press' && again.key === decision.key;
+                        }, () => (0, tmux_1.sendSpecialKey)(sessionName, decision.key), { mode: 'exclusive' });
+                        if (pressed.answered) {
+                            trustDialogHandled = true;
+                            trustPressedAt = Date.now();
+                            // Issue #3790: the poller leaves the answered dialog alone even if
+                            // the window closes before gemini redraws it.
+                            (0, launch_window_1.recordLaunchDialogPress)(sessionName, trustPressedAt);
+                            logger.info('auto-trusted-folder-for-gemini');
+                            // Continue polling for prompt after trust dialog
+                        }
+                        else {
+                            // Not answered this poll; the next one reads the screen again.
+                            logger.info('gemini-trust-answer-skipped', { sessionName, reason: pressed.reason });
+                        }
                     }
                     else {
                         const warning = (0, launch_dialog_1.launchDialogWarning)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, decision);
@@ -188,6 +208,9 @@ class GeminiTool extends base_1.BaseCLITool {
     /**
      * Wait for Gemini prompt before sending a message.
      * Used by sendMessage to ensure Gemini is ready to accept input.
+     *
+     * @throws Error (`Gemini prompt not ready`) when the prompt did not appear
+     *   within {@link GEMINI_PROMPT_WAIT_TIMEOUT_MS}; nothing was typed
      */
     async waitForPrompt(sessionName) {
         const startTime = Date.now();
@@ -206,7 +229,10 @@ class GeminiTool extends base_1.BaseCLITool {
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
+        // Issue #3981: give up without typing, as codex does. Sending anyway put the
+        // body into whatever held the pane (a dialog, a slow start, a shell).
         logger.info('gemini-prompt-not-detected');
+        throw new Error('Gemini prompt not ready: timed out waiting for the input prompt before sending');
     }
     /**
      * Send a message to Gemini interactive session
@@ -239,7 +265,8 @@ class GeminiTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to Gemini: ${errorMessage}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to Gemini: ${errorMessage}`, { cause: error });
         }
     }
     /**

package/dist/server/src/lib/cli-tools/launch-keys.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * The keys a launch types into its pane, in one writer's turn (Issue #3981).
+ *
+ * #3975 put gemini's and claude's launch lines under the instance input lock;
+ * the other seven launch sites, and claude's `unset CLAUDECODE` before its
+ * line, still typed with no lock, so a send holding the composer could have
+ * them land in the middle of its body, paste or Enter. Every launch now types
+ * through {@link typeLaunchLines}: one `exclusive` turn for all of its lines
+ * (R2 of `session-launch-flight`), joined when the launcher already holds the
+ * lock (codex relaunching inside a send). The init polls and readiness waits
+ * that follow stay outside (#3975), so a send waiting for the prompt is never
+ * held behind them.
+ *
+ * @module lib/cli-tools/launch-keys
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeLaunchLines = typeLaunchLines;
+const tmux_1 = require("../tmux/tmux");
+const instance_input_lock_1 = require("../session/instance-input-lock");
+/**
+ * Type `steps` into `sessionName` as one `exclusive` writer, in order.
+ *
+ * @param sessionName - tmux session name
+ * @param steps - Lines (typed with Enter) and self-typing steps
+ * @throws Whatever `withInstanceInputLock` throws when not admitted; nothing was typed then
+ */
+async function typeLaunchLines(sessionName, steps) {
+    await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, async () => {
+        for (const step of steps) {
+            if (typeof step === 'string') {
+                await (0, tmux_1.sendKeys)(sessionName, step, true);
+            }
+            else {
+                await step();
+            }
+        }
+    });
+}

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

@@ -235,7 +235,10 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
             if (port === null) {
                 logger.warn('opencode-v2-launch-without-server', { worktreeId, instanceId });
             }
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)((0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({ target, executablePath: executable.path, worktreePath })), true);
+            // Issue #3981: in one writer's turn of the input lock; the readiness
+            // wait below stays outside it.
+            const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({ target, executablePath: executable.path, worktreePath });
+            await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
             await this.waitForReady(sessionName);
             await (0, runtime_1.attachOpencodeV2EventStream)(target);
             logger.info('started-opencode-v2-session');
@@ -313,7 +316,8 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
             logger.info('sent-message-to-opencode-v2-session');
         }
         catch (error) {
-            throw new Error(`Failed to send message to OpenCode V2: ${(0, errors_1.getErrorMessage)(error)}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to OpenCode V2: ${(0, errors_1.getErrorMessage)(error)}`, { cause: error });
         }
     }
     /**

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

@@ -78,6 +78,7 @@ const opencode_executable_1 = require("./opencode-executable");
 const log_diagnosis_1 = require("../../lib/hooks/sources/opencode/log-diagnosis");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const errors_1 = require("../../lib/errors");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /** OpenCode TUI graceful exit command [D1-006] */
@@ -334,7 +335,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
@@ -478,17 +481,42 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * and it is logged as `opencode-send-unverified` so it is visible rather than
      * inferred.
      *
+     * ## Issue #3957: the dispatch boundary
+     *
+     * This path types no key, so it reports no input start. Right before the
+     * POST it notes a `dispatch` boundary instead (`noteDispatchStart`), which a
+     * relay-bound send records as its lower bound — and which can refuse, in
+     * which case nothing is posted and the refusal propagates past the catch
+     * below. When the POST does not end delivered, the caller is told whether
+     * nothing exists (`not_sent`: a POST the server refused — Issue #3992 — or a
+     * `404` on the read-back) or it cannot be said (`unknown`: a POST that got no
+     * answer or an unexpected 2xx, a body that read back different, an exhausted
+     * ladder), BEFORE the keyboard fallback runs.
+     *
      * @param target - The instance
      * @param message - The body, sent verbatim
      * @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) {
+        const outcome = await this.dispatchViaServer(target, message, imagePath);
+        if (outcome === 'delivered')
+            return true;
+        if (outcome !== 'skipped')
+            (0, instance_input_lock_1.noteDispatchFailed)(outcome);
+        return false;
+    }
+    /**
+     * {@link trySendViaServer}'s body, telling apart a route that was never tried
+     * (`skipped`) from a dispatch that did not deliver (Issue #3957).
+     */
+    async dispatchViaServer(target, message, imagePath) {
         const instanceId = target.instanceId ?? target.cliToolId;
+        let dispatched = false;
         try {
             const port = (0, ports_1.getAssignedOpencodePort)(target);
             if (port === null)
-                return false;
+                return 'skipped';
             // The same three preconditions the abort path checks (#2034): a port with
             // a live subscription behind it, and a session this instance owns. The
             // liveness check is what keeps a squatter on a remembered port from being
@@ -501,7 +529,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     port,
                     liveness: liveness.state,
                 });
-                return false;
+                return 'skipped';
             }
             // Null on a pane that has not run a turn yet — the gate learns the session
             // from the first frame that names it. That first send goes over the
@@ -513,7 +541,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     instanceId,
                     port,
                 });
-                return false;
+                return 'skipped';
             }
             const parts = [{ type: 'text', text: message }];
             if (imagePath !== undefined) {
@@ -535,10 +563,20 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // §20.5). Null when nothing is configured, and the request body is then
             // byte-identical to the pre-#2048 one.
             const selection = (0, launch_settings_1.opencodePromptSelection)((0, launch_settings_1.getOpencodeLaunchSettings)(target));
-            if (!(await (0, client_1.sendOpencodePrompt)(port, sessionId, messageId, parts, selection)))
-                return false;
+            // Issue #3957: the boundary, right before the POST. A refusal throws and
+            // nothing is posted.
+            (0, instance_input_lock_1.noteDispatchStart)();
+            dispatched = true;
+            // Issue #3992: a POST the server refused (a non-2xx, an unknown route's
+            // `200 text/html`) sent nothing. One that got no answer, or an unexpected
+            // 2xx, may still have created the message, so it stays unknown.
+            const dispatch = await (0, client_1.sendOpencodePrompt)(port, sessionId, messageId, parts, selection);
+            if (dispatch === 'rejected')
+                return 'not_sent';
+            if (dispatch === 'unknown')
+                return 'unknown';
             const verified = await this.verifyPostedMessage(port, sessionId, messageId, message);
-            if (!verified) {
+            if (verified !== 'found') {
                 logger.warn('opencode-send-unverified', {
                     worktreeId: target.worktreeId,
                     instanceId,
@@ -547,7 +585,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     messageId,
                     hasImage: imagePath !== undefined,
                 });
-                return false;
+                return verified === 'missing' ? 'not_sent' : 'unknown';
             }
             logger.info('opencode-send-delivered-via-api', {
                 worktreeId: target.worktreeId,
@@ -557,9 +595,13 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 messageId,
                 hasImage: imagePath !== undefined,
             });
-            return true;
+            return 'delivered';
         }
         catch (error) {
+            // Issue #3957: the relay refused the boundary — nothing was posted, and
+            // nothing may be typed either.
+            if ((0, instance_input_lock_1.isInputBoundaryRefusal)(error))
+                throw error;
             // Nothing above is allowed to take the send down: the keystroke route is
             // still there and is what runs when this answers false.
             logger.warn('opencode-send-api-failed', {
@@ -567,7 +609,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 instanceId,
                 error: (0, errors_1.getErrorMessage)(error),
             });
-            return false;
+            return dispatched ? 'unknown' : 'skipped';
         }
     }
     /**
@@ -581,7 +623,9 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * — so the check is that the sent body is *among* the text parts, not that it
      * is the only one.
      *
-     * @returns True once the body was found; false on a `404` or after the ladder
+     * @returns `found` once the body was found; `missing` on a `404`; `mismatch`
+     *   when a message exists under the id with other text; `unknown` after the
+     *   ladder (Issue #3957 tells the last three apart)
      */
     async verifyPostedMessage(port, sessionId, messageId, message) {
         for (const waitMs of exports.OPENCODE_SEND_READBACK_DELAYS_MS) {
@@ -589,14 +633,14 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 await new Promise((resolve) => setTimeout(resolve, waitMs));
             const readback = await (0, client_1.readOpencodeUserMessage)(port, sessionId, messageId);
             if (readback.kind === 'found')
-                return readback.texts.includes(message);
+                return readback.texts.includes(message) ? 'found' : 'mismatch';
             // A `404` is the server saying the message does not exist, which does not
             // become truer by asking again — the measured cause is a part the server
             // could not resolve, and it discards the whole message when that happens.
             if (readback.kind === 'missing')
-                return false;
+                return 'missing';
         }
-        return false;
+        return 'unknown';
     }
     /**
      * Send a message to OpenCode interactive session
@@ -649,7 +693,8 @@ 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 #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to OpenCode: ${errorMessage}`, { cause: error });
         }
     }
     /**

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);