commandmate 0.30.1 → 0.31.0

package/dist/server/src/lib/polling/response-checker.js

@@ -28,6 +28,12 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const prompt_dedup_state_1 = require("./prompt-dedup-state");
 const response_dedup_1 = require("./response-dedup");
 const structured_history_gate_1 = require("./structured-history-gate");
+// Issue #2317 Phase D: while a human holds the pane's geometry, the frame is
+// their terminal (44 rows), not the 1000-row canvas every rule below was
+// measured against. See the block in `checkForResponse` for what that changes.
+const session_name_1 = require("../../lib/cli-tools/session-name");
+const geometry_delegation_1 = require("../../lib/tmux/geometry-delegation");
+const tmux_session_surface_1 = require("../../lib/session/tmux-session-surface");
 const response_poller_core_1 = require("./response-poller-core");
 const push_1 = require("../../lib/push");
 // Issue #1790: imported by deep path, not through `@/lib/push`. Suites that
@@ -246,13 +252,21 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
     // silently delete another tool's boundary, and a boundary that stops existing
     // does not fail loudly: it puts terminal furniture back into History.
     const openCodeCleanLines = cliToolId === 'opencode' ? lines.map(cli_patterns_1.stripAnsi) : null;
+    // Issue #2250: Command Code is the fourth. Its landmark is its own — the
+    // `❯ Ask your question...` composer fenced by two full-pane rules, with the
+    // permission-mode row underneath — and it is load-bearing rather than tidy:
+    // that placeholder is drawn with the same `❯ <text>` shape as a transcript
+    // echo, so without the boundary `findRecentUserPromptIndex` anchors the turn
+    // on the FOOTER and every reply extracts as empty (#1289's defect, verbatim).
     const chromeStart = cliToolId === 'claude'
         ? (0, cli_patterns_1.findClaudeChromeStart)(lines)
         : cliToolId === 'copilot'
             ? (0, cli_patterns_1.findCopilotChromeStart)(lines)
-            : openCodeCleanLines
-                ? (0, cli_patterns_1.findOpenCodeChromeStart)(openCodeCleanLines)
-                : -1;
+            : cliToolId === 'command-code'
+                ? (0, cli_patterns_1.findCommandCodeChromeStart)(lines)
+                : openCodeCleanLines
+                    ? (0, cli_patterns_1.findOpenCodeChromeStart)(openCodeCleanLines)
+                    : -1;
     const contentEnd = chromeStart >= 0 ? chromeStart : totalLines;
     const BUFFER_RESET_TOLERANCE = 25;
     const bufferShrank = totalLines > 0 && lastCapturedLine > BUFFER_RESET_TOLERANCE && (totalLines + BUFFER_RESET_TOLERANCE) < lastCapturedLine;
@@ -330,7 +344,16 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
         return -1;
     };
     // Early check for interactive prompts (before extraction logic)
