commandmate 0.33.1 → 0.33.3

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

@@ -76,6 +76,8 @@ exports.isAntigravityTurnClosingRecord = isAntigravityTurnClosingRecord;
 exports.isAntigravityTurnWritable = isAntigravityTurnWritable;
 exports.isAntigravityPromptRecord = isAntigravityPromptRecord;
 exports.renderAntigravityTurn = renderAntigravityTurn;
+exports.antigravityTurnLastRecordAt = antigravityTurnLastRecordAt;
+exports.resolveAntigravityTurnCompletion = resolveAntigravityTurnCompletion;
 const event_mapper_1 = require("../event-mapper");
 const turn_body_1 = require("../turn-body");
 /**
@@ -444,3 +446,104 @@ function renderAntigravityTurn(turn) {
         unknownRecordTypes: [...unknown],
     };
 }
+/**
+ * Epoch ms of the newest record agy wrote inside this turn, or 0 (Issue #2443).
+ *
+ * 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. The prompt record is deliberately
+ * outside the walk — `records` holds everything *after* the `USER_INPUT` — which
+ * is why {@link resolveAntigravityTurnCompletion} floors the comparison at
+ * {@link AntigravityTurnAccumulator.startedAt} as well.
+ *
+ * @returns Epoch ms, or 0 when the turn has no timestamped record
+ */
+function antigravityTurnLastRecordAt(turn) {
+    let at = 0;
+    for (const record of turn.records) {
+        if (record.timestampMs !== null && record.timestampMs > at)
+            at = record.timestampMs;
+    }
+    return at;
+}
+/**
+ * Whether agy has vouched for this turn's body (Issue #2443).
+ *
+ * ## What this is separate from, and why the separation is the Issue
+ *
+ * {@link isAntigravityTurnWritable} answers "may a row be written from this
+ * turn". It has to be generous — agy writes **no record that closes a turn**, so
+ * the shape of the last thing it wrote is all there is, and an interim report
+ * ("waiting for the worker") is prose with no `tool_calls` exactly like a
+ * conclusion is. #2438 made the row that follows from that repairable. What it
+ * could not make repairable is everything a save *triggers*: a relay delivering
+ * the interim body to the session that asked for the answer cannot be taken
+ * back, and `broadcastMessage('message_updated', …)` does not rewind it.
+ *
+ * So this is the second question — "is this body final" — and it is answered
+ * from a different kind of evidence, deliberately:
+ *
+ *  - **not the wording.** "waiting", "Waiting for" and their translations are a
+ *    model's prose, and a rule keyed on them is wrong the first time the model
+ *    is asked to answer in another language or writes a conclusion that mentions
+ *    waiting.
+ *  - **not a fixed quiet period.** The gaps measured on the reporting machine
+ *    were 3 / 58 / 156 s from an interim candidate to the next record and 9 /
+ *    113 / 118 s from the final one, which overlap: no constant separates them.
+ *  - **not `status: DONE`** (all 15 measured candidates carry it, early and
+ *    final alike) **and not `truncated_fields`**, which is agy saying it
+ *    shortened a field.
+ *
+ * ## The evidence that is used
+ *
+ * agy's own `Stop` hook, correlated by instant. `Stop` is agy reporting that its
+ * loop ended, and CommandMate already records when one arrived
+ * (`session/agent-event-state`'s `getLastStopEventAt`). What makes it usable
+ * despite `source.ts`'s warning that a `Stop` can be answered with
+ * `{"decision":"continue"}` is that the correlation is an ordering rather than a
+ * flag: a stop is evidence about the file **as it was when the stop arrived**.
+ *
+ *  - A resumed loop appends records *after* the stop, which pushes
+ *    `lastRecordAt` past `stopAt` and takes the confirmation away again. The
+ *    evidence therefore withdraws itself in exactly the case the warning is
+ *    about, with no `continue`-detection of its own.
+ *  - A stop belonging to the *previous* turn is older than this turn's records
+ *    and confirms nothing.
+ *  - No stop at all — hooks not wired up, agy killed, CommandMate restarted
+ *    since — is `no-stop-event`, and the caller keeps the body provisional
+ *    rather than promoting it.
+ *
+ * The residual is agy's clock resolution: `created_at` is written to the second,
+ * so a record appended in the same second as the stop compares equal to it.
+ * That is a sub-second window, it is bounded by one `created_at` tick, and the
+ * direction of the error is a body confirmed one record early rather than a turn
+ * confirmed that never ended.
+ *
+ * Pure: the stop instant is a parameter, so this file keeps its no-filesystem,
+ * no-database, no-`globalThis` contract and the rule is a property a test states
+ * against values rather than against a running server.
+ *
+ * @param turn - The turn to judge
+ * @param stopAt - Epoch ms of this instance's last `Stop`, or null when none has
+ *   been received
+ */
+function resolveAntigravityTurnCompletion(turn, stopAt) {
+    const lastRecordAt = antigravityTurnLastRecordAt(turn);
+    const base = { confirmed: false, lastRecordAt, stopAt };
+    // A turn agy is still working through has no final body to vouch for. Asked
+    // before the clock questions so that "it is still running" never reads as
+    // "its records are unstamped".
+    if (!isAntigravityTurnWritable(turn))
+        return { ...base, reason: 'turn-open' };
+    if (lastRecordAt <= 0)
+        return { ...base, reason: 'no-timestamped-record' };
+    if (stopAt === null)
+        return { ...base, reason: 'no-stop-event' };
+    // `startedAt` as well as the newest record: a turn whose records all predate
+    // its own prompt is a shape this reader has not seen, and taking the later of
+    // the two cannot make the test easier to pass.
+    if (stopAt < Math.max(lastRecordAt, turn.startedAt)) {
+        return { ...base, reason: 'stop-before-last-record' };
+    }
+    return { confirmed: true, reason: 'stop-after-last-record', lastRecordAt, stopAt };
+}

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

