commandmate 0.30.2 → 0.31.0

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

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * Command Code CLI tool implementation (Issue #2250, Epic #2249 Phase A).
+ *
+ * Integration with the Command Code CLI (`commandcode`, measured against
+ * v1.40.1). Command Code renders an INLINE TUI — `#{alternate_on}` is 0 and the
+ * pane keeps its scrollback, like codex and agy, unlike claude v2 / opencode /
+ * copilot — with a claude-shaped bottom-pinned composer:
+ *
+ * ```text
+ * ❯ <echoed prompt>
+ * ✻ Thought for 1 second [ctrl+o to expand]
+ * ⠶ <reply>
+ *  ✻ Worked for 2s
+ * ────────────────────────  ← rule
+ * ❯ Ask your question...    ← composer
+ * ────────────────────────  ← rule
+ *   ? for shortcuts · taste on
+ * ```
+ *
+ * ## The executable is `commandcode`, not `cmd`
+ *
+ * The package ships four bins — `cmd`, `cmdc`, `command-code`, `commandcode`.
+ * `cmd` collides with Windows' shell and reads as CommandMate's own name in a
+ * log line, so the unambiguous spelling is the one CommandMate launches
+ * (Epic #2249 決定 1).
+ *
+ * ## The launch line lives in one place
+ *
+ * {@link buildCommandCodeLaunchCommand} is the only thing that renders it, and
+ * since Phase B (#2251) its body is `buildAgentLaunchCommandLine` — so the line
+ * carries `CM_HOOK_URL` and the worktree's `.commandcode/settings.local.json`
+ * has been written by the time the pane sees it. The flags stay here rather than
+ * moving into the source, because which flags Command Code is launched with is
+ * this module's decision (Epic #2249 決定 2) and the hook source's business is
+ * 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.buildCommandCodeLaunchCommand = buildCommandCodeLaunchCommand;
+exports.isCommandCodeReady = isCommandCodeReady;
+const base_1 = require("./base");
+const terminal_keys_1 = require("../../types/terminal-keys");
+const tmux_1 = require("../tmux/tmux");
+const submit_verified_sender_1 = require("./submit-verified-sender");
+const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const errors_1 = require("../../lib/errors");
+const logger_1 = require("../../lib/logger");
+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 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';
+/**
+ * Launch flags, in the order Epic #2249 決定 2 fixed them.
+ *
+ * - `--trust` skips the first-run "do you trust this folder?" confirmation, so a
+ *   worktree CommandMate just created does not park the session on a dialog no
+ *   one is watching.
+ * - `--skip-onboarding` skips the taste-onboarding walkthrough, which is the
+ *   same class of unattended-launch blocker (#2131's `wait` sat on claude's
+ *   onboarding dialog for three hours).
+ * - `--no-auto-update` because a background self-update restarts the agent, and
+ *   a restart is what killed Auto-Yes the last time an agent did it.
+ */
+exports.COMMAND_CODE_LAUNCH_FLAGS = [
+    '--trust',
+    '--skip-onboarding',
+    '--no-auto-update',
+];
+/** `/exit` — Command Code's own quit command. */
+exports.COMMAND_CODE_EXIT_COMMAND = '/exit';
+/**
+ * Render the shell line that starts Command Code in a pane (Issue #2251).
+ *
+ * Two things happen here, in this order, and the order is the point:
+ *
+ *  1. `buildAgentLaunchCommandLine` asks the tool's own {@link AgentEventSource}
+ *     to write `<worktree>/.commandcode/settings.local.json` and to declare the
+ *     environment the hooks need, then renders `CM_HOOK_URL='…' 'commandcode'`.
+ *     Going through the shared helper rather than through
+ *     `prepareAgentLaunch(...).command` is what keeps `env` from being silently
+ *     dropped (#1846): the plan's environment is *data*, and this is the one
+ *     function that turns it into shell assignments.
+ *  2. {@link COMMAND_CODE_LAUNCH_FLAGS} are appended **after** the rendered
+ *     line, the shape `AntigravityTool` uses for `--model`. Appending keeps the
+ *     assignments in front of the executable by construction instead of by the
+ *     caller remembering to put them there.
+ *
+ * With `CM_AGENT_HOOKS_INJECT=0` the source returns the bare executable and an
+ * empty environment, so this renders the byte-identical Phase A line
+ * `commandcode --trust --skip-onboarding --no-auto-update`.
+ *
+ * @param context - The instance being started, its executable, and its worktree
+ * @returns The command line to type at the pane's shell prompt
+ */
+function buildCommandCodeLaunchCommand(context) {
+    return [(0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)(context), ...exports.COMMAND_CODE_LAUNCH_FLAGS].join(' ');
+}
+/** Interval for polling composer readiness. */
+const COMMAND_CODE_POLL_INTERVAL_MS = 1000;
+/** Max attempts for initialization polling (30 * 1000ms = 30s window). */
+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;
+/** Rows of pane tail the readiness probe reads. */
+const COMMAND_CODE_READINESS_CAPTURE_LINES = 50;
+/**
+ * Whether Command Code is sitting at a live, empty-of-work composer.
+ *
+ * Structural rather than textual, for the reason
+ * {@link findCommandCodeChromeStart} spells out: the composer block is drawn
+ * only when the agent is accepting input. While a permission dialog is up the
+ * whole block is replaced by the dialog (`dialog-create-file.txt` has one rule
+ * and no composer), and while a turn runs the status row sits above the block —
+ * hence the second condition.
+ *
+ * The footer's `? for shortcuts` is deliberately NOT the signal: it is only the
+ * DEFAULT permission mode's spelling of that row (see
+ * `COMMAND_CODE_MODE_INDICATOR_PATTERN`), so a session started in plan or
+ * auto-accept mode would never look ready.
+ *
+ * @param rawOutput - A captured pane, ANSI intact
+ * @returns True when the composer is on screen and no turn is in flight
+ */
+function isCommandCodeReady(rawOutput) {
+    const lines = rawOutput.split('\n');
+    const chromeStart = (0, cli_patterns_1.findCommandCodeChromeStart)(lines);
+    if (chromeStart < 0)
+        return false;
+    return !cli_patterns_1.COMMAND_CODE_THINKING_PATTERN.test((0, cli_patterns_1.stripAnsi)(rawOutput));
+}
+/**
+ * Command Code CLI tool implementation.
+ * Manages `commandcode` sessions using tmux.
+ */
+class CommandCodeTool extends base_1.BaseCLITool {
+    id = 'command-code';
+    name = 'Command Code CLI';
+    command = exports.COMMAND_CODE_COMMAND;
+    /**
+     * Declare the claude-family pad (Issue #2297).
+     *
+     * Command Code renders claude's inline overlay TUI, so it takes the same
+     * declaration rather than a copy of the base list — see
+     * {@link CLAUDE_NAVIGATION_KEY_VALUES}.
+     *
+     * **Its own `/model` picker does NOT use `s`.** Measured on v1.40.1 at
+     * 200x1000 for this Issue: a provider-grouped list of model NAMES with no
+     * option numbers, a `› Type to search models...` filter row, and the footer
+     * `type to search · ↑/↓ navigate · shift+↑/↓ jump provider · enter to select ·
+     * esc to cancel`. Nothing on it offers a session scope, so the chat surface
+     * draws no `s` button there: the button is gated on the footer being on
+     * screen (`readSelectionListShape`), not on the tool id. The key is declared
+     * anyway so the two halves of the claude family cannot drift apart, and
+     * declaring a key nobody draws sends nothing.
+     */
+    navigationKeys() {
+        return { keys: terminal_keys_1.CLAUDE_NAVIGATION_KEY_VALUES, leaderKey: null };
+    }
+    /**
+     * Check if a Command Code session is running for a worktree.
+     *
+     * @param worktreeId - Worktree ID
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     * @returns True if session is running
+     */
+    async isRunning(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        return await (0, tmux_1.hasSession)(sessionName);
+    }
+    /**
+     * Start a new Command Code session for a worktree.
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     */
+    async launchSession(worktreeId, worktreePath, instanceId) {
+        const available = await this.isInstalled();
+        if (!available) {
+            throw (0, install_hints_1.missingToolError)(this);
+        }
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            await this.reconcileExistingSession(sessionName);
+            // Issue #2070's shape: a tmux session outlives the agent that was launched
+            // into it, and skipping the launch for a pane holding nothing but a shell
+            // prompt leaves `kill-session` by hand as the only recovery.
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                logger.info('command-code-session-exists');
+                return;
+            }
+            logger.warn('command-code-session-relaunch', { sessionName });
+        }
+        // Issue #2251, seam S8: fence this instance's structured events off from the
+        // process that used to hold the same (worktree, tool, instance) key. On the
+        // creation path and on #2070's relaunch path — the reuse branch above has
+        // already returned — and before the pane exists, so there is no window in
+        // which a live pane is judged against a stale generation. Bumped even if the
+        // 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 });
+        try {
+            if (!exists) {
+                // Inline-rendered, so the pane keeps scrollback; depth comes from the
+                // shared TMUX_HISTORY_LIMIT default (Issue #1624).
+                await (0, tmux_1.createSession)({
+                    sessionName,
+                    workingDirectory: worktreePath,
+                });
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
+            await (0, tmux_1.sendKeys)(sessionName, buildCommandCodeLaunchCommand({
+                target: { worktreeId, cliToolId: tool_id_1.COMMAND_CODE_CLI_TOOL_ID, instanceId },
+                executablePath: this.command,
+                worktreePath,
+            }), true);
+            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.COMMAND_CODE_INIT_WAIT_MS));
+            await this.waitForReady(sessionName);
+            logger.info('started-command-code-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to start Command Code session: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /**
+     * Poll until the composer block is drawn.
+     *
+     * No dialog is answered here: `--trust` and `--skip-onboarding` are what
+     * remove the two startup dialogs Command Code has, so a launch that still
+     * parks on one is a launch whose flags did not take effect — and blind-firing
+     * Enter at an unmeasured dialog is how #1928 describes an Auto-Yes accident.
+     * A timeout logs and returns; the send path's own wait is what refuses.
+     */
+    async waitForReady(sessionName) {
+        for (let i = 0; i < COMMAND_CODE_INIT_MAX_ATTEMPTS; i++) {
+            try {
+                const rawOutput = await (0, tmux_1.capturePane)(sessionName, COMMAND_CODE_READINESS_CAPTURE_LINES);
+                if (isCommandCodeReady(rawOutput)) {
+                    logger.info('command-code-prompt-detected');
+                    return;
+                }
+            }
+            catch {
+                // Capture may fail during initialization - continue polling
+            }
+            await new Promise((resolve) => setTimeout(resolve, COMMAND_CODE_POLL_INTERVAL_MS));
+        }
+        logger.info('command-code-prompt-detection-timeout');
+    }
+    /**
+     * Wait for the composer before sending a message.
+     * Mirrors CodexTool.waitForPrompt: throws on timeout so a failed readiness
+     * check STOPS the send rather than typing into a non-ready TUI.
+     *
+     * @throws Error when the composer is not detected within the timeout
+     */
+    async waitForPrompt(sessionName) {
+        const startTime = Date.now();
+        const pollInterval = 500;
+        while (Date.now() - startTime < COMMAND_CODE_PROMPT_WAIT_TIMEOUT_MS) {
+            try {
+                const rawOutput = await (0, tmux_1.capturePane)(sessionName, COMMAND_CODE_READINESS_CAPTURE_LINES);
+                if (isCommandCodeReady(rawOutput)) {
+                    return;
+                }
+            }
+            catch {
+                // Capture may fail - continue polling
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        logger.info('command-code-prompt-not-ready');
+        throw new Error('Command Code prompt not ready: timed out waiting for the composer before sending');
+    }
+    /**
+     * Send a message to the Command Code session.
+     *
+     * @param worktreeId - Worktree ID
+     * @param message - Message to send
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     */
+    async sendMessage(worktreeId, message, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (!exists) {
+            throw new Error(`Command Code session ${sessionName} does not exist. Start the session first.`);
+        }
+        // Issue #2070: the pane exists, but does the AGENT? Relaunches into the same
+        // pane when the tool is gone; costs one `capture-pane` when it is not.
+        await this.relaunchIfToolExited(worktreeId, instanceId);
+        try {
+            await this.waitForPrompt(sessionName);
+            // Issue #1471: body/Enter separation + read-back submit verification.
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'command-code',
+                composer: this.describeComposer(),
+            });
+            // Required so the poller re-reads instead of answering from the 5s cache.
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            logger.info('sent-message-to-command-code-session');
+        }
+        catch (error) {
+            throw new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`);
+        }
+    }
+    /**
+     * Kill the Command Code session.
+     *
+     * `/exit` typed and submitted as SEPARATE tmux commands, the shape #1905
+     * settled on for opencode: `/` opens Command Code's slash-command menu, and a
+     * `C-m` arriving inside the same `send-keys` is consumed by that menu rather
+     * than by the composer. Measured on 1.40.1 — the separated form exits the
+     * agent and drops the pane back to its shell.
+     *
+     * @param worktreeId - Worktree ID
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     */
+    async killSession(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        try {
+            const exists = await (0, tmux_1.hasSession)(sessionName);
+            if (exists) {
+                await (0, tmux_1.sendKeys)(sessionName, exports.COMMAND_CODE_EXIT_COMMAND, 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.TUI_EXIT_WAIT_MS));
+            }
+            const killed = await (0, tmux_1.killSession)(sessionName);
+            // So a later session reusing the name starts clean.
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            if (killed) {
+                logger.info('stopped-command-code-session');
+            }
+        }
+        catch (error) {
+            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            throw error;
+        }
+    }
+}
+exports.CommandCodeTool = CommandCodeTool;

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

@@ -65,6 +65,12 @@ const COMPOSER_SPECS = {
     gemini: { ...exports.DEFAULT_COMPOSER_SPEC, clearBeforeSend: false },
     copilot: { ...exports.DEFAULT_COMPOSER_SPEC, clearBeforeSend: false },
     antigravity: { ...exports.DEFAULT_COMPOSER_SPEC, clearBeforeSend: false },
+    // Issue #2250. `input-line-marker` is right: Command Code draws a `❯` composer
+    // at the bottom of the pane, the shape the reader looks for. `clearBeforeSend`
+    // stays false because #1880's `C-e`+`C-u` was measured on claude's box and
+    // nobody has measured Command Code's -- the same reason gemini, copilot and
+    // agy carry the flag off.
+    'command-code': { ...exports.DEFAULT_COMPOSER_SPEC, clearBeforeSend: false },
     // vibe-local's IME mode makes the first Enter insert a newline, so the
     // initial submit is two presses (see VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS).
     'vibe-local': { ...exports.DEFAULT_COMPOSER_SPEC, clearBeforeSend: false, submitEnterCount: 2 },

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

@@ -31,7 +31,7 @@ const hook_settings_1 = require("../../lib/hooks/sources/copilot/hook-settings")
 const tool_id_1 = require("../../lib/hooks/sources/copilot/tool-id");
 const errors_1 = require("../../lib/errors");
 const logger_1 = require("../../lib/logger");
-const session_start_error_1 = require("../session/session-start-error");
+const install_hints_1 = require("./install-hints");
 const logger = (0, logger_1.createLogger)('cli-tools/copilot');
 /** Interval for polling prompt detection */
 const COPILOT_POLL_INTERVAL_MS = 1000;
@@ -168,7 +168,7 @@ class CopilotTool extends base_1.BaseCLITool {
         // no copilot: the answer and the action have to come from one measurement.
         const resolved = await (0, copilot_executable_1.resolveCopilotExecutable)();
         if (!resolved) {
-            throw new session_start_error_1.SessionStartUnavailableError(this.name, `GitHub Copilot CLI is not installed. ${copilot_constants_1.COPILOT_INSTALL_HINT}`);
+            throw (0, install_hints_1.missingToolError)(this);
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists

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

@@ -21,7 +21,7 @@ const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const logger_1 = require("../../lib/logger");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
-const session_start_error_1 = require("../session/session-start-error");
+const install_hints_1 = require("./install-hints");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
 /**
  * Extract error message from unknown error type (DRY)
@@ -66,7 +66,7 @@ class GeminiTool extends base_1.BaseCLITool {
         // Check if Gemini is installed
         const geminiAvailable = await this.isInstalled();
         if (!geminiAvailable) {
-            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'Gemini CLI is not installed or not in PATH');
+            throw (0, install_hints_1.missingToolError)(this);
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists

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.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_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';
+/** Command Code's own quit command (Issue #2250). */
+exports.COMMAND_CODE_EXIT_COMMAND_TEXT = '/exit';
 /** The graceful exit command gemini's TUI accepts. */
 exports.GEMINI_EXIT_COMMAND_TEXT = '/quit';
 /**
@@ -114,6 +116,19 @@ const GRACEFUL_EXIT_SPECS = {
         exitWaitMs: cli_tool_timing_config_1.COPILOT_EXIT_WAIT_MS,
         ownsLoopbackServer: false,
     },
+    // `/exit` typed and submitted separately, the same shape as opencode's below
+    // and for the same measured reason: `/` opens Command Code's slash-command
+    // menu, so an Enter batched into the same `send-keys` is the menu's, not the
+    // composer's. The separated form exits 1.40.1 and returns the pane to its
+    // shell (Issue #2250).
+    'command-code': {
+        keys: [
+            (0, cli_tool_contracts_1.literalStep)(exports.COMMAND_CODE_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.TUI_EXIT_WAIT_MS,
+        ownsLoopbackServer: false,
+    },
     // `/exit` typed and submitted separately, because the batched form does not
     // exit at all: typing `/` opens the command palette and the `C-m` arriving in
     // the same tmux command is consumed by it, leaving `/exit` in the composer

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.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.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");
@@ -31,6 +31,9 @@ var gemini_1 = require("./gemini");
 Object.defineProperty(exports, "GeminiTool", { enumerable: true, get: function () { return gemini_1.GeminiTool; } });
 var antigravity_1 = require("./antigravity");
 Object.defineProperty(exports, "AntigravityTool", { enumerable: true, get: function () { return antigravity_1.AntigravityTool; } });
+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; } });
 // 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

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * How to obtain each agent CLI CommandMate can drive (Issue #2301).
+ *
+ * ## Why this exists
+ *
+ * Every one of the eight tools already refuses to start when its binary is not
+ * on `PATH` — that gate is #2009's, and it is uniform. What was NOT uniform was
+ * what the refusal said. Seven of them said some spelling of
+ * `<tool> is not installed or not in PATH` and stopped there; only copilot went
+ * on to name the installer (`COPILOT_INSTALL_HINT`, #1907). So a reader who
+ * picked opencode or Command Code from the agent list got a sentence that told
+ * them the tool was missing and nothing about how to stop it being missing,
+ * while the reader who picked copilot got both. This module is the second half
+ * of that sentence, written once for all eight.
+ *
+ * ## Where the strings come from
+ *
+ * Measured against the npm registry and this machine's global install on
+ * 2026-09-05, not copied from an Issue body:
+ *
+ * | tool          | binary        | evidence                                    |
+ * |---------------|---------------|---------------------------------------------|
+ * | claude        | `claude`      | `@anthropic-ai/claude-code` 2.1.261          |
+ * | codex         | `codex`       | `@openai/codex` — the package #2069 updates  |
+ * | gemini        | `gemini`      | `@google/gemini-cli` 0.58.0                  |
+ * | opencode      | `opencode`    | `opencode-ai` 1.18.28                        |
+ * | copilot       | `copilot`     | {@link COPILOT_INSTALL_HINT} (#1907)         |
+ * | command-code  | `commandcode` | `command-code` 1.49.0 (four bins; #2250      |
+ * |               |               | picked `commandcode`)                        |
+ * | antigravity   | `agy`         | no package — the URL below is a string in    |
+ * |               |               | the shipped `agy` binary itself              |
+ * | vibe-local    | `vibe-local`  | a local script, not a published artifact     |
+ *
+ * `@anthropic-ai/claude-cli` — the name `PreflightChecker.getInstallHint` still
+ * carries — is **not** a package that exists; `npm view` 404s it. The spelling
+ * here is the one that resolves.
+ *
+ * ## Why not `CLI_TOOL_DISPLAY_NAMES`' neighbour in `types.ts`
+ *
+ * A hint is advice about the world outside this repository, and it goes stale
+ * on someone else's release schedule. Keeping it out of `types.ts` keeps the
+ * module that every consumer of `CLIToolType` imports free of a table that has
+ * to be re-measured, and gives the re-measurement one file to land in.
+ *
+ * ## The one path this does not reach yet
+ *
+ * Seven tools ask `isInstalled()` inside their own `launchSession` and throw
+ * from there, so pointing that line at {@link missingToolError} is all it takes.
+ * claude does not: `ClaudeTool.launchSession` delegates to
+ * `lib/session/claude-session`, which owns the detection AND composes the
+ * sentence (`Claude CLI is not installed or not in PATH`, #1637). Enriching it
+ * means editing that module, and `tests/integration/api-send-cli-tool.test.ts`
+ * pins the sentence verbatim — both outside the scope this change was allowed to
+ * touch, so claude's tmux-launch wording is unchanged here.
+ *
+ * claude is NOT hintless, though: `assertToolStartable` and
+ * `reportToolUnavailable` (`./start-availability`) both build their refusal from
+ * this module, so the path Assistant Chat takes already carries the hint. What
+ * remains is one line in `claude-session.ts` plus the assertion that pins it.
+ *
+ * @module lib/cli-tools/install-hints
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_TOOL_INSTALL_HINTS = void 0;
+exports.getCliToolInstallHint = getCliToolInstallHint;
+exports.buildMissingToolMessage = buildMissingToolMessage;
+exports.missingToolError = missingToolError;
+const copilot_constants_1 = require("../../config/copilot-constants");
+const session_start_error_1 = require("../session/session-start-error");
+/**
+ * One sentence per tool, saying how to get it.
+ *
+ * Total rather than partial (`Record`, not `Partial<Record>`), so adding a
+ * ninth entry to `CLI_TOOL_IDS` fails `tsc` here instead of shipping a tool
+ * whose refusal says nothing — the shape #2009 used to make the gate itself
+ * impossible to forget.
+ */
+exports.CLI_TOOL_INSTALL_HINTS = {
+    claude: 'Install with: npm install -g @anthropic-ai/claude-code',
+    codex: 'Install with: npm install -g @openai/codex',
+    gemini: 'Install with: npm install -g @google/gemini-cli',
+    opencode: 'Install with: npm install -g opencode-ai',
+    copilot: copilot_constants_1.COPILOT_INSTALL_HINT,
+    'command-code': 'Install with: npm install -g command-code',
+    // 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',
+    // Deliberately not an install command. `vibe-local` is a local shell script
+    // driving an Ollama model, which is also why `version-probes.ts` excludes it
+    // from staleness probing — there is no published artifact to point at.
+    'vibe-local': 'vibe-local is a local script rather than a published package: put your own `vibe-local` executable on PATH.',
+};
+/**
+ * How to obtain `id`.
+ *
+ * @param id - The tool whose binary is missing
+ * @returns The tool's install sentence
+ */
+function getCliToolInstallHint(id) {
+    return exports.CLI_TOOL_INSTALL_HINTS[id];
+}
+/**
+ * The whole sentence a missing binary earns: what is missing, what it is
+ * called on `PATH`, and how to get it.
+ *
+ * The binary name is inside the message because the display name is often not
+ * the thing to type — `Command Code CLI` is `commandcode`, `Antigravity CLI` is
+ * `agy` — and the two tools whose old wording already spelled it out were the
+ * two whose names diverge most.
+ *
+ * `is not installed` is load-bearing: `lib/push/failure-push-notifier` renders
+ * its own localized body, but the HTTP layer and three suites read this string,
+ * and #2009's contract is that the phrase survives.
+ *
+ * @param tool - The tool that could not be started
+ * @returns A sentence safe to hand back to an HTTP caller
+ */
+function buildMissingToolMessage(tool) {
+    return (`${tool.name} (${tool.command}) is not installed or not in PATH. ` +
+        `${getCliToolInstallHint(tool.id)}`);
+}
+/**
+ * The typed refusal, carrying {@link buildMissingToolMessage}.
+ *
+ * @param tool - The tool that could not be started
+ * @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));
+}

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

@@ -193,6 +193,24 @@ const LIVENESS_SPECS = {
             cli_patterns_1.ANTIGRAVITY_THINKING_PATTERN,
         ],
     },
+    /**
+     * Command Code 1.40.1 — measured live at 200x1000 (Issue #2250).
+     *
+     * The composer glyph, the footer's mode indicator and the status row. The
+     * footer is included as well as the composer because the two are drawn in the
+     * same block and a frame carrying either one is a frame Command Code owns;
+     * neither can be matched by a shell prompt, which is the only property this
+     * list has to keep.
+     */
+    'command-code': {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [
+            cli_patterns_1.COMMAND_CODE_PROMPT_PATTERN,
+            cli_patterns_1.COMMAND_CODE_MODE_INDICATOR_PATTERN,
+            cli_patterns_1.COMMAND_CODE_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

@@ -45,6 +45,7 @@ const vibe_local_1 = require("./vibe-local");
 const opencode_1 = require("./opencode");
 const copilot_1 = require("./copilot");
 const antigravity_1 = require("./antigravity");
+const command_code_1 = require("./command-code");
 /**
  * CLI Tool Manager (Singleton)
  * Provides centralized access to all CLI tools (Issue #368: includes Vibe Local, Issue #379: includes OpenCode)
@@ -65,6 +66,7 @@ class CLIToolManager {
         this.tools.set('opencode', new opencode_1.OpenCodeTool());
         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());
     }
     /**
      * Get singleton instance

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

@@ -72,7 +72,7 @@ const opencode_session_recall_1 = require("../../lib/session/opencode-session-re
 const opencode_session_store_1 = require("../../lib/session/opencode-session-store");
 const graceful_exit_1 = require("./graceful-exit");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
-const session_start_error_1 = require("../session/session-start-error");
+const install_hints_1 = require("./install-hints");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /**
@@ -244,7 +244,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
     async launchSession(worktreeId, worktreePath, instanceId) {
         const opencodeAvailable = await this.isInstalled();
         if (!opencodeAvailable) {
-            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'OpenCode is not installed or not in PATH');
+            throw (0, install_hints_1.missingToolError)(this);
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);