commandmate 0.42.2 → 0.43.0

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

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * OpenCode V2 (`opencode2`) CLI tool (Issue #2934, Epic #2370 Phase 1).
+ *
+ * A separate tool from `opencode` (v1), not a version branch of it: OpenCode
+ * 2.0's server, event vocabulary and screen all differ, and v1 keeps every
+ * behaviour it had (Epic #2370, decision 1).
+ *
+ * ## The pane
+ *
+ * One tmux pane holds both processes OpenCode V2 needs. The launch line runs
+ * `scripts/opencode-v2/launch.sh`, which starts `opencode2 serve` on the
+ * instance's own port with the instance's own password, waits for
+ * `GET /openapi.json`, runs `opencode2 --server <url> <worktree>` in the
+ * foreground, and — through a trap on EXIT / HUP / INT / TERM — stops the server
+ * whichever way the TUI goes. So `/exit`, a crashed TUI and `tmux kill-session`
+ * all release the port (the #1905 failure, prevented by construction), and a
+ * CommandMate restart leaves both running because neither is CommandMate's
+ * child.
+ *
+ * ## What is structured and what is read off the screen
+ *
+ *  - state (running / ready / waiting) comes from the server's SSE stream
+ *    (`@/lib/hooks/sources/opencode-v2`), subscribed once the TUI is up;
+ *  - sending goes through the TUI's composer via tmux, as for v1's fallback
+ *    path (D6). `session.prompt` is not used: it addresses a session by id, and
+ *    the TUI may be showing a different one;
+ *  - the screen scraper still reads the pane, as every tool's fallback.
+ *
+ * Phase 2 adds approvals / questions / History, Phase 3 richer screen reading
+ * and quick keys ({@link OpenCodeV2Tool.navigationKeys}, Issue #2966).
+ *
+ * @module lib/cli-tools/opencode-v2
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCodeV2Tool = exports.OPENCODE_V2_NAVIGATION_KEY_VALUES = exports.OPENCODE_V2_RESUME_RETRY_MS = exports.OPENCODE_V2_READY_MAX_ATTEMPTS = exports.OPENCODE_V2_READY_POLL_INTERVAL_MS = void 0;
+exports.parseOpencodeV2Version = parseOpencodeV2Version;
+exports.toOpencodeV2ComposerText = toOpencodeV2ComposerText;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const base_1 = require("./base");
+const terminal_keys_1 = require("../../types/terminal-keys");
+const tmux_1 = require("../tmux/tmux");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const submit_verified_sender_1 = require("./submit-verified-sender");
+const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+const logger_1 = require("../../lib/logger");
+const errors_1 = require("../../lib/errors");
+const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
+const runtime_1 = require("../../lib/hooks/sources/opencode-v2/runtime");
+const client_1 = require("../../lib/hooks/sources/opencode-v2/client");
+const ports_1 = require("../../lib/hooks/sources/opencode-v2/ports");
+const subscription_1 = require("../../lib/hooks/sources/opencode-v2/subscription");
+const tool_id_1 = require("../../lib/hooks/sources/opencode-v2/tool-id");
+const graceful_exit_1 = require("./graceful-exit");
+const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const install_hints_1 = require("./install-hints");
+const opencode_executable_1 = require("./opencode-executable");
+const logger = (0, logger_1.createLogger)('cli-tools/opencode-v2');
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/** Interval between composer polls (launch and send). */
+exports.OPENCODE_V2_READY_POLL_INTERVAL_MS = 500;
+/** Composer polls after the launch line before giving up (30 s at 500 ms). */
+exports.OPENCODE_V2_READY_MAX_ATTEMPTS = 60;
+/** Rows captured when looking for the composer. The pane is 200 rows tall. */
+const OPENCODE_V2_READY_CAPTURE_LINES = tmux_pane_config_1.OPENCODE_PANE_HEIGHT;
+/**
+ * How long a failed lazy resume is not retried (ms). `isRunning` is polled, and
+ * a server that is really gone must not be probed on every poll.
+ */
+exports.OPENCODE_V2_RESUME_RETRY_MS = 30_000;
+/**
+ * The version `opencode2 --version` reports, or null when the output is not
+ * OpenCode V2's. Issue #2939: the same rule OpenCode 1.x is told apart by
+ * (`./opencode-executable`), so `1.18.33` is not V2 and `opencode v2.0.18` is.
+ */
+function parseOpencodeV2Version(output) {
+    const info = (0, opencode_executable_1.parseOpencodeVersionOutput)(output);
+    return info?.generation === 'v2' ? info.version : null;
+}
+/** A bare `/<name>`: a slash command with no argument and no whitespace at all. */
+const BARE_SLASH_COMMAND = /^\/\S+$/;
+/**
+ * The text to type for `message` (Issue #2950).
+ *
+ * The TUI opens its command dropdown on any composer text starting with `/`,
+ * and while it is open Enter picks a row instead of submitting — so a bare
+ * `/probe-agentsskills` sits in the composer ("No matching commands") and runs
+ * nothing, while `/probe-agentsskills ` (one trailing space) closes the
+ * dropdown and runs. The palette already inserts `` `${trigger} ` `` (see
+ * `loadOpencodeSkills` in `@/lib/slash-commands`, "The trailing space is
+ * load-bearing"), but the send route trims the body, so the space never
+ * arrives. It is put back here, and only for a bare `/<name>`: a command with
+ * an argument already has a space after the name, and ordinary text does not
+ * open the dropdown.
+ */
+function toOpencodeV2ComposerText(message) {
+    return BARE_SLASH_COMMAND.test(message) ? `${message} ` : message;
+}
+/**
+ * The leader-chord letters OpenCode V2 2.0.18 answers on its home screen, as
+ * sent by `OpencodeQuickKeys`' v2 strip (Issue #2966): `a` agents, `l`
+ * sessions, `m` models. `n` (new session) is also sent, but is already in
+ * {@link NAVIGATION_KEY_VALUES} (#2254), so it is not listed twice.
+ *
+ * Deliberately narrower than v1's `OPENCODE_CHORD_ONLY_VALUES`. Measured on
+ * 2.0.18 (private tmux socket, 80 columns, isolated `HOME` / XDG dirs):
+ * `ctrl+x t` is not `theme_list` any more — on the home screen the leader lets
+ * the `t` through into the composer, and inside a session it opens a terminal
+ * pane. `g` / `u` / `r` / `c` work only inside a session and type their letter
+ * into the composer otherwise; the strip does not offer them for v2 (see
+ * `OpencodeQuickKeys`), so they are not declared either.
+ */
+const OPENCODE_V2_CHORD_ONLY_VALUES = ['a', 'l', 'm'];
+/**
+ * Everything an OpenCode V2 pane may be sent through `/special-keys`: the base
+ * pad plus the `ctrl+x` leader, `ctrl+p` / `ctrl+t`, and the three chord
+ * letters above (Issue #2966).
+ */
+exports.OPENCODE_V2_NAVIGATION_KEY_VALUES = [
+    ...terminal_keys_1.NAVIGATION_KEY_VALUES,
+    terminal_keys_1.OPENCODE_LEADER_KEY,
+    ...terminal_keys_1.OPENCODE_DIRECT_KEY_VALUES,
+    ...OPENCODE_V2_CHORD_ONLY_VALUES,
+];
+class OpenCodeV2Tool extends base_1.BaseCLITool {
+    id = tool_id_1.OPENCODE_V2_CLI_TOOL_ID;
+    name = 'OpenCode V2';
+    command = tool_id_1.OPENCODE_V2_COMMAND;
+    /** Last lazy-resume attempt per session name, for {@link OPENCODE_V2_RESUME_RETRY_MS}. */
+    resumeAttemptedAt = new Map();
+    /**
+     * Declare the keys OpenCode V2's quick keys send (Issue #2966).
+     *
+     * Without this override the route validates against the base pad and answers
+     * 400 for `C-p` / `C-t` / `C-x`, so the palette, the variant cycle and every
+     * leader chord on the strip would be unsendable. The leader is `ctrl+x`, the
+     * same default as v1 — 2.0.18's own palette prints `ctrl+x m`, `ctrl+x a`,
+     * `ctrl+x l`, `ctrl+x n`.
+     *
+     * @returns This tool's {@link NavigationKeySpec}
+     */
+    navigationKeys() {
+        return {
+            keys: exports.OPENCODE_V2_NAVIGATION_KEY_VALUES,
+            leaderKey: terminal_keys_1.OPENCODE_LEADER_KEY,
+        };
+    }
+    /**
+     * Installed means an executable that identifies itself as OpenCode V2
+     * (`opencode v<semver>`, D1): `opencode2`, or — Issue #2939 — an `opencode`
+     * that answers as V2, for an operator who has V2 under that name only.
+     */
+    async isInstalled() {
+        return (await (0, opencode_executable_1.resolveOpencodeV2Executable)()).executable !== null;
+    }
+    /**
+     * Whether the instance's tmux session exists.
+     *
+     * A live session this process holds no subscription for — a pane that
+     * outlived a CommandMate restart — gets its event stream back here, fire and
+     * forget and at most every {@link OPENCODE_V2_RESUME_RETRY_MS}, so status
+     * comes from the server again as soon as anything polls the pane.
+     */
+    async isRunning(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const running = await (0, tmux_1.hasSession)(sessionName);
+        if (running)
+            this.resumeInBackground(worktreeId, sessionName, instanceId);
+        return running;
+    }
+    resumeInBackground(worktreeId, sessionName, instanceId) {
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        if ((0, subscription_1.isOpencodeV2Subscribed)(target))
+            return;
+        const now = Date.now();
+        const last = this.resumeAttemptedAt.get(sessionName);
+        if (last !== undefined && now - last < exports.OPENCODE_V2_RESUME_RETRY_MS)
+            return;
+        this.resumeAttemptedAt.set(sessionName, now);
+        void (async () => {
+            try {
+                const worktreePath = await (0, tmux_1.getSessionWorkingDirectory)(sessionName);
+                if (worktreePath === null)
+                    return;
+                await (0, runtime_1.resumeOpencodeV2EventStream)(target, worktreePath);
+            }
+            catch (error) {
+                logger.debug('opencode-v2-lazy-resume-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            }
+        })();
+    }
+    async launchSession(worktreeId, worktreePath, instanceId) {
+        // Issue #2939: the file that answered as V2 is the file the line runs.
+        const executable = (await (0, opencode_executable_1.resolveOpencodeV2Executable)()).executable;
+        if (!executable) {
+            throw (0, install_hints_1.missingToolError)(this);
+        }
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const geometry = { windowWidth: (0, tmux_pane_config_1.resolveOpencodePaneWidth)(), windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT };
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            await this.reconcileExistingSession(sessionName, worktreePath, geometry);
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                await (0, runtime_1.resumeOpencodeV2EventStream)(target, worktreePath);
+                logger.info('opencode-v2-session-exists');
+                return;
+            }
+            logger.warn('opencode-v2-session-relaunch', { sessionName });
+            // The pane is back at its shell, so whatever it held is gone with it.
+            await (0, runtime_1.releaseOpencodeV2Server)(target);
+        }
+        (0, agent_session_lifecycle_1.beginAgentSession)(target);
+        try {
+            if (!exists) {
+                await (0, tmux_1.createSession)({ sessionName, workingDirectory: worktreePath });
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
+            try {
+                await execFileAsync('tmux', [
+                    'resize-window', '-t', (0, tmux_1.exactTarget)(sessionName),
+                    '-x', String(geometry.windowWidth), '-y', String(geometry.windowHeight),
+                ]);
+            }
+            catch {
+                // Non-fatal, as for v1: the TUI still starts at whatever size it gets.
+            }
+            // Port and password first: the launch line is built from both.
+            const port = await (0, runtime_1.reserveOpencodeV2Server)(target, worktreePath);
+            if (port === null) {
+                logger.warn('opencode-v2-launch-without-server', { worktreeId, instanceId });
+            }
+            await (0, tmux_1.sendKeys)(sessionName, (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({ target, executablePath: executable.path, worktreePath }), true);
+            await this.waitForReady(sessionName);
+            await (0, runtime_1.attachOpencodeV2EventStream)(target);
+            logger.info('started-opencode-v2-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to start OpenCode V2 session: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /** Poll until the composer is on screen (or give up quietly). */
+    async waitForReady(sessionName) {
+        for (let attempt = 0; attempt < exports.OPENCODE_V2_READY_MAX_ATTEMPTS; attempt++) {
+            try {
+                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_V2_READY_CAPTURE_LINES));
+                if ((0, cli_patterns_1.isOpencodeV2ComposerVisible)(output)) {
+                    logger.info('opencode-v2-composer-detected', { attempt });
+                    return true;
+                }
+            }
+            catch {
+                // The pane may not be readable yet; keep polling.
+            }
+            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_V2_READY_POLL_INTERVAL_MS));
+        }
+        logger.info('opencode-v2-ready-detection-timeout');
+        return false;
+    }
+    /**
+     * Wait for the composer before typing into it (D6).
+     *
+     * Issue #2971: a dialog open over the composer (model / variant picker,
+     * Commands, Sessions, agents) leaves the footer on screen, so the composer
+     * check alone passes and the text went into the dialog's filter. The send is
+     * refused instead, on the first frame that shows one: the dialog is someone's
+     * choice in progress, so it is neither dismissed (Escape would throw that
+     * choice away) nor waited out (nothing closes it but a person).
+     *
+     * @throws When a dialog is open, or when the composer does not appear within
+     *   {@link OPENCODE_V2_COMPOSER_WAIT_MS}
+     */
+    async waitForComposer(sessionName) {
+        const deadline = Date.now() + cli_tool_timing_config_1.OPENCODE_V2_COMPOSER_WAIT_MS;
+        for (;;) {
+            let dialog = null;
+            try {
+                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_V2_READY_CAPTURE_LINES));
+                dialog = (0, cli_patterns_1.findOpencodeV2DialogTitle)(output);
+                if (dialog === null && (0, cli_patterns_1.isOpencodeV2ComposerVisible)(output))
+                    return;
+            }
+            catch {
+                // Treated as "not yet".
+            }
+            if (dialog !== null) {
+                throw new Error(`OpenCode V2 composer not available: the "${dialog}" dialog is open. ` +
+                    'Close it (esc) or finish the choice, then send again');
+            }
+            if (Date.now() >= deadline)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_V2_READY_POLL_INTERVAL_MS));
+        }
+        throw new Error('OpenCode V2 composer not ready: timed out waiting for it before sending');
+    }
+    async sendMessage(worktreeId, message, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        if (!(await (0, tmux_1.hasSession)(sessionName))) {
+            throw new Error(`OpenCode V2 session ${sessionName} does not exist. Start the session first.`);
+        }
+        await this.relaunchIfToolExited(worktreeId, instanceId);
+        try {
+            await this.waitForComposer(sessionName);
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message: toOpencodeV2ComposerText(message),
+                cliToolId: tool_id_1.OPENCODE_V2_CLI_TOOL_ID,
+                composer: this.describeComposer(),
+            });
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            logger.info('sent-message-to-opencode-v2-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to send message to OpenCode V2: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /**
+     * Stop the TUI and, through the wrapper's trap, its server.
+     *
+     * `/exit` and a separate Enter first (the declared graceful sequence), then
+     * the postcondition: the session gone AND the port no longer answering. If
+     * either fails the session is killed — the SIGHUP reaches the wrapper, whose
+     * trap stops the server. Everything the instance held (subscription, port,
+     * password file) is released at the end.
+     */
+    async killSession(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+        try {
+            if (await (0, tmux_1.hasSession)(sessionName)) {
+                await (0, tmux_1.sendKeys)(sessionName, graceful_exit_1.OPENCODE_V2_EXIT_COMMAND_TEXT, false);
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
+                await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.OPENCODE_V2_EXIT_WAIT_MS));
+                const verdict = await (0, graceful_exit_1.verifyGracefulExit)({
+                    sessionAlive: () => (0, tmux_1.hasSession)(sessionName),
+                    portAnswering: port === null
+                        ? null
+                        : async () => (await (0, client_1.probeOpencodeV2Server)(port, '')).kind !== 'unreachable',
+                });
+                if (!verdict.ok) {
+                    logger.info('opencode-v2-graceful-exit-postcondition-unmet', {
+                        sessionName,
+                        reason: verdict.reason,
+                        ...(port !== null ? { port } : {}),
+                    });
+                    await (0, tmux_1.killSession)(sessionName);
+                }
+            }
+            else {
+                await (0, tmux_1.killSession)(sessionName);
+            }
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            this.resumeAttemptedAt.delete(sessionName);
+            logger.info('stopped-opencode-v2-session');
+        }
+        catch (error) {
+            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            throw error;
+        }
+        finally {
+            await (0, runtime_1.releaseOpencodeV2Server)(target);
+        }
+    }
+}
+exports.OpenCodeV2Tool = OpenCodeV2Tool;

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