@@ -104,6 +104,7 @@ const os_1 = require("os");
 const path_1 = require("path");
 const auto_yes_state_1 = require("../../../../lib/auto-yes-state");
 const user_turn_recorder_1 = require("../../../../lib/history/user-turn-recorder");
+const assistant_response_saver_1 = require("../../../../lib/assistant-response-saver");
 const logger_1 = require("../../../../lib/logger");
 const agent_transcript_1 = require("../../../../types/agent-transcript");
 const transcript_1 = require("./transcript");
@@ -266,10 +267,18 @@ function acceptClaudeTranscriptHint(homeDir, hint) {
  *
  * Never throws.
  *
+ * Since Issue #2436 the false can explain itself: pass a
+ * `StructuredHistoryCaptureReport` and `outcome` is set to `'not_yet_closed'`
+ * when the newest turn is one the agent has not finished writing — the case the
+ * `-turn-open` line below reports, and the one where the caller's scraped copy
+ * is worth holding rather than saving. Every other false leaves it unset, which
+ * the gate reads as `'unavailable'`.
+ *
  * @param target - The instance whose turn just ended
+ * @param report - Optional out-parameter; see `StructuredHistoryCaptureReport`
  * @returns Whether History now holds this instance's newest turn as Markdown
  */
-async function captureClaudeTranscriptTurn(target, capture) {
+async function captureClaudeTranscriptTurn(target, capture, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
     try {
         const homeDir = capture.homeDir ?? (0, os_1.homedir)();
@@ -340,6 +349,9 @@ async function captureClaudeTranscriptTurn(target, capture) {
                 instanceId,
                 turnsInWindow: built.turns.length,
             });
+            // Issue #2437: this turn is already History's Markdown, so the pane rows
+            // behind it must stop being "unsaved output" the pre-send flush can pick up.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
             return true;
         }
         if (pending.turns.length > 1) {
@@ -374,7 +386,14 @@ async function captureClaudeTranscriptTurn(target, capture) {
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            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);
+            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, report);
+        }
+        if (captured) {
+            // Issue #2437: History now holds this turn as the agent's own Markdown.
+            // Park the pre-send flush's cursor past the pane rows it covers, or a
+            // `/send` arriving before the next poll tick saves the whole finished turn
+            // a second time.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
         }
         return captured;
     }
@@ -925,8 +944,13 @@ async function refreshClaudeTurnRows(target, candidates, path) {
  *
  * @returns Whether History holds this turn as the agent's own Markdown
  */
-async function writeClaudeTurn(target, turn, rendered, timestampMs, path) {
+async function writeClaudeTurn(target, turn, rendered, timestampMs, path, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    // Issue #2436: the caller's report is about the turn THIS call is deciding.
+    // The loop above walks oldest-first, so a verdict left by an earlier turn has
+    // to be cleared before this one's is written.
+    if (report)
+        report.outcome = undefined;
     if (!(0, transcript_1.isClaudeTurnWritable)(turn)) {
         // The agent has not said `end_turn` for this prompt and no later prompt has
         // taken over, so what is in the file is a turn in progress. Writing it would
@@ -941,6 +965,8 @@ async function writeClaudeTurn(target, turn, rendered, timestampMs, path) {
         // Handing it back to the scraper costs the Markdown rendering for this turn
         // and nothing else: the Stop receiver asks again after a short delay, and
         // the poller asks again when the pane returns to the composer.
+        if (report)
+            report.outcome = 'not_yet_closed';
         logger.info('claude-transcript-turn-open', {
             worktreeId: target.worktreeId,
             instanceId,

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

@@ -101,6 +101,7 @@ const path_1 = require("path");
 const auto_yes_state_1 = require("../../../../lib/auto-yes-state");
 const transcript_tail_1 = require("../../../../lib/history/transcript-tail");
 const user_turn_recorder_1 = require("../../../../lib/history/user-turn-recorder");
+const assistant_response_saver_1 = require("../../../../lib/assistant-response-saver");
 const logger_1 = require("../../../../lib/logger");
 const agent_transcript_1 = require("../../../../types/agent-transcript");
 const transcript_1 = require("./transcript");
@@ -332,11 +333,19 @@ async function scanForRollout(dir, sessionId, depth) {
  *
  * Never throws.
  *
+ * Since Issue #2436 the false can explain itself: pass a
+ * `StructuredHistoryCaptureReport` and `outcome` is set to `'not_yet_closed'`
+ * when the newest turn is one the agent has not finished writing — the case the
+ * `-turn-open` line below reports, and the one where the caller's scraped copy
+ * is worth holding rather than saving. Every other false leaves it unset, which
+ * the gate reads as `'unavailable'`.
+ *
  * @param target - The instance whose turn just ended
  * @param capture - See {@link CodexTranscriptCapture}
+ * @param report - Optional out-parameter; see `StructuredHistoryCaptureReport`
  * @returns Whether History now holds this turn as the agent's own Markdown
  */
-async function captureCodexTranscriptTurn(target, capture = {}) {
+async function captureCodexTranscriptTurn(target, capture = {}, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
     try {
         const codexHome = capture.codexHome ?? resolveCodexHome();
@@ -395,6 +404,9 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
                 instanceId,
                 turnsInWindow: built.turns.length,
             });
+            // Issue #2437: this turn is already History's Markdown, so the pane rows
+            // behind it must stop being "unsaved output" the pre-send flush can pick up.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
             return true;
         }
         if (pending.turns.length > 1) {
@@ -428,7 +440,14 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.turnId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), windowFacts);
+            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.turnId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), windowFacts, report);
+        }
+        if (captured) {
+            // Issue #2437: History now holds this turn as the agent's own Markdown.
+            // Park the pre-send flush's cursor past the pane rows it covers, or a
+            // `/send` arriving before the next poll tick saves the whole finished turn
+            // a second time.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
         }
         return captured;
     }
@@ -670,14 +689,21 @@ function nextTurnOpensAt(turns, userRows, index) {
  *
  * @returns Whether History holds this turn as the agent's own Markdown
  */
-async function writeCodexTurn(target, turn, rendered, timestampMs, windowFacts) {
+async function writeCodexTurn(target, turn, rendered, timestampMs, windowFacts, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    // Issue #2436: the caller's report is about the turn THIS call is deciding.
+    // The loop above walks oldest-first, so a verdict left by an earlier turn has
+    // to be cleared before this one's is written.
+    if (report)
+        report.outcome = undefined;
     if (!turn.closed) {
         // codex has not written the `task_complete` for this `turn_id` yet, so what
         // is in the file is a turn in progress. Writing it would put a truncated
         // reply in History permanently — and unlike an empty one, a truncated one
         // looks finished. Handing it back to the scraper costs the Markdown
         // rendering for this turn and nothing else.
+        if (report)
+            report.outcome = 'not_yet_closed';
         logger.info('codex-transcript-turn-open', {
             worktreeId: target.worktreeId,
             instanceId,

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

@@ -135,6 +135,7 @@ const path_1 = require("path");
 const auto_yes_state_1 = require("../../../../lib/auto-yes-state");
 const transcript_tail_1 = require("../../../../lib/history/transcript-tail");
 const user_turn_recorder_1 = require("../../../../lib/history/user-turn-recorder");
+const assistant_response_saver_1 = require("../../../../lib/assistant-response-saver");
 const logger_1 = require("../../../../lib/logger");
 const agent_transcript_1 = require("../../../../types/agent-transcript");
 const transcript_1 = require("./transcript");
@@ -325,10 +326,18 @@ async function findCommandCodeTranscriptPath(homeDir, sessionId) {
  *
  * Never throws.
  *
+ * Since Issue #2436 the false can explain itself: pass a
+ * `StructuredHistoryCaptureReport` and `outcome` is set to `'not_yet_closed'`
+ * when the newest turn is one the agent has not finished writing — the case the
+ * `-turn-open` line below reports, and the one where the caller's scraped copy
+ * is worth holding rather than saving. Every other false leaves it unset, which
+ * the gate reads as `'unavailable'`.
+ *
  * @param target - The instance whose turn just ended
+ * @param report - Optional out-parameter; see `StructuredHistoryCaptureReport`
  * @returns Whether History now holds this instance's newest turn as Markdown
  */
-async function captureCommandCodeTranscriptTurn(target, capture) {
+async function captureCommandCodeTranscriptTurn(target, capture, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
     try {
         const homeDir = capture.commandCodeHome ?? (0, os_1.homedir)();
@@ -394,6 +403,9 @@ async function captureCommandCodeTranscriptTurn(target, capture) {
                 instanceId,
                 turnsInWindow: built.turns.length,
             });
+            // Issue #2437: this turn is already History's Markdown, so the pane rows
+            // behind it must stop being "unsaved output" the pre-send flush can pick up.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
             return true;
         }
         if (pending.turns.length > 1) {
@@ -426,7 +438,14 @@ async function captureCommandCodeTranscriptTurn(target, capture) {
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            captured = await writeCommandCodeTurn(target, turn, (0, transcript_1.renderCommandCodeTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.promptId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), path);
+            captured = await writeCommandCodeTurn(target, turn, (0, transcript_1.renderCommandCodeTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.promptId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), path, report);
+        }
+        if (captured) {
+            // Issue #2437: History now holds this turn as the agent's own Markdown.
+            // Park the pre-send flush's cursor past the pane rows it covers, or a
+            // `/send` arriving before the next poll tick saves the whole finished turn
+            // a second time.
+            await (0, assistant_response_saver_1.advanceCapturedLineForTranscriptTurn)(target);
         }
         return captured;
     }
@@ -773,8 +792,13 @@ async function refreshCommandCodeTurnRows(target, candidates, path) {
  *
  * @returns Whether History holds this turn as the agent's own Markdown
  */
-async function writeCommandCodeTurn(target, turn, rendered, timestampMs, path) {
+async function writeCommandCodeTurn(target, turn, rendered, timestampMs, path, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
+    // Issue #2436: the caller's report is about the turn THIS call is deciding.
+    // The loop above walks oldest-first, so a verdict left by an earlier turn has
+    // to be cleared before this one's is written.
+    if (report)
+        report.outcome = undefined;
     if (!(0, transcript_1.isCommandCodeTurnWritable)(turn)) {
         // The agent's last word in this turn reached for a tool and no later prompt
         // has taken over, so what is in the file is a turn in progress. Writing it
@@ -789,6 +813,8 @@ async function writeCommandCodeTurn(target, turn, rendered, timestampMs, path) {
         // Handing it back to the scraper costs the Markdown rendering for this turn
         // and nothing else: the Stop receiver asks again after a short delay, and
         // the poller asks again when the pane returns to the composer.
+        if (report)
+            report.outcome = 'not_yet_closed';
         logger.info('command-code-transcript-turn-open', {
             worktreeId: target.worktreeId,
             instanceId,

package/dist/server/src/lib/hooks/stop-history-capture.js

@@ -248,7 +248,12 @@ async function readAfterResponding(gate, worktree, cliToolId, instanceId, captur
     try {
         for (const [index, delayMs] of delaysMs.entries()) {
             await sleep(delayMs);
-            const captured = await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
+            // Issue #2436: the boolean is the verdict, the report says why. Read
+            // explicitly rather than as truthiness — an open turn answers `false`
+            // here and must keep the loop going, which is exactly the misreading the
+            // Issue's requirement C is about.
+            const report = {};
+            const captured = await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture, report);
             if (captured) {
                 // The line an operator greps when a codex reply did reach the chat
                 // surface: the receiver's own `agent-event-stop-applied` cannot carry
@@ -269,6 +274,10 @@ async function readAfterResponding(gate, worktree, cliToolId, instanceId, captur
                 instanceId,
                 attempt: index + 1,
                 attempts: delaysMs.length,
+                // Issue #2436: `not_yet_closed` here means the next read is worth
+                // taking; anything else means these delays are being spent on a turn
+                // that will never be written by this reader.
+                outcome: report.outcome ?? 'unavailable',
                 elapsedMs: Date.now() - startedAt,
             });
         }
@@ -324,7 +333,15 @@ async function resolveStopTranscriptCapture(worktree, cliToolId, instanceId, opt
         // found that way has no session pointer either, and therefore sends no stop
         // event this path could act on.
         const capture = { worktreePath: worktree.path, transcriptPathHint: null };
-        if (await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture)) {
+        // Issue #2436: `captureStructuredHistoryTurn` still answers a boolean, and
+        // `true` still means — and only means — "the row is written NOW". That is
+        // load-bearing here: the three statuses below are decided by reading this
+        // value as a boolean, and a tri-state RETURN would have made every one of
+        // them truthy, turning an open turn into `captured` and cancelling the very
+        // reads that go on to write it. The third value arrives beside the boolean
+        // instead, in `firstReport`, and is used explicitly.
+        const firstReport = {};
+        if (await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture, firstReport)) {
             return { status: 'captured' };
         }
         // Asked once, before any waiting, on either path: every failure other than
@@ -333,7 +350,14 @@ async function resolveStopTranscriptCapture(worktree, cliToolId, instanceId, opt
         // nor deferring can fix, and an instance with no transcript will not have
         // one in 150 ms either. A transcript that exists does not stop existing
         // between attempts, so this is not re-asked.
-        const hasTranscript = () => gate.hasStructuredHistoryTranscript(worktree.id, cliToolId, instanceId, capture);
+        //
+        // Issue #2436: a reader that answered `not_yet_closed` HAS just read the
+        // file — that is what "the turn in it is still open" is a statement about —
+        // so the probe is skipped and the answer taken from the report. The
+        // fallback is the pre-#2436 round-trip, for a reader that reported nothing.
+        const hasTranscript = () => firstReport.outcome === 'not_yet_closed'
+            ? Promise.resolve(true)
+            : gate.hasStructuredHistoryTranscript(worktree.id, cliToolId, instanceId, capture);
         if (exports.STOP_HOOK_BLOCKS_TRANSCRIPT_CLOSE.has(cliToolId)) {
             const delaysMs = options.deferredDelaysMs ?? exports.STOP_TRANSCRIPT_DEFERRED_DELAYS_MS;
             if (delaysMs.length === 0)
@@ -357,7 +381,8 @@ async function resolveStopTranscriptCapture(worktree, cliToolId, instanceId, opt
         const maxAttempts = Math.max(1, options.maxAttempts ?? exports.STOP_TRANSCRIPT_MAX_ATTEMPTS);
         for (let attempt = 2; attempt <= maxAttempts; attempt += 1) {
             await sleep(retryDelayMs);
-            const captured = await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
+            const report = {};
+            const captured = await gate.captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture, report);
             logger.debug('stop-history-capture-retried', {
                 worktreeId: worktree.id,
                 cliToolId,
@@ -365,6 +390,7 @@ async function resolveStopTranscriptCapture(worktree, cliToolId, instanceId, opt
                 attempt,
                 maxAttempts,
                 captured,
+                outcome: report.outcome ?? 'unavailable',
             });
             if (captured)
                 return { status: 'captured' };