commandmate 0.48.0 → 0.49.1

package/dist/server/src/lib/relay/relay-system-line.js

@@ -34,9 +34,10 @@ const logger = (0, logger_1.createLogger)('relay-system-line');
  * @param target - Whose transcript the line goes in (always the requester, A)
  * @param subject - Whose name the sentence carries (always the worker, B)
  * @param at - Epoch ms
+ * @param detail - Issue #3957: the overlap and hold reason a `replied` line names
  * @returns Whether a row was written by this call
  */
-function writeRelaySystemLine(db, relayId, kind, target, subject, at = Date.now()) {
+function writeRelaySystemLine(db, relayId, kind, target, subject, at = Date.now(), detail = {}) {
     const requestId = `${chat_db_1.RELAY_SYSTEM_REQUEST_ID_PREFIX}${relayId}:${kind}`;
     try {
         if ((0, chat_db_1.findMessageByRequestId)(db, target.worktreeId, requestId))
@@ -46,7 +47,7 @@ function writeRelaySystemLine(db, relayId, kind, target, subject, at = Date.now(
             worktreeId: target.worktreeId,
             cliToolId: target.cliToolId,
             instanceId: target.instanceId,
-            content: (0, relay_messages_1.buildRelaySystemLine)(locale, kind, subject.alias),
+            content: (0, relay_messages_1.buildRelaySystemLine)(locale, kind, subject.alias, detail),
             relayId,
             kind,
             at,

package/dist/server/src/lib/relay/types.js

@@ -10,7 +10,7 @@
  * @module lib/relay/types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPEN_RELAY_STATES = void 0;
+exports.LEGACY_RELAY_BINDING_FIELDS = exports.OPEN_RELAY_STATES = void 0;
 exports.isOpenRelayState = isOpenRelayState;
 exports.emptyRelayCounts = emptyRelayCounts;
 /** The states from which a relay can still produce a delivery. */
@@ -19,6 +19,17 @@ exports.OPEN_RELAY_STATES = ['pending', 'prompt'];
 function isOpenRelayState(state) {
     return exports.OPEN_RELAY_STATES.includes(state);
 }
+/** The v62 fields of a row with no binding, as a legacy relay reads (Issue #3957). */
+exports.LEGACY_RELAY_BINDING_FIELDS = {
+    bindMode: 'legacy',
+    sendState: null,
+    inputBoundaryAt: null,
+    boundaryKind: null,
+    turnOpenAtSend: null,
+    obsState: null,
+    holdReason: null,
+    overlap: null,
+};
 /** An empty {@link RelayCounts}. */
 function emptyRelayCounts() {
     return { pending: 0, delivered: 0, prompt: 0, expired: 0, cancelled: 0 };

package/dist/server/src/lib/session/agent-session-lifecycle.js

@@ -45,6 +45,8 @@ const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_generation_archive_1 = require("../../lib/session/session-generation-archive");
 const session_starting_state_1 = require("../../lib/session/session-starting-state");
 const auto_yes_enter_fallback_state_1 = require("../../lib/polling/auto-yes-enter-fallback-state");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+const session_name_1 = require("../../lib/cli-tools/session-name");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/session/agent-session-lifecycle');
 /**
@@ -84,6 +86,22 @@ function beginAgentSession(target, at = Date.now()) {
     // to. A relaunch does not stop the Auto-Yes poller, so the record (and the
     // poller's keys, through the epoch) are expired here, with the generation.
     (0, auto_yes_enter_fallback_state_1.beginEnterFallbackSession)(target.worktreeId, target.cliToolId, target.instanceId);
+    // Issue #3945: the composer is a new process's. A carried paste mark of the
+    // old one no longer describes it, sends still waiting for the old composer
+    // must not type into this one, and an old send still in flight loses its
+    // ticket. A send relaunching its own pane keeps its own (see
+    // `invalidateInstanceInput`). In memory only; a name that does not resolve
+    // has no lock to expire.
+    try {
+        (0, instance_input_lock_1.invalidateInstanceInput)((0, session_name_1.resolveSessionName)(target.cliToolId, target.worktreeId, target.instanceId));
+    }
+    catch (error) {
+        logger.warn('instance-input-invalidate-failed', {
+            worktreeId: target.worktreeId,
+            cliToolId: target.cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
     const after = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     const source = (0, sources_1.getAgentEventSource)(target.cliToolId);
     logger.info('agent-session-generation-begun', {

package/dist/server/src/lib/session/claude-session.js

@@ -34,6 +34,7 @@ const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifec
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_start_error_1 = require("../../lib/session/session-start-error");
 const launch_screen_1 = require("../../lib/session/launch-screen");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const logger = (0, logger_1.createLogger)('claude-session');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ----- Helper Functions -----
@@ -166,12 +167,18 @@ exports.CLAUDE_TRUST_DIALOG_EXITED = 'trust dialog: Claude Code exited to the sh
  * dialog that outlives it, and a cursor that has not reached Yes after
  * TRUST_DIALOG_MAX_MOVES moves fails the start without Enter.
  *
+ * Issue #3975: each key goes out as an `exclusive` writer of the instance's
+ * input lock ({@link sendTrustDialogKey}), so it never lands inside a send's
+ * body or Enter, and a `respond` to the same dialog reads the screen again
+ * after it. Only the key: the polls and their sleeps stay outside the lock.
+ *
  * @param sessionName - tmux session name
  * @param dialogScreen - ANSI-stripped pane output when the dialog is open, else null
  * @param state - Mutated in place
+ * @param readMark - {@link instanceInputLaunchReadMark} taken before `dialogScreen` was captured
  * @throws {SessionStartFailedError} When the move budget is spent
  */
-async function answerTrustDialog(sessionName, dialogScreen, state) {
+async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)()) {
     if (state.pollsSinceAnswer !== null)
         state.pollsSinceAnswer++;
     if (state.pollsSinceMove !== null)
@@ -192,7 +199,8 @@ async function answerTrustDialog(sessionName, dialogScreen, state) {
         if (!due)
             return;
         try {
-            await (0, tmux_1.sendKeys)(sessionName, '', true);
+            if (!(await sendTrustDialogKey(sessionName, readMark, 'Enter')))
+                return;
             state.pollsSinceAnswer = 0;
             state.answers++;
             logger.info('trust-dialog-detected', { keys: 'Enter', attempt: state.answers });
@@ -209,7 +217,8 @@ async function answerTrustDialog(sessionName, dialogScreen, state) {
         throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK);
     }
     try {
-        await (0, tmux_1.sendSpecialKeys)(sessionName, [keys[0]]);
+        if (!(await sendTrustDialogKey(sessionName, readMark, keys[0])))
+            return;
         state.pollsSinceMove = 0;
         state.moves++;
         logger.info('trust-dialog-cursor-move', { key: keys[0], attempt: state.moves });
@@ -218,6 +227,28 @@ async function answerTrustDialog(sessionName, dialogScreen, state) {
         // Left unhandled so a later poll moves the cursor again
     }
 }
+/**
+ * Send one trust-dialog key (Enter, or a cursor move) under the instance's
+ * input lock as an `exclusive` writer (Issue #3975). When a send came between
+ * the read the key was decided on (`readMark`) and the lock, the dialog is read
+ * again and the key goes out only if that screen still calls for it.
+ *
+ * @returns Whether the key was sent; false when it was not (the next poll decides again)
+ */
+async function sendTrustDialogKey(sessionName, readMark, key) {
+    const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => {
+        const screen = await getCleanPaneOutput(sessionName);
+        if (!(0, cli_patterns_1.isClaudeTrustDialogOpen)(screen))
+            return false;
+        const keys = (0, cli_patterns_1.resolveClaudeTrustDialogKeys)(screen);
+        if (keys === null)
+            return false;
+        return key === 'Enter' ? keys.length === 1 : keys.length > 1 && keys[0] === key;
+    }, () => (key === 'Enter' ? (0, tmux_1.sendKeys)(sessionName, '', true) : (0, tmux_1.sendSpecialKeys)(sessionName, [key])), { mode: 'exclusive' });
+    if (!outcome.answered)
+        logger.info('trust-dialog-key-skipped', { key, reason: outcome.reason });
+    return outcome.answered;
+}
 /**
  * Whether the pane's foreground process is a shell again (Issue #3089). A
  * pane tmux cannot describe is not called exited; the start budget still
@@ -657,8 +688,10 @@ async function startClaudeSession(options) {
         });
         // SF-S2-003: Sanitize environment after createSession, before launching Claude CLI
         await (0, session_key_sender_1.sanitizeSessionEnvironment)(sessionName);
-        // Start Claude CLI in interactive mode using dynamically resolved path
-        await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+        // Start Claude CLI in interactive mode using dynamically resolved path.
+        // Issue #3975: one writer's turn, as gemini's launch line; the init polls
+        // below stay outside the lock.
+        await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, () => (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true));
         // Wait for Claude to initialize with dynamic detection (OCP-001)
         // Use constants instead of hardcoded values
         const maxWaitTime = exports.CLAUDE_INIT_TIMEOUT;
@@ -671,6 +704,8 @@ async function startClaudeSession(options) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             // SF-001: Use getCleanPaneOutput helper (DRY)
             let cleanOutput = null;
+            // Issue #3975: before the read the trust keys are decided on.
+            const readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)();
             try {
                 cleanOutput = await getCleanPaneOutput(sessionName);
             }
@@ -684,7 +719,7 @@ async function startClaudeSession(options) {
             // BEFORE the prompt: the dialog's cursor row (`❯ No, exit`) wears the
             // prompt glyph, so an open dialog is never read as a ready prompt.
             const trustDialogOpen = (0, cli_patterns_1.isClaudeTrustDialogOpen)(cleanOutput);
-            await answerTrustDialog(sessionName, trustDialogOpen ? cleanOutput : null, trust);
+            await answerTrustDialog(sessionName, trustDialogOpen ? cleanOutput : null, trust, readMark);
             // Claude is ready when we see the prompt (DRY-001)
             // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
             // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)

package/dist/server/src/lib/session/composer-clear.js

@@ -30,13 +30,64 @@
  * frame back to the browser.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = exports.MAX_COMPOSER_CLEAR_PASSES = void 0;
+exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = exports.MAX_COMPOSER_CLEAR_PASSES = exports.findCodexLiveComposerRow = exports.codexDialogBelow = void 0;
+exports.readClearComposer = readClearComposer;
+exports.isCodexPasteTokenOnly = isCodexPasteTokenOnly;
 exports.clearComposer = clearComposer;
+exports.recheckComposerBeforeInput = recheckComposerBeforeInput;
 const tmux_1 = require("../../lib/tmux/tmux");
 const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const composer_text_1 = require("../../lib/detection/composer-text");
+Object.defineProperty(exports, "codexDialogBelow", { enumerable: true, get: function () { return composer_text_1.codexDialogBelow; } });
+Object.defineProperty(exports, "findCodexLiveComposerRow", { enumerable: true, get: function () { return composer_text_1.findCodexLiveComposerRow; } });
+const status_detector_1 = require("../../lib/detection/status-detector");
 const logger_1 = require("../../lib/logger");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
 const logger = (0, logger_1.createLogger)('composer-clear');
+/**
+ * The composer as this loop reads it.
+ *
+ * {@link extractLiveComposerText} — the reading the unsent bar is drawn from
+ * (Issue #3927) — and for codex one more reading when it finds no
+ * composer (Issue #3906): a body of more paragraphs than the extractor's four
+ * blocks — the partly arrived paste the sender reads as `pasting` and withdraws
+ * through this function — is still a composer holding text. Only `content` is
+ * taken from that reading; anything else stays `no_composer`, so a frame this
+ * reading cannot vouch for is never reported as emptied.
+ *
+ * A composer the extractor does find is still not the live one when a dialog
+ * option is drawn below it ({@link codexDialogBelow}): that frame is
+ * `no_composer`, so no `C-e`+`C-u` goes into the dialog.
+ */
+function readClearComposer(capture, cliToolId) {
+    const read = (0, composer_text_1.extractLiveComposerText)(capture, cliToolId);
+    if (cliToolId !== 'codex' || read.state !== 'no_composer')
+        return read;
+    const rows = capture.split('\n');
+    const row = (0, composer_text_1.findCodexLiveComposerRow)(rows);
+    if (row < 0)
+        return read;
+    const held = (0, composer_text_1.readCodexComposerFrom)(rows, row);
+    return held.state === 'content' ? held : read;
+}
+/**
+ * A codex composer holding exactly one collapsed paste placeholder and nothing
+ * else (Issue #3937) — the one frame a pass sends `C-e`+`BSpace` for instead of
+ * `C-e`+`C-u` ({@link clearComposerPasteToken}).
+ *
+ * Anything more than the bare placeholder keeps the `C-e`+`C-u` pass, because
+ * none of it has been measured on a live codex: a placeholder with typed text
+ * after it (`C-e`+`BSpace` would eat the last typed character, not the
+ * placeholder), two placeholders, and a body quoting the placeholder's wording
+ * among other text. A body that is nothing but that wording typed out is not
+ * told apart here; one `BSpace` takes its `]`, and from the next read on it is
+ * ordinary text again — `C-e`+`C-u` — so the read-back still decides.
+ */
+const CODEX_PASTE_TOKEN_ONLY = /^\[Pasted Content \d+ chars?\]$/;
+/** Whether a pass over this reading should send `C-e`+`BSpace` (Issue #3937). */
+function isCodexPasteTokenOnly(read, cliToolId) {
+    return cliToolId === 'codex' && read.state === 'content' && CODEX_PASTE_TOKEN_ONLY.test(read.text.trim());
+}
 /**
  * Upper bound on `C-e`+`C-u` passes.
  *
@@ -67,15 +118,25 @@ async function clearComposer(sessionName, cliToolId, options = {}) {
     const delay = options.delay ?? defaultDelay;
     const maxPasses = options.maxPasses ?? exports.MAX_COMPOSER_CLEAR_PASSES;
     let passes = 0;
-    let result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+    let result = readClearComposer(options.initialCapture ?? (await capture(sessionName)), cliToolId);
     // Snapshot before the first pass: every later read shows less of it (a pass
     // eats one row), so this is the only moment the full text exists.
     const discardedText = result.state === 'content' ? result.text : '';
     while (result.state === 'content' && passes < maxPasses) {
-        await sendClear(sessionName);
+        if (options.beforePass !== undefined && !options.beforePass()) {
+            // Issue #3945: the composer is another writer's now; its text is not ours to erase.
+            logger.warn('composer-clear:not-owner', { sessionName, cliToolId, passes });
+            break;
+        }
+        if (isCodexPasteTokenOnly(result, cliToolId)) {
+            await (options.sendClearPasteToken ?? tmux_1.clearComposerPasteToken)(sessionName);
+        }
+        else {
+            await sendClear(sessionName);
+        }
         passes++;
         await delay(exports.COMPOSER_CLEAR_REDRAW_DELAY_MS);
-        result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+        result = readClearComposer(await capture(sessionName), cliToolId);
     }
     // Whatever happened above, the cached frame is now stale: the poller and the
     // WebSocket push both read through `captureSessionOutput`, and serving the
@@ -93,3 +154,47 @@ async function clearComposer(sessionName, cliToolId, options = {}) {
     }
     return { cleared, passes, state: result.state, remainingText: result.text, discardedText };
 }
+/**
+ * Re-read the pane under the input lock, before anything is typed (Issue #3945
+ * stage 2).
+ *
+ * The prompt guard and the tool's readiness wait ran before the lock was taken,
+ * and a dialog may have opened since — while this send queued behind another
+ * one, or in a wait that follows readiness. Every send makes it (review-1 #4). This
+ * read goes to tmux directly (`capturePane`, never the TTL cache), and its frame
+ * is one of three things:
+ *
+ *   - a dialog (`detectSessionStatus().hasActivePrompt`) — refused, `not-sent`
+ *     with the prompt guard's reason (`prompt-waiting`);
+ *   - unreadable (the capture or the detector threw) — refused, `not-sent`:
+ *     typing into a pane nobody could read is the failure this exists for;
+ *   - anything else — returned, for the pre-send clear to take as its first read.
+ *
+ * Also taken by copilot's selection-list keys right before they are typed
+ * (review-2), with the same refusals.
+ *
+ * The scraper's reading only: the structured (hooks) layer is the prompt
+ * guard's, consulted before the lock.
+ *
+ * @throws Error worded for `classifySendFailure` (`prompt-waiting` / `recheck-failed`), with
+ *   `code` {@link INPUT_RECHECK_PROMPT_WAITING_CODE} / {@link INPUT_RECHECK_FAILED_CODE} (Issue #3952)
+ */
+async function recheckComposerBeforeInput(sessionName, cliToolId) {
+    let frame;
+    let dialog;
+    try {
+        frame = await (0, tmux_1.capturePane)(sessionName, CLEAR_READBACK_CAPTURE_LINES);
+        dialog = (0, status_detector_1.detectSessionStatus)(frame, cliToolId).hasActivePrompt;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error('input-recheck-failed', { sessionName, cliToolId, error: message });
+        throw Object.assign(new Error(`Could not re-read session ${sessionName} before typing (${message}); nothing was typed (Issue #3945).`), { code: send_attempt_types_1.INPUT_RECHECK_FAILED_CODE });
+    }
+    if (dialog) {
+        logger.warn('input-recheck-prompt-waiting', { sessionName, cliToolId });
+        throw Object.assign(new Error(`A prompt dialog is open in session ${sessionName} ` +
+            '(re-checked under the input lock); nothing was typed (Issue #3945).'), { code: send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE });
+    }
+    return frame;
+}

package/dist/server/src/lib/session/current-output-builder.js

@@ -14,7 +14,6 @@ const db_1 = require("../../lib/db");
 const unclassified_frame_tracker_1 = require("../../lib/detection/unclassified-frame-tracker");
 const session_starting_state_1 = require("../../lib/session/session-starting-state");
 const composer_text_1 = require("../../lib/detection/composer-text");
-const upstream_faults_1 = require("../../lib/detection/upstream-faults");
 const opencode_pane_obstruction_1 = require("../../lib/detection/opencode-pane-obstruction");
 const logger_1 = require("../../lib/logger");
 const manager_1 = require("../../lib/cli-tools/manager");
@@ -77,8 +76,15 @@ const logger = (0, logger_1.createLogger)('current-output-builder');
  * @param instanceId - Optional agent instance ID (defaults to the primary instance)
  * @param resolution - How the caller resolved that pair, when it resolved one
  *   (Issue #1884). Appended to the payload; nothing here reads it.
+ * @param options.freshCapture - Drop the session's capture-cache entry first, so
+ *   the frame is read off the pane rather than a capture up to 5 s old
+ *   (Issue #3956: `/current-output?fresh=1`, the same step as the WS streamer's
+ *   `captureFreshPayload`). Absent, the cache answers as before.
  */
-async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId, resolution) {
+async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId, resolution, options) {
+    if (options?.freshCapture) {
+        (0, tmux_capture_cache_1.invalidateCache)(manager_1.CLIToolManager.getInstance().getTool(cliToolId).getSessionName(worktreeId, instanceId));
+    }
     const payload = await buildPayload(db, worktreeId, cliToolId, instanceId);
     // Issue #3705: the payload's own writers asked after their awaits (see
     // `buildPayload`); the progress frame below is one more write, of the turn
@@ -569,7 +575,10 @@ function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, p
         promptDedup: (0, prompt_dedup_state_1.getPromptDedupSkips)(worktreeId, cliToolId, instanceId),
         // Issue #1839: read from `realtimeSnippet`, the same rows an operator sees
         // in `capture --json`, so what the field claims can be checked against what
-        // is printed next to it.
+        // is printed next to it. Issue #3946: plus, on codex's split screen only, the
+        // transcript's last content row above that window (`matchPaneUpstreamFault`,
+        // `model-capacity` only) — then the row is not in `realtimeSnippet`, and
+        // `matchedText` carries it so the claim can still be checked.
         upstreamFault: upstreamFaultMatch
             ? {
                 id: upstreamFaultMatch.fault.id,
@@ -578,7 +587,9 @@ function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, p
             }
             : null,
         // Issue #2095: the same three keys as `upstreamFault`, read from the same
-        // rows, so an operator comparing the two is comparing like with like. The
+        // `realtimeSnippet` rows (upstreamFault alone adds codex's one transcript row
+        // above them, #3946), so an operator comparing the two is comparing like with
+        // like. The
         // detector's `boxRight` / `rows` stay off the wire — they are how the rule
         // decided, not what a caller acts on, and the payload is already a published
         // contract wide enough to be hard to change.
@@ -815,6 +826,8 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // once, here, above the first reader. The 100 rows are also what the payload
     // publishes, which is the property both fields rest on: what they claim can be
     // checked against the rows printed next to them in `capture --json`.
+    // (Issue #3946: `upstreamFault` also reads codex's last transcript row above
+    // this window on a split screen; its `matchedText` is then that row.)
     // Issue #2768: still "the 100 rows this payload publishes" — but anchored to
     // the last content row when the plain tail is entirely blank (top-anchored panes).
     const realtimeSnippet = (0, realtime_snippet_1.selectRealtimeSnippetRows)(lines).join('\n');
@@ -914,11 +927,15 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // Issue #1879: structural, and computed here next to the other frame readers
     // rather than inside a status branch — the bar it feeds must appear on the
     // strength of what is in the box, never on the strength of a status verdict.
-    const composer = (0, composer_text_1.extractComposerText)(output, cliToolId);
+    // Issue #3927: the live box — a codex composer left above a dialog is not one.
+    const composer = (0, composer_text_1.extractLiveComposerText)(output, cliToolId);
     // Issue #1839: judged on exactly what is published as `realtimeSnippet`, not
     // on `output`. The wider capture keeps a banner from an hour ago in scope, and
     // a fault the operator cannot see in the payload next to it is unverifiable.
-    const upstreamFaultMatch = (0, upstream_faults_1.matchUpstreamFault)(realtimeSnippet);
+    // Issue #3946: plus, for codex's split screen only, the transcript's last row
+    // above the window (on the `■ ` error-row rules alone) — the same entry the
+    // push poller calls; the matched row is then in `matchedText`.
+    const upstreamFaultMatch = (0, realtime_snippet_1.matchPaneUpstreamFault)(lines, cliToolId);
     const autoYesState = (0, auto_yes_manager_1.getAutoYesState)(worktreeId, cliToolId, instanceId);
     // Issue #1785 + #1784: ONE resolution for both halves, not two readers.
     //