commandmate 0.30.2 → 0.31.0

package/dist/server/src/lib/hooks/sources/opencode/history.js

@@ -320,6 +320,47 @@ async function publishOpencodeTurnProgress(target, turn) {
         });
     }
 }
+/**
+ * When each backfilled turn's last assistant message finished (Issue #2273).
+ *
+ * `info.time.completed` on every `role: "assistant"` message, folded onto the
+ * turn key (`parentID`) with `Math.max` — a tool-calling turn produces more than
+ * one assistant message (measured: two, in turn 2 of the captured session) and
+ * the turn ended when the last of them did. `time.created` is the fallback for a
+ * message opencode has not marked complete.
+ *
+ * Read here rather than on the accumulator because `./transcript` is not this
+ * Issue's to change, and read defensively for the reason everything in this
+ * subsystem is: a shape opencode changes must cost the timestamp, not the row.
+ *
+ * @returns `parentID` → epoch ms; absent for a turn with no usable clock
+ */
+function lastOpencodeCompletedAt(body) {
+    const at = new Map();
+    if (!Array.isArray(body))
+        return at;
+    for (const entry of body) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const info = (0, event_mapper_1.isPlainObject)(entry.info) ? entry.info : null;
+        if (!info || info.role !== 'assistant')
+            continue;
+        const userMessageId = (0, event_mapper_1.readStringField)(info, transcript_1.OPENCODE_TURN_KEY_FIELD);
+        if (!userMessageId)
+            continue;
+        const time = (0, event_mapper_1.isPlainObject)(info.time) ? info.time : null;
+        const finished = readFiniteNumber(time?.completed) ?? readFiniteNumber(time?.created) ?? null;
+        if (finished === null)
+            continue;
+        if (finished > (at.get(userMessageId) ?? 0))
+            at.set(userMessageId, finished);
+    }
+    return at;
+}
+/** A finite number, or null. */
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
 /**
  * The turn currently open on this session, for tests and for callers that need
  * to know whether a flush would do anything.
@@ -342,9 +383,12 @@ function peekOpencodeTurn(target, sessionId) {
  *
  * @param target - The instance
  * @param sessionId - `ses_…` from the `session.idle` frame
+ * @param closedAt - When the turn ended, epoch ms. Defaults to now, which is
+ *   what `session.idle` means: opencode's own end-of-turn frame is being handled
+ *   (Issue #2273). A parameter only so a test need not move the clock.
  * @returns Whether a row was written
  */
