commandmate 0.33.1 → 0.33.2

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' };

package/dist/server/src/lib/polling/response-checker.js

@@ -1,11 +1,15 @@
 "use strict";
 /** Response checking and extraction logic for CLI tool polling (Issue #575 split from response-poller.ts). */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_SCRAPE_HOLD_MS = void 0;
 exports.incompleteResult = incompleteResult;
 exports.buildPromptExtractionResult = buildPromptExtractionResult;
 exports.detectPromptOnCleanFrame = detectPromptOnCleanFrame;
 exports.detectPromptWithOptions = detectPromptWithOptions;
 exports.extractResponse = extractResponse;
+exports.resetPendingScrapedResponses = resetPendingScrapedResponses;
+exports.hasPendingScrapedResponse = hasPendingScrapedResponse;
+exports.flushPendingScrapedResponse = flushPendingScrapedResponse;
 exports.checkForResponse = checkForResponse;
 const cli_session_1 = require("../../lib/session/cli-session");
 const db_instance_1 = require("../../lib/db/db-instance");
@@ -30,6 +34,7 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const prompt_dedup_state_1 = require("./prompt-dedup-state");
 const response_dedup_1 = require("./response-dedup");
 const structured_history_gate_1 = require("./structured-history-gate");
+const stop_history_capture_1 = require("../../lib/hooks/stop-history-capture");
 const relay_triggers_1 = require("../../lib/relay/relay-triggers");
 // Issue #2317 Phase D: while a human holds the pane's geometry, the frame is
 // their terminal (44 rows), not the 1000-row canvas every rule below was
@@ -735,6 +740,176 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
 // ============================================================================
 // checkForResponse (exported for response-poller-core.ts)
 // ============================================================================
