commandmate 0.30.0 → 0.30.2

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

@@ -90,13 +90,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAUDE_TRANSCRIPT_TAIL_BYTES = void 0;
+exports.CLAUDE_TURN_RECHECK_LIMIT = exports.CLAUDE_TRANSCRIPT_TAIL_BYTES = void 0;
 exports.resetClaudeTranscriptSessions = resetClaudeTranscriptSessions;
 exports.resolveClaudeSessionId = resolveClaudeSessionId;
 exports.claudeProjectsRoot = claudeProjectsRoot;
 exports.claudeTranscriptPath = claudeTranscriptPath;
 exports.acceptClaudeTranscriptHint = acceptClaudeTranscriptHint;
 exports.captureClaudeTranscriptTurn = captureClaudeTranscriptTurn;
+exports.resolveClaudeTranscriptPath = resolveClaudeTranscriptPath;
 exports.readClaudeTurnProgress = readClaudeTurnProgress;
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
@@ -113,8 +114,9 @@ const logger = (0, logger_1.createLogger)('lib/hooks/sources/claude/history');
  * The file grows for the life of the session and a long one is tens of
  * megabytes — the largest on this machine on 2026-08-31 was 23 MB — so reading
  * it whole on every finished turn would be the most expensive thing the poller
- * does. Only the newest turn is ever written (see {@link captureClaudeTranscriptTurn}),
- * so only the newest turn has to be in the window.
+ * does. Only turns whose prompt record is inside the window are ever written
+ * (see {@link captureClaudeTranscriptTurn}), which is also what stops a turn the
+ * window opened halfway through being written from its middle.
  *
  * 4 MiB is roughly two orders of magnitude above the measured size of a single
  * turn and still small enough to read and parse in one tick. A turn that