-    if (cliToolId === 'claude' || cliToolId === 'codex' || cliToolId === 'copilot') {
+    //
+    // Issue #2250: `command-code` must be here. Its permission dialog draws its
+    // highlighted option as `❯ 1. Yes` and keeps a full-pane rule above the block,
+    // so `hasPrompt && hasSeparator && !isThinking` below is TRUE while the dialog
+    // is waiting for an answer — the turn would be declared finished and the
+    // dialog saved as the reply.
+    if (cliToolId === 'claude' ||
+        cliToolId === 'codex' ||
+        cliToolId === 'copilot' ||
+        cliToolId === 'command-code') {
         const fullOutput = lines.join('\n');
         const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
         if (promptDetection.isPrompt) {
@@ -374,8 +397,15 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
         ? copilotStatusBar === 'idle'
         : (cliToolId === 'codex' || cliToolId === 'gemini' || cliToolId === 'vibe-local' || cliToolId === 'antigravity') && hasPrompt && !isThinking;
     const isClaudeComplete = cliToolId === 'claude' && hasPrompt && hasSeparator && !isThinking;
+    // Issue #2250: claude's shape, because Command Code's layout is claude's — the
+    // composer sits between two full-pane rules and is drawn only when the agent
+    // will accept input. Deliberately NOT keyed on `✻ Worked for`: that row is the
+    // live turn's, not the transcript's (it is present in `turn-version.txt` and
+    // gone from `dialog-create-file.txt`, the same pane one prompt later) and
+    // `WorkedDurationNote` omits it entirely for a turn under 1000 ms.
+    const isCommandCodeComplete = cliToolId === 'command-code' && hasPrompt && hasSeparator && !isThinking;
     const isOpenCodeDone = cliToolId === 'opencode' && (0, response_extractor_1.isOpenCodeComplete)(cleanOutputToCheck);
-    if (isPromptBasedComplete || isClaudeComplete || isOpenCodeDone) {
+    if (isPromptBasedComplete || isClaudeComplete || isCommandCodeComplete || isOpenCodeDone) {
         const responseLines = [];
         const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated);
         let endIndex = totalLines;
@@ -515,6 +545,30 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
                 return incompleteResult(totalLines);
             }
         }
+        // Issue #2250: Command Code's launch screen is a complete, idle frame --
+        // block-art logo, three `#` banner rows, composer drawn between its two
+        // rules -- so every check above accepts it, and History would open with
+        // `# Command Code v1.40.1 / # models: … / # <cwd>` saved as the agent's
+        // first reply before the operator has said anything.
+        //
+        // The rule is ONE condition and it is a positive one: Command Code echoes
+        // every prompt into the transcript as `❯ <text>`, and the launch screen has
+        // none. That is the shape #1897 and #2247 both converged on; the anchor
+        // heuristics claude carries above (`hasBannerArt` / `hasVersionInfo` /
+        // `hasStartupTips`) are deliberately NOT reproduced here, because they are
+        // what #2247 had to take back -- a bare version string in a reply is a
+        // normal reply, and Command Code prints its own version on every launch.
+        //
+        // `findRecentUserPromptIndex` is the same `/^[>❯]\s+\S/` scan the extraction
+        // anchors on, and it stops at `contentEnd`, so the composer's own dim
+        // `❯ Ask your question...` placeholder cannot be mistaken for an echo
+        // (#1879's trap).
+        if (cliToolId === 'command-code' && findRecentUserPromptIndex(totalLines) < 0) {
+            logger.info('Command Code launch screen suppressed, response not saved', {
+                responseLength: response.length,
+            });
+            return incompleteResult(totalLines);
+        }
         // Gemini-specific check
         if (cliToolId === 'gemini') {
             const bannerCharCount = (response.match(/[░███]/g) || []).length;
@@ -631,6 +685,36 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             return false;
         }
+        // Issue #2317 Phase D: is a human reading this pane at their own terminal
+        // size right now, and did they just stop?
+        //
+        // Asked only for the tools `attach --live` accepts — no other session can be
+        // delegated, so asking about one would be a tmux round-trip per poll with a
+        // single possible answer. The read itself is memoised for a second
+        // (`DELEGATION_TTL_MS`), which is under one poll interval.
+        const sessionName = (0, session_name_1.resolveSessionName)(cliToolId, worktreeId, instanceId);
+        const delegation = (0, tmux_session_surface_1.isLiveAttachEligibleSession)(sessionName)
+            ? await (0, geometry_delegation_1.probeGeometryDelegation)(sessionName)
+            : { delegated: false, released: false };
+        if (delegation.released) {
+            // The canvas is 1000 rows again, so a cursor recorded against a 44-row
+            // frame indexes into a pane that no longer exists. Zero is the only value
+            // that cannot be wrong in either direction: too low re-saves a turn, too
+            // high suppresses every future one. Done BEFORE the state is read below so
+            // this poll already sees the reset.
+            //
+            // A no-op for claude in practice — it renders in the alternate screen, so
+            // `lineCountIsCursor` is false and the cursor is not consulted — and that
+            // is exactly why it is written here rather than left implicit: the guard
+            // has to already be right on the day a scrollback tool is added to
+            // `LIVE_ATTACH_TOOLS`.
+            (0, db_1.updateSessionState)(db, worktreeId, cliToolId, 0, resolvedInstanceId);
+            logger.info('geometry-delegation-released', {
+                worktreeId,
+                cliToolId,
+                instanceId: resolvedInstanceId,
+            });
+        }
         // Get session state (last captured line count)
         const sessionState = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId);
         const lastCapturedLine = sessionState?.lastCapturedLine || 0;
@@ -891,8 +975,25 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                 worktreePath: worktree.path,
                 transcriptPathHint: claudeMetadata?.logFilePath ?? null,
             }));
