commandmate 0.47.2 → 0.49.0

package/dist/server/src/lib/auto-yes-state.js

@@ -16,6 +16,7 @@ exports.buildCompositeKey = buildCompositeKey;
 exports.extractWorktreeId = extractWorktreeId;
 exports.extractCliToolId = extractCliToolId;
 exports.extractInstanceId = extractInstanceId;
+exports.autoYesAnswerModeOf = autoYesAnswerModeOf;
 exports.isAutoYesExpired = isAutoYesExpired;
 exports.getAutoYesState = getAutoYesState;
 exports.setAutoYesEnabled = setAutoYesEnabled;
@@ -36,12 +37,14 @@ exports.getCompositeKeysByWorktree = getCompositeKeysByWorktree;
 exports.deleteAutoYesStateByWorktree = deleteAutoYesStateByWorktree;
 exports.getEnabledAutoYesByWorktree = getEnabledAutoYesByWorktree;
 exports.getRestartReleasedAutoYesByWorktree = getRestartReleasedAutoYesByWorktree;
+exports.getEnabledAutoYesAnswerModeByWorktree = getEnabledAutoYesAnswerModeByWorktree;
 exports.migrateAutoYesStateWorktreeIds = migrateAutoYesStateWorktreeIds;
 exports.calculateBackoffInterval = calculateBackoffInterval;
 const auto_yes_config_1 = require("../config/auto-yes-config");
 const path_validator_1 = require("./security/path-validator");
 const types_1 = require("./cli-tools/types");
 const logger_1 = require("../lib/logger");
+const auto_yes_answer_mode_1 = require("../types/auto-yes-answer-mode");
 const global_state_1 = require("./global-state");
 const logger = (0, logger_1.createLogger)('auto-yes-state');
 // =============================================================================
@@ -124,6 +127,14 @@ function extractInstanceId(compositeKey) {
     // parts[2] = alias instanceId; fall back to parts[1] (cliToolId) for primary keys.
     return parts[2] ?? parts[1] ?? null;
 }
+/**
+ * The answer mode a state stands for (Issue #3863): its own, or
+ * `recommended` for a state that predates the field. Not meaningful on a
+ * disabled state, whose mode a later enable does not inherit.
+ */
+function autoYesAnswerModeOf(state) {
+    return state.answerMode ?? auto_yes_answer_mode_1.DEFAULT_AUTO_YES_ANSWER_MODE;
+}
 /** In-memory storage for auto-yes states (globalThis for hot reload persistence) */
 const autoYesStates = (0, global_state_1.getOrInitGlobal)('__autoYesStates', () => new Map());
 // =============================================================================
