commandmate 0.48.0 → 0.49.0

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

@@ -456,6 +456,15 @@ function codexComposerRegion(output) {
     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]))
@@ -463,18 +472,57 @@ function codexComposerRegion(output) {
     let lastBlockStart = end;
     while (lastBlockStart > 0 && !isBlank(raw[lastBlockStart - 1]))
         lastBlockStart--;
-    const stop = lastBlockStart > box.lastRow ? lastBlockStart - 1 : end;
-    const rows = raw.slice(box.firstRow, stop + 1).map((row) => (0, cli_patterns_1.stripAnsi)(row));
+    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');
 }
-function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
+/** 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') {
+            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')) {
-                return { kind: 'text', text: firstNonBlankLine(read.text), rows: read.text.split('\n'), region };
+                // 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
@@ -483,6 +531,45 @@ function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
             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);
 }
@@ -497,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.
@@ -530,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') {
@@ -551,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.
@@ -590,10 +682,15 @@ function isSubmitted(output, cliToolId, message, composerSpec = (0, composer_spe
  * 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 = readSubmitComposer(output, cliToolId, 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) {
@@ -674,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, cliToolId, composerSpec) {
+function describeComposer(output, cliToolId, composerSpec, message) {
     const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = readSubmitComposer(output, cliToolId, 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')
@@ -749,7 +846,7 @@ async function confirmPasteLanded(params) {
     }
     const bytes = Buffer.byteLength(message, 'utf8');
     const lineCount = message.split('\n').length;
-    const shown = describeComposer(output, cliToolId, 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 });
@@ -781,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).
@@ -794,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.`.
  *
@@ -808,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, cliToolId, 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 });
@@ -1003,9 +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' after the final resend's read-back: give up below.
+        // 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/detection/composer-text.js

@@ -93,12 +93,25 @@
  * server does. That is deliberate — `useTerminalPanePolling` derives the
  * composer text client-side from the frame it already has, which keeps the
  * WebSocket push path and the HTTP poll path from disagreeing.
+ *
+ * That is also why the "a dialog below the composer means no composer" rule
+ * (Issue #3927, {@link codexDialogBelow}) lives here rather than next to the
+ * clear in `session/composer-clear.ts`: the clear, the published
+ * `composerText` and the browser's own reading all go through
+ * {@link extractLiveComposerText}, and `tools/codex/cli-patterns.ts`, whose
+ * `readCodexGlyphRowKind` the rule was first written on, imports the logger.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_COMPOSER_TOOLS = exports.COMPOSER_TEXT_MAX_CHARS = void 0;
 exports.findClaudeInputBox = findClaudeInputBox;
+exports.isCodexComposerRow = isCodexComposerRow;
+exports.isCodexBoldGutterRow = isCodexBoldGutterRow;
+exports.findCodexLiveComposerRow = findCodexLiveComposerRow;
+exports.codexDialogBelow = codexDialogBelow;
 exports.findCodexInputBox = findCodexInputBox;
 exports.extractComposerText = extractComposerText;
+exports.extractLiveComposerText = extractLiveComposerText;
+exports.readCodexComposerFrom = readCodexComposerFrom;
 const ansi_1 = require("./ansi");
 /**
  * Upper bound on the published composer text.
@@ -208,6 +221,10 @@ function isBlankRow(line) {
  * A bare `\u203A` with nothing after it is accepted: `capture-pane` trims trailing
  * whitespace, so that is what a composer with neither text nor placeholder looks
  * like, and calling it `no_composer` would be a worse answer than `empty`.
+ *
+ * Exported for the send path (Issue #3906): when {@link findCodexInputBox}'s
+ * block bound cannot reach a composer split by many blank rows, the sender
+ * still has to tell the real `\u203A` row from these look-alikes.
  */
 function isCodexComposerRow(line) {
     if (line === undefined)
@@ -226,6 +243,120 @@ function isCodexComposerRow(line) {
     const firstText = chars.slice(2).find(c => c.ch !== ' ');
     return firstText === undefined || !firstText.bold;
 }
+/**
+ * Whether a codex `\u203A` row has its gutter space inside the glyph's bold span
+ * (Issue #3906).
+ *
+ * codex also draws the transcript echo of a sent message with a bold glyph that
+ * is NOT dim — `ESC[1m\u203A ESC[0m` + text (measured on 0.153.2 and 0.160.0:
+ * `tests/fixtures/codex-live-2310/turn-submitted-no-status.txt:36`,
+ * `codex-multiline-composer-3205/tc104-raw-pane.txt:20`,
+ * `codex-dialogs-0157/approval.txt:24`) — which {@link isCodexComposerRow}
+ * accepts. Every measured composer resets right after its glyph
+ * (`ESC[1m\u203AESC[0m `), and every echo carries the space in the glyph's span,
+ * dim or not. {@link findCodexInputBox} does not need this — it only looks at
+ * the frame's last blocks, where the live composer is — but a search that climbs
+ * past them into the transcript does.
+ */
+function isCodexBoldGutterRow(line) {
+    if (line === undefined)
+        return false;
+    const chars = scanAttributedChars(line);
+    return chars.length > 1 && chars[0].ch === CODEX_PROMPT_GLYPH && chars[1].ch === ' ' && chars[1].bold;
+}
+/**
+ * Classify one raw codex row whose first rendered glyph is `\u203A` (Issue #3927).
+ *
+ * The same reading as `readCodexGlyphRowKind` in `tools/codex/cli-patterns.ts`,
+ * re-stated on this module's SGR scan because that module imports the logger
+ * and this one is read by the browser bundle. In order: no attributes at all →
+ * null (a stripped capture, where every `\u203A` use reads the same); a dim
+ * glyph → the transcript echo; a bold label → a dialog option; a dim label →
+ * the composer's placeholder; a coloured glyph whose label is drawn in the
+ * same colour → a dialog option (from 0.155.1 the composer's glyph is
+ * coloured too, but it resets before its label); anything else → the composer.
+ * `tests/unit/lib/detection/composer-text-dialog-below-3927.test.ts` holds the
+ * two readings equal over the codex fixtures.
+ *
+ * @param rawRow - One row of the capture, ANSI intact
+ */
+function readCodexGlyphRow(rawRow) {
+    if (!rawRow.includes('\x1b'))
+        return null;
+    const chars = scanAttributedChars(rawRow);
+    const glyphIndex = chars.findIndex(c => c.ch.trim() !== '');
+    if (glyphIndex < 0 || chars[glyphIndex].ch !== CODEX_PROMPT_GLYPH)
+        return null;
+    const glyph = chars[glyphIndex];
+    if (glyph.dim)
+        return 'transcript-echo';
+    const label = chars.slice(glyphIndex + 1).find(c => c.ch.trim() !== '');
+    if (label?.bold)
+        return 'option';
+    if (label?.dim)
+        return 'composer';
+    if (glyph.fg !== null && label?.fg === glyph.fg)
+        return 'option';
+    return 'composer';
+}
+/**
+ * A composer row by every reading: {@link isCodexComposerRow}, and not the
+ * bold-not-dim echo ({@link isCodexBoldGutterRow}). The caller has already had
+ * {@link readCodexGlyphRow} call it `'composer'`, which also requires ANSI
+ * attributes: an attribute-free `\u203A` row (a stripped capture, where a dialog
+ * option reads the same as a composer) is never taken (Issue #3906).
+ */
+function isLiveComposerRow(row) {
+    return isCodexComposerRow(row) && !isCodexBoldGutterRow(row);
+}
+/**
+ * The live codex composer's `\u203A` row, wherever it is in the frame (Issue #3906).
+ *
+ * Read from the bottom, in the order `findCodexBottomGlyphRow` reads a frame:
+ * a dialog's highlighted option reached before any composer row means the
+ * dialog is what the pane shows now, and a composer row above it is one left
+ * there from before (codex-live-1671) — so the answer is -1, not that row. The
+ * transcript echo of a sent message is skipped, dim ({@link isCodexComposerRow}
+ * rejects it) or not ({@link isCodexBoldGutterRow}).
+ *
+ * Moved here from `session/composer-clear.ts` by Issue #3927, with
+ * {@link codexDialogBelow}, so the browser can read the same rule.
+ *
+ * @param rows - The capture split into rows, ANSI intact
+ * @returns The row's index, or -1 when no live composer row is drawn
+ */
+function findCodexLiveComposerRow(rows) {
+    for (let i = rows.length - 1; i >= 0; i--) {
+        const kind = readCodexGlyphRow(rows[i]);
+        if (kind === 'option')
+            return -1;
+        if (kind === 'composer' && isLiveComposerRow(rows[i]))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Whether a dialog, not a composer, is what the pane shows below `row` (Issue #3906).
+ *
+ * The same bottom-up reading as {@link findCodexLiveComposerRow}, stopped at
+ * `row`: a dialog's highlighted option reached first means the composer at
+ * `row` — even one {@link findCodexInputBox} located among the frame's last
+ * blocks — was left there from before the dialog opened. A live composer row
+ * reached first means it was not.
+ *
+ * @param rows - The capture split into rows, ANSI intact
+ * @param row - Index of the composer's `\u203A` row
+ */
+function codexDialogBelow(rows, row) {
+    for (let i = rows.length - 1; i > row; i--) {
+        const kind = readCodexGlyphRow(rows[i]);
+        if (kind === 'option')
+            return true;
+        if (kind === 'composer' && isLiveComposerRow(rows[i]))
+            return false;
+    }
+    return false;
+}
 /**
  * Locate codex's composer in a captured pane (Issue #1890).
  *
@@ -282,7 +413,7 @@ function findCodexInputBox(lines) {
  */
 function applySgr(params, state) {
     const parts = params === '' ? ['0'] : params.split(';');
-    let { dim, bold } = state;
+    let { dim, bold, fg } = state;
     for (let i = 0; i < parts.length; i++) {
         const code = parts[i] === '' ? 0 : Number(parts[i]);
         if (Number.isNaN(code))
@@ -290,15 +421,18 @@ function applySgr(params, state) {
         if (code === 38 || code === 48 || code === 58) {
             const mode = parts[i + 1] === '' || parts[i + 1] === undefined ? -1 : Number(parts[i + 1]);
             // 5 = 256-colour (one argument), 2 = 24-bit RGB (three arguments).
-            if (mode === 5)
-                i += 2;
-            else if (mode === 2)
-                i += 4;
-            else
-                i += 1;
+            const argCount = mode === 5 ? 2 : mode === 2 ? 4 : 1;
+            if (code === 38)
+                fg = parts.slice(i + 1, i + 1 + argCount).join(';');
+            i += argCount;
             continue;
         }
-        if (code === 0 || code === 22) {
+        if (code === 0) {
+            dim = false;
+            bold = false;
+            fg = null;
+        }
+        else if (code === 22) {
             dim = false;
             bold = false;
         }
@@ -306,8 +440,12 @@ function applySgr(params, state) {
             bold = true;
         else if (code === 2)
             dim = true;
+        else if (code === 39)
+            fg = null;
+        else if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97))
+            fg = String(code);
     }
-    return { dim, bold };
+    return { dim, bold, fg };
 }
 /**
  * Split one raw pane row into rendered characters tagged with their dim state.
@@ -319,12 +457,12 @@ function applySgr(params, state) {
  */
 function scanAttributedChars(line) {
     const out = [];
-    let state = { dim: false, bold: false };
+    let state = { dim: false, bold: false, fg: null };
     let i = 0;
     while (i < line.length) {
         const ch = line[i];
         if (ch !== '\x1b') {
-            out.push({ ch, dim: state.dim, bold: state.bold });
+            out.push({ ch, dim: state.dim, bold: state.bold, fg: state.fg });
             i++;
             continue;
         }
@@ -430,6 +568,72 @@ function extractComposerText(rawCapture, cliToolId) {
     const region = locateComposer(lines, cliToolId);
     if (region === null)
         return { text: '', state: 'no_composer' };
+    return readComposerRegion(lines, region);
+}
+/**
+ * The composer the pane shows NOW — {@link extractComposerText}, less a codex
+ * composer that a dialog has opened below (Issue #3927).
+ *
+ * codex draws on the normal screen, so a composer row from before a dialog
+ * opened can still sit among the frame's last blocks, above the dialog's
+ * highlighted option. {@link extractComposerText} locates it and reports its
+ * old text as `content`; this reports `no_composer`, the answer the clear
+ * (`session/composer-clear.ts`) has given that frame since #3906. The two
+ * display paths — the published `composerText`
+ * (`session/current-output-builder.ts`) and the browser's own reading
+ * (`hooks/useTerminalPanePolling.ts`) — read through this, so the unsent bar
+ * neither shows text its [Clear] cannot remove nor offers a [Run] whose Enter
+ * would land in the dialog.
+ *
+ * {@link extractComposerText} itself keeps its reading. The sender
+ * (`cli-tools/submit-verified-sender.ts`) applies {@link codexDialogBelow} to
+ * the box it locates on its own branches, and Auto-Yes's Enter fallback and
+ * the send-residue check are left reading the box as before.
+ *
+ * @param rawCapture - A pane capture with ANSI attributes intact
+ * @param cliToolId - The CLI whose session was captured
+ */
+function extractLiveComposerText(rawCapture, cliToolId) {
+    const read = extractComposerText(rawCapture, cliToolId);
+    if (cliToolId !== 'codex' || read.state === 'no_composer' || read.state === 'unsupported_tool')
+        return read;
+    const lines = rawCapture.split('\n');
+    const box = findCodexInputBox(lines);
+    if (box !== null && codexDialogBelow(lines, box.firstRow))
+        return { text: '', state: 'no_composer' };
+    return read;
+}
+/**
+ * Read a codex composer from a known `\u203A` row (Issue #3906).
+ *
+ * {@link findCodexInputBox} only searches the frame's last four blocks, and
+ * takes the composer's own block alone: a body of several paragraphs puts its
+ * `\u203A` row higher up, and its text stops at the first blank row. This reads
+ * from `firstRow` down to the frame's last block — codex's model / cwd footer —
+ * blank rows included, under the same dim rule as {@link extractComposerText}.
+ * When the composer's own block is the frame's last block it is read to the end.
+ *
+ * Whether `firstRow` is the live composer — not a row left above a dialog — is
+ * the caller's question; this only reads it.
+ *
+ * @param lines - Captured pane lines, ANSI intact
+ * @param firstRow - Index of a row {@link isCodexComposerRow} accepts
+ */
+function readCodexComposerFrom(lines, firstRow) {
+    let end = lines.length - 1;
+    while (end >= 0 && isBlankRow(lines[end]))
+        end--;
+    let lastBlockStart = end;
+    while (lastBlockStart > 0 && !isBlankRow(lines[lastBlockStart - 1]))
+        lastBlockStart--;
+    let ownBlockEnd = firstRow;
+    while (ownBlockEnd + 1 < lines.length && !isBlankRow(lines[ownBlockEnd + 1]))
+        ownBlockEnd++;
+    const lastRow = lastBlockStart > ownBlockEnd ? lastBlockStart - 1 : end;
+    return readComposerRegion(lines, { firstRow, lastRow, glyph: CODEX_PROMPT_GLYPH_PATTERN });
+}
+/** The text of a located composer region, under the dim rule. */
+function readComposerRegion(lines, region) {
     const realRows = [];
     const renderedRows = [];
     for (let i = region.firstRow; i <= region.lastRow; i++) {