+        // Issue #2317 Phase D: the scrape is dropped while the geometry is
+        // delegated, and the transcript capture above is what makes that safe.
+        //
+        // ORDER IS LOAD-BEARING. The delegation test is folded in AFTER the two
+        // calls above rather than short-circuiting them: `captureStructuredHistoryTurn`
+        // is a WRITE, not a query — it is the moment claude's own transcript becomes
+        // a History row — so an `||` that put the delegation first would suppress
+        // the scrape and the real reply together, and the turn would vanish. Read as
+        // it stands: record the turn from the agent's own file, then drop the pane's
+        // copy of it, which at 44 rows is a fraction of the answer hard-wrapped at
+        // the reader's terminal width.
+        //
+        // When the transcript capture answers false (an unreadable or absent file)
+        // the turn goes UNRECORDED for as long as the delegation lasts. That is the
+        // deliberate trade: a missing row is recoverable, a truncated reply saved as
+        // the agent's answer is not.
+        const suppressScrapedHistory = structuredHistoryLive || delegation.delegated;
         // Create Markdown log file for the conversation pair
-        if (cleanedResponse && !structuredHistoryLive) {
+        if (cleanedResponse && !suppressScrapedHistory) {
             await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId);
         }
         // Mark any pending prompts as answered
@@ -913,7 +1014,7 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // are not byte-comparable — the pane's copy is hard-wrapped at the pane
         // width and gutter-prefixed, so no content check could ever recognise them
         // as the same reply.
