commandmate 0.33.0 → 0.33.2

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

package/dist/server/src/lib/push/failure-push-notifier.js

@@ -12,6 +12,7 @@
  * | verification failed | `lib/verification/gate-runner`              | event  |
  * | upstream API fault  | `lib/polling/response-checker` (#1839 match)| level  |
  * | session start failed| `lib/cli-tools/start-availability` (#2009/#2022)| event |
+ * | stale hook URL      | `lib/cli-tools/start-availability` (#2429)  | event  |
  *
  * The shape column is the whole design. An **event** fires once by construction
  * — a run closes once, a start attempt throws once — so its only guard is the
@@ -60,6 +61,7 @@ exports.formatWorktreeWideAgentLabel = formatWorktreeWideAgentLabel;
 exports.notifyVerificationFailurePush = notifyVerificationFailurePush;
 exports.notifyUpstreamFaultPush = notifyUpstreamFaultPush;
 exports.notifySessionStartFailurePush = notifySessionStartFailurePush;
+exports.notifyStaleHookUrlPush = notifyStaleHookUrlPush;
 const db_instance_1 = require("../../lib/db/db-instance");
 const worktree_db_1 = require("../../lib/db/worktree-db");
 const logger_1 = require("../../lib/logger");
@@ -194,7 +196,11 @@ async function raiseFailurePush(input) {
             agentName: input.agentLabel ?? input.instanceId,
             instanceId: input.instanceId,
             excerpt: input.excerpt,
-            failure: { reason: input.reason, signature: input.signature },
+            failure: {
+                reason: input.reason,
+                signature: input.signature,
+                ...(input.body ? { body: input.body } : {}),
+            },
             ...(input.subject ? { url: input.subject.url } : {}),
         });
     }
@@ -444,3 +450,64 @@ async function notifySessionStartFailurePush(input) {
         subject: input.subject,
     });
 }
+// ===========================================================================
+// 4. Stale hook URL on an adopted session
+// ===========================================================================
+/**
+ * The sentence a stale hook URL gets, per locale (Issue #2429).
+ *
+ * Written here rather than in the `locales/<lang>/notifications.json`
+ * dictionaries, for the reason `push-sender`'s
+ * {@link ProducerWordedFailureReason} gives: the body is a
+ * relation between two numbers and a remedy, not a template plus a name, and
+ * this is the layer that holds the numbers. `Record<SupportedLocale, string>`
+ * is what makes a new locale a type error here instead of an English card in a
+ * Japanese notification tray.
+ *
+ * Both wordings name the remedy — restarting the session — because the fact on
+ * its own is not actionable: an operator who is told only that two ports differ
+ * has no way to know that CommandMate will not repair it by itself, and it will
+ * not, deliberately (see `BaseCLITool.warnIfHookUrlIsStale`).
+ */
+function staleHookUrlBody(report) {
+    const { toolName, sessionPort, serverPort } = report;
+    return {
+        en: `${toolName} is still posting its hooks to port ${sessionPort}, but this server is on ` +
+            `${serverPort}. Restart the session to reconnect it.`,
+        ja: `${toolName} のフックが古いポート ${sessionPort} 宛のままです（このサーバーは ` +
+            `${serverPort}）。セッションを再起動すると直ります。`,
+    };
+}
+/**
+ * Notify that an adopted session's hooks are addressed to another server.
+ * Never throws.
+ *
+ * Called from exactly one place — `reportStaleHookUrl` in
+ * `lib/cli-tools/start-availability`, which is also where the "once" lives.
+ * This function therefore has no edge of its own, exactly like
+ * {@link notifySessionStartFailurePush}: the rate is bounded by how often a
+ * session is started, and the caller has already decided that this particular
+ * (instance, port pair) has not been reported before.
+ *
+ * `kind: 'failure'` rather than `'completion'` because the reader has to act —
+ * until they restart the session, `commandmate wait` on it cannot complete on
+ * the agent's own word and every turn pays #1975's 60 s hold before falling
+ * back to the frame.
+ */
+async function notifyStaleHookUrlPush(report) {
+    const instanceId = report.instanceId ?? report.cliToolId;
+    await raiseFailurePush({
+        reason: 'hook-url-stale',
+        worktreeId: report.worktreeId,
+        instanceId,
+        // The two ports, so a pane that later points at a THIRD server is a second
+        // incident rather than a repeat of this one.
+        signature: `hook-url-stale:${instanceId}:${report.sessionPort}:${report.serverPort}`,
+        body: staleHookUrlBody(report),
+        logContext: {
+            cliToolId: report.cliToolId,
+            sessionPort: report.sessionPort,
+            serverPort: report.serverPort,
+        },
+    });
+}