commandmate 0.42.2 → 0.44.0

package/dist/server/src/lib/detection/tools/command-code/plan-review-state.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Which part of Command Code's plan review overlay has the keyboard
+ * (Issue #3125).
+ *
+ * The detector already says THAT the overlay is up
+ * (`command_code_plan_review`, see `detect.ts`). Answering it needs one more
+ * fact, because the same keys mean different things depending on where the
+ * focus is — measured on 1.58.0 (`tests/fixtures/command-code-plan-review-2763/`)
+ * and unchanged in the 1.74.0 rows #3059 observed
+ * (`tests/fixtures/command-code-plan-review-3125/`):
+ *
+ * | phase            | hint bar (last content row)                  | `Enter` does            |
+ * |------------------|----------------------------------------------|-------------------------|
+ * | `body`           | `type + enter to comment · …`                | opens / pins a comment  |
+ * | `comment-box`    | `enter to pin · esc discard`                 | pins what is typed      |
+ * | `action-focus`   | `↑/↓ choose · enter to run` (a `❯` on a row) | RUNS the focused action |
+ * | `approve-choice` | `←/→ choose · enter confirm · esc back`      | confirms the approval   |
+ *
+ * The body cursor itself is drawn by background colour alone and cannot be read
+ * off a plain capture; the hint bar and the `❯` can, which is all this needs.
+ *
+ * Browser-safe and pure, like `selection-shape.ts` it builds on.
+ *
+ * @module lib/detection/tools/command-code/plan-review-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCommandCodePlanReviewState = readCommandCodePlanReviewState;
+const ansi_1 = require("../../ansi");
+const selection_shape_1 = require("../../selection-shape");
+/** Rows read from the end of the frame — the same 15 the detector reads. */
+const TAIL_CONTENT_ROWS = 15;
+const BODY_HINT = /^\s*type \+ enter to comment\b/i;
+const COMMENT_BOX_HINT = /^\s*enter to pin\s*·\s*esc discard\s*$/i;
+const ACTION_FOCUS_HINT = /^\s*↑\/↓ choose\s*·\s*enter to run\s*$/i;
+const FOCUSED_ACTION_ROW = /^\s*❯ +(?:Submit review\b|Approve\s+ctrl\+a\b|Cancel\s+esc\b)/im;
+const PENDING_BADGE = /^\s*REVIEW\s+(\d+)\s+pending comments?\b/im;
+const APPROVE_WITH_COMMENTS_SELECTED = /\(•\)\s+with\s+\d+\s+comments?\s+as\s+notes/i;
+/**
+ * Read the plan review overlay's focus off a capture.
+ *
+ * @param frame - a raw `capture-pane` frame, ANSI intact or stripped
+ * @returns null when the overlay is not at the bottom of this frame
+ */
+function readCommandCodePlanReviewState(frame) {
+    if (!frame)
+        return null;
+    const rows = (0, ansi_1.stripAnsi)(frame.replace(/\r\n/g, '\n'))
+        .split('\n')
+        .filter((row) => row.trim() !== '')
+        .slice(-TAIL_CONTENT_ROWS);
+    if (rows.length === 0)
+        return null;
+    const tail = rows.join('\n');
+    const pendingMatch = PENDING_BADGE.exec(tail);
+    const pendingComments = pendingMatch ? Number(pendingMatch[1]) : 0;
+    if ((0, selection_shape_1.isCommandCodePlanApproveChoice)(tail)) {
+        return {
+            phase: 'approve-choice',
+            pendingComments,
+            approveChoice: APPROVE_WITH_COMMENTS_SELECTED.test(tail) ? 'with-comments' : 'discard-comments',
+        };
+    }
+    if (!(0, selection_shape_1.hasCommandCodePlanReviewFooterAtBottom)(tail))
+        return null;
+    const hint = rows[rows.length - 1];
+    let phase = 'unknown';
+    if (FOCUSED_ACTION_ROW.test(tail) || ACTION_FOCUS_HINT.test(hint))
+        phase = 'action-focus';
+    else if (COMMENT_BOX_HINT.test(hint))
+        phase = 'comment-box';
+    else if (BODY_HINT.test(hint))
+        phase = 'body';
+    return { phase, pendingComments, approveChoice: null };
+}

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

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * OpenCode V2 screen detector — the fallback reader (Issue #2934, Phase 1).
+ *
+ * OpenCode V2's state comes from its server's SSE stream
+ * (`@/lib/hooks/sources/opencode-v2`); this module is what decides when that
+ * stream is not there (a pane launched `--standalone`, a subscription that has
+ * not reattached yet). It reads, in this order:
+ *
+ *  - the approval dialog's button strip (`Allow once   Always allow   Reject`)
+ *    → `waiting` (Issue #2965);
+ *  - the question form's key hints (`↑↓ select  enter submit  esc dismiss`)
+ *    → `waiting` (Issue #2965);
+ *  - a dialog's title row (`Select variant … esc`, the model / variant
+ *    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 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`.
+ *
+ * Both dialogs are drawn INSIDE the composer's `┃` gutter and replace the
+ * footer altogether (measured on 2.0.18, 80x200, 2026-09-29:
+ * `tests/fixtures/opencode-v2-live-2945/permission-required.txt` /
+ * `question.txt`), so before #2965 they reached the floor as `running` /
+ * `default` — an unclassified frame, which is what wrote the "could not parse
+ * it" row into the chat while the structured layer held the very approval.
+ *
+ * v1's opencode detector is deliberately not reused: its dialog rule keys on
+ * v1's wording (`Allow always`, the reverse word order) and would misread v2.
+ *
+ * `detectDialog` (Issue #2984) reads the same three surfaces for the Auto-Yes
+ * gate (`polling/auto-yes-dialog-gate`), measured on 2.0.18 at 80x200
+ * (2026-09-29, `tests/fixtures/opencode-v2-dialogs-2984/`): the approval strip
+ * (`keys` — a typed digit leaves it open), the question form (`numbered`,
+ * `answer_only` — a typed `2` alone submitted `Blue`) and a dialog title
+ * (`keys` — a digit goes into the filter). v2's approvals and questions are
+ * still answered through the agent's own API (#2945); what the gate needs from
+ * this module is the NO — an agent's reply that quotes a `❯ 1. Yes` dialog is
+ * none of the three, so Auto-Yes does not type into the composer for it.
+ *
+ * @module lib/detection/tools/opencode-v2/detect
+ */
+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.endsWithTurnComplete = endsWithTurnComplete;
+const cli_patterns_1 = require("../../cli-patterns");
+const status_reason_1 = require("../../status-reason");
+const run_detection_1 = require("../run-detection");
+const verified_against_1 = require("../verified-against");
+exports.VERIFIED_AGAINST = verified_against_1.OPENCODE_V2_VERIFIED_AGAINST;
+/**
+ * The approval dialog's button strip, on the composer's own `┃` gutter:
+ * `┃   Allow once   Always allow   Reject  ctrl+f fullscreen  ⇆ select  enter con…`
+ * (2.0.18). The gutter anchor keeps the same words reaching the pane inside a
+ * reply from being read as a dialog, as v1's `OPENCODE_PERMISSION_PATTERN`
+ * does; the word order is v2's own (`Always allow`, not v1's `Allow always`).
+ */
+exports.OPENCODE_V2_PERMISSION_PATTERN = /^[^\S\n]*[│┃][^\S\n]*Allow once[^\S\n]{2,}Always allow[^\S\n]{2,}Reject\b/m;
+/**
+ * The question form's key hints, on the composer's gutter:
+ * `┃  ↑↓ select  enter submit  esc dismiss` (2.0.18, below the numbered
+ * choices and `Type your own answer`).
+ */
+exports.OPENCODE_V2_QUESTION_PATTERN = /^[^\S\n]*[│┃][^\S\n]*↑↓ select[^\S\n]+enter submit[^\S\n]+esc dismiss\b/m;
+/**
+ * The row that closes a finished turn: `Build · <model> · 3.5s · 11.2 tok/s`
+ * (2.0.18). Transcript rows carry no gutter; the composer's model bar
+ * (`┃  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).
+ */
+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]*$/;
+/** 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. */
+const GUTTER_ROW_PATTERN = /^[^\S\n]*[│┃]/;
+/** One choice of the question form: `┃  1. Red` (2.0.18). */
+const QUESTION_OPTION_ROW_PATTERN = /^[^\S\n]*[│┃][^\S\n]*(\d+)\.[^\S\n]+(\S.*?)[^\S\n]*$/;
+/**
+ * The question form as a dialog (Issue #2984): the choices on the gutter rows
+ * above its key hints, numbered 1..n without a gap. `null` when the hints row
+ * is not in the status window or fewer than two choices can be read.
+ *
+ * `numbered` / `answer_only` because that is what the form does with a digit:
+ * measured on 2.0.18, typing `2` with no Enter submitted `Blue`
+ * (`tests/fixtures/opencode-v2-dialogs-2984/question-answered-by-digit.txt`).
+ */
+function readQuestionDialog(frame) {
+    if (!exports.OPENCODE_V2_QUESTION_PATTERN.test(frame.lastLines))
+        return null;
+    const lines = frame.contentLines;
+    let hints = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (exports.OPENCODE_V2_QUESTION_PATTERN.test(lines[i])) {
+            hints = i;
+            break;
+        }
+    }
+    if (hints < 0)
+        return null;
+    const options = [];
+    for (let i = hints - 1; i >= 0 && GUTTER_ROW_PATTERN.test(lines[i]); i--) {
+        const match = QUESTION_OPTION_ROW_PATTERN.exec(lines[i]);
+        if (match)
+            options.unshift(`${match[1]}. ${match[2]}`);
+    }
+    if (options.length < 2)
+        return null;
+    if (!options.every((option, index) => option.startsWith(`${index + 1}. `)))
+        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) {
+    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))
+        return true;
+    return /^\s*\d+\.\d+\.\d+\s*$/.test(line);
+}
+/**
+ * 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;
+}
+exports.opencodeV2StatusDetector = (0, run_detection_1.createToolStatusDetector)({
+    tool: 'opencode-v2',
+    verifiedAgainst: exports.VERIFIED_AGAINST,
+    // Issue #2991: every v2 dialog is recognised by `beforePrompt` below, so a
+    // numbered list that reaches the generic parser is text in a reply (the UAT
+    // frame: `❯ 1. Yes / 2. No` quoted in the answer). Unvouched by
+    // `detectDialog`, it is not published as `waiting` — which had left the
+    // session refusing every send with nothing on screen to answer.
+    requireVouchedPrompt: true,
+    // Issue #2965: the two dialogs, ahead of everything. Each is the agent
+    // blocked on a human whatever else is on the pane — the question frame keeps
+    // the previous turn's completion row above it — and ahead of the generic
+    // numbered-list parser too, because the question's `1. Red / 2. Blue` is
+    // driven by ↑↓ + Enter (hence `hasActivePrompt: false` and a reason from
+    // `SELECTION_LIST_REASONS`, which draws the arrow keys instead of offering to
+    // type a number). Issue #2984 measured that a typed digit also commits it,
+    // with no Enter — see `detectDialog` below.
+    beforePrompt(frame) {
+        if (exports.OPENCODE_V2_PERMISSION_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.OPENCODE_PERMISSION_PROMPT,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        if (exports.OPENCODE_V2_QUESTION_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.OPENCODE_SELECTION_LIST,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        // Issue #2971: a dialog opened over the composer keeps the footer (and
+        // often the placeholder) on screen, so every rule below read it as `ready`
+        // and `wait` completed a turn that never started. Its title row sits ~150
+        // rows above the bottom of an 80x200 pane, outside `lastLines`, so the
+        // whole frame is read. The reason is v1's (#2112): the same kind of
+        // overlay, driven by ↑↓ + Enter and closed with `esc` — no number answers
+        // it, hence `hasActivePrompt: false`.
+        if ((0, cli_patterns_1.findOpencodeV2DialogTitle)((0, cli_patterns_1.stripAnsi)(frame.raw)) !== null) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.OPENCODE_MODAL_OVERLAY,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+    afterThinking(frame) {
+        if ((0, cli_patterns_1.detectThinking)('opencode-v2', frame.lastLines)) {
+            return {
+                status: 'running',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.THINKING_INDICATOR,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        // Issue #2965: the completion row as the last transcript row, with no
+        // `esc interrupt` (ruled out just above) — a finished turn, whether or not
+        // the footer made it into the capture.
+        if (endsWithTurnComplete(frame)) {
+            return {
+                status: 'ready',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.OPENCODE_RESPONSE_COMPLETE,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        // 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)) ||
+            cli_patterns_1.OPENCODE_V2_FOOTER_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'ready',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.INPUT_PROMPT,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+    // Issue #2984: the seam the Auto-Yes gate and `respond` read. The same three
+    // rules `beforePrompt` reports `waiting` on, in the same order, so the gate
+    // and the status API agree about which frames carry a dialog.
+    //
+    // The strip and the question form are anchored on the composer's `┃` gutter,
+    // which `stripBoxDrawing` removes: on the spelling the Auto-Yes poller judges
+    // they answer `null` (v1's #1893 precedent). For Auto-Yes `null` and `keys`
+    // both send nothing, and the question form never reaches the gate anyway —
+    // it draws no `❯` for the generic parser to key on.
+    detectDialog(frame) {
+        if (exports.OPENCODE_V2_PERMISSION_PATTERN.test(frame.lastLines)) {
+            return { kind: 'permission', options: exports.OPENCODE_V2_PERMISSION_OPTIONS, answerMode: 'keys' };
+        }
+        const question = readQuestionDialog(frame);
+        if (question !== null)
+            return question;
+        if ((0, cli_patterns_1.findOpencodeV2DialogTitle)((0, cli_patterns_1.stripAnsi)(frame.raw)) !== null) {
+            return { kind: 'picker', options: [], answerMode: 'keys' };
+        }
+        return null;
+    },
+});

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

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * OpenCode V2's dialog title row — a pure, dependency-free leaf (Issue #2983).
+ *
+ * Moved out of `cli-patterns.ts` (which re-exports both names) so a client
+ * component can read the same row the detector reads without pulling the
+ * logger and the tool registry into the browser bundle: the chat surface's
+ * dialog card draws v2's model keys only while one of these dialogs is open,
+ * because each of those keys closes the dialog with `Escape` before it is sent.
+ *
+ * @module lib/detection/tools/opencode-v2/dialog-title
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_V2_DIALOG_TITLE_PATTERN = void 0;
+exports.findOpencodeV2DialogTitle = findOpencodeV2DialogTitle;
+/**
+ * The title row of an OpenCode V2 dialog opened over the composer: the model
+ * picker (`ctrl+x m`), the variant picker it opens next, the Commands palette
+ * (`ctrl+p`), Sessions (`ctrl+x l`) and Select agent (`ctrl+x a`) — Issue #2971.
+ *
+ * Measured on 2.0.18 at 80x200 (2026-09-29,
+ * `tests/fixtures/opencode-v2-live-2971/`): every one of them opens with a row
+ * `   <Title>                                     esc`, the dismiss hint
+ * right-aligned after a wide gap, with no `┃` gutter in front. The row BELOW it
+ * is the filter (`Search`, or whatever was typed into it) and changes; the
+ * title row does not. The footer (`… ctrl+p commands`) stays drawn under every
+ * one of them, which is why the footer alone cannot say the composer is free.
+ *
+ * Not matched: the running footer (`esc interrupt  ctrl+p commands`, `esc` not
+ * last) and the question form's `┃  ↑↓ select  enter submit  esc dismiss`
+ * (gutter, `esc` not last). Match against the ANSI-stripped frame; the title
+ * sits far above the 15-line status window (row 52 of 200), so pass the whole
+ * capture.
+ */
+exports.OPENCODE_V2_DIALOG_TITLE_PATTERN = /^[^\S\n]*[^\s\u2502\u2503\u2579\u2580][^\n]*?[^\S\n]{8,}esc[^\S\n]*$/m;
+/**
+ * The title of the OpenCode V2 dialog open on the pane (`Select variant`), or
+ * `null` when none is (Issue #2971). A send must not type while one is open:
+ * the text lands in the dialog's filter, not in the composer.
+ *
+ * @param text - ANSI-stripped capture of the whole pane
+ */
+function findOpencodeV2DialogTitle(text) {
+    const match = exports.OPENCODE_V2_DIALOG_TITLE_PATTERN.exec(text);
+    if (match === null)
+        return null;
+    return match[0].trim().replace(/\s+esc$/, '');
+}

