commandmate 0.30.1 → 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.
+ *
+ * @returns Epoch ms, or 0 when the turn has no timestamped record
+ */
+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).
  *
- * 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.
+ * 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 resolveAssistantTimestampMs(turn, userRow) {
-    if (userRow.timestampMs === null)
-        return turn.startedAt;
-    return Math.max(turn.startedAt, userRow.timestampMs + 1);
+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.
@@ -532,12 +593,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;