commandmate 0.49.2 → 0.50.0

package/dist/server/src/lib/detection/tools/claude/patterns.js

@@ -50,6 +50,8 @@ exports.CLAUDE_SESSION_ERROR_REGEX_PATTERNS = exports.CLAUDE_SESSION_ERROR_PATTE
 exports.findClaudeChromeStart = findClaudeChromeStart;
 exports.resolveClaudeTrustDialogKeys = resolveClaudeTrustDialogKeys;
 exports.isClaudeTrustDialogOpen = isClaudeTrustDialogOpen;
+exports.resolveClaudeAutoDefaultNudgeKey = resolveClaudeAutoDefaultNudgeKey;
+exports.isClaudeAutoDefaultNudgeOpen = isClaudeAutoDefaultNudgeOpen;
 const composer_text_1 = require("../../composer-text");
 /**
  * Claude's turn-completion marker: a spinner glyph, a verb, and a duration.
@@ -278,6 +280,80 @@ function findOpenClaudeTrustYesRow(lines) {
     }
     return -1;
 }
+/** The question of Claude Code's offer to make auto mode the default (Issue #4134, 2.1.318). */
+const CLAUDE_AUTO_DEFAULT_NUDGE_QUESTION = /Make auto mode your default permission mode\?/;
+/** The option that writes `permissions.defaultMode: "auto"` to the operator's settings. */
+const CLAUDE_AUTO_DEFAULT_NUDGE_YES_ROW = /^\s*(?:([>❯])\s+)?Yes, set auto mode as my default permission mode\s*$/;
+/** The option that keeps their mode, whichever it is (`current_mode` in the executable). */
+const CLAUDE_AUTO_DEFAULT_NUDGE_NO_ROW = /^\s*(?:([>❯])\s+)?No, keep \S.*$/;
+/** How far below the question the options may start: the description wraps with the pane's width. */
+const CLAUDE_AUTO_DEFAULT_NUDGE_MAX_ROWS = 8;
+/**
+ * The key that moves Claude Code's "Make auto mode your default permission
+ * mode?" towards No, or `null` when the dialog is not open or its cursor cannot
+ * be read (Issue #4134).
+ *
+ * The launch answers No because it is the answer that changes nothing: No writes
+ * only `hasSeenAutoDefaultNudge` to `~/.claude.json`, Yes rewrites the operator's
+ * `permissions.defaultMode` (measured on 2.1.318, and read in its executable).
+ * The cursor starts on Yes, so Enter is returned only for a screen showing it on
+ * No, and the option rows have to be the last thing on the pane: Claude's input
+ * box below them means this is scrollback or a quotation.
+ *
+ * @param output - ANSI-stripped pane output
+ * @returns `Down` or `Up` to move, `Enter` to confirm No, or null
+ */
+function resolveClaudeAutoDefaultNudgeKey(output) {
+    const rows = readClaudeAutoDefaultNudgeRows(output);
+    if (rows === null)
+        return null;
+    if (rows.no.cursor)
+        return 'Enter';
+    if (!rows.yes.cursor)
+        return null;
+    return rows.yes.index < rows.no.index ? 'Down' : 'Up';
+}
+/**
+ * Whether the dialog of {@link resolveClaudeAutoDefaultNudgeKey} is the open screen.
+ *
+ * @param output - ANSI-stripped pane output
+ */
+function isClaudeAutoDefaultNudgeOpen(output) {
+    return readClaudeAutoDefaultNudgeRows(output) !== null;
+}
+function readClaudeAutoDefaultNudgeRows(output) {
+    const lines = output.split('\n');
+    let question = -1;
+    for (let i = lines.length - 1; i >= 0 && question === -1; i--) {
+        if (CLAUDE_AUTO_DEFAULT_NUDGE_QUESTION.test(lines[i]))
+            question = i;
+    }
+    if (question === -1)
+        return null;
+    // Below the question there is only the description and the two options.
+    const below = lines.slice(question + 1);
+    if (below.some((line) => exports.CLAUDE_SEPARATOR_PATTERN.test(line)))
+        return null;
+    let yes = null;
+    let no = null;
+    let last = -1;
+    for (let offset = 0; offset < below.length; offset++) {
+        const line = below[offset];
+        if (line.trim() !== '')
+            last = offset;
+        if (offset >= CLAUDE_AUTO_DEFAULT_NUDGE_MAX_ROWS)
+            continue;
+        const yesMatch = CLAUDE_AUTO_DEFAULT_NUDGE_YES_ROW.exec(line);
+        if (yesMatch)
+            yes = { index: offset, cursor: yesMatch[1] !== undefined };
+        const noMatch = CLAUDE_AUTO_DEFAULT_NUDGE_NO_ROW.exec(line);
+        if (noMatch)
+            no = { index: offset, cursor: noMatch[1] !== undefined };
+    }
+    if (yes === null || no === null)
+        return null;
+    return last === Math.max(yes.index, no.index) ? { yes, no } : null;
+}
 /**
  * [Issue #1495] Footer signature of Claude Code's `/model` local-settings overlay.
  * Verified against a real Claude Code v2.1.218 capture, the footer reads:

package/dist/server/src/lib/detection/tools/codex/cli-patterns.js

@@ -156,6 +156,11 @@ exports.CODEX_DIALOG_RULES_VERIFIED_AGAINST = {
  * | `Press space to select or enter to save` | `/experimental` (0.155.1) | 1st |
  * | `left/right group · enter edit shortcut · … · esc close` | `/keymap` | 2nd |
  * | `enter continue · esc skip` | update offer (0.157.1, Issue #3020) | 2nd |
+ * | `enter confirm · esc skip` | hook review (0.166.0, Issue #4134) | 2nd |
+ * | `t trust all · enter review · esc close` | hooks list (0.166.0) | 2nd |
+ * | `t trust · esc back` | hooks detail (0.166.0) | 2nd |
+ * | `enter details · esc close` | hooks list, nothing to review (0.166.0) | 2nd |
+ * | `space/enter toggle · esc back` | hooks detail, trusted (0.166.0) | 2nd |
  *
  * No `/g` (keeps `.test()` stateless) and no nested quantifiers (ReDoS-safe).
  */

