commandmate 0.33.0 → 0.33.2

package/dist/server/src/lib/db/migrations/runner.js

@@ -17,7 +17,7 @@ const path_1 = __importDefault(require("path"));
  * Current schema version
  * Increment this when adding new migrations
  */
-exports.CURRENT_SCHEMA_VERSION = 60;
+exports.CURRENT_SCHEMA_VERSION = 61;
 /**
  * Get current schema version from database
  */

package/dist/server/src/lib/db/migrations/v61-session-notes.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Migration v61: the one-line note an operator keeps beside a session (#2427).
+ *
+ * ## What a row is, and what it is emphatically not
+ *
+ * One row is a free-text reminder of what THIS session was last asked to do —
+ * "#2427 の DB 層", "レビュー待ち" — rewritten every time the operator hands the
+ * session a new instruction. It exists because a four-way split shows four
+ * terminals whose headers all read `claude`, and the pane that is three
+ * scrollbacks deep gives no answer to "which one was doing the migration".
+ *
+ * It is **not** an alias. `agent_instances.alias` is a *resolution key*: since
+ * Issue #2376 `--instance レビュー担当` finds the roster row whose alias matches,
+ * so an alias is a name the routing layer reads. A note is read by human eyes
+ * only, and nothing in `resolveInstanceSelector` (the `/resolve-target` route)
+ * or in `resolveInstanceCliTool` looks at this table. That separation is the
+ * point of storing it apart from the roster rather than widening the alias: a
+ * memo the operator rewrites hourly must never be able to change where the next
+ * `send` lands.
+ *
+ * ## Why a table of its own rather than a column on `agent_instances`
+ *
+ * The reason v59 gives, unchanged: `setAgentInstances` is a full REPLACE —
+ * `PATCH /api/worktrees/[id]` posts the whole roster and the write deletes every
+ * row for the worktree and re-inserts from the payload, which is
+ * `AgentInstance[]` (id, tool, alias, order) and nothing else. A `note` column
+ * there would be silently emptied every time somebody renamed an instance or
+ * dragged one up the list — i.e. by the two operations most likely to happen
+ * while a note is worth keeping. A separate table survives the replace, and
+ * `pruneSessionNotes` removes the rows whose instance genuinely went away.
+ *
+ * It also keeps `AgentInstance` — which is the roster PATCH's *input* shape, not
+ * merely its output — free of a field the writer would have to echo back to
+ * avoid erasing it.
+ *
+ * ## Column notes
+ *
+ * - **`note` is NOT NULL and a row means a note exists.** Clearing the text
+ *   deletes the row (see `setSessionNote`) rather than storing `''`: an empty
+ *   note and no note are indistinguishable to every reader, and the delete keeps
+ *   the table to the sessions somebody actually annotated. That is also what
+ *   makes "the note is empty" renderable as *absence* in the split header, which
+ *   the Issue asks for.
+ * - **`updated_at` is displayed, not just bookkeeping.** The Issue's acceptance
+ *   condition is that the note carries the time it was written, so the column is
+ *   part of the payload rather than an audit field. Epoch milliseconds, matching
+ *   v44 onward.
+ * - **`worktree_id` is spelled conventionally** so `getWorktreeChildTables()`
+ *   finds it by introspection: the row then follows a worktree id rename
+ *   (v54/v55) and is swept when the worktree is deleted, which is exactly as
+ *   long as a note about one of that worktree's sessions can mean anything.
+ *
+ * The primary key is `(worktree_id, instance_id)` — the identity
+ * `agent_instances` uses and the identity a note is about. `cli_tool_id` is
+ * deliberately absent for v59's reason: an instance id belongs to one tool by
+ * construction (`resolveInstanceCliTool`), so a composite including it would let
+ * one session hold two contradictory notes.
+ *
+ * The rollback drops the table, which is the whole of what this migration adds.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v61_migrations = void 0;
+exports.v61_migrations = [
+    {
+        version: 61,
+        name: 'session-notes',
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS session_notes (
+          worktree_id TEXT NOT NULL,
+          instance_id TEXT NOT NULL,
+          note TEXT NOT NULL,
+          updated_at INTEGER NOT NULL,
+
+          PRIMARY KEY (worktree_id, instance_id),
+          FOREIGN KEY (worktree_id) REFERENCES worktrees(id) ON DELETE CASCADE
+        );
+      `);
+        },
+        down: (db) => {
+            db.exec('DROP TABLE IF EXISTS session_notes;');
+        },
+    },
+];

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,

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,