commandmate 0.29.2 → 0.30.1

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

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Separating an agent's own words from its tool log (Issue #2234).
+ *
+ * Four readers — `./claude/transcript`, `./opencode/transcript`,
+ * `./codex/transcript` and `./antigravity/transcript` — turn one agent turn into
+ * the single Markdown body that becomes one `chat_messages` row. Each of them
+ * used to lay the pieces out in transcript order and join them, which put a run
+ * of tool-call lines at the **top** of every body that opened with a tool call.
+ * Measured on 400 real Claude Code transcripts (2026-09-02,
+ * `docs/design/2234-turn-prose-tool-separation.md` §1): **141 of 586 non-empty
+ * turns (24 %)** began with `- \`Bash\` — …`. The chat surface (#2232) shows the
+ * 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:
+ *
+ *  1. **Prose leads.** Text the agent wrote — and the folded `Thinking` quotes
+ *     that sit between the sentences — keep their transcript order and come
+ *     first.
+ *  2. **The tool log is one section, at the end**, in transcript order, folded
+ *     into a blockquote under a labelled heading.
+ *
+ * ## Why the order claim from #2041 / #2121 is narrowed rather than dropped
+ *
+ * Those Issues kept strict transcript order on the argument that "the order is
+ * the only record of what happened when, and this row is the record". That is
+ * still true *within* each kind and is still what this module emits: the tool
+ * lines are in call order, and the paragraphs are in the order they were
+ * written. What is given up is the interleaving **between** the two — which
+ * paragraph a given call sat under. It is given up deliberately, because the
+ * surface that reads this row is a chat bubble, and a bubble whose first line is
+ * `- \`Bash\` — git status` has already failed the reader before the ordering
+ * argument gets a hearing.
+ *
+ * ## Why a blockquote and not `<details>`
+ *
+ * Measured, not assumed (§3 of the design note). The card renders with
+ * `remarkGfm` + `rehypeSanitize` + `rehypeHighlight` and deliberately **no**
+ * `rehypeRaw`, so raw HTML never becomes an element: a `<details>` /
+ * `<summary>` wrapper is dropped whole and takes its summary text with it,
+ * leaving a bare list and no label. A blockquote with a bold first line is
+ * Markdown's own way of saying "subordinate", survives the sanitiser untouched,
+ * and is the same shape the four readers already use for `Thinking`.
+ *
+ * @module lib/hooks/sources/turn-body
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TURN_TOOL_LOG_LABEL = void 0;
+exports.separateTurnBody = separateTurnBody;
+/**
+ * The bold first line of the folded tool section.
+ *
+ * English, like the `Thinking` label the four readers already share, and for the
+ * same reason: the string is written into `chat_messages.content` at read time,
+ * so it is baked into rows that outlive any later locale change and cannot be
+ * re-translated by the UI.
+ */
+exports.TURN_TOOL_LOG_LABEL = 'Tool calls';
+/**
+ * Quote one already-rendered tool line.
+ *
+ * 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.
+ */
+function quoteToolLine(line) {
+    return line
+        .split('\n')
+        .map((part) => (part.length > 0 ? `> ${part}` : '>'))
+        .join('\n');
+}
+/**
+ * Lay one turn's rendered blocks out as the body a history row stores.
+ *
+ * Pure: same blocks in, same string out, no clock and no I/O. That is what lets
+ * the settled row (each source's `history` module) and the live
+ * `chat_turn_progress` bubble
+ * (#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.
+ *
+ * @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
+ */
+function separateTurnBody(blocks) {
+    const prose = [];
+    const tools = [];
+    for (const block of blocks) {
+        if (block.text.length === 0)
+            continue;
+        if (block.kind === 'tool')
+            tools.push(block.text);
+        else
+            prose.push(block.text);
+    }
+    // A blank line between every pair, which is what keeps a paragraph a paragraph
+    // and stops a heading being absorbed into the text above it. #2041's join had
+    // a second rule — consecutive tool lines joined by a single newline so they
+    // stayed one Markdown list — which is gone because no tool line reaches this
+    // list any more.
+    const proseText = prose.join('\n\n');
+    const toolLog = tools.length === 0
+        ? ''
+        : [
+            `> **${exports.TURN_TOOL_LOG_LABEL} (${tools.length})**`,
+            '>',
+            ...tools.map(quoteToolLine),
+        ].join('\n');
+    const body = proseText.length > 0 && toolLog.length > 0
+        ? `${proseText}\n\n${toolLog}`
+        : `${proseText}${toolLog}`;
+    return { body, prose: proseText, toolLog, toolCalls: tools.length };
+}

package/dist/server/src/lib/hooks/stop-history-capture.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Reading the transcript when the agent says it stopped (Issue #2246).
+ *
+ * ## Why the poller was not enough
+ *
+ * `lib/polling/structured-history-gate` is asked to record a turn at exactly one
+ * moment: the poll on which the scraper decided the turn had finished and was
+ * about to save its own copy. That is the right moment — doing the handover at
+ * the point of the write is what makes it impossible for both writers to run —
+ * but it is the *only* moment, and the decision behind it is a string analysis
+ * of a terminal frame.
+ *
+ * When that analysis misses one completion the cost is not a delay. By the time
+ * the next completion is judged, the newest turn is the next one; before #2246
+ * the reader wrote only that, so the missed turn belonged to nobody and stayed
+ * missing. One misjudged frame, one turn gone (measured 2026-09-02: a reply the
+ * transcript held in full and History never showed).
+ *
+ * The agent itself knows the boundary exactly, and has been telling us: the
+ * `stop` hook. This module is that second trigger.
+ *
+ * ## What it does not do
+ *
+ * **It does not replace the poller's call.** A session with no hooks — or with
+ * hooks the operator never wired up — sends no `stop`, and for it the poller is
+ * still the only trigger there is. Two triggers for one turn cost nothing
+ * because the readers are idempotent and the gate serialises them per instance;
+ * one trigger that is sometimes absent costs a reply.
+ *
+ * **It does not decide anything about the turn.** The whole judgement stays in
+ * the gate and the readers, so the two entry points cannot drift.
+ *
+ * Never throws: a hook post is fire-and-forget from a CLI's stop handler, and a
+ * failure here must not become the agent's problem.
+ *
+ * @module lib/hooks/stop-history-capture
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = void 0;
+exports.captureTranscriptTurnOnStop = captureTranscriptTurnOnStop;
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/hooks/stop-history-capture');
+/**
+ * How long to wait before asking a second time.
+ *
+ * The `stop` hook fires when the agent considers the turn over, and the last
+ * assistant record is appended to the transcript around — not necessarily
+ * before — that instant. A reader that arrives in the gap sees the prompt
+ * record and no body, answers false (correctly: an empty row would be a blank
+ * reply forever) and, without a retry, hands a turn the agent has definitely
+ * finished back to the scraper.
+ *
+ * Half a second is chosen against what the gap actually is — a file append that
+ * has already been issued — rather than against a timeout. One retry and not a
+ * loop, because the poller's own trigger is still behind this: if the file is
+ * still empty after the retry, the next poll is the right place to notice, and
+ * a hook handler that waits on a file is a hook handler that can hang a turn.
+ */
+exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = 500;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Ask the pull-mode reader to record this instance's turn, now.
+ *
+ * The tool question is asked first and without doing any work
+ * (`isPullTranscriptHistory`), so a `stop` from gemini, copilot or opencode
+ * costs one map lookup and returns — in particular it never waits out the
+ * retry delay. opencode has a second writer too, but a *push* one: its
+ * subscription has already received the reply and there is nothing to pull.
+ *
+ * The import is dynamic so that the poller's module graph — which reaches every
+ * transcript reader and the whole opencode client — does not become a static
+ * dependency of the hook receiver.
+ *
+ * @param worktree - The worktree the event resolved to
+ * @param cliToolId - The tool that sent the event
+ * @param instanceId - The already-resolved instance id
+ * @returns Whether History now holds this instance's newest turn as Markdown
+ */
+async function captureTranscriptTurnOnStop(worktree, cliToolId, instanceId, options = {}) {
+    try {
+        const { captureStructuredHistoryTurn, hasStructuredHistoryTranscript, isPullTranscriptHistory } = await Promise.resolve().then(() => __importStar(require('../../lib/polling/structured-history-gate')));
+        if (!isPullTranscriptHistory(cliToolId))
+            return false;
+        // No `transcriptPathHint`: that value is a line the *pane* printed, and the
+        // hook receiver has not read the pane. A tool whose transcript can only be
+        // found that way has no session pointer either, and therefore sends no stop
+        // event this path could act on.
+        const capture = { worktreePath: worktree.path, transcriptPathHint: null };
+        if (await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture)) {
+            return true;
+        }
+        const retryDelayMs = options.retryDelayMs ?? exports.STOP_TRANSCRIPT_RETRY_DELAY_MS;
+        if (retryDelayMs <= 0)
+            return false;
+        // The retry is for one failure and one only: the turn's last assistant
+        // record had not been appended yet. Every other reason the capture answers
+        // false — no session pointer, no transcript, the operator never wired hooks
+        // for this tool — is a reason waiting cannot fix, and this handler is on the
+        // agent's own stop path, so half a second spent for nothing is half a second
+        // added to every turn it is spent on.
+        if (!(await hasStructuredHistoryTranscript(worktree.id, cliToolId, instanceId, capture))) {
+            return false;
+        }
+        await sleep(retryDelayMs);
+        const captured = await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
+        logger.debug('stop-history-capture-retried', {
+            worktreeId: worktree.id,
+            cliToolId,
+            instanceId,
+            captured,
+        });
+        return captured;
+    }
+    catch (error) {
+        logger.warn('stop-history-capture-failed', {
+            worktreeId: worktree.id,
+            cliToolId,
+            instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}

package/dist/server/src/lib/polling/prompt-dedup.js

@@ -13,10 +13,8 @@ exports.clearPromptHashCache = clearPromptHashCache;
 exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
-/**
- * In-memory cache: pollerKey -> SHA-256 hash of last saved prompt content.
- */
-const promptHashCache = new Map();
+const promptHashCache = globalThis.__promptHashCache ??
+    (globalThis.__promptHashCache = new Map());
 /**
  * Check if the given prompt content is a duplicate of the last saved prompt
  * for the same pollerKey. If not a duplicate, updates the cache.

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

@@ -96,6 +96,35 @@ function observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output)
         matchedText: match?.matchedText,
     }).catch(() => { });
 }
+/**
+ * The `onUpdated` hook for `markPendingPromptsAsAnswered` (Issue #2195).
+ *
+ * The sweep stamps every still-pending prompt row of an instance the moment the
+ * agent is seen to have moved on, which flips a prompt card in the chat surface
+ * from "waiting for your answer" to answered. That was the one history mutation
+ * with no realtime frame behind it, so every open pane kept showing the stale
+ * card until its next `/messages` poll — and #2195 stretches that poll to 15s
+ * whenever a socket is up, so the omission had to be closed in the same change
+ * that introduced the longer interval.
+ *
+ * `message_updated`, never `message`: the row already existed and was already
+ * delivered when it was created, so a client that appended instead of replacing
+ * would show the question twice.
+ */
+function broadcastPromptSweptToAnswered(worktreeId) {
+    return (message) => {
+        try {
+            (0, ws_server_1.broadcastMessage)('message_updated', { worktreeId, message });
+        }
+        catch (error) {
+            // The rows are already stamped; a socket write must not fail the poll.
+            logger.warn('prompt-sweep-broadcast-failed', {
+                worktreeId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+}
 // Issue #1790: arm the waiting-edge push subscription.
 //
 // It has to exist before the first edge, and `server.ts` reaches this module at
@@ -405,10 +434,36 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
         // CRITICAL FIX: Detect and skip Claude Code startup banner/screen
         if (cliToolId === 'claude') {
             const cleanResponse = (0, cli_patterns_1.stripAnsi)(response);
-            const hasBannerArt = /[╭╮╰╯│]/.test(cleanResponse) || /░{3,}/.test(cleanResponse) || /▓{3,}/.test(cleanResponse);
-            const hasVersionInfo = /Claude Code|claude\/|v\d+\.\d+/.test(cleanResponse);
+            // Issue #2247: `│` is what Claude Code draws markdown TABLES with -- the
+            // live frame in `tests/fixtures/claude-live-2247/turn-table.txt` is a
+            // two-row table and nothing else -- so it identified a reply, not a banner.
+            // The banner's own frame glyphs are the rounded corners and the block
+            // shading; those stay.
+            const hasBannerArt = /[╭╮╰╯]/.test(cleanResponse) || /░{3,}/.test(cleanResponse) || /▓{3,}/.test(cleanResponse);
+            // Issue #2247: the bare `v\d+\.\d+` alternative matched any version string a
+            // reply happens to mention. The frame that lost a turn on 2026-09-02 was
+            // "GitHub Release v0.30.0 を公開しました" (148 chars, well under the 2000
+            // below). What the banner actually prints is the tool's own name and
+            // version on one row -- `Claude Code v2.1.258` -- so that is what is
+            // matched now, plus the `claude/` form older banners used.
+            const hasVersionInfo = /Claude Code v\d+\.\d+|claude\//.test(cleanResponse);
             const hasStartupTips = /Tip:|for shortcuts|\?\s*for help/.test(cleanResponse);
             const hasProjectInit = /^\s*\/Users\/.*$/m.test(cleanResponse) && cleanResponse.split('\n').length < 30;
+            // Issue #2247: the anchors above are only evidence of a banner on a pane
+            // that has not had a single turn yet -- the same shape as the #1897 copilot
+            // fix below. Claude echoes every prompt into the transcript as `❯ <text>`,
+            // and the startup screen has none, so an echo anywhere in the transcript
+            // rules the banner out no matter what the reply quotes.
+            //
+            // The search is `findRecentUserPromptIndex`, deliberately: it is the same
+            // `/^[>❯]\s+\S/` this file already anchors extraction on, and it stops at
+            // `contentEnd`. That bound is load-bearing rather than incidental -- the
+            // footer's composer draws a DIM ghost suggestion (`❯ Try "write a test for
+            // <filepath>"`, see `boot-banner.txt`) whose stripped bytes are identical
+            // to a real echo (#1879), so a scan over the whole pane would read the
+            // startup screen as "already had a turn" and put the banner back in
+            // History.
+            const hasTurnEcho = findRecentUserPromptIndex(totalLines) >= 0;
             const userPromptMatch = cleanResponse.match(/^[>❯]\s+(\S.*)$/m);
             if (userPromptMatch) {
                 const userPromptIndex = cleanResponse.indexOf(userPromptMatch[0]);
@@ -423,7 +478,21 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
                     return incompleteResult(totalLines);
                 }
             }
-            else if ((hasBannerArt || hasVersionInfo || hasStartupTips || hasProjectInit) && response.length < 2000) {
+            else if (!hasTurnEcho &&
+                (hasBannerArt || hasVersionInfo || hasStartupTips || hasProjectInit) &&
+                response.length < 2000) {
+                // Issue #2247: this branch used to swallow the turn in silence -- the
+                // poller kept ticking every 2s and `response-poller` logged nothing at
+                // all, so the only way to tell a lost turn from an idle session was to
+                // re-run `extractResponse` on a saved pane by hand. It is reached only
+                // before the first echo lands, so it cannot become a per-tick flood.
+                logger.info('Claude startup banner suppressed, response not saved', {
+                    responseLength: response.length,
+                    hasBannerArt,
+                    hasVersionInfo,
+                    hasStartupTips,
+                    hasProjectInit,
+                });
                 return incompleteResult(totalLines);
             }
         }
@@ -593,7 +662,7 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
             const tailLines = cleanOutput.split('\n').slice(-thinking_constants_1.THINKING_TAIL_LINE_COUNT).join('\n');
             if (thinkingPattern.test(tailLines)) {
-                const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId);
+                const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId, broadcastPromptSweptToAnswered(worktreeId));
                 if (answeredCount > 0) {
                     logger.info('marked-answeredcount-pending');
                 }
@@ -809,13 +878,25 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // (the prompt row, Auto-Yes, the waiting episode, the push fan-out), and the
         // liveness answer is only allowed to suppress the two calls that RECORD THE
         // REPLY. See `./structured-history-gate` for the whole argument.
-        const structuredHistoryLive = (0, structured_history_gate_1.isStructuredHistoryWriterLive)(worktreeId, cliToolId, instanceId);
+        //
+        // Issue #2121 adds the second shape. Claude has no stream to be live on; it
+        // has a transcript file, and this is the moment to read it — the turn is
+        // finished (everything above this line established that) and the row is
+        // about to be written. `captureStructuredHistoryTurn` writes the agent's own
+        // Markdown and answers true, or answers false and leaves the scrape below to
+        // be the only record. `||` and not `&&`: the two are different tools'
+        // answers to the same question, and each one is false for the other's tool.
+        const structuredHistoryLive = (0, structured_history_gate_1.isStructuredHistoryWriterLive)(worktreeId, cliToolId, instanceId) ||
+            (await (0, structured_history_gate_1.captureStructuredHistoryTurn)(worktreeId, cliToolId, instanceId, {
+                worktreePath: worktree.path,
+                transcriptPathHint: claudeMetadata?.logFilePath ?? null,
+            }));
         // Create Markdown log file for the conversation pair
         if (cleanedResponse && !structuredHistoryLive) {
             await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId);
         }
         // Mark any pending prompts as answered
-        const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId);
+        const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId, broadcastPromptSweptToAnswered(worktreeId));
         if (answeredCount > 0) {
             logger.info('marked-answeredcount-pending');
         }

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

@@ -23,10 +23,8 @@ exports.isDuplicateResponse = isDuplicateResponse;
 exports.clearResponseHashCache = clearResponseHashCache;
 exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
 const crypto_1 = require("crypto");
-/**
- * In-memory cache: pollerKey -> SHA-256 hash of the last saved response content.
- */
-const responseHashCache = new Map();
+const responseHashCache = globalThis.__responseHashCache ??
+    (globalThis.__responseHashCache = new Map());
 /**
  * Check whether the given response content was already saved during the current
  * polling cycle for the same pollerKey. If it is new, updates the cache.