commandmate 0.30.2 → 0.31.0

package/dist/server/src/lib/detection/tools/registry.js

@@ -15,8 +15,9 @@ exports.getToolStatusDetector = getToolStatusDetector;
 const detect_1 = require("./antigravity/detect");
 const detect_2 = require("./claude/detect");
 const detect_3 = require("./codex/detect");
-const detect_4 = require("./copilot/detect");
-const detect_5 = require("./opencode/detect");
+const detect_4 = require("./command-code/detect");
+const detect_5 = require("./copilot/detect");
+const detect_6 = require("./opencode/detect");
 const run_detection_1 = require("./run-detection");
 const verified_against_1 = require("./verified-against");
 /**
@@ -38,9 +39,10 @@ const vibeLocalStatusDetector = createGenericStatusDetector('vibe-local');
 const DETECTORS = {
     claude: detect_2.claudeStatusDetector,
     codex: detect_3.codexStatusDetector,
-    copilot: detect_4.copilotStatusDetector,
-    opencode: detect_5.opencodeStatusDetector,
+    copilot: detect_5.copilotStatusDetector,
+    opencode: detect_6.opencodeStatusDetector,
     antigravity: detect_1.antigravityStatusDetector,
+    'command-code': detect_4.commandCodeStatusDetector,
     gemini: geminiStatusDetector,
     'vibe-local': vibeLocalStatusDetector,
 };

package/dist/server/src/lib/detection/tools/verified-against.js

@@ -26,7 +26,7 @@
  * instead of importing it.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DETECTOR_VERIFIED_AGAINST = exports.UNMEASURED_VERIFIED_AGAINST = exports.ANTIGRAVITY_VERIFIED_AGAINST = exports.OPENCODE_VERIFIED_AGAINST = exports.COPILOT_VERIFIED_AGAINST = exports.CODEX_VERIFIED_AGAINST = exports.CLAUDE_VERIFIED_AGAINST = void 0;
+exports.DETECTOR_VERIFIED_AGAINST = exports.UNMEASURED_VERIFIED_AGAINST = exports.COMMAND_CODE_VERIFIED_AGAINST = exports.ANTIGRAVITY_VERIFIED_AGAINST = exports.OPENCODE_VERIFIED_AGAINST = exports.COPILOT_VERIFIED_AGAINST = exports.CODEX_VERIFIED_AGAINST = exports.CLAUDE_VERIFIED_AGAINST = void 0;
 /** claude these rules were read off (#1708 / #1927 fixtures). */
 exports.CLAUDE_VERIFIED_AGAINST = {
     version: '2.1.240',
@@ -39,10 +39,21 @@ exports.CODEX_VERIFIED_AGAINST = {
     capturedAt: '2026-08-15',
     paneGeometry: '200x1000',
 };
-/** copilot-cli these rules were read off (#1885 / #1895 fixtures). */
+/**
+ * copilot-cli these rules were read off (#1885 / #1895 / #2269 fixtures).
+ *
+ * Bumped from 1.0.80 because the frames were RE-CAPTURED and the rules CHANGED:
+ * 1.0.82 redrew the composer's fence (`─` rules became a `╻▄` / `╹▀` half-block
+ * frame), dropped the `❯` from the composer in favour of the frame's own `┃`
+ * edge, boxed the transcript's echoed prompt between two more half-block
+ * dividers, and put a file-type badge in front of most tool rows' verbs. The
+ * frames are `tests/unit/lib/detection/fixtures/copilot-live-2269/`, captured on
+ * a private tmux socket at the production geometry; the 1.0.80 frames stay where
+ * they are and the rules still answer for both builds.
+ */
 exports.COPILOT_VERIFIED_AGAINST = {
-    version: '1.0.80',
-    capturedAt: '2026-08-21',
+    version: '1.0.82',
+    capturedAt: '2026-09-04',
     paneGeometry: '200x1000',
 };
 /**
@@ -62,11 +73,50 @@ exports.OPENCODE_VERIFIED_AGAINST = {
     capturedAt: '2026-08-26',
     paneGeometry: '80x200',
 };
-/** agy these rules were read off (#988 / #995). */
+/**
+ * agy these rules were read off (#988 / #995 footer + selection rules, re-read
+ * against the #2270 live panes).
+ *
+ * Bumped from `0.4.x` / `2026-07-30` / `inline` because the frames were
+ * RE-CAPTURED, not because the binary moved: #2270 drove agy 1.1.25 on a private
+ * tmux socket at the production geometry and kept both panes inline in
+ * `tests/unit/status-detector-selection.test.ts`
+ * (`AGY_1125_PERMISSION_PANE`, `AGY_1125_SWITCH_MODEL_PANE`) under the banner
+ * `Antigravity CLI 1.1.25`, trailing pane padding included. The
+ * `Do you want to proceed?` + `N. label` rules were measured off those frames,
+ * and `ANTIGRAVITY_SELECTION_LIST_PATTERN` (#995 / #997) was re-checked against
+ * them and left unchanged.
+ *
+ * `paneGeometry` leaves `inline` because the 1.1.25 permission dialog draws no
+ * composer row at all — it reproduces only at the 200x1000 pane the server
+ * captures, and a fixture without the ~970 blank padding rows exercises a
+ * different `lastLines` slice than production does. That is a statement about
+ * the capture condition, not about agy: the scrollback-retained rendering the
+ * `afterThinking` footer rules rest on (#988) is unchanged, and the 1.1.25
+ * dialog still ends on `esc to cancel`.
+ *
+ * What this stamp does NOT claim: #2270 captured `waiting` frames only, so the
+ * idle (`? for shortcuts`) and generating (spinner) branches are carried over
+ * from the 0.4 captures rather than re-measured. A live IDLE 1.1.25 frame is
+ * still uncaptured — see the `readIdleEvidence` note in `antigravity/detect.ts`.
+ */
 exports.ANTIGRAVITY_VERIFIED_AGAINST = {
-    version: '0.4.x',
-    capturedAt: '2026-07-30',
-    paneGeometry: 'inline',
+    version: '1.1.25',
+    capturedAt: '2026-09-04',
+    paneGeometry: '200x1000',
+};
+/**
+ * Command Code these rules were read off (#2250 fixtures).
+ *
+ * The frames are `tests/fixtures/command-code-live-2250/`, captured on a private
+ * tmux socket at the production geometry — the default pane size does not
+ * reproduce the 200-column rules that fence the composer, and the status row
+ * drops its `esc to interrupt` tail below 72 columns.
+ */
+exports.COMMAND_CODE_VERIFIED_AGAINST = {
+    version: '1.40.1',
+    capturedAt: '2026-09-03',
+    paneGeometry: '200x1000',
 };
 /**
  * The stamp for a tool whose frames nobody has captured yet.
@@ -94,6 +144,7 @@ exports.DETECTOR_VERIFIED_AGAINST = {
     copilot: exports.COPILOT_VERIFIED_AGAINST,
     opencode: exports.OPENCODE_VERIFIED_AGAINST,
     antigravity: exports.ANTIGRAVITY_VERIFIED_AGAINST,
+    'command-code': exports.COMMAND_CODE_VERIFIED_AGAINST,
     gemini: exports.UNMEASURED_VERIFIED_AGAINST,
     'vibe-local': exports.UNMEASURED_VERIFIED_AGAINST,
 };

package/dist/server/src/lib/detection/version-probes.js

@@ -124,7 +124,7 @@ function parseCliVersion(output) {
     return match ? `${match[1]}.${match[2]}.${match[3]}` : null;
 }
 /**
- * A `verifiedAgainst` stamp written as a minor-series wildcard: `0.4.x`.
+ * A `verifiedAgainst` stamp written as a minor-series wildcard: `2.0.x`.
  *
  * Only ever applied to the stamp, never to a probe's own output — one side of
  * this comparison is a string a human typed into a tool module, the other is
@@ -135,11 +135,32 @@ const VERIFIED_AGAINST_WILDCARD_REGEX = /^(\d+)\.(\d+)\.(?:x|\*)$/i;
  * The comparable form of a `verifiedAgainst` stamp, or null when there is none.
  *
  * `'unmeasured'` is null — a tool nobody has captured frames for cannot be
- * fresh or stale. `'0.4.x'` becomes `0.4.0`: antigravity's stamp is a minor
- * series rather than a build (Issue #995 measured a range), and reading it as
- * "no version" would silently exempt the one tool whose rules are furthest
- * behind. Widening to `.0` is the safe direction — it can only ever call a
- * newer install stale, never call a stale one current.
+ * fresh or stale. A minor-series stamp such as `'2.0.x'` becomes `2.0.0`;
+ * widening to `.0` is the safe direction, because it can only ever call a newer
+ * install stale, never call a stale one current.
+ *
+ * ## The wildcard branch has no caller in the table today, and stays anyway
+ *
+ * antigravity's `0.4.x` (Issue #995 measured a range rather than a build) was
+ * the only wildcard stamp ever written, and Issue #2292 replaced it with the
+ * build #2270 actually read the rules off (`1.1.25`). Re-run the grep that
+ * settled it and the branch has zero users:
+ *
+ * ```
+ * $ grep -rnE "version: '[0-9]+\.[0-9]+\.(x|\*)'" src/
+ * (no matches)
+ * ```
+ *
+ * It is kept, because deleting it would not delete the FORMAT.
+ * `verifiedAgainst` is a hand-written string, and the next person who measures a
+ * series rather than a build can still type `2.0.x`. With this branch that
+ * stamp compares. Without it {@link parseCliVersion} reads it as null and the
+ * tool is filed alongside `'unmeasured'` — never stale, no warning, nothing an
+ * operator can act on — which is the same failure #2292 was raised to fix, one
+ * level further down. A parser for an input the table still permits is not dead
+ * code; the unit exercises it on the format directly rather than through
+ * whichever stamp the table happens to hold, so it does not go vacuous now that
+ * no tool uses it.
  */
 function parseVerifiedAgainstVersion(stamp) {
     const wildcard = VERIFIED_AGAINST_WILDCARD_REGEX.exec(stamp);
@@ -180,6 +201,7 @@ exports.DETECTOR_VERSION_PROBES = {
     claude: { kind: 'execFile', command: 'claude', args: ['--version'] },
     codex: { kind: 'execFile', command: 'codex', args: ['--version'] },
     antigravity: { kind: 'execFile', command: 'agy', args: ['--version'] },
+    'command-code': { kind: 'execFile', command: 'commandcode', args: ['--version'] },
     opencode: { kind: 'execFile', command: 'opencode', args: ['--version'] },
     gemini: { kind: 'execFile', command: 'gemini', args: ['--version'] },
     copilot: {

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

@@ -366,12 +366,21 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
                 anchored: pending.anchored,
             });
         }
+        // Every prompt row first, then every reply (Issue #2273). The two passes are
+        // what let a reply be dated at its turn's END without overtaking the NEXT
+        // turn's prompt: a queued `/send` row is written while this turn is still
+        // running, so its instant is only knowable once that row has been recorded.
+        // With one turn pending — the ordinary case — this is the single call it
+        // always was.
+        const userRows = [];
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            userRows.push(await recordAntigravityUserTurn(target, pending.turns[index], previousStartedAt));
+        }
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
-            const userRow = await recordAntigravityUserTurn(target, turn, previousStartedAt);
-            captured = await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+            captured = await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastAntigravityRecordAt(turn), nextTurnOpensAt(pending.turns, userRows, index)), path);
         }
         return captured;
     }
