commandmate 0.49.1 → 0.49.2

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

@@ -31,6 +31,8 @@ const terminal_keys_1 = require("../../types/terminal-keys");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
 const session_starting_state_1 = require("../session/session-starting-state");
+const session_launch_flight_1 = require("../session/session-launch-flight");
+const launch_keys_1 = require("./launch-keys");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 const logger = (0, logger_1.createLogger)('cli-tools/base');
 /**
@@ -221,6 +223,27 @@ class BaseCLITool {
      * @throws Whatever {@link launchSession} threw — unchanged, after reporting
      */
     async startSession(worktreeId, worktreePath, instanceId, model) {
+        // Issue #3981: one launch per session (`session-launch-flight`). A second
+        // request joins the launch in progress instead of starting its own — whose
+        // reuse branch would kill the first one's half-launched pane — and a caller
+        // that holds the input lock is refused rather than made to wait (R1). A
+        // name that does not validate is left to `launchSession` to refuse, and
+        // reported as before. A start that asks for a model the launch in
+        // progress is not starting with is refused instead of joining it (#2771).
+        let sessionName = null;
+        try {
+            sessionName = this.getSessionName(worktreeId, instanceId);
+        }
+        catch {
+            // fall through: launchSession throws on it, inside the reporting below
+        }
+        const launch = () => this.startSessionOnce(worktreeId, worktreePath, instanceId, model);
+        if (sessionName === null)
+            return launch();
+        return (0, session_launch_flight_1.runSessionLaunch)(sessionName, this.name, launch, { cliToolId: this.id, model });
+    }
+    /** {@link startSession}'s body: one launch, its failure reported once. */
+    async startSessionOnce(worktreeId, worktreePath, instanceId, model) {
         // Issue #3195: this launch's "starting" record is written under this token
         // (see `session-starting-state`), so the `finally` below clears this
         // launch's record and never a later launch's of the same instance.
@@ -615,6 +638,11 @@ class BaseCLITool {
      */
     async requireSession(label, worktreeId, instanceId, options) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
+        // Issue #3981: a pane another request is still launching reads as
+        // "exists, tool not live" and would be relaunched or typed into. Wait for
+        // that launch first — or, holding the input lock (claude and codex send
+        // under it), refuse with nothing typed (R1).
+        await (0, session_launch_flight_1.settleSessionLaunch)(sessionName, this.name);
         const exists = await (0, tmux_1.hasSession)(sessionName);
         if (!exists) {
             throw new Error(`${label} session ${sessionName} does not exist. Start the session first.`);
@@ -683,6 +711,17 @@ class BaseCLITool {
         }
         return { sessionName, exists, live: false };
     }
+    /**
+     * Type a launch's keys — its launch line, and anything that has to go in
+     * before it — in one `exclusive` turn of the instance input lock (Issue
+     * #3981, `./launch-keys`). The waits after the keys stay outside the lock.
+     *
+     * @param sessionName - tmux session name
+     * @param steps - Lines typed with Enter, or steps that type their own keys
+     */
+    async typeLaunchLines(sessionName, steps) {
+        await (0, launch_keys_1.typeLaunchLines)(sessionName, steps);
+    }
     /**
      * Create the tmux session a launch types into, then wait
      * {@link TUI_SESSION_CREATE_WAIT_MS} for it. Creation path only: on the #2070

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

@@ -244,11 +244,13 @@ class CodexTool extends base_1.BaseCLITool {
             // as the new one's.
             const relaunchIntoSamePane = async () => {
                 (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: sources_1.CODEX_CLI_TOOL_ID, instanceId });
-                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Issue #3981: one writer's turn, as the first launch line below.
+                await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
                 await new Promise((resolve) => setTimeout(resolve, CODEX_INIT_WAIT_MS));
             };
-            // Start Codex CLI in interactive mode
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+            // Start Codex CLI in interactive mode. Issue #3981: in one writer's turn
+            // of the input lock (joined when this launch runs inside a send's).
+            await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
             // Wait for Codex to initialize
             await new Promise((resolve) => setTimeout(resolve, CODEX_INIT_WAIT_MS));
             // Poll until Codex interactive prompt is ready
@@ -771,7 +773,8 @@ class CodexTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to Codex: ${errorMessage}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to Codex: ${errorMessage}`, { cause: error });
         }
     }
     /**

package/dist/server/src/lib/cli-tools/command-code.js

@@ -238,11 +238,14 @@ class CommandCodeTool extends base_1.BaseCLITool {
                 // shared TMUX_HISTORY_LIMIT default (Issue #1624).
                 await this.createLaunchPane(sessionName, worktreePath);
             }
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(buildCommandCodeLaunchCommand({
+            // Issue #3981: in one writer's turn of the input lock; the readiness
+            // wait below stays outside it.
+            const launchCommand = buildCommandCodeLaunchCommand({
                 target: { worktreeId, cliToolId: tool_id_1.COMMAND_CODE_CLI_TOOL_ID, instanceId },
                 executablePath: this.command,
                 worktreePath,
-            })), true);
+            });
+            await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
             await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.COMMAND_CODE_INIT_WAIT_MS));
             await this.waitForReady(sessionName);
             logger.info('started-command-code-session');
@@ -368,7 +371,8 @@ class CommandCodeTool extends base_1.BaseCLITool {
             // Issue #3006: passed through unwrapped so its `code` reaches the route.
             if ((0, session_start_error_1.isSessionStartTimeoutError)(error))
                 throw error;
-            const wrapped = new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            const wrapped = new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`, { cause: error });
             // Issue #3772: the plan review refusal comes before the body; keep its code.
             if (error?.code === send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE) {
                 throw Object.assign(wrapped, { code: send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE });

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

@@ -380,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
@@ -742,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 });
         }
     }
     /**

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

@@ -111,7 +111,8 @@ class GeminiTool extends base_1.BaseCLITool {
                 // 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.
-                await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, () => (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true));
+                // 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
@@ -207,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();
@@ -225,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
@@ -258,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

@@ -335,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
@@ -691,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);

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

@@ -10,6 +10,7 @@ exports.withoutTrailingBlankRows = withoutTrailingBlankRows;
 exports.findPasteTokens = findPasteTokens;
 exports.readSubmitComposer = readSubmitComposer;
 exports.classifySubmit = classifySubmit;
+exports.classifySubmitWithRule = classifySubmitWithRule;
 exports.isSubmitted = isSubmitted;
 exports.classifyPasteLanded = classifyPasteLanded;
 exports.compactText = compactText;
@@ -452,6 +453,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 +471,34 @@ 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.
     if (composer.kind !== 'text') {
-        return 'submitted';
+        return { state: 'submitted', rule: composer.kind === 'absent' ? 'B-absent' : 'B-empty' };
     }
     // 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.js

@@ -89,6 +89,13 @@
  * checks it still owns the composer before every key, watches an `unseen`
  * paste a little longer before giving up, and leaves a mark for a body that
  * may still arrive, which the next send waits out ({@link waitOutCarriedPaste}).
+ *
+ * Issue #4035 is a claude session's first prompt reported sent when it was
+ * not. Keys typed right after the prompt appeared were drawn ~1 s later and
+ * their Enter was lost, while the read-back still showed the dim placeholder
+ * (rule F). On that first prompt a B or F verdict now waits for claude's own
+ * `UserPromptSubmit` ({@link awaitPromptReport}), and a later send that clears
+ * a body this one called sent says so ({@link reportSubmittedBodyInComposer}).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -124,7 +131,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LITERAL_SEND_MAX_BYTES = exports.isSubmitted = exports.classifySubmit = exports.classifyPasteLanded = exports.recheckComposerBeforeInput = void 0;
+exports.PROMPT_REPORT_WAIT_MS = exports.LITERAL_SEND_MAX_BYTES = exports.isSubmitted = exports.classifySubmitWithRule = exports.classifySubmit = exports.classifyPasteLanded = exports.recheckComposerBeforeInput = void 0;
 exports.clearComposerBeforeSend = clearComposerBeforeSend;
 exports.sendMessageWithSubmitVerification = sendMessageWithSubmitVerification;
 const childProcess = __importStar(require("child_process"));
@@ -137,6 +144,9 @@ const logger_1 = require("../../lib/logger");
 const global_state_1 = require("../../lib/global-state");
 const composer_clear_1 = require("../../lib/session/composer-clear");
 Object.defineProperty(exports, "recheckComposerBeforeInput", { enumerable: true, get: function () { return composer_clear_1.recheckComposerBeforeInput; } });
+const prompt_submit_receipt_1 = require("../../lib/session/prompt-submit-receipt");
+const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const composer_text_1 = require("../../lib/detection/composer-text");
 const submit_composer_read_1 = require("./submit-composer-read");
@@ -145,6 +155,7 @@ const submit_composer_read_1 = require("./submit-composer-read");
 var submit_composer_read_2 = require("./submit-composer-read");
 Object.defineProperty(exports, "classifyPasteLanded", { enumerable: true, get: function () { return submit_composer_read_2.classifyPasteLanded; } });
 Object.defineProperty(exports, "classifySubmit", { enumerable: true, get: function () { return submit_composer_read_2.classifySubmit; } });
+Object.defineProperty(exports, "classifySubmitWithRule", { enumerable: true, get: function () { return submit_composer_read_2.classifySubmitWithRule; } });
 Object.defineProperty(exports, "isSubmitted", { enumerable: true, get: function () { return submit_composer_read_2.isSubmitted; } });
 const logger = (0, logger_1.createLogger)('cli-tools/submit-verified-sender');
 /**
@@ -203,6 +214,15 @@ const RECHECK_CAPTURE_LINES = 200;
 const CARRIED_MARK_POLL_MS = 200;
 /** Default bounded recovery Enters (each read back) before giving up (throwing). */
 const DEFAULT_VERIFY_ATTEMPTS = 4;
+/**
+ * How long a B/F verdict on a session's first prompt waits for the agent's own
+ * report of it (Issue #4035). Claude 2.1.314 reported the first prompt 0.66–0.74 s
+ * after the send began in all 29 submitted first sends measured; an unsent body
+ * was drawn into the composer 0.9–1.7 s after its Enter.
+ */
+exports.PROMPT_REPORT_WAIT_MS = 5000;
+/** How often the report and the composer are looked at during that wait. */
+const PROMPT_REPORT_POLL_MS = 100;
 /** Run one tmux command, optionally feeding it `input` on stdin. */
 function runTmux(args, input) {
     return new Promise((resolve, reject) => {
@@ -234,6 +254,12 @@ function runTmux(args, input) {
  * `load-buffer` ran. A lost ticket drops the buffer and throws before anything
  * reaches the pane (`input lock lost, nothing was typed`).
  *
+ * Issue #4011: a failed `load-buffer` throws with `delivery: 'not-started'`
+ * (the field `TmuxSendError` carries) — it runs before `paste-buffer`, so none
+ * of the body reached the pane, however it failed (an exit status or a timeout).
+ * Issue #4031: worded `Failed to load message into tmux buffer` and coded
+ * `PASTE_NOT_STARTED_CODE`, so `classifySendFailure` records it `not-sent`.
+ *
  * @throws Error when either tmux command fails, or `ticket` lost the composer
  */
 async function pasteBody(sessionName, message, ticket, cliToolId) {
@@ -245,7 +271,13 @@ async function pasteBody(sessionName, message, ticket, cliToolId) {
     catch (error) {
         await runTmux(['delete-buffer', '-b', bufferName]).catch(() => undefined);
         const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to paste message into tmux session: ${errorMessage}`);
+        // Issue #4031: its own wording and code, apart from `paste-buffer`'s
+        // failure below (whose body may be on the pane), so the send is recorded
+        // `not-sent` with or without a bound relay.
+        throw Object.assign(new Error(`Failed to load message into tmux buffer: ${errorMessage}`), {
+            delivery: 'not-started',
+            code: send_attempt_types_1.PASTE_NOT_STARTED_CODE,
+        });
     }
     if (!ticket.isCurrent()) {
         await runTmux(['delete-buffer', '-b', bufferName]).catch(() => undefined);
@@ -599,6 +631,67 @@ async function confirmTypedBodyLanded(params) {
         `${attempts * TYPED_BODY_POLL_MS}ms (it shows ${shown}); the message is ${bytes} bytes. ` +
         'Enter was not pressed, so nothing was submitted (Issue #3366).');
 }
+/**
+ * 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);
+}
+/**
+ * Watch a session's first prompt until the agent reports it (Issue #4035).
+ *
+ * Reads the hook record and the composer every {@link PROMPT_REPORT_POLL_MS}
+ * until `deadline`, without pressing anything. The deadline is the send's, not
+ * the call's: a send that waits again after a resent Enter gets only what is
+ * left of its {@link PROMPT_REPORT_WAIT_MS} (it holds the input lock meanwhile).
+ *
+ *   - the agent reported the prompt — `received`;
+ *   - the screen changes its verdict — generating (A), or the body drawn into
+ *     the composer after all (C/D, `pending`: the caller resends Enter, as for
+ *     any typed-but-unsent body), or a completion (E) — `screen`, with the frame;
+ *   - neither, to the end — `unreported`: nothing says the message left.
+ */
+async function awaitPromptReport(params) {
+    const { sessionName, message, cliToolId, composer, enteredAt, deadline } = params;
+    let rule = params.rule;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, PROMPT_REPORT_POLL_MS));
+        if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt) === 'received')
+            return { verdict: 'received' };
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+        const verdict = (0, submit_composer_read_1.classifySubmitWithRule)(output, cliToolId, message, composer);
+        if (verdict.state !== 'submitted' || verdict.rule === 'A')
+            return { verdict: 'screen', ...verdict, output };
+        rule = verdict.rule;
+    }
+    if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt) === 'received')
+        return { verdict: 'received' };
+    return { verdict: 'unreported', rule };
+}
+/**
+ * Say so when the pre-send clear finds the body this session last reported
+ * submitted (Issue #4035): that body never reached the agent, and the send that
+ * said `sent` for it was wrong. The instance's `lastSend` is turned
+ * `indeterminate` (the send now running records its own outcome after it).
+ */
+function reportSubmittedBodyInComposer(sessionName, cliToolId, composerText, cleared) {
+    if (composerText === '' || !(0, prompt_submit_receipt_1.matchesSubmittedBody)(sessionName, composerText))
+        return;
+    const target = (0, prompt_submit_receipt_1.getPromptSubmitTarget)(sessionName);
+    if (target !== null)
+        (0, send_attempt_state_1.markLastSendDiscarded)({ ...target, instanceId: target.instanceId ?? target.cliToolId });
+    logger.warn('pre-send-found-submitted-body', {
+        sessionName,
+        cliToolId,
+        cleared,
+        length: composerText.length,
+    });
+}
 /**
  * Empty the composer before the body is typed into it (Issue #1880).
  *
@@ -658,6 +751,7 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
     });
     if (ticket !== undefined)
         assertInputOwner(ticket, cliToolId, 'the pre-send clear', false);
+    reportSubmittedBodyInComposer(sessionName, cliToolId, result.discardedText, result.state !== 'content');
     if (result.state === 'content') {
         logger.error('pre-send-composer-clear-failed', {
             sessionName,
@@ -742,9 +836,11 @@ async function sendUnderInputLock(params, ticket) {
         }
         catch (error) {
             // Whether tmux put any of it into the pane is unknown — except after a
-            // refused input boundary (Issue #3992), which stops before `paste-buffer`:
-            // a mark then would only hold the next send off for nothing.
-            if (!(0, instance_input_lock_1.isInputBoundaryRefusal)(error))
+            // refused input boundary (Issue #3992) or a failed `load-buffer` (Issue
+            // #4011, `not-started`), both before `paste-buffer`: a mark then would
+            // only hold the next send off for nothing.
+            const notStarted = error?.delivery === 'not-started';
+            if (!(0, instance_input_lock_1.isInputBoundaryRefusal)(error) && !notStarted)
                 (0, instance_input_lock_1.leaveCarriedPasteMark)(ticket);
             throw error;
         }
@@ -796,6 +892,8 @@ async function sendUnderInputLock(params, ticket) {
         }
     }
     // 3. Submit as a separate command (double Enter for vibe-local's IME mode).
+    //    Issue #4035: the agent's own report of the prompt counts from here.
+    const enteredAt = Date.now();
     for (let i = 0; i < Math.max(1, submitEnterCount); i++) {
         assertInputOwner(ticket, cliToolId, 'Enter', true);
         await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
@@ -812,11 +910,62 @@ async function sendUnderInputLock(params, ticket) {
     //    was reported "could not be confirmed" — a sent message as exit 99. The
     //    last read sends nothing: no Enter goes out that is not read back.
     const attempts = Math.max(1, verifyAttempts);
+    // Issue #4035: one wait for the agent's report per send, however many reads.
+    let promptReportDeadline = null;
     for (let attempt = 0; attempt <= attempts; attempt++) {
         await new Promise((resolve) => setTimeout(resolve, verifyDelayMs));
-        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
-        const state = (0, submit_composer_read_1.classifySubmit)(output, cliToolId, message, composer);
+        let output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+        let { state, rule } = (0, submit_composer_read_1.classifySubmitWithRule)(output, cliToolId, message, composer);
+        const receipt = needsPromptReport(state, rule, message)
+            ? (0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt)
+            : 'not-required';
+        // Issue #4035: every verdict names the rule that gave it, so a send reported
+        // `sent` can be traced to what the screen showed.
+        logger.info('submit-classified', { sessionName, cliToolId, attempt, state, rule, receipt });
+        if (receipt === 'awaited') {
+            // Issue #4035: the screen says only that the body is not in the composer,
+            // on a session that has not reported a prompt yet. Watch, without Enter,
+            // until the agent reports it or the composer shows the body after all.
+            promptReportDeadline ??= Date.now() + exports.PROMPT_REPORT_WAIT_MS;
+            const watched = await awaitPromptReport({
+                sessionName,
+                message,
+                cliToolId,
+                composer,
+                enteredAt,
+                rule,
+                deadline: promptReportDeadline,
+            });
+            if (watched.verdict === 'unreported') {
+                (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+                logger.error('submit-not-confirmed:prompt-unreported', {
+                    sessionName,
+                    cliToolId,
+                    attempt,
+                    rule: watched.rule,
+                    waitedMs: exports.PROMPT_REPORT_WAIT_MS,
+                });
+                throw new Error(`Message submit could not be confirmed for session ${sessionName}: the composer did not show the body ` +
+                    `(rule ${watched.rule}) but the agent did not report the prompt within ${exports.PROMPT_REPORT_WAIT_MS}ms ` +
+                    '(Issue #4035).');
+            }
+            if (watched.verdict === 'received') {
+                logger.info('submit-confirmed-by-prompt-hook', { sessionName, cliToolId, attempt, rule });
+                state = 'submitted';
+            }
+            else {
+                ({ state, rule, output } = watched);
+                logger.info('submit-classified', { sessionName, cliToolId, attempt, state, rule, receipt: 'awaited' });
+            }
+        }
         if (state === 'submitted') {
+            // Issue #4035: only a body the screen alone called submitted is remembered
+            // for the next send's clear. One the agent reported did leave, and the same
+            // text back in the composer is claude restoring it (Esc), the history (↑),
+            // or a person typing it — not a send that never arrived.
+            if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt) !== 'received') {
+                (0, prompt_submit_receipt_1.noteSubmittedBody)(sessionName, message);
+            }
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             return;
         }
@@ -863,6 +1012,14 @@ async function sendUnderInputLock(params, ticket) {
             logger.warn('submit-not-confirmed:foreign-paste-token', { sessionName, cliToolId, attempt });
             continue;
         }
+        // Issue #4035: the Enter thought lost may only have been late — the agent
+        // reporting the prompt now means it went, and another Enter would land on an
+        // empty composer, or on a dialog that the prompt just opened.
+        if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt) === 'received') {
+            logger.info('submit-confirmed-by-prompt-hook', { sessionName, cliToolId, attempt, rule });
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            return;
+        }
         // state === 'pending' — still typed-but-unsent, resend a single Enter and re-check.
         logger.warn('submit-not-confirmed:resending-enter', {
             sessionName,