commandmate 0.49.1 → 0.49.3

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;