commandmate 0.29.2 → 0.30.0

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

@@ -0,0 +1,448 @@
+"use strict";
+/**
+ * Turning codex's rollout JSONL back into the reply the agent wrote
+ * (Issue #2197).
+ *
+ * The third of these readers, after `../opencode/transcript` (#2041, push) and
+ * `../claude/transcript` (#2121, pull). Same job, same reason: the poller can
+ * only ever save a *rendering* of the reply — the agent's Markdown after its TUI
+ * has wrapped it to the pane width, drawn `•` bullets in front of it and run a
+ * spinner through it — while the agent itself writes the source down as it goes.
+ *
+ * ## Two parallel streams in one file, and why only one is read
+ *
+ * A rollout file is a sequence of `{ordinal, timestamp, type, payload}` lines,
+ * and it holds the same conversation **twice**:
+ *
+ *  - `type: "response_item"` — what was sent to the model. `message` records
+ *    with `role: developer | user | assistant`, `reasoning` records whose text
+ *    is encrypted, `custom_tool_call` / `custom_tool_call_output` pairs.
+ *  - `type: "event_msg"` with `payload.type: "item_completed"` — what the TUI
+ *    displayed. One `item` per line: `UserMessage`, `AgentMessage`,
+ *    `CommandExecution`, `FileChange`, `McpToolCall`, `Reasoning`, …
+ *
+ * Only the second is read, and that is the load-bearing decision of this module.
+ * Three measurements force it (`docs/design/codex-transcript-reader.md` §2,
+ * against codex-cli 0.151.0 live and 250 archived sessions on 0.142.0…0.151.0):
+ *
+ *  1. **`role: "user"` is mostly not the user.** The `response_item` stream
+ *     carries `<environment_context>`, `<recommended_plugins>` and the AGENTS.md
+ *     instructions as `role: "user"` records. The item stream carries none of
+ *     them: a `UserMessage` item is emitted for the operator's own text and for
+ *     nothing else. That is positive evidence rather than a deny list, which is
+ *     the discipline #2196 settled on for the same question on claude.
+ *  2. **The item stream is the only one with readable tool calls.**
+ *     `custom_tool_call.input` is a JavaScript snippet
+ *     (`const r = await tools.exec_command({...})`); the `CommandExecution` item
+ *     carries the argv and a `parsed_cmd` with the shell line in it.
+ *  3. **`content_item_kinds` — the field that marks a `response_item` as the
+ *     operator's — does not exist before 0.151.0.** It is absent on 0.149.1,
+ *     where the injected and the real `role: "user"` records are otherwise
+ *     identical. A reader built on it would have gone quietly wrong one version
+ *     back.
+ *
+ * `response_item` lines are therefore counted as duplicates of the item stream
+ * and dropped, not reported as unknown. See {@link CodexTurnBuild}.
+ *
+ * ## The turn boundary is written down
+ *
+ * codex stamps a `turn_id` on `task_started`, on every `item_completed`, on
+ * `turn_context` and on `task_complete`. This is the one place codex is easier
+ * to read than claude, which has no link at all from a reply to the prompt it
+ * answers and has to infer the boundary from record order (#2121). Here the
+ * boundary is a field, and a turn is closed by the `task_complete` that carries
+ * its id — measured on 326 of 326 archived turns.
+ *
+ * ## Pure on purpose
+ *
+ * No filesystem, no database, no `globalThis` — `./history` owns all three, the
+ * same split the other two readers use, so "the saved body equals the
+ * transcript's text" is a property a test asserts against a fixture rather than
+ * a claim.
+ *
+ * @module lib/hooks/sources/codex/transcript
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_THINKING_LABEL = exports.MAX_CODEX_TOOL_DETAIL_LENGTH = exports.MAX_CODEX_TURN_ITEMS = exports.CODEX_TURN_TRUNCATION_MARKER = exports.MAX_CODEX_TURN_BODY_LENGTH = exports.CODEX_ROLLOUT_EXTENSION = exports.CODEX_SESSIONS_DIR_SEGMENTS = void 0;
+exports.readCodexRolloutItem = readCodexRolloutItem;
+exports.readCodexRolloutRecord = readCodexRolloutRecord;
+exports.parseCodexRollout = parseCodexRollout;
+exports.buildCodexTurns = buildCodexTurns;
+exports.renderCodexTurn = renderCodexTurn;
+const event_mapper_1 = require("../event-mapper");
+const turn_body_1 = require("../turn-body");
+/** `$CODEX_HOME/sessions` — where codex keeps one machine's rollout files. */
+exports.CODEX_SESSIONS_DIR_SEGMENTS = ['sessions'];
+/** `.jsonl`; the only extension this reader will open. */
+exports.CODEX_ROLLOUT_EXTENSION = '.jsonl';
+/** Longest body written for one turn. Same bound and reason as claude's. */
+exports.MAX_CODEX_TURN_BODY_LENGTH = 200_000;
+/** Appended when {@link MAX_CODEX_TURN_BODY_LENGTH} truncates a turn. */
+exports.CODEX_TURN_TRUNCATION_MARKER = '\n\n_(truncated)_';
+/**
+ * Cap on items kept for one turn.
+ *
+ * The same 2048 claude's reader uses, and generous for the same reason: a codex
+ * turn on the archived corpus ran to 46 `Reasoning` items and 25
+ * `CommandExecution`s, and the overflow is reported rather than hidden.
+ */
+exports.MAX_CODEX_TURN_ITEMS = 2048;
+/** Longest tool detail put on a summary line. */
+exports.MAX_CODEX_TOOL_DETAIL_LENGTH = 200;
+/** The label a reasoning summary is folded behind. Same word claude uses. */
+exports.CODEX_THINKING_LABEL = 'Thinking';
+/**
+ * Read one `item_completed` item.
+ *
+ * @returns The item, or null when the value is not an object with a `type`
+ */
+function readCodexRolloutItem(value) {
+    if (!(0, event_mapper_1.isPlainObject)(value))
+        return null;
+    const type = (0, event_mapper_1.readStringField)(value, 'type');
+    if (!type)
+        return null;
+    return {
+        type,
+        id: (0, event_mapper_1.readStringField)(value, 'id'),
+        text: readItemText(type, value),
+        phase: (0, event_mapper_1.readStringField)(value, 'phase'),
+        detail: readItemDetail(type, value),
+    };
+}
+/**
+ * The prose an item carries, or null.
+ *
+ * Read per item type rather than by trying every text-shaped field on every
+ * item, so that a later codex adding a `text` to a tool item does not silently
+ * start rendering tool output as the agent's prose. `content` is a list of
+ * `{type, text}` on both message items — spelled `"text"` on `UserMessage` and
+ * `"Text"` on `AgentMessage`, which is why the element's own type is not
+ * checked.
+ */
+function readItemText(type, item) {
+    if (type === 'UserMessage' || type === 'AgentMessage') {
+        return joinContentText(item.content);
+    }
+    if (type === 'Reasoning') {
+        // `summary_text` is a list of strings. Measured empty on 12,084 of 12,084
+        // archived reasoning items — the summaries are not retained on this
+        // account — so an empty one is skipped rather than rendered as a blank
+        // quote, exactly as #2121 does for claude's empty `thinking` blocks.
+        return joinStringList(item.summary_text);
+    }
+    return null;
+}
+/** Concatenate a `content` array's `text` fields. */
+function joinContentText(content) {
+    if (!Array.isArray(content))
+        return null;
+    let out = '';
+    for (const entry of content) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const text = (0, event_mapper_1.readStringField)(entry, 'text');
+        if (text)
+            out += text;
+    }
+    return out.length > 0 ? out : null;
+}
+/** Join a list of strings, dropping anything that is not one. */
+function joinStringList(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parts = value.filter((entry) => typeof entry === 'string' && entry !== '');
+    return parts.length > 0 ? parts.join('\n\n') : null;
+}
+/**
+ * The one-line summary of a tool item, or null.
+ *
+ * One rule per measured item type. Every shape below was dumped off a real
+ * rollout rather than read out of a schema — see the design doc's §2.3 table —
+ * and an item type that is not here produces no detail, which is what puts it in
+ * {@link CodexRenderedTurn.unknownBlockTypes} unless it is deliberately silent.
+ */
+function readItemDetail(type, item) {
+    if (type === 'CommandExecution') {
+        // `parsed_cmd[0].cmd` is the shell line codex itself displays; `command` is
+        // the argv it ran it with (`["/bin/zsh","-lc","<the line>"]`). Preferring
+        // the parsed form keeps the summary readable, and the argv is the fallback
+        // for a call codex could not parse.
+        const parsed = readParsedCommand(item.parsed_cmd);
+        if (parsed)
+            return boundDetailText(collapseToLine(parsed));
+        const argv = readArgv(item.command);
+        return argv ? boundDetailText(collapseToLine(argv)) : null;
+    }
+    if (type === 'FileChange') {
+        const changes = item.changes;
+        if (!(0, event_mapper_1.isPlainObject)(changes))
+            return null;
+        const paths = Object.keys(changes);
+        return paths.length > 0 ? boundDetailText(paths.join(', ')) : null;
+    }
+    if (type === 'McpToolCall') {
+        const server = (0, event_mapper_1.readStringField)(item, 'server');
+        const tool = (0, event_mapper_1.readStringField)(item, 'tool');
+        if (!server && !tool)
+            return null;
+        return boundDetailText([server, tool].filter(Boolean).join('.'));
+    }
+    if (type === 'ImageView') {
+        const path = (0, event_mapper_1.readStringField)(item, 'path');
+        return path ? boundDetailText(path) : null;
+    }
+    if (type === 'Extension') {
+        const query = (0, event_mapper_1.readStringField)(item, 'query') ?? (0, event_mapper_1.readStringField)(item, 'action');
+        return query ? boundDetailText(collapseToLine(query)) : null;
+    }
+    return null;
+}
+/** `parsed_cmd[].cmd`, joined. */
+function readParsedCommand(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parts = [];
+    for (const entry of value) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const cmd = (0, event_mapper_1.readStringField)(entry, 'cmd');
+        if (cmd)
+            parts.push(cmd);
+    }
+    return parts.length > 0 ? parts.join(' ; ') : null;
+}
+/** `command`, joined with spaces. */
+function readArgv(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parts = value.filter((entry) => typeof entry === 'string');
+    return parts.length > 0 ? parts.join(' ') : null;
+}
+/** A tool detail on one line. A heredoc puts newlines in a shell command. */
+function collapseToLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function boundDetailText(value) {
+    return value.length <= exports.MAX_CODEX_TOOL_DETAIL_LENGTH
+        ? value
+        : `${value.slice(0, exports.MAX_CODEX_TOOL_DETAIL_LENGTH - 1)}…`;
+}
+/**
+ * Read one parsed rollout line.
+ *
+ * @returns The record, or null when the value is not an object with a `type`
+ */
+function readCodexRolloutRecord(value) {
+    if (!(0, event_mapper_1.isPlainObject)(value))
+        return null;
+    const type = (0, event_mapper_1.readStringField)(value, 'type');
+    if (!type)
+        return null;
+    const payload = (0, event_mapper_1.isPlainObject)(value.payload) ? value.payload : null;
+    const payloadType = payload ? (0, event_mapper_1.readStringField)(payload, 'type') : null;
+    const timestamp = (0, event_mapper_1.readStringField)(value, 'timestamp');
+    const parsed = timestamp ? Date.parse(timestamp) : NaN;
+    return {
+        type,
+        payloadType,
+        turnId: payload ? (0, event_mapper_1.readStringField)(payload, 'turn_id') : null,
+        sessionId: payload
+            ? ((0, event_mapper_1.readStringField)(payload, 'session_id') ?? (0, event_mapper_1.readStringField)(payload, 'thread_id'))
+            : null,
+        timestampMs: Number.isFinite(parsed) ? parsed : null,
+        item: payload && payloadType === 'item_completed' ? readCodexRolloutItem(payload.item) : null,
+    };
+}
+/**
+ * Parse a slice of a rollout 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 whole 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
+ * losing it costs this poll rather than the file.
+ *
+ * @param text - The bytes read, decoded as UTF-8
+ */
+function parseCodexRollout(text) {
+    const records = [];
+    let malformedLines = 0;
+    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 = readCodexRolloutRecord(parsed);
+        if (record)
+            records.push(record);
+        else
+            malformedLines += 1;
+    }
+    return { records, malformedLines };
+}
+/**
+ * Group a rollout's records into turns.
+ *
+ * Keyed on `turn_id` rather than on file order, which is what lets the
+ * `token_count` and `thread_settings_applied` records that codex interleaves
+ * between a turn's items sit between them without splitting the turn. The map
+ * preserves first-seen order, so the newest turn is still the last one.
+ *
+ * @param records - In file order
+ * @param sessionId - Fallback for records that carry no session id
+ */
+function buildCodexTurns(records, sessionId) {
+    const turns = new Map();
+    let duplicateStreamRecords = 0;
+    let turnlessRecords = 0;
+    let fileSessionId = null;
+    for (const record of records) {
+        if (record.type === 'session_meta' && record.sessionId)
+            fileSessionId = record.sessionId;
+        if (record.type === 'response_item') {
+            duplicateStreamRecords += 1;
+            continue;
+        }
+        const turnId = record.turnId;
+        if (!turnId) {
+            turnlessRecords += 1;
+            continue;
+        }
+        let turn = turns.get(turnId);
+        if (!turn) {
+            turn = {
+                sessionId: record.sessionId ?? fileSessionId ?? sessionId,
+                turnId,
+                startedAt: record.timestampMs ?? 0,
+                prompts: [],
+                items: [],
+                closed: false,
+                overflowed: false,
+            };
+            turns.set(turnId, turn);
+        }
+        if (record.payloadType === 'task_complete') {
+            turn.closed = true;
+            continue;
+        }
+        const item = record.item;
+        if (!item)
+            continue;
+        if (item.type === 'UserMessage') {
+            if (item.id && item.text) {
+                turn.prompts.push({
+                    itemId: item.id,
+                    text: item.text,
+                    timestampMs: record.timestampMs ?? turn.startedAt,
+                });
+            }
+            continue;
+        }
+        if (turn.items.length >= exports.MAX_CODEX_TURN_ITEMS) {
+            turn.overflowed = true;
+            continue;
+        }
+        turn.items.push(item);
+    }
+    return { turns: [...turns.values()], duplicateStreamRecords, turnlessRecords };
+}
+/**
+ * Item types that carry nothing a reader wants.
+ *
+ * A deny set rather than an allow set, for the reason the other two readers
+ * give: an item type a later codex adds should surface in the unknown tally
+ * instead of being silently equivalent to something that was checked.
+ * `ContextCompaction` is on it because its whole payload is `{type, id}` —
+ * measured on 53 archived items, every one of them with no other field.
+ */
+const CODEX_SILENT_ITEM_TYPES = new Set(['ContextCompaction']);
+/** The word each tool item is labelled with on its summary line. */
+const CODEX_TOOL_LABELS = {
+    CommandExecution: 'exec',
+    FileChange: 'edit',
+    McpToolCall: 'mcp',
+    ImageView: 'view',
+    Extension: 'extension',
+};
+/** One tool call as a single Markdown line. */
+function renderToolItem(item) {
+    const label = CODEX_TOOL_LABELS[item.type] ?? item.type;
+    return item.detail ? `- \`${label}\` — ${item.detail}` : `- \`${label}\``;
+}
+/**
+ * A reasoning summary, folded.
+ *
+ * A blockquote and not `<details>`, for the reason `../opencode/transcript`
+ * documents: `<details>` would require running raw HTML through the card's
+ * sanitiser, and that costs every unfenced `<T>` in ordinary prose.
+ */
+function renderReasoningItem(text) {
+    const quoted = text
+        .trim()
+        .split('\n')
+        .map((line) => (line.length > 0 ? `> ${line}` : '>'))
+        .join('\n');
+    return `> **${exports.CODEX_THINKING_LABEL}**\n>\n${quoted}`;
+}
+/**
+ * Render one turn to Markdown.
+ *
+ * Transcript order within each kind — the same decision #2041 and #2121 took,
+ * and for the same reason: the order is the only record of what happened when,
+ * and this row is the record. Both `commentary` and `final_answer` messages are
+ * kept; codex's TUI shows both, and dropping the commentary would remove the
+ * sentence that explains what the tool line underneath it is for.
+ *
+ * The layout — prose first, the calls folded into one labelled section — is
+ * `../turn-body`'s and is shared with the other three readers (#2234).
+ */
+function renderCodexTurn(turn) {
+    const rendered = [];
+    const unknown = new Set();
+    let textBlocks = 0;
+    let toolBlocks = 0;
+    for (const item of turn.items) {
+        if (item.type === 'AgentMessage') {
+            const text = item.text?.trim() ?? '';
+            if (text.length === 0)
+                continue;
+            rendered.push({ kind: 'prose', text });
+            textBlocks += 1;
+            continue;
+        }
+        if (item.type === 'Reasoning') {
+            const text = item.text?.trim() ?? '';
+            if (text.length === 0)
+                continue;
+            rendered.push({ kind: 'aside', text: renderReasoningItem(text) });
+            continue;
+        }
+        if (item.type in CODEX_TOOL_LABELS) {
+            rendered.push({ kind: 'tool', text: renderToolItem(item) });
+            toolBlocks += 1;
+            continue;
+        }
+        if (!CODEX_SILENT_ITEM_TYPES.has(item.type))
+            unknown.add(item.type);
+    }
+    let body = (0, turn_body_1.separateTurnBody)(rendered).body;
+    if (body.length > exports.MAX_CODEX_TURN_BODY_LENGTH) {
+        body =
+            body.slice(0, exports.MAX_CODEX_TURN_BODY_LENGTH - exports.CODEX_TURN_TRUNCATION_MARKER.length) +
+                exports.CODEX_TURN_TRUNCATION_MARKER;
+    }
+    return {
+        sessionId: turn.sessionId,
+        turnId: turn.turnId,
+        body,
+        textBlocks,
+        toolBlocks,
+        unknownBlockTypes: [...unknown],
+    };
+}