-async function flushOpencodeTurn(target, sessionId) {
+async function flushOpencodeTurn(target, sessionId, closedAt = Date.now()) {
     const turns = transcripts.get(keyOf(target));
     const turn = turns?.get(sessionId);
     if (!turn || !turns)
@@ -353,7 +397,12 @@ async function flushOpencodeTurn(target, sessionId) {
     // not find the accumulator still there and race a duplicate insert past the
     // existence check below.
     turns.delete(sessionId);
-    return writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'stream');
+    // The turn's END and not its start (Issue #2273). A reply dated where the turn
+    // opened draws ABOVE the tool approvals that were written seconds into it, so
+    // the chat surface reads question → answer → approval for a turn that really
+    // went question → approval → answer. `Math.max` because a clock that went
+    // backwards must not put the reply before its own prompt.
+    return writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), Math.max(turn.startedAt, closedAt), 'stream');
 }
 /**
  * Forget everything held for one instance.
@@ -506,11 +555,16 @@ async function backfillOpencodeHistory(target, port, sessionId) {
                 limit: exports.MAX_OPENCODE_BACKFILLED_TURNS,
             });
         }
+        // Issue #2273: the same rule the live flush follows, off the REST document's
+        // own clock. `time.completed` is when opencode finished the assistant
+        // message; the stream route has no equivalent field and uses the instant
+        // `session.idle` arrived, which is the same fact a moment later.
+        const completedAt = lastOpencodeCompletedAt(body);
         let written = 0;
         // Oldest of the kept ones first, so the rows are inserted in conversation
         // order and `updateWorktreeTimestamp` ends on the newest.
         for (const turn of [...kept].reverse()) {
-            const saved = await writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'backfill');
+            const saved = await writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), Math.max(turn.startedAt, completedAt.get(turn.userMessageId) ?? 0), 'backfill');
             if (saved)
                 written += 1;
         }

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

@@ -186,8 +186,14 @@ const OPENCODE_SILENT_PART_TYPES = new Set([
     'snapshot',
     'patch',
 ]);
-/** The label a reasoning block is folded behind. */
-exports.OPENCODE_REASONING_LABEL = 'Thinking';
+/**
+ * The label a reasoning block is folded behind.
+ *
+ * An alias of `../turn-body`'s constant since #2272 rather than a second copy
+ * of the string: the section heading and this name have to stay equal or the
+ * chat surface's reader stops recognising the section it is meant to fold.
+ */
+exports.OPENCODE_REASONING_LABEL = turn_body_1.TURN_REASONING_LABEL;
 /**
  * One tool call as a single Markdown line.
  *
@@ -218,33 +224,16 @@ function renderToolPart(part) {
 function collapseToLine(value) {
     return value.replace(/\s+/g, ' ').trim();
 }
-/**
- * Reasoning, folded.
- *
- * A blockquote rather than `<details>`, and the reason is a rendering decision
- * that belongs here because it decides what is *stored*: showing `<details>`
- * would mean running `rehype-raw` over agent output in `ConversationPairCard`,
- * and that costs every unfenced `<T>` in ordinary prose — the HTML parser eats
- * it as a tag. A blockquote is Markdown's own way of saying "subordinate", it
- * survives the sanitiser with no raw-HTML pass, and the card's existing
- * two-line collapse already keeps it out of the way.
- */
-function renderReasoningPart(text) {
-    const quoted = text
-        .trim()
-        .split('\n')
-        .map((line) => (line.length > 0 ? `> ${line}` : '>'))
-        .join('\n');
-    return `> **${exports.OPENCODE_REASONING_LABEL}**\n>\n${quoted}`;
-}
 /**
  * Render one turn to Markdown.
  *
- * Stream order within each kind — reasoning sits where the agent thought it and
- * the calls are in the order they were made. #2041 kept one stream for all of
- * them and #2234 split the tool calls out into a section of their own; the
- * layout is `../turn-body`'s, shared with the other three readers, and
- * {@link separateTurnBody} carries the reasoning for both halves of that.
+ * Stream order within each kind — the thoughts are in the order they were
+ * thought and the calls in the order they were made. #2041 kept one stream for
+ * all of them, #2234 split the tool calls out into a section of their own, and
+ * #2272 did the same for the reasoning: measured against 1.18.22, opencode
+ * emits a `reasoning` part in front of *every* text part, so leaving them
+ * inline meant a one-line answer whose bubble opened with `> **Thinking**` and a
+ * long one with four such quotes buried in it. The layout is `../turn-body`'s.
  *
  * @param turn - The accumulator, live or rebuilt from REST
  */
