commandmate 0.42.1 → 0.43.0

package/dist/server/src/lib/cli-tools/agent-mode-spec.js

@@ -24,6 +24,7 @@
  * | gemini         | 0.58.0   | `app.cycleApprovalMode` (docs)   | **NOT MEASURED** — see below                  |
  * | opencode       | 1.18.30  | agent switch, not a mode         | — (already shipped as #2046's quick keys)     |
  * | vibe-local     | —        | nothing (5 presses, no change)   | — (`-y` AUTO-APPROVE is fixed)                |
+ * | opencode-v2    | 2.0.18   | agent switch (Build ⇄ Plan)      | build ⇄ plan (declared since #3038)           |
  *
  * ## The three tools this table deliberately leaves out
  *
@@ -32,6 +33,9 @@
  *    mode spec would put a second button on the same key with a different
  *    promise. The separation is a DECLARATION (no entry here), not a tool-id
  *    check in the UI.
+ *    (OpenCode V2 is NOT left out any more — see {@link OPENCODE_V2_MODE_SPEC}.
+ *    #2966 left it out for v1's reason; #3038 moved its `shift+tab` from the
+ *    quick keys to the mode button, so there is still one button per key.)
  *  - **vibe-local.** Five presses produced a byte-identical frame. There is no
  *    mode to cycle; the wrapper fixes `-y`.
  *  - **gemini.** Its bundled `docs/reference/keyboard-shortcuts.md` does bind
@@ -44,12 +48,13 @@
  *
  * ## Why the indicators are patterns on a windowed tail and not positions
  *
- * The five declaring tools put the mode in five structurally different places —
+ * The declaring tools put the mode in structurally different places —
  * a dedicated footer row (claude), an independent row above the shortcut hint
  * (Command Code 1.53.1) or *replacing* it (1.49.0), the right end of a status
  * bar (codex), a word spliced into a hint bar whose element count changes with
  * the mode (copilot), and a right-aligned footer segment plus a banner inside
- * the composer box (agy). No column index, no row offset and no "nth segment"
+ * the composer box (agy), and the agent row under the composer (OpenCode V2).
+ * No column index, no row offset and no "nth segment"
  * rule survives that set, so each tool declares what its row LOOKS like and the
  * reader scans a small window of non-blank tail rows for it.
  *
@@ -290,6 +295,52 @@ const ANTIGRAVITY_MODE_SPEC = {
     tailRows: 2,
     noteId: null,
 };
+/**
+ * OpenCode V2's agent row, directly under the composer (Issue #3038).
+ *
+ * `shift+tab` on 2.0.18 toggles the AGENT, not a permission mode — `Build`
+ * (edits allowed) ⇄ `Plan` (read only) — on the home screen and inside a session
+ * alike, and the composer's last row names it. Measured 2026-09-30 through
+ * `scripts/opencode-v2/launch.sh` on a private tmux socket, 80x200
+ * (`tests/fixtures/opencode-v2-agent-mode-3038/`):
+ *
+ *   `   ┃  Build · LongCat 2.5 Preview Free OpenCode Zen`   (home, 4th row up)
+ *   `  ┃  Plan · LongCat 2.5 Preview Free OpenCode Zen`     (session, 3rd row up)
+ *
+ * Two rows the patterns must NOT read, both on the same screen:
+ *
+ *  - the completion row a finished turn leaves in the transcript,
+ *    `     Build · LongCat 2.5 Preview Free · 4.9s · 8.1 tok/s`. On 2.0.18 it
+ *    has no gutter at all (v1 drew `▣` there); the required `┃` excludes it;
+ *  - the user's own message, drawn in the same `┃  <text>` gutter. It is above
+ *    the composer, so the tail window below cannot reach it on a frame where
+ *    the composer is drawn.
+ *
+ * Both agents are drawn, so unlike codex / copilot / agy there is no silent
+ * base mode here: a frame without the row (a permission or question dialog
+ * replaces the composer) reads `unknown`.
+ *
+ * `build` is its own id rather than `default` — the chip says what the pane
+ * says (#2592) — and the `opencodeAgentSwitch` note tells the user this button
+ * switches the agent, which its "permission mode" aria label does not.
+ *
+ * The same key was `OpencodeQuickKeys`' v2 `agentNext` until #3038. It was
+ * taken off the strip in the same change, so the key has one button.
+ */
+const OPENCODE_V2_MODE_SPEC = {
+    key: 'BTab',
+    cycle: ['build', 'plan'],
+    indicators: [
+        { mode: 'build', pattern: /^[^\S\n]*┃[^\S\n]+Build[^\S\n]·[^\S\n]/ },
+        { mode: 'plan', pattern: /^[^\S\n]*┃[^\S\n]+Plan[^\S\n]·[^\S\n]/ },
+    ],
+    // The home screen draws `2.0.18` under the footer, which puts the agent row
+    // 4th from the bottom; in a session it is 3rd (footer, `╹▀▀▀`, agent row).
+    // Four and no more: the fifth row up is the composer's own gutter, and above
+    // that is the transcript, where the user's `┃  …` message lives.
+    tailRows: 4,
+    noteId: 'opencodeAgentSwitch',
+};
 /**
  * The declarations, keyed by tool.
  *
@@ -304,6 +355,7 @@ const AGENT_MODE_SPECS = {
     codex: CODEX_MODE_SPEC,
     copilot: COPILOT_MODE_SPEC,
     antigravity: ANTIGRAVITY_MODE_SPEC,
+    'opencode-v2': OPENCODE_V2_MODE_SPEC,
 };
 /**
  * How one CLI cycles its permission mode, or `null` when it does not have one.

package/dist/server/src/lib/cli-tools/base.js

@@ -595,8 +595,10 @@ class BaseCLITool {
      * against `NAVIGATION_KEY_VALUES` anyway, because a future edit could still
      * add an override to one of them.
      *
-     * THREE tools override it now:
+     * FOUR tools override it now:
      *  - opencode, with its `ctrl+x` leader and chord letters (#2046);
+     *  - OpenCode V2, with the same leader and a narrower set measured on 2.0.18
+     *    (`OPENCODE_V2_NAVIGATION_KEY_VALUES`, #2966);
      *  - claude and Command Code, with `CLAUDE_NAVIGATION_KEY_VALUES` — the base
      *    pad plus `s`, the key claude's `/model` footer offers for "use this
      *    session only" while `Enter` on the same overlay rewrites the user's
@@ -611,8 +613,10 @@ class BaseCLITool {
      * Declare how this tool cycles its permission mode (Issue #2592).
      *
      * The default is `null` — "this tool has no mode on `shift+tab`" — and that is
-     * the answer for three of the eight: opencode (whose `BTab` switches AGENTS,
+     * the answer for four of the nine: opencode (whose `BTab` switches AGENTS,
      * and already has `OpencodeQuickKeys`' `agentPrev` button from #2046),
+     * OpenCode V2 (the same: `BTab` toggles Build ⇄ Plan on 2.0.18 and is its
+     * quick keys' `agentNext`, #2966),
      * vibe-local (measured: five presses, byte-identical frame) and gemini (its
      * own docs bind `app.cycleApprovalMode`, but sign-in refused the CLI and the
      * footer spelling was never measured — a button is a promise about what

package/dist/server/src/lib/cli-tools/command-code.js

@@ -36,7 +36,7 @@
  * only the correlation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandCodeTool = exports.COMMAND_CODE_EXIT_COMMAND = exports.COMMAND_CODE_LAUNCH_FLAGS = exports.COMMAND_CODE_COMMAND = void 0;
+exports.CommandCodeTool = exports.COMMAND_CODE_STARTING_WINDOW_MS = exports.COMMAND_CODE_EXIT_COMMAND = exports.COMMAND_CODE_LAUNCH_FLAGS = exports.COMMAND_CODE_COMMAND = void 0;
 exports.buildCommandCodeLaunchCommand = buildCommandCodeLaunchCommand;
 exports.isCommandCodeReady = isCommandCodeReady;
 const base_1 = require("./base");
@@ -51,6 +51,7 @@ const tool_id_1 = require("../../lib/hooks/sources/command-code/tool-id");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const install_hints_1 = require("./install-hints");
+const session_start_error_1 = require("../../lib/session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/command-code');
 /** The executable CommandMate launches. See the module docblock for why not `cmd`. */
 exports.COMMAND_CODE_COMMAND = 'commandcode';
@@ -106,6 +107,16 @@ const COMMAND_CODE_POLL_INTERVAL_MS = 1000;
 const COMMAND_CODE_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for the composer before sending a message. */
 const COMMAND_CODE_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/**
+ * How long after a launch a composer that has never been seen still counts as
+ * "starting" (Issue #3006).
+ *
+ * Past this, a pane that has shown no composer since it was launched is not
+ * slow, it is stuck on something (an unmeasured dialog, a crash screen), and
+ * `prompt not ready` — which #3007 answers by reading the screen — is the
+ * truer report than "retry in a few seconds".
+ */
+exports.COMMAND_CODE_STARTING_WINDOW_MS = 120_000;
 /** Rows of pane tail the readiness probe reads. */
 const COMMAND_CODE_READINESS_CAPTURE_LINES = 50;
 /**
@@ -141,6 +152,20 @@ class CommandCodeTool extends base_1.BaseCLITool {
     id = 'command-code';
     name = 'Command Code CLI';
     command = exports.COMMAND_CODE_COMMAND;
+    /**
+     * Sessions this instance launched whose composer has not been seen since,
+     * keyed by tmux session name, valued by launch time (Issue #3006).
+     *
+     * This is what tells a slow cold start apart from a live session that is
+     * showing something other than the composer. Only the launch path adds an
+     * entry, and any readiness probe that sees the composer removes it, so a
+     * session that has ever reached its composer keeps the old
+     * `prompt not ready` refusal. Held per instance rather than per module
+     * because `CLIToolManager` holds one instance for the process, and a restart
+     * forgets it — which errs towards `prompt not ready`, the answer this
+     * repository gave before.
+     */
+    composerPendingSince = new Map();
     /**
      * Declare the claude-family pad (Issue #2297).
      *
@@ -209,6 +234,9 @@ class CommandCodeTool extends base_1.BaseCLITool {
         // launch below then fails: falling back to the screen scraper is always safe
         // and trusting a dead session's events is not.
         (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: tool_id_1.COMMAND_CODE_CLI_TOOL_ID, instanceId });
+        // Issue #3006: from here until a readiness probe sees the composer, a send
+        // that cannot find it is reporting a slow start, not a wedged session.
+        this.composerPendingSince.set(sessionName, Date.now());
         try {
             if (!exists) {
                 // Inline-rendered, so the pane keeps scrollback; depth comes from the
@@ -229,6 +257,7 @@ class CommandCodeTool extends base_1.BaseCLITool {
             logger.info('started-command-code-session');
         }
         catch (error) {
+            this.composerPendingSince.delete(sessionName);
             throw new Error(`Failed to start Command Code session: ${(0, errors_1.getErrorMessage)(error)}`);
         }
     }
@@ -246,6 +275,7 @@ class CommandCodeTool extends base_1.BaseCLITool {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, COMMAND_CODE_READINESS_CAPTURE_LINES);
                 if (isCommandCodeReady(rawOutput)) {
+                    this.composerPendingSince.delete(sessionName);
                     logger.info('command-code-prompt-detected');
                     return;
                 }
@@ -262,6 +292,15 @@ class CommandCodeTool extends base_1.BaseCLITool {
      * Mirrors CodexTool.waitForPrompt: throws on timeout so a failed readiness
      * check STOPS the send rather than typing into a non-ready TUI.
      *
+     * Issue #3006: when the session was launched by this server and its composer
+     * has not been seen once since — the cold start of a dispatch — the timeout
+     * is a {@link SessionStartTimeoutError} (`SESSION_STARTING`, 503 at the send
+     * route), the same answer claude gives for a start that is merely slow. A
+     * session that HAS shown its composer keeps the plain `prompt not ready`
+     * error: it is up, and something on screen is in the way.
+     *
+     * @throws SessionStartTimeoutError when a just-launched session's composer
+     *   has still not appeared
      * @throws Error when the composer is not detected within the timeout
      */
     async waitForPrompt(sessionName) {
@@ -271,6 +310,7 @@ class CommandCodeTool extends base_1.BaseCLITool {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, COMMAND_CODE_READINESS_CAPTURE_LINES);
                 if (isCommandCodeReady(rawOutput)) {
+                    this.composerPendingSince.delete(sessionName);
                     return;
                 }
             }
@@ -279,6 +319,16 @@ class CommandCodeTool extends base_1.BaseCLITool {
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
+        const launchedAt = this.composerPendingSince.get(sessionName);
+        if (launchedAt !== undefined) {
+            const sinceLaunchMs = Date.now() - launchedAt;
+            if (sinceLaunchMs <= exports.COMMAND_CODE_STARTING_WINDOW_MS) {
+                logger.info('command-code-session-still-starting', { sessionName, sinceLaunchMs });
+                throw new session_start_error_1.SessionStartTimeoutError(this.name, sessionName, sinceLaunchMs);
+            }
+            // Too long since the launch to call it slow; report it as not ready.
+            this.composerPendingSince.delete(sessionName);
+        }
         logger.info('command-code-prompt-not-ready');
         throw new Error('Command Code prompt not ready: timed out waiting for the composer before sending');
     }
@@ -312,6 +362,9 @@ class CommandCodeTool extends base_1.BaseCLITool {
             logger.info('sent-message-to-command-code-session');
         }
         catch (error) {
+            // Issue #3006: passed through unwrapped so its `code` reaches the route.
+            if ((0, session_start_error_1.isSessionStartTimeoutError)(error))
+                throw error;
             throw new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`);
         }
     }
@@ -338,6 +391,7 @@ class CommandCodeTool extends base_1.BaseCLITool {
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_EXIT_WAIT_MS));
             }
             const killed = await (0, tmux_1.killSession)(sessionName);
+            this.composerPendingSince.delete(sessionName);
             // So a later session reusing the name starts clean.
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             if (killed) {

package/dist/server/src/lib/cli-tools/composer-spec.js

@@ -87,6 +87,16 @@ const COMPOSER_SPECS = {
         clearBeforeSend: false,
         submitEnterCount: 1,
     },
+    // Issue #2934: OpenCode V2 draws the same gutter-and-no-marker input box as
+    // v1 (`┃  Ask anything… "…"` on 2.0.18, 80x200), so the box reader is the
+    // right one — the marker reader would find nothing and classify every send
+    // `submitted` without evidence. Same pane height as v1's.
+    'opencode-v2': {
+        reader: 'opencode-box',
+        verifyCaptureLines: tmux_pane_config_1.OPENCODE_PANE_HEIGHT,
+        clearBeforeSend: false,
+        submitEnterCount: 1,
+    },
 };
 /**
  * The composer description for a CLI tool.

package/dist/server/src/lib/cli-tools/copilot-executable.js

@@ -39,6 +39,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COPILOT_VERSION_PROBE_TIMEOUT_MS = void 0;
 exports.findExecutableOnPath = findExecutableOnPath;
+exports.findExecutablesOnPath = findExecutablesOnPath;
 exports.resolveCopilotExecutable = resolveCopilotExecutable;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
@@ -83,17 +84,32 @@ function isExecutableFile(candidate) {
  * is; what is copilot-specific is the caller below.
  */
 function findExecutableOnPath(name) {
+    return findExecutablesOnPath(name, 1)[0] ?? null;
+}
+/**
+ * Every executable named `name` on `PATH`, in `PATH` order, up to `limit`.
+ *
+ * Issue #2939: `opencode` can name two different programs on one machine
+ * (OpenCode 1.x's installer and `@opencode/cli`, which registers `opencode`
+ * next to `opencode2`), so "the first one" is not always the one a tool wants.
+ * The same walk as {@link findExecutableOnPath}, not a second copy of it.
+ */
+function findExecutablesOnPath(name, limit = Infinity) {
     const rawPath = process.env.PATH;
-    if (!rawPath)
-        return null;
+    if (!rawPath || limit <= 0)
+        return [];
+    const found = [];
     for (const directory of rawPath.split(path_1.delimiter)) {
         if (!directory)
             continue;
         const candidate = (0, path_1.join)(directory, name);
-        if (isExecutableFile(candidate))
-            return candidate;
+        if (found.includes(candidate) || !isExecutableFile(candidate))
+            continue;
+        found.push(candidate);
+        if (found.length >= limit)
+            break;
     }
-    return null;
+    return found;
 }
 /**
  * Where `gh copilot` puts the copy it downloads.

package/dist/server/src/lib/cli-tools/graceful-exit.js

@@ -42,7 +42,7 @@
  * @module lib/cli-tools/graceful-exit
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_GRACEFUL_EXIT_SPEC = exports.GEMINI_EXIT_COMMAND_TEXT = exports.COMMAND_CODE_EXIT_COMMAND_TEXT = exports.OPENCODE_EXIT_COMMAND_TEXT = exports.COPILOT_EXIT_COMMAND_TEXT = void 0;
+exports.DEFAULT_GRACEFUL_EXIT_SPEC = exports.GEMINI_EXIT_COMMAND_TEXT = exports.COMMAND_CODE_EXIT_COMMAND_TEXT = exports.OPENCODE_V2_EXIT_COMMAND_TEXT = exports.OPENCODE_EXIT_COMMAND_TEXT = exports.COPILOT_EXIT_COMMAND_TEXT = void 0;
 exports.resolveGracefulExitSpec = resolveGracefulExitSpec;
 exports.verifyGracefulExit = verifyGracefulExit;
 const copilot_constants_1 = require("../../config/copilot-constants");
@@ -52,6 +52,8 @@ const cli_tool_contracts_1 = require("../../types/cli-tool-contracts");
 exports.COPILOT_EXIT_COMMAND_TEXT = '/exit';
 /** The graceful exit command opencode's TUI accepts. */
 exports.OPENCODE_EXIT_COMMAND_TEXT = '/exit';
+/** OpenCode V2's quit command (Issue #2934) — the TUI's own `/exit`. */
+exports.OPENCODE_V2_EXIT_COMMAND_TEXT = '/exit';
 /** Command Code's own quit command (Issue #2250). */
 exports.COMMAND_CODE_EXIT_COMMAND_TEXT = '/exit';
 /** The graceful exit command gemini's TUI accepts. */
@@ -141,6 +143,18 @@ const GRACEFUL_EXIT_SPECS = {
         exitWaitMs: cli_tool_timing_config_1.OPENCODE_EXIT_WAIT_MS,
         ownsLoopbackServer: true,
     },
+    // Issue #2934: `/exit` and a separate Enter, as for v1. The server is not the
+    // TUI here but `opencode2 serve` in the same pane, stopped by
+    // `scripts/opencode-v2/launch.sh`'s trap when the TUI goes — so the pane still
+    // owns a loopback port, and the postcondition checks it stopped answering.
+    'opencode-v2': {
+        keys: [
+            (0, cli_tool_contracts_1.literalStep)(exports.OPENCODE_V2_EXIT_COMMAND_TEXT, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS),
+            (0, cli_tool_contracts_1.keyStep)('Enter'),
+        ],
+        exitWaitMs: cli_tool_timing_config_1.OPENCODE_V2_EXIT_WAIT_MS,
+        ownsLoopbackServer: true,
+    },
 };
 /**
  * The graceful-exit description for a CLI tool.

package/dist/server/src/lib/cli-tools/index.js

@@ -6,7 +6,7 @@
  * @module cli-tools
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIToolManager = exports.buildCommandCodeLaunchCommand = exports.CommandCodeTool = exports.AntigravityTool = exports.GeminiTool = exports.CodexTool = exports.ClaudeTool = exports.BaseCLITool = exports.DEFAULT_GRACEFUL_EXIT_SPEC = exports.verifyGracefulExit = exports.resolveGracefulExitSpec = exports.GEMINI_PANE_HEIGHT = exports.resolveCaptureSpec = exports.DEFAULT_COMPOSER_SPEC = exports.resolveComposerSpec = exports.isImageCapableCLITool = void 0;
+exports.CLIToolManager = exports.OpenCodeV2Tool = exports.buildCommandCodeLaunchCommand = exports.CommandCodeTool = exports.AntigravityTool = exports.GeminiTool = exports.CodexTool = exports.ClaudeTool = exports.BaseCLITool = exports.DEFAULT_GRACEFUL_EXIT_SPEC = exports.verifyGracefulExit = exports.resolveGracefulExitSpec = exports.GEMINI_PANE_HEIGHT = exports.resolveCaptureSpec = exports.DEFAULT_COMPOSER_SPEC = exports.resolveComposerSpec = exports.isImageCapableCLITool = void 0;
 var types_1 = require("./types");
 Object.defineProperty(exports, "isImageCapableCLITool", { enumerable: true, get: function () { return types_1.isImageCapableCLITool; } });
 var composer_spec_1 = require("./composer-spec");
@@ -34,6 +34,8 @@ Object.defineProperty(exports, "AntigravityTool", { enumerable: true, get: funct
 var command_code_1 = require("./command-code");
 Object.defineProperty(exports, "CommandCodeTool", { enumerable: true, get: function () { return command_code_1.CommandCodeTool; } });
 Object.defineProperty(exports, "buildCommandCodeLaunchCommand", { enumerable: true, get: function () { return command_code_1.buildCommandCodeLaunchCommand; } });
+var opencode_v2_1 = require("./opencode-v2");
+Object.defineProperty(exports, "OpenCodeV2Tool", { enumerable: true, get: function () { return opencode_v2_1.OpenCodeV2Tool; } });
 // Export CLI tool manager
 var manager_1 = require("./manager");
 Object.defineProperty(exports, "CLIToolManager", { enumerable: true, get: function () { return manager_1.CLIToolManager; } });

package/dist/server/src/lib/cli-tools/install-hints.js

@@ -83,6 +83,8 @@ exports.CLI_TOOL_INSTALL_HINTS = {
     opencode: 'Install with: npm install -g opencode-ai',
     copilot: copilot_constants_1.COPILOT_INSTALL_HINT,
     'command-code': 'Install with: npm install -g command-code',
+    // Issue #2934: the package installs the `opencode2` executable.
+    'opencode-v2': 'Install with: npm install -g @opencode/cli',
     // No package to name: `agy` ships with Antigravity and updates itself. The
     // URL is lifted from the binary on PATH rather than from a search result.
     antigravity: 'Install the Antigravity CLI: https://antigravity.google/docs/cli/reference',
@@ -114,18 +116,22 @@ function getCliToolInstallHint(id) {
  * and #2009's contract is that the phrase survives.
  *
  * @param tool - The tool that could not be started
+ * @param detail - Why, when there is more to say than "not on PATH" — e.g.
+ *   `opencode` is there but is OpenCode V2 (Issue #2939)
  * @returns A sentence safe to hand back to an HTTP caller
  */
-function buildMissingToolMessage(tool) {
+function buildMissingToolMessage(tool, detail) {
     return (`${tool.name} (${tool.command}) is not installed or not in PATH. ` +
+        (detail ? `${detail} ` : '') +
         `${getCliToolInstallHint(tool.id)}`);
 }
 /**
  * The typed refusal, carrying {@link buildMissingToolMessage}.
  *
  * @param tool - The tool that could not be started
+ * @param detail - See {@link buildMissingToolMessage}
  * @returns The error every launch path throws for a missing binary
  */
-function missingToolError(tool) {
-    return new session_start_error_1.SessionStartUnavailableError(tool.name, buildMissingToolMessage(tool));
+function missingToolError(tool, detail) {
+    return new session_start_error_1.SessionStartUnavailableError(tool.name, buildMissingToolMessage(tool, detail));
 }

package/dist/server/src/lib/cli-tools/liveness-spec.js

@@ -211,6 +211,25 @@ const LIVENESS_SPECS = {
             cli_patterns_1.COMMAND_CODE_THINKING_PATTERN,
         ],
     },
+    /**
+     * OpenCode V2 2.0.18 — measured at 80x200 (Issue #2934).
+     *
+     * The footer (`… ctrl+p commands`) is drawn on every frame the TUI paints,
+     * before and after a turn and while one runs, so it alone carries liveness;
+     * the placeholder and the running hint are listed as well so a frame with
+     * either is not taken for a shell. None of the three can be matched by a
+     * shell prompt. After the TUI exits the alternate screen is gone and only the
+     * shell's rows remain, which is what makes the verdict flip.
+     */
+    'opencode-v2': {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [
+            cli_patterns_1.OPENCODE_V2_IDLE_COMPOSER_PATTERN,
+            cli_patterns_1.OPENCODE_V2_FOOTER_PATTERN,
+            cli_patterns_1.OPENCODE_V2_THINKING_PATTERN,
+        ],
+    },
     /** vibe-local — patterns from `cli-patterns`; no live frames (needs Ollama). */
     'vibe-local': {
         ...SHARED,

package/dist/server/src/lib/cli-tools/manager.js

@@ -46,6 +46,7 @@ const opencode_1 = require("./opencode");
 const copilot_1 = require("./copilot");
 const antigravity_1 = require("./antigravity");
 const command_code_1 = require("./command-code");
+const opencode_v2_1 = require("./opencode-v2");
 /**
  * CLI Tool Manager (Singleton)
  * Provides centralized access to all CLI tools (Issue #368: includes Vibe Local, Issue #379: includes OpenCode)
@@ -67,6 +68,7 @@ class CLIToolManager {
         this.tools.set('copilot', new copilot_1.CopilotTool());
         this.tools.set('antigravity', new antigravity_1.AntigravityTool());
         this.tools.set('command-code', new command_code_1.CommandCodeTool());
+        this.tools.set('opencode-v2', new opencode_v2_1.OpenCodeV2Tool());
     }
     /**
      * Get singleton instance

package/dist/server/src/lib/cli-tools/opencode-executable.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Which `opencode` is OpenCode 1.x and which is OpenCode V2 (Issue #2939).
+ *
+ * ## Why the name is not enough
+ *
+ * OpenCode V2's npm package `@opencode/cli` (2.0.18) registers **both**
+ * `opencode` and `opencode2` in its `bin`. So on a machine that has it,
+ * `opencode` may be OpenCode 1.x (its own installer, `~/.opencode/bin`) or
+ * OpenCode V2 (`/opt/homebrew/bin/opencode`), decided by nothing but the order
+ * of `PATH`. Asking `which opencode` then answers "OpenCode is installed" for a
+ * V2 binary, and the v1 launch line (`opencode --port N --hostname …`) reaches
+ * a program that has neither flag.
+ *
+ * The answer here is the version each candidate prints about itself:
+ *
+ *  - OpenCode 1.x prints a bare `1.18.33`;
+ *  - OpenCode V2 prints `opencode v2.0.18`.
+ *
+ * Every `opencode` / `opencode2` on `PATH` is a candidate, not just the first,
+ * so a V2 `opencode` earlier on `PATH` no longer hides a 1.x one behind it.
+ *
+ * ## Probe and launch are one measurement
+ *
+ * The path that answered is the path the launch line runs — the rule
+ * `./copilot-executable` set for copilot (#1907). The server resolves names on
+ * its own `PATH`, the pane on its login shell's; typing a bare `opencode` would
+ * let the two disagree.
+ *
+ * ## Cost
+ *
+ * `opencode --version` takes ~0.4 s and both tools probe `opencode`, so one
+ * probe per path is shared for {@link OPENCODE_EXECUTABLE_CACHE_TTL_MS}, and a
+ * concurrent caller gets the probe already in flight.
+ *
+ * @module lib/cli-tools/opencode-executable
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS = exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS = exports.OPENCODE_V2_BINARY_NAME = exports.OPENCODE_V1_BINARY_NAME = void 0;
+exports.parseOpencodeVersionOutput = parseOpencodeVersionOutput;
+exports.clearOpencodeExecutableCache = clearOpencodeExecutableCache;
+exports.probeOpencodeExecutable = probeOpencodeExecutable;
+exports.resolveOpencodeV1Executable = resolveOpencodeV1Executable;
+exports.resolveOpencodeV2Executable = resolveOpencodeV2Executable;
+exports.describeOpencodeV1Unavailable = describeOpencodeV1Unavailable;
+const child_process_1 = require("child_process");
+const copilot_executable_1 = require("./copilot-executable");
+const env_sanitizer_1 = require("../security/env-sanitizer");
+/** OpenCode 1.x's executable name (tool id `opencode`). */
+exports.OPENCODE_V1_BINARY_NAME = 'opencode';
+/** OpenCode V2's own executable name (tool id `opencode-v2`). */
+exports.OPENCODE_V2_BINARY_NAME = 'opencode2';
+/** Budget for one `--version`. */
+exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS = 5000;
+/** `--version` prints one short line; anything bigger is not an answer. */
+const OPENCODE_VERSION_PROBE_MAX_BUFFER = 64 * 1024;
+/** How long one probe result is reused (same TTL as the installed-agents cache). */
+exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS = 30_000;
+/** Candidates probed per name. A PATH with more copies than this is not a setup to guess about. */
+const MAX_CANDIDATES_PER_NAME = 4;
+/** `opencode v2.0.18` — OpenCode V2's form. */
+const PREFIXED_VERSION_LINE = /^opencode v(\d+)\.(\d+)\.(\d+)((?:[-+][0-9A-Za-z.-]+)?)$/;
+/** `1.18.33` — OpenCode 1.x's form: the version and nothing else. */
+const BARE_VERSION_LINE = /^v?(\d+)\.(\d+)\.(\d+)((?:[-+][0-9A-Za-z.-]+)?)$/;
+/**
+ * Classify `opencode --version` / `opencode2 --version` output.
+ *
+ * A line has to be a version in one of the two forms and nothing else, so a
+ * different program that happens to print a number is not taken for either.
+ * The major version decides: 1 is OpenCode 1.x, 2 or later is OpenCode V2.
+ * `0.x` (the pre-1.0 `opencode`) and anything unreadable are null.
+ *
+ * @returns The generation and version, or null when the output is not OpenCode's
+ */
+function parseOpencodeVersionOutput(output) {
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = PREFIXED_VERSION_LINE.exec(line) ?? BARE_VERSION_LINE.exec(line);
+        if (!match)
+            continue;
+        const major = Number(match[1]);
+        const version = `${match[1]}.${match[2]}.${match[3]}${match[4] ?? ''}`;
+        if (major === 1)
+            return { generation: 'v1', version };
+        if (major >= 2)
+            return { generation: 'v2', version };
+        return null;
+    }
+    return null;
+}
+const probeCache = new Map();
+/** Forget every cached probe (tests, and a caller that knows the install changed). */
+function clearOpencodeExecutableCache() {
+    probeCache.clear();
+}
+function runVersionProbe(executable) {
+    return new Promise((resolve) => {
+        try {
+            (0, child_process_1.execFile)(executable, ['--version'], {
+                timeout: exports.OPENCODE_VERSION_PROBE_TIMEOUT_MS,
+                maxBuffer: OPENCODE_VERSION_PROBE_MAX_BUFFER,
+                env: (0, env_sanitizer_1.sanitizeEnvForChildProcess)(),
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    resolve(null);
+                    return;
+                }
+                resolve(parseOpencodeVersionOutput(`${stdout ?? ''}\n${stderr ?? ''}`));
+            });
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}
+/** `<path> --version`, classified; cached per path. Never rejects. */
+function probeOpencodeExecutable(path) {
+    const now = Date.now();
+    const cached = probeCache.get(path);
+    if (cached && cached.expiresAt > now)
+        return cached.info;
+    const info = runVersionProbe(path);
+    probeCache.set(path, { expiresAt: now + exports.OPENCODE_EXECUTABLE_CACHE_TTL_MS, info });
+    return info;
+}
+/** Probe `names` in order and return the first candidate of `generation`. */
+async function resolveGeneration(names, generation) {
+    const probed = [];
+    for (const name of names) {
+        for (const path of (0, copilot_executable_1.findExecutablesOnPath)(name, MAX_CANDIDATES_PER_NAME)) {
+            if (probed.some((p) => p.path === path))
+                continue;
+            const info = await probeOpencodeExecutable(path);
+            probed.push({ path, info });
+            if (info?.generation === generation) {
+                return { executable: { path, version: info.version, generation }, probed };
+            }
+        }
+    }
+    return { executable: null, probed };
+}
+/**
+ * OpenCode 1.x: the first `opencode` on `PATH` that prints a 1.x version.
+ * An `opencode` that answers `opencode v2.x` is skipped, never launched.
+ */
+function resolveOpencodeV1Executable() {
+    return resolveGeneration([exports.OPENCODE_V1_BINARY_NAME], 'v1');
+}
+/**
+ * OpenCode V2: `opencode2` first, then an `opencode` that prints
+ * `opencode v2.x` — for an operator who has V2 only under the `opencode` name.
+ */
+function resolveOpencodeV2Executable() {
+    return resolveGeneration([exports.OPENCODE_V2_BINARY_NAME, exports.OPENCODE_V1_BINARY_NAME], 'v2');
+}
+/**
+ * Why OpenCode 1.x counts as not installed, when there is more to say than
+ * "no `opencode` on PATH".
+ *
+ * @returns A sentence naming the `opencode` that is there and what it is, or
+ *   null when nothing called `opencode` was found at all
+ */
+function describeOpencodeV1Unavailable(resolution) {
+    if (resolution.executable)
+        return null;
+    const v2 = resolution.probed.find((p) => p.info?.generation === 'v2');
+    if (v2?.info) {
+        return (`\`opencode\` at ${v2.path} is OpenCode V2 ${v2.info.version}, not OpenCode 1.x ` +
+            '(npm `@opencode/cli` registers both `opencode` and `opencode2`). ' +
+            'Use the OpenCode V2 agent, or put an OpenCode 1.x `opencode` on PATH.');
+    }
+    const other = resolution.probed[0];
+    if (other) {
+        return `\`opencode\` at ${other.path} did not report an OpenCode 1.x version (\`opencode --version\`).`;
+    }
+    return null;
+}