commandmate 0.49.1 → 0.49.3

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,67 +131,42 @@ 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.promptUnreportedResendNote = exports.PROMPT_UNREPORTED_RESEND_NOTE = exports.PROMPT_REPORT_WAIT_MS = exports.PROMPT_REPORT_POLL_MS = exports.LITERAL_SEND_MAX_BYTES = exports.INPUT_READINESS_UNDER_LOCK_WAIT_MS = exports.isSubmitted = exports.classifySubmitWithRule = exports.classifySubmit = exports.classifyPasteLanded = exports.recheckComposerBeforeInput = void 0;
 exports.clearComposerBeforeSend = clearComposerBeforeSend;
 exports.sendMessageWithSubmitVerification = sendMessageWithSubmitVerification;
 const childProcess = __importStar(require("child_process"));
 const tmux_1 = require("../tmux/tmux");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const composer_spec_1 = require("./composer-spec");
-const cli_patterns_1 = require("../detection/cli-patterns");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
-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_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");
+const submit_verified_sender_shared_1 = require("./submit-verified-sender-shared");
+const submit_verified_sender_lock_1 = require("./submit-verified-sender-lock");
+const submit_verified_sender_composer_1 = require("./submit-verified-sender-composer");
+const submit_verified_sender_report_1 = require("./submit-verified-sender-report");
 // Issue #3963: the composer reads moved to `submit-composer-read`; re-exported
 // so every caller and test keeps importing them from here.
 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');
-/**
- * Largest body typed as keystrokes (`send-keys -l`); anything longer is pasted
- * (Issue #2464).
- *
- * The limit is the pty's, not tmux's. tmux hands the pane the whole argv —
- * 16,320 bytes arrived intact on tmux 3.5a, and past ~16.3 KB `send-keys`
- * refuses with `command too long`, loudly — but the TUI reads it back in
- * pty-sized pieces, 1,022 bytes each on macOS. Claude Code keeps only the last
- * piece of unbracketed input (`12288 mod 1022` = the 24 bytes that arrived of a
- * 12 KB brief), so a body is only safe as keystrokes while it fits in a single
- * read. Half the smallest read measured leaves room for multi-byte text and for
- * a platform whose reads are shorter.
- */
-exports.LITERAL_SEND_MAX_BYTES = 512;
-/**
- * How often the composer is read while a pasted body is expected to appear in
- * it. Claude, codex, Command Code and agy all drew the pasted body within
- * 60 ms of `paste-buffer` on a 12 KB brief.
- */
-const PASTE_LANDED_POLL_MS = 100;
-/** Composer reads before a paste that has not fully appeared is abandoned (2 s). */
-const DEFAULT_PASTE_LANDED_ATTEMPTS = 20;
-/**
- * How often the composer is read while a TYPED body is expected to appear in it
- * (Issue #3366). codex draws a burst of keystrokes all at once when the burst
- * ends, so the poll only decides how late after that moment Enter goes in.
- */
-const TYPED_BODY_POLL_MS = 50;
-/**
- * Composer reads before a typed body that has not appeared is abandoned (5 s).
- *
- * codex 0.160.0 drew a 539-character body ~2.2 s after `send-keys` — about 4 ms
- * per character — and a typed body is at most {@link LITERAL_SEND_MAX_BYTES},
- * so this is roughly twice the slowest draw measured, for a loaded machine.
- */
-const DEFAULT_TYPED_BODY_ATTEMPTS = 100;
-/** Per-command timeout for `load-buffer` / `paste-buffer`, as for every other tmux call. */
-const PASTE_COMMAND_TIMEOUT_MS = 5000;
+// Issue #4056: the constants, option types and helpers moved to
+// `submit-verified-sender-*.ts`; the public ones are re-exported from here.
+var submit_verified_sender_shared_2 = require("./submit-verified-sender-shared");
+Object.defineProperty(exports, "INPUT_READINESS_UNDER_LOCK_WAIT_MS", { enumerable: true, get: function () { return submit_verified_sender_shared_2.INPUT_READINESS_UNDER_LOCK_WAIT_MS; } });
+Object.defineProperty(exports, "LITERAL_SEND_MAX_BYTES", { enumerable: true, get: function () { return submit_verified_sender_shared_2.LITERAL_SEND_MAX_BYTES; } });
+Object.defineProperty(exports, "PROMPT_REPORT_POLL_MS", { enumerable: true, get: function () { return submit_verified_sender_shared_2.PROMPT_REPORT_POLL_MS; } });
+Object.defineProperty(exports, "PROMPT_REPORT_WAIT_MS", { enumerable: true, get: function () { return submit_verified_sender_shared_2.PROMPT_REPORT_WAIT_MS; } });
+Object.defineProperty(exports, "PROMPT_UNREPORTED_RESEND_NOTE", { enumerable: true, get: function () { return submit_verified_sender_shared_2.PROMPT_UNREPORTED_RESEND_NOTE; } });
+Object.defineProperty(exports, "promptUnreportedResendNote", { enumerable: true, get: function () { return submit_verified_sender_shared_2.promptUnreportedResendNote; } });
 /**
  * Makes each send's tmux paste buffer name unique within this process — on
  * `globalThis` (Issue #3945 review #11): tmux buffers are server-wide, and a
@@ -193,20 +175,10 @@ const PASTE_COMMAND_TIMEOUT_MS = 5000;
  * `load-buffer` overwriting the first before its `paste-buffer`).
  */
 const pasteBufferSeq = (0, global_state_1.getOrInitGlobal)('__submitPasteBufferSeq', () => ({ last: 0 }));
