commandmate 0.49.2 → 0.49.3

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

@@ -16,6 +16,7 @@ exports.classifyPasteLanded = classifyPasteLanded;
 exports.compactText = compactText;
 const composer_spec_1 = require("./composer-spec");
 const cli_patterns_1 = require("../detection/cli-patterns");
+const composer_own_text_1 = require("../detection/tools/opencode/composer-own-text");
 const composer_text_1 = require("../../lib/detection/composer-text");
 /**
  * Version-resilient pasted-text placeholder.
@@ -39,6 +40,13 @@ const PASTE_PLACEHOLDER_PATTERN = /\[Pasted text[\s#]/;
  * substitution, so a genuinely-submitted message never fails spuriously.
  */
 const REPLACEMENT_COMMAND_PATTERN = /^\/[A-Za-z]/;
+/**
+ * opencode's empty-buffer placeholder on a box row's own text (Issue #4067):
+ * `OPENCODE_IDLE_COMPOSER_PATTERN` with the gutter already removed by
+ * `readOpenCodeComposerOwnRows`. Start-anchored like that pattern, so the
+ * phrase quoted inside a typed body is not taken for it.
+ */
+const OPENCODE_OWN_PLACEHOLDER = /^Ask anything(?:\.\.\.|\u2026)/;
 /**
  * Prompt input-line markers across the marker-drawing TUIs.
  * claude/gemini/copilot: `>` or `❯`; codex: `›`; antigravity: `>`;
@@ -95,17 +103,26 @@ exports.VERIFY_WINDOW_LINES = 12;
  */
 function readComposer(reader, lines, windowLines) {
     if (reader === 'opencode-box') {
-        const rows = (0, cli_patterns_1.findOpenCodeComposerRows)(lines);
-        if (rows === null)
+        // Each buffer row's own text: gutter removed and cut at the box's right
+        // edge (Issue #4067), so the sidebar drawn on the same rows (#2047/#2095 —
+        // its working directory starts with `/`) is never read as the body. The
+        // same cut as the send readiness (`isOpenCodeComposerReady`).
+        const box = (0, composer_own_text_1.readOpenCodeComposerBox)(lines);
+        if (box === null)
             return { kind: 'absent' };
+        const { rows } = box;
+        // An overlay over the box (its bottom border cut in two): its rows are read
+        // to the border's far end, and the reading is marked so B and F do not
+        // stand on it (review of #4067).
+        const obscured = box.obscured ? { obscured: true } : {};
         // The placeholder is painted only while the buffer is empty, and only
-        // inside the box — hence matched on the raw, still-guttered row (#1883).
-        if (rows.some((row) => cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(row)))
-            return { kind: 'empty' };
-        const first = rows.map(cli_patterns_1.stripOpenCodeGutter).find((row) => row.length > 0);
+        // inside the box (#1883) — read on the row's own text, which is inside it.
+        if (rows.some((row) => OPENCODE_OWN_PLACEHOLDER.test(row)))
+            return { kind: 'empty', ...obscured };
+        const first = rows.find((row) => row.length > 0);
         if (first === undefined)
-            return { kind: 'empty' };
-        return { kind: 'text', text: first, rows };
+            return { kind: 'empty', ...obscured };
+        return { kind: 'text', text: first, rows, ...obscured };
     }
     if (reader !== 'input-line-marker')
         return { kind: 'absent' };
@@ -432,6 +449,11 @@ function readSubmitComposer(output, cliToolId, reader, lines, windowLines, messa
  *      pre-#1501 permissive default, so normal sends never spuriously fail) —
  *      except in a codex composer above the read window -> indeterminate
  *      (Issue #3906).
+ *   None of B–F holds for opencode's box with an overlay drawn over it (its
+ *   bottom border cut in two) -> indeterminate (`B-obscured` when nothing is
+ *   seen, `F-obscured` for any text — the body, a token or a `/…` included;
+ *   review of #4067): what the box holds under the overlay is not seen, and an
+ *   Enter or a clear would go to the overlay.
  *
  * C–F are scoped to the composer only, so the user-message echo that a TUI
  * prints into its history above the prompt never causes a false verdict.
@@ -476,9 +498,20 @@ function classifySubmitWithRule(output, cliToolId, message, composerSpec = (0, c
     const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines, message);
     // B. No composer visible (scrolled off / dialog / still starting), or the
     //    composer is empty => the message left the box => submitted.
+    //    Not on opencode's box with an overlay drawn over it (review of #4067):
+    //    nothing seen there is not the box being empty -> indeterminate.
     if (composer.kind !== 'text') {
+        if (composer.kind === 'empty' && composer.obscured)
+            return { state: 'indeterminate', rule: 'B-obscured' };
         return { state: 'submitted', rule: composer.kind === 'absent' ? 'B-absent' : 'B-empty' };
     }
+    //    Text in opencode's box under an overlay (review of #4067): the reading
+    //    runs to the border's far end, the overlay's text included, so none of
+    //    C–F is read from it. C/D would resend Enter and E clear the line — keys
+    //    that would go to the palette or picker on top, not to the box ->
+    //    indeterminate (no Enter, no clear; read again).
+    if (composer.obscured)
+        return { state: 'indeterminate', rule: 'F-obscured' };
     // C. A paste placeholder is still folded into the composer => body is there.
     if (composer.rows.some((row) => PASTE_PLACEHOLDER_PATTERN.test(row) || findPasteTokens(row).tokens.length > 0)) {
         return { state: 'pending', rule: 'C' };

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

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

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

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Ownership and readiness under the instance input lock (Issue #4056: split out
+ * of `submit-verified-sender.ts`): {@link assertInputOwner} before every key,
+ * and the tool's readiness asked again of the frames read under the lock.
+ *
+ * Sends no key. Imports nothing from `submit-verified-sender.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEADLINE_PASSED = void 0;
+exports.beforeDeadline = beforeDeadline;
+exports.isReadyFrame = isReadyFrame;
+exports.awaitReadyUnderLock = awaitReadyUnderLock;
+exports.assertInputOwner = assertInputOwner;
+exports.assertStillOwnedAfterEnter = assertStillOwnedAfterEnter;
+const composer_clear_1 = require("../../lib/session/composer-clear");
+const submit_verified_sender_shared_1 = require("./submit-verified-sender-shared");
+/** What {@link beforeDeadline} answers when the deadline came first. */
+exports.DEADLINE_PASSED = Symbol('deadline-passed');
+/**
+ * `read`'s value, or {@link DEADLINE_PASSED} when `deadline` (epoch ms) comes
+ * first. A rejection that arrives in time is thrown; one that arrives later is
+ * dropped with the read (Issue #4040).
+ */
+async function beforeDeadline(read, deadline) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(exports.DEADLINE_PASSED), Math.max(0, deadline - Date.now()));
+    });
+    try {
+        return await Promise.race([read, expired]);
+    }
+    finally {
+        clearTimeout(timer);
+        read.catch(() => undefined);
+    }
+}
+function isReadyFrame(readiness, frame) {
+    try {
+        return readiness.isReady(frame);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The newest frame under the lock that passes the tool's readiness test
+ * (Issue #4040), or a refusal before any key.
+ *
+ * The refusal does not quote the frame: `classifySendFailure` reads this
+ * wording, and a screen saying `submit could not be confirmed` would turn it
+ * into `indeterminate`.
+ *
+ * @throws Error `<label> prompt not ready …` (`not-sent` / `prompt-not-ready`);
+ *   the re-check's own refusals (dialog, unreadable pane); a lost lock
+ */
+async function awaitReadyUnderLock(readiness, frame, params) {
+    if (readiness === undefined || isReadyFrame(readiness, frame))
+        return frame;
+    const { sessionName, cliToolId, ticket } = params;
+    const deadline = Date.now() + submit_verified_sender_shared_1.INPUT_READINESS_UNDER_LOCK_WAIT_MS;
+    for (;;) {
+        const beforeSleep = deadline - Date.now();
+        if (beforeSleep <= 0)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, Math.min(submit_verified_sender_shared_1.INPUT_READINESS_UNDER_LOCK_POLL_MS, beforeSleep)));
+        if (Date.now() >= deadline)
+            break;
+        assertInputOwner(ticket, cliToolId, 'the readiness re-read', false);
+        const current = await beforeDeadline((0, composer_clear_1.recheckComposerBeforeInput)(sessionName, cliToolId), deadline);
+        // A frame read after the deadline is not taken: the wait is over.
+        if (current === exports.DEADLINE_PASSED || Date.now() > deadline)
+            break;
+        if (isReadyFrame(readiness, current))
+            return current;
+    }
+    submit_verified_sender_shared_1.logger.warn('input-readiness-not-ready-under-lock', { sessionName, cliToolId });
+    throw new Error(`${readiness.label} prompt not ready under the input lock: ` +
+        `no input prompt within ${submit_verified_sender_shared_1.INPUT_READINESS_UNDER_LOCK_WAIT_MS}ms, so nothing was typed (Issue #4040)`);
+}
+/**
+ * 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;
+    submit_verified_sender_shared_1.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).`);
+}
+/**
+ * Throw unless `ticket` still owns the session, after the body and an Enter
+ * went in (Issue #4048 item 2). Unlike a loss before the body
+ * ({@link assertInputOwner} with `typed: false`), this is no proof the message
+ * was not sent — the replaced process may have taken the prompt — so the error
+ * classifies `indeterminate`, never `not-sent` / `session-replaced`.
+ */
+function assertStillOwnedAfterEnter(ticket, cliToolId, step) {
+    if (ticket.isCurrent())
+        return;
+    submit_verified_sender_shared_1.logger.error('input-lock-lost-after-enter', {
+        sessionName: ticket.sessionName,
+        cliToolId,
+        step,
+        generation: ticket.generation,
+    });
+    throw new Error(`Session ${ticket.sessionName} was replaced during ${step}, after the message and Enter were sent; ` +
+        'the previous process may have submitted it (Issue #4048).');
+}

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

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * The read-back's verdicts after Enter and the agent's own report of the prompt
+ * (Issue #4056: split out of `submit-verified-sender.ts`, with the helpers
+ * #4057 split out of `sendUnderInputLock`). Reads the pane; sends no key.
+ *
+ * Imports nothing from `submit-verified-sender.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitPromptReport = awaitPromptReport;
+exports.reportSubmittedBodyInComposer = reportSubmittedBodyInComposer;
+exports.resolveSubmitEnterCount = resolveSubmitEnterCount;
+exports.pasteFailureMayHaveTyped = pasteFailureMayHaveTyped;
+exports.shouldAwaitTypedBody = shouldAwaitTypedBody;
+exports.promptReceiptFor = promptReceiptFor;
+exports.settleAwaitedPromptReport = settleAwaitedPromptReport;
+exports.rememberScreenOnlySubmit = rememberScreenOnlySubmit;
+exports.logClearInputFailed = logClearInputFailed;
+exports.holdsResendEnter = holdsResendEnter;
+const tmux_1 = require("../tmux/tmux");
+const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const prompt_submit_receipt_1 = require("../../lib/session/prompt-submit-receipt");
+const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
+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_composer_1 = require("./submit-verified-sender-composer");
+const submit_verified_sender_lock_1 = require("./submit-verified-sender-lock");
+/**
+ * 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.
+ *
+ * Issue #4048: the wait asks whether `ticket` still owns the session before
+ * every read of the report, after every capture, and so before any verdict it
+ * returns. The body and its Enter are already in, so a session replaced
+ * meanwhile THROWS as indeterminate ({@link assertStillOwnedAfterEnter}) — the
+ * old process may have taken the prompt — and the new session's screen and
+ * hooks are never read as this send's.
+ *
+ * The deadline is followed by one last read of the screen
+ * ({@link rereadBeforeUnreported}) before `unreported`.
+ */
+async function awaitPromptReport(params) {
+    const { sessionName, message, cliToolId, composer, enteredAt, deadline, ticket, target } = params;
+    const reported = () => {
+        (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the prompt report wait');
+        return (0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt, target) === 'received';
+    };
+    let rule = params.rule;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, submit_verified_sender_shared_1.PROMPT_REPORT_POLL_MS));
+        if (reported())
+            return { verdict: 'received' };
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+        (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the prompt report wait');
+        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 (reported())
+        return { verdict: 'received' };
+    const last = await rereadBeforeUnreported({ sessionName, message, cliToolId, composer, ticket });
+    if (last !== null)
+        return { verdict: 'screen', state: 'submitted', rule: 'A', output: last };
+    // The hook may have come while the screen was read.
+    if (reported())
+        return { verdict: 'received' };
+    return { verdict: 'unreported', rule };
+}
+/**
+ * The last look at the screen before a first prompt is called `unreported`
+ * (Issue #4048 item 1). Only A — the tool generating — saves the send: it is
+ * what a `SessionStart`-only environment (the http `UserPromptSubmit` hook not
+ * arriving) shows for a body that did go, right at the deadline. Anything else
+ * — B, F, the body still in the composer, a capture that fails — leaves the
+ * send unconfirmed, and no Enter is pressed for it. Ownership is asked before
+ * and after the capture.
+ *
+ * A says only that something is being generated, not that it is this body
+ * (a person's key, or a generation that started otherwise); that limit is
+ * accepted, as for every A verdict.
+ *
+ * @returns The frame when it shows A, else null
+ */
+async function rereadBeforeUnreported(params) {
+    const { sessionName, message, cliToolId, composer, ticket } = params;
+    (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the last read before prompt-unreported');
+    let output;
+    try {
+        output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+    }
+    catch (error) {
+        submit_verified_sender_shared_1.logger.warn('prompt-unreported-reread-failed', {
+            sessionName,
+            cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the last read before prompt-unreported');
+        return null;
+    }
+    (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the last read before prompt-unreported');
+    const verdict = (0, submit_composer_read_1.classifySubmitWithRule)(output, cliToolId, message, composer);
+    submit_verified_sender_shared_1.logger.info('prompt-unreported-reread', { sessionName, cliToolId, state: verdict.state, rule: verdict.rule });
+    return verdict.state === 'submitted' && verdict.rule === 'A' ? output : null;
+}
+/**
+ * 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).
+ *
+ * Issue #4048: only for claude, whose first prompt is hook-checked — on any
+ * other tool the warning is all (its `lastSend` is not rewritten) — and only the
+ * record of the attempt whose body was found (matched by its digest), so a later
+ * send, or one the agent reported, is never demoted. With an explicit `target`,
+ * the body is looked up only in the entry both the name and the target name.
+ */
+function reportSubmittedBodyInComposer(sessionName, cliToolId, composerText, cleared, target) {
+    if (composerText === '')
+        return;
+    const expected = target === undefined ? undefined : { ...target, cliToolId };
+    const found = (0, prompt_submit_receipt_1.findSubmittedBody)(sessionName, composerText, expected);
+    if (found === null)
+        return;
+    const owner = (0, prompt_submit_receipt_1.reportsPrompts)(cliToolId) ? (0, prompt_submit_receipt_1.getPromptSubmitTarget)(sessionName, expected) : null;
+    if (owner !== null) {
+        (0, send_attempt_state_1.markLastSendDiscarded)({ ...owner, instanceId: owner.instanceId ?? owner.cliToolId }, Date.now(), found.messageDigest);
+    }
+    submit_verified_sender_shared_1.logger.warn('pre-send-found-submitted-body', {
+        sessionName,
+        cliToolId,
+        cleared,
+        length: composerText.length,
+        lastSendDemoted: owner !== null,
+    });
+}
+/** `params.submitEnterCount`, else the composer's (Issue #4057: split out of {@link sendUnderInputLock}). */
+function resolveSubmitEnterCount(params, composer) {
+    return params.submitEnterCount ?? composer.submitEnterCount;
+}
+/** Whether a failed paste must leave a carried mark (Issue #4057: split out of {@link sendUnderInputLock}). */
+function pasteFailureMayHaveTyped(error) {
+    // Whether tmux put any of it into the pane is unknown — except after a
+    // 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';
+    return !(0, instance_input_lock_1.isInputBoundaryRefusal)(error) && !notStarted;
+}
+/** Whether the typed body is waited for before Enter (Issue #4057: split out of {@link sendUnderInputLock}). */
+function shouldAwaitTypedBody(awaitTypedBody, cliToolId) {
+    return awaitTypedBody && composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId);
+}
+/** The receipt a read-back's verdict asks for (Issue #4057: split out of {@link sendUnderInputLock}). */
+function promptReceiptFor(input) {
+    const { state, rule, message, sessionName, cliToolId, enteredAt, target } = input;
+    return (0, submit_verified_sender_composer_1.needsPromptReport)(state, rule, message)
+        ? (0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt, target)
+        : 'not-required';
+}
+/**
+ * The read-back after an `awaited` receipt, from what {@link awaitPromptReport}
+ * resolved to (Issue #4057: split out of {@link sendUnderInputLock}). Synchronous:
+ * the wait itself stays in the caller, so the continuation after it is the
+ * original one. THROWS when the agent never reported the prompt.
+ */
+function settleAwaitedPromptReport(input) {
+    const { watched, sessionName, cliToolId, attempt, rule, output, target } = input;
+    if (watched.verdict === 'unreported') {
+        // Issue #4048: no extra Enter — the last read did not show the body
+        // generating, and the body may have gone all the same (only the http
+        // hook missing), so the failure says to look before resending.
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+        submit_verified_sender_shared_1.logger.error('submit-not-confirmed:prompt-unreported', {
+            sessionName,
+            cliToolId,
+            attempt,
+            rule: watched.rule,
+            waitedMs: submit_verified_sender_shared_1.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 ${submit_verified_sender_shared_1.PROMPT_REPORT_WAIT_MS}ms ` +
+            `(Issue #4035). ${(0, submit_verified_sender_shared_1.promptUnreportedResendNote)(target, cliToolId)}`);
+    }
+    if (watched.verdict === 'received') {
+        submit_verified_sender_shared_1.logger.info('submit-confirmed-by-prompt-hook', { sessionName, cliToolId, attempt, rule });
+        return { state: 'submitted', rule, output };
+    }
+    const { state, rule: screenRule, output: screenOutput } = watched;
+    submit_verified_sender_shared_1.logger.info('submit-classified', { sessionName, cliToolId, attempt, state, rule: screenRule, receipt: 'awaited' });
+    return { state, rule: screenRule, output: screenOutput };
+}
+/** Remember a body only the screen called submitted (Issue #4057: split out of {@link sendUnderInputLock}). */
+function rememberScreenOnlySubmit(input) {
+    const { sessionName, cliToolId, enteredAt, message, ticket, target } = input;
+    // 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.
+    // Issue #4048: noted only while this send still owns the session (the
+    // entry under its name is otherwise a newer generation's), and, with an
+    // explicit target, only in the entry the target names.
+    (0, submit_verified_sender_lock_1.assertStillOwnedAfterEnter)(ticket, cliToolId, 'the submit record');
+    if ((0, prompt_submit_receipt_1.readPromptSubmitReceipt)(sessionName, cliToolId, enteredAt, target) !== 'received') {
+        (0, prompt_submit_receipt_1.noteSubmittedBody)(sessionName, message, target === undefined ? undefined : { ...target, cliToolId });
+    }
+}
+/** Log a failed clear of a replaced input line (Issue #4057: split out of {@link sendUnderInputLock}). */
+function logClearInputFailed(sessionName, cliToolId, clearError) {
+    submit_verified_sender_shared_1.logger.error('submit-clear-input-failed', {
+        sessionName,
+        cliToolId,
+        error: clearError instanceof Error ? clearError.message : String(clearError),
+    });
+}
+/**
+ * Whether a read-back that is not the last one sends no Enter (Issue #4057:
+ * split out of {@link sendUnderInputLock}; the caller goes on to the next read).
+ */
+function holdsResendEnter(input) {
+    const { state, output, sessionName, cliToolId, message, composer, attempt } = input;
+    // 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') {
+        submit_verified_sender_shared_1.logger.warn('submit-not-confirmed:composer-unreadable', { sessionName, cliToolId, attempt });
+        return true;
+    }
+    // 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 ((0, submit_verified_sender_composer_1.composerShowsForeignPasteToken)(output, cliToolId, message, composer)) {
+        submit_verified_sender_shared_1.logger.warn('submit-not-confirmed:foreign-paste-token', { sessionName, cliToolId, attempt });
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * The shared sender's logger, constants and option types (Issue #4056: split
+ * out of `submit-verified-sender.ts`, which re-exports the public ones).
+ *
+ * Imports nothing from `submit-verified-sender.ts` (no import cycle).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INPUT_READINESS_UNDER_LOCK_POLL_MS = exports.INPUT_READINESS_UNDER_LOCK_WAIT_MS = exports.PROMPT_UNREPORTED_RESEND_NOTE = exports.PROMPT_REPORT_POLL_MS = exports.PROMPT_REPORT_WAIT_MS = exports.DEFAULT_VERIFY_ATTEMPTS = exports.CARRIED_MARK_POLL_MS = exports.RECHECK_CAPTURE_LINES = exports.PASTE_COMMAND_TIMEOUT_MS = exports.DEFAULT_TYPED_BODY_ATTEMPTS = exports.TYPED_BODY_POLL_MS = exports.DEFAULT_PASTE_LANDED_ATTEMPTS = exports.PASTE_LANDED_POLL_MS = exports.LITERAL_SEND_MAX_BYTES = exports.logger = void 0;
+exports.promptUnreportedResendNote = promptUnreportedResendNote;
+const logger_1 = require("../../lib/logger");
+exports.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.
+ */
+exports.PASTE_LANDED_POLL_MS = 100;
+/** Composer reads before a paste that has not fully appeared is abandoned (2 s). */
+exports.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.
+ */
+exports.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.
+ */
+exports.DEFAULT_TYPED_BODY_ATTEMPTS = 100;
+/** Per-command timeout for `load-buffer` / `paste-buffer`, as for every other tmux call. */
+exports.PASTE_COMMAND_TIMEOUT_MS = 5000;
+/**
+ * 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.
+ */
+exports.RECHECK_CAPTURE_LINES = 200;
+/** How often a send waiting out a carried paste mark reads the composer (Issue #3945). */
+exports.CARRIED_MARK_POLL_MS = 200;
+/** Default bounded recovery Enters (each read back) before giving up (throwing). */
+exports.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. */
+exports.PROMPT_REPORT_POLL_MS = 100;
+/**
+ * What the `prompt-unreported` failure says about the body (Issue #4048): the
+ * agent's report never came, but that is no proof the body did not go — an
+ * environment where only the http `UserPromptSubmit` hook fails still submits
+ * it. Kept after the `(Issue #4035)` wording `classifySendFailure` matches.
+ */
+exports.PROMPT_UNREPORTED_RESEND_NOTE = 'The body may already have been submitted; check the pane (`commandmate capture <worktree-id> --pane`) before resending it.';
+/**
+ * {@link PROMPT_UNREPORTED_RESEND_NOTE} aimed at the pane the body went to
+ * (Issue #4048): with an explicit target its worktree and ` --instance <id>`
+ * for a named instance, else ` --agent <tool>` for the tool's primary (the
+ * worktree's default agent may be another tool) — the same flags the CLI's
+ * own hint (`paneCaptureCommand`) gives. Without a target the note names none.
+ */
+function promptUnreportedResendNote(target, cliToolId) {
+    if (target === undefined)
+        return exports.PROMPT_UNREPORTED_RESEND_NOTE;
+    const instance = target.instanceId
+        ? ` --instance ${target.instanceId}`
+        : cliToolId !== undefined
+            ? ` --agent ${cliToolId}`
+            : '';
+    return ('The body may already have been submitted; check the pane ' +
+        `(\`commandmate capture ${target.worktreeId}${instance} --pane\`) before resending it.`);
+}
+/**
+ * How long a send that owns the input lock keeps re-reading a pane whose input
+ * prompt is not up (Issue #4040), the sleeps and the captures together: a
+ * `capture-pane` may take up to its own 5 s timeout (`tmux.ts`), so a read
+ * still running at the deadline is abandoned rather than awaited. Short on
+ * purpose: the tool's own wait (15 s) ran before the lock, and every writer
+ * behind this one waits as long. It covers a picker or a redraw finishing just
+ * as the lock changed hands.
+ */
+exports.INPUT_READINESS_UNDER_LOCK_WAIT_MS = 2000;
+/** How often that wait reads the pane. */
+exports.INPUT_READINESS_UNDER_LOCK_POLL_MS = 200;