@@ -73,6 +73,8 @@ const opencode_session_store_1 = require("../../lib/session/opencode-session-sto
 const graceful_exit_1 = require("./graceful-exit");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const install_hints_1 = require("./install-hints");
+const opencode_executable_1 = require("./opencode-executable");
+const log_diagnosis_1 = require("../../lib/hooks/sources/opencode/log-diagnosis");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /**
@@ -227,6 +229,14 @@ class OpenCodeTool extends base_1.BaseCLITool {
             leaderKey: terminal_keys_1.OPENCODE_LEADER_KEY,
         };
     }
+    /**
+     * Installed means an `opencode` on PATH that reports a 1.x version (Issue
+     * #2939). `which opencode` is not enough: npm `@opencode/cli` registers
+     * `opencode` for OpenCode V2 too. See `./opencode-executable`.
+     */
+    async isInstalled() {
+        return (await (0, opencode_executable_1.resolveOpencodeV1Executable)()).executable !== null;
+    }
     /**
      * Check if OpenCode session is running for a worktree
      */
@@ -242,9 +252,12 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * @param worktreePath - Worktree path
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
-        const opencodeAvailable = await this.isInstalled();
-        if (!opencodeAvailable) {
-            throw (0, install_hints_1.missingToolError)(this);
+        // Issue #2939: one resolution decides both whether to start and what to
+        // run, so the launch line names the very file that answered as 1.x.
+        const resolution = await (0, opencode_executable_1.resolveOpencodeV1Executable)();
+        const executable = resolution.executable;
+        if (!executable) {
+            throw (0, install_hints_1.missingToolError)(this, (0, opencode_executable_1.describeOpencodeV1Unavailable)(resolution));
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
@@ -355,7 +368,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // variable, because CommandMate holds the connection (#1846).
             const plannedCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target,
-                executablePath: this.command,
+                executablePath: executable.path,
                 worktreePath,
             });
             // Issue #2038: continue the conversation this instance was in before it
@@ -379,6 +392,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     sessionId: resumeSessionId,
                 });
             }