@@ -268,7 +257,9 @@ function renderOpencodeTurn(turn) {
             const text = part.text?.trim() ?? '';
             if (text.length === 0)
                 continue;
-            blocks.push({ kind: 'aside', text: renderReasoningPart(text) });
+            // Raw, not pre-quoted: `separateTurnBody` folds the whole run under one
+            // `Thinking (N)` heading and owns the quoting (Issue #2272).
+            blocks.push({ kind: 'reasoning', text });
             continue;
         }
         if (part.type === 'tool') {
@@ -284,7 +275,11 @@ function renderOpencodeTurn(turn) {
         if (!OPENCODE_SILENT_PART_TYPES.has(part.type))
             unknown.add(part.type);
     }
-    let body = (0, turn_body_1.separateTurnBody)(blocks).body;
+    const separated = (0, turn_body_1.separateTurnBody)(blocks);
+    // The cap still counts the whole body, reasoning included — but the reasoning
+    // now sits behind the prose, so what a 200 kB turn loses is the tail of its
+    // thinking rather than the answer (Issue #2272).
+    let body = separated.body;
     if (body.length > exports.MAX_OPENCODE_TURN_BODY_LENGTH) {
         body =
             body.slice(0, exports.MAX_OPENCODE_TURN_BODY_LENGTH - exports.OPENCODE_TURN_TRUNCATION_MARKER.length) +
@@ -296,6 +291,7 @@ function renderOpencodeTurn(turn) {
         body,
         textParts,
         toolParts,
+        reasoningParts: separated.reasoningBlocks,
         unknownPartTypes: [...unknown],
     };
 }

package/dist/server/src/lib/hooks/sources/registry.js

@@ -40,6 +40,7 @@ const source_3 = require("./gemini/source");
 const source_4 = require("./antigravity/source");
 const source_5 = require("./codex/source");
 const source_6 = require("./opencode/source");
+const source_7 = require("./command-code/source");
 const registered = (globalThis.__agentEventSources ??= new Map());
 /** Memoised compatibility sources, so repeated lookups return one object. */
 const legacy = (globalThis.__agentEventLegacySources ??= new Map());
@@ -109,3 +110,6 @@ registerAgentEventSource(source_3.geminiAgentEventSource);
 registerAgentEventSource(source_4.antigravityAgentEventSource);
 registerAgentEventSource(source_5.codexAgentEventSource);
 registerAgentEventSource(source_6.opencodeAgentEventSource);
+// Issue #2251, Epic #2249 Phase B. The seventh, and the last line of "adding a
+// tool" — its own directory plus this.
+registerAgentEventSource(source_7.commandCodeAgentEventSource);

package/dist/server/src/lib/hooks/sources/turn-body.js

@@ -13,13 +13,32 @@
  * body in full, so those 141 bubbles opened with a tool log instead of a reply.
  *
  * This module is the one place that decides the layout, and every reader goes
- * through it. Two rules:
+ * through it. Three rules:
  *
- *  1. **Prose leads.** Text the agent wrote — and the folded `Thinking` quotes
- *     that sit between the sentences — keep their transcript order and come
+ *  1. **Prose leads.** Text the agent wrote keeps its transcript order and comes
  *     first.
  *  2. **The tool log is one section, at the end**, in transcript order, folded
  *     into a blockquote under a labelled heading.
+ *  3. **Reasoning is one section too** (Issue #2272), between the two, on the
+ *     same shape — see {@link TURN_REASONING_LABEL}.
+ *
+ * ## Why reasoning became a section of its own (Issue #2272)
+ *
+ * #2234 moved the tool calls and deliberately left the folded `Thinking` quotes
+ * where they sat, on the argument that they are the agent's own words about the
+ * reply. Measured against opencode 1.18.22 that argument does not survive
+ * contact: opencode emits a `reasoning` part before *every* text part, so the
+ * body opens with `> **Thinking**` on a one-line answer and carries four such
+ * quotes on a long one — which is exactly the failure #2234 set out to fix, from
+ * the other producer.
+ *
+ * The distinction is therefore drawn on the **block kind**, not on the reader:
+ * `reasoning` carries the raw text and is folded into the trailing section,
+ * `aside` carries text a reader already folded itself and stays with the prose.
+ * The four readers that push `aside` (claude, codex, antigravity, command-code)
+ * are untouched by this Issue because none of them has been measured the way
+ * opencode has; they can move a block at a time by switching kind, with no
+ * change here.
  *
  * ## Why the order claim from #2041 / #2121 is narrowed rather than dropped
  *
@@ -46,7 +65,7 @@
  * @module lib/hooks/sources/turn-body
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TURN_TOOL_LOG_LABEL = void 0;
+exports.TURN_REASONING_LABEL = exports.TURN_TOOL_LOG_LABEL = void 0;
 exports.separateTurnBody = separateTurnBody;
 /**
  * The bold first line of the folded tool section.
@@ -58,15 +77,31 @@ exports.separateTurnBody = separateTurnBody;
  */
 exports.TURN_TOOL_LOG_LABEL = 'Tool calls';
 /**
- * Quote one already-rendered tool line.
+ * The bold first line of the folded reasoning section (Issue #2272).
  *
- * The four readers all render a call as a **single-line** list item — their
- * detail readers collapse whitespace precisely so a heredoc in a shell command
- * cannot put a newline here — so one prefix per line is enough and the split is
- * a guard rather than a case that is expected to fire.
+ * The same string the five readers already used for their own inline quotes, on
+ * purpose: it is baked into `chat_messages.content` at read time, so the rows
+ * written before this Issue carry `> **Thinking**` and the rows written after it
+ * carry `> **Thinking (N)**`. Keeping the label identical is what lets one
+ * reader on the chat surface fold both shapes — see `splitChatThinking` in
+ * `components/worktree/ChatMessageBubble`.
  */
-function quoteToolLine(line) {
-    return line
+exports.TURN_REASONING_LABEL = 'Thinking';
+/**
+ * Put one block inside a blockquote, line by line.
+ *
+ * Every line gets its own `> ` because a blockquote ends at the first line that
+ * has none — a lazy continuation would work in CommonMark for a paragraph and
+ * would NOT for the list items the tool log is made of.
+ *
+ * For a tool line the split is a guard rather than a case that is expected to
+ * fire: the five readers all render a call as a single-line list item and
+ * collapse whitespace precisely so a heredoc in a shell command cannot put a
+ * newline here. For a reasoning block it is the normal path — that text is
+ * paragraphs.
+ */
+function quoteBlock(text) {
+    return text
         .split('\n')
         .map((part) => (part.length > 0 ? `> ${part}` : '>'))
         .join('\n');
@@ -80,21 +115,25 @@ function quoteToolLine(line) {
  * (#2199) agree — both reach this function through the same renderer, so the
  * text a reader watches being written is the text that settles.
  *
- * A turn with no tool calls comes out **byte-identical** to what the readers
- * produced before this Issue: the whole change is the section this adds.
+ * A turn with neither a tool call nor a `reasoning` block comes out
+ * **byte-identical** to what the readers produced before #2234 / #2272: the
+ * whole change is the sections this adds.
  *
  * @param blocks - Rendered pieces in transcript order; empty text is the
  *   caller's to drop
- * @returns The body and the two halves it was built from
+ * @returns The body and the three parts it was built from
  */
 function separateTurnBody(blocks) {
     const prose = [];
+    const reasoning = [];
     const tools = [];
     for (const block of blocks) {
         if (block.text.length === 0)
             continue;
         if (block.kind === 'tool')
             tools.push(block.text);
+        else if (block.kind === 'reasoning')
+            reasoning.push(block.text);
         else
             prose.push(block.text);
     }
@@ -104,15 +143,34 @@ function separateTurnBody(blocks) {
     // stayed one Markdown list — which is gone because no tool line reaches this
     // list any more.
     const proseText = prose.join('\n\n');
+    // One heading for the whole run, and a bare `>` between the blocks so two
+    // consecutive thoughts stay two paragraphs inside the quote rather than
+    // running into one another.
+    const reasoningLog = reasoning.length === 0
+        ? ''
+        : [
+            `> **${exports.TURN_REASONING_LABEL} (${reasoning.length})**`,
+            '>',
+            reasoning.map(quoteBlock).join('\n>\n'),
+        ].join('\n');
     const toolLog = tools.length === 0
         ? ''
         : [
             `> **${exports.TURN_TOOL_LOG_LABEL} (${tools.length})**`,
             '>',
-            ...tools.map(quoteToolLine),
+            ...tools.map(quoteBlock),
         ].join('\n');
-    const body = proseText.length > 0 && toolLog.length > 0
-        ? `${proseText}\n\n${toolLog}`
-        : `${proseText}${toolLog}`;
-    return { body, prose: proseText, toolLog, toolCalls: tools.length };
+    // Prose, then reasoning, then the tool log. The tool log stays last because
+    // #2234 put it there and the readers' rows are matched on `request_id` rather
+    // than rewritten, so moving it would split History into two layouts for no
+    // gain.
+    const body = [proseText, reasoningLog, toolLog].filter((part) => part.length > 0).join('\n\n');
+    return {
+        body,
+        prose: proseText,
+        reasoningLog,
+        reasoningBlocks: reasoning.length,
+        toolLog,
+        toolCalls: tools.length,
+    };
 }

package/dist/server/src/lib/job-executor.js

@@ -7,6 +7,11 @@
  * This module manages the DB logging lifecycle (create/update execution logs)
  * and delegates actual command execution to claude-executor.
  *
+ * Scheduled tools: claude, codex, gemini, vibe-local, opencode, copilot,
+ * antigravity, command-code (Issue #2253). Which flags each one is launched
+ * with, and how its stdout is decoded back into an answer, is claude-executor's
+ * business — this module only records the verdict.
+ *
  * Trust boundary: All inputs are DB-derived from schedule-manager.ts (trusted).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -186,6 +191,13 @@ async function executeSchedule(state) {
         // Resolve the CLI options via the centralized helper (DR1-004, #2044)
         const options = resolveScheduleExecuteOptions(state.entry, worktree);
         const result = await (0, claude_executor_1.executeClaudeCommand)(state.entry.message, worktree.path, state.entry.cliToolId, state.entry.permission, options);
+        // Issue #2253: `result.status` is not always "did the process exit 0".
+        // command-code writes a `{"type":"result","subtype":…}` line even on a
+        // non-zero exit and can pair `subtype: "success"` with exit 9, so
+        // claude-executor reads both halves and folds the verdict into `status` and
+        // into the head of `output` (a `Reason: command-code exit N (…)` line).
+        // This row is therefore the failure reason as well as the transcript, and
+        // must keep writing `result.output` verbatim rather than a summary of it.
         updateExecutionLog(logId, result.status, result.output, result.exitCode);
         updateScheduleLastExecuted(state.scheduleId);
         logger.info('execution:completed', { name: state.entry.name, status: result.status });

package/dist/server/src/lib/polling/auto-yes-dialog-gate.js

@@ -94,6 +94,12 @@ exports.AUTO_YES_DIALOG_GATE_DEFAULT_MODE = {
     gemini: 'legacy',
     antigravity: 'legacy',
     'vibe-local': 'legacy',
+    // Issue #2250 / Epic #2249 決定 3: Command Code's Auto-Yes stays on the legacy
+    // numbered-response path. Its `PreToolUse` hook fires AFTER the permission
+    // dialog is answered (measured: dialog 00:11:37, answer 00:11:46, hook
+    // 00:11:46), so a `permissionDecision` cannot dismiss the dialog and there is
+    // no measured dialog rule to gate on.
+    'command-code': 'legacy',
 };
 /**
  * The kill switch (§13.1 DR3-016).

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.