commandmate 0.30.0 → 0.30.2

package/dist/server/src/lib/history/user-turn-recorder.js

@@ -148,8 +148,9 @@ function describe(target) {
  *   re-read of the log and a `/clear`.
  * @param content - The prompt, as the agent recorded it
  * @param timestampMs - When the agent says it was prompted, epoch ms
+ * @param options - See {@link RecordUserTurnOptions}; the defaults are #2196's
  */
-async function recordUserTurn(target, key, content, timestampMs) {
+async function recordUserTurn(target, key, content, timestampMs, options = {}) {
     const instanceId = target.instanceId ?? target.cliToolId;
     const normalized = normalizeUserTurnContent(content);
     if (key.length === 0 || normalized.length === 0) {
@@ -171,7 +172,7 @@ async function recordUserTurn(target, key, content, timestampMs) {
             };
         }
         const at = timestampMs > 0 ? timestampMs : Date.now();
-        const adopted = adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at);
+        const adopted = adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, options);
         if (adopted)
             return adopted;
         const message = chatDb.createMessage(db, {
@@ -217,13 +218,17 @@ async function recordUserTurn(target, key, content, timestampMs) {
  *
  * @returns The claimed row, or null when nothing here belongs to this prompt
  */
-function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at) {
+function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, options) {
+    // `Math.min` and not a replacement: {@link RecordUserTurnOptions} may widen
+    // the search backwards and may never narrow it, so a caller that supplies a
+    // bound *inside* the standard window changes nothing.
+    const fromMs = Math.min(at - exports.USER_TURN_ADOPTION_WINDOW_MS, options.adoptionFromMs ?? Number.POSITIVE_INFINITY);
     const candidates = chatDb
         .findUnkeyedUserMessages(db, {
         worktreeId: target.worktreeId,
         cliToolId: target.cliToolId,
         instanceId,
-        fromMs: at - exports.USER_TURN_ADOPTION_WINDOW_MS,
+        fromMs,
         toMs: at + exports.USER_TURN_ADOPTION_WINDOW_MS,
     })
         .filter((row) => normalizeUserTurnContent(row.content) === normalized)

package/dist/server/src/lib/hooks/agent-event-service.js

@@ -30,6 +30,7 @@ const path_validator_1 = require("../../lib/security/path-validator");
 const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
 const gate_runner_1 = require("../../lib/verification/gate-runner");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const stop_history_capture_1 = require("../../lib/hooks/stop-history-capture");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/hooks/agent-event-service');
 /**
@@ -144,14 +145,32 @@ function safeRealpath(target) {
  * Apply a `stop` event to whatever the worktree is currently doing.
  *
  * The no-op is the load-bearing case. Sessions with no contract, and therefore
- * no task, are the overwhelming majority; for them this records the timestamp
- * and returns. Nothing about the existing completion path changes.
+ * no task, are the overwhelming majority; for them this records the timestamp,
+ * asks the transcript reader for the turn, and returns.
+ *
+ * ## Why the history read is here (Issue #2246)
+ *
+ * Because it must happen for *every* stop event and not only for the ones that
+ * govern a task — the majority case above is exactly the session whose replies
+ * this is trying not to lose — and because both callers of this function are
+ * stop receivers (`/api/hooks/agent-event` and the compatibility
+ * `/api/hooks/claude-done`). Putting it in one of the routes would have left the
+ * other one on the old behaviour.
+ *
+ * It runs **before** the task lookup so that the two early returns below cannot
+ * skip it, and after `recordAgentStopEvent` because the reader resolves its
+ * transcript through the session pointer that call refreshes.
+ *
+ * It is awaited rather than detached. The turn has already ended, so the cost is
+ * paid by nobody who is waiting for an answer, and a detached promise here would
+ * be one whose failures nothing observes.
  *
  * Never throws. A hook is fire-and-forget from a CLI's stop handler, and a
  * failure here must not become the agent's problem.
  */
 async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
     (0, agent_event_state_1.recordAgentStopEvent)(worktree.id, cliToolId, instanceId);
+    const structuredHistoryCaptured = await (0, stop_history_capture_1.captureTranscriptTurnOnStop)(worktree, cliToolId, instanceId);
     let task;
     try {
         task = (0, tasks_db_1.getActiveTaskForInstance)(db, worktree.id, cliToolId, instanceId);
@@ -161,10 +180,20 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
             worktreeId: worktree.id,
             error: error instanceof Error ? error.message : String(error),
         });
-        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+        return {
+            taskId: null,
+            taskEventApplied: false,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     if (!task) {
-        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+        return {
+            taskId: null,
+            taskEventApplied: false,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     let taskEventApplied = false;
     try {
@@ -178,7 +207,12 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
         });
     }
     if (!task.contract.success.autoVerifyOnStop) {
-        return { taskId: task.id, taskEventApplied, verificationRunId: null };
+        return {
+            taskId: task.id,
+            taskEventApplied,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     let verificationRunId = null;
     try {
@@ -201,5 +235,5 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
             });
         }
     }
-    return { taskId: task.id, taskEventApplied, verificationRunId };
+    return { taskId: task.id, taskEventApplied, verificationRunId, structuredHistoryCaptured };
 }

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

@@ -99,6 +99,7 @@ exports.antigravityBrainRoot = antigravityBrainRoot;
 exports.antigravityTranscriptPath = antigravityTranscriptPath;
 exports.acceptAntigravityTranscriptPath = acceptAntigravityTranscriptPath;
 exports.captureAntigravityTranscriptTurn = captureAntigravityTranscriptTurn;
+exports.resolveAntigravityTranscriptPath = resolveAntigravityTranscriptPath;
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -256,15 +257,21 @@ function acceptAntigravityTranscriptPath(agyHome, candidate) {
     return resolved;
 }
 /**
- * Read the newest turn out of this instance's transcript and write it.
+ * Read this instance's unwritten turns out of its transcript and write them.
  *
- * **Only the newest turn**, and that is the same deliberate difference from
- * opencode's backfill that #2121 documents: every earlier turn already has a
- * `chat_messages` row the *scraper* wrote, and writing a Markdown row for it too
- * would put the same reply in History twice. One row per turn from the scraper,
- * one row per turn from here, so the swap is one-for-one.
+ * **Every turn in the window that is not already a row**, oldest first, which is
+ * the shape Issue #2246 gave all three pull readers and the reasoning for it is
+ * written out once on `../claude/history`'s
+ * {@link captureClaudeTranscriptTurn}. The short version: this reader only runs
+ * when the poller judges a turn finished, so a missed judgement used to lose a
+ * turn permanently — by the next judgement "the newest turn" had moved on.
  *
- * The return value is the poller's instruction. **True** means History holds
+ * #2121's one-row-per-turn argument is preserved by the **anchor**: the newest
+ * turn in the window this reader has already written is where the backfill
+ * starts, and a window with no anchor falls back to the newest turn alone.
+ *
+ * The return value is the poller's instruction, and it is about the **newest**
+ * turn whatever else was written on the way. **True** means History holds
  * this turn as the agent's own Markdown and the scrape must be dropped. **False**
  * means it does not, for any reason at all — no conversation pointer, no file, an
  * unreadable file, a window with no prompt in it — and the scrape must be saved.
@@ -313,8 +320,7 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
             return false;
         const parsed = (0, transcript_1.parseAntigravityTranscript)(text);
         const built = (0, transcript_1.buildAntigravityTurns)(parsed.records, conversationId);
-        const turn = built.turns.at(-1);
-        if (!turn) {
+        if (built.turns.length === 0) {
             // No `USER_INPUT` in the window. Two ordinary causes, both fail-open: the
             // 4 MiB window cut mid-conversation, and `transcript_full.jsonl` can hold
             // less than the whole history — one of the 41 files in the corpus held a
@@ -341,8 +347,33 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
                 preludeRecords: built.preludeRecords,
             });
         }
-        const userRow = await recordAntigravityUserTurn(target, turn);
-        return await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        const pending = await selectUnwrittenAntigravityTurns(target, built.turns);
+        if (pending.turns.length === 0) {
+            logger.debug('antigravity-transcript-turns-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                turnsInWindow: built.turns.length,
+            });
+            return true;
+        }
+        if (pending.turns.length > 1) {
+            logger.info('antigravity-transcript-backfilling-turns', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                path,
+                pendingTurns: pending.turns.length,
+                turnsInWindow: built.turns.length,
+                anchored: pending.anchored,
+            });
+        }
+        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);
+        }
+        return captured;
     }
     catch (error) {
         logger.error('antigravity-transcript-capture-failed', {
@@ -353,6 +384,59 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
         return false;
     }
 }
+/**
+ * The transcript file this instance would be read from, or null (Issue #2246).
+ *
+ * The same two steps {@link captureAntigravityTranscriptTurn} opens with, asked
+ * without reading or writing anything; see `../claude/history`'s
+ * {@link resolveClaudeTranscriptPath} for what the Stop receiver does with it.
+ *
+ * Never throws.
+ */
+async function resolveAntigravityTranscriptPath(target, capture = {}) {
+    try {
+        const conversationId = await resolveAntigravityConversationId(target);
+        if (!conversationId)
+            return null;
+        return await locateAntigravityTranscript(capture.antigravityHome ?? resolveAntigravityHome(), conversationId);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The turns {@link captureAntigravityTranscriptTurn} still has to write (#2246).
+ *
+ * The same rule as `../claude/history`'s, on agy's own key: search backwards
+ * from the newest turn for one that is already a row, and take everything after
+ * it. Record order and never a timestamp — agy stamps `created_at` at
+ * second resolution, so a turn and its own reply routinely share an instant.
+ *
+ * @param turns - Every turn in the window, oldest first
+ */
+async function selectUnwrittenAntigravityTurns(target, turns) {
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        const requestId = (0, agent_transcript_1.antigravityTurnRequestId)(turn.conversationId, turn.stepIndex);
+        if (!findMessageByRequestId(db, target.worktreeId, requestId))
+            continue;
+        return {
+            turns: turns.slice(index + 1),
+            previousStartedAt: turn.startedAt,
+            anchored: true,
+        };
+    }
+    return {
+        turns: turns.slice(-1),
+        previousStartedAt: turns.length > 1 ? turns[turns.length - 2].startedAt : 0,
+        anchored: false,
+    };
+}
 /**
  * The transcript file for this conversation, or null.
  *
@@ -392,12 +476,16 @@ async function isReadableFile(path) {
  *
  * Never throws; `recordUserTurn` reports its failures in the return value.
  */
-async function recordAntigravityUserTurn(target, turn) {
+async function recordAntigravityUserTurn(target, turn, previousStartedAt = 0) {
     const skipped = { outcome: 'skipped', messageId: null, timestampMs: null };
     const prompt = turn.prompt;
     if (!prompt)
         return skipped;
-    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.antigravityPromptRequestId)(turn.conversationId, prompt.stepIndex), prompt.text, prompt.timestampMs);
+    // Issue #2246: a turn read late is a turn whose `/send` row may be older than
+    // #2196's symmetric window reaches. The previous turn's start is the tightest
+    // honest bound, and it only ever widens the search.
+    const adoption = previousStartedAt > 0 ? { adoptionFromMs: previousStartedAt } : {};
+    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.antigravityPromptRequestId)(turn.conversationId, prompt.stepIndex), prompt.text, prompt.timestampMs, adoption);
     if (recorded.outcome === 'failed') {
         logger.warn('antigravity-transcript-user-turn-failed', {
             worktreeId: target.worktreeId,
@@ -444,12 +532,31 @@ function resolveAssistantTimestampMs(turn, userRow) {
  */
 async function writeAntigravityTurn(target, turn, rendered, timestampMs, path) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    if (!(0, transcript_1.isAntigravityTurnWritable)(turn)) {
+        // agy has not finished this answer and no later prompt has taken over, so
+        // what is in the file is a turn in progress. Writing it would put a reply
+        // with its last paragraph missing into History permanently — the row is
+        // keyed on `(conversationId, step_index)`, so every later read finds it and
+        // answers "already saved". That is Issue #2264, reported against claude and
+        // structurally identical here: a turn cut off after its `tool_calls` renders
+        // a *non-empty* body, so the emptiness guard below cannot see it.
+        logger.info('antigravity-transcript-turn-open', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            conversationId: rendered.conversationId,
+            stepIndex: rendered.stepIndex,
+            records: turn.records.length,
+            textBlocks: rendered.textBlocks,
+            toolBlocks: rendered.toolBlocks,
+        });
+        return false;
+    }
     if (rendered.body.length === 0) {
-        // A turn that said nothing yet. Unlike codex there is no `task_complete` to
-        // tell an unfinished turn from a silent one, so the body is the only
-        // evidence there is — and answering false is right for both readings: the
-        // scraper keeps the reply if there was one, and an empty row that would show
-        // as a blank answer forever is never written.
+        // A turn that said nothing. agy has no `task_complete`, so a closed turn
+        // that rendered to nothing and an interrupted one look alike here — and
+        // answering false is right for both readings: the scraper keeps the reply if
+        // there was one, and an empty row that would show as a blank answer forever
+        // is never written.
         logger.info('antigravity-transcript-turn-empty', {
             worktreeId: target.worktreeId,
             instanceId,

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

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