commandmate 0.30.1 → 0.31.0

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

@@ -90,7 +90,7 @@ 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;
@@ -324,6 +324,12 @@ async function captureClaudeTranscriptTurn(target, capture) {
             });
         }
         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
@@ -352,12 +358,23 @@ async function captureClaudeTranscriptTurn(target, capture) {
         // 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.
+        //
+        // Every prompt row is recorded before any reply is written (Issue #2273).
+        // That is what lets a reply be dated at its turn's END without overtaking
+        // the NEXT turn's prompt: a queued `/send` row is written while this turn is
+        // still running, so its instant is only knowable once that row has been
+        // recorded. With one turn pending — the ordinary case — this is the single
+        // call it always was.
+        const userRows = [];
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            userRows.push(await recordClaudeUserTurn(target, pending.turns[index], previousStartedAt));
+        }
+        const lastRecordAt = lastClaudeAssistantRecordAt(parsed.records);
         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, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+            captured = await writeClaudeTurn(target, turn, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.promptUuid) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), path);
         }
         return captured;
     }
@@ -493,6 +510,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,
     };
 }
@@ -632,22 +654,87 @@ async function recordClaudeUserTurn(target, turn, previousStartedAt = 0) {
 /**
  * When the assistant row for this turn is dated.
  *
- * #2121 dated it by the prompt record's clock so that a row written a poll late
- * still sorts where the conversation put it, and that is still what happens for
- * every turn that produced no user row.
- *
- * When there *is* a user row, it sits on that same instant — both come from the
- * one prompt record — and `groupMessagesIntoPairs` orders by timestamp and
- * nothing else. A tie there is decided by whichever row the database happened to
- * return first, and the losing arrangement (assistant, then user) is exactly the
- * `orphan` pair this Issue exists to remove. So the reply is moved to the first
- * millisecond after the prompt: the smallest change that makes the order a
- * property of the data rather than of the query plan.
+ * **The turn's LAST assistant record, not its prompt (Issue #2273).** #2121
+ * dated the reply by the prompt record's clock so that a row written a poll late
+ * still sorted where the conversation put it, and #2196 moved it one millisecond
+ * on so that `groupMessagesIntoPairs` — which orders by timestamp and nothing
+ * else — could never return the answer above the question. Both properties
+ * survive: `earliest` is a floor this never goes under.
+ *
+ * What neither accounted for is the row that lands BETWEEN the prompt and the
+ * reply. A tool approval is written when the dialog appears, seconds into the
+ * turn, and the chat surface orders its rows by timestamp — so a reply dated at
+ * the turn's start draws ABOVE an approval that really happened before it. The
+ * measured case is in the Issue: prompt `04:49:50.989Z`, reply `04:49:54.000Z`,
+ * approval `04:49:57.513Z`, rendered as question → answer → approval.
+ *
+ * The turn's last assistant record is the moment the reply was finished, so
+ * everything the turn produced on the way sorts before it. `lastRecordAt` is 0
+ * when the window held no timestamped assistant record for the turn, and the row
+ * is then dated exactly where #2196 put it.
+ *
+ * `nextTurnOpensAt` is the ceiling. The next turn's prompt row may be a `/send`
+ * row written while THIS turn was still running — a queued prompt — and a reply
+ * that overtook it would be paired with the wrong question.
+ *
+ * @param lastRecordAt - Epoch ms of the turn's last assistant record, or 0
+ * @param nextTurnOpensAt - Epoch ms of the next turn's user row, or null when
+ *   this is the newest turn in the window
  */
-function resolveAssistantTimestampMs(turn, userRow) {
-    if (userRow.timestampMs === null)
-        return turn.startedAt;
-    return Math.max(turn.startedAt, userRow.timestampMs + 1);
+function resolveAssistantTimestampMs(turn, userRow, lastRecordAt = 0, nextTurnOpensAt = null) {
+    const earliest = userRow.timestampMs === null
+        ? turn.startedAt
+        : Math.max(turn.startedAt, userRow.timestampMs + 1);
+    const latest = nextTurnOpensAt === null ? Number.POSITIVE_INFINITY : nextTurnOpensAt - 1;
+    return Math.max(earliest, Math.min(lastRecordAt, latest));
+}
+/**
+ * When each turn's last assistant record was written (Issue #2273).
+ *
+ * Keyed by `promptUuid`, which is the turn key {@link buildClaudeTurns} uses, and
+ * walked over the same records with the same two rules — sidechains skipped, a
+ * prompt record opening a turn — so the two passes cannot disagree about which
+ * turn a record belongs to. It is a second pass rather than a field on the
+ * accumulator because `./transcript` is not this Issue's to change.
+ *
+ * Only `assistant` records count. A turn's `user` records are its tool RESULTS,
+ * and the last of those is a step the agent took before it had finished
+ * answering; the reply is dated by the agent's last word.
+ *
+ * @returns `promptUuid` → epoch ms; absent for a turn with no timestamped
+ *   assistant record
+ */
+function lastClaudeAssistantRecordAt(records) {
+    const at = new Map();
+    let key = null;
+    for (const record of records) {
+        if (record.isSidechain)
+            continue;
+        if ((0, transcript_1.isClaudePromptRecord)(record)) {
+            key = record.uuid;
+            continue;
+        }
+        if (record.type !== 'assistant' || key === null || record.timestampMs === null)
+            continue;
+        if (record.timestampMs > (at.get(key) ?? 0))
+            at.set(key, record.timestampMs);
+    }
+    return at;
+}
+/**
+ * The instant the next pending turn's prompt row carries, or null (Issue #2273).
+ *
+ * The user row's own timestamp when there is one, because that is what History
+ * sorts on and it can be EARLIER than the turn's start — an adopted `/send` row
+ * was written when CommandMate handed the text to the pane, which for a queued
+ * prompt is while the previous turn was still running. The turn's start is the
+ * fallback for a turn that produced no row at all.
+ */
+function nextTurnOpensAt(turns, userRows, index) {
+    const next = turns[index + 1];
+    if (!next)
+        return null;
+    return userRows[index + 1]?.timestampMs ?? next.startedAt;
 }
 /**
  * The transcript file for this instance, or null.
@@ -717,6 +804,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.
  *
@@ -731,8 +925,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
@@ -762,12 +981,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, {

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

@@ -36,9 +36,12 @@
  *     is therefore keyed on the *prompt* record, never on a `requestId`.
  *  3. **`type: "user"` is mostly not the user.** Of 19 user records in the
  *     sampled session, 18 were `tool_result` payloads. Tool results, `isMeta`
- *     placeholders (`[Image: original 1440x2170…]`), and the slash-command
+ *     placeholders (`[Image: original 1440x2170…]`), and the built-in command
  *     bookkeeping records (`<command-name>`, `<local-command-stdout>`) all have
- *     `type: "user"` and none of them is a prompt. See {@link isClaudePromptRecord}.
+ *     `type: "user"` and none of them is a prompt. The one `<command-…>` shape
+ *     that *is* a prompt — a project command, recorded `<command-message>` first
+ *     — is Issue #2265; see {@link CLAUDE_SLASH_COMMAND_PREFIX} and
+ *     {@link isClaudePromptRecord}.
  *  4. **`thinking` blocks can be empty.** The block arrives with a `signature`
  *     and `thinking: ""` when the text is not retained, so an empty one is
  *     skipped rather than rendered as a blank quote.
@@ -53,13 +56,16 @@
  * @module lib/hooks/sources/claude/transcript
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAUDE_HUMAN_PROMPT_SOURCES = exports.CLAUDE_HUMAN_ORIGIN_KIND = exports.CLAUDE_THINKING_LABEL = exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH = exports.MAX_CLAUDE_TURN_BLOCKS = exports.CLAUDE_TURN_TRUNCATION_MARKER = exports.MAX_CLAUDE_TURN_BODY_LENGTH = exports.CLAUDE_PROJECTS_DIR_SEGMENTS = void 0;
+exports.CLAUDE_END_TURN_STOP_REASON = exports.CLAUDE_HUMAN_PROMPT_SOURCES = exports.CLAUDE_HUMAN_ORIGIN_KIND = exports.CLAUDE_SLASH_COMMAND_PREFIX = exports.CLAUDE_THINKING_LABEL = exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH = exports.MAX_CLAUDE_TURN_BLOCKS = exports.CLAUDE_TURN_TRUNCATION_MARKER = exports.MAX_CLAUDE_TURN_BODY_LENGTH = exports.CLAUDE_PROJECTS_DIR_SEGMENTS = void 0;
 exports.claudeProjectSlug = claudeProjectSlug;
+exports.claudeSlashCommandPrompt = claudeSlashCommandPrompt;
 exports.readClaudeContentBlock = readClaudeContentBlock;
 exports.readClaudeTranscriptRecord = readClaudeTranscriptRecord;
 exports.parseClaudeTranscript = parseClaudeTranscript;
 exports.isClaudePromptRecord = isClaudePromptRecord;
 exports.isClaudeOperatorPromptRecord = isClaudeOperatorPromptRecord;
+exports.isClaudeTurnClosingRecord = isClaudeTurnClosingRecord;
+exports.isClaudeTurnWritable = isClaudeTurnWritable;
 exports.createClaudeTurn = createClaudeTurn;
 exports.buildClaudeTurns = buildClaudeTurns;
 exports.renderClaudeTurn = renderClaudeTurn;
@@ -111,18 +117,97 @@ exports.CLAUDE_THINKING_LABEL = 'Thinking';
 /**
  * Prefixes that mark a `type: "user"` record as bookkeeping rather than a prompt.
  *
- * All four were observed on real transcripts. `<local-command-caveat>` and the
- * `<command-…>` trio are how a slash command is recorded; `<local-command-stdout>`
- * is its output. Treating any of them as a prompt would open a turn that the
- * operator never typed, and the reply to the *next* real prompt would be filed
- * under it.
+ * Three since Issue #2265, which took `<command-message>` off the list — see
+ * {@link CLAUDE_SLASH_COMMAND_PREFIX} for the census that separated the two
+ * shapes the `<command-…>` trio is written in. What is left is the bookkeeping
+ * of a **built-in** command: `<command-name>` first is how Claude records
+ * `/model`, `/compact`, `/clear`, `/login` and `/plan`, `<local-command-stdout>`
+ * is that command's output, and `<local-command-caveat>` is the preamble in
+ * front of it. Treating any of them as a prompt would open a turn that the agent
+ * never answers, and the reply to the *next* real prompt would be filed under it.
  */
 const CLAUDE_SYNTHETIC_PROMPT_PREFIXES = [
     '<local-command-caveat>',
     '<local-command-stdout>',
     '<command-name>',
-    '<command-message>',
 ];
+/**
+ * The tag a slash command the operator typed opens with (Issue #2265).
+ *
+ * ## The two shapes, and why the leading tag is the discriminator
+ *
+ * Claude writes the same three tags for two quite different events, and it
+ * writes them in a different **order** for each. Measured over every
+ * `type: "user"` record under `~/.claude/projects` on 2026-09-03 whose text
+ * opens with one of the `<command-…>` tags — 222 records:
+ *
+ * | leading tag | count | `<command-name>` values |
+ * |---|---|---|
+ * | `<command-message>` | 118 | `/orchestrate`, `/release`, `/uat`, `/worktree-cleanup`, `/worktree-new`, `/multi-stage-design-review`, `/cmate-*` |
+ * | `<command-name>` | 104 | `/model`, `/compact`, `/clear`, `/login`, `/plan` |
+ *
+ * The split is exact and it is the split that matters here. The 118 are
+ * *project and user commands* — a `.claude/commands/*.md` or a skill, expanded
+ * into instructions the agent then works through, which is a turn with a reply
+ * in it. The 104 are commands Claude Code executes itself; their whole output is
+ * the `<local-command-stdout>` record that follows and the agent never answers
+ * them.
+ *
+ * Before #2265 both were excluded, on the reading that a slash command is not
+ * "the operator's text". That cost the 118 their entire turn: the reply was
+ * folded into whichever turn came before — already saved, so
+ * `selectUnwrittenClaudeTurns` answered "nothing to write", and the answer *this*
+ * reader gives is also what suppresses the scraper's copy. The measured loss was
+ * a `/release v0.30.1` turn of 7 text blocks and an `/orchestrate` turn of 8,
+ * neither of which reached History by any path at all.
+ *
+ * ## `origin`, and the versions that carry it
+ *
+ * The 118 also answer {@link isClaudeOperatorPromptRecord}, but only on recent
+ * Claude Code: of them, every record from 2.1.238 onwards (46) carries
+ * `origin: {"kind": "human"}` and every record before it (72, versions 2.1.220
+ * … 2.1.235) carries neither marker — those predate the field. On an old
+ * version the turn is still opened and its reply still written; only the `user`
+ * row is skipped, which is #2196's stated degradation and not a new one.
+ */
+exports.CLAUDE_SLASH_COMMAND_PREFIX = '<command-message>';
+/** `<command-name>/release</command-name>` — the command itself. */
+const CLAUDE_COMMAND_NAME_PATTERN = /<command-name>([\s\S]*?)<\/command-name>/;
+/** `<command-args>v0.30.1</command-args>` — absent on a bare invocation. */
+const CLAUDE_COMMAND_ARGS_PATTERN = /<command-args>([\s\S]*?)<\/command-args>/;
+/**
+ * The line the operator typed, rebuilt from a slash-command record (Issue #2265).
+ *
+ * `<command-name>` and `<command-args>` back into `/release v0.30.1`, which is
+ * the string that was in the composer and — for a command CommandMate sent — the
+ * string `sendUserMessage` already wrote to `chat_messages`. That equality is
+ * what makes the `/send` row *adoptable* instead of duplicated: `recordUserTurn`
+ * compares on normalised content, and the raw record text
+ * (`<command-message>release</command-message>\n<command-name>…`) matches nothing
+ * a person ever sent.
+ *
+ * Returns null for anything that is not this shape, including a
+ * `<command-message>` record with no `<command-name>` in it. Null is what keeps
+ * {@link isClaudePromptRecord} from opening a turn it could not name: a record
+ * whose command cannot be read would otherwise reach History as its own XML,
+ * which is exactly the class of mistake #2196's positive-evidence rule exists to
+ * avoid. No such record was observed — all 118 carried both tags.
+ *
+ * @param text - The record's text, as {@link ClaudeTranscriptRecord.text} holds it
+ * @returns `/name args`, `/name` when there are no arguments, or null
+ */
+function claudeSlashCommandPrompt(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith(exports.CLAUDE_SLASH_COMMAND_PREFIX))
+        return null;
+    const name = CLAUDE_COMMAND_NAME_PATTERN.exec(trimmed)?.[1].trim() ?? '';
+    if (name.length === 0)
+        return null;
+    // Absent on a bare invocation, and empty on a command invoked with no
+    // arguments; both mean the prompt is the command name on its own.
+    const args = CLAUDE_COMMAND_ARGS_PATTERN.exec(trimmed)?.[1].trim() ?? '';
+    return args.length === 0 ? name : `${name} ${args}`;
+}
 /**
  * Read one `message.content` element.
  *
@@ -235,6 +320,7 @@ function readClaudeTranscriptRecord(value) {
         isCompactSummary: value.isCompactSummary === true,
         isInterruption: (0, event_mapper_1.readStringField)(value, 'interruptedMessageId') !== null,
         timestampMs: Number.isFinite(parsed) ? parsed : null,
+        stopReason: message ? (0, event_mapper_1.readStringField)(message, 'stop_reason') : null,
         blocks,
         text,
     };
@@ -279,11 +365,19 @@ function parseClaudeTranscript(text) {
  *
  *  - it carries a `tool_result` block — 18 of the 19 user records in the sampled
  *    session were these;
- *  - `isMeta` is true — the image placeholders and the local-command caveat;
- *  - its text opens with one of {@link CLAUDE_SYNTHETIC_PROMPT_PREFIXES} — the
- *    slash-command bookkeeping;
+ *  - `isMeta` is true — the image placeholders, the local-command caveat, and
+ *    the body of the `.claude/commands/*.md` or skill a slash command expands
+ *    to, which arrives on its own record right behind the one below;
+ *  - its text opens with one of {@link CLAUDE_SYNTHETIC_PROMPT_PREFIXES} — a
+ *    built-in command and its output;
  *  - it has no text at all, or no `uuid` to name the turn with.
  *
+ * A record opening with {@link CLAUDE_SLASH_COMMAND_PREFIX} is the fifth case
+ * and the one Issue #2265 changed: it **is** a prompt, because the operator
+ * typed `/release v0.30.1` and the agent answers it at length. It qualifies only
+ * when {@link claudeSlashCommandPrompt} can actually read the command out of it,
+ * so a shape this reader could not name never opens a turn.
+ *
  * Everything else is treated as a prompt, including `[Request interrupted by
  * user]`. That is deliberate: an interruption really does end the turn, and the
  * records after it really do belong to whatever came next.
@@ -300,6 +394,8 @@ function isClaudePromptRecord(record) {
     const text = record.text.trim();
     if (text.length === 0)
         return false;
+    if (text.startsWith(exports.CLAUDE_SLASH_COMMAND_PREFIX))
+        return claudeSlashCommandPrompt(text) !== null;
     return !CLAUDE_SYNTHETIC_PROMPT_PREFIXES.some((prefix) => text.startsWith(prefix));
 }
 /**
@@ -345,6 +441,14 @@ exports.CLAUDE_HUMAN_PROMPT_SOURCES = ['typed', 'queued'];
  * is the pre-#2196 behaviour — an orphaned assistant pair, which is untidy, and
  * not a fabricated user message, which is wrong.
  *
+ * Issue #2265 widened what reaches here by one shape — the project-command
+ * record `isClaudePromptRecord` now accepts — and the rule holds on it without
+ * change: of the 118 such records under `~/.claude/projects` on 2026-09-03, the
+ * 46 written by Claude Code 2.1.238 and later carry `origin: {"kind": "human"}`
+ * and answer true, and the 72 written before the field existed carry no marker
+ * and answer false. The second group loses its `user` row and keeps its reply,
+ * which is this function's designed degradation rather than a new gap.
+ *
  * `isCompactSummary` and `isInterruption` are then checked explicitly even
  * though nothing observed carries a human marker *and* either flag. They are not
  * redundant by construction: compaction and interruption are both things the
@@ -362,16 +466,62 @@ function isClaudeOperatorPromptRecord(record) {
         return record.originKind === exports.CLAUDE_HUMAN_ORIGIN_KIND;
     return record.promptSource !== null && exports.CLAUDE_HUMAN_PROMPT_SOURCES.includes(record.promptSource);
 }
+/**
+ * `message.stop_reason` on the record that ends a reply (Issue #2264).
+ *
+ * The other value this reader cares about is `tool_use`, which is not named as
+ * a constant because nothing branches on it: everything that is not `end_turn`
+ * leaves the turn open.
+ */
+exports.CLAUDE_END_TURN_STOP_REASON = 'end_turn';
+/**
+ * Whether this assistant record is the one that ended the reply (Issue #2264).
+ *
+ * `end_turn` **and** prose on the same record. See
+ * {@link ClaudeTurnAccumulator.closed} for why neither half alone is the rule,
+ * and note that the emptiness test here is the one `renderClaudeTurn` applies to
+ * a text block — a block whose `text` trims to nothing is not rendered, so it
+ * cannot be what makes a turn look finished either.
+ */
+function isClaudeTurnClosingRecord(record) {
+    if (record.type !== 'assistant')
+        return false;
+    if (record.stopReason !== exports.CLAUDE_END_TURN_STOP_REASON)
+        return false;
+    return record.blocks.some((block) => block.type === 'text' && (block.text ?? '').trim().length > 0);
+}
+/**
+ * Whether a writer may record this turn (Issue #2264).
+ *
+ * Either proof that nothing more is coming: the agent said so
+ * ({@link ClaudeTurnAccumulator.closed}), or it has moved on to another prompt
+ * ({@link ClaudeTurnAccumulator.superseded}).
+ */
+function isClaudeTurnWritable(turn) {
+    if (turn.closed || turn.superseded)
+        return true;
+    // No record of this turn said why it stopped, so there is no evidence to
+    // refuse it on. See {@link ClaudeTurnAccumulator.stopReasonObserved}: this is
+    // unreachable against every Claude version measured, and it is what keeps a
+    // version that stops writing the field from silently disabling the reader.
+    return !turn.stopReasonObserved;
+}
 /** A brand-new accumulator for one turn. */
 function createClaudeTurn(record, sessionId) {
     return {
         sessionId: record.sessionId ?? sessionId,
         promptUuid: record.uuid,
         startedAt: record.timestampMs ?? 0,
-        promptText: record.text,
+        // A slash command's record is XML and the operator typed a line; #2265 puts
+        // the line on the turn so that the `user` row reads `/release v0.30.1` and
+        // the `/send` row holding those same bytes is adopted rather than doubled.
+        promptText: claudeSlashCommandPrompt(record.text) ?? record.text,
         promptIsOperatorInput: isClaudeOperatorPromptRecord(record),
         blocks: [],
         assistantRecords: 0,
+        closed: false,
+        superseded: false,
+        stopReasonObserved: false,
         overflowed: false,
     };
 }
@@ -416,6 +566,13 @@ function buildClaudeTurns(records, sessionId) {
             continue;
         }
         current.assistantRecords += 1;
+        // Assigned rather than or-ed, so the value left standing is the *last*
+        // assistant record's answer. A turn that ends on a `tool_use` record after
+        // an earlier `end_turn` — which is what a turn Claude resumed looks like —
+        // is open again, and that is the reading the Issue's census supports.
+        current.closed = isClaudeTurnClosingRecord(record);
+        if (record.stopReason !== null)
+            current.stopReasonObserved = true;
         for (const block of record.blocks) {
             if (current.blocks.length >= exports.MAX_CLAUDE_TURN_BLOCKS) {
                 current.overflowed = true;
@@ -424,6 +581,11 @@ function buildClaudeTurns(records, sessionId) {
             current.blocks.push(block);
         }
     }
+    // Every turn but the last one has a later prompt behind it, and a prompt is
+    // proof the agent moved on. See {@link ClaudeTurnAccumulator.superseded}.
+    for (let index = 0; index < turns.length - 1; index += 1) {
+        turns[index].superseded = true;
+    }
     return { turns, orphanedAssistantRecords, sidechainRecords };
 }
 /**