@@ -216,15 +218,38 @@ function acceptClaudeTranscriptHint(homeDir, hint) {
     return resolved;
 }
 /**
- * Read the newest turn out of this instance's transcript and write it.
- *
- * **Only the newest turn**, and that is the deliberate difference from
- * opencode's backfill. Every earlier turn of this session already has a
- * `chat_messages` row that the *scraper* wrote, and writing a Markdown row for
- * it as well would put the same reply in History twice — once as prose and once
- * as the pane drew it. The scraper wrote exactly one row per turn and this
- * writes exactly one row per turn, so the swap is one-for-one and history is
- * neither duplicated nor rewritten.
+ * Read this instance's unwritten turns out of its transcript and write them.
+ *
+ * ## Why this is no longer "only the newest turn" (Issue #2246)
+ *
+ * #2121 wrote `built.turns.at(-1)` and nothing else, for a reason that was
+ * sound and is still half true: every earlier turn of this session already has
+ * a `chat_messages` row that the *scraper* wrote, and writing a Markdown row
+ * for it as well would put the same reply in History twice — once as prose and
+ * once as the pane drew it.
+ *
+ * What that argument did not cover is a turn **no writer recorded at all**. The
+ * trigger for this reader is the poller deciding a turn finished, so a poll that
+ * misjudges one completion (#2247's launch-banner heuristic, measured on
+ * 2026-09-02) does not merely delay the turn: by the time the next completion is
+ * judged, "the newest turn" is the *next* one, and the missed turn is nobody's.
+ * One dropped completion cost one turn permanently.
+ *
+ * So the unit of work is now "every turn in the window that is not already a
+ * row", written oldest first, and what preserves #2121's argument is the
+ * **anchor**: the newest turn in the window that this reader has already written
+ * is where the backfill starts. Turns after it are turns this reader was live
+ * for, so a scraper row for them exists only in the case the anchor cannot see
+ * — the reader answering false once for a transient reason (an empty body) and
+ * the scraper saving that turn's pane copy. That trade is deliberate and in the
+ * direction every Issue in this subsystem picks: two writers duplicate a reply,
+ * no writer loses one.
+ *
+ * When the window holds **no** anchor — a session the reader has never written
+ * for, and equally the first read after a `/clear` — this falls back to #2121's
+ * behaviour exactly: the newest turn, and nothing before it. That is the case
+ * where the earlier turns really are the scraper's, and there is no evidence in
+ * the window that says otherwise.
  *
  * The return value is the poller's instruction, so the two failure directions
  * are worth stating plainly. **True** means this path has recorded the turn and
@@ -234,10 +259,15 @@ function acceptClaudeTranscriptHint(homeDir, hint) {
  * false, which is the fail-open the acceptance criteria require: two writers
  * duplicate a reply, no writer loses one.
  *
+ * **It is the newest turn the answer is about**, backfill or not. A run that
+ * wrote three missed turns and then found the newest one still empty answers
+ * false, because the scrape the poller is holding is the pane's copy of *that*
+ * turn and dropping it would lose it.
+ *
  * Never throws.
  *
  * @param target - The instance whose turn just ended
- * @returns Whether History now holds this turn as the agent's own Markdown
+ * @returns Whether History now holds this instance's newest turn as Markdown
  */
 async function captureClaudeTranscriptTurn(target, capture) {
     const instanceId = target.instanceId ?? target.cliToolId;
@@ -262,8 +292,7 @@ async function captureClaudeTranscriptTurn(target, capture) {
             return false;
         const parsed = (0, transcript_1.parseClaudeTranscript)(text);
         const built = (0, transcript_1.buildClaudeTurns)(parsed.records, sessionId ?? '');
-        const turn = built.turns.at(-1);
-        if (!turn) {
+        if (built.turns.length === 0) {
             logger.info('claude-transcript-no-turn', {
                 worktreeId: target.worktreeId,
                 instanceId,
@@ -294,8 +323,49 @@ async function captureClaudeTranscriptTurn(target, capture) {
                 sidechainRecords: built.sidechainRecords,
             });
         }
-        const userRow = await recordClaudeUserTurn(target, turn);
-        return await writeClaudeTurn(target, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        const pending = await selectUnwrittenClaudeTurns(target, built.turns);
+        // Before anything is written: the rows that are already there (#2264). This
+        // is deliberately ahead of the early return below, because "the newest turn
+        // is already a row" is the state the nine short rows the Issue measured were
+        // stuck in — the reader answered true and did nothing while the transcript
+        // beside it held the missing paragraph.
+        await refreshClaudeTurnRows(target, built.turns.slice(0, built.turns.length - pending.turns.length).slice(-exports.CLAUDE_TURN_RECHECK_LIMIT), path);
+        if (pending.turns.length === 0) {
+            // The anchor is the newest turn in the window, so there is nothing to
+            // write and the newest turn is a row. True, for the reason
+            // {@link writeClaudeTurn} answers true to an already-saved turn: a second
+            // poll of one finished turn must not put the pane's copy on top of it.
+            logger.debug('claude-transcript-turns-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                turnsInWindow: built.turns.length,
+            });
+            return true;
+        }
+        if (pending.turns.length > 1) {
+            // The #2246 case, and the one worth a line in the log: more than one turn
+            // was unwritten, so a completion went unnoticed at the time.
+            logger.info('claude-transcript-backfilling-turns', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                path,
+                pendingTurns: pending.turns.length,
+                turnsInWindow: built.turns.length,
+                anchored: pending.anchored,
+            });
+        }
+        // Oldest first, and the ordering is load-bearing twice over: History sorts
+        // by timestamp, and each turn's `/send` row is adopted against the previous
+        // turn's start, so a later turn must not get to claim a row an earlier one
+        // is about to ask for.
+        let captured = false;
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const turn = pending.turns[index];
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            const userRow = await recordClaudeUserTurn(target, turn, previousStartedAt);
+            captured = await writeClaudeTurn(target, turn, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        }
+        return captured;
     }
     catch (error) {
         logger.error('claude-transcript-capture-failed', {
@@ -306,6 +376,78 @@ async function captureClaudeTranscriptTurn(target, capture) {
         return false;
     }
 }
+/**
+ * The turns {@link captureClaudeTranscriptTurn} still has to write (Issue #2246).
+ *
+ * The search runs **backwards from the newest turn** and stops at the first one
+ * that is already a row. That turn is the *anchor*, and everything after it is
+ * pending — by construction, since the anchor is the newest written turn in the
+ * window.
+ *
+ * Two properties of that rule are worth stating because both were required:
+ *
+ *  - **Order, not time.** The comparison is the transcript's own record order
+ *    and never a timestamp. A turn's assistant row is dated one millisecond
+ *    after its user row (`resolveAssistantTimestampMs`), so the rows do not
+ *    carry an ordering that could be trusted for this.
+ *  - **The window bounds it.** `buildClaudeTurns` only opens a turn on a prompt
+ *    record, so a turn whose prompt fell outside
+ *    {@link CLAUDE_TRANSCRIPT_TAIL_BYTES} is not in `turns` at all and cannot be
+ *    backfilled from its middle. Its records are counted as
+ *    `orphanedAssistantRecords` instead, which is what the caller reports.
+ *
+ * A window with no anchor answers with the newest turn alone. See
+ * {@link captureClaudeTranscriptTurn} for why that is #2121's behaviour rather
+ * than a degraded one.
+ *
+ * @param turns - Every turn in the window, oldest first
+ */
+async function selectUnwrittenClaudeTurns(target, turns) {
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const requestId = (0, agent_transcript_1.claudeTurnRequestId)(turns[index].promptUuid);
+        if (!findMessageByRequestId(db, target.worktreeId, requestId))
+            continue;
+        return {
+            turns: turns.slice(index + 1),
+            previousStartedAt: turns[index].startedAt,
+            anchored: true,
+        };
+    }
+    return {
+        turns: turns.slice(-1),
+        previousStartedAt: turns.length > 1 ? turns[turns.length - 2].startedAt : 0,
+        anchored: false,
+    };
+}
+/**
+ * The transcript file this instance would be read from, or null (Issue #2246).
+ *
+ * The same two steps {@link captureClaudeTranscriptTurn} opens with — resolve
+ * the session pointer, then check the filesystem — asked without reading or
+ * writing anything. The Stop receiver uses it to decide whether waiting half a
+ * second and asking again could possibly help: a session with no transcript to
+ * name will not have grown one by then, and a hook handler that sleeps for
+ * nothing is a hook handler that slows every turn of every tool.
+ *
+ * Never throws.
+ */
+async function resolveClaudeTranscriptPath(target, capture) {
+    try {
+        const homeDir = capture.homeDir ?? (0, os_1.homedir)();
+        if (typeof capture.worktreePath !== 'string' || capture.worktreePath.length === 0) {
+            return null;
+        }
+        return await locateClaudeTranscript(homeDir, capture, await resolveClaudeSessionId(target));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * The key for a body read with no prompt record in the window.
  *
@@ -357,6 +499,11 @@ function collectHeadlessClaudeTurn(records, sessionId) {
         promptIsOperatorInput: false,
         blocks,
         assistantRecords,
+        // Never handed to a writer, so neither flag can be read off it; false is the
+        // value that would refuse the write if one were ever attempted.
+        closed: false,
+        superseded: false,
+        stopReasonObserved: false,
         overflowed,
     };
 }
@@ -463,8 +610,14 @@ async function readClaudeTurnProgress(target, capture) {
  * agent really did reply, and #2121's behaviour for those turns is unchanged.
  *
  * Never throws; `recordUserTurn` reports its failures in the return value.
+ *
+ * @param previousStartedAt - When the turn before this one opened, or 0. Widens
+ *   `/send` adoption backwards to that instant (Issue #2246): a prompt the agent
+ *   queued for eleven minutes is still the row CommandMate wrote when it sent
+ *   the text, and #2196's symmetric two-minute window cannot reach it. Never
+ *   narrows — see {@link RecordUserTurnOptions}.
  */
-async function recordClaudeUserTurn(target, turn) {
+async function recordClaudeUserTurn(target, turn, previousStartedAt = 0) {
     const instanceId = target.instanceId ?? target.cliToolId;
     if (!turn.promptIsOperatorInput) {
         logger.debug('claude-transcript-user-turn-skipped', {
@@ -475,7 +628,8 @@ async function recordClaudeUserTurn(target, turn) {
         });
         return { outcome: 'skipped', messageId: null, timestampMs: null };
     }
-    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.claudePromptRequestId)(turn.promptUuid), turn.promptText, turn.startedAt);
+    const adoption = previousStartedAt > 0 ? { adoptionFromMs: previousStartedAt } : {};
+    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.claudePromptRequestId)(turn.promptUuid), turn.promptText, turn.startedAt, adoption);
     if (recorded.outcome === 'failed') {
         logger.warn('claude-transcript-user-turn-failed', {
             worktreeId: target.worktreeId,
@@ -574,6 +728,113 @@ async function readClaudeTranscriptTail(path) {
         await handle?.close().catch(() => { });
     }
 }
+/**
+ * How many already-written turns are re-rendered and compared (Issue #2264).
+ *
+ * The repair half of #2264 has to look at rows the reader has **already**
+ * written, which is the one thing the anchor rule deliberately does not do — so
+ * it is bounded here rather than by the window. Three, because the poller runs
+ * every two seconds and re-rendering the whole 4 MiB window on every tick would
+ * turn a repair into the most expensive thing the poll does, while a row that is
+ * going to grow grows within a second of being written.
+ *
+ * The cost of the bound is only paid by rows the old code left short: those are
+ * repaired on the next read that still has the turn among its newest three, and
+ * a session that has moved four turns past one of them keeps it. The Issue's own
+ * nine rows were all the newest turn at the time, so all nine are inside it.
+ */
+exports.CLAUDE_TURN_RECHECK_LIMIT = 3;
+/**
+ * Replace a saved row whose body has since grown (Issue #2264).
+ *
+ * The second half of the fix, and the half that repairs what the first half
+ * only stops happening again. A row keyed `claude-turn:<uuid>` is written once
+ * and every later read answers "already saved" — so the nine short rows the
+ * Issue measured were frozen, and the scrape that could have replaced them was
+ * suppressed two seconds later by that same idempotency answer.
+ *
+ * **Strictly longer, never merely different.** Equality is the ordinary case and
+ * must cost nothing, and a body that got *shorter* between two reads is not a
+ * turn that grew — it is a window that slid, or a truncation marker, and
+ * overwriting a full reply with a shorter one is the one outcome worse than the
+ * bug. Longer implies different, so one comparison covers both halves of the
+ * Issue's "differs and is longer".
+ *
+ * `message_updated`, never `message`: the row already existed and was already
+ * delivered when it was created (#2195), so a client that appended instead of
+ * replacing would show the reply twice.
+ *
+ * @param existing - The row `findMessageByRequestId` answered with
+ * @returns Whether the row was replaced
+ */
+async function growClaudeTurnRow(target, existing, rendered, path) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    const previousLength = existing.content.length;
+    if (rendered.body.length <= previousLength)
+        return false;
+    const [{ getDbInstance }, { updateMessageContent }, { broadcastMessage }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
+    ]);
+    updateMessageContent(getDbInstance(), existing.id, rendered.body);
+    broadcastMessage('message_updated', {
+        worktreeId: target.worktreeId,
+        message: { ...existing, content: rendered.body },
+    });
+    logger.info('claude-transcript-turn-updated', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        sessionId: rendered.sessionId,
+        requestId: existing.requestId,
+        path,
+        previousLength,
+        bodyLength: rendered.body.length,
+        textBlocks: rendered.textBlocks,
+        toolBlocks: rendered.toolBlocks,
+    });
+    return true;
+}
+/**
+ * Re-read the newest already-written turns and grow the short ones (#2264).
+ *
+ * Runs before the pending turns are written and independently of whether there
+ * are any — the case it exists for is precisely the one
+ * {@link captureClaudeTranscriptTurn} used to return `true` from without doing
+ * anything: the newest turn already has a row, and that row is missing its last
+ * paragraph.
+ *
+ * Turns that are still open are skipped rather than compared. Their body is by
+ * definition not the final one, and a repair that raced the agent would rewrite
+ * the row on every poll of a long turn.
+ *
+ * The database is asked before the turn is rendered, so a candidate with no row
+ * — every candidate, in a session this reader has never written to — costs one
+ * indexed lookup and no Markdown.
+ *
+ * @param candidates - Already-written turns, oldest first, at most {@link CLAUDE_TURN_RECHECK_LIMIT}
+ * @returns How many rows were replaced
+ */
+async function refreshClaudeTurnRows(target, candidates, path) {
+    if (candidates.length === 0)
+        return 0;
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    let updated = 0;
+    for (const turn of candidates) {
+        if (!(0, transcript_1.isClaudeTurnWritable)(turn))
+            continue;
+        const existing = findMessageByRequestId(db, target.worktreeId, (0, agent_transcript_1.claudeTurnRequestId)(turn.promptUuid));
+        if (!existing)
+            continue;
+        if (await growClaudeTurnRow(target, existing, (0, transcript_1.renderClaudeTurn)(turn), path))
+            updated += 1;
+    }
+    return updated;
+}
 /**
  * Write one rendered turn, unless it is already there.
  *
@@ -588,8 +849,33 @@ async function readClaudeTranscriptTail(path) {
  *
  * @returns Whether History holds this turn as the agent's own Markdown
  */
-async function writeClaudeTurn(target, rendered, timestampMs, path) {
+async function writeClaudeTurn(target, turn, rendered, timestampMs, path) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    if (!(0, transcript_1.isClaudeTurnWritable)(turn)) {
+        // The agent has not said `end_turn` for this prompt and no later prompt has
+        // taken over, so what is in the file is a turn in progress. Writing it would
+        // put a reply with its last paragraph missing into History **permanently** —
+        // the row is keyed on the prompt's `uuid`, so every later read finds it and
+        // answers "already saved". That is Issue #2264 exactly: 9 of `claude-2`'s 20
+        // turns on 2026-09-03 were saved as a bare `> **Tool calls (1)**` with not
+        // one character of prose, because the Stop hook beat the last append and the
+        // emptiness guard below cannot see the difference — a turn cut off after its
+        // tool calls renders a *non-empty* body.
+        //
+        // Handing it back to the scraper costs the Markdown rendering for this turn
+        // and nothing else: the Stop receiver asks again after a short delay, and
+        // the poller asks again when the pane returns to the composer.
+        logger.info('claude-transcript-turn-open', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            sessionId: rendered.sessionId,
+            promptUuid: rendered.promptUuid,
+            assistantRecords: turn.assistantRecords,
+            textBlocks: rendered.textBlocks,
+            toolBlocks: rendered.toolBlocks,
+        });
+        return false;
+    }
     if (rendered.body.length === 0) {
         // The turn is open but the agent has not written anything to the file yet —
         // the prompt record is there and the assistant records are not. Answering
@@ -619,12 +905,17 @@ async function writeClaudeTurn(target, rendered, timestampMs, path) {
         Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
     ]);
     const db = getDbInstance();
-    if (findMessageByRequestId(db, target.worktreeId, requestId)) {
+    const existing = findMessageByRequestId(db, target.worktreeId, requestId);
+    if (existing) {
         logger.debug('claude-transcript-turn-already-saved', {
             worktreeId: target.worktreeId,
             instanceId,
             requestId,
         });
+        // The row may still be one of the short ones #2264 was reported for, and
+        // this is the one place that knows both the row and the turn. See
+        // {@link growClaudeTurnRow}.
+        await growClaudeTurnRow(target, existing, rendered, path);
         return true;
     }
     const message = createMessage(db, {