commandmate 0.33.1 → 0.33.3

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

@@ -118,9 +118,41 @@ const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate')
  * can see is not a lock.
  */
 const captureQueue = (globalThis.__structuredHistoryCaptureQueue ??= new Map());
-/** Forget every instance's in-flight capture. Test seam. */
+/**
+ * The last completion each instance was announced for (Issue #2443).
+ *
+ * Keyed by the same triple as {@link captureQueue}, holding whatever
+ * `StructuredHistoryCaptureReport.completionKey` the reader minted. Its only job
+ * is to make the completion edge an *edge*: the poller re-reads a finished turn
+ * every couple of seconds, and #2443 forbids adding a path that re-delivers a
+ * body somebody already has.
+ *
+ * On `globalThis` for the reason {@link captureQueue} is, and in memory for the
+ * reason `session/agent-event-state` gives: the value describes a live session,
+ * and a restart that forgets it costs at most one extra announcement into a
+ * relay whose own stash guard already refuses a second payload.
+ */
+const announcedCompletions = (globalThis.__structuredHistoryAnnouncedCompletions ??= new Map());
+/** Forget every instance's in-flight capture and announced completion. Test seam. */
 function resetStructuredHistoryCaptureQueue() {
     captureQueue.clear();
+    announcedCompletions.clear();
+}
+/**
+ * Whether this completion has already been announced for this instance (#2443).
+ *
+ * A reader that minted no key is always announced — the pre-#2443 behaviour, and
+ * the behaviour claude, codex and command-code keep. Records the key as a side
+ * effect when the answer is "no", because the two steps must not be separable:
+ * an announcement that forgot to record would repeat on the next poll.
+ */
+function claimCompletionAnnouncement(key, completionKey) {
+    if (completionKey === undefined)
+        return true;
+    if (announcedCompletions.get(key) === completionKey)
+        return false;
+    announcedCompletions.set(key, completionKey);
+    return true;
 }
 /** The queue key; the same triple `buildCompositeKey` spells everywhere else. */
 function captureKeyOf(worktreeId, cliToolId, instanceId) {
@@ -161,19 +193,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 +299,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];
@@ -285,9 +328,25 @@ async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, c
         return false;
     }
     const resolvedInstanceId = instanceId ?? cliToolId;
-    return serializePerInstance(captureKeyOf(worktreeId, cliToolId, resolvedInstanceId), async () => {
+    const captureKey = captureKeyOf(worktreeId, cliToolId, resolvedInstanceId);
+    return serializePerInstance(captureKey, 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);
+            // Issue #2443: absent means `settled`, which is what leaves the three
+            // readers that have a turn-closing record exactly where they were.
+            const completion = readerReport.completion ?? 'settled';
+            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';
+                report.completion = completion;
+                report.completionKey = readerReport.completionKey;
+                report.completionReason = readerReport.completionReason;
+            }
             // 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
@@ -297,8 +356,33 @@ async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, c
             // Announced only when the capture actually wrote something: a `false`
             // means the scraper is still the writer for this turn, and the poller's
             // own call below will announce it.
-            if (captured)
-                (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, true);
+            //
+            // Issue #2443 adds the second condition, and it is the whole Issue.
+            // `captured` means History holds the newest turn; it does **not** mean
+            // the agent is finished with it, because antigravity has no record that
+            // closes a turn and an interim report is saved under the same key the
+            // conclusion will land on. Announcing here would hand a relay the
+            // interim body as the answer, and `broadcastMessage('message_updated',
+            // …)` — the repair #2438 added — does not take a delivered message
+            // back. So a provisional capture announces nothing at all; the relay
+            // keeps waiting on the deadline it already has, and the settled capture
+            // that follows announces the finished body.
+            if (captured && completion === 'settled') {
+                if (claimCompletionAnnouncement(captureKey, readerReport.completionKey)) {
+                    (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, true);
+                }
+            }
+            else if (captured) {
+                logger.info('structured-history-capture-provisional', {
+                    worktreeId,
+                    cliToolId,
+                    instanceId: resolvedInstanceId,
+                    // The reader's own word for what is missing; see
+                    // `AntigravityTurnCompletionReason`. This is the line #2443 asks for
+                    // — the reason left on the relay's waiting path.
+                    reason: readerReport.completionReason ?? 'unknown',
+                });
+            }
             return captured;
         }
         catch (error) {