commandmate 0.30.2 → 0.31.1

package/dist/server/src/lib/hooks/sources/command-code/transcript.js

@@ -0,0 +1,604 @@
+"use strict";
+/**
+ * Turning Command Code's transcript JSONL back into the reply the agent wrote
+ * (Issue #2252, Epic #2249 Phase C).
+ *
+ * The fifth of these readers, after `../claude/transcript` (#2121),
+ * `../codex/transcript` (#2197) and `../antigravity/transcript` (#2198), and the
+ * one whose file looks most like claude's while agreeing with **antigravity**
+ * about the thing that decides the shape of the code: there is no record that
+ * says a turn ended.
+ *
+ * ## What was measured
+ *
+ * Against Command Code **v1.40.1** on 2026-09-03, on the live transcripts in
+ * `tests/fixtures/transcripts/command-code/` (that directory's README says which
+ * bytes are the tool's and which are ours), and against the tool's own bundle
+ * (`dist/cli.mjs`), which is the only complete statement of the writer:
+ *
+ *  1. **The file is `<header>` then entries.** Line 1 is
+ *     `{"type":"session","version":3,"id":…,"timestamp":…,"cwd":…}` and every
+ *     later line is `{"type":…,"id":…,"parentId":…,"timestamp":…,…}`. The
+ *     bundle's `isSessionEntryV3` accepts nine `type`s —
+ *     `message`, `model_change`, `effort_change`, `compaction`,
+ *     `branch_summary`, `custom`, `custom_message`, `label`, `session_info` —
+ *     of which only `message` carries a conversation. See
+ *     {@link COMMAND_CODE_MESSAGE_RECORD_TYPE}.
+ *  2. **`id` is an 8-hex short id, not a uuid** (`cb06ab09`), minted by
+ *     `generateEntryId` with a collision check against the ids already in the
+ *     file. `parentId` chains each entry to the previous one in file order — it
+ *     is not a reply-to pointer — so turns are built from order, exactly as
+ *     claude's are.
+ *  3. **`message.meta.source` is the record's provenance**, and it is a first
+ *     class field rather than something to infer: `user` for the operator's own
+ *     prompt, `model` for the agent, `tool` for a `tool_result` carrier, and —
+ *     from the bundle's agent loop — `steering` and `followup` for prompts the
+ *     loop appends on the operator's behalf. `meta` also carries `createdAt`
+ *     (epoch ms, when the message was *made*), `messageId`, `isMeta`,
+ *     `isSummary` and `isAutomated`.
+ *  4. **The entry `timestamp` is when the entry was appended to the store, not
+ *     when the message was made.** The writer buffers: `persistEntry` writes
+ *     nothing at all until the first *assistant* message entry, and then flushes
+ *     the header and everything before it in one `writeWholeFile`. In the
+ *     captured session that gave the prompt, the reply and the tool result the
+ *     same `timestamp` and three different `meta.createdAt`s. So
+ *     {@link CommandCodeTranscriptRecord.timestampMs} prefers `createdAt`.
+ *  5. **There is no `stop_reason`.** claude's #2264 gate reads
+ *     `message.stop_reason`; Command Code persists no such field on any record,
+ *     and grepping the capture confirms it. What the bundle *does* show is the
+ *     loop's own end condition — `if(!A){const e="max_tokens"===x.stopReason?
+ *     "max_tokens":"end_turn"; … runOnStop(…)}` where `A` is `hadToolCalls` —
+ *     so "the model's last message asked for no tool" **is** the end of the
+ *     turn, it simply is not written down. That is
+ *     {@link isCommandCodeTurnClosingRecord}, and it is the same rule
+ *     `../antigravity/transcript` arrived at for the same reason.
+ *
+ * ## Re-measured on v1.49.0 (Issue #2304)
+ *
+ * All five facts above still hold, unchanged, nine minor versions later: same
+ * `version: 3` header, same `type: session` / `type: message` split, same
+ * `message.meta` fields, same `thinking` / `text` / `tool_use` / `tool_result`
+ * content blocks, still no `stop_reason` anywhere. The capture is
+ * `hook-session-1490.jsonl` in the fixtures directory, taken from the same live
+ * run whose hook payloads are `hook-payloads-1490.json`, and no change to this
+ * module was needed for it.
+ *
+ * What *did* change is the directory around the file: 1.49.0 writes
+ * `<session_id>.meta.json` and `<session_id>.checkpoints.jsonl` beside the
+ * transcript, and 1.40.1 wrote neither. Neither is this module's problem —
+ * `./history`'s scan matches `<session_id>.jsonl` exactly — but the checkpoints
+ * file is worth one sentence here because it is the one that could reach this
+ * parser: its rows are `{id, messageId, turnNumber, createdAt, prompt,
+ * messageCount, files}` with **no `type` field at all**, so
+ * {@link readCommandCodeTranscriptRecord} declines every one of them and
+ * {@link parseCommandCodeTranscript} answers zero records. Measured, not
+ * assumed. That is what makes the fail-open hold without a fourth condition on
+ * `acceptCommandCodeTranscriptHint`, which the file's `.jsonl` suffix would
+ * otherwise satisfy.
+ *
+ * ## Pure on purpose
+ *
+ * No filesystem, no database, no `globalThis` — `./history` owns all three. The
+ * consequence is that "the saved body equals the transcript's text" is a
+ * property a test can assert against a fixture rather than a claim, which is why
+ * all four of its siblings are written this way.
+ *
+ * @module lib/hooks/sources/command-code/transcript
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMAND_CODE_THINKING_LABEL = exports.MAX_COMMAND_CODE_TOOL_DETAIL_LENGTH = exports.MAX_COMMAND_CODE_TURN_BLOCKS = exports.COMMAND_CODE_TURN_TRUNCATION_MARKER = exports.MAX_COMMAND_CODE_TURN_BODY_LENGTH = exports.COMMAND_CODE_OPERATOR_MESSAGE_SOURCE = exports.COMMAND_CODE_MESSAGE_RECORD_TYPE = exports.COMMAND_CODE_SESSION_RECORD_TYPE = exports.COMMAND_CODE_TRANSCRIPT_EXTENSION = exports.COMMAND_CODE_PROJECTS_DIR_SEGMENTS = void 0;
+exports.readCommandCodeContentBlock = readCommandCodeContentBlock;
+exports.readCommandCodeTranscriptRecord = readCommandCodeTranscriptRecord;
+exports.parseCommandCodeTranscript = parseCommandCodeTranscript;
+exports.isCommandCodePromptRecord = isCommandCodePromptRecord;
+exports.isCommandCodeOperatorPromptRecord = isCommandCodeOperatorPromptRecord;
+exports.isCommandCodeTurnClosingRecord = isCommandCodeTurnClosingRecord;
+exports.isCommandCodeTurnWritable = isCommandCodeTurnWritable;
+exports.createCommandCodeTurn = createCommandCodeTurn;
+exports.buildCommandCodeTurns = buildCommandCodeTurns;
+exports.renderCommandCodeTurn = renderCommandCodeTurn;
+const event_mapper_1 = require("../event-mapper");
+const turn_body_1 = require("../turn-body");
+/**
+ * `~/.commandcode/projects` — the directory Command Code keeps one project's
+ * sessions in, relative to the home directory.
+ *
+ * **The leaf below it is not computable and this module never tries.** The
+ * bundle's `getProjectDirName` is `slugify(cwd)`, and the captured pair shows
+ * that `slugify` splits camel case as well as replacing separators
+ * (`…/MyCodeBranchDesk/probe` → `…-my-code-branch-desk-probe`), which is a
+ * different function from claude's byte-for-byte `[^A-Za-z0-9] → -`.
+ * Reimplementing an unpublished slug would be a rule that silently stops
+ * matching the day Command Code changes it; `./history` looks the session id up
+ * on the filesystem instead.
+ */
+exports.COMMAND_CODE_PROJECTS_DIR_SEGMENTS = ['.commandcode', 'projects'];
+/** `.jsonl`; the only extension this reader will open. */
+exports.COMMAND_CODE_TRANSCRIPT_EXTENSION = '.jsonl';
+/** The header line's `type`. Carries the session id and the `cwd`. */
+exports.COMMAND_CODE_SESSION_RECORD_TYPE = 'session';
+/** The only entry `type` that carries a conversation. */
+exports.COMMAND_CODE_MESSAGE_RECORD_TYPE = 'message';
+/**
+ * `message.meta.source` for a record the person at the keyboard produced.
+ *
+ * The positive evidence {@link isCommandCodeOperatorPromptRecord} requires; see
+ * that function for the census behind choosing an allow list over a deny list.
+ */
+exports.COMMAND_CODE_OPERATOR_MESSAGE_SOURCE = 'user';
+/** Longest body written for one turn. Same bound and reason as claude's. */
+exports.MAX_COMMAND_CODE_TURN_BODY_LENGTH = 200_000;
+/** Appended when {@link MAX_COMMAND_CODE_TURN_BODY_LENGTH} truncates a turn. */
+exports.COMMAND_CODE_TURN_TRUNCATION_MARKER = '\n\n_(truncated)_';
+/**
+ * Cap on content blocks kept for one turn.
+ *
+ * claude's number, for a reason that carries over unchanged: the overflow is
+ * reported rather than hidden, so the bound only has to be far above a real
+ * turn, and one round of Command Code's loop already produced three blocks
+ * (`thinking`, `tool_use`, `tool_use`) on a single record.
+ */
+exports.MAX_COMMAND_CODE_TURN_BLOCKS = 2048;
+/** Longest tool detail put on a summary line. */
+exports.MAX_COMMAND_CODE_TOOL_DETAIL_LENGTH = 200;
+/** The label a thinking block is folded behind. The same word the others use. */
+exports.COMMAND_CODE_THINKING_LABEL = 'Thinking';
+/**
+ * The fields of a `tool_use` input worth putting on the summary line, in
+ * preference order.
+ *
+ * The first two are measured on this tool: `shell_command` carries `command` and
+ * `description`, and the file tools (`write_file` / `read_file` / `edit_file`)
+ * carry `file_path` — the bundle's own `fileArgOf` is `input.file_path ??
+ * input.path`, which is why `path` follows it. The rest are the same fall-back
+ * order claude's reader uses, and every one of them is a *miss* rather than a
+ * mistake: a tool whose input matches none of them renders as the bare tool
+ * name, which is what the operator saw on the TUI's tool row anyway.
+ */
+const COMMAND_CODE_TOOL_DETAIL_FIELDS = [
+    'command',
+    'file_path',
+    'path',
+    'pattern',
+    'query',
+    'url',
+    'description',
+];
+/**
+ * Read one `message.content` element.
+ *
+ * @returns The block, or null when it is not an object with a `type`
+ */
+function readCommandCodeContentBlock(value) {
+    if (!(0, event_mapper_1.isPlainObject)(value))
+        return null;
+    const type = (0, event_mapper_1.readStringField)(value, 'type');
+    if (!type)
+        return null;
+    if (type === 'tool_use') {
+        return {
+            type,
+            text: null,
+            toolName: (0, event_mapper_1.readStringField)(value, 'name'),
+            toolDetail: readToolDetail(value.input),
+        };
+    }
+    // `text` on a text block, `thinking` on a thinking block. Read by name rather
+    // than by trying both on every block, so that a future block type carrying an
+    // unrelated `text` field is not silently rendered as prose. Note that a
+    // `tool_result` block *does* carry nested `content[].text` on this tool and is
+    // deliberately not reached by either lookup.
+    const text = type === 'text'
+        ? ((0, event_mapper_1.readStringField)(value, 'text') ?? '')
+        : type === 'thinking'
+            ? ((0, event_mapper_1.readStringField)(value, 'thinking') ?? '')
+            : null;
+    return { type, text, toolName: null, toolDetail: null };
+}
+/** The first present detail field of a `tool_use` input, collapsed to a line. */
+function readToolDetail(input) {
+    if (!(0, event_mapper_1.isPlainObject)(input))
+        return null;
+    for (const field of COMMAND_CODE_TOOL_DETAIL_FIELDS) {
+        const value = (0, event_mapper_1.readStringField)(input, field);
+        if (value)
+            return boundToolDetail(collapseToLine(value));
+    }
+    return null;
+}
+/** A tool detail on one line. A heredoc `command` puts newlines in it. */
+function collapseToLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function boundToolDetail(value) {
+    return value.length <= exports.MAX_COMMAND_CODE_TOOL_DETAIL_LENGTH
+        ? value
+        : `${value.slice(0, exports.MAX_COMMAND_CODE_TOOL_DETAIL_LENGTH - 1)}…`;
+}
+/** `message.meta`, when the entry has one. */
+function readMessageMeta(message) {
+    if (!message)
+        return null;
+    return (0, event_mapper_1.isPlainObject)(message.meta) ? message.meta : null;
+}
+/**
+ * Read one parsed transcript line.
+ *
+ * @returns The record, or null when the value is not an object with a `type`
+ */
+function readCommandCodeTranscriptRecord(value) {
+    if (!(0, event_mapper_1.isPlainObject)(value))
+        return null;
+    const type = (0, event_mapper_1.readStringField)(value, 'type');
+    if (!type)
+        return null;
+    const isHeader = type === exports.COMMAND_CODE_SESSION_RECORD_TYPE;
+    const message = (0, event_mapper_1.isPlainObject)(value.message) ? value.message : null;
+    const meta = readMessageMeta(message);
+    const rawContent = message?.content;
+    const blocks = [];
+    let text = '';
+    if (typeof rawContent === 'string') {
+        // Not observed on v1.40.1 — every captured `content` is an array — but the
+        // bundle's own `hasValidV2Content` accepts a bare string for a non-tool
+        // role, so a session migrated from the v1/v2 format can hold one.
+        text = rawContent;
+    }
+    else if (Array.isArray(rawContent)) {
+        for (const entry of rawContent) {
+            const block = readCommandCodeContentBlock(entry);
+            if (!block)
+                continue;
+            blocks.push(block);
+            if (block.type === 'text' && block.text)
+                text += block.text;
+        }
+    }
+    const timestamp = (0, event_mapper_1.readStringField)(value, 'timestamp');
+    const parsedTimestamp = timestamp ? Date.parse(timestamp) : NaN;
+    const createdAt = meta && typeof meta.createdAt === 'number' ? meta.createdAt : null;
+    return {
+        type,
+        // The header's `id` is the session id, not an entry id, so it must not
+        // become a turn key. Only `message` entries and their siblings have one.
+        id: isHeader ? null : (0, event_mapper_1.readStringField)(value, 'id'),
+        parentId: (0, event_mapper_1.readStringField)(value, 'parentId'),
+        role: message ? (0, event_mapper_1.readStringField)(message, 'role') : null,
+        sessionId: isHeader ? (0, event_mapper_1.readStringField)(value, 'id') : null,
+        cwd: isHeader ? (0, event_mapper_1.readStringField)(value, 'cwd') : null,
+        parentSession: isHeader ? (0, event_mapper_1.readStringField)(value, 'parentSession') : null,
+        source: meta ? (0, event_mapper_1.readStringField)(meta, 'source') : null,
+        isMeta: meta?.isMeta === true,
+        isSummary: meta?.isSummary === true,
+        isAutomated: meta?.isAutomated === true,
+        timestampMs: createdAt !== null && Number.isFinite(createdAt)
+            ? createdAt
+            : Number.isFinite(parsedTimestamp)
+                ? parsedTimestamp
+                : null,
+        blocks,
+        text,
+    };
+}
+/**
+ * Parse a slice of a transcript file, one line at a time.
+ *
+ * A line that does not parse is counted and dropped; the rest of the slice is
+ * still read. That is the entire answer to "the file is being appended to while
+ * we read it": the only line a concurrent write can damage is the last one, and
+ * the cost of losing it is that this turn is written on the next poll instead of
+ * this one.
+ *
+ * @param text - The bytes read, decoded as UTF-8
+ */
+function parseCommandCodeTranscript(text) {
+    const records = [];
+    let malformedLines = 0;
+    let sessionId = null;
+    let cwd = null;
+    let parentSession = null;
+    for (const line of text.split('\n')) {
+        if (line.trim().length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            malformedLines += 1;
+            continue;
+        }
+        const record = readCommandCodeTranscriptRecord(parsed);
+        if (!record) {
+            malformedLines += 1;
+            continue;
+        }
+        records.push(record);
+        if (record.sessionId) {
+            sessionId = record.sessionId;
+            cwd = record.cwd;
+            parentSession = record.parentSession;
+        }
+    }
+    return { records, malformedLines, sessionId, cwd, parentSession };
+}
+/**
+ * Whether this record opens a turn.
+ *
+ * Command Code's own rule, taken verbatim from its bundle —
+ * `isFreshUserTurn(e) = "user" === e.role && !e.content.some(e => "tool_result"
+ * === e.type)` — plus the three guards a *reader* needs that the tool does not:
+ *
+ *  - it must be a `message` entry, because `label` / `session_info` /
+ *    `model_change` carry no conversation;
+ *  - it must have an `id`, because that is the turn key and an invented one is a
+ *    row no later run can recognise as already written;
+ *  - it must have text, because a turn with no prompt in it is a turn this
+ *    reader cannot name in History.
+ *
+ * `meta.isMeta` disqualifies it too: that is the flag the tool's own
+ * `filterVisibleMessages` hides a record on, so a record Command Code does not
+ * show the operator is not one CommandMate should open a turn on.
+ *
+ * Deliberately **wider** than {@link isCommandCodeOperatorPromptRecord}: a
+ * `steering` or `followup` prompt really is answered, and the reply really does
+ * belong to it. The narrower question is "should this text appear as the
+ * operator's message", which is asked separately and has a different cost of
+ * being wrong.
+ */
+function isCommandCodePromptRecord(record) {
+    if (record.type !== exports.COMMAND_CODE_MESSAGE_RECORD_TYPE)
+        return false;
+    if (record.role !== 'user')
+        return false;
+    if (record.isMeta)
+        return false;
+    if (!record.id)
+        return false;
+    // Command Code's own boundary. A user record that carries tool output is the
+    // agent's loop feeding itself, not a new question — the captured turn has one
+    // such record carrying two `tool_result` blocks.
+    if (record.blocks.some((block) => block.type === 'tool_result'))
+        return false;
+    return record.text.trim().length > 0;
+}
+/**
+ * Whether this record is text a human typed at the terminal (the #2196 rule).
+ *
+ * ## Positive evidence, not a deny list
+ *
+ * The rule is `meta.source === "user"`, and a record that claims anything else —
+ * or nothing at all — produces no `user` row. That direction is the one #2196
+ * settled for claude and it is *better* supported here, because Command Code
+ * stamps the provenance itself rather than leaving it to be inferred: the
+ * bundle's composer path writes `meta:{source:"user",createdAt:Date.now(),…}`,
+ * and the agent loop writes `source:"steering"` for text queued while a turn was
+ * running and `source:"followup"` for a prompt it appends on the operator's
+ * behalf. Both of those pass {@link isCommandCodePromptRecord} — they are
+ * genuinely turns — and neither is something a person put in the chat pane.
+ *
+ * A deny list would default a shape a later Command Code invents to *being
+ * shown*; this defaults to being skipped, which costs the `user` row and keeps
+ * the reply — the designed degradation rather than a fabricated message.
+ *
+ * `isSummary` and `isAutomated` are then checked explicitly even though nothing
+ * observed carries `source: "user"` *and* either flag. They are not redundant by
+ * construction: compaction is something the operator initiates, so a later
+ * version stamping `source: "user"` on the summary it produces would be
+ * defensible from Command Code's side and wrong from this one's.
+ */
+function isCommandCodeOperatorPromptRecord(record) {
+    if (!isCommandCodePromptRecord(record))
+        return false;
+    if (record.isSummary)
+        return false;
+    if (record.isAutomated)
+        return false;
+    return record.source === exports.COMMAND_CODE_OPERATOR_MESSAGE_SOURCE;
+}
+/**
+ * Whether this assistant record is the one that ended the reply (Issue #2264).
+ *
+ * Prose, and **no `tool_use` block beside it**. See
+ * {@link CommandCodeTurnAccumulator.closed} for why neither half alone is the
+ * rule, and note that the emptiness test here is the one
+ * {@link renderCommandCodeTurn} 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 isCommandCodeTurnClosingRecord(record) {
+    if (record.type !== exports.COMMAND_CODE_MESSAGE_RECORD_TYPE)
+        return false;
+    if (record.role !== 'assistant')
+        return false;
+    if (record.blocks.some((block) => block.type === 'tool_use'))
+        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 finished answering
+ * ({@link CommandCodeTurnAccumulator.closed}), or it has moved on to another
+ * prompt ({@link CommandCodeTurnAccumulator.superseded}).
+ *
+ * No third branch. claude's equivalent keeps one — a turn whose records carried
+ * no `stop_reason` at all is written anyway, so that a Claude release which
+ * dropped the field could not switch the reader off silently — and that escape
+ * hatch has nothing to guard here: this rule reads no optional field, only the
+ * presence of block types the render path already depends on. If `tool_use`
+ * were renamed the bodies would be wrong long before the gate was.
+ * `../antigravity/transcript` reaches the same two-branch predicate for the same
+ * reason.
+ */
+function isCommandCodeTurnWritable(turn) {
+    return turn.closed || turn.superseded;
+}
+/** A brand-new accumulator for one turn. */
+function createCommandCodeTurn(record, sessionId) {
+    return {
+        sessionId,
+        promptId: record.id,
+        startedAt: record.timestampMs ?? 0,
+        promptText: record.text,
+        promptIsOperatorInput: isCommandCodeOperatorPromptRecord(record),
+        blocks: [],
+        assistantRecords: 0,
+        closed: false,
+        superseded: false,
+        overflowed: false,
+    };
+}
+/**
+ * Group a transcript's records into turns.
+ *
+ * File order, and a prompt record opens a turn. Deliberately **not** the
+ * `parentId` chain: the bundle sets `parentId` to `lastEntryId` — the entry
+ * before this one, whatever it was — so it links a reply to a tool result as
+ * readily as to its prompt, and following it would rebuild file order the long
+ * way round. `../claude/transcript` gives the same reasoning for the same
+ * decision.
+ *
+ * @param records - In file order
+ * @param sessionId - Fallback for a window that did not include the header
+ */
+function buildCommandCodeTurns(records, sessionId) {
+    const turns = [];
+    const seenIds = new Set();
+    let current = null;
+    let orphanedAssistantRecords = 0;
+    let unresolvedParentRecords = 0;
+    let nonMessageRecords = 0;
+    let resolvedSessionId = sessionId;
+    for (const record of records) {
+        if (record.sessionId) {
+            resolvedSessionId = record.sessionId;
+            continue;
+        }
+        if (record.type !== exports.COMMAND_CODE_MESSAGE_RECORD_TYPE) {
+            nonMessageRecords += 1;
+            if (record.id)
+                seenIds.add(record.id);
+            continue;
+        }
+        if (record.parentId !== null && !seenIds.has(record.parentId)) {
+            unresolvedParentRecords += 1;
+        }
+        if (record.id)
+            seenIds.add(record.id);
+        if (isCommandCodePromptRecord(record)) {
+            current = createCommandCodeTurn(record, resolvedSessionId);
+            turns.push(current);
+            continue;
+        }
+        if (record.role !== 'assistant')
+            continue;
+        if (!current) {
+            orphanedAssistantRecords += 1;
+            continue;
+        }
+        current.assistantRecords += 1;
+        // Assigned rather than or-ed, so the value left standing is the *last*
+        // assistant record's answer. See {@link CommandCodeTurnAccumulator.closed}.
+        current.closed = isCommandCodeTurnClosingRecord(record);
+        for (const block of record.blocks) {
+            if (current.blocks.length >= exports.MAX_COMMAND_CODE_TURN_BLOCKS) {
+                current.overflowed = true;
+                break;
+            }
+            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 CommandCodeTurnAccumulator.superseded}.
+    for (let index = 0; index < turns.length - 1; index += 1) {
+        turns[index].superseded = true;
+    }
+    return { turns, orphanedAssistantRecords, unresolvedParentRecords, nonMessageRecords };
+}
+/**
+ * Block types that carry nothing a reader wants.
+ *
+ * A deny set rather than an allow set, for the reason the other four readers
+ * give: a block type a later Command Code adds should surface in the unknown
+ * tally instead of being silently equivalent to a tool result. `tool_result` is
+ * on it because those blocks live on `user` records, which never reach a turn's
+ * body.
+ */
+const COMMAND_CODE_SILENT_BLOCK_TYPES = new Set(['tool_result']);
+/** One tool call as a single Markdown line. */
+function renderToolBlock(block) {
+    const name = block.toolName ?? 'tool';
+    return block.toolDetail ? `- \`${name}\` — ${block.toolDetail}` : `- \`${name}\``;
+}
+/**
+ * Thinking, folded.
+ *
+ * A blockquote and not `<details>`, for the reason `../turn-body` documents: the
+ * card renders with no `rehypeRaw`, so a `<details>` wrapper is dropped whole
+ * and takes its summary text with it.
+ */
+function renderThinkingBlock(text) {
+    const quoted = text
+        .trim()
+        .split('\n')
+        .map((line) => (line.length > 0 ? `> ${line}` : '>'))
+        .join('\n');
+    return `> **${exports.COMMAND_CODE_THINKING_LABEL}**\n>\n${quoted}`;
+}
+/**
+ * Render one turn to Markdown.
+ *
+ * Every block is kept, and the layout belongs to `../turn-body` (#2234): prose
+ * leads, thinking stays where it was written as a folded quote, and the tool
+ * calls become one labelled section at the end. Command Code needs that
+ * separation more than most — its captured turn opens with `thinking` and two
+ * `tool_use` blocks and does not reach prose until the *next* record, so a body
+ * in transcript order would open with a tool log every time.
+ */
+function renderCommandCodeTurn(turn) {
+    const rendered = [];
+    const unknown = new Set();
+    let textBlocks = 0;
+    let toolBlocks = 0;
+    for (const block of turn.blocks) {
+        if (block.type === 'text') {
+            const text = block.text?.trim() ?? '';
+            if (text.length === 0)
+                continue;
+            rendered.push({ kind: 'prose', text });
+            textBlocks += 1;
+            continue;
+        }
+        if (block.type === 'thinking') {
+            // Measured empty on this tool as well as on claude: the captured blocks
+            // carry `signature: ""` and the text is not always retained.
+            const text = block.text?.trim() ?? '';
+            if (text.length === 0)
+                continue;
+            rendered.push({ kind: 'aside', text: renderThinkingBlock(text) });
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            rendered.push({ kind: 'tool', text: renderToolBlock(block) });
+            toolBlocks += 1;
+            continue;
+        }
+        if (!COMMAND_CODE_SILENT_BLOCK_TYPES.has(block.type))
+            unknown.add(block.type);
+    }
+    let body = (0, turn_body_1.separateTurnBody)(rendered).body;
+    if (body.length > exports.MAX_COMMAND_CODE_TURN_BODY_LENGTH) {
+        body =
+            body.slice(0, exports.MAX_COMMAND_CODE_TURN_BODY_LENGTH - exports.COMMAND_CODE_TURN_TRUNCATION_MARKER.length) +
+                exports.COMMAND_CODE_TURN_TRUNCATION_MARKER;
+    }
+    return {
+        sessionId: turn.sessionId,
+        promptId: turn.promptId,
+        body,
+        textBlocks,
+        toolBlocks,
+        unknownBlockTypes: [...unknown],
+    };
+}

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

@@ -12,7 +12,7 @@
  * @module lib/hooks/sources
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_CLI_TOOL_ID = exports.CODEX_CLI_TOOL_ID = exports.ANTIGRAVITY_CLI_TOOL_ID = exports.GEMINI_CLI_TOOL_ID = exports.COPILOT_CLI_TOOL_ID = exports.CLAUDE_CLI_TOOL_ID = exports.isAbstainSafe = exports.describeNoDecision = exports.describeAbstain = exports.resetPendingDecisions = exports.openDecisionSlot = exports.listOpenDecisions = exports.closeDecisionSlot = exports.answerPendingDecision = exports.TOOL_CALL_ID_FIELDS = exports.SESSION_ID_FIELDS = exports.extractSnakeCaseEventDetail = exports.CAMEL_CASE_HOOK_EVENT_NAMES = exports.whenNamed = exports.runEventMappers = exports.resetUnknownEventTallies = exports.readStringField = exports.readNestedString = exports.readFirstStringField = exports.isPlainObject = exports.getUnknownEventTally = exports.fromNameTable = exports.boundDetail = exports.renderAgentLaunchCommand = exports.HOOK_PORT_ENV_VAR = exports.COMMANDMATE_HOOK_ENV_VARS = exports.AGENT_EVENT_URL_ENV_VAR = exports.definePushHookSource = exports.definePullEventSource = exports.unregisterAgentEventSource = exports.registerAgentEventSource = exports.listAgentEventSources = exports.hasAgentEventSource = exports.getAgentEventSource = void 0;
+exports.COMMAND_CODE_CLI_TOOL_ID = exports.OPENCODE_CLI_TOOL_ID = exports.CODEX_CLI_TOOL_ID = exports.ANTIGRAVITY_CLI_TOOL_ID = exports.GEMINI_CLI_TOOL_ID = exports.COPILOT_CLI_TOOL_ID = exports.CLAUDE_CLI_TOOL_ID = exports.isAbstainSafe = exports.describeNoDecision = exports.describeAbstain = exports.resetPendingDecisions = exports.openDecisionSlot = exports.listOpenDecisions = exports.closeDecisionSlot = exports.answerPendingDecision = exports.TOOL_CALL_ID_FIELDS = exports.SESSION_ID_FIELDS = exports.extractSnakeCaseEventDetail = exports.CAMEL_CASE_HOOK_EVENT_NAMES = exports.whenNamed = exports.runEventMappers = exports.resetUnknownEventTallies = exports.readStringField = exports.readNestedString = exports.readFirstStringField = exports.isPlainObject = exports.getUnknownEventTally = exports.fromNameTable = exports.boundDetail = exports.renderAgentLaunchCommand = exports.HOOK_PORT_ENV_VAR = exports.COMMANDMATE_HOOK_ENV_VARS = exports.AGENT_EVENT_URL_ENV_VAR = exports.definePushHookSource = exports.definePullEventSource = exports.unregisterAgentEventSource = exports.registerAgentEventSource = exports.listAgentEventSources = exports.hasAgentEventSource = exports.getAgentEventSource = void 0;
 var registry_1 = require("./registry");
 Object.defineProperty(exports, "getAgentEventSource", { enumerable: true, get: function () { return registry_1.getAgentEventSource; } });
 Object.defineProperty(exports, "hasAgentEventSource", { enumerable: true, get: function () { return registry_1.hasAgentEventSource; } });
@@ -65,3 +65,5 @@ var tool_id_5 = require("./codex/tool-id");
 Object.defineProperty(exports, "CODEX_CLI_TOOL_ID", { enumerable: true, get: function () { return tool_id_5.CODEX_CLI_TOOL_ID; } });
 var tool_id_6 = require("./opencode/tool-id");
 Object.defineProperty(exports, "OPENCODE_CLI_TOOL_ID", { enumerable: true, get: function () { return tool_id_6.OPENCODE_CLI_TOOL_ID; } });
+var tool_id_7 = require("./command-code/tool-id");
+Object.defineProperty(exports, "COMMAND_CODE_CLI_TOOL_ID", { enumerable: true, get: function () { return tool_id_7.COMMAND_CODE_CLI_TOOL_ID; } });