-        if (!structuredHistoryLive) {
+        if (!suppressScrapedHistory) {
             // Create new CLI tool message in database
             const message = (0, db_1.createMessage)(db, {
                 worktreeId,
@@ -936,6 +1037,10 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                 cliToolId,
                 instanceId: resolvedInstanceId,
                 scrapedLength: cleanedResponse.length,
+                // Which of the two reasons suppressed it. Without this the Phase D case
+                // and the ordinary #2041/#2121 handover are one indistinguishable log
+                // line, and "History is missing a turn" has two very different causes.
+                reason: structuredHistoryLive ? 'structured-history' : 'geometry-delegated',
             });
         }
         // Issue #1790: the agent has just produced a reply, so whatever it was

package/dist/server/src/lib/polling/structured-history-gate.js

@@ -1,16 +1,17 @@
 "use strict";
 /**
  * Whether somebody better-informed is already recording this turn (Issue #2041,
- * extended for Claude Code in #2121, codex in #2197 and antigravity in #2198).
+ * extended for Claude Code in #2121, codex in #2197, antigravity in #2198 and
+ * Command Code in #2252).
  *
  * The poller's job has always been to be the only writer of conversation
- * history, because for most of the six tools the terminal is the only place the
- * reply exists. Four of them now have a second writer: opencode publishes its
- * replies over the SSE stream CommandMate subscribes to (#1763/#2041), and
- * claude, codex and antigravity each keep their own transcript file on disk.
- * Two writers for one turn would put the same answer in History twice — once as
- * the agent wrote it and once as its TUI drew it — so one of them has to stand
- * down, and it is the one reading the screen.
+ * history, because for most of the seven tools the terminal is the only place
+ * the reply exists. Five of them now have a second writer: opencode publishes
+ * its replies over the SSE stream CommandMate subscribes to (#1763/#2041), and
+ * claude, codex, antigravity and command-code each keep their own transcript
+ * file on disk. Two writers for one turn would put the same answer in History
+ * twice — once as the agent wrote it and once as its TUI drew it — so one of
+ * them has to stand down, and it is the one reading the screen.
  *
  * ## Why this is a module and not an `if`
  *
@@ -74,9 +75,11 @@ const subscription_1 = require("../../lib/hooks/sources/opencode/subscription");
 const history_1 = require("../../lib/hooks/sources/claude/history");
 const history_2 = require("../../lib/hooks/sources/codex/history");
 const history_3 = require("../../lib/hooks/sources/antigravity/history");
+const history_4 = require("../../lib/hooks/sources/command-code/history");
 const tool_id_1 = require("../../lib/hooks/sources/claude/tool-id");
 const tool_id_2 = require("../../lib/hooks/sources/codex/tool-id");
 const tool_id_3 = require("../../lib/hooks/sources/antigravity/tool-id");
+const tool_id_4 = require("../../lib/hooks/sources/command-code/tool-id");
 const registry_1 = require("../../lib/hooks/sources/registry");
 const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate');
 /**
@@ -168,6 +171,10 @@ const PULL_TRANSCRIPT_READERS = {
         capture: (target, capture) => (0, history_3.captureAntigravityTranscriptTurn)(target, capture),
         locate: (target, capture) => (0, history_3.resolveAntigravityTranscriptPath)(target, capture),
     },
+    [tool_id_4.COMMAND_CODE_CLI_TOOL_ID]: {
+        capture: (target, capture) => (0, history_4.captureCommandCodeTranscriptTurn)(target, capture),
+        locate: (target, capture) => (0, history_4.resolveCommandCodeTranscriptPath)(target, capture),
+    },
 };
 /**
  * What this tool's source says about who records its replies.

package/dist/server/src/lib/realtime/types.js

@@ -20,17 +20,27 @@ exports.parseRealtimeEvent = parseRealtimeEvent;
  */
 exports.CLIENT_VERSION_MESSAGE_TYPE = 'client_version';
 /**
- * Server → client notice that the running server version differs from this
- * tab's bundle version (#1338/#1356). Drives the reload banner.
+ * Server → client notice that the bundle the server now serves was built from a
+ * different version than this tab's bundle (#1338/#1356/#2271). Drives the
+ * reload banner.
  */
 exports.VERSION_MISMATCH_EVENT_TYPE = 'version_mismatch';
 /**
- * Whether the running server version and this tab's bundle version have drifted
- * apart and the user should be nudged to reload (#1338/#1356).
+ * Whether two **build identities** have drifted apart and the user should be
+ * nudged to reload (#1338/#1356).
+ *
+ * Both arguments are the version a bundle was *built from*, never the version
+ * installed on disk. Issue #2271: feeding this the runtime `package.json`
+ * version on the server side made it fire permanently for everyone, because the
+ * release procedure bumps that file and deliberately does not rebuild the
+ * running server's `.next` — so "installed > served" is the steady state after
+ * every release rather than evidence of anything. `resolveBundleDrift()` in
+ * `@/lib/version-checker` is the one caller that resolves the server side, and
+ * it resolves it from the build manifest.
  *
  * Conservative on purpose (受入条件: 版が一致している間は誤検知しない): an empty or
  * `'0.0.0'` fallback on either side means "version unknown" and is never treated
- * as a mismatch, so a server that cannot resolve its own version stays silent.
+ * as a mismatch, so a server that cannot resolve its own build stays silent.
  */
 function isVersionMismatch(serverVersion, clientVersion) {
     if (!serverVersion || !clientVersion)

package/dist/server/src/lib/response-cleaner.js

@@ -160,8 +160,15 @@ function cleanGeminiResponse(response) {
  * their own by {@link COPILOT_FOLD_MARKER_PATTERN} and
  * {@link COPILOT_COMMAND_OUTPUT_PATTERN}, so nothing needs a block that can run
  * away over a whole message.
+ *
+ * Issue #2269: the verb list moved to {@link COPILOT_TOOL_VERBS}, which
+ * `COPILOT_TOOL_ROW_PATTERN` reads as well. 1.0.82 marks most tool rows with a
+ * file-type badge rather than `●` and that pattern owns those; `●` is still the
+ * marker for a tool row whose file type has no badge (`● Read d.txt 1 line
+ * read`, measured) and for the ask-user row (`● Asked user …`), so both markers
+ * have to answer to one vocabulary.
  */
-const COPILOT_TOOL_ACTION_PATTERN = /^●\s+(?:Get |Read |Run |Search |Write |Edit |Delete |List |Create |Fetch |Explore |Execute |Install |Model changed to:)/;
+const COPILOT_TOOL_ACTION_PATTERN = new RegExp(`^●\\s+(?:${cli_patterns_1.COPILOT_TOOL_VERBS})[\\s:]`);
 /**
  * copilot 1.0.80's tool invocation row (Issue #1897).
  *
@@ -263,6 +270,22 @@ function cleanCopilotResponse(response) {
     let inThinkingBlock = false;
     let inToolOutputBlock = false;
     for (const line of responseLines) {
+        // Issue #2269: tested BEFORE normalisation, for the reason #1897 records at
+        // COPILOT_BOX_ROW_PATTERN and then only acted on in the accumulator:
+        // `normalizeCopilotLine` deletes every U+2500..U+257F glyph, so by the time
+        // COPILOT_SKIP_PATTERNS runs below, every glyph-anchored rule in it is dead
+        // in THIS function. That is what let two rows of copilot's launch screen
+        // through -- `  ╰─╯╰─╯  Copilot v1.0.82 uses AI.` cleans to a bare version
+        // string (1.0.82 split the one-line disclaimer the exact-match rule was
+        // written for), and `   └ Enable all permissions …` cleans to prose -- on
+        // every call that receives a raw frame rather than accumulated content.
+        //
+        // Deliberately not resetting the block flags: the reasoning block's own rows
+        // are `│ <chain of thought>`, so a box row is the middle of a block far more
+        // often than the end of one. That is the behaviour the dead `/^[│└]/` rule
+        // below was written with, and this is the live version of it.
+        if (cli_patterns_1.COPILOT_BOX_ROW_PATTERN.test(line))
+            continue;
         // Normalize using the same function as TUI accumulator (DRY)
         const normalized = (0, tui_accumulator_1.normalizeCopilotLine)(line);
         if (!normalized) {

package/dist/server/src/lib/response-extractor.js

@@ -203,6 +203,17 @@ function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset,
         const foundUserPrompt = findRecentUserPromptIndex(totalLines);
         return foundUserPrompt >= 0 ? foundUserPrompt + 1 : Math.max(0, lastCapturedLine);
     }
+    // Branch 2a''' (Command Code, Issue #2250): same reasoning as agy's above.
+    // Command Code is inline-rendered (`#{alternate_on}` = 0, scrollback kept), so
+    // `lastCapturedLine` is a real cursor and stays the fallback; but the echo
+    // `❯ <message>` is present in every captured turn and is the cleaner boundary,
+    // and the caller has already excluded the composer from the search window by
+    // trimming the chrome, so the echo this finds is a transcript row rather than
+    // the placeholder in the input box.
+    if (cliToolId === 'command-code') {
+        const foundUserPrompt = findRecentUserPromptIndex(totalLines);
+        return foundUserPrompt >= 0 ? foundUserPrompt + 1 : Math.max(0, lastCapturedLine);
+    }
     // Compute bufferWasReset internally (MF-001: responsibility boundary)
     const bufferWasReset = lastCapturedLine >= totalLines || bufferReset;
     // Branch 1: Buffer was reset - find the most recent user prompt as anchor

package/dist/server/src/lib/session/claude-executor.js

@@ -4,7 +4,7 @@
  * Issue #294: Executes CLI tool commands for scheduled executions
  * Issue #379: Added OpenCode support (opencode run)
  *
- * Supported tools: claude, codex, gemini, vibe-local, opencode, copilot, antigravity
+ * Supported tools: claude, codex, gemini, vibe-local, opencode, copilot, antigravity, command-code
  *
  * Security:
  * - Uses execFile (not exec) to prevent shell injection
@@ -14,11 +14,13 @@
  * - Validates cliToolId against ALLOWED_CLI_TOOLS whitelist [SEC-001]
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_CLI_TOOLS = exports.MAX_MESSAGE_LENGTH = exports.EXECUTION_TIMEOUT_MS = exports.MAX_STORED_OUTPUT_SIZE = exports.MAX_OUTPUT_SIZE = void 0;
+exports.COMMAND_CODE_EXIT_REASONS = exports.ALLOWED_CLI_TOOLS = exports.MAX_MESSAGE_LENGTH = exports.EXECUTION_TIMEOUT_MS = exports.MAX_STORED_OUTPUT_SIZE = exports.MAX_OUTPUT_SIZE = void 0;
 exports.getCommandForTool = getCommandForTool;
 exports.truncateOutput = truncateOutput;
 exports.buildCliArgs = buildCliArgs;
 exports.extractOpencodeFinalText = extractOpencodeFinalText;
+exports.extractCommandCodeResult = extractCommandCodeResult;
+exports.describeCommandCodeFailure = describeCommandCodeFailure;
 exports.executeClaudeCommand = executeClaudeCommand;
 exports.getActiveProcesses = getActiveProcesses;
 const child_process_1 = require("child_process");
@@ -62,6 +64,16 @@ function getCommandForTool(cliToolId) {
         // Issue #990 (Phase C): Antigravity's executable is `agy`, not the tool id.
         case 'antigravity':
             return 'agy';
+        // Issue #2253: Command Code ships four bins (`cmd` / `cmdc` / `command-code`
+        // / `commandcode`) and Epic #2249 決定 1 picked the unambiguous spelling, so
+        // the tool id is not the executable here either. Written as a literal to
+        // match the two cases above rather than importing
+        // `COMMAND_CODE_COMMAND` from `@/lib/cli-tools/command-code`, which would
+        // pull the tmux transport into the scheduler's dependency graph; the unit
+        // test imports both and asserts they are the same string, so the copy
+        // cannot drift.
+        case 'command-code':
+            return 'commandcode';
         default:
             return cliToolId;
     }
@@ -94,6 +106,7 @@ function truncateOutput(output) {
  * - vibe-local: [-p <message> -y] or [--model <model> -p <message> -y]
  * - opencode: run --format json [-m <model>] [--agent <a>] [--variant <v>] [-c] [--title <t>] <message>
  * - antigravity: -p <message> --dangerously-skip-permissions
+ * - command-code: -p <message> --output-format json [--yolo | --permission-mode <permission>]
  * - others: -p <message> (fallback)
  *
  * @param message - Prompt message
@@ -159,6 +172,44 @@ function buildCliArgs(message, cliToolId, permission, options) {
             args.push(message);
             return args;
         }
+        case 'command-code': {
+            // Issue #2253 (Epic #2249 Phase D): `commandcode -p <message>` runs one
+            // prompt non-interactively. `--output-format json` is unconditional for
+            // the same reason opencode's `--format json` is: the text format writes a
+            // rendered answer with no frame around it, while the json format ends in a
+            // single `{"type":"result",…}` line carrying `finalText` and `subtype`,
+            // which is what {@link extractCommandCodeResult} reads.
+            //
+            // ## `--yolo` and `--permission-mode` are different axes, and exclusive here
+            //
+            // `commandcode --help` lists them separately, and the shipped option
+            // declaration in `command-code@1.40.1/dist/cli.mjs` is
+            // `.addOption(new Be('--permission-mode <mode>', …).choices(['default',
+            // 'standard','plan','auto-accept','dont-ask']))` with `--yolo` as a plain
+            // boolean alias of `--dangerously-skip-permissions`. So `--yolo` is not a
+            // *value* of the mode flag, and sending both would ask the CLI to run
+            // under a mode and to bypass modes at once. A scheduled run has nobody to
+            // answer a permission dialog, so the default is `--yolo` and an explicit
+            // permission replaces it rather than joining it.
+            //
+            // The whitelist check follows copilot's shape (SEC4-001) rather than
+            // codex's `??`: a permission the dropdown could not have produced falls
+            // back to the unattended default instead of reaching the CLI, where an
+            // unknown `--permission-mode` value is a `.choices()` rejection and the
+            // run would fail before the prompt was ever sent.
+            //
+            // `--yolo` does not override `.commandcode/settings.json`
+            // `permissions.deny`; a denied tool call still ends the run with exit 4,
+            // which {@link describeCommandCodeExit} names in the failure reason.
+            const args = ['-p', message, '--output-format', 'json'];
+            if (schedule_config_1.COMMAND_CODE_PERMISSIONS.includes(permission)) {
+                args.push('--permission-mode', permission);
+            }
+            else {
+                args.push('--yolo');
+            }
+            return args;
+        }
         case 'antigravity':
             // Issue #990 (Phase C): `agy -p <message>` runs a single prompt non-interactively.
             // --dangerously-skip-permissions auto-approves tool use so the process does not
@@ -292,6 +343,134 @@ function renderOpencodeErrorFrame(record) {
     const message = typeof data.message === 'string' ? data.message : '';
     return message ? `opencode error: ${name}: ${message}` : `opencode error: ${name}`;
 }
+// =============================================================================
+// command-code `--output-format json` extraction (Issue #2253)
+// =============================================================================
+/**
+ * `PRINT_EXIT_CODE`, read off `command-code@1.40.1/dist/cli.mjs`.
+ *
+ * The bundle declares it as one object —
+ * `{SUCCESS:0, ERROR:1, AUTH_ERROR:3, PERMISSION_DENIED:4, RATE_LIMITED:5,
+ * CONNECTION_ERROR:6, SERVER_ERROR:7, MAX_TURNS_REACHED:8, NO_RESPONSE:9,
+ * INSUFFICIENT_CREDITS:10, INTERRUPTED:130}` — and `classifyPrintModeError`
+ * next to it is what picks between them. Issue #2253 lists six of the eleven;
+ * all eleven are recorded here because the point of the map is to turn a bare
+ * number in an execution log into a sentence, and a code that falls through
+ * produces exactly the log line the map exists to replace.
+ *
+ * 0 is deliberately absent: success is not a failure reason, and a lookup that
+ * answers for it would let a caller render "Reason: success" on a run that
+ * worked.
+ */
+exports.COMMAND_CODE_EXIT_REASONS = {
+    1: 'error',
+    3: 'authentication failed',
+    4: 'permission denied',
+    5: 'rate limited',
+    6: 'connection error',
+    7: 'server error',
+    8: 'max turns reached',
+    9: 'no response',
+    10: 'insufficient credits',
+    130: 'interrupted',
+};
+/**
+ * The result line of `commandcode -p … --output-format json`, or null.
+ *
+ * ## The measured stream
+ *
+ * One JSON object per line. Every line but the last is `{"type":"event",…}`;
+ * the last is the result. Measured on command-code 1.40.1 (fixtures under
+ * `tests/fixtures/command-code/headless/`):
+ *
+ * ```text
+ * {"type":"event","event":{"type":"run_start","sessionId":"…"}}
+ * {"type":"event","event":{"type":"text_delta","delta":"OK"}}
+ * {"type":"event","event":{"type":"run_end","result":{"finalText":"OK",…}}}
+ * {"type":"result","subtype":"success","sessionId":"…","stopReason":"end_turn",
+ *  "usage":{…},"durationMs":1957,"finalText":"OK"}
+ * ```
+ *
+ * ## Why the last result line rather than `run_end`
+ *
+ * `run_end` carries a `result.finalText` too, and on a successful run they
+ * agree. But `buildPrintResultLine` in the bundle emits the result line on the
+ * failure path as well, where no `run_end` was ever produced: an empty query
+ * answers with exactly one line,
+ * `{"type":"result","subtype":"error",…,"finalText":"","error":"Error: No query
+ * provided. …"}`, and nothing else. Reading `run_end` would see nothing there.
+ *
+ * ## Why it never throws and never invents a result
+ *
+ * Null means "this stdout carried no result line", which the caller renders as
+ * raw output rather than as an empty answer — the state a run that dies before
+ * `runPrintMode` is actually in (`--model <unknown>` exits 1 with **empty
+ * stdout** and the message only on stderr). Unparseable lines are skipped for
+ * the reason the opencode reader skips them: a stray `console.log` from a mod
+ * lands on the same stdout as the stream.
+ *
+ * @param stdout - Raw stdout from `commandcode -p … --output-format json`
+ * @returns The decoded result line, or null when stdout carried none
+ */
+function extractCommandCodeResult(stdout) {
+    let found = null;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        let frame;
+        try {
+            frame = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (typeof frame !== 'object' || frame === null)
+            continue;
+        const record = frame;
+        if (record.type !== 'result')
+            continue;
+        if (typeof record.subtype !== 'string')
+            continue;
+        found = {
+            subtype: record.subtype,
+            finalText: typeof record.finalText === 'string' ? record.finalText : '',
+            ...(typeof record.error === 'string' ? { error: record.error } : {}),
+        };
+    }
+    return found;
+}
+/**
+ * One line naming why a Command Code run failed, or null when it did not.
+ *
+ * Both halves are load-bearing, because the CLI can disagree with itself. A run
+ * whose answer is blank exits `NO_RESPONSE` (9) while `buildPrintResultLine`
+ * still stamps `subtype: "success"` — the subtype is derived from `stopReason`
+ * and the exit code from `classifyPrintOutcome`, and only the pair says what
+ * happened. So a non-zero exit is a failure whatever the subtype says, and a
+ * subtype other than `success` is a failure whatever the exit code says.
+ *
+ * @param exitCode - Process exit code (null when killed by a signal)
+ * @param result - Decoded result line, when stdout carried one
+ * @returns A `Reason: …` sentence, or null when the run succeeded
+ */
+function describeCommandCodeFailure(exitCode, result) {
+    const failedByCode = exitCode !== null && exitCode !== 0;
+    const failedBySubtype = result !== null && result.subtype !== 'success';
+    if (!failedByCode && !failedBySubtype)
+        return null;
+    const parts = [];
+    if (exitCode !== null && exitCode !== 0) {
+        const reason = exports.COMMAND_CODE_EXIT_REASONS[exitCode];
+        parts.push(reason ? `exit ${exitCode} (${reason})` : `exit ${exitCode}`);
+    }
+    if (result) {
+        parts.push(`subtype=${result.subtype}`);
+        if (result.error)
+            parts.push(result.error);
+    }
+    return `Reason: command-code ${parts.join(' / ')}`;
+}
 /**
  * Execute a CLI command in a worktree directory.
  *
@@ -332,23 +511,43 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                 const isMaxBuffer = errCode === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
                 // maxBuffer 超過は時間切れではなく「出力過多」なので timeout 扱いにしない。
                 const isTimeout = error.killed || errCode === 'ETIMEDOUT';
+                // Issue #2253: command-code writes its whole NDJSON stream *and* a
+                // final result line before exiting non-zero — a max-turns run ends at
+                // exit 8 with a complete `{"type":"result","subtype":"max_turns",…}`
+                // line — so the answer and the CLI's own reason are on stdout even
+                // here. Decoding them turns a log that said "Error: Command failed"
+                // over a 4KB event dump into the reason plus the text.
+                const commandCodeResult = cliToolId === 'command-code'
+                    ? extractCommandCodeResult(stdout || '')
+                    : null;
+                const exitCodeNumber = typeof errCode === 'number' ? errCode : null;
                 const errorSummary = [
                     `Error: ${error.message}`,
                     `Code: ${errCode ?? 'unknown'}`,
                     `Signal: ${error.signal ?? 'none'}`,
                     isMaxBuffer ? 'Reason: stdout exceeded execFile maxBuffer (output_limit)' : null,
+                    cliToolId === 'command-code'
+                        ? describeCommandCodeFailure(exitCodeNumber, commandCodeResult)
+                        : null,
                 ]
                     .filter((line) => line !== null)
                     .join('\n');
+                // `?? stdout` on purpose, matching the success path: a run that died
+                // before it could write a result line (an unknown `--model` exits 1
+                // with empty stdout and the message on stderr) reports what it did
+                // write rather than an empty body.
+                const decodedStdout = commandCodeResult
+                    ? commandCodeResult.finalText
+                    : (stdout || '');
                 const rawOutput = (0, cli_patterns_1.stripAnsi)([
                     errorSummary,
-                    stdout ? `\n--- stdout ---\n${stdout}` : '',
+                    decodedStdout ? `\n--- stdout ---\n${decodedStdout}` : '',
                     stderr ? `\n--- stderr ---\n${stderr}` : '',
                 ].join('\n'));
                 const output = truncateOutput(rawOutput);
                 resolve({
                     output,
-                    exitCode: typeof errCode === 'number' ? errCode : null,
+                    exitCode: exitCodeNumber,
                     status: isTimeout ? 'timeout' : 'failed',
                     error: error.message,
                 });
@@ -358,6 +557,26 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
             // stored output is the assistant's answer rather than the event log.
             // `?? stdout` on purpose: an unrecognised stream is reported verbatim,
             // never swallowed.
+            //
+            // Issue #2253: command-code is the same deal one flag over
+            // (`--output-format json`), except that its stream also carries the
+            // CLI's own verdict. `classifyPrintOutcome` in the bundle can exit 0
+            // only on `subtype: "success"`, so this branch is the success case in
+            // practice — but the subtype is read rather than assumed, because
+            // "the process exited 0" and "the agent answered" are two facts and
+            // this layer is the only one that can still see the second.
+            if (cliToolId === 'command-code') {
+                const result = extractCommandCodeResult(stdout || '');
+                const failure = describeCommandCodeFailure(0, result);
+                const body = result ? result.finalText : (stdout || '');
+                resolve({
+                    output: truncateOutput((0, cli_patterns_1.stripAnsi)(failure ? `${failure}\n${body}` : body)),
+                    exitCode: 0,
+                    status: failure ? 'failed' : 'completed',
+                    ...(failure ? { error: failure } : {}),
+                });
+                return;
+            }
             const decoded = cliToolId === 'opencode'
                 ? extractOpencodeFinalText(stdout || '') ?? stdout ?? ''
                 : stdout || '';