+            const launchedAt = Date.now();
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
             // Issue #1908: poll for opencode's own composer instead of sleeping 15 s.
             await this.waitForReady(sessionName);
@@ -393,7 +407,17 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // with the server already listening, which the fixed 15 s wait did not
             // guarantee: the 22.8 s run had nothing to probe at 15 s and would have
             // lost structured events for the whole session.
-            await (0, runtime_1.attachOpencodeEventStream)(target);
+            const attached = await (0, runtime_1.attachOpencodeEventStream)(target);
+            // Issue #2939 (D2): a server that never answered may be OpenCode 1.x
+            // dying on the database OpenCode V2 migrated. opencode's own log says so;
+            // when it does, that is the start error. Otherwise nothing changes.
+            if (!attached && (0, ports_1.getAssignedOpencodePort)(target) !== null) {
+                const conflict = await (0, log_diagnosis_1.findOpencodeSharedDataConflict)(launchedAt);
+                if (conflict !== null) {
+                    logger.warn('opencode-shared-data-conflict', { worktreeId, finding: conflict });
+                    throw new Error((0, log_diagnosis_1.buildOpencodeSharedDataConflictMessage)(conflict));
+                }
+            }
             logger.info('started-opencode-session:sessionname');
         }
         catch (error) {

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

@@ -24,7 +24,7 @@ exports.isImageCapableCLITool = isImageCapableCLITool;
  * T2.1: Single source of truth for CLI tool IDs
  * CLIToolType is derived from this constant (DRY principle)
  */
-exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local', 'opencode', 'copilot', 'antigravity', 'command-code'];
+exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local', 'opencode', 'copilot', 'antigravity', 'command-code', 'opencode-v2'];
 /**
  * CLI tools that render inside the terminal's alternate screen (Issue #1268).
  *
@@ -48,6 +48,9 @@ const ALTERNATE_SCREEN_CLI_TOOLS = new Set([
     // INLINE -- measured on 1.40.1, `#{alternate_on}` is 0 and the pane keeps its
     // scrollback -- so its captured line count really is a monotonic cursor, the
     // way codex's and agy's are.
+    // Issue #2934: OpenCode V2's TUI is the same full-screen toolkit as v1's
+    // (`#{alternate_on}` 1 on 2.0.18, measured 2026-09-28).
+    'opencode-v2',
 ]);
 /**
  * Whether a CLI tool renders in the terminal's alternate screen, making the
@@ -195,6 +198,7 @@ exports.CLI_TOOL_DISPLAY_NAMES = {
     copilot: 'Copilot',
     antigravity: 'Antigravity',
     'command-code': 'Command Code',
+    'opencode-v2': 'OpenCode V2',
 };
 /**
  * Check if a string is a valid CLIToolType

package/dist/server/src/lib/cmate-cli-tool-parser.js

@@ -16,9 +16,12 @@
  * - resolveScheduleCommandOptions(): CMATE.md row -> executor options (Issue #2044)
  * - TOOLS_WITH_MODEL_SUPPORT: Set of tools supporting --model in CMATE.md
  * - TOOLS_WITH_RUN_OPTIONS: Set of tools whose column accepts a flag list
+ * - TOOLS_WITH_VARIANT_ON_MODEL: tools whose variant rides on the model (Issue #2982)
+ * - validateVariantHasModel(): refuse a model-less variant for those tools (Issue #2982)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_COLUMN_SYNTAX = exports.TOOLS_WITH_RUN_OPTIONS = exports.TOOLS_WITH_MODEL_SUPPORT = void 0;
+exports.OPENCODE_V2_COLUMN_SYNTAX = exports.OPENCODE_COLUMN_SYNTAX = exports.TOOLS_WITH_VARIANT_ON_MODEL = exports.TOOLS_WITH_RUN_OPTIONS = exports.TOOLS_WITH_MODEL_SUPPORT = void 0;
+exports.validateVariantHasModel = validateVariantHasModel;
 exports.tokenizeCliToolColumn = tokenizeCliToolColumn;
 exports.parseCliToolColumn = parseCliToolColumn;
 exports.validateCopilotModelName = validateCopilotModelName;
@@ -57,8 +60,14 @@ const opencode_constants_1 = require("../config/opencode-constants");
  * format `opencode run --help` documents for `-m, --model` (measured on
  * opencode 1.18.21). It is not prefixed with `ollama/` — see
  * `buildCliArgs()` for why that prefix went away.
+ *
+ * ## `opencode-v2` (Issue #2982)
+ *
+ * `opencode2 run -m` takes the same `provider/model` value (plus an optional
+ * `#variant`, see {@link TOOLS_WITH_VARIANT_ON_MODEL}), and the executor's
+ * `opencode-v2` case has built `-m` since #2974.
  */
-exports.TOOLS_WITH_MODEL_SUPPORT = new Set(['copilot', 'opencode']);
+exports.TOOLS_WITH_MODEL_SUPPORT = new Set(['copilot', 'opencode', 'opencode-v2']);
 /**
  * CLI Tools whose CMATE.md column is a **flag list** rather than one fixed shape
  * (Issue #2044).
@@ -73,8 +82,28 @@ exports.TOOLS_WITH_MODEL_SUPPORT = new Set(['copilot', 'opencode']);
  * CommandMate can drive (`--agent`, `--variant`, `-c`, `--title`), and a
  * schedule that wants `--agent plan --variant high` cannot say so in three
  * tokens. Membership here is what {@link parseCliToolColumn} branches on.
+ *
+ * Issue #2982: `opencode-v2` joins with the same five column flags. Its
+ * `opencode2 run` has `-m`, `--agent`, `-c` and `--title` with v1's meaning;
+ * `--variant` is the one difference, see {@link TOOLS_WITH_VARIANT_ON_MODEL}.
  */
-exports.TOOLS_WITH_RUN_OPTIONS = new Set(['opencode']);
+exports.TOOLS_WITH_RUN_OPTIONS = new Set(['opencode', 'opencode-v2']);
+/**
+ * Tools whose CLI has no `--variant` flag and takes the variant as a suffix of
+ * the model instead: `-m provider/model#variant` (Issue #2982).
+ *
+ * `opencode2 run` (2.0.18, measured in #2974) answers `--variant` with
+ * "Unrecognized flag" and exit 1. The column still spells the variant as
+ * `--variant <name>` — the same grammar, dialog field and writer order as v1 —
+ * and `claude-executor.ts` composes `model#variant`. Two consequences are
+ * enforced by {@link validateVariantHasModel}:
+ *
+ * - a variant **without a model** has nothing to ride on, and is an error
+ *   rather than a silently dropped option;
+ * - `#` in the model itself is not a way around it: `MODEL_NAME_PATTERN`
+ *   already refuses `#`, so `--model x#high` is rejected as an invalid model.
+ */
+exports.TOOLS_WITH_VARIANT_ON_MODEL = new Set(['opencode-v2']);
 /**
  * The opencode column grammar, as one line, for error messages.
  *
@@ -82,6 +111,28 @@ exports.TOOLS_WITH_RUN_OPTIONS = new Set(['opencode']);
  * the flags the loop accepts are edited together.
  */
 exports.OPENCODE_COLUMN_SYNTAX = 'opencode [--model <provider/model>] [--agent <name>] [--variant <name>] [--continue] [--title <text>]';
+/**
+ * The opencode-v2 column grammar, as one line, for error messages (Issue #2982).
+ *
+ * Same flags as {@link OPENCODE_COLUMN_SYNTAX}; `--variant` is nested inside
+ * the `--model` bracket because it is only valid alongside a model.
+ */
+exports.OPENCODE_V2_COLUMN_SYNTAX = 'opencode-v2 [--model <provider/model> [--variant <name>]] [--agent <name>] [--continue] [--title <text>]';
+/**
+ * Error for a variant given without a model, for the tools in
+ * {@link TOOLS_WITH_VARIANT_ON_MODEL} (Issue #2982). Shared by the column
+ * parser and `cmate-writer.validateScheduleInput()` so the file and the
+ * form refuse the same row with the same words.
+ *
+ * @returns The error message, or undefined when the combination is fine
+ */
+function validateVariantHasModel(cliToolId, model, variant) {
+    if (!exports.TOOLS_WITH_VARIANT_ON_MODEL.has(cliToolId))
+        return undefined;
+    if (!variant?.trim() || model?.trim())
+        return undefined;
+    return `${cliToolId} option "--variant" needs "--model" (sent as -m <provider/model>#<variant>)`;
+}
 // =============================================================================
 // Parse Functions
 // =============================================================================
@@ -154,7 +205,8 @@ function tokenizeCliToolColumn(raw) {
  * - **a missing value** — `--agent --title x` would make `--title` the agent
  *   name, and a value starting with `-` is the DR4-001 injection shape anyway.
  *
- * @param cliToolId - Always `opencode` today; echoed into error messages
+ * @param cliToolId - `opencode` or `opencode-v2` (Issue #2982); echoed into
+ *   error messages and picks the syntax hint
  * @param tokens - Tokens after the tool id
  * @returns The parsed options, or an error
  */
@@ -218,10 +270,15 @@ function parseOpencodeRunFlags(cliToolId, tokens) {
                 parsed.continueSession = true;
                 break;
             }
-            default:
-                return { cliToolId, error: `${cliToolId} only supports: ${exports.OPENCODE_COLUMN_SYNTAX}` };
+            default: {
+                const syntax = cliToolId === 'opencode-v2' ? exports.OPENCODE_V2_COLUMN_SYNTAX : exports.OPENCODE_COLUMN_SYNTAX;
+                return { cliToolId, error: `${cliToolId} only supports: ${syntax}` };
+            }
         }
     }
+    const variantError = validateVariantHasModel(cliToolId, parsed.model, parsed.variant);
+    if (variantError)
+        return { cliToolId, error: variantError };
     return parsed;
 }
 /**
@@ -508,7 +565,8 @@ function parseAndValidateCliToolColumn(raw) {
  * {@link TOOLS_WITH_MODEL_SUPPORT} for the model, exactly as that line did, so
  * the two agree about which tools take one; the run options are additionally
  * gated on {@link TOOLS_WITH_RUN_OPTIONS} so a future tool cannot inherit
- * opencode's flags by accident.
+ * opencode's flags by accident. For `opencode-v2` (Issue #2982) the variant is
+ * passed on as-is; the executor folds it into `-m model#variant`.
  *
  * Living here rather than in `job-executor.ts` is the point: the column's
  * grammar is this module's business, and a scheduler that re-states any part of

package/dist/server/src/lib/cmate-parser.js

@@ -206,6 +206,12 @@ function parseSchedulesSection(rows) {
             logger.warn('parse:invalid-cli-tool', { name: sanitizedName, cliToolId: resolvedCliToolId });
             continue;
         }
+        // Issue #2934: registered but not schedulable (SCHEDULE_UNSUPPORTED_CLI_TOOLS,
+        // empty since #2974). Skipped like an unknown tool, so no run is built for it.
+        if (!(0, schedule_config_1.isScheduleSupportedCliTool)(resolvedCliToolId)) {
+            logger.warn('parse:unsupported-cli-tool', { name: sanitizedName, cliToolId: resolvedCliToolId });
+            continue;
+        }
         const defaultPermission = schedule_config_1.DEFAULT_PERMISSIONS[resolvedCliToolId] ?? '';
         let permission = permissionStr?.trim() || defaultPermission;
         // Validate permission against allowed values
@@ -237,6 +243,12 @@ function parseSchedulesSection(rows) {
             case 'command-code':
                 allowedValues = schedule_config_1.COMMAND_CODE_SCHEDULE_PERMISSIONS;
                 break;
+            // Issue #2974: `default` (no flag) / `auto` (`--auto`). An empty cell
+            // resolves to `default`, so an `ask` rule fails the run rather than being
+            // approved unattended.
+            case 'opencode-v2':
+                allowedValues = schedule_config_1.OPENCODE_V2_PERMISSIONS;
+                break;
             case 'gemini':
             case 'vibe-local':
             case 'opencode':

package/dist/server/src/lib/cmate-validator.js

@@ -225,6 +225,16 @@ function validateSchedulesSection(rows) {
                 field: 'cliTool',
             });
         }
+        // Issue #2934: a registered tool that cannot be scheduled
+        // (SCHEDULE_UNSUPPORTED_CLI_TOOLS, empty since #2974). The parser skips the
+        // same rows.
+        if (parsed && (0, types_1.isCliToolType)(parsed.cliToolId) && !(0, schedule_config_1.isScheduleSupportedCliTool)(parsed.cliToolId)) {
+            errors.push({
+                row: i,
+                message: `Row ${i + 1}: CLI Tool "${parsed.cliToolId}" is not supported in schedules yet`,
+                field: 'cliTool',
+            });
+        }
         // Validate permission (6th column)
         // Empty/missing permission is allowed -- parser applies default per CLI tool
         const permissionStr = row[5];
@@ -245,7 +255,9 @@ function validateSchedulesSection(rows) {
                     : cliToolId === 'copilot' ? schedule_config_1.COPILOT_PERMISSIONS
                         : cliToolId === 'antigravity' ? schedule_config_1.ANTIGRAVITY_PERMISSIONS
                             : cliToolId === 'command-code' ? schedule_config_1.COMMAND_CODE_SCHEDULE_PERMISSIONS
-                                : [];
+                                // Issue #2974: `default` / `auto`, the parser's and the dialog's list.
+                                : cliToolId === 'opencode-v2' ? schedule_config_1.OPENCODE_V2_PERMISSIONS
+                                    : [];
             if (!allowedValues.includes(trimmedPermission)) {
                 errors.push({
                     row: i,