package/dist/server/src/lib/detection/tools/registry.js

@@ -18,6 +18,7 @@ const detect_3 = require("./codex/detect");
 const detect_4 = require("./command-code/detect");
 const detect_5 = require("./copilot/detect");
 const detect_6 = require("./opencode/detect");
+const detect_7 = require("./opencode-v2/detect");
 const run_detection_1 = require("./run-detection");
 const verified_against_1 = require("./verified-against");
 /**
@@ -43,6 +44,7 @@ const DETECTORS = {
     opencode: detect_6.opencodeStatusDetector,
     antigravity: detect_1.antigravityStatusDetector,
     'command-code': detect_4.commandCodeStatusDetector,
+    'opencode-v2': detect_7.opencodeV2StatusDetector,
     gemini: geminiStatusDetector,
     'vibe-local': vibeLocalStatusDetector,
 };

package/dist/server/src/lib/detection/tools/run-detection.js

@@ -99,6 +99,15 @@ function runToolDetection(spec, frame, context = {}) {
             // and let the chain continue to the tool's running/idle branches.
             promptDetection = { ...promptDetection, isPrompt: false, promptData: undefined };
         }
+        else if (spec.requireVouchedPrompt && context.isPromptVouched?.(promptDetection) === false) {
+            // Issue #2991: a numbered list the tool's own dialog rules do not vouch
+            // for — the agent's reply quoting `❯ 1. Yes / 2. No`. Auto-Yes (#2984)
+            // and History (#2457) already refuse it; publishing `waiting` for it
+            // left the session unanswerable (no dialog to answer) and unwritable (the
+            // send guard refused every message). Neutralised the same way as the
+            // stale block above, so the tool's own branches decide the status.
+            promptDetection = { ...promptDetection, isPrompt: false, promptData: undefined };
+        }
         else {
             return {
                 status: 'waiting',

package/dist/server/src/lib/detection/tools/verified-against.js

@@ -26,7 +26,7 @@
  * instead of importing it.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DETECTOR_VERIFIED_AGAINST = exports.UNMEASURED_VERIFIED_AGAINST = exports.COMMAND_CODE_VERIFIED_AGAINST = exports.ANTIGRAVITY_VERIFIED_AGAINST = exports.OPENCODE_VERIFIED_AGAINST = exports.COPILOT_VERIFIED_AGAINST = exports.CODEX_VERIFIED_AGAINST = exports.CLAUDE_VERIFIED_AGAINST = void 0;
+exports.DETECTOR_VERIFIED_AGAINST = exports.UNMEASURED_VERIFIED_AGAINST = exports.OPENCODE_V2_VERIFIED_AGAINST = exports.COMMAND_CODE_VERIFIED_AGAINST = exports.ANTIGRAVITY_VERIFIED_AGAINST = exports.OPENCODE_VERIFIED_AGAINST = exports.COPILOT_VERIFIED_AGAINST = exports.CODEX_VERIFIED_AGAINST = exports.CLAUDE_VERIFIED_AGAINST = void 0;
 /** claude these rules were read off (#1708 / #1927 fixtures). */
 exports.CLAUDE_VERIFIED_AGAINST = {
     version: '2.1.240',
@@ -224,6 +224,21 @@ exports.COMMAND_CODE_VERIFIED_AGAINST = {
     capturedAt: '2026-09-20',
     paneGeometry: '200x1000',
 };
+/**
+ * OpenCode V2 (`opencode2`, npm `@opencode/cli`) — Issue #2934, Epic #2370
+ * Phase 1.
+ *
+ * 2.0.18 is the build Phase 0 and Phase 1 were measured on (2026-09-28, pane
+ * 80x200): the SSE vocabulary the state is read from, and the composer / footer
+ * rows the send path and the fallback reader match. OpenCode V2 shipped 18
+ * releases in its first two weeks, so this stamp is expected to go `stale`
+ * quickly — which is the freshness probe doing its job, not a defect.
+ */
+exports.OPENCODE_V2_VERIFIED_AGAINST = {
+    version: '2.0.18',
+    capturedAt: '2026-09-28',
+    paneGeometry: '80x200',
+};
 /**
  * The stamp for a tool whose frames nobody has captured yet.
  *
@@ -251,6 +266,7 @@ exports.DETECTOR_VERIFIED_AGAINST = {
     opencode: exports.OPENCODE_VERIFIED_AGAINST,
     antigravity: exports.ANTIGRAVITY_VERIFIED_AGAINST,
     'command-code': exports.COMMAND_CODE_VERIFIED_AGAINST,
+    'opencode-v2': exports.OPENCODE_V2_VERIFIED_AGAINST,
     gemini: exports.UNMEASURED_VERIFIED_AGAINST,
     'vibe-local': exports.UNMEASURED_VERIFIED_AGAINST,
 };

package/dist/server/src/lib/detection/upstream-faults.js

@@ -46,6 +46,14 @@ const excerpt_1 = require("./excerpt");
 exports.UPSTREAM_FAULTS = [
     { id: 'overloaded', pattern: /\b5\d{2}\s+Overloaded\b/i, selfRetrying: true },
     { id: 'retrying', pattern: /Retrying in \d+s\s*[·•]\s*attempt \d+\/\d+/i, selfRetrying: true },
+    {
+        // The conversation outgrew the model's window (Issue #3011). Command Code
+        // prints `400 This model's maximum context length is N tokens. However, you
+        // requested M tokens`; retrying the same session cannot succeed.
+        id: 'context-limit',
+        pattern: /\bmaximum context length is \d+ tokens\b/i,
+        selfRetrying: false,
+    },
     { id: 'limit-reached', pattern: /\blimit reached\b/i, selfRetrying: false },
     { id: 'api-error', pattern: /\bAPI Error(?::|\s+\d{3})/i, selfRetrying: false },
 ];

package/dist/server/src/lib/detection/version-probes.js

@@ -104,6 +104,7 @@ exports.getDetectorStalenessSnapshot = getDetectorStalenessSnapshot;
 exports.clearDetectorVersionProbeCache = clearDetectorVersionProbeCache;
 const child_process_1 = require("child_process");
 const copilot_executable_1 = require("../cli-tools/copilot-executable");
+const opencode_executable_1 = require("../cli-tools/opencode-executable");
 const env_sanitizer_1 = require("../security/env-sanitizer");
 const verified_against_1 = require("./tools/verified-against");
 /** Budget for one `<cli> --version`. Matches the catalog probe and copilot-executable. */
@@ -202,7 +203,19 @@ exports.DETECTOR_VERSION_PROBES = {
     codex: { kind: 'execFile', command: 'codex', args: ['--version'] },
     antigravity: { kind: 'execFile', command: 'agy', args: ['--version'] },
     'command-code': { kind: 'execFile', command: 'commandcode', args: ['--version'] },
-    opencode: { kind: 'execFile', command: 'opencode', args: ['--version'] },
+    // Issue #2939: both OpenCodes are delegated, like copilot. `opencode` may be
+    // OpenCode V2 (npm `@opencode/cli` registers it next to `opencode2`), so the
+    // row reads the version of the binary each tool would launch — the same
+    // resolution `isInstalled()` and the launch line use, never `opencode v2.x`
+    // filed as OpenCode 1.x's version.
+    opencode: {
+        kind: 'delegated',
+        probe: async () => (await (0, opencode_executable_1.resolveOpencodeV1Executable)()).executable?.version ?? null,
+    },
+    'opencode-v2': {
+        kind: 'delegated',
+        probe: async () => (await (0, opencode_executable_1.resolveOpencodeV2Executable)()).executable?.version ?? null,
+    },
     gemini: { kind: 'execFile', command: 'gemini', args: ['--version'] },
     copilot: {
         kind: 'delegated',

package/dist/server/src/lib/hooks/agent-session-telemetry.js

@@ -61,6 +61,17 @@
  * its own — see {@link AgentSessionContextUsage} and
  * `docs/design/opencode-server-live-verification.md` §14.
  *
+ * ## OpenCode V2 (Issue #2981)
+ *
+ * `opencode-v2` fills both records too, with the same meanings — measured on
+ * 2.0.18 (`tests/fixtures/opencode-v2-usage-2981`): `GET /api/session/{id}`
+ * carries the session's cumulative `cost` / `tokens` (the running total
+ * `session.usage.updated` announces), while the TUI's `6.3K (1%)` is the last
+ * assistant message's footprint. The writer is
+ * `./sources/opencode-v2/usage`, which asks its own server with its own port
+ * and password; {@link ensureAgentSessionContextUsage} leaves those instances
+ * alone.
+ *
  * @module lib/hooks/agent-session-telemetry
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -70,6 +81,7 @@ exports.getAgentSessionTelemetry = getAgentSessionTelemetry;
 exports.forgetAgentSessionTelemetry = forgetAgentSessionTelemetry;
 exports.resetAgentSessionTelemetry = resetAgentSessionTelemetry;
 exports.readOpencodeSessionFrame = readOpencodeSessionFrame;
+exports.readOpencodeSessionInfo = readOpencodeSessionInfo;
 exports.agentSessionContextPercent = agentSessionContextPercent;
 exports.getAgentSessionContextUsage = getAgentSessionContextUsage;
 exports.recordAgentSessionContextUsage = recordAgentSessionContextUsage;
@@ -190,7 +202,25 @@ function readOpencodeSessionFrame(frame, at) {
     const properties = isPlainObject(frame.properties) ? frame.properties : null;
     if (!properties)
         return null;
-    const info = isPlainObject(properties.info) ? properties.info : null;
+    return readOpencodeSessionInfo(properties.info, at);
+}
+/**
+ * Read one `Session` object, or answer null (Issue #2981).
+ *
+ * Split out of {@link readOpencodeSessionFrame} because OpenCode V2 serves the
+ * same fields — `Session.Info` in 2.0.18's `GET /openapi.json` declares `id`,
+ * `parentID`, `title`, `agent`, `model: { id, providerID, variant? }`, `cost`
+ * and `tokens: { input, output, reasoning, cache: { read, write } }` — from
+ * `GET /api/session/{id}` instead of on a frame. One reader keeps the two
+ * versions from disagreeing about what "verbatim" means, and the sub-agent
+ * refusal above applies to both.
+ *
+ * @param value - The `Session` object, unvalidated
+ * @param at - Epoch ms it was received
+ * @returns The record to store, or null when this is not one to store
+ */
+function readOpencodeSessionInfo(value, at) {
+    const info = isPlainObject(value) ? value : null;
     if (!info)
         return null;
     if (typeof info.parentID === 'string' && info.parentID.length > 0)
@@ -276,6 +306,11 @@ function ensureAgentSessionContextUsage(target, record) {
     // close is what retires it, the same lifetime the record itself has.
     if (!record || !record.id)
         return cached;
+    // Issue #2981: OpenCode V2 measures its own context in the same refresh that
+    // writes the record (`./sources/opencode-v2/usage`), with its own port and
+    // password. The v1 fetch below would dial v1's port map for a v2 instance.
+    if (target.cliToolId === 'opencode-v2')
+        return cached;
     if (cached && cached.sessionAt === record.at)
         return cached;
     if (contextRefreshes.has(key))

package/dist/server/src/lib/hooks/sources/claude/transcript.js

@@ -59,6 +59,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLAUDE_END_TURN_STOP_REASON = exports.CLAUDE_HUMAN_PROMPT_SOURCES = exports.CLAUDE_HUMAN_ORIGIN_KIND = exports.CLAUDE_SLASH_COMMAND_PREFIX = exports.CLAUDE_THINKING_LABEL = exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH = exports.MAX_CLAUDE_TURN_BLOCKS = exports.CLAUDE_TURN_TRUNCATION_MARKER = exports.MAX_CLAUDE_TURN_BODY_LENGTH = exports.CLAUDE_PROJECTS_DIR_SEGMENTS = void 0;
 exports.claudeProjectSlug = claudeProjectSlug;
 exports.claudeSlashCommandPrompt = claudeSlashCommandPrompt;
+exports.claudePastedContentPrompt = claudePastedContentPrompt;
 exports.readClaudeContentBlock = readClaudeContentBlock;
 exports.readClaudeTranscriptRecord = readClaudeTranscriptRecord;
 exports.parseClaudeTranscript = parseClaudeTranscript;
@@ -210,6 +211,37 @@ function claudeSlashCommandPrompt(text) {
     const args = CLAUDE_COMMAND_ARGS_PATTERN.exec(trimmed)?.[1].trim() ?? '';
     return args.length === 0 ? name : `${name} ${args}`;
 }
+/**
+ * A paste's wrapper: `<pasted_content id="X">` … `</pasted_content id="X">`.
+ *
+ * The closing tag repeats the opening tag's id (`\1`), so a pair whose ids
+ * differ — or a tag only mentioned in prose — is not a wrapper and is left alone.
+ * One newline just inside each tag is the wrapper's own framing, not the body's.
+ */
+const CLAUDE_PASTED_CONTENT_PATTERN = /<pasted_content id="([^"<>\s]+)">\n?([\s\S]*?)\n?<\/pasted_content id="\1">/g;
+/**
+ * The text a person sent, with Claude Code's paste wrapper taken off (Issue #3102).
+ *
+ * Claude Code records a multi-line message that arrived as a paste — which is
+ * what CommandMate's tmux send looks like to it — with the body wrapped in
+ * `<pasted_content id="X">…</pasted_content id="X">`. `recordUserTurn` compares
+ * the transcript's text with the `/send` row (and a relay row) byte for byte, so
+ * the wrapper made every such prompt look like a different message and a second
+ * `user` row was written. Unwrapping here lets the existing adoption rules match.
+ *
+ * Every wrapper in the text is replaced by its body, including one inside a
+ * sentence the person typed around a paste. When the result is empty the original
+ * is returned, so this never turns a record into a blank prompt.
+ *
+ * @param text - The record's text, as {@link ClaudeTranscriptRecord.text} holds it
+ * @returns The text without wrappers, or `text` itself when there is none to remove
+ */
+function claudePastedContentPrompt(text) {
+    if (!text.includes('<pasted_content id='))
+        return text;
+    const unwrapped = text.replace(CLAUDE_PASTED_CONTENT_PATTERN, (_match, _id, body) => body);
+    return unwrapped.trim().length === 0 ? text : unwrapped;
+}
 /**
  * Read one `message.content` element.
  *
@@ -517,7 +549,7 @@ function createClaudeTurn(record, sessionId) {
         // A slash command's record is XML and the operator typed a line; #2265 puts
         // the line on the turn so that the `user` row reads `/release v0.30.1` and
         // the `/send` row holding those same bytes is adopted rather than doubled.
-        promptText: claudeSlashCommandPrompt(record.text) ?? record.text,
+        promptText: claudeSlashCommandPrompt(record.text) ?? claudePastedContentPrompt(record.text),
         promptIsOperatorInput: isClaudeOperatorPromptRecord(record),
         blocks: [],
         assistantRecords: 0,