+// ============================================================================
+// The held scrape (Issue #2436)
+// ============================================================================
+/**
+ * How long a scraped reply is held while its transcript finishes closing.
+ *
+ * Derived from `STOP_TRANSCRIPT_DEFERRED_DELAYS_MS`, not spelled again: those
+ * are the instants the Stop receiver re-reads the transcript at after it has
+ * answered the agent (#2398), so their SUM is the moment after which nobody is
+ * still trying. Holding past it would be holding for a row that has no producer
+ * left; stopping short of it would race the producer that is still running.
+ *
+ * The measured gap this covers is under a second — codex 2026-09-08 appended
+ * `task_complete` ~700 ms after the frame went quiet — so the budget is roughly
+ * ten times the case it exists for, spent only on turns that ask for it.
+ */
+exports.PENDING_SCRAPE_HOLD_MS = stop_history_capture_1.STOP_TRANSCRIPT_DEFERRED_DELAYS_MS.reduce((total, delay) => total + delay, 0);
+/**
+ * Held scrapes, by poller key.
+ *
+ * **Deliberately not in `./response-dedup`.** That module's two caches are
+ * cleared by `stopPollingByKey` — `clearResponseHashCache` is called from
+ * inside it — so a held reply parked beside them would be dropped by the very
+ * event that has to write it (Issue #2436, requirement B). It lives here, next
+ * to the code that fills it and the code that writes it out, and
+ * `flushPendingScrapedResponse` is what the poller calls before it clears
+ * anything.
+ *
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the poller's bundle and each route's bundle would otherwise
+ * hold a private copy, and a held reply only one bundle can see is a lost one.
+ */
+const pendingScrapedResponses = (globalThis.__pendingScrapedResponses ??= new Map());
+/** Forget every held scrape. Test seam. */
+function resetPendingScrapedResponses() {
+    pendingScrapedResponses.clear();
+}
+/** Whether a scrape is being held for this poller key. Test seam / diagnostics. */
+function hasPendingScrapedResponse(pollerKey) {
+    return pendingScrapedResponses.has(pollerKey);
+}
+/**
+ * Hold this tick's scraped reply instead of writing it (Issue #2436).
+ *
+ * Called when the transcript reader has said `not_yet_closed`: the agent's own
+ * Markdown for this turn is coming, and writing the pane's copy now is what put
+ * 234,323 characters of prompt echo, intermediate output and footer into
+ * History beside the real answer.
+ *
+ * A second hold for the same key REPLACES the content and keeps the original
+ * deadline. Replaces, because a frame that moved on is a better copy of the
+ * same turn; keeps, because a pane that redraws every tick would otherwise push
+ * its own deadline forward forever and the hold would stop being bounded.
+ */
+function holdScrapedResponse(pollerKey, pending) {
+    const existing = pendingScrapedResponses.get(pollerKey);
+    if (existing) {
+        existing.content = pending.content;
+        return;
+    }
+    pendingScrapedResponses.set(pollerKey, pending);
+}
+/**
+ * Drop a held scrape without writing it (Issue #2436).
+ *
+ * The one thing that justifies dropping it: the transcript reader has since
+ * written the turn as the agent's own Markdown, so the pane's copy is the
+ * duplicate this Issue exists to stop.
+ */
+function discardPendingScrapedResponse(pollerKey) {
+    pendingScrapedResponses.delete(pollerKey);
+}
+/**
+ * Write a held scrape now, whatever the clock says (Issue #2436).
+ *
+ * Exported because `response-poller-core` calls it from `stopPollingByKey`,
+ * which is every way a polling cycle ends: an explicit stop, the session going
+ * away, `MAX_POLLING_DURATION`, and the restart that opens the NEXT turn. A
+ * held reply must not be able to outlive the cycle that holds it — the caches
+ * that key it are cleared in that same function, and a reply nobody writes is
+ * strictly worse than the duplicate row this Issue is trading against.
+ *
+ * **Deliberately bypasses `isDuplicateResponse`.** The hash for this content was
+ * registered by the tick that decided to hold it (the dedup guard's check is
+ * also its write), so a re-check here would answer "duplicate" for the reply
+ * that has never been saved. That is requirement A of the Issue in one line.
+ *
+ * Synchronous through the row: `better-sqlite3` is, and this runs on shutdown
+ * paths where an awaited continuation may never be reached. The Markdown
+ * conversation log is fired afterwards and not waited for, because it is a
+ * secondary record and the row is the one History reads.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @param reason - What ended the hold; logged, for the operator reading back
+ * @returns Whether a held reply was written
+ */
+function flushPendingScrapedResponse(pollerKey, reason) {
+    const pending = pendingScrapedResponses.get(pollerKey);
+    if (!pending)
+        return false;
+    pendingScrapedResponses.delete(pollerKey);
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        const message = (0, db_1.createMessage)(db, {
+            worktreeId: pending.worktreeId,
+            role: 'assistant',
+            content: pending.content,
+            messageType: 'normal',
+            timestamp: pending.timestamp,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            summary: pending.summary,
+            logFileName: pending.logFileName,
+            requestId: pending.requestId,
+        });
+        (0, ws_server_1.broadcastMessage)('message', { worktreeId: pending.worktreeId, message });
+        logger.info('pending-scrape-flushed', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            reason,
+            scrapedLength: pending.content.length,
+            heldForMs: Date.now() - pending.timestamp.getTime(),
+        });
+        void (0, conversation_logger_1.recordClaudeConversation)(db, pending.worktreeId, pending.content, pending.cliToolId).catch(() => { });
+        return true;
+    }
+    catch (error) {
+        logger.warn('pending-scrape-flush-failed', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            reason,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * End a hold whose deadline has passed, one way or the other (Issue #2436).
+ *
+ * Run at the top of every tick, because the tick that has to notice an expiry
+ * is very often one that returns early — a static frame yields no new lines for
+ * a scrollback tool and is a duplicate for an alternate-screen one, and neither
+ * of those paths reaches the save block at the bottom of `checkForResponse`.
+ *
+ * The reader is asked ONE more time before the row is written. By the deadline
+ * the throttled recheck (#2399) has usually already captured the turn and
+ * dropped the hold, but the two are not in step — the recheck is every third
+ * duplicate tick and this is a wall clock — and a last read costs one tail
+ * parse against writing a pane dump that is about to be superseded.
+ */
+async function settleExpiredPendingScrapedResponse(pollerKey) {
+    const pending = pendingScrapedResponses.get(pollerKey);
+    if (!pending || Date.now() < pending.expiresAt)
+        return;
+    const captured = await (0, structured_history_gate_1.captureStructuredHistoryTurn)(pending.worktreeId, pending.cliToolId, pending.instanceId, { worktreePath: pending.worktreePath, transcriptPathHint: pending.transcriptPathHint });
+    if (captured) {
+        discardPendingScrapedResponse(pollerKey);
+        (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
+        logger.info('pending-scrape-superseded', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            heldForMs: Date.now() - pending.timestamp.getTime(),
+        });
+        return;
+    }
+    flushPendingScrapedResponse(pollerKey, 'hold-expired');
+}
 /**
  * Record what the structured writers said about this turn, for the ticks that
  * will not get to ask (Issue #2399).
@@ -784,9 +959,20 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         const running = await (0, cli_session_1.isSessionRunning)(worktreeId, cliToolId, instanceId);
         if (!running) {
             logger.info('session-not-running');
+            // `stopPolling` is what confirms a held scrape here; see
+            // `flushPendingScrapedResponse` and `stopPollingByKey`. Requirement B of
+            // Issue #2436: this return is ~300 lines above the save path, so a hold
+            // released only down there would never be released at all.
             (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             return false;
         }
+        const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
+        // Issue #2436: a scrape held by an earlier tick, whose transcript has now
+        // had its whole budget to close. Ahead of everything below because most
+        // ticks of a finished turn never reach the save path — a static frame is a
+        // duplicate for an alternate-screen tool and yields no new lines for a
+        // scrollback one, and both of those return early.
+        await settleExpiredPendingScrapedResponse(pollerKey);
         // Issue #2317 Phase D: is a human reading this pane at their own terminal
         // size right now, and did they just stop?
         //
@@ -831,7 +1017,6 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // Layer 2: Accumulate TUI content for full-screen TUI tools, so a turn that
         // outgrows the alternate-screen pane keeps the head that has scrolled away.
         if (cliToolId === 'opencode' || cliToolId === 'copilot') {
-            const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             // Issue #1911: opencode is accumulated from the CURRENT TURN'S REGION
             // rather than the whole frame. Feeding the raw pane seeded the accumulator
             // with the previous turn's transcript, the echoed prompt and the bottom
@@ -885,7 +1070,6 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         if (promptDetection.isPrompt) {
             // Issue #565: Content hash-based duplicate prompt prevention
             const promptContent = promptDetection.rawContent || promptDetection.cleanContent;
-            const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             const normalizedForDedup = (0, prompt_dedup_1.normalizePromptForDedup)(promptContent, cliToolId);
             if ((0, prompt_dedup_1.isDuplicatePrompt)(pollerKey, normalizedForDedup)) {
                 // Issue #1695: the log line below is invisible to `commandmate capture
@@ -995,7 +1179,6 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             cleanedResponse = (0, response_cleaner_1.cleanClaudeResponse)(result.response);
         }
         else if (cliToolId === 'copilot') {
-            const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             const accumulatedContent = (0, tui_accumulator_1.getAccumulatedContent)(pollerKey);
             const sourceContent = accumulatedContent || result.response;
             cleanedResponse = (0, response_cleaner_1.cleanCopilotResponse)(sourceContent);
@@ -1003,7 +1186,6 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
         }
         else if (cliToolId === 'opencode') {
-            const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             // Issue #1911 defect 3: opencode wrote to the Layer-2 accumulator but never
             // read it, so any turn longer than the pane was saved without its head.
             //
@@ -1042,7 +1224,6 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // Without this the disabled cursor would leave nothing suppressing re-saves and
         // the poller would append the same finished reply every 2 s.
         if (!lineCountIsCursor) {
-            const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             if ((0, response_dedup_1.isDuplicateResponse)(pollerKey, cleanedResponse)) {
                 // Issue #1695: this branch used to drop the response silently — the
                 // prompt-side guard above has logged its skip since #565, this one
@@ -1092,6 +1273,16 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                 // is neither. Two rows for one turn is the failure this trades for, and
                 // #2401 has already stopped the junk one being picked as a relay's
                 // answer.
+                //
+                // Issue #2436 narrowed what that trade costs, without changing the
+                // decision above. The row this skip cannot retract is now only ever one
+                // the poller had no reason to hold: a turn whose reader said
+                // `not_yet_closed` is held at the save path below rather than written,
+                // so on the ordinary codex turn there is no earlier row here to regret.
+                // What remains is the case the three reasons above are actually about —
+                // a scrape written when the reader could tell us nothing, and a
+                // transcript that closed later anyway — and for that the row stays,
+                // folded rather than deleted on the chat surface (`ChatMessageBubble`).
                 if ((0, response_dedup_1.claimStructuredHistoryRecheck)(pollerKey)) {
                     const recaptured = await (0, structured_history_gate_1.captureStructuredHistoryTurn)(worktreeId, cliToolId, instanceId, {
                         worktreePath: worktree.path,
@@ -1099,6 +1290,11 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                     });
                     if (recaptured) {
                         (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
+                        // Issue #2436: the turn is now the agent's own Markdown, so a
+                        // scrape held for it is exactly the second row this Issue exists
+                        // to stop. Dropped, not written — the only case where dropping a
+                        // held reply loses nothing.
+                        discardPendingScrapedResponse(pollerKey);
                         logger.info('structured-history-recheck-captured', {
                             worktreeId,
                             cliToolId,
@@ -1132,18 +1328,24 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // Markdown and answers true, or answers false and leaves the scrape below to
         // be the only record. `||` and not `&&`: the two are different tools'
         // answers to the same question, and each one is false for the other's tool.
+        //
+        // Issue #2436 adds the third answer. `captureReport.outcome` distinguishes
+        // "the agent has not closed this turn yet" from "there is nothing to read
+        // here", which the boolean could not: both arrived as `false`, and `false`
+        // meant "save the pane's copy". See {@link StructuredHistoryCaptureOutcome}.
+        const captureReport = {};
         const structuredHistoryLive = (0, structured_history_gate_1.isStructuredHistoryWriterLive)(worktreeId, cliToolId, instanceId) ||
             (await (0, structured_history_gate_1.captureStructuredHistoryTurn)(worktreeId, cliToolId, instanceId, {
                 worktreePath: worktree.path,
                 transcriptPathHint: claudeMetadata?.logFilePath ?? null,
-            }));
+            }, captureReport));
         // Issue #2399: remember which way that went, because the next tick may not
         // get here. A `false` is the reader saying "not yet, or not mine", and the
         // dedup guard above turns every following poll of the same static frame into
         // a return — so unless the fact is written down now, the ask never happens
         // again. A `true` settles it: the turn is recorded and there is nothing left
         // to re-ask about.
-        markOrSettleStructuredHistoryRecheck((0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId), structuredHistoryLive);
+        markOrSettleStructuredHistoryRecheck(pollerKey, structuredHistoryLive);
         // Issue #2317 Phase D: the scrape is dropped while the geometry is
         // delegated, and the transcript capture above is what makes that safe.
         //
@@ -1161,8 +1363,20 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // deliberate trade: a missing row is recoverable, a truncated reply saved as
         // the agent's answer is not.
         const suppressScrapedHistory = structuredHistoryLive || delegation.delegated;
+        // Issue #2436: not suppressed — HELD. The reader has read the transcript,
+        // found the newest turn still open and said so, which means the agent's own
+        // Markdown for this turn is on its way. Writing the pane's copy now is what
+        // put a 234,323-character dump of prompt echo, intermediate output and
+        // footer into History beside the real answer, and #2399 explicitly accepted
+        // that trade because the boolean it had could not tell "not yet" from
+        // "never". It can now.
+        //
+        // Everything else this tick does still happens: the cursor advances, the
+        // prompts are marked answered, the waiting episode closes, the push goes
+        // out. Only the two writes that RECORD THE REPLY wait.
+        const holdScrapedHistory = !suppressScrapedHistory && captureReport.outcome === 'not_yet_closed';
         // Create Markdown log file for the conversation pair
-        if (cleanedResponse && !suppressScrapedHistory) {
+        if (cleanedResponse && !suppressScrapedHistory && !holdScrapedHistory) {
             await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId);
         }
         // Mark any pending prompts as answered
@@ -1183,7 +1397,38 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // are not byte-comparable — the pane's copy is hard-wrapped at the pane
         // width and gutter-prefixed, so no content check could ever recognise them
         // as the same reply.
-        if (!suppressScrapedHistory) {
+        if (holdScrapedHistory) {
+            holdScrapedResponse(pollerKey, {
+                worktreeId,
+                cliToolId,
+                instanceId: resolvedInstanceId,
+                content: cleanedResponse,
+                // The instant the turn was JUDGED finished, not the instant the row is
+                // written. History sorts on this, and a row dated at the end of the
+                // hold would sort under the NEXT turn's prompt.
+                timestamp: new Date(),
+                summary: claudeMetadata?.summary,
+                logFileName: claudeMetadata?.logFileName,
+                requestId: claudeMetadata?.requestId,
+                worktreePath: worktree.path,
+                transcriptPathHint: claudeMetadata?.logFilePath ?? null,
+                expiresAt: Date.now() + exports.PENDING_SCRAPE_HOLD_MS,
+            });
+            logger.info('structured-history-scrape-held', {
+                worktreeId,
+                cliToolId,
+                instanceId: resolvedInstanceId,
+                scrapedLength: cleanedResponse.length,
+                holdMs: exports.PENDING_SCRAPE_HOLD_MS,
+            });
+            // The completion edge is announced HERE and not at the flush, because the
+            // turn finished now. A relay waiting on this session gets #2401's grace
+            // window to find a turn-keyed row, which is exactly the row the hold is
+            // waiting for; delaying the announcement by the hold would delay every
+            // delivery by it too.
+            (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, false);
+        }
+        else if (!suppressScrapedHistory) {
             // Create new CLI tool message in database
             const message = (0, db_1.createMessage)(db, {
                 worktreeId,
@@ -1209,6 +1454,10 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, false);
         }
         else {
+            // Issue #2436: a hold from an earlier tick of this same turn is now moot
+            // — the row it was waiting for exists.
+            if (structuredHistoryLive)
+                discardPendingScrapedResponse(pollerKey);
             logger.info('structured-history-scrape-suppressed', {
                 worktreeId,
                 cliToolId,

package/dist/server/src/lib/polling/response-poller-core.js

@@ -365,6 +365,26 @@ function stopPollingByKey(pollerKey, options = {}) {
         });
         return;
     }
+    // Issue #2436: a scraped reply this cycle decided to HOLD — because the
+    // agent's transcript had not closed the turn yet — is confirmed here, before
+    // anything that keys it is dropped. Every way a cycle ends comes through this
+    // function: an explicit stop, `checkForResponse` finding the session gone,
+    // `MAX_POLLING_DURATION`, and the restart that opens the next turn. A hold
+    // that outlived its cycle would be a reply nobody ever writes, which is worse
+    // than the duplicate row the hold is trading against.
+    //
+    // Ahead of `clearResponseHashCache` below, and that ordering is the whole
+    // reason the held reply does not live in `./response-dedup` beside the hash:
+    // it would be cleared by the same call that has to write it.
+    //
+    // `resume` is the one exception, and for the same reason the response hash
+    // survives it: the cycle is not ending, it is being picked up where a prompt
+    // paused it, and the turn the hold belongs to is still the current one. The
+    // hold stays bounded regardless — the first tick of the resumed chain runs
+    // `settleExpiredPendingScrapedResponse`, and by then the deadline has almost
+    // certainly passed.
+    if (!options.resume)
+        (0, response_checker_1.flushPendingScrapedResponse)(pollerKey, 'poller-stopped');
     const owner = coordinator.owners.get(pollerKey);
     // The live owner stopping itself from inside its own tick. Identity, not key
     // equality: a stale generation with the same key was turned away above.

package/dist/server/src/lib/polling/structured-history-gate.js

@@ -161,19 +161,19 @@ function serializePerInstance(key, work) {
  */
 const PULL_TRANSCRIPT_READERS = {
     [tool_id_1.CLAUDE_CLI_TOOL_ID]: {
-        capture: (target, capture) => (0, history_1.captureClaudeTranscriptTurn)(target, capture),
+        capture: (target, capture, report) => (0, history_1.captureClaudeTranscriptTurn)(target, capture, report),
         locate: (target, capture) => (0, history_1.resolveClaudeTranscriptPath)(target, capture),
     },
     [tool_id_2.CODEX_CLI_TOOL_ID]: {
-        capture: (target, capture) => (0, history_2.captureCodexTranscriptTurn)(target, capture),
+        capture: (target, capture, report) => (0, history_2.captureCodexTranscriptTurn)(target, capture, report),
         locate: (target, capture) => (0, history_2.resolveCodexTranscriptPath)(target, capture),
     },
     [tool_id_3.ANTIGRAVITY_CLI_TOOL_ID]: {
-        capture: (target, capture) => (0, history_3.captureAntigravityTranscriptTurn)(target, capture),
+        capture: (target, capture, report) => (0, history_3.captureAntigravityTranscriptTurn)(target, capture, report),
         locate: (target, capture) => (0, history_3.resolveAntigravityTranscriptPath)(target, capture),
     },
     [tool_id_4.COMMAND_CODE_CLI_TOOL_ID]: {
-        capture: (target, capture) => (0, history_4.captureCommandCodeTranscriptTurn)(target, capture),
+        capture: (target, capture, report) => (0, history_4.captureCommandCodeTranscriptTurn)(target, capture, report),
         locate: (target, capture) => (0, history_4.resolveCommandCodeTranscriptPath)(target, capture),
     },
 };
@@ -267,12 +267,23 @@ function isStructuredHistoryWriterLive(worktreeId, cliToolId, instanceId) {
  * not: this runs inside the poller's save path, and an exception here would cost
  * the scraped reply as well as the structured one.
  *
+ * Since Issue #2436 the `false` can be asked to explain itself: pass a
+ * {@link StructuredHistoryCaptureReport} and `outcome` says whether the turn is
+ * merely still open — the row is coming, and a caller holding the pane's copy
+ * should wait — or whether nothing will ever be written for it. The boolean is
+ * unchanged in meaning and in value; see
+ * {@link StructuredHistoryCaptureOutcome} for why the third value is reported
+ * beside it rather than in it.
+ *
  * @param worktreeId - The worktree
  * @param cliToolId - The tool driving the pane
  * @param instanceId - The agent instance; defaults to the primary
  * @param capture - Where to look; see {@link StructuredHistoryCapture}
+ * @param report - Optional out-parameter; see {@link StructuredHistoryCaptureReport}
  */
-async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, capture) {
+async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, capture, report) {
+    if (report)
+        report.outcome = 'unavailable';
     if (!isPullTranscriptHistory(cliToolId))
         return false;
     const reader = PULL_TRANSCRIPT_READERS[cliToolId];
@@ -286,8 +297,17 @@ async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, c
     }
     const resolvedInstanceId = instanceId ?? cliToolId;
     return serializePerInstance(captureKeyOf(worktreeId, cliToolId, resolvedInstanceId), async () => {
+        // The reader's own report, kept local and copied out below: `report` is
+        // the caller's object and must end up holding one verdict, not whatever
+        // the last reader to touch it happened to leave there.
+        const readerReport = {};
         try {
-            const captured = await reader.capture({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, capture);
+            const captured = await reader.capture({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, capture, readerReport);
+            if (report) {
+                // A reader that says nothing is read as `unavailable` — the pre-#2436
+                // behaviour, and the safe direction: the scraper keeps the turn.
+                report.outcome = captured ? 'captured' : readerReport.outcome ?? 'unavailable';
+            }
             // Issue #2377: the moment a relay is waiting for. This is the single
             // point BOTH triggers of a pull capture pass through — the poller's save
             // path and the Stop hook receiver — which is why the relay needs one