@@ -192,14 +203,28 @@ function getAutoYesState(worktreeId, cliToolId = 'claude', instanceId) {
  * @param worktreeId - Worktree identifier
  * @param cliToolId - CLI tool type
  * @param enabled - Whether to enable or disable auto-yes
- * @param duration - Optional duration in milliseconds (must be an ALLOWED_DURATIONS value).
- *                   Defaults to DEFAULT_AUTO_YES_DURATION (1 hour) when omitted.
+ * @param duration - Optional duration in milliseconds (must be an AUTO_YES_DURATIONS value,
+ *                   1〜24 whole hours). Defaults to DEFAULT_AUTO_YES_DURATION (1 hour) when omitted.
+ *                   Issue #3913: checked at run time too — an enable with any other
+ *                   value throws a RangeError and leaves the state as it was.
  * @param stopPattern - Optional regex pattern for stop condition (Issue #314).
  * @param instanceId - Optional instance identifier (Issue #896; defaults to primary).
- */
-function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern, instanceId) {
+ * @param answerMode - Issue #3863: how questions are answered. Omitted, an
+ *   enable over a LIVE grant keeps that grant's mode, and any other enable —
+ *   from off, or over a grant that has run out — starts at `recommended`.
+ *   Whether the grant is live is read through {@link getAutoYesState}, which
+ *   turns an expired grant into a disabled one first, so an enable at or after
+ *   the deadline is a new grant, not a continuation. Ignored when disabling.
+ */
+function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern, instanceId, answerMode) {
     const key = buildCompositeKey(worktreeId, cliToolId, instanceId);
     if (enabled) {
+        // Issue #3913: the type is not proof (a cast, or a caller outside the
+        // route's check), so the value is checked before anything is written.
+        if (duration !== undefined && !(0, auto_yes_config_1.isAllowedDuration)(duration)) {
+            throw new RangeError(`Invalid Auto-Yes duration: ${String(duration)} (must be 1-24 whole hours in ms)`);
+        }
+        const current = answerMode === undefined ? getAutoYesState(worktreeId, cliToolId, instanceId) : null;
         const now = Date.now();
         const effectiveDuration = duration ?? auto_yes_config_1.DEFAULT_AUTO_YES_DURATION;
         const state = {
@@ -207,6 +232,7 @@ function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern
             enabledAt: now,
             expiresAt: now + effectiveDuration,
             stopPattern,
+            answerMode: answerMode ?? (current?.enabled ? autoYesAnswerModeOf(current) : auto_yes_answer_mode_1.DEFAULT_AUTO_YES_ANSWER_MODE),
         };
         autoYesStates.set(key, state);
         notifyChangeAfterShutdown();
@@ -681,6 +707,35 @@ function getRestartReleasedAutoYesByWorktree() {
     }
     return byWorktree;
 }
+/**
+ * The answer mode of every armed instance, grouped by worktree and keyed by
+ * instance, for the worktree list (Issue #3863).
+ *
+ * Its own map rather than a field on {@link getEnabledAutoYesByWorktree}'s
+ * entries, whose `{ enabled, expiresAt }` shape the list pins (#2512). The same
+ * instances that map holds (armed, read through {@link getAutoYesState} so an
+ * expiry resolved at read time drops out), each with the mode it runs under.
+ *
+ * @returns worktreeId -> instanceId -> mode; worktrees with nothing armed are absent
+ */
+function getEnabledAutoYesAnswerModeByWorktree() {
+    const byWorktree = new Map();
+    // A snapshot of the keys: an expired read below rewrites its own entry.
+    for (const key of Array.from(autoYesStates.keys())) {
+        const cliToolId = extractCliToolId(key);
+        if (!cliToolId)
+            continue;
+        const worktreeId = extractWorktreeId(key);
+        const instanceId = extractInstanceId(key) ?? cliToolId;
+        const state = getAutoYesState(worktreeId, cliToolId, instanceId);
+        if (!state?.enabled)
+            continue;
+        const entries = byWorktree.get(worktreeId) ?? {};
+        entries[instanceId] = autoYesAnswerModeOf(state);
+        byWorktree.set(worktreeId, entries);
+    }
+    return byWorktree;
+}
 /**
  * Re-key every auto-yes state whose worktree ID is being renamed
  * (Issue #1621 Phase 3).

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

@@ -289,7 +289,7 @@ function withoutTrailingBlankRows(lines) {
         end--;
     return lines.slice(0, end);
 }
-/** Default bounded read-back attempts before giving up (throwing). */
+/** Default bounded recovery Enters (each read back) before giving up (throwing). */
 const DEFAULT_VERIFY_ATTEMPTS = 4;
 /**
  * First non-blank line of the message, trimmed. This is what a TUI shows on the
@@ -427,12 +427,148 @@ function comparePasteToken(token, message) {
  * and its first line is the input line. Every other frame (a one-row
  * composer, an empty or ghost one, none at all, another tool) is read exactly
  * as before.
+ *
+ * Issue #3880 (H-2): this is also the reader before Enter
+ * ({@link classifyPasteLanded}) and in the error text ({@link describeComposer}).
+ * The paste check used to read the twelve-row tail with {@link readComposer}
+ * alone, so a codex composer taller than that window (a 20-line paste, or 600
+ * bytes wrapped in a narrow pane) put its `›` row above the window — `unseen`,
+ * and the body that was in the composer was withdrawn and reported as not
+ * landed — and a continuation row starting with `>` (a Markdown quote) was taken
+ * for the input line — `mismatch`. The same frame read after Enter was
+ * `pending`. One reader on both sides of Enter keeps the two verdicts about the
+ * same composer.
+ */
+/**
+ * Everything a codex composer holds, for deciding that a pasted body arrived in
+ * full (Issue #3880).
+ *
+ * `extractComposerText` answers for the UI: its text stops at 2,000 characters,
+ * at 40 rows and at the composer's first blank row, so a composer that matches
+ * it may still be missing the rest of the body — or hold something after it.
+ * This reads the raw rows instead, from the `›` row down to the last block of
+ * the frame (codex's model / cwd footer), so a body with blank lines, more than
+ * 40 rows or more than 2,000 characters is compared whole, and anything typed
+ * after the body is part of what is compared.
  */
-function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
+function codexComposerRegion(output) {
+    const raw = output.split('\n');
+    const box = (0, composer_text_1.findCodexInputBox)(raw);
+    if (box === null)
+        return null;
+    return codexRegionFrom(raw, box.firstRow, box.lastRow);
+}
+/**
+ * {@link codexComposerRegion} from a known `›` row (Issue #3906): the rows from
+ * `firstRow` down to the frame's last block (the footer), ANSI and glyph
+ * stripped. `lastRow` is the end of the `›` row's own block, so a composer that
+ * is itself the frame's last block is read to the end.
+ */
+function codexRegionFrom(raw, firstRow, lastRow) {
+    const isBlank = (row) => (0, cli_patterns_1.stripAnsi)(row).trim() === '';
+    let end = raw.length - 1;
+    while (end >= 0 && isBlank(raw[end]))
+        end--;
+    let lastBlockStart = end;
+    while (lastBlockStart > 0 && !isBlank(raw[lastBlockStart - 1]))
+        lastBlockStart--;
+    const stop = lastBlockStart > lastRow ? lastBlockStart - 1 : end;
+    const rows = raw.slice(firstRow, stop + 1).map((row) => (0, cli_patterns_1.stripAnsi)(row));
+    rows[0] = rows[0].replace(/^\s*\u203A ?/, '');
+    return rows.join('\n');
+}
+/** End (inclusive) of the blank-row-delimited block that starts at `row`. */
+function blockEndFrom(raw, row) {
+    let end = row;
+    while (end + 1 < raw.length && (0, cli_patterns_1.stripAnsi)(raw[end + 1]).trim() !== '')
+        end++;
+    return end;
+}
+/** The bottom-most row of `windowLines` the marker reader takes as the input line, as a frame index. */
+function markerRowIndex(windowLines, windowStart) {
+    for (let i = windowLines.length - 1; i >= 0; i--) {
+        if (INPUT_LINE_MARKER.test(windowLines[i]))
+            return windowStart + i;
+    }
+    return -1;
+}
+function readSubmitComposer(output, cliToolId, reader, lines, windowLines, message) {
     if (cliToolId === 'codex' && reader === 'input-line-marker') {
+        const raw = output.split('\n');
+        const windowStart = lines.length - windowLines.length;
         const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
-        if (read.state === 'content' && read.text.includes('\n')) {
-            return { kind: 'text', text: firstNonBlankLine(read.text), rows: read.text.split('\n') };
+        if (read.state === 'content') {
+            const box = (0, composer_text_1.findCodexInputBox)(raw);
+            // Issue #3906: a dialog option drawn below the composer the extractor
+            // located means the dialog is what the pane shows now, on every branch
+            // below — that composer is one left from before, not this send's.
+            if (box !== null && (0, composer_text_1.codexDialogBelow)(raw, box.firstRow))
+                return { kind: 'absent' };
+            const outsideWindow = box !== null && box.firstRow < windowStart;
+            const region = codexComposerRegion(output) ?? read.text;
+            if (read.text.includes('\n')) {
+                // Issue #3906: a composer of many rows with no blank line (20 lines) has
+                // its `›` row above the window too, and is marked so like the others.
+                return {
+                    kind: 'text',
+                    text: firstNonBlankLine(read.text),
+                    rows: read.text.split('\n'),
+                    region,
+                    ...(outsideWindow ? { outsideWindow } : {}),
+                };
+            }
+            // Issue #3906 (1): the `›` row sits above the twelve-row window (a one-line
+            // paragraph, a blank line, then a tall one). The marker reader would see no
+            // input line there — `unseen` before Enter, `submitted` after it — so the
+            // composer `extractComposerText` located is read instead, whole.
+            if (outsideWindow && (0, composer_text_1.findCodexLiveComposerRow)(raw) === box.firstRow) {
+                return { kind: 'text', text: read.text.trim(), rows: [raw[box.firstRow]], region, outsideWindow: true };
+            }
+            // Issue #3880 (N1): a one-row excerpt is read as before for its verdict
+            // after Enter, but still carries the whole region — `head` with the rest of
+            // the body under a blank row is one excerpt row and must not pass for the
+            // whole body before Enter.
+            const single = readComposer(reader, lines, windowLines);
+            return single.kind === 'text' ? { ...single, region } : single;
+        }
+        if (read.state === 'no_composer') {
+            // Issue #3906 (2): more paragraphs than the four blocks the extractor
+            // searches. Whatever the marker reader takes must carry the whole region,
+            // so the composer's first line alone never passes for the body. The row is
+            // the live composer only when no dialog option is drawn below it
+            // ({@link findCodexLiveComposerRow}, the order `findCodexBottomGlyphRow`
+            // reads a frame in): a composer row left above an approval dialog is
+            // never this send's composer, however its text reads.
+            const composerRow = (0, composer_text_1.findCodexLiveComposerRow)(raw);
+            if (composerRow >= 0) {
+                const region = codexRegionFrom(raw, composerRow, blockEndFrom(raw, composerRow));
+                const text = stripInputMarker((0, cli_patterns_1.stripAnsi)(raw[composerRow]));
+                if (composerRow >= windowStart) {
+                    const single = readComposer(reader, lines, windowLines);
+                    if (single.kind === 'text' && markerRowIndex(windowLines, windowStart) === composerRow) {
+                        return { ...single, region };
+                    }
+                    return single;
+                }
+                // Above the window as well, with no dialog below it.
+                if (message !== undefined && text.length > 0 && inputMatchesBody(text, message)) {
+                    return { kind: 'text', text, rows: [raw[composerRow]], region, outsideWindow: true };
+                }
+                // Not the body's first line. A composer whose own block is empty or
+                // placeholder-only is empty; real text is read too — a `/…` command
+                // there is `replaced` as it is inside the window, and anything else is
+                // not proof that the message left ({@link classifySubmit}: `indeterminate`).
+                const held = (0, composer_text_1.readCodexComposerFrom)(raw.slice(0, blockEndFrom(raw, composerRow) + 1), composerRow);
+                if (held.state !== 'content')
+                    return { kind: 'empty' };
+                return {
+                    kind: 'text',
+                    text: firstNonBlankLine(held.text),
+                    rows: [raw[composerRow]],
+                    region,
+                    outsideWindow: true,
+                };
+            }
         }
     }
     return readComposer(reader, lines, windowLines);
@@ -448,7 +584,9 @@ function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
  *   E. A DIFFERENT slash command is in the composer    -> replaced (TUI popup
  *      autocompleted the command; clear the line and throw, never resend Enter).
  *   F. Any other non-empty text (idle placeholder/hint) -> submitted (unchanged
- *      pre-#1501 permissive default, so normal sends never spuriously fail).
+ *      pre-#1501 permissive default, so normal sends never spuriously fail) —
+ *      except in a codex composer above the read window -> indeterminate
+ *      (Issue #3906).
  *
  * 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.
@@ -481,7 +619,7 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
     if ((0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
         return 'submitted';
     }
-    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines);
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines, message);
     // B. No composer visible (scrolled off / dialog / still starting), or the
     //    composer is empty => the message left the box => submitted.
     if (composer.kind !== 'text') {
@@ -502,8 +640,11 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
         return 'replaced';
     }
     // F. Non-empty, non-command steady-state text (idle placeholder / hint) =>
-    //    submitted, preserving the pre-#1501 permissive default.
-    return 'submitted';
+    //    submitted, preserving the pre-#1501 permissive default. Not for a codex
+    //    composer above the window (Issue #3906): before #3906 that frame was
+    //    read as no composer at all; text there that is not the body says
+    //    neither that the message left nor that Enter would send it.
+    return composer.outsideWindow ? 'indeterminate' : 'submitted';
 }
 /**
  * Backward-compatible boolean view of {@link classifySubmit}: submitted vs not.
@@ -530,14 +671,53 @@ function isSubmitted(output, cliToolId, message, composerSpec = (0, composer_spe
  *   3. Anything else — the idle placeholder, a ghost suggestion, no composer —
  *      shows nothing of the body. `unseen`, which the caller decides about.
  *
- * Reads the same tail window as {@link classifySubmit}, so a history echo of an
- * earlier message above the composer is never mistaken for this one.
+ * Reads the composer the way {@link classifySubmit} does
+ * ({@link readSubmitComposer}), so a history echo of an earlier message above the
+ * composer is never mistaken for this one, and a frame both functions see holds
+ * the same composer for both (Issue #3880). A multi-row codex composer is
+ * compared as a whole ({@link codexComposerRegion}), whitespace removed
+ * (wrapping and continuation indent proof): only the WHOLE body is `landed`;
+ * the body's beginning alone is `pasting` (never enough to press Enter on), the
+ * body plus anything else or text from inside it is `mismatch`. The whole body
+ * is checked before placeholders, so a body that itself quotes
+ * `[Pasted Content 600 chars]` is its own text, not codex's placeholder; a real
+ * placeholder is only ever the composer's first row.
+ *
+ * Issue #3906: a codex composer outside the twelve-row window, or split into
+ * more blocks than `extractComposerText` searches, is still read with its whole
+ * region ({@link readSubmitComposer}), so neither `unseen` for a body that is
+ * there nor `landed` on its first line alone.
  */
 function classifyPasteLanded(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
     const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = readComposer(composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES), message);
     if (composer.kind !== 'text')
         return 'unseen';
+    if (composer.region !== undefined) {
+        const shown = compactText(composer.region);
+        const body = compactText(message);
+        if (shown === body)
+            return 'landed';
+        const placeholder = findPasteTokens(composer.text);
+        if (placeholder.tokens.length > 0) {
+            // A placeholder plus anything else — on its row or under it — is not the body as sent.
+            const below = compactText(composer.region.split('\n').slice(1).join('\n'));
+            if (placeholder.tokens.length > 1 || placeholder.rest !== '' || below !== '')
+                return 'mismatch';
+            return comparePasteToken(placeholder.tokens[0], message);
+        }
+        if (body.startsWith(shown))
+            return 'pasting';
+        // The body's beginning followed by something else, the body plus more, or a
+        // piece from inside it: the composer holds something other than the body.
+        if (inputMatchesBody(composer.text, message) || shown.startsWith(body) || body.includes(shown)) {
+            return 'mismatch';
+        }
+        return 'unseen';
+    }
+    // The whole body on one row is the body, even when it quotes a placeholder.
+    if (compactText(composer.text) === compactText(message))
+        return 'landed';
     const { tokens, rest } = findPasteTokens(composer.text);
     if (tokens.length === 0) {
         if (inputMatchesBody(composer.text, message))
@@ -591,9 +771,9 @@ async function pasteBody(sessionName, message) {
     }
 }
 /** The composer's first row, for an error message a person has to act on. */
-function describeComposer(output, composerSpec) {
+function describeComposer(output, cliToolId, composerSpec, message) {
     const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = readComposer(composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES), message);
     if (composer.kind === 'absent')
         return 'no composer on screen';
     if (composer.kind === 'empty')
@@ -666,7 +846,7 @@ async function confirmPasteLanded(params) {
     }
     const bytes = Buffer.byteLength(message, 'utf8');
     const lineCount = message.split('\n').length;
-    const shown = describeComposer(output, composer);
+    const shown = describeComposer(output, cliToolId, composer, message);
     await withdrawUnsentBody(sessionName, cliToolId, composer);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     logger.error('paste-not-landed', { sessionName, cliToolId, state, bytes, lines: lineCount, shown });
@@ -698,6 +878,12 @@ function visibleTypedBody(message) {
     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 = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    const composer = readSubmitComposer(output, 'codex', composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES), message);
+    return composer.kind === 'text' && composer.region !== undefined && compactText(composer.region) === compactText(message);
+}
 /**
  * Wait until the composer shows the typed body; only then may Enter be pressed
  * (Issue #3366).
@@ -711,6 +897,11 @@ function visibleTypedBody(message) {
  * a prefix is not enough, because codex can draw the first keystrokes before it
  * decides the rest are a burst.
  *
+ * On codex the verdict is the whole composer against the whole body
+ * ({@link codexComposerShowsWholeBody}, Issue #3906): the extractor's text is
+ * the body's first paragraph at most, so on its own it would let Enter go on a
+ * body whose later paragraphs had not been drawn.
+ *
  * A body that never appears is taken back out and the send THROWS without
  * Enter — nothing was submitted, so the caller must not print `Message sent.`.
  *
@@ -725,12 +916,21 @@ async function confirmTypedBodyLanded(params) {
     for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
         await new Promise((resolve) => setTimeout(resolve, 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))
+                return;
+            continue;
+        }
         const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
         if (read.state === 'content' && compactText(read.text) === expected)
             return;
     }
     const bytes = Buffer.byteLength(message, 'utf8');
-    const shown = describeComposer(output, composer);
+    const shown = describeComposer(output, cliToolId, composer, message);
     await withdrawUnsentBody(sessionName, cliToolId, composer);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     logger.error('typed-body-not-landed', { sessionName, cliToolId, bytes, attempts, shown });
@@ -819,9 +1019,10 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
  *
  * The body and Enter are always separate tmux commands (never batched), so the
  * TUI cannot swallow the Enter inside a bracketed-paste buffer. After the
- * initial submit the pane is read back up to `verifyAttempts` times; each time
- * it is still pending an extra Enter is sent. If submit can never be confirmed
- * the function THROWS — callers must surface that as a failure, never as
+ * initial submit the pane is read back; each time it is still pending an extra
+ * Enter is sent, up to `verifyAttempts` of them, and every Enter — the last one
+ * included (Issue #3880) — is read back before a verdict. If submit can never
+ * be confirmed the function THROWS — callers must surface that as a failure, never as
  * success (Issues #1469/#1470/#1471).
  *
  * A body longer than {@link LITERAL_SEND_MAX_BYTES} is pasted instead of typed,
@@ -884,8 +1085,14 @@ async function sendMessageWithSubmitVerification(params) {
     }
     // 4. Read-back verification: confirm the message left the input box, resend
     //    Enter while it is still pending, and throw if it never submits.
+    //
+    //    Every Enter is followed by a read (Issue #3880, H-1): `attempts` resends
+    //    take `attempts + 1` reads. The loop used to resend on its last pending read
+    //    and throw straight after, so a message that only that last Enter submitted
+    //    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);
-    for (let attempt = 0; attempt < attempts; attempt++) {
+    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 = classifySubmit(output, cliToolId, message, composer);
@@ -913,6 +1120,15 @@ async function sendMessageWithSubmitVerification(params) {
             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;
+        }
         // state === 'pending' — still typed-but-unsent, resend a single Enter and re-check.
         logger.warn('submit-not-confirmed:resending-enter', {
             sessionName,

package/dist/server/src/lib/db/chat-db.js

@@ -715,7 +715,11 @@ function recordAnsweredPrompt(db, params) {
     }
     const answeredAt = new Date().toISOString();
     if (target) {
-        const updated = { ...target.parsed, status: 'answered', answer, answeredAt, answeredBy };
+        // Issue #3881 (review P2-2): the row keeps the reading it was saved with;
+        // one saved without a reading (before #3881) takes the answerer's, so a
+        // row's classification does not depend on which writer came first.
+        const reading = target.parsed.reading === undefined && promptData.reading !== undefined ? { reading: promptData.reading } : {};
+        const updated = { ...target.parsed, ...reading, status: 'answered', answer, answeredAt, answeredBy };
         updatePromptData(db, target.id, updated);
         return { message: getMessageById(db, target.id), created: false };
     }

package/dist/server/src/lib/db/verification-db.js

@@ -21,6 +21,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_RUN_HISTORY_DAYS = exports.MAX_RUN_HISTORY_LIMIT = exports.DEFAULT_RUN_HISTORY_LIMIT = exports.VERIFICATION_GATE_SOURCES = exports.VERIFICATION_TRIGGERS = void 0;
+exports.parseGateTiming = parseGateTiming;
 exports.createVerificationRun = createVerificationRun;
 exports.finishVerificationRun = finishVerificationRun;
 exports.createGateResult = createGateResult;
@@ -54,6 +55,20 @@ exports.VERIFICATION_TRIGGERS = ['manual', 'wait', 'api', 'task'];
  * The runtime tuple mirrors the CHECK constraint in migration v56.
  */
 exports.VERIFICATION_GATE_SOURCES = ['builtin', 'verify.yaml', 'contract'];
+/**
+ * How much of a gate's `log_tail` the history listing reads: enough for the
+ * `[timing]` line, which is the last line — never the log body.
+ */
+const TIMING_TAIL_CHARS = 200;
+/** The last line of `logEnd`, when it is the runner's `[timing]` line. */
+const TIMING_LINE = /(?:^|\n)\[timing\] queue=(\d+(?:\.\d+)?)s mutex=(\d+(?:\.\d+)?)s run=(\d+(?:\.\d+)?)s\s*$/;
+/** The {@link VerificationGateTiming} of a gate whose `log_tail` ends with `logEnd`, or null. */
+function parseGateTiming(logEnd) {
+    const match = TIMING_LINE.exec(logEnd ?? '');
+    if (!match)
+        return null;
+    return { queueSec: Number(match[1]), mutexSec: Number(match[2]), runSec: Number(match[3]) };
+}
 const RUN_COLUMNS = `
   id, worktree_id, instance_id, task_id, trigger, status, base_ref, started_at, finished_at
 `;
@@ -247,7 +262,8 @@ function clampInt(value, fallback, min, max) {
 }
 /**
  * Recent runs across worktrees, newest first, each with its gate verdicts but
- * no log bodies (Issue #1593).
+ * no log bodies (Issue #1593). A gate's `[timing]` line is the one piece of its
+ * log that is carried, parsed into numbers (`timing`, Issue #3884).
  *
  * `worktreeId` is optional because the advisor that consumes this (#1594) looks
  * at a repository's trend, not one worktree's. Ordering follows the same
@@ -285,7 +301,8 @@ function listVerificationRunsForPeriod(db, opts = {}) {
     const placeholders = runRows.map(() => '?').join(', ');
     const gateRows = db
         .prepare(`
-      SELECT run_id, gate_id, status, exit_code, duration_ms, source
+      SELECT run_id, gate_id, status, exit_code, duration_ms, source,
+             substr(log_tail, -${TIMING_TAIL_CHARS}) AS log_end
       FROM verification_gate_results
       WHERE run_id IN (${placeholders})
       ORDER BY started_at ASC, id ASC
@@ -300,6 +317,10 @@ function listVerificationRunsForPeriod(db, opts = {}) {
             durationMs: row.duration_ms,
             source: row.source ?? null,
         };
+        // Only the numbers leave this function: the log stays out of the listing (#3884).
+        const timing = parseGateTiming(row.log_end);
+        if (timing)
+            summary.timing = timing;
         const bucket = byRun.get(row.run_id);
         if (bucket)
             bucket.push(summary);