package/dist/server/src/lib/hooks/sources/copilot/source.js

@@ -220,6 +220,8 @@ exports.copilotAgentEventSource = (0, define_source_1.definePushHookSource)({
         // measured. Default = Claude's fallback, the time window.
         eventIdentity: null,
         resync: 'none',
+        // Issue #2197. Nobody but the screen scraper records copilot replies.
+        transcriptHistory: null,
     },
     // The same CamelCase dialect as Claude and codex — measured against six
     // captured payloads (#1757 §8.1), not assumed from the resemblance. Shared

package/dist/server/src/lib/hooks/sources/gemini/source.js

@@ -132,6 +132,8 @@ exports.geminiAgentEventSource = (0, define_source_1.definePushHookSource)({
         permissionReplyReleasesPrompt: false,
         eventIdentity: null,
         resync: 'none',
+        // Issue #2197. Nobody but the screen scraper records gemini replies.
+        transcriptHistory: null,
     },
     // gemini's own table, kept in gemini's own module: four of the seven are
     // spelled differently, and merging them into the shared CamelCase table would

package/dist/server/src/lib/hooks/sources/legacy-relay.js

@@ -67,6 +67,9 @@ function createLegacyRelaySource(cliToolId) {
             permissionReplyReleasesPrompt: false,
             eventIdentity: null,
             resync: 'none',
+            // Issue #2197. A tool on the compatibility relay has no reader, which
+            // is the same "nobody has measured this" the empty event list states.
+            transcriptHistory: null,
         },
         mappers: (0, event_mapper_1.fromNameTable)(hook_event_vocabulary_1.CAMEL_CASE_HOOK_EVENT_NAMES),
         nativeEventNameFields: ['hook_event_name'],

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

@@ -254,6 +254,11 @@ function recordOpencodeTranscriptFrame(target, frame, receivedAt) {
                 partType: part.type,
             });
         }