-/**
- * Rows read for the re-check under the input lock (Issue #3945). The same
- * capture `clearComposer` takes for its first read, so on a tool that clears
- * before sending that read is the re-check's frame and no extra read is made.
- */
-const RECHECK_CAPTURE_LINES = 200;
-/** How often a send waiting out a carried paste mark reads the composer (Issue #3945). */
-const CARRIED_MARK_POLL_MS = 200;
-/** Default bounded recovery Enters (each read back) before giving up (throwing). */
-const DEFAULT_VERIFY_ATTEMPTS = 4;
 /** Run one tmux command, optionally feeding it `input` on stdin. */
 function runTmux(args, input) {
     return new Promise((resolve, reject) => {
-        const child = childProcess.execFile('tmux', args, { timeout: PASTE_COMMAND_TIMEOUT_MS }, (error) => {
+        const child = childProcess.execFile('tmux', args, { timeout: submit_verified_sender_shared_1.PASTE_COMMAND_TIMEOUT_MS }, (error) => {
             if (error) {
                 reject(error);
                 return;
@@ -234,6 +206,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,11 +223,17 @@ 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);
-        assertInputOwner(ticket, cliToolId, 'paste-buffer', false);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'paste-buffer', false);
     }
     // Issue #3953: the send's stamp, as the typed branch takes it — after
     // `load-buffer` (up to its timeout), right before the body reaches the pane.
@@ -272,16 +256,6 @@ async function pasteBody(sessionName, message, ticket, cliToolId) {
     }
 }
 /** The composer's first row, for an error message a person has to act on. */
-function describeComposer(output, cliToolId, composerSpec, message) {
-    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
-    if (composer.kind === 'absent')
-        return 'no composer on screen';
-    if (composer.kind === 'empty')
-        return 'an empty composer';
-    const text = composer.text.length > 80 ? `${composer.text.slice(0, 80)}…` : composer.text;
-    return JSON.stringify(text);
-}
 /**
  * Take a body that did not arrive intact back out of the composer, best effort.
  *
@@ -298,7 +272,7 @@ async function withdrawUnsentBody(sessionName, cliToolId, composerSpec, ticket)
     // no longer current means another writer owns the composer now, and what it
     // holds is that writer's.
     if (!ticket.isCurrent()) {
-        logger.error('paste-withdraw-skipped-not-owner', { sessionName, cliToolId, generation: ticket.generation });
+        submit_verified_sender_shared_1.logger.error('paste-withdraw-skipped-not-owner', { sessionName, cliToolId, generation: ticket.generation });
         return false;
     }
     try {
@@ -311,7 +285,7 @@ async function withdrawUnsentBody(sessionName, cliToolId, composerSpec, ticket)
         return false;
     }
     catch (clearError) {
-        logger.error('paste-withdraw-failed', {
+        submit_verified_sender_shared_1.logger.error('paste-withdraw-failed', {
             sessionName,
             cliToolId,
             error: clearError instanceof Error ? clearError.message : String(clearError),
@@ -319,23 +293,6 @@ async function withdrawUnsentBody(sessionName, cliToolId, composerSpec, ticket)
         return false;
     }
 }
-/**
- * Throw unless `ticket` still owns the composer (Issue #3945 stage 3). Called
- * right before every key a send sends — body, paste, each Enter — so work still
- * in flight after its ownership ended cannot reach the next owner's composer.
- *
- * @param typed - Whether any of the body may already be in the composer, which
- *   decides how the failure classifies (`not-sent` before the body only).
- */
-function assertInputOwner(ticket, cliToolId, step, typed) {
-    if (ticket.isCurrent())
-        return;
-    logger.error('input-lock-lost', { sessionName: ticket.sessionName, cliToolId, step, generation: ticket.generation });
-    if (!typed) {
-        throw new Error(`Session ${ticket.sessionName} was handed to another writer before ${step}; input lock lost, nothing was typed (Issue #3945).`);
-    }
-    throw new Error(`Session ${ticket.sessionName} was handed to another writer before ${step}; part of the message may be in its composer (Issue #3945).`);
-}
 /**
  * Hold off typing while a carried paste mark is fresh (Issue #3945 stage 4).
  *
@@ -352,7 +309,7 @@ async function waitOutCarriedPaste(sessionName, cliToolId, composer, ticket) {
     const mark = (0, instance_input_lock_1.getCarriedPasteMark)(sessionName);
     if (mark === null)
         return false;
-    logger.warn('carried-paste-mark-wait', {
+    submit_verified_sender_shared_1.logger.warn('carried-paste-mark-wait', {
         sessionName,
         cliToolId,
         originGeneration: mark.originGeneration,
@@ -360,13 +317,13 @@ async function waitOutCarriedPaste(sessionName, cliToolId, composer, ticket) {
         remainingMs: mark.expiresAt - Date.now(),
     });
     while (Date.now() < mark.expiresAt) {
-        await new Promise((resolve) => setTimeout(resolve, Math.min(CARRIED_MARK_POLL_MS, mark.expiresAt - Date.now())));
+        await new Promise((resolve) => setTimeout(resolve, Math.min(submit_verified_sender_shared_1.CARRIED_MARK_POLL_MS, mark.expiresAt - Date.now())));
         if (!composer.clearBeforeSend)
             continue;
-        assertInputOwner(ticket, cliToolId, 'the carried paste wait', false);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'the carried paste wait', false);
         let frame;
         try {
-            frame = await (0, tmux_1.capturePane)(sessionName, RECHECK_CAPTURE_LINES);
+            frame = await (0, tmux_1.capturePane)(sessionName, submit_verified_sender_shared_1.RECHECK_CAPTURE_LINES);
         }
         catch {
             // The re-check after the wait decides about a pane that cannot be read.
@@ -379,7 +336,7 @@ async function waitOutCarriedPaste(sessionName, cliToolId, composer, ticket) {
             beforePass: () => ticket.isCurrent(),
         });
         (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-        logger.warn('carried-paste-withdrawn', {
+        submit_verified_sender_shared_1.logger.warn('carried-paste-withdrawn', {
             sessionName,
             cliToolId,
             originGeneration: mark.originGeneration,
@@ -390,12 +347,6 @@ async function waitOutCarriedPaste(sessionName, cliToolId, composer, ticket) {
     (0, instance_input_lock_1.clearExpiredCarriedPasteMark)(ticket);
     return true;
 }
-/** Whether the composer in `output` holds any text at all, read as the sender reads it. */
-function composerHoldsText(output, cliToolId, composerSpec, message) {
-    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    return ((0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message)
-        .kind === 'text');
-}
 /**
  * Wait until the composer shows the whole pasted body; decide whether Enter
  * may be pressed (Issue #2464).
@@ -437,20 +388,20 @@ async function confirmPasteLanded(params) {
     let lateAfterMs = null;
     try {
         for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
-            await new Promise((resolve) => setTimeout(resolve, PASTE_LANDED_POLL_MS));
+            await new Promise((resolve) => setTimeout(resolve, submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS));
             output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
             state = (0, submit_composer_read_1.classifyPasteLanded)(output, cliToolId, message, composer);
             if (state === 'landed' || state === 'mismatch')
                 break;
         }
         if (state === 'unseen' && composer.clearBeforeSend) {
-            const observeAttempts = Math.ceil(instance_input_lock_1.LATE_PASTE_OBSERVE_MS / PASTE_LANDED_POLL_MS);
+            const observeAttempts = Math.ceil(instance_input_lock_1.LATE_PASTE_OBSERVE_MS / submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS);
             for (let attempt = 1; attempt <= observeAttempts; attempt++) {
-                await new Promise((resolve) => setTimeout(resolve, PASTE_LANDED_POLL_MS));
+                await new Promise((resolve) => setTimeout(resolve, submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS));
                 output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
                 state = (0, submit_composer_read_1.classifyPasteLanded)(output, cliToolId, message, composer);
                 if (state !== 'unseen') {
-                    lateAfterMs = attempt * PASTE_LANDED_POLL_MS;
+                    lateAfterMs = attempt * submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS;
                     break;
                 }
             }
@@ -462,18 +413,18 @@ async function confirmPasteLanded(params) {
     if (readError === null && lateAfterMs === null && state === 'landed')
         return;
     if (readError === null && state === 'unseen' && !composer.clearBeforeSend) {
-        logger.warn('paste-landed-unverified', { sessionName, cliToolId, bytes: Buffer.byteLength(message, 'utf8') });
+        submit_verified_sender_shared_1.logger.warn('paste-landed-unverified', { sessionName, cliToolId, bytes: Buffer.byteLength(message, 'utf8') });
         return;
     }
     const bytes = Buffer.byteLength(message, 'utf8');
     const lineCount = message.split('\n').length;
-    const shown = readError === null ? describeComposer(output, cliToolId, composer, message) : 'an unreadable pane';
+    const shown = readError === null ? (0, submit_verified_sender_composer_1.describeComposer)(output, cliToolId, composer, message) : 'an unreadable pane';
     const withdrawn = await withdrawUnsentBody(sessionName, cliToolId, composer, ticket);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     const mayStillArrive = readError !== null || state === 'unseen' || state === 'pasting' || !withdrawn;
     if (mayStillArrive)
         (0, instance_input_lock_1.leaveCarriedPasteMark)(ticket);
-    logger.error('paste-not-landed', {
+    submit_verified_sender_shared_1.logger.error('paste-not-landed', {
         sessionName,
         cliToolId,
         state,
@@ -488,50 +439,15 @@ async function confirmPasteLanded(params) {
     const what = readError !== null
         ? `the composer could not be read while the paste was checked (${readError})`
         : lateAfterMs !== null
-            ? `the paste appeared ${lateAfterMs}ms after the ${attempts * PASTE_LANDED_POLL_MS}ms check and was taken back out (the composer showed ${shown})`
+            ? `the paste appeared ${lateAfterMs}ms after the ${attempts * submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS}ms check and was taken back out (the composer showed ${shown})`
             : state === 'mismatch'
                 ? `the composer does not hold the message as sent (it shows ${shown})`
                 : state === 'pasting'
-                    ? `the paste had not finished arriving after ${attempts * PASTE_LANDED_POLL_MS}ms (the composer shows ${shown})`
+                    ? `the paste had not finished arriving after ${attempts * submit_verified_sender_shared_1.PASTE_LANDED_POLL_MS}ms (the composer shows ${shown})`
                     : `the message never appeared in the composer (${shown})`;
     throw new Error(`Message body did not arrive intact for session ${sessionName}: ${what}; the message is ${bytes} bytes / ${lineCount} lines. ` +
         'Enter was not pressed, so nothing was submitted (Issue #2464).');
 }
-/**
- * Whether the composer shows a paste placeholder whose count is not this body's
- * (Issue #3945): one counting fewer or more, or more than one placeholder.
- */
-function composerShowsForeignPasteToken(output, cliToolId, message, composerSpec) {
-    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, cliToolId, composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
-    if (composer.kind !== 'text')
-        return false;
-    if (!composer.rows.some((row) => (0, submit_composer_read_1.findPasteTokens)(row).tokens.length > 0))
-        return false;
-    return (0, submit_composer_read_1.classifyPasteLanded)(output, cliToolId, message, composerSpec) !== 'landed';
-}
-/**
- * The part of a typed body the composer reader can see (Issue #3366).
- *
- * The codex reader takes the composer as one run of non-blank rows, so a blank
- * line inside the body ends what it returns: what it can show is the body up to
- * its first blank line after the first non-blank one. Leading blank lines are
- * kept — they are drawn as composer rows of their own and compact to nothing.
- */
-function visibleTypedBody(message) {
-    const lines = message.split('\n');
-    const first = lines.findIndex((line) => line.trim() !== '');
-    if (first < 0)
-        return '';
-    const blank = lines.findIndex((line, index) => index > first && line.trim() === '');
-    return lines.slice(0, blank < 0 ? lines.length : blank).join('\n');
-}
-/** Whether the whole codex composer, read past the bounded readers (Issue #3906), is exactly `message`. */
-function codexComposerShowsWholeBody(output, message, composerSpec) {
-    const lines = (0, submit_composer_read_1.withoutTrailingBlankRows)((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = (0, submit_composer_read_1.readSubmitComposer)(output, 'codex', composerSpec.reader, lines, lines.slice(-submit_composer_read_1.VERIFY_WINDOW_LINES), message);
-    return composer.kind === 'text' && composer.region !== undefined && (0, submit_composer_read_1.compactText)(composer.region) === (0, submit_composer_read_1.compactText)(message);
-}
 /**
  * Wait until the composer shows the typed body; only then may Enter be pressed
  * (Issue #3366).
@@ -557,21 +473,21 @@ function codexComposerShowsWholeBody(output, message, composerSpec) {
  */
 async function confirmTypedBodyLanded(params) {
     const { sessionName, message, cliToolId, composer, attempts, ticket } = params;
-    const expected = (0, submit_composer_read_1.compactText)(visibleTypedBody(message));
+    const expected = (0, submit_composer_read_1.compactText)((0, submit_verified_sender_composer_1.visibleTypedBody)(message));
     if (expected === '')
         return;
     let output = '';
     let readError = null;
     try {
         for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
-            await new Promise((resolve) => setTimeout(resolve, TYPED_BODY_POLL_MS));
+            await new Promise((resolve) => setTimeout(resolve, submit_verified_sender_shared_1.TYPED_BODY_POLL_MS));
             output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
             // Issue #3906: on codex the whole composer must show the whole body. The
             // extractor's excerpt stops at the first blank row, so its match is only
             // the first paragraph — a five-paragraph body with one paragraph drawn
             // would pass on it — and it cannot reach a body of more than four blocks.
             if (cliToolId === 'codex') {
-                if (codexComposerShowsWholeBody(output, message, composer))
+                if ((0, submit_verified_sender_composer_1.codexComposerShowsWholeBody)(output, message, composer))
                     return;
                 continue;
             }
@@ -584,19 +500,19 @@ async function confirmTypedBodyLanded(params) {
         readError = error instanceof Error ? error.message : String(error);
     }
     const bytes = Buffer.byteLength(message, 'utf8');
-    const shown = readError === null ? describeComposer(output, cliToolId, composer, message) : 'an unreadable pane';
+    const shown = readError === null ? (0, submit_verified_sender_composer_1.describeComposer)(output, cliToolId, composer, message) : 'an unreadable pane';
     // Issue #3945: a body never seen (codex can draw a burst late), a read that
     // threw, or a withdrawal that was not confirmed may still put text in the
     // composer after this throw — the next send waits that out.
-    const seen = readError === null && composerHoldsText(output, cliToolId, composer, message);
+    const seen = readError === null && (0, submit_verified_sender_composer_1.composerHoldsText)(output, cliToolId, composer, message);
     const withdrawn = await withdrawUnsentBody(sessionName, cliToolId, composer, ticket);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     const mayStillArrive = !seen || !withdrawn;
     if (mayStillArrive)
         (0, instance_input_lock_1.leaveCarriedPasteMark)(ticket);
-    logger.error('typed-body-not-landed', { sessionName, cliToolId, bytes, attempts, shown, readError, carried: mayStillArrive });
+    submit_verified_sender_shared_1.logger.error('typed-body-not-landed', { sessionName, cliToolId, bytes, attempts, shown, readError, carried: mayStillArrive });
     throw new Error(`Message body did not appear in the composer for session ${sessionName} within ` +
-        `${attempts * TYPED_BODY_POLL_MS}ms (it shows ${shown}); the message is ${bytes} bytes. ` +
+        `${attempts * submit_verified_sender_shared_1.TYPED_BODY_POLL_MS}ms (it shows ${shown}); the message is ${bytes} bytes. ` +
         'Enter was not pressed, so nothing was submitted (Issue #3366).');
 }
 /**
@@ -657,9 +573,10 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
         ...(ticket !== undefined ? { beforePass: () => ticket.isCurrent() } : {}),
     });
     if (ticket !== undefined)
-        assertInputOwner(ticket, cliToolId, 'the pre-send clear', false);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'the pre-send clear', false);
+    (0, submit_verified_sender_report_1.reportSubmittedBodyInComposer)(sessionName, cliToolId, result.discardedText, result.state !== 'content', options.target);
     if (result.state === 'content') {
-        logger.error('pre-send-composer-clear-failed', {
+        submit_verified_sender_shared_1.logger.error('pre-send-composer-clear-failed', {
             sessionName,
             cliToolId,
             passes: result.passes,
@@ -673,7 +590,7 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
         // The only record of what was thrown away. `remainingText` is the FINAL
         // read and is empty on this path by definition, which is why clearComposer
         // reports `discardedText` separately.
-        logger.warn('pre-send-composer-cleared', {
+        submit_verified_sender_shared_1.logger.warn('pre-send-composer-cleared', {
             sessionName,
             cliToolId,
             passes: result.passes,
@@ -709,11 +626,18 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
  *   when the composer was not free in time (nothing typed).
  */
 async function sendMessageWithSubmitVerification(params) {
-    await (0, instance_input_lock_1.withInstanceInputLock)(params.sessionName, (ticket) => sendUnderInputLock(params, ticket));
+    await (0, instance_input_lock_1.withInstanceInputLock)(params.sessionName, (ticket) => {
+        // Issue #4065: the body's generation, told to the request before any key
+        // (and kept by it if the send throws). The same ticket when this joins the
+        // send service's outer lock (claude / codex), so it is told once more,
+        // with the same number.
+        (0, instance_input_lock_1.noteInputTicket)(ticket);
+        return sendUnderInputLock(params, ticket);
+    });
 }
 async function sendUnderInputLock(params, ticket) {
-    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, pasteLandedAttempts = DEFAULT_PASTE_LANDED_ATTEMPTS, awaitTypedBody = false, typedBodyAttempts = DEFAULT_TYPED_BODY_ATTEMPTS, } = params;
-    const submitEnterCount = params.submitEnterCount ?? composer.submitEnterCount;
+    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = submit_verified_sender_shared_1.DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, pasteLandedAttempts = submit_verified_sender_shared_1.DEFAULT_PASTE_LANDED_ATTEMPTS, awaitTypedBody = false, typedBodyAttempts = submit_verified_sender_shared_1.DEFAULT_TYPED_BODY_ATTEMPTS, target, } = params;
+    const submitEnterCount = (0, submit_verified_sender_report_1.resolveSubmitEnterCount)(params, composer);
     // -1. Issue #3945 (review-1 #4): every send re-reads the pane once it owns
     //     the composer, whether or not it queued — the prompt guard and the
     //     tool's readiness wait ran before the lock, and a dialog can open in the
@@ -727,24 +651,30 @@ async function sendUnderInputLock(params, ticket) {
     if (await waitOutCarriedPaste(sessionName, cliToolId, composer, ticket)) {
         frame = await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, cliToolId);
     }
+    // Issue #4040: the tool's readiness, asked again of that same newest frame.
+    // A dialog was refused just above (and is, at once, on every re-read); this
+    // refuses a pane that went back to loading, or still shows the picker of the
+    // send before, after the tool's own wait said "ready".
+    frame = await (0, submit_verified_sender_lock_1.awaitReadyUnderLock)(params.readiness, frame, { sessionName, cliToolId, ticket });
     // 0. Empty the composer first (Issue #1880). The body below is typed at the
     //    TUI's current cursor position, so anything already in the box would be
     //    spliced into it. Throws for a claude composer that could not be emptied.
-    await clearComposerBeforeSend(sessionName, cliToolId, composer, { initialCapture: frame, ticket });
-    if (Buffer.byteLength(message, 'utf8') > exports.LITERAL_SEND_MAX_BYTES) {
+    await clearComposerBeforeSend(sessionName, cliToolId, composer, {
+        initialCapture: frame,
+        ticket,
+        ...(target !== undefined ? { target } : {}),
+    });
+    if (Buffer.byteLength(message, 'utf8') > submit_verified_sender_shared_1.LITERAL_SEND_MAX_BYTES) {
         // 1'. A body that would reach the TUI as more than one pty read is pasted
         //     as ONE bracketed paste, and Enter waits until the composer shows all
         //     of it (Issue #2464). Typed, Claude Code would keep only its last read.
         const pastedAt = Date.now();
-        assertInputOwner(ticket, cliToolId, 'the paste', false);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'the paste', false);
         try {
             await pasteBody(sessionName, message, ticket, cliToolId);
         }
         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))
+            if ((0, submit_verified_sender_report_1.pasteFailureMayHaveTyped)(error))
                 (0, instance_input_lock_1.leaveCarriedPasteMark)(ticket);
             throw error;
         }
@@ -766,7 +696,7 @@ async function sendUnderInputLock(params, ticket) {
         //    nowhere at all, with `rc 0`. All four measured on tmux 3.5a; the argv is
         //    built in `lib/tmux/key-sequence.ts`, which carries the table.
         const typedAt = Date.now();
-        assertInputOwner(ticket, cliToolId, 'the body', false);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'the body', false);
         // Issue #3953: the send's stamp is taken here — after the lock, the carried
         // mark, the re-check and the clear, right before the body's first key — so a
         // previous turn that ended during any of them is older than this send.
@@ -787,7 +717,7 @@ async function sendUnderInputLock(params, ticket) {
         //    means waiting until the body is drawn (Issue #3366): an Enter pressed
         //    while codex still holds the keystrokes as a paste burst becomes a
         //    newline, and the body stays unsent. The fixed wait stays as a floor.
-        if (awaitTypedBody && composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId)) {
+        if ((0, submit_verified_sender_report_1.shouldAwaitTypedBody)(awaitTypedBody, cliToolId)) {
             await confirmTypedBodyLanded({ sessionName, message, cliToolId, composer, attempts: typedBodyAttempts, ticket });
         }
         const remaining = textInputWaitMs - (Date.now() - typedAt);
@@ -796,8 +726,10 @@ 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);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'Enter', true);
         await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
         if (i < submitEnterCount - 1) {
             await new Promise((resolve) => setTimeout(resolve, interEnterWaitMs));
@@ -812,11 +744,40 @@ 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 });
+        // Issue #4048: a frame read after the session was replaced is the new
+        // process's, and so would be its hooks — neither says anything about this
+        // send, whose Enter went to the old one (indeterminate, not `not-sent`).
+        (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the read-back');
+        let { state, rule } = (0, submit_composer_read_1.classifySubmitWithRule)(output, cliToolId, message, composer);
+        const receipt = (0, submit_verified_sender_report_1.promptReceiptFor)({ state, rule, message, sessionName, cliToolId, enteredAt, target });
+        // Issue #4035: every verdict names the rule that gave it, so a send reported
+        // `sent` can be traced to what the screen showed.
+        submit_verified_sender_shared_1.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() + submit_verified_sender_shared_1.PROMPT_REPORT_WAIT_MS;
+            const watched = await (0, submit_verified_sender_report_1.awaitPromptReport)({
+                sessionName,
+                message,
+                cliToolId,
+                composer,
+                enteredAt,
+                rule,
+                deadline: promptReportDeadline,
+                ticket,
+                ...(target !== undefined ? { target } : {}),
+            });
+            ({ state, rule, output } = (0, submit_verified_sender_report_1.settleAwaitedPromptReport)({ watched, sessionName, cliToolId, attempt, rule, output, target }));
+        }
         if (state === 'submitted') {
+            (0, submit_verified_sender_report_1.rememberScreenOnlySubmit)({ sessionName, cliToolId, enteredAt, message, ticket, target });
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             return;
         }
@@ -831,48 +792,43 @@ async function sendUnderInputLock(params, ticket) {
                     await (0, tmux_1.clearInputLine)(sessionName);
                 }
                 else {
-                    logger.error('submit-clear-input-skipped-not-owner', { sessionName, cliToolId, generation: ticket.generation });
+                    submit_verified_sender_shared_1.logger.error('submit-clear-input-skipped-not-owner', { sessionName, cliToolId, generation: ticket.generation });
                 }
             }
             catch (clearError) {
-                logger.error('submit-clear-input-failed', {
-                    sessionName,
-                    cliToolId,
-                    error: clearError instanceof Error ? clearError.message : String(clearError),
-                });
+                (0, submit_verified_sender_report_1.logClearInputFailed)(sessionName, cliToolId, clearError);
             }
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.error('submit-replaced-by-tui-completion', { sessionName, cliToolId, attempt });
+            submit_verified_sender_shared_1.logger.error('submit-replaced-by-tui-completion', { sessionName, cliToolId, attempt });
             throw new Error(`Message was replaced by a TUI autocompletion for session ${sessionName}; the input no longer matches the sent text. Cleared the input line without submitting to avoid executing a different command.`);
         }
         // state === 'pending' / 'indeterminate' after the final read-back: give up below.
         if (attempt === attempts)
             break;
