commandmate 0.30.1 → 0.30.2

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

@@ -532,12 +532,31 @@ function resolveAssistantTimestampMs(turn, userRow) {
  */
 async function writeAntigravityTurn(target, turn, rendered, timestampMs, path) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    if (!(0, transcript_1.isAntigravityTurnWritable)(turn)) {
+        // agy has not finished this answer 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 `(conversationId, step_index)`, so every later read finds it and
+        // answers "already saved". That is Issue #2264, reported against claude and
+        // structurally identical here: a turn cut off after its `tool_calls` renders
+        // a *non-empty* body, so the emptiness guard below cannot see it.
+        logger.info('antigravity-transcript-turn-open', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            conversationId: rendered.conversationId,
+            stepIndex: rendered.stepIndex,
+            records: turn.records.length,
+            textBlocks: rendered.textBlocks,
+            toolBlocks: rendered.toolBlocks,
+        });
+        return false;
+    }
     if (rendered.body.length === 0) {
-        // A turn that said nothing yet. Unlike codex there is no `task_complete` to
-        // tell an unfinished turn from a silent one, so the body is the only
-        // evidence there is — and answering false is right for both readings: the
-        // scraper keeps the reply if there was one, and an empty row that would show
-        // as a blank answer forever is never written.
+        // A turn that said nothing. agy has no `task_complete`, so a closed turn
+        // that rendered to nothing and an interrupted one look alike here — and
+        // answering false is right for both readings: the scraper keeps the reply if
+        // there was one, and an empty row that would show as a blank answer forever
+        // is never written.
         logger.info('antigravity-transcript-turn-empty', {
             worktreeId: target.worktreeId,
             instanceId,

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

@@ -72,6 +72,8 @@ exports.readAntigravityTranscriptRecord = readAntigravityTranscriptRecord;
 exports.parseAntigravityTranscript = parseAntigravityTranscript;
 exports.extractAntigravityUserRequest = extractAntigravityUserRequest;
 exports.buildAntigravityTurns = buildAntigravityTurns;
+exports.isAntigravityTurnClosingRecord = isAntigravityTurnClosingRecord;
+exports.isAntigravityTurnWritable = isAntigravityTurnWritable;
 exports.isAntigravityPromptRecord = isAntigravityPromptRecord;
 exports.renderAntigravityTurn = renderAntigravityTurn;
 const event_mapper_1 = require("../event-mapper");
@@ -298,6 +300,8 @@ function buildAntigravityTurns(records, conversationId) {
                     ? { stepIndex: record.stepIndex, text, timestampMs: record.timestampMs ?? startedAt }
                     : null,
                 records: [],
+                closed: false,
+                superseded: false,
                 overflowed: false,
             });
             continue;
@@ -307,14 +311,49 @@ function buildAntigravityTurns(records, conversationId) {
             preludeRecords += 1;
             continue;
         }
+        // Assigned rather than or-ed, so what survives is the last `MODEL` record's
+        // answer. `SYSTEM` records are ignored here for the same reason they render
+        // to nothing: agy injected them, they are not agy speaking.
+        if (record.source === exports.ANTIGRAVITY_MODEL_SOURCE) {
+            turn.closed = isAntigravityTurnClosingRecord(record);
+        }
         if (turn.records.length >= exports.MAX_ANTIGRAVITY_TURN_RECORDS) {
             turn.overflowed = true;
             continue;
         }
         turn.records.push(record);
     }
+    // Every turn but the last has a later prompt behind it, and a prompt is proof
+    // agy moved on. See {@link AntigravityTurnAccumulator.superseded}.
+    for (let index = 0; index < turns.length - 1; index += 1) {
+        turns[index].superseded = true;
+    }
     return { turns, preludeRecords };
 }
+/**
+ * Whether this `MODEL` record is agy finishing its answer (Issue #2264).
+ *
+ * See {@link AntigravityTurnAccumulator.closed} for the argument; the emptiness
+ * test is the one {@link renderAntigravityTurn} applies to `content`, so a
+ * record that renders to nothing cannot be what makes a turn look finished.
+ */
+function isAntigravityTurnClosingRecord(record) {
+    if (record.source !== exports.ANTIGRAVITY_MODEL_SOURCE)
+        return false;
+    if (record.type !== exports.ANTIGRAVITY_PLANNER_TYPE)
+        return false;
+    if (record.toolCalls.length > 0)
+        return false;
+    return (record.content ?? '').trim().length > 0;
+}
+/**
+ * Whether a writer may record this turn (Issue #2264).
+ *
+ * Either proof that nothing more is coming — agy answered, or it moved on.
+ */
+function isAntigravityTurnWritable(turn) {
+    return turn.closed || turn.superseded;
+}
 /** Whether this record is the one the operator's own text arrived on. */
 function isAntigravityPromptRecord(record) {
     return record.source === exports.ANTIGRAVITY_USER_SOURCE && record.type === exports.ANTIGRAVITY_USER_TYPE;

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
@@ -357,7 +363,7 @@ async function captureClaudeTranscriptTurn(target, capture) {
             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, userRow), path);
         }
         return captured;
     }
@@ -493,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,
     };
 }
@@ -717,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.
  *
@@ -731,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
@@ -762,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, {

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 };
 }
 /**