+        // Issue #2199: the chat surface's live body. Fire-and-forget — this function
+        // is on the SSE reader's hot path and its contract is that a frame is
+        // accounted for by the time it returns; awaiting a broadcast would make the
+        // accumulator's correctness depend on a WebSocket.
+        void publishOpencodeTurnProgress(target, turn);
     }
     catch (error) {
         logger.error('opencode-transcript-record-failed', {
@@ -263,6 +268,58 @@ function recordOpencodeTranscriptFrame(target, frame, receivedAt) {
         });
     }
 }
+/**
+ * Push the open turn's body to the chat surface (Issue #2199).
+ *
+ * The push half of the same fact `flushOpencodeTurn` eventually writes, and
+ * deliberately built from the SAME accumulator through the SAME
+ * `renderOpencodeTurn`: a live body rendered by a second, "cheaper" path would
+ * differ from the row that replaces it, and the replacement would read as the
+ * reply changing its mind at the moment it finished.
+ *
+ * `opencodeTurnRequestId(turn.userMessageId)` is the key on both sides, so the
+ * client's swap is a string comparison and needs no notion of ordering. Which is
+ * what makes the re-sent boundary frames harmless twice over: the accumulator
+ * overwrites a repeat into the same `prt_…` slot (see `./transcript`), so the
+ * rendered body is byte-identical and the shared builder's no-change rule drops
+ * it before it reaches the wire.
+ *
+ * The import is dynamic for the reason every database import in this file is:
+ * `current-output-builder` statically imports `@/lib/db`, and a static import
+ * here would put `better-sqlite3` into the graph of everything that imports
+ * `@/lib/hooks/sources`.
+ *
+ * Never throws.
+ */
+async function publishOpencodeTurnProgress(target, turn) {
+    try {
+        const { emitChatTurnProgress } = await Promise.resolve().then(() => __importStar(require('../../../../lib/session/current-output-builder')));
+        await emitChatTurnProgress({
+            worktreeId: target.worktreeId,
+            cliToolId: target.cliToolId,
+            instanceId: target.instanceId ?? target.cliToolId,
+        }, () => {
+            const rendered = (0, transcript_1.renderOpencodeTurn)(turn);
+            if (rendered.body.length === 0)
+                return null;
+            return {
+                turnKey: (0, agent_transcript_1.opencodeTurnRequestId)(rendered.userMessageId),
+                body: rendered.body,
+                // The stream carries the turn from its first part, so nothing is ever
+                // missing from the head. The only cut this body can take is the
+                // shared builder's size bound, which reports itself.
+                partial: false,
+            };
+        });
+    }
+    catch (error) {
+        logger.debug('opencode-transcript-progress-failed', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
 /**
  * The turn currently open on this session, for tests and for callers that need
  * to know whether a flush would do anything.

package/dist/server/src/lib/hooks/sources/opencode/source.js

@@ -321,6 +321,10 @@ exports.opencodeAgentEventSource = (0, define_source_1.definePullEventSource)({
         // both back to the pre-#1900 behaviour, which is what the mutation case in
         // `tests/unit/hooks/sources/opencode-resilience-1900.test.ts` asserts.
         resync: 'session-status-poll',
+        // Issue #2197. opencode is the push half: `./history` is already writing
+        // the reply out of the SSE stream, so the gate asks whether the
+        // subscription is live rather than asking for the turn.
+        transcriptHistory: 'push',
     },
     // C4. Predicates, not a name table: see ./mappers.
     mappers: mappers_1.OPENCODE_MAPPERS,

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

@@ -63,6 +63,7 @@ exports.addOpencodePart = addOpencodePart;
 exports.renderOpencodeTurn = renderOpencodeTurn;
 exports.buildOpencodeTurnsFromMessages = buildOpencodeTurnsFromMessages;
 const event_mapper_1 = require("../event-mapper");
+const turn_body_1 = require("../turn-body");
 /**
  * The field that groups assistant messages into one turn.
  *
@@ -239,10 +240,11 @@ function renderReasoningPart(text) {
 /**
  * Render one turn to Markdown.
  *
- * Stream order throughout — a tool line sits where the agent called it and
- * reasoning sits where the agent thought it. Reordering to put prose first
- * would read better in the two-line collapsed preview and is not done: the
- * order is the only record of what happened when, and this row is the record.
+ * Stream order within each kind — reasoning sits where the agent thought it and
+ * the calls are in the order they were made. #2041 kept one stream for all of
+ * them and #2234 split the tool calls out into a section of their own; the
+ * layout is `../turn-body`'s, shared with the other three readers, and
+ * {@link separateTurnBody} carries the reasoning for both halves of that.
  *
  * @param turn - The accumulator, live or rebuilt from REST
  */
@@ -258,7 +260,7 @@ function renderOpencodeTurn(turn) {
             const text = part.text?.trim() ?? '';
             if (text.length === 0)
                 continue;
-            blocks.push(text);
+            blocks.push({ kind: 'prose', text });
             textParts += 1;
             continue;
         }
@@ -266,7 +268,7 @@ function renderOpencodeTurn(turn) {
             const text = part.text?.trim() ?? '';
             if (text.length === 0)
                 continue;
-            blocks.push(renderReasoningPart(text));
+            blocks.push({ kind: 'aside', text: renderReasoningPart(text) });
             continue;
         }
         if (part.type === 'tool') {
@@ -275,14 +277,14 @@ function renderOpencodeTurn(turn) {
             // a call was still running has nothing to summarise but its name.
             if (part.status === 'pending')
                 continue;
-            blocks.push(renderToolPart(part));
+            blocks.push({ kind: 'tool', text: renderToolPart(part) });
             toolParts += 1;
             continue;
         }
         if (!OPENCODE_SILENT_PART_TYPES.has(part.type))
             unknown.add(part.type);
     }
-    let body = joinTurnBlocks(blocks);
+    let body = (0, turn_body_1.separateTurnBody)(blocks).body;
     if (body.length > exports.MAX_OPENCODE_TURN_BODY_LENGTH) {
         body =
             body.slice(0, exports.MAX_OPENCODE_TURN_BODY_LENGTH - exports.OPENCODE_TURN_TRUNCATION_MARKER.length) +
@@ -297,26 +299,6 @@ function renderOpencodeTurn(turn) {
         unknownPartTypes: [...unknown],
     };
 }
-/**
- * Join the rendered blocks.
- *
- * Consecutive tool lines are joined with a single newline so they stay one
- * Markdown list; everything else is separated by a blank line, which is what
- * makes a paragraph a paragraph and stops a heading being absorbed into the
- * text above it.
- */
-function joinTurnBlocks(blocks) {
-    let out = '';
-    for (let i = 0; i < blocks.length; i += 1) {
-        if (i === 0) {
-            out = blocks[i];
-            continue;
-        }
-        const bothToolLines = blocks[i].startsWith('- `') && blocks[i - 1].startsWith('- `');
-        out += bothToolLines ? `\n${blocks[i]}` : `\n\n${blocks[i]}`;
-    }
-    return out;
-}
 /**
  * Rebuild every turn of a session from `GET /session/:id/message`.
  *