commandmate 0.49.2 → 0.50.0

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

@@ -4,7 +4,12 @@
  * (Issue #3217 I-3). `cli-patterns.ts` re-exports every public name.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_SKIP_PATTERNS = exports.OPENCODE_SEPARATOR_PATTERN = exports.OPENCODE_SELECTION_LIST_PATTERN = exports.OPENCODE_FOOTER_STATUS_PATTERN = exports.OPENCODE_USER_ECHO_PATTERN = exports.OPENCODE_GUTTER_ROW_PATTERN = exports.OPENCODE_COMPOSER_BOTTOM_BORDER = exports.OPENCODE_PROCESSING_INDICATOR = exports.OPENCODE_PERMISSION_PATTERN = exports.OPENCODE_TURN_COMPLETE_PATTERN = exports.OPENCODE_RESPONSE_COMPLETE = exports.OPENCODE_LOADING_PATTERN = exports.OPENCODE_THINKING_PATTERN = exports.OPENCODE_PROMPT_AFTER_RESPONSE = exports.OPENCODE_IDLE_COMPOSER_PATTERN = exports.OPENCODE_PROMPT_PATTERN = void 0;
+exports.OPENCODE_TRANSCRIPT_SKIP_PATTERNS = exports.OPENCODE_CHROME_ROW_PATTERNS = exports.OPENCODE_SKIP_PATTERNS = exports.OPENCODE_MODEL_ROW_PATTERN = exports.OPENCODE_SEPARATOR_PATTERN = exports.OPENCODE_SELECTION_LIST_PATTERN = exports.OPENCODE_FOOTER_STATUS_PATTERN = exports.OPENCODE_USER_ECHO_PATTERN = exports.OPENCODE_GUTTER_ROW_PATTERN = exports.OPENCODE_COMPOSER_BOTTOM_BORDER = exports.OPENCODE_PROCESSING_INDICATOR = exports.OPENCODE_PERMISSION_PATTERN = exports.OPENCODE_TURN_COMPLETE_PATTERN = exports.OPENCODE_RESPONSE_COMPLETE = exports.OPENCODE_LOADING_PATTERN = exports.OPENCODE_THINKING_PROGRESS_ROW = exports.OPENCODE_THINKING_PATTERN = exports.OPENCODE_PROMPT_AFTER_RESPONSE = exports.OPENCODE_IDLE_COMPOSER_PATTERN = exports.OPENCODE_PROMPT_PATTERN = void 0;
+exports.findOpenCodeIdleComposer = findOpenCodeIdleComposer;
+exports.isOpencodeProcessingFooter = isOpencodeProcessingFooter;
+exports.isOpenCodeThinkingBelowComposer = isOpenCodeThinkingBelowComposer;
+exports.isOpenCodeProgressBelowComposer = isOpenCodeProgressBelowComposer;
+exports.isOpenCodeThinkingInOpenTurn = isOpenCodeThinkingInOpenTurn;
 exports.findOpenCodeChromeStart = findOpenCodeChromeStart;
 exports.findOpenCodeUserEchoEnd = findOpenCodeUserEchoEnd;
 exports.findOpenCodeComposerRows = findOpenCodeComposerRows;
@@ -47,8 +52,88 @@ exports.OPENCODE_PROMPT_PATTERN = /Ask anything(?:\.\.\.|\u2026)/;
  *
  * opencode 1.18.31 以降は見本文を U+2026（`…`）で描く。ASCII の `...` も実行ファイルに
  * 残っているので両方を受け付ける（Issue #2915、2026-09-28 に実行ファイルから確認）。
+ *
+ * Read by position (Issue #4209): the placeholder row, then only gutter rows (the
+ * blank rows and the agent/model row), then the composer's bottom border `╹▀▀▀…` —
+ * the box as every V1 frame under `tests/fixtures/opencode*` and
+ * `tests/unit/lib/detection/fixtures/opencode-live-*` that draws the placeholder
+ * draws it. The gutter alone does not say "composer": the transcript echoes each
+ * sent message in the same `┃` box, and at 200 columns the echo's blank gutter row
+ * carries the sidebar's session title, so a title holding the phrase put an empty
+ * composer on the pane (`opencode-live-2047/w200/{phrase-in-response,
+ * numbered-answer,sidebar-title-phrase}.txt`). V2's pattern had the same defect
+ * (#4188). The echo block ends in a non-gutter row, never the border.
+ *
+ * Kept a `RegExp` (a subclass whose `exec` is {@link findOpenCodeIdleComposer})
+ * because liveness's `alivePatterns` takes regular expressions; the send path's
+ * readiness wait and the status detector call the function directly.
+ * **Guaranteed**: `test`, `exec`, and the string methods that go through `exec` on
+ * a non-global pattern (`String.prototype.match` / `search` / `replace`). Rows are
+ * split on LF only. **Not guaranteed**: `split` and `matchAll` (they construct
+ * `Symbol.species`, the native `RegExp`), and a copy built from `source` and
+ * `flags` — native `^` under the `m` flag also starts a line after U+2028 / U+2029 /
+ * CR, and the copy retries from every gutter row. `source` still spells the rule.
+ */
+exports.OPENCODE_IDLE_COMPOSER_PATTERN = new (class OpencodeIdleComposerPattern extends RegExp {
+    static get [Symbol.species]() {
+        return RegExp;
+    }
+    constructor() {
+        super('^[^\\S\\n]*[\\u2502\\u2503][^\\S\\n]*Ask anything(?:\\.\\.\\.|\\u2026)[^\\n]*\\n(?:[^\\S\\n]*[\\u2502\\u2503][^\\n]*\\n)*[^\\S\\n]*\\u2579\\u2580{4,}', 'm');
+    }
+    exec(text) {
+        const found = findOpenCodeIdleComposer(text);
+        if (!found)
+            return null;
+        const match = [text.slice(found.start, found.end)];
+        match.index = found.start;
+        match.input = text;
+        return match;
+    }
+})();
+/** The placeholder at the start of a gutter row (Issue #1883). */
+const IDLE_COMPOSER_PLACEHOLDER_ROW = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask anything(?:\.\.\.|\u2026)/;
+/** A row of one of the `┃` boxes. */
+const IDLE_COMPOSER_GUTTER_ROW = /^[^\S\n]*[\u2502\u2503]/;
+/** The composer's bottom border, as the match ends on it. */
+const IDLE_COMPOSER_BORDER_ROW = /^[^\S\n]*\u2579\u2580{4,}/;
+/**
+ * The empty composer of {@link OPENCODE_IDLE_COMPOSER_PATTERN}, by position, in one
+ * pass (Issue #4209, the shape of V2's `findOpencodeV2IdleComposer` from #4188): the
+ * first placeholder row whose gutter run reaches a bottom border `╹▀▀▀…`, as
+ * character offsets from the placeholder row's start to the end of the border's
+ * `▀` run; or null.
+ *
+ * Each border walks up its own run of gutter rows once, and the runs do not
+ * overlap (a border row is not a gutter row), so the work is linear in the rows.
+ * Rows are split on LF only.
+ *
+ * @param text - ANSI-stripped capture, box drawing intact
+ * @returns The match's `[start, end)` in `text`, or null
  */
-exports.OPENCODE_IDLE_COMPOSER_PATTERN = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask anything(?:\.\.\.|\u2026)/m;
+function findOpenCodeIdleComposer(text) {
+    const rows = text.split('\n');
+    const offsets = new Array(rows.length);
+    let offset = 0;
+    for (let i = 0; i < rows.length; i++) {
+        offsets[i] = offset;
+        offset += rows[i].length + 1;
+    }
+    for (let border = 1; border < rows.length; border++) {
+        const borderMatch = IDLE_COMPOSER_BORDER_ROW.exec(rows[border]);
+        if (!borderMatch)
+            continue;
+        let placeholder = -1;
+        for (let j = border - 1; j >= 0 && IDLE_COMPOSER_GUTTER_ROW.test(rows[j]); j--) {
+            if (IDLE_COMPOSER_PLACEHOLDER_ROW.test(rows[j]))
+                placeholder = j;
+        }
+        if (placeholder >= 0) {
+            return { start: offsets[placeholder], end: offsets[border] + borderMatch[0].length };
+        }
+    }
+    return null;
+}
 /**
  * OpenCode prompt pattern after response completion (Issue #379)
  * Shows "tab agents  ctrl+p commands" in the TUI status bar after a response finishes.
@@ -61,6 +146,18 @@ exports.OPENCODE_PROMPT_AFTER_RESPONSE = /tab agents\s+ctrl\+p commands/;
  * Used by detectThinking() to determine if the tool is actively processing.
  */
 exports.OPENCODE_THINKING_PATTERN = /Thinking:/;
+/**
+ * OpenCode's progress row drawn under the composer's bottom border while a turn
+ * runs, read as a whole row (Issue #4188): a spinner run (braille `⠦`, or the
+ * `⬝■` run of the busy footer), then `Thinking:` — e.g. `   ⠦ Thinking: Crafting…`.
+ *
+ * Only for the rows below the border, where the footer also draws the cwd
+ * (`/private/tmp/…/repo`, wrapped over several rows). {@link OPENCODE_THINKING_PATTERN}
+ * matches the word anywhere, so a cwd such as `/tmp/Thinking:demo` read there as a
+ * running turn. A row opening with the spinner is never a path, nor a path's
+ * wrapped continuation (which opens with the path's next character).
+ */
+exports.OPENCODE_THINKING_PROGRESS_ROW = /^[^\S\n]*[\u2800-\u28FF\u2B1D\u25A0]+[^\S\n]+Thinking:/m;
 /**
  * OpenCode loading indicator pattern (Issue #379)
  * Shows a series of 4+ filled square characters (U+2B1D) during initial loading/model warm-up.
@@ -119,10 +216,15 @@ exports.OPENCODE_RESPONSE_COMPLETE = /\u25A3\s+\w+\s+·\s+\S+(?:\s+·\s+(?:[\d]+
  * quantifier -- ReDoS safe), and `.`/`[^·\n]` never cross a line without the
  * `m` flag, so the duration has to be on the marker's own row.
  *
- * Durations observed: `2.3s`, `5.2s`, `45.2s`; the `Nh`/`Nm` prefixes are
- * inherited from the #379 pattern and kept for long turns.
+ * Durations, as opencode formats them (Issue #4134, its `duration` function in
+ * the 1.18.35 executable): `836ms` under a second, `5.2s` under a minute, `1m 5s`
+ * under an hour, `1h 5m` under a day, `2d 3h` beyond. Reading only the second and
+ * third forms left a turn under a second, or over an hour, with no positive
+ * evidence: `running` / `unknown_frame` for good, so `wait` ended in exit 124
+ * (`tests/fixtures/opencode-live-4134/turn-done-subsecond.txt`). `\b` keeps a
+ * following word from passing for a unit.
  */
-exports.OPENCODE_TURN_COMPLETE_PATTERN = /\u25A3\s+\w+\s+·\s+[^·\n]+·\s+(?:\d+h\s*)?(?:\d+m\s*)?[\d.]+s/;
+exports.OPENCODE_TURN_COMPLETE_PATTERN = /\u25A3\s+\w+\s+·\s+[^·\n]+·\s+(?:\d+ms|(?:\d+h\s*)?(?:\d+m\s*)?[\d.]+s|\d+h\s+\d+m|\d+d\s+\d+h)\b/;
 /**
  * OpenCode's permission dialog, anchored on its button row (Issue #1893).
  *
@@ -204,8 +306,122 @@ exports.OPENCODE_PERMISSION_PATTERN = /^[^\S\n]*[\u2502\u2503][^\S\n]*Allow once
  * Filtered from response extraction via OPENCODE_SKIP_PATTERNS, which shares
  * this constant: the widened row is dropped from a saved answer for the same
  * reason the narrow one was.
+ *
+ * Issue #4175: matched as a whole row, not as words anywhere. The hint opens its row
+ * (after the spinner run `⬝■` when there is one) and the row ends there or goes on
+ * after two spaces with the footer's columns — the shape of every measured row
+ * (`opencode-live-1894/`, `opencode-live-2047/w80|w120|w200/`, the canary capture).
+ * A sentence of a reply with the words in it (`The footer reads esc interrupt while…`)
+ * read as a running turn before, in the status reader, in `isOpenCodeComplete` and
+ * in this list. A row that is the hint and nothing else still matches: tests outside
+ * this Issue pin `'esc interrupt'` and the label alone as matches, and the status
+ * reader adds the position on top ({@link isOpencodeProcessingFooter}).
+ *
+ * Issue #4188: the completion check (`isOpenCodeComplete`) reads it by position
+ * too, and the poller's extraction of a frame whose chrome it located skips it no
+ * more ({@link OPENCODE_TRANSCRIPT_SKIP_PATTERNS}): a reply quoting the hint row
+ * whole above the composer completes, and keeps the row.
+ */
+exports.OPENCODE_PROCESSING_INDICATOR = /(?:^|\n)[^\S\n]*(?:[\u2B1D\u25A0]+[^\S\n]+)?esc (?:again to )?interrupt(?:[^\S\n]{2}[^\n]*)?[^\S\n]*(?=\n|$)/;
+/**
+ * Whether the busy footer is on the frame, by position (Issue #4175): an
+ * {@link OPENCODE_PROCESSING_INDICATOR} row BELOW the composer's bottom border when
+ * the text holds one — every measured running frame draws the hint on the row right
+ * under it — and anywhere in the text when it holds none (a window cut above the
+ * border; the rule as it was). A reply quoting the hint row whole sits above the
+ * border and is not read.
+ *
+ * @param text - ANSI-stripped rows, box drawing intact (the status reader's `lastLines`)
+ */
+function isOpencodeProcessingFooter(text) {
+    const rows = text.split('\n');
+    let border = -1;
+    for (let i = rows.length - 1; i >= 0; i--) {
+        if (exports.OPENCODE_COMPOSER_BOTTOM_BORDER.test(rows[i])) {
+            border = i;
+            break;
+        }
+    }
+    return exports.OPENCODE_PROCESSING_INDICATOR.test(rows.slice(border + 1).join('\n'));
+}
+/**
+ * The rows under the composer's bottom border `╹▀▀▀…`, joined, or null when no
+ * border is at or below `from` (Issue #4209).
+ */
+function rowsBelowComposerBorder(lines, from) {
+    for (let i = lines.length - 1; i >= Math.max(0, from); i--) {
+        if (exports.OPENCODE_COMPOSER_BOTTOM_BORDER.test(lines[i]))
+            return lines.slice(i + 1).join('\n');
+    }
+    return null;
+}
+/**
+ * Whether the spinner's `Thinking:` row ({@link OPENCODE_THINKING_PROGRESS_ROW}) is
+ * drawn under the composer's bottom border (Issue #4209). The thinking half of
+ * {@link isOpenCodeProgressBelowComposer}; the status detector reads the busy hint
+ * half in its own branch ({@link isOpencodeProcessingFooter}), which keeps its own
+ * reason code. `false` when there is no border.
+ *
+ * @param lines - ANSI-stripped rows, box drawing intact
+ * @param from - The first row the border may be on (default 0)
+ */
+function isOpenCodeThinkingBelowComposer(lines, from = 0) {
+    const below = rowsBelowComposerBorder(lines, from);
+    return below !== null && exports.OPENCODE_THINKING_PROGRESS_ROW.test(below);
+}
+/**
+ * Whether an opencode frame shows a turn still running under the composer's
+ * bottom border `╹▀▀▀…` (Issue #4188, shared by Issue #4209): a progress row there,
+ * read whole — the spinner's `Thinking:` row ({@link OPENCODE_THINKING_PROGRESS_ROW})
+ * or the busy hint ({@link OPENCODE_PROCESSING_INDICATOR}). The footer's cwd also
+ * sits there, so the bare word is not read: a cwd of `/tmp/Thinking:demo` is not a
+ * running turn. `false` when the frame has no border (the permission dialog drawn
+ * in the composer's place runs to the last row).
+ *
+ * The rule the poller's save (`extractCompletedResponse`) reads. Lives here, beside
+ * the patterns it combines, so the status detector (`./detect.ts` and the thinking
+ * step of `../run-detection.ts`) reads the same rule rather than a copy: before
+ * #4209 the save read this while the status read the word in the last five rows,
+ * so a finished reply was saved while the session showed `running`.
+ *
+ * @param lines - ANSI-stripped rows, box drawing intact
+ * @param from - The first row the border may be on (the chrome's start; default 0)
+ */
+function isOpenCodeProgressBelowComposer(lines, from = 0) {
+    const below = rowsBelowComposerBorder(lines, from);
+    return below !== null && (exports.OPENCODE_THINKING_PROGRESS_ROW.test(below) || exports.OPENCODE_PROCESSING_INDICATOR.test(below));
+}
+/** A `Thinking:` row read whole: the word opens the row, after the spinner when there is one. */
+const OPENCODE_THINKING_ROW = /^[^\S\n]*(?:[\u2800-\u28FF\u2B1D\u25A0]+[^\S\n]+)?Thinking:/;
+/**
+ * Whether the current turn, still open, ends on a `Thinking:` row (Issue #4209): one
+ * of the last `tailRows` non-blank rows of the turn region (below the newest echoed
+ * prompt, above the chrome — {@link findOpenCodeUserEchoEnd},
+ * {@link findOpenCodeChromeStart}) opens with the word, and the region holds no
+ * finished-turn marker ({@link OPENCODE_TURN_COMPLETE_PATTERN}).
+ *
+ * The status detector's reading of the progress row opencode draws in the
+ * transcript (`opencode-live-1894/esc-again-after-marker.txt`: `⠦ Thinking:
+ * Preparing an essay` under the echo). Never true on a frame the poller saves:
+ * that needs the marker in the same region (`isOpenCodeComplete`), so there the
+ * status reads only {@link isOpenCodeProgressBelowComposer}, as the save does. A
+ * reply quoting the word in a finished turn, or the footer's cwd, is not read.
+ *
+ * @param lines - ANSI-stripped rows, box drawing intact
+ * @param tailRows - How many non-blank rows from the region's end to read
  */
-exports.OPENCODE_PROCESSING_INDICATOR = /esc (?:again to )?interrupt/;
+function isOpenCodeThinkingInOpenTurn(lines, tailRows) {
+    const rows = [...lines];
+    const chromeStart = findOpenCodeChromeStart(rows);
+    const echoEnd = findOpenCodeUserEchoEnd(rows, chromeStart);
+    const region = rows.slice(echoEnd + 1, chromeStart >= 0 ? chromeStart : rows.length);
+    if (region.some((row) => exports.OPENCODE_TURN_COMPLETE_PATTERN.test(row)))
+        return false;
+    return region
+        .filter((row) => row.trim() !== '')
+        .slice(-tailRows)
+        .some((row) => OPENCODE_THINKING_ROW.test(row));
+}
 /**
  * OpenCode's composer bottom border: `  ╹▀▀▀▀▀▀…` (Issue #1911).
  *
@@ -489,6 +705,17 @@ exports.OPENCODE_SELECTION_LIST_PATTERN = /^[^\S\n]*(?:Select[^\S\n]+(?:model|pr
  * Covers: vertical lines (U+2503), box corners, horizontal lines, and other TUI elements.
  */
 exports.OPENCODE_SEPARATOR_PATTERN = /^[\u2503\u2579\u25A3\u2580\u2500\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C]+$/;
+/**
+ * The composer's agent/model row once its gutter is stripped
+ * (`Build · GPT-5.6 Luna GitHub Copilot`; Issue #379, named by Issue #4209).
+ *
+ * Matched as a word at the row's start, so a reply's row opening with "Build "
+ * matches too: read only where the rows carry no position
+ * ({@link OPENCODE_CHROME_ROW_PATTERNS}). On every measured V1 frame no row of the
+ * turn region above the chrome opens with it (the turn's own marker opens with
+ * `▣`).
+ */
+exports.OPENCODE_MODEL_ROW_PATTERN = /^Build\s+/;
 /**
  * OpenCode skip patterns for response cleaning (Issue #379)
  * Lines matching any of these patterns are filtered from extracted responses.
@@ -499,10 +726,44 @@ exports.OPENCODE_SEPARATOR_PATTERN = /^[\u2503\u2579\u25A3\u2580\u2500\u250C\u25
 exports.OPENCODE_SKIP_PATTERNS = [
     exports.OPENCODE_SEPARATOR_PATTERN,
     exports.OPENCODE_LOADING_PATTERN,
-    /^Build\s+/,
+    exports.OPENCODE_MODEL_ROW_PATTERN,
     exports.OPENCODE_PROMPT_AFTER_RESPONSE,
     exports.OPENCODE_PROCESSING_INDICATOR,
     exports.OPENCODE_PROMPT_PATTERN,
     exports.OPENCODE_FOOTER_STATUS_PATTERN,
     pasted_text_1.PASTED_TEXT_PATTERN,
 ];
+/**
+ * Rows only opencode's bottom chrome draws (Issue #4188): the spinner run, the
+ * first-idle footer (`tab agents  ctrl+p commands`), the busy hint
+ * (`esc interrupt`) and the placeholder (`Ask anything...`). Issue #4209 added the
+ * composer's agent/model row ({@link OPENCODE_MODEL_ROW_PATTERN}) and the footer's
+ * status cell ({@link OPENCODE_FOOTER_STATUS_PATTERN}): a reply's row opening with
+ * "Build " or quoting `8.5K (1%) · $` was dropped from the save.
+ *
+ * Matched as words, so one row cannot tell them from a reply quoting them. On
+ * every measured frame under `tests/fixtures/opencode*` and
+ * `tests/unit/lib/detection/fixtures/opencode-live-*` a row these match sits in
+ * the chrome {@link findOpenCodeChromeStart} locates — or is a reply's row above
+ * it (`phrase-in-response.txt`: `Ask anything... is the placeholder`). So a reader
+ * that already holds only the rows above the chrome must not skip them.
+ */
+exports.OPENCODE_CHROME_ROW_PATTERNS = [
+    exports.OPENCODE_LOADING_PATTERN,
+    exports.OPENCODE_PROMPT_AFTER_RESPONSE,
+    exports.OPENCODE_PROCESSING_INDICATOR,
+    exports.OPENCODE_PROMPT_PATTERN,
+    exports.OPENCODE_MODEL_ROW_PATTERN,
+    exports.OPENCODE_FOOTER_STATUS_PATTERN,
+];
+/**
+ * {@link OPENCODE_SKIP_PATTERNS} less {@link OPENCODE_CHROME_ROW_PATTERNS}, for rows
+ * known to lie above the located chrome (Issue #4188): the turn region of a frame
+ * whose chrome `response-checker` found, the reply it extracted from it, and the
+ * Layer-2 accumulator's rows cut from such a frame (`sliceOpenCodeTurnWithSkip`).
+ * The whole list stays for a frame with no chrome boundary, where the words are
+ * the only reading left (the fallback {@link isOpencodeProcessingFooter} takes on a
+ * text with no border), and for the per-row readers that are handed no position
+ * (the default of `cleanOpenCodeResponse` / `extractTuiContentLines`).
+ */
+exports.OPENCODE_TRANSCRIPT_SKIP_PATTERNS = exports.OPENCODE_SKIP_PATTERNS.filter((pattern) => !exports.OPENCODE_CHROME_ROW_PATTERNS.includes(pattern));

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

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Whether an opencode (v1) pane is ready to take a typed message body
+ * (Issue #4040).
+ *
+ * The launch wait (`OpenCodeTool.waitForReady`) is not this test: it accepts
+ * the `Connect a provider` overlay so a launch does not burn its window there,
+ * and `OPENCODE_IDLE_COMPOSER_PATTERN` only anchors the placeholder's row in the
+ * box over its bottom border (#4209) —
+ * it does not say the rest of the input box is empty, and opencode stops
+ * painting the placeholder once a session has answered a turn (every
+ * post-turn frame in `tests/fixtures/opencode-live-2047/w80/` has an input box
+ * of blank gutter rows and no `Ask anything`).
+ *
+ * Ready means, on the WHOLE frame (the box is centred under the banner until
+ * the first turn, ~100 rows above the bottom):
+ *
+ * - no dialog or overlay — the detector's `waiting` (permission strip, picker,
+ *   palette, `Connect a provider`) and the picker header itself;
+ * - the input box is on screen (`findOpenCodeComposerRows`: its bottom border
+ *   and gutter);
+ * - every buffer row of it is empty: blank, or the placeholder (optionally with
+ *   its quoted suggestion) and nothing else. A row holding any other text —
+ *   a previous body, a typed character — is not ready.
+ *
+ * A turn being generated keeps the empty box on screen (`turn-running.txt`),
+ * so it is ready by the same rule; no generation exception is needed.
+ *
+ * Text right of the box is not read as the row's own: the sidebar
+ * (#2047/#2095) shares rows with the input box, beyond the right end of the
+ * box's bottom border (`╹▀…▀`, measured in `opencode-live-2047/w200/`: border
+ * to column 156, sidebar from 160). Text inside the box is the buffer however
+ * far it is indented (`┃    old` is not empty), as `submit-composer-read`'s
+ * `opencode-box` reader reads it — both through `composer-own-text` (#4067).
+ *
+ * @module lib/detection/tools/opencode/readiness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOpenCodeNotReadyScreen = readOpenCodeNotReadyScreen;
+exports.isOpenCodeComposerReady = isOpenCodeComposerReady;
+const ansi_1 = require("../../ansi");
+const status_detector_1 = require("../../status-detector");
+const patterns_1 = require("./patterns");
+const composer_own_text_1 = require("./composer-own-text");
+/** The placeholder opencode paints in an empty buffer, with its quoted suggestion. */
+const PLACEHOLDER = /^Ask anything(?:\.\.\.|…)(?:[^\S\n]+"[^"\n]*")?$/;
+/**
+ * @param output - Raw `capture-pane` output of the whole pane (ANSI allowed)
+ * @returns What keeps the pane from being ready; null when it is ready
+ */
+function readOpenCodeNotReadyScreen(output) {
+    const text = (0, ansi_1.stripAnsi)(output);
+    if (patterns_1.OPENCODE_SELECTION_LIST_PATTERN.test(text))
+        return 'dialog';
+    const status = (0, status_detector_1.detectSessionStatus)(output, 'opencode');
+    if (status.hasActivePrompt || status.status === 'waiting')
+        return 'dialog';
+    // Each row's own text, cut at the box's right edge (Issue #4067: the same
+    // cut the submit read-back uses — `composer-own-text`).
+    const rows = (0, composer_own_text_1.readOpenCodeComposerOwnRows)(text.split('\n'));
+    if (rows === null || rows.length === 0)
+        return 'no-input-box';
+    return rows.every((own) => own === '' || PLACEHOLDER.test(own)) ? null : 'input-box-holds-text';
+}
+/**
+ * @param output - Raw `capture-pane` output of the whole pane (ANSI allowed)
+ * @returns true when the input box is on screen, empty, and nothing covers it
+ */
+function isOpenCodeComposerReady(output) {
+    return readOpenCodeNotReadyScreen(output) === null;
+}

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

@@ -15,8 +15,9 @@
  *    pickers, Commands, Sessions, Select agent) anywhere on the pane
  *    → `waiting` (Issue #2971);
  *  - the footer's `esc interrupt` hint → `running`;
- *  - the completion row (`Build · <model> · 3.5s · 11.2 tok/s`) as the last
- *    transcript row → `ready` (Issue #2965);
+ *  - the completion row (`Build · <model> · 3.5s · 11.2 tok/s`, or the same row
+ *    ending in `· interrupted`) as the last transcript row → `ready` (Issue #2965,
+ *    #4161);
  *  - the gutter-anchored empty composer (`┃  Ask anything…`) → `ready`;
  *  - otherwise the footer without that hint (`… 8.6K (1%)  ctrl+p commands`,
  *    the frame after a turn, whose composer is a bare gutter) → `ready`.
@@ -45,8 +46,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeV2StatusDetector = exports.OPENCODE_V2_PERMISSION_OPTIONS = exports.OPENCODE_V2_TURN_COMPLETE_PATTERN = exports.OPENCODE_V2_QUESTION_PATTERN = exports.OPENCODE_V2_PERMISSION_PATTERN = exports.VERIFIED_AGAINST = void 0;
+exports.findOpencodeV2LastTranscriptRow = findOpencodeV2LastTranscriptRow;
 exports.endsWithTurnComplete = endsWithTurnComplete;
 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 live_region_1 = require("./live-region");
@@ -73,8 +76,22 @@ exports.OPENCODE_V2_QUESTION_PATTERN = /^[^\S\n]*[│┃][^\S\n]*↑↓ select[^
  * (`┃  Build · <model> OpenCode Zen`) does and has no duration, so neither it
  * nor v1's `▣` row matches. A duration is required — the row without one is not
  * a completion (the lesson v1's #1893 learned).
+ *
+ * Durations, as V1's `OPENCODE_TURN_COMPLETE_PATTERN` reads them (Issue #4146):
+ * `836ms`, `5.2s`, `1m 5s`, `1h 5m`, `2d 3h`. Read off the 2.0.18 executable, whose
+ * `FR` draws this row's duration, the same five forms as V1's formatter. 未測定:
+ * no captured frame has a turn of an hour or more, so those two forms come from
+ * that function and not from a screen.
+ *
+ * An interrupted turn closes on the same row with ` · interrupted` last (Issue #4161):
+ * `Build · <model> · 4.5s · interrupted` after a second Esc on 2.0.18, and
+ * `· 41.6s · 13.4 tok/s · interrupted` after a declined tool call
+ * (`tests/fixtures/opencode-v2-dialogs-2984/question-under-quoted-dialog.txt`). The
+ * turn is over, as the event stream says (`session.execution.interrupted` is a
+ * `stop`), and the footer has lost its hint. Only the last transcript row is read
+ * ({@link endsWithTurnComplete}), so a later turn or a question below it is not this.
  */
-exports.OPENCODE_V2_TURN_COMPLETE_PATTERN = /^[^\S\n│┃]*[A-Za-z][\w-]*(?: [\w-]+)* · [^\n]+? · \d+(?:\.\d+)?(?:ms|s|m(?: \d+s)?)(?: · [\d.]+ tok\/s)?[^\S\n]*$/;
+exports.OPENCODE_V2_TURN_COMPLETE_PATTERN = /^[^\S\n│┃]*[A-Za-z][\w-]*(?: [\w-]+)* · [^\n]+? · (?:\d+(?:\.\d+)?(?:ms|s|m(?: \d+s)?)|\d+h \d+m|\d+d \d+h)(?: · [\d.]+ tok\/s)?(?: · interrupted)?[^\S\n]*$/;
 /** The approval strip's buttons, in the order it draws them (2.0.18). */
 exports.OPENCODE_V2_PERMISSION_OPTIONS = ['Allow once', 'Always allow', 'Reject'];
 /** A row of the composer's gutter (`┃  …`). The question form is drawn entirely on it. */
@@ -115,30 +132,46 @@ function readQuestionDialog(frame) {
         return null;
     return { kind: 'question', options, answerMode: 'numbered', submitMode: 'answer_only' };
 }
-/** Rows below the transcript that are chrome: gutter padding, the model bar, the rule, the footer, the version. */
-function isChromeRow(line) {
+/**
+ * Rows below the transcript that are chrome: gutter padding, the model bar, the rule,
+ * the footer, the version.
+ *
+ * Issue #4175: the footer by its position (the row under the composer's border,
+ * {@link isOpencodeV2FooterRowAt}), not by `ctrl+p commands` anywhere in the row — a
+ * reply's last row saying those words was stepped over as chrome, and the row above
+ * it read as the last transcript row.
+ */
+function isChromeRow(lines, index) {
+    const line = lines[index];
     if (/^[\s│┃╹▀]*$/.test(line))
         return true;
     // The composer's model bar: gutter, then `<Agent> · <model> <provider>` with no second `·`.
     if (/^[^\S\n]*[│┃][^\S\n]*[A-Za-z][\w-]* · [^·\n]+$/.test(line))
         return true;
-    if (cli_patterns_1.OPENCODE_V2_FOOTER_PATTERN.test(line))
+    if ((0, patterns_1.isOpencodeV2FooterRowAt)(lines, index))
         return true;
     return /^\s*\d+\.\d+\.\d+\s*$/.test(line);
 }
+/**
+ * The index of the last transcript row — the first row above the composer's
+ * chrome — or -1. `lines` are ANSI-stripped, box drawing intact.
+ */
+function findOpencodeV2LastTranscriptRow(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (isChromeRow(lines, i))
+            continue;
+        return i;
+    }
+    return -1;
+}
 /**
  * Whether the last transcript row — the first row above the composer's chrome —
  * is the completion row. Only the LAST row counts: the completion row of an
  * earlier turn stays on the pane behind the next turn and behind a dialog.
  */
 function endsWithTurnComplete(frame) {
-    const lines = frame.contentLines;
-    for (let i = lines.length - 1; i >= 0; i--) {
-        if (isChromeRow(lines[i]))
-            continue;
-        return exports.OPENCODE_V2_TURN_COMPLETE_PATTERN.test(lines[i]);
-    }
-    return false;
+    const last = findOpencodeV2LastTranscriptRow(frame.contentLines);
+    return last >= 0 && exports.OPENCODE_V2_TURN_COMPLETE_PATTERN.test(frame.contentLines[last]);
 }
 exports.opencodeV2StatusDetector = (0, run_detection_1.createToolStatusDetector)({
     tool: 'opencode-v2',
@@ -190,8 +223,11 @@ exports.opencodeV2StatusDetector = (0, run_detection_1.createToolStatusDetector)
         }
         // The placeholder against the ANSI-stripped frame with its box drawing
         // intact (the pattern anchors on the `┃` gutter). The footer is on every
-        // frame, and the running hint was ruled out just above.
-        if (cli_patterns_1.OPENCODE_V2_IDLE_COMPOSER_PATTERN.test((0, cli_patterns_1.stripAnsi)(frame.raw)) ||
+        // frame, and the running hint was ruled out just above. Issue #4175: the
+        // footer under the composer's border, not its words in a reply. Issue #4188:
+        // the placeholder inside the box over that border, not a transcript echo,
+        // read in one pass over the rows (`OPENCODE_V2_IDLE_COMPOSER_PATTERN`'s reader).
+        if ((0, patterns_1.findOpencodeV2IdleComposer)((0, cli_patterns_1.stripAnsi)(frame.raw)) !== null ||
             cli_patterns_1.OPENCODE_V2_FOOTER_PATTERN.test(frame.lastLines)) {
             return (0, verdicts_1.positiveVerdict)('ready', status_reason_1.STATUS_REASON.INPUT_PROMPT);
         }