@@ -500,21 +509,73 @@ async function recordAntigravityUserTurn(target, turn, previousStartedAt = 0) {
 /**
  * When the assistant row for this turn is dated.
  *
- * The turn's own clock, from the `USER_INPUT` record that opened it, so a row
- * written a poll late still sorts where the conversation put it.
+ * **The turn's LAST record, not its first (Issue #2273).** #2196 dated the reply
+ * one millisecond after the prompt so that `groupMessagesIntoPairs` — which
+ * orders by timestamp and nothing else — could never put the answer above the
+ * question. That is still guaranteed, by `earliest` below, and it is still
+ * necessary: agy stamps the prompt and the first reply of a fast turn with the
+ * *same second* (measured — `created_at` is second-resolution, and turn 1 of the
+ * captured session has `02:12:41Z` on both).
+ *
+ * What #2196 did not account for is the row that lands BETWEEN the two. A tool
+ * approval is written when the dialog appears, seconds into the turn, and the
+ * chat surface orders its rows by timestamp: a reply dated at the turn's start
+ * therefore draws above an approval that really happened before it. The measured
+ * case is in the Issue — prompt `04:49:50.989Z`, reply `04:49:54.000Z`, approval
+ * `04:49:57.513Z` — and the reply's own last record is later than all three. So
+ * the last record's instant is what the row is dated by: it is the moment the
+ * turn actually ended, and everything the turn produced sorts before it.
+ *
+ * Two bounds keep the move honest:
+ *
+ *  - `earliest` is a floor, never overridden. A turn with no timestamped
+ *    record (`lastRecordAt === 0`) is dated exactly where #2196 put it.
+ *  - `nextTurnOpensAt` is a ceiling. The next turn's prompt row may be a `/send`
+ *    row written while THIS turn was still running — a queued prompt — and a
+ *    reply that overtook it would be paired with the wrong question.
+ *
+ * @param lastRecordAt - Epoch ms of the turn's last record, or 0 when unknown
+ * @param nextTurnOpensAt - Epoch ms of the next turn's user row, or null when
+ *   this is the newest turn in the window
+ */
+function resolveAssistantTimestampMs(turn, userRow, lastRecordAt = 0, nextTurnOpensAt = null) {
+    const earliest = userRow.timestampMs === null
+        ? turn.startedAt
+        : Math.max(turn.startedAt, userRow.timestampMs + 1);
+    const latest = nextTurnOpensAt === null ? Number.POSITIVE_INFINITY : nextTurnOpensAt - 1;
+    return Math.max(earliest, Math.min(lastRecordAt, latest));
+}
+/**
+ * When the last record agy wrote for this turn was made (Issue #2273).
+ *
+ * The maximum rather than `records.at(-1)`: `created_at` is agy's own field and
+ * a record that carries none reads as null, so the last record in file order is
+ * not always the last one with a clock on it.
  *
- * When there is a user row the reply is moved to the first millisecond after it:
- * `groupMessagesIntoPairs` orders by timestamp and nothing else, and agy stamps
- * both the prompt and the first reply of a fast turn with the *same second*
- * (measured — `created_at` is second-resolution, and turn 1 of the captured
- * session has `02:12:41Z` on both). A tie is then decided by whichever row the
- * database returned first, and the losing arrangement — assistant, then user —
- * is exactly the `orphan` pair #2196 exists to remove.
+ * @returns Epoch ms, or 0 when the turn has no timestamped record
  */
-function resolveAssistantTimestampMs(turn, userRow) {
-    if (userRow.timestampMs === null)
-        return turn.startedAt;
-    return Math.max(turn.startedAt, userRow.timestampMs + 1);
+function lastAntigravityRecordAt(turn) {
+    let at = 0;
+    for (const record of turn.records) {
+        if (record.timestampMs !== null && record.timestampMs > at)
+            at = record.timestampMs;
+    }
+    return at;
+}
+/**
+ * The instant the next pending turn's prompt row carries, or null (Issue #2273).
+ *
+ * The user row's own timestamp when there is one, because that is what History
+ * sorts on and it can be EARLIER than the turn's start — an adopted `/send` row
+ * was written when CommandMate handed the text to the pane, which for a queued
+ * prompt is while the previous turn was still running. The turn's start is the
+ * fallback for a turn that produced no row at all.
+ */
+function nextTurnOpensAt(turns, userRows, index) {
+    const next = turns[index + 1];
+    if (!next)
+        return null;
+    return userRows[index + 1]?.timestampMs ?? next.startedAt;
 }
 /**
  * Write one rendered turn, unless it is already there.

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

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

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

@@ -400,12 +400,22 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
                 anchored: pending.anchored,
             });
         }
+        // Every prompt row first, then every reply (Issue #2273). The two passes are
+        // what let a reply be dated at its turn's END without overtaking the NEXT
+        // turn's prompt: a queued `/send` row is written while this turn is still
+        // running, so its instant is only knowable once that row has been recorded.
+        // With one turn pending — the ordinary case — this is the single call it
+        // always was.
+        const userRows = [];
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            userRows.push(await recordCodexUserTurns(target, pending.turns[index], previousStartedAt));
+        }
+        const lastRecordAt = lastCodexRecordAt(parsed.records);
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
-            const lastUserRow = await recordCodexUserTurns(target, turn, previousStartedAt);
-            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, lastUserRow), path);
+            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.turnId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), path);
         }
         return captured;
     }
@@ -544,20 +554,79 @@ async function recordCodexUserTurns(target, turn, previousStartedAt = 0) {
 /**
  * When the assistant row for this turn is dated.
  *
- * The turn's own clock, from the first record bearing its `turn_id`, so a row
- * written a poll late still sorts where the conversation put it.
+ * **The turn's LAST record, not its first (Issue #2273).** #2197 dated the reply
+ * by the first record bearing the `turn_id` so that a row written a poll late
+ * still sorted where the conversation put it, and #2196 moved it one millisecond
+ * past the last prompt so that `groupMessagesIntoPairs` — which orders by
+ * timestamp and nothing else — could never return the answer above the question.
+ * Both properties survive: `earliest` is a floor this never goes under, and for
+ * codex it is the floor that matters most, because a turn can carry SEVERAL
+ * prompts (measured at more than one on 23 of 326 archived turns) and the reply
+ * has to sort past all of them.
+ *
+ * What neither accounted for is the row that lands BETWEEN the prompt and the
+ * reply. A tool approval is written when the dialog appears, seconds into the
+ * turn, and the chat surface orders its rows by timestamp — so a reply dated at
+ * the turn's start draws ABOVE an approval that really happened before it. The
+ * turn's last record — for codex, the `task_complete` that closes it — is the
+ * moment the turn ended, so everything it produced on the way sorts before it.
+ *
+ * `nextTurnOpensAt` is the ceiling. The next turn's prompt row may be a `/send`
+ * row written while THIS turn was still running — a queued prompt — and a reply
+ * that overtook it would be paired with the wrong question.
+ *
+ * @param lastRecordAt - Epoch ms of the turn's last record, or 0 when unknown
+ * @param nextTurnOpensAt - Epoch ms of the next turn's user row, or null when
+ *   this is the newest turn in the window
+ */
+function resolveAssistantTimestampMs(turn, userRow, lastRecordAt = 0, nextTurnOpensAt = null) {
+    const earliest = userRow.timestampMs === null
+        ? turn.startedAt
+        : Math.max(turn.startedAt, userRow.timestampMs + 1);
+    const latest = nextTurnOpensAt === null ? Number.POSITIVE_INFINITY : nextTurnOpensAt - 1;
+    return Math.max(earliest, Math.min(lastRecordAt, latest));
+}
+/**
+ * When each turn's last record was written (Issue #2273).
+ *
+ * Keyed by `turn_id` and walked over the same records {@link buildCodexTurns}
+ * walks, with the same `response_item` exclusion — that stream is codex's
+ * duplicate of the same events and counting it would be counting each record
+ * twice. It is a second pass rather than a field on the accumulator because
+ * `./transcript` is not this Issue's to change.
+ *
+ * Every record of the turn counts, `task_complete` included: that one IS the
+ * turn's end and is exactly the instant the reply should be dated by.
  *
- * When there is a user row it sits on the same instant or later, and
- * `groupMessagesIntoPairs` orders by timestamp and nothing else — a tie there is
- * decided by whichever row the database returned first, and the losing
- * arrangement (assistant, then user) is exactly the `orphan` pair #2196 exists
- * to remove. So the reply is moved to the first millisecond after the last
- * prompt: the smallest change that makes the order a property of the data.
+ * @returns `turn_id` → epoch ms; absent for a turn with no timestamped record
  */
-function resolveAssistantTimestampMs(turn, userRow) {
-    if (userRow.timestampMs === null)
-        return turn.startedAt;
-    return Math.max(turn.startedAt, userRow.timestampMs + 1);
+function lastCodexRecordAt(records) {
+    const at = new Map();
+    for (const record of records) {
+        if (record.type === 'response_item')
+            continue;
+        const turnId = record.turnId;
+        if (!turnId || record.timestampMs === null)
+            continue;
+        if (record.timestampMs > (at.get(turnId) ?? 0))
+            at.set(turnId, record.timestampMs);
+    }
+    return at;
+}
+/**
+ * The instant the next pending turn's prompt row carries, or null (Issue #2273).
+ *
+ * The user row's own timestamp when there is one, because that is what History
+ * sorts on and it can be EARLIER than the turn's start — an adopted `/send` row
+ * was written when CommandMate handed the text to the pane, which for a queued
+ * prompt is while the previous turn was still running. The turn's start is the
+ * fallback for a turn that produced no row at all.
+ */
+function nextTurnOpensAt(turns, userRows, index) {
+    const next = turns[index + 1];
+    if (!next)
+        return null;
+    return userRows[index + 1]?.timestampMs ?? next.startedAt;
 }
 /**
  * Write one rendered turn, unless it is already there.