package/dist/server/src/lib/detection/tools/codex/detect.js

@@ -196,6 +196,8 @@ exports.codexStatusDetector = (0, run_detection_1.createToolStatusDetector)({
         // codex-cli 0.148.0 answers "1. Review hooks" with a two-screen review UI:
         //   screen 2 "Press t to trust all; enter to review hooks; esc to close"
         //   screen 3 "Press t to trust; esc to go back"
+        // and 0.166.0 (Issue #4134) rewords them and leaves them open after `t`
+        // (`hooks-settled`, see `getCodexLifecycleDialog`).
         // Neither carries a numbered option, a "press enter to confirm" footer, or any
         // thinking indicator, so every branch below falls through to the `running`
         // default -- which is how two live sessions sat parked on screen 3 while the UI
@@ -204,7 +206,9 @@ exports.codexStatusDetector = (0, run_detection_1.createToolStatusDetector)({
         // Checked ahead of prompt detection because the transcript rows on screen 2 are
         // ordinary text that must not be read as options.
         const codexLifecycleDialog = (0, cli_patterns_1.getCodexLifecycleDialog)((0, frame_1.withLiveRegion)(frame, 'codex'));
-        if (codexLifecycleDialog === 'hooks-list' || codexLifecycleDialog === 'hooks-detail') {
+        if (codexLifecycleDialog === 'hooks-list' ||
+            codexLifecycleDialog === 'hooks-detail' ||
+            codexLifecycleDialog === 'hooks-settled') {
             return (0, verdicts_1.positiveVerdictWithPrompt)('waiting', status_reason_1.STATUS_REASON.CODEX_HOOKS_REVIEW, detectCodexPrompt(frame.clean));
         }
         // 0.8. Codex: selection list detection BEFORE prompt detection (Issue #622)

package/dist/server/src/lib/detection/tools/codex/patterns.js

@@ -10,6 +10,7 @@ exports.isCodexTurnActive = isCodexTurnActive;
 exports.isCodexPromptReady = isCodexPromptReady;
 exports.findCodexComposerRow = findCodexComposerRow;
 exports.getCodexActiveDialog = getCodexActiveDialog;
+exports.readCodexEnterConfirmedCursor = readCodexEnterConfirmedCursor;
 exports.getCodexLifecycleDialog = getCodexLifecycleDialog;
 exports.findCodexChromeStart = findCodexChromeStart;
 exports.findCodexUserEchoIndex = findCodexUserEchoIndex;
@@ -346,14 +347,61 @@ exports.CODEX_HOOKS_REVIEW_ANCHORS = ['Hooks need review', 'Continue without tru
  * The semicolon is what separates it from screen 3's footer — "trust all;" and
  * "trust;" are disjoint — and matching the footer rather than the table above it
  * keeps the two screens distinguishable by a single line each.
+ *
+ * 0.166.0 (Issue #4134): `t trust all · enter review · esc close`.
  */
-const CODEX_HOOKS_LIST_FOOTER_PATTERN = /press\s+t\s+to\s+trust\s+all\s*;/i;
+const CODEX_HOOKS_LIST_FOOTER_PATTERN = /press\s+t\s+to\s+trust\s+all\s*;|^\s*t\s+trust\s+all\s+·\s+enter\s+review\s+·\s+esc\s+close\s*$/i;
 /**
  * Footer of screen 3, the per-hook review DETAIL (Issue #1829):
  * `Press t to trust; esc to go back`. Where both live sessions in the Issue were
  * found parked.
+ *
+ * 0.166.0 (Issue #4134): `t trust · esc back`.
+ */
+const CODEX_HOOKS_DETAIL_FOOTER_PATTERN = /press\s+t\s+to\s+trust\s*;|^\s*t\s+trust\s+·\s+esc\s+back\s*$/i;
+/**
+ * The same two screens with nothing left to review (0.166.0, Issue #4134):
+ * `enter details · esc close` and `space/enter toggle · esc back`. `t` no longer
+ * closes the screen on this build, so a launch that granted trust is left here
+ * until `esc`, and `› PreToolUse` on the list wears the composer glyph.
  */
-const CODEX_HOOKS_DETAIL_FOOTER_PATTERN = /press\s+t\s+to\s+trust\s*;/i;
+const CODEX_HOOKS_SETTLED_FOOTER_PATTERN = /^\s*(?:enter\s+details\s+·\s+esc\s+close|space\/enter\s+toggle\s+·\s+esc\s+back)\s*$/i;
+/**
+ * Footer of the screens whose digit only moves the cursor (0.166.0, Issue #4134):
+ * the hook review's `enter confirm · esc skip` and the folder trust's
+ * `enter continue · esc back` / `esc quit`.
+ *
+ * `esc skip` after `enter continue` is deliberately not here: that is the update
+ * offer, whose digit still confirms by itself on 0.166.0 (measured:
+ * `dismissed_version` written on the `3`, `tests/fixtures/codex-dialogs-0166/`).
+ */
+const CODEX_ENTER_CONFIRMS_FOOTER_PATTERN = /^\s*enter\s+(?:confirm\s+·\s+esc\s+skip|continue\s+·\s+esc\s+(?:back|quit))\s*$/i;
+/** A numbered option under the cursor; group 1 is its number. */
+const CODEX_CURSOR_OPTION_ROW = /^\s*›\s*(\d+)\./;
+/** Rows above the footer the option block can start at (the hook review has three options). */
+const CODEX_ENTER_CONFIRMS_MAX_ROWS = 6;
+/**
+ * The option the cursor is on, on a screen where a digit moves the cursor and
+ * Enter confirms (Issue #4134); `null` on any other screen, including one where
+ * the digit confirms by itself.
+ *
+ * Read off the bottom of the frame, so a screen left in scrollback above a
+ * composer does not answer: the footer has to be the last content row.
+ *
+ * @param output - ANSI-stripped pane capture
+ */
+function readCodexEnterConfirmedCursor(output) {
+    const rows = output.split('\n').filter((row) => row.trim() !== '');
+    const footer = rows.length - 1;
+    if (footer < 0 || !CODEX_ENTER_CONFIRMS_FOOTER_PATTERN.test(rows[footer]))
+        return null;
+    for (let i = footer - 1; i >= Math.max(0, footer - CODEX_ENTER_CONFIRMS_MAX_ROWS); i--) {
+        const match = CODEX_CURSOR_OPTION_ROW.exec(rows[i]);
+        if (match)
+            return Number(match[1]);
+    }
+    return null;
+}
 /**
  * How much of the active region {@link getCodexLifecycleDialog} judges, in
  * non-blank lines counted from the bottom (Issue #1829).
@@ -427,6 +475,8 @@ function getCodexLifecycleDialog(output) {
             return 'hooks-list';
         if (CODEX_HOOKS_DETAIL_FOOTER_PATTERN.test(line))
             return 'hooks-detail';
+        if (CODEX_HOOKS_SETTLED_FOOTER_PATTERN.test(line))
+            return 'hooks-settled';
         // The agent asking the human for permission mid-turn (Issue #1628's
         // "esc to cancel" footer, which no lifecycle screen wears). This is exactly
         // the prompt Auto-Yes exists to answer, so whatever lifecycle text is still

package/dist/server/src/lib/detection/tools/codex/prompt.js

@@ -58,6 +58,7 @@ const LIFECYCLE_DIALOG_KINDS = {
     'hooks-review': 'permission',
     'hooks-list': 'picker',
     'hooks-detail': 'picker',
+    'hooks-settled': 'picker',
     update: 'update',
     trust: 'trust',
 };
@@ -74,10 +75,24 @@ function detectCodexDialog(frame, context) {
     const lines = (0, cli_patterns_1.stripBoxDrawing)(frame.clean).split('\n');
     const block = (0, dialog_block_1.findNumberedOptionBlock)(lines, context.contentEnd);
     if (context.lifecycleDialog) {
+        // `sendPromptAnswer` sends the digit and then Enter unless told otherwise. Read
+        // against the keys measured on 0.166.0 (`tests/fixtures/codex-dialogs-0166/README.md`,
+        // Issue #4146): on the hook review and the folder trust the digit moves the cursor
+        // and the Enter confirms that row, so the pair does what was asked.
+        //
+        // The update offer confirms on the digit alone. Issue #4161 measured where its
+        // Enter went (isolated CODEX_HOME, private tmux, the same 100 ms apart): onto the
+        // folder trust it wrote `trust_level = "trusted"`, onto the hook review it opened
+        // the list, and on the composer it did nothing. Hence `answer_only`, for this
+        // screen only.
+        //
+        // 未確認: a `respond` through a server at a live pane (the keys were sent with
+        // tmux), and a digit on the hooks list and detail.
         return {
             kind: LIFECYCLE_DIALOG_KINDS[context.lifecycleDialog],
             options: block?.options ?? [],
             answerMode: 'numbered',
+            ...(context.lifecycleDialog === 'update' ? { submitMode: 'answer_only' } : {}),
         };
     }
     if (!block)
@@ -106,9 +121,14 @@ function detectCodexDialog(frame, context) {
     return {
         kind: isApproval ? 'permission' : 'picker',
         options: block.options,
-        // Measured: codex takes the digit as text. `sendPromptAnswer` types it for
-        // this tool, and the hooks-review screens confirm the digit lands
-        // immediately (reference: codex 0.148 review flow).
+        // The digit reaches the dialog as text, and `sendPromptAnswer` types it and
+        // presses Enter. On 0.157.1 `/model`'s digit decides by itself and opens the
+        // second step (`tests/fixtures/codex-dialogs-0157/model-picker-digit.txt`), so
+        // the Enter lands there.
+        //
+        // 未確認 on 0.166.0 (Issue #4146): `tests/fixtures/codex-dialogs-0166/` holds
+        // the launch screens only, which take the branch above. No approval or picker
+        // frame, and no `respond` at one, has been measured on that build.
         answerMode: 'numbered',
     };
 }

package/dist/server/src/lib/detection/tools/opencode/composer-own-text.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * The text an opencode input box holds, cut out of the rows it shares with the
+ * sidebar (Issue #4067).
+ *
+ * opencode (v1, and v2 2.0.x — same box: `┃` gutter rows over a `╹▀…▀` bottom
+ * border) draws its sidebar (#2047/#2095) on the same rows as the input box,
+ * right of the box's bottom border: measured in `opencode-live-2047/w200/`
+ * (border to column 156, sidebar from 160), `opencode-live-2046/w80/sidebar-on.txt`
+ * and `opencode-v2-usage-2981/pane-turn1-2.0.18.txt`. A row's own text is what
+ * lies left of that border's end, its gutter removed.
+ *
+ * Before #4067 there were two readings of the same rows: the send readiness
+ * (#4040) cut at the right edge, and the submit read-back
+ * (`submit-composer-read`'s `opencode-box`) read the whole row — so an empty box
+ * beside the sidebar was ready to the one and held `/private/…` (the sidebar's
+ * working directory) to the other, which then classified a delivered message
+ * `replaced`. Both now read through this module.
+ *
+ * Text inside the box is the buffer however far it is indented (`┃    old` is
+ * not empty).
+ *
+ * @module lib/detection/tools/opencode/composer-own-text
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeBoxRightEdge = opencodeBoxRightEdge;
+exports.opencodeBoxObscured = opencodeBoxObscured;
+exports.opencodeOwnText = opencodeOwnText;
+exports.readOpenCodeComposerOwnRows = readOpenCodeComposerOwnRows;
+exports.readOpenCodeComposerBox = readOpenCodeComposerBox;
+const terminal_columns_1 = require("../../terminal-columns");
+const patterns_1 = require("./patterns");
+/** The input box's bottom border row (`╹▀…▀`), the newest one on the pane, or `null`. */
+function bottomBorderRow(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (patterns_1.OPENCODE_COMPOSER_BOTTOM_BORDER.test(lines[i]))
+            return lines[i];
+    }
+    return null;
+}
+/**
+ * The column just right of the input box: the end of its bottom border
+ * (`╹▀…▀`), the newest one on the pane. `null` when there is none.
+ *
+ * The end of the border's FIRST run: on a border an overlay cuts in two
+ * ({@link opencodeBoxObscured}) that is where the overlay starts, not the box's
+ * right edge.
+ *
+ * @param lines - Captured pane lines, ANSI-stripped, box drawing intact
+ */
+function opencodeBoxRightEdge(lines) {
+    const row = bottomBorderRow(lines);
+    if (row === null)
+        return null;
+    const border = /╹▀+/.exec(row);
+    return border ? border.index + border[0].length : null;
+}
+/**
+ * Whether something is drawn over the input box: its bottom border is cut in
+ * two — `╹▀▀▀▀▀▀`, blanks, then `▀▀▀▀▀▀▀▀` further right (review of #4067).
+ * A palette or picker (`opencode-live-2049/command-palette-11822.txt`,
+ * `opencode-live-1896/command-palette.txt`, `canary/opencode-picker.raw.txt`)
+ * paints over the box's rows from that cut on, so what the box holds there
+ * cannot be read: neither an empty box nor the absence of one. No capture with
+ * a whole box has a `▀` right of its border's first run (the sidebar's rows
+ * included: every `.txt` capture under `tests/` was checked).
+ *
+ * @param lines - Captured pane lines, ANSI-stripped, box drawing intact
+ */
+function opencodeBoxObscured(lines) {
+    const row = bottomBorderRow(lines);
+    if (row === null)
+        return false;
+    const border = /╹▀+/.exec(row);
+    return border !== null && row.includes('▀', border.index + border[0].length);
+}
+/**
+ * The row's own text: inside the box (left of `rightEdge`), gutter removed.
+ * With no right edge (no border found) the whole row is read, as before #4067.
+ *
+ * @param row - One composer row, gutter intact
+ * @param rightEdge - {@link opencodeBoxRightEdge} of the same frame
+ */
+function opencodeOwnText(row, rightEdge) {
+    const inside = rightEdge === null ? row : row.slice(0, (0, terminal_columns_1.indexAtColumn)(row, rightEdge));
+    return (0, patterns_1.stripOpenCodeGutter)(inside);
+}
+/**
+ * The input box's buffer rows as their own text (gutter and sidebar removed),
+ * or `null` when no box is on screen ({@link findOpenCodeComposerRows}).
+ *
+ * @param lines - Captured pane lines of the WHOLE pane, ANSI-stripped
+ */
+function readOpenCodeComposerOwnRows(lines) {
+    const rows = (0, patterns_1.findOpenCodeComposerRows)(lines);
+    if (rows === null)
+        return null;
+    const rightEdge = opencodeBoxRightEdge(lines);
+    return rows.map((row) => opencodeOwnText(row, rightEdge));
+}
+/**
+ * The input box as the submit read-back reads it: its rows' own text, and
+ * whether an overlay hides part of it. `null` when no box is on screen.
+ *
+ * @param lines - Captured pane lines of the WHOLE pane, ANSI-stripped
+ */
+function readOpenCodeComposerBox(lines) {
+    const rows = (0, patterns_1.findOpenCodeComposerRows)(lines);
+    if (rows === null)
+        return null;
+    if (!opencodeBoxObscured(lines)) {
+        const rightEdge = opencodeBoxRightEdge(lines);
+        return { rows: rows.map((row) => opencodeOwnText(row, rightEdge)), obscured: false };
+    }
+    const border = bottomBorderRow(lines);
+    // A column, like the right edge: the overlay's text on the border row may be wide.
+    const farEdge = (0, terminal_columns_1.visibleWidth)(border.slice(0, border.lastIndexOf('▀') + 1));
+    return { rows: rows.map((row) => opencodeOwnText(row, farEdge)), obscured: true };
+}

package/dist/server/src/lib/detection/tools/opencode/detect.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeStatusDetector = exports.VERIFIED_AGAINST = void 0;
 exports.readIdleEvidence = readIdleEvidence;
 const cli_patterns_1 = require("../../cli-patterns");
+const patterns_1 = require("./patterns");
 const verdicts_1 = require("../verdicts");
 const status_reason_1 = require("../../status-reason");
 const opencode_modal_overlay_1 = require("../../opencode-modal-overlay");
@@ -75,16 +76,23 @@ function readIdleEvidence(frame) {
         .join('\n');
     if (cli_patterns_1.OPENCODE_TURN_COMPLETE_PATTERN.test(window))
         return 'positive';
-    const composerWindow = frame.lines
-        .slice(Math.max(0, lastIndex - frame_1.STATUS_CHECK_LINE_COUNT + 1), lastIndex + 1)
-        .join('\n');
-    return cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(composerWindow) ? 'positive' : 'none';
+    // Issue #4209: the placeholder inside the box over its bottom border, read on the
+    // whole frame (the border sits under the content window), as branch E reads it.
+    return (0, patterns_1.findOpenCodeIdleComposer)(frame.clean) !== null ? 'positive' : 'none';
 }
 exports.opencodeStatusDetector = (0, run_detection_1.createToolStatusDetector)({
     tool: 'opencode',
     verifiedAgainst: exports.VERIFIED_AGAINST,
     // Issue #3183: where the live part of the frame begins (`./live-region.ts`).
     liveRegion: live_region_1.OPENCODE_LIVE_REGION,
+    // Issue #4209: the shared thinking step reads the progress row under the
+    // composer's bottom border, whole, as the poller's save does
+    // (`isOpenCodeProgressBelowComposer`; its busy-hint half is branch A). The word in
+    // the last five rows read the footer's cwd there: `/tmp/Thinking:demo` kept a
+    // finished session `running` while its reply was saved.
+    readThinking(frame) {
+        return (0, patterns_1.isOpenCodeThinkingBelowComposer)(frame.lines);
+    },
     afterThinking(frame) {
         // 2.5. OpenCode status detection (Issue #379)
         // OpenCode TUI layout: content area (top) | empty padding (~150 lines) | footer status bar (~6 lines at bottom).
@@ -130,17 +138,21 @@ exports.opencodeStatusDetector = (0, run_detection_1.createToolStatusDetector)({
             return (0, verdicts_1.positiveVerdict)('waiting', status_reason_1.STATUS_REASON.OPENCODE_PERMISSION_PROMPT);
         }
         // A. Check footer for processing indicator ("esc interrupt" replaces "ctrl+t variants..." during processing)
-        if (cli_patterns_1.OPENCODE_PROCESSING_INDICATOR.test(frame.lastLines)) {
+        // Issue #4175: the hint's row under the composer's border, not the words in a reply.
+        if ((0, patterns_1.isOpencodeProcessingFooter)(frame.lastLines)) {
             return (0, verdicts_1.positiveVerdict)('running', status_reason_1.STATUS_REASON.OPENCODE_PROCESSING_INDICATOR);
         }
         const { candidates, lastIndex } = findContentEnd(frame);
         if (lastIndex < 0)
             return null;
-        // B. Check last few content lines for thinking indicators
-        const contentThinkingWindow = candidates
-            .slice(Math.max(0, lastIndex - thinking_constants_1.THINKING_TAIL_LINE_COUNT + 1), lastIndex + 1)
-            .join('\n');
-        if ((0, cli_patterns_1.detectThinking)('opencode', contentThinkingWindow)) {
+        // B. A `Thinking:` row at the end of the current turn, while it is open.
+        //
+        // Issue #4209: read by position and whole, not as the word anywhere in the last
+        // content rows — a finished reply quoting `Thinking:` was `running` while the
+        // poller saved it. The row has to open a row of the turn region (below the
+        // newest echo, above the chrome) and the region must hold no finished-turn
+        // marker, which every frame the poller saves holds.
+        if ((0, patterns_1.isOpenCodeThinkingInOpenTurn)(frame.lines, thinking_constants_1.THINKING_TAIL_LINE_COUNT)) {
             return (0, verdicts_1.positiveVerdict)('running', status_reason_1.STATUS_REASON.THINKING_INDICATOR);
         }
         // C. Check content area for selection list (Issue #473: fuzzy-search list detection)
@@ -211,17 +223,20 @@ exports.opencodeStatusDetector = (0, run_detection_1.createToolStatusDetector)({
         // only on positive evidence"), not a fallback for "nothing looked busy".
         //
         // The row is matched on `frame.lines` (ANSI stripped, box drawing intact)
-        // via OPENCODE_IDLE_COMPOSER_PATTERN, so it must carry the input box's own
+        // via findOpenCodeIdleComposer, so it must carry the input box's own
         // gutter. The bare phrase reaching the pane inside a response body is not
         // read as an idle composer.
         //
         // D1's other half — "and the footer shows no processing marker" — is
         // branch A above, which has already returned `running` for any frame whose
         // footer carries `esc interrupt`.
-        const composerWindow = frame.lines
-            .slice(Math.max(0, lastIndex - frame_1.STATUS_CHECK_LINE_COUNT + 1), lastIndex + 1)
-            .join('\n');
-        if (cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(composerWindow)) {
+        //
+        // Issue #4209: and by position — the placeholder row has to sit in the box over
+        // the composer's bottom border (`findOpenCodeIdleComposer`). The echo of a sent
+        // message is guttered too, and at 200 columns its blank gutter row carries the
+        // sidebar's session title. Read on the whole frame: the border is below the
+        // content window.
+        if ((0, patterns_1.findOpenCodeIdleComposer)(frame.clean) !== null) {
             return (0, verdicts_1.positiveVerdict)('ready', status_reason_1.STATUS_REASON.INPUT_PROMPT);
         }
         return null;