-        // state === 'indeterminate' (Issue #3906) — no Enter: the composer does not
-        // show the body, so another Enter could submit whatever it does show.
-        if (state === 'indeterminate') {
-            logger.warn('submit-not-confirmed:composer-unreadable', { sessionName, cliToolId, attempt });
-            continue;
-        }
-        // Issue #3945 (review #1): a paste placeholder that does not count this
-        // body is not this body. It can only be a paste that arrived after the
-        // initial Enter (a carried send's, past its mark), and another Enter would
-        // submit it. One that counts exactly this body cannot be told apart: that
-        // Enter is the accepted gap (LATE_TOKEN_AFTER_ENTER_SAME_COUNT in the tests).
-        if (composerShowsForeignPasteToken(output, cliToolId, message, composer)) {
-            logger.warn('submit-not-confirmed:foreign-paste-token', { sessionName, cliToolId, attempt });
+        if ((0, submit_verified_sender_report_1.holdsResendEnter)({ state, output, sessionName, cliToolId, message, composer, 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.
+        // Issue #4048: a report read after the session was replaced (during the
+        // wait above, say) may be the new generation's own prompt — this send is
+        // then indeterminate, never confirmed by it.
+        if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt, target) === 'received') {
+            (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the prompt report check');
+            submit_verified_sender_shared_1.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', {
+        submit_verified_sender_shared_1.logger.warn('submit-not-confirmed:resending-enter', {
             sessionName,
             cliToolId,
             attempt,
         });
-        assertInputOwner(ticket, cliToolId, 'a resent Enter', true);
+        (0, submit_verified_sender_lock_1.assertInputOwner)(ticket, cliToolId, 'a resent Enter', true);
         await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
     }
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-    logger.error('submit-verification-failed', { sessionName, cliToolId, attempts });
+    submit_verified_sender_shared_1.logger.error('submit-verification-failed', { sessionName, cliToolId, attempts });
     throw new Error(`Message submit could not be confirmed for session ${sessionName} after ${attempts} attempts (typed but unsent)`);
 }