commandmate 0.33.1 → 0.33.2

package/dist/server/src/lib/assistant-response-saver.js

@@ -18,9 +18,43 @@
  * buffer, which is false for alternate-screen tools — those are handled by the
  * response poller instead (Issue #1268 / #1292; see savePendingAssistantResponse).
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectBufferReset = detectBufferReset;
 exports.cleanCliResponse = cleanCliResponse;
+exports.advanceCapturedLineForTranscriptTurn = advanceCapturedLineForTranscriptTurn;
 exports.savePendingAssistantResponse = savePendingAssistantResponse;
 const cli_session_1 = require("./session/cli-session");
 const db_1 = require("./db");
@@ -82,6 +116,31 @@ function detectBufferReset(currentLineCount, lastCapturedLine) {
     }
     return { bufferReset: false, reason: null };
 }
+/**
+ * How many rows of a capture count as "read so far".
+ *
+ * Trailing blank rows are discarded, for consistency with the response poller's
+ * `extractResponse`: tmux pads the pane out to its height, and counting that
+ * padding inflates the stored cursor so far past the real content that the
+ * poller's dedup check (`result.lineCount <= lastCapturedLine`) can never fire
+ * again.
+ *
+ * The one definition of the count, shared by the two writers of
+ * `session_states.last_captured_line` in this module (Issue #2437): the
+ * pre-send flush and {@link advanceCapturedLineForTranscriptTurn}. Two spellings
+ * of "how far have I read" would be two cursors that disagree.
+ *
+ * @param output - Raw capture
+ * @returns Row count with trailing blank rows removed
+ */
+function countCapturedLines(output) {
+    const lines = output.split('\n');
+    let trimmedLength = lines.length;
+    while (trimmedLength > 0 && lines[trimmedLength - 1].trim() === '') {
+        trimmedLength--;
+    }
+    return trimmedLength;
+}
 /**
  * Time offset (in milliseconds) for assistant message timestamp
  * Ensures assistant response appears before user message in chronological order
@@ -91,8 +150,23 @@ const ASSISTANT_TIMESTAMP_OFFSET_MS = 1;
 /**
  * Clean CLI tool response based on tool type
  *
+ * Every one of `CLI_TOOL_IDS`' eight tools has a branch (Issue #2437). Until
+ * then four of them — codex, command-code, antigravity and vibe-local — fell
+ * through to `output.trim()`, and codex's branch said so in as many words:
+ * *"Codex doesn't need special cleaning"*. It does. What that branch actually
+ * saved was codex's **idle composer**, ANSI and all, as an assistant reply:
+ *
+ * ```text
+ * › Ask Codex to do anything
+ *
+ *   gpt-6-astra xhigh · ~/share/work/… · Main [default]
+ * ```
+ *
+ * See {@link cleanScrollbackResponse} for how the four share one cleaner
+ * without sharing a boundary rule.
+ *
  * @param output - Raw output from CLI tool
- * @param cliToolId - CLI tool identifier (claude, codex, gemini)
+ * @param cliToolId - CLI tool identifier
  * @returns Cleaned response content
  */
 function cleanCliResponse(output, cliToolId) {
@@ -106,12 +180,101 @@ function cleanCliResponse(output, cliToolId) {
         case 'copilot':
             return (0, response_cleaner_1.cleanCopilotResponse)(output);
         case 'codex':
-            // Codex doesn't need special cleaning
-            return output.trim();
+        case 'command-code':
+        case 'antigravity':
+        case 'vibe-local':
+            return (0, response_cleaner_1.cleanScrollbackResponse)(output, cliToolId);
         default:
             return output.trim();
     }
 }
+/**
+ * Move `last_captured_line` past everything a transcript row now covers
+ * (Issue #2437).
+ *
+ * ## The defect this closes
+ *
+ * The pre-send flush ({@link savePendingAssistantResponse}) reads
+ * `lastCapturedLine`, and saves **everything past it** as the pending reply. The
+ * only writer of that cursor used to be the flush itself and the response
+ * poller — the Stop path that writes the agent's OWN Markdown into History
+ * (`hooks/sources/<tool>/history.ts`) never touched it. So on this ordering, which
+ * costs nothing to hit at a 2-second poll interval:
+ *
+ * ```text
+ * 1. turn ends  → the Stop path writes the turn as a Markdown row   (cursor unmoved)
+ * 2. `/send` arrives BEFORE the next poll tick
+ * 3. the flush saves "everything since the cursor" = the whole finished turn
+ * ```
+ *
+ * The second copy is the pane's scrape of the very same turn, so the chat
+ * surface shows one reply twice. A cleaner cannot help: what is duplicated is
+ * the real body, not chrome.
+ *
+ * ## Why a capture rather than an arithmetic bump
+ *
+ * The cursor is a row index into the pane, and the transcript reader never looks
+ * at the pane at all — it reads a JSONL file. The only honest way to say "the
+ * pane up to here is already in History" is to ask the pane how tall it is now.
+ * The capture is the cached one ({@link captureSessionOutput}, 5s TTL shared
+ * with the poller), so a Stop that lands between two ticks usually costs no
+ * `tmux capture-pane` at all.
+ *
+ * ## What it deliberately does not do
+ *
+ * - **Alternate-screen tools are skipped.** For claude, opencode and copilot the
+ *   line count is a screen-row constant rather than a cursor (Issue #1268), and
+ *   {@link savePendingAssistantResponse} refuses to run for them at all — there
+ *   is no cursor here to advance and writing one would be a lie.
+ * - **The cursor only ever moves forward.** A capture shorter than the stored
+ *   value is a buffer reset, and `detectBufferReset` owns that reading; moving
+ *   the cursor backwards from here would hand the flush a range it has already
+ *   saved.
+ * - **It never throws, and never changes the caller's answer.** The transcript
+ *   row is written whether or not this succeeds; a failure here costs one
+ *   duplicated reply, and a failure that propagated would cost the row.
+ *
+ * @param target - The instance whose turn was just written to History
+ * @returns The cursor's new value, or null when it was left where it was
+ */
+async function advanceCapturedLineForTranscriptTurn(target) {
+    const { worktreeId, cliToolId } = target;
+    const resolvedInstanceId = target.instanceId ?? cliToolId;
+    try {
+        if ((0, types_1.usesAlternateScreen)(cliToolId)) {
+            return null;
+        }
+        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, SESSION_OUTPUT_BUFFER_SIZE, target.instanceId);
+        if (!output) {
+            return null;
+        }
+        const currentLineCount = countCapturedLines(output);
+        const { getDbInstance } = await Promise.resolve().then(() => __importStar(require('./db/db-instance')));
+        const db = getDbInstance();
+        const lastCapturedLine = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId)?.lastCapturedLine || 0;
+        if (currentLineCount <= lastCapturedLine) {
+            return null;
+        }
+        (0, db_1.updateSessionState)(db, worktreeId, cliToolId, currentLineCount, target.instanceId);
+        logger.info('transcript:cursor-advanced', {
+            worktreeId,
+            instanceId: resolvedInstanceId,
+            from: lastCapturedLine,
+            to: currentLineCount,
+        });
+        return currentLineCount;
+    }
+    catch (error) {
+        // Never the caller's problem: the transcript row is already written, and the
+        // worst this costs is the duplicate it was meant to prevent.
+        logger.debug('transcript:cursor-advance-failed', {
+            worktreeId,
+            instanceId: resolvedInstanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
 /**
  * Save pending assistant response before a new user message
  *
@@ -170,16 +333,9 @@ async function savePendingAssistantResponse(db, worktreeId, cliToolId, userMessa
         if (!output) {
             return null;
         }
-        // 3. Calculate current line count
-        // Trim trailing empty lines for consistency with response-poller's extractResponse.
-        // Without this, tmux buffer padding inflates the line count, causing the poller's
-        // dedup check (result.lineCount <= lastCapturedLine) to always trigger.
+        // 3. Calculate current line count (see countCapturedLines for the trim).
         const lines = output.split('\n');
-        let trimmedLength = lines.length;
-        while (trimmedLength > 0 && lines[trimmedLength - 1].trim() === '') {
-            trimmedLength--;
-        }
-        const currentLineCount = trimmedLength;
+        const currentLineCount = countCapturedLines(output);
         // 4. Detect buffer reset (Issue #59 fix)
         const { bufferReset, reason } = detectBufferReset(currentLineCount, lastCapturedLine);
         if (bufferReset) {

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

@@ -91,7 +91,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANTIGRAVITY_CLI_HOME_SEGMENTS = exports.ANTIGRAVITY_TRANSCRIPT_TAIL_BYTES = void 0;
+exports.ANTIGRAVITY_TURN_RECHECK_LIMIT = exports.ANTIGRAVITY_CLI_HOME_SEGMENTS = exports.ANTIGRAVITY_TRANSCRIPT_TAIL_BYTES = void 0;
 exports.resetAntigravityTranscriptConversations = resetAntigravityTranscriptConversations;
 exports.resolveAntigravityConversationId = resolveAntigravityConversationId;
 exports.resolveAntigravityHome = resolveAntigravityHome;
@@ -106,6 +106,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");
@@ -288,11 +289,29 @@ function acceptAntigravityTranscriptPath(agyHome, candidate) {
  *
  * Never throws.
  *
+ * **A row this reader wrote is not final (Issue #2438).** Before anything is
+ * written, the newest already-written turns — at most
+ * {@link ANTIGRAVITY_TURN_RECHECK_LIMIT} of them — are re-rendered and compared
+ * against the rows they produced, and a row whose turn now renders *strictly
+ * longer* is replaced in place. agy has no record that closes a turn, so an
+ * interim report reads as a finished answer (`isAntigravityTurnClosingRecord`)
+ * and used to freeze a half-written reply into History forever. That is a
+ * repair and not a second verdict: growing an older row changes neither the
+ * return value nor `report`, both of which are about the **newest** turn.
+ *
+ * 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 AntigravityTranscriptCapture}
+ * @param report - Optional out-parameter; see `StructuredHistoryCaptureReport`
  * @returns Whether History now holds this turn as the agent's own Markdown
  */
-async function captureAntigravityTranscriptTurn(target, capture = {}) {
+async function captureAntigravityTranscriptTurn(target, capture = {}, report) {
     const instanceId = target.instanceId ?? target.cliToolId;
     try {
         const agyHome = capture.antigravityHome ?? resolveAntigravityHome();
@@ -348,12 +367,26 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
             });
         }
         const pending = await selectUnwrittenAntigravityTurns(target, built.turns);
+        // Before anything is written: the rows that are already there (#2438). This
+        // is deliberately ahead of the early return below, because "the newest turn
+        // is already a row" is exactly the state the frozen row the Issue measured
+        // was stuck in — agy said "waiting for the worker", the writer saved that,
+        // and every later read answered true and did nothing while the conclusion
+        // sat in the transcript beside it. Written turns are re-checked whether or
+        // not anything is pending, so an old turn can be repaired in the same pass
+        // that writes a new one.
+        await refreshAntigravityTurnRows(target, built.turns
+            .slice(0, built.turns.length - pending.turns.length)
+            .slice(-exports.ANTIGRAVITY_TURN_RECHECK_LIMIT), path);
         if (pending.turns.length === 0) {
             logger.debug('antigravity-transcript-turns-already-saved', {
                 worktreeId: target.worktreeId,
                 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) {
@@ -380,7 +413,14 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            captured = await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastAntigravityRecordAt(turn), nextTurnOpensAt(pending.turns, userRows, index)), path);
+            captured = await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastAntigravityRecordAt(turn), 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;
     }
@@ -577,6 +617,137 @@ function nextTurnOpensAt(turns, userRows, index) {
         return null;
     return userRows[index + 1]?.timestampMs ?? next.startedAt;
 }
+/**
+ * How many already-written turns are re-rendered and compared (Issue #2438).
+ *
+ * The repair half of #2438 has to look at rows this reader has **already**
+ * written, which is the one thing the anchor rule of
+ * {@link selectUnwrittenAntigravityTurns} deliberately does not do — so it is
+ * bounded here rather than by the read window. Three, the number claude and
+ * command-code settled on in #2264 and for the same arithmetic: the poller runs
+ * every couple of seconds, re-rendering the whole window on every tick would
+ * make a repair the most expensive thing the poll does, and a turn that is going
+ * to grow grows within seconds of being written.
+ *
+ * The cost of the bound is paid by rows a session has already moved three turns
+ * past: those keep whatever they were written with. The measured case — one
+ * conversation whose only turn was `#0` — is inside it by a wide margin.
+ */
+exports.ANTIGRAVITY_TURN_RECHECK_LIMIT = 3;
+/**
+ * Replace a saved row whose body has since grown (Issue #2438).
+ *
+ * The defect this exists for is not that the wrong body was written; it is that
+ * the row was written **early**. `isAntigravityTurnClosingRecord` reads prose
+ * with no `tool_calls` as agy finishing, and an interim report — "waiting for
+ * the worker" — has exactly that shape. The row is keyed
+ * `antigravity-turn:<conversationId>#<stepIndex>`, so once it exists every later
+ * read finds it, answers "already saved", and the gate suppresses the scrape
+ * that could have carried the conclusion instead. Nothing else in the system
+ * ever revisits that row.
+ *
+ * **Strictly longer, never merely different.** Equality is the ordinary case and
+ * must cost nothing, and a body that got *shorter* between two reads is not a
+ * turn that grew — it is a window that slid, or a truncation marker, and
+ * overwriting a full reply with a shorter one is the one outcome worse than the
+ * bug. Longer implies different, so one comparison covers both.
+ *
+ * Only `content` moves. The row's `id`, `request_id`, `timestamp`, worktree,
+ * tool and instance are what History sorts and pairs on, and a repair that
+ * disturbed any of them would move an old answer to the bottom of the
+ * conversation.
+ *
+ * `message_updated`, never `message`: the row already existed and was already
+ * delivered when it was created, so a client that appended instead of replacing
+ * would show the reply twice.
+ *
+ * @param existing - The row `findMessageByRequestId` answered with
+ * @returns Whether the row was replaced
+ */
+async function growAntigravityTurnRow(target, existing, rendered, path) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    // The stored body is the only evidence of what History holds, so a row that
+    // carries none is not evidence that anything grew. Same answer as "not
+    // longer": leave it alone. This runs inside the poller's save path, where the
+    // module contract is that nothing throws.
+    const previous = existing.content;
+    if (typeof previous !== 'string')
+        return false;
+    const previousLength = previous.length;
+    if (rendered.body.length <= previousLength)
+        return false;
+    const [{ getDbInstance }, { updateMessageContent }, { broadcastMessage }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
+    ]);
+    updateMessageContent(getDbInstance(), existing.id, rendered.body);
+    broadcastMessage('message_updated', {
+        worktreeId: target.worktreeId,
+        message: { ...existing, content: rendered.body },
+    });
+    logger.info('antigravity-transcript-turn-updated', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        conversationId: rendered.conversationId,
+        stepIndex: rendered.stepIndex,
+        requestId: existing.requestId,
+        path,
+        previousLength,
+        bodyLength: rendered.body.length,
+        textBlocks: rendered.textBlocks,
+        toolBlocks: rendered.toolBlocks,
+    });
+    return true;
+}
+/**
+ * Re-read the newest already-written turns and grow the short ones (#2438).
+ *
+ * Runs before the pending turns are written and independently of whether there
+ * are any — the case it exists for is precisely the one
+ * {@link captureAntigravityTranscriptTurn} used to return `true` from without
+ * doing anything: the newest turn already has a row, and that row stopped at
+ * agy's interim report.
+ *
+ * Turns that are open again are skipped rather than compared. A turn whose last
+ * record is a `tool_calls` is one agy is still working through, its body is by
+ * definition not the final one, and a repair that raced the agent would rewrite
+ * the row on every poll of a long turn. **This is not a second chance to write
+ * a turn**: a candidate with no row is left alone, because the anchor rule
+ * already decided it is not this pass's to create.
+ *
+ * The database is asked before the turn is rendered, so a candidate with no row
+ * — every candidate, in a session this reader has never written to — costs one
+ * indexed lookup and no Markdown.
+ *
+ * Serialisation is the gate's, per instance: this adds no loop and no timer of
+ * its own, it is one more thing the poll's existing pass does.
+ *
+ * @param candidates - Already-written turns, oldest first, at most
+ *   {@link ANTIGRAVITY_TURN_RECHECK_LIMIT}
+ * @returns How many rows were replaced
+ */
+async function refreshAntigravityTurnRows(target, candidates, path) {
+    if (candidates.length === 0)
+        return 0;
+    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();
+    let updated = 0;
+    for (const turn of candidates) {
+        if (!(0, transcript_1.isAntigravityTurnWritable)(turn))
+            continue;
+        const existing = findMessageByRequestId(db, target.worktreeId, (0, agent_transcript_1.antigravityTurnRequestId)(turn.conversationId, turn.stepIndex));
+        if (!existing)
+            continue;
+        if (await growAntigravityTurnRow(target, existing, (0, transcript_1.renderAntigravityTurn)(turn), path)) {
+            updated += 1;
+        }
+    }
+    return updated;
+}
 /**
  * Write one rendered turn, unless it is already there.
  *
@@ -587,20 +758,36 @@ function nextTurnOpensAt(turns, userRows, index) {
  * Answering **true** for a turn that was already saved is deliberate. It means
  * "History holds this turn as Markdown", which is what the poller needs to know
  * — a second poll of the same finished turn must not save the pane's copy on top
- * of the row this path wrote.
+ * of the row this path wrote. Since #2438 that row is no longer left as it was
+ * found: it is the same comparison {@link growAntigravityTurnRow} makes for the
+ * turns the recheck window covers, made here where both the row and the turn
+ * are already in hand.
  *
  * @returns Whether History holds this turn as the agent's own Markdown
  */
-async function writeAntigravityTurn(target, turn, rendered, timestampMs, path) {
+async function writeAntigravityTurn(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.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
+        // with its last paragraph missing into History — 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.
+        //
+        // #2438 made such a row repairable rather than making it acceptable: a
+        // short row only grows while its turn is still among the newest
+        // {@link ANTIGRAVITY_TURN_RECHECK_LIMIT}, and nothing at all rewinds what a
+        // relay already delivered from it. Not writing it in the first place is
+        // still the fix; the repair is the second line.
+        if (report)
+            report.outcome = 'not_yet_closed';
         logger.info('antigravity-transcript-turn-open', {
             worktreeId: target.worktreeId,
             instanceId,
@@ -654,12 +841,20 @@ async function writeAntigravityTurn(target, turn, rendered, timestampMs, path) {
         Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
     ]);
     const db = getDbInstance();
-    if (findMessageByRequestId(db, target.worktreeId, requestId)) {
+    const existing = findMessageByRequestId(db, target.worktreeId, requestId);
+    if (existing) {
         logger.debug('antigravity-transcript-turn-already-saved', {
             worktreeId: target.worktreeId,
             instanceId,
             requestId,
         });
+        // The row may be one of the ones #2438 was reported for — saved at agy's
+        // interim report — and this is the one place that holds both the row and
+        // the turn. The comparison and the notification are not repeated here; see
+        // {@link growAntigravityTurnRow}. The verdict is unchanged: History holds
+        // this turn either way, and `report.outcome` is about this turn's
+        // completeness rather than about an edit.
+        await growAntigravityTurnRow(target, existing, rendered, path);
         return true;
     }
     const message = createMessage(db, {

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,