commandmate 0.45.1 → 0.46.1

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

@@ -49,6 +49,7 @@ const session_name_1 = require("../../lib/cli-tools/session-name");
 const geometry_delegation_1 = require("../../lib/tmux/geometry-delegation");
 const tmux_session_surface_1 = require("../../lib/session/tmux-session-surface");
 const response_poller_core_1 = require("./response-poller-core");
+const poller_owner_1 = require("./poller-owner");
 const push_1 = require("../../lib/push");
 // Issue #1790: imported by deep path, not through `@/lib/push`. Suites that
 // replace the barrel to count notifications (e.g. the #1547 escalation test)
@@ -449,6 +450,48 @@ function markOrSettleStructuredHistoryRecheck(pollerKey, recorded) {
         (0, response_dedup_1.markStructuredHistoryRecheckPending)(pollerKey);
     }
 }
+/**
+ * Whether this tick may still act for `pollerKey` after the `await` it has just
+ * resumed from, logging the refusal when it may not (Issue #3705).
+ *
+ * #3663, #3684 and #3701 asked {@link mayActForPollerKey} at the writes that had
+ * been reported, one at a time. A tick resumes from an `await` with no idea
+ * whether its chain was stopped, cut loose past `STALLED_TICK_TIMEOUT` or moved
+ * by a worktree-ID migration in the meantime, and every write after that
+ * `await` — the prompt sweep, the waiting edge, the completion push, the cursor,
+ * the fault notifier, the TUI accumulator, the recheck and skip-streak state —
+ * lands under a key it no longer owns, on whatever the successor has put there.
+ * So the question is asked after every `await` of the tick, named by the point
+ * it resumed from, and the writes below each point run only on a yes.
+ *
+ * Not asked where a self-stop hands back its verdict (`return await
+ * recordCompletedResponse(…)`): `runPollTick` settles the pause from that
+ * value, and a stop the tick raised itself must not lose what it recorded.
+ *
+ * @param ctx - What this tick is keyed by
+ * @param after - The `await` the tick has just resumed from, for the log line
+ */
+function mayStillActAfter(ctx, after) {
+    if ((0, poller_owner_1.mayActForPollerKey)(ctx.pollerKey))
+        return true;
+    // One line per retired tick, at the first point that turned it away: a tick
+    // refused at the capture is asked again after the reader and the log.
+    const owner = (0, poller_owner_1.currentPollerOwner)();
+    if (owner === undefined || !refusalLogged.has(owner)) {
+        if (owner)
+            refusalLogged.add(owner);
+        logger.info('retired-tick-refused', {
+            worktreeId: ctx.worktreeId,
+            cliToolId: ctx.cliToolId,
+            instanceId: ctx.resolvedInstanceId,
+            generation: owner?.generation,
+            after,
+        });
+    }
+    return false;
+}
+/** The retired chains {@link mayStillActAfter} has already logged (Issue #3705). */
+const refusalLogged = new WeakSet();
 /**
  * Read the frame this tick captured: is there a finished turn on it that the
  * cursor has not already counted?
@@ -469,17 +512,25 @@ function markOrSettleStructuredHistoryRecheck(pollerKey, recorded) {
  * @param ctx - What this tick is keyed by
  * @param output - The capture this tick made
  * @param lastCapturedLine - Its cursor, 0 when there is none
+ * @param owns - Whether the tick still owns its key (Issue #3705); false reads
+ *   the frame and writes nothing
  * @returns What the tick goes on with, or `false` when the tick ends here
  */
-function extractCompletedTurn(ctx, output, lastCapturedLine) {
+function extractCompletedTurn(ctx, output, lastCapturedLine, owns) {
     const { db, worktreeId, cliToolId, instanceId, resolvedInstanceId, pollerKey } = ctx;
     // Issue #2000: the frame is in hand, so this is the cheapest place to ask
     // whether the model API has stalled the session. Level in, edge out — see
     // the helper.
-    observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output);
+    //
+    // Issue #3705: every write in this function is the caller's `owns` — asked
+    // right after the capture, with no `await` since. A retired tick's frame is
+    // read, and none of it lands on the fault episode, the accumulator, the skip
+    // streaks or the pending prompts of the key it lost.
+    if (owns)
+        observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output);
     // 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') {
+    if (owns && (cliToolId === 'opencode' || cliToolId === 'copilot')) {
         // 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
@@ -498,13 +549,18 @@ function extractCompletedTurn(ctx, output, lastCapturedLine) {
         // skipped on the line count ("no new output"), which says nothing about
         // whether the prompt is still on screen, and neither do the cursor returns
         // further down.
-        if (result)
+        //
+        // Issue #3552: the same frame ends a run of duplicate response ticks for
+        // the same reason — an unfinished frame is not the saved reply.
+        if (owns && result) {
             (0, prompt_dedup_1.resetDuplicatePromptSkipStreak)(pollerKey);
+            (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
+        }
         // DR-004 windowing: Only check tail lines
         const { thinkingPattern } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
         const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
         const tailLines = cleanOutput.split('\n').slice(-thinking_constants_1.THINKING_TAIL_LINE_COUNT).join('\n');
-        if (thinkingPattern.test(tailLines)) {
+        if (owns && thinkingPattern.test(tailLines)) {
             // Intended twin of the sweep in recordCompletedResponse: this one runs when
             // working is visible on an unfinished frame, that one when a response is
             // recorded (Issue #31).
@@ -565,6 +621,21 @@ function extractCompletedTurn(ctx, output, lastCapturedLine) {
  */
 function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
     const { db, worktree, worktreeId, cliToolId, instanceId, resolvedInstanceId, pollerKey } = ctx;
+    // Issue #3701: the question #3663 / #3684 ask, for the prompt a tick retired
+    // during the capture's `await` then finds on the pane — no row, broadcast,
+    // task event, push or waiting episode under the key it lost. Asked BEFORE the
+    // dedup below, which registers the hash before the save: a refused tick that
+    // registered it would make the successor drop the same prompt as a
+    // duplicate. No `await` from here to the end of this function.
+    if (!(0, poller_owner_1.mayActForPollerKey)(pollerKey)) {
+        logger.info('prompt-save-refused', {
+            worktreeId,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            generation: (0, poller_owner_1.currentPollerOwner)()?.generation,
+        });
+        return false;
+    }
     // Issue #565: Content hash-based duplicate prompt prevention
     const promptContent = promptDetection.rawContent || promptDetection.cleanContent;
     const normalizedForDedup = (0, prompt_dedup_1.normalizePromptForDedup)(promptContent, cliToolId);
@@ -681,9 +752,10 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
  * @param cliToolId - CLI tool identifier
  * @param result - The complete extraction this tick made
  * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @param owns - Whether the tick still owns its key (Issue #3705)
  * @returns The cleaned response
  */
-function cleanCompletedResponse(cliToolId, result, pollerKey) {
+function cleanCompletedResponse(cliToolId, result, pollerKey, owns) {
     // Clean up responses
     let cleanedResponse = result.response;
     if (cliToolId === 'gemini') {
@@ -697,7 +769,10 @@ function cleanCompletedResponse(cliToolId, result, pollerKey) {
         const sourceContent = accumulatedContent || result.response;
         cleanedResponse = (0, response_cleaner_1.cleanCopilotResponse)(sourceContent);
         cleanedResponse = (0, response_cleaner_1.truncateMessage)(cleanedResponse, copilot_constants_1.COPILOT_MAX_MESSAGE_LENGTH, copilot_constants_1.COPILOT_TRUNCATION_MARKER);
-        (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
+        // Issue #3705: read, but not cleared, by a tick that lost the key — the
+        // successor may already be accumulating its own turn under it.
+        if (owns)
+            (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
     }
     else if (cliToolId === 'opencode') {
         // Issue #1911 defect 3: opencode wrote to the Layer-2 accumulator but never
@@ -719,7 +794,8 @@ function cleanCompletedResponse(cliToolId, result, pollerKey) {
             ? accumulatedContent
             : result.response;
         cleanedResponse = (0, response_cleaner_1.cleanOpenCodeResponse)(sourceContent);
-        (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
+        if (owns)
+            (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
     }
     return cleanedResponse;
 }
@@ -739,6 +815,15 @@ function cleanCompletedResponse(cliToolId, result, pollerKey) {
  */
 async function recheckDuplicateResponse(ctx, result, claudeMetadata) {
     const { db, worktree, worktreeId, cliToolId, instanceId, resolvedInstanceId, pollerKey } = ctx;
+    // Issue #3705 (review): a retired tick reaches this function too. The dedup
+    // answers "duplicate" on a hash match BEFORE it asks about ownership (it only
+    // refuses to REGISTER a hash), and the hash it matches may be the successor's
+    // — the same reply, saved by the chain that replaced this one while this
+    // tick's capture was in flight. Everything below writes under the key (the
+    // skip-log claim, the cursor, the recheck claim, then the reader), so the
+    // question is asked first, with no `await` between it and those writes.
+    if (!mayStillActAfter(ctx, 'capture'))
+        return false;
     // Issue #1695: this branch used to drop the response silently — the
     // prompt-side guard above has logged its skip since #565, this one
     // logged nothing at all, so a reply that never reached History left no
@@ -816,6 +901,11 @@ async function recheckDuplicateResponse(ctx, result, claudeMetadata) {
             worktreePath: worktree.path,
             transcriptPathHint: claudeMetadata?.logFilePath ?? null,
         });
+        // Issue #3705: the recheck the successor is owed is not settled, and its
+        // hold not dropped, by a tick retired while the reader ran. What the reader
+        // answered is still the answer (it asks the same question before it writes).
+        if (!mayStillActAfter(ctx, 'recheck-reader'))
+            return recaptured;
         if (recaptured) {
             (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
             // Issue #2436: the turn is now the agent's own Markdown, so a
@@ -863,7 +953,10 @@ function recordOrHoldScrapedResponse(ctx, cleanedResponse, claudeMetadata, decis
     // width and gutter-prefixed, so no content check could ever recognise them
     // as the same reply.
     if (holdScrapedHistory) {
-        (0, pending_scraped_response_1.holdScrapedResponse)(pollerKey, {
+        // Issue #3663: refused (false) to a tick whose chain was retired while it
+        // awaited the reader — a stop, a stalled-tick restart or a worktree-ID
+        // migration. The store logs that, so this tick does not claim a hold.
+        const held = (0, pending_scraped_response_1.holdScrapedResponse)(pollerKey, {
             worktreeId,
             cliToolId,
             instanceId: resolvedInstanceId,
@@ -879,19 +972,37 @@ function recordOrHoldScrapedResponse(ctx, cleanedResponse, claudeMetadata, decis
             transcriptPathHint: claudeMetadata?.logFilePath ?? null,
             expiresAt: Date.now() + pending_scraped_response_1.PENDING_SCRAPE_HOLD_MS,
         });
-        logger.info('structured-history-scrape-held', {
+        if (held) {
+            logger.info('structured-history-scrape-held', {
+                worktreeId,
+                cliToolId,
+                instanceId: resolvedInstanceId,
+                scrapedLength: cleanedResponse.length,
+                holdMs: pending_scraped_response_1.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. Issue #3684: only for a hold that was taken — a
+            // refused one is a retired tick, which announces nothing under the key
+            // it lost, as in the immediate-save branch below.
+            (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, false);
+        }
+    }
+    else if (!suppressScrapedHistory && !(0, poller_owner_1.mayActForPollerKey)(pollerKey)) {
+        // Issue #3684: the same question the hold asks (#3663), for the reply saved
+        // at once — a tick retired while it awaited the reader or the log writes no
+        // row, broadcast or relay edge under the key it lost. No `await` between
+        // this check and the three below. Issue #3705: the caller now asks the
+        // same question for the rest of the tick's writes and the Markdown log for
+        // its own, so a retired tick reaches this branch only to be refused here.
+        logger.info('scraped-response-save-refused', {
             worktreeId,
             cliToolId,
             instanceId: resolvedInstanceId,
-            scrapedLength: cleanedResponse.length,
-            holdMs: pending_scraped_response_1.PENDING_SCRAPE_HOLD_MS,
+            generation: (0, poller_owner_1.currentPollerOwner)()?.generation,
         });
-        // 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
@@ -994,7 +1105,13 @@ async function recordCompletedResponse(ctx, turn, claudeMetadata, cleanedRespons
     // 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(pollerKey, structuredHistoryLive);
+    //
+    // Issue #3705: by a tick that still owns the key. A retired one goes on to
+    // the scrape decision below only so that the store's and the save branch's
+    // own refusals (#3663, #3684) speak for it; nothing else it would write does.
+    if (mayStillActAfter(ctx, 'reader')) {
+        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.
     //
@@ -1025,8 +1142,29 @@ async function recordCompletedResponse(ctx, turn, claudeMetadata, cleanedRespons
     // 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
+    //
+    // Issue #3705: keyed, so the log asks before its own write (after its own
+    // awaits) whether this tick still owns the key. A held reply confirmed by a
+    // stop is logged by the store with no key (`pending-scraped-response`), and
+    // that log is kept.
     if (cleanedResponse && !suppressScrapedHistory && !holdScrapedHistory) {
-        await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId);
+        await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId, { pollerKey });
+    }
+    // Issue #3705: everything from here to the end of the function runs without
+    // an `await`, so this is the tick's last chance to find out that it was
+    // retired while the reader or the log ran. A retired tick sweeps no prompt to
+    // "answered", closes no waiting episode, sends no completion push and moves
+    // no cursor under the key it lost — the successor's, possibly. The scrape
+    // decision still runs: every branch of it asks the same question itself
+    // (#3663 the hold, #3684 the immediate save, the store the discard), and its
+    // refusal lines are what the earlier suites read.
+    if (!mayStillActAfter(ctx, 'conversation-log')) {
+        recordOrHoldScrapedResponse(ctx, cleanedResponse, claudeMetadata, {
+            structuredHistoryLive,
+            suppressScrapedHistory,
+            holdScrapedHistory,
+        });
+        return false;
     }
     // Mark any pending prompts as answered. Intended twin of the sweep in
     // extractCompletedTurn (working visible on an unfinished frame); this one runs
@@ -1098,8 +1236,23 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             return false;
         }
+        const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
+        // Issue #3213: what the steps split out of this function are keyed by.
+        const ctx = {
+            db,
+            worktree,
+            worktreeId,
+            cliToolId,
+            instanceId,
+            resolvedInstanceId,
+            pollerKey,
+        };
         // Check if CLI tool session is running
         const running = await (0, cli_session_1.isSessionRunning)(worktreeId, cliToolId, instanceId);
+        // Issue #3705: the first of the tick's awaits. Every one of them is followed
+        // by the same question; see `mayStillActAfter`.
+        if (!mayStillActAfter(ctx, 'session-check'))
+            return false;
         if (!running) {
             logger.info('session-not-running');
             // `stopPolling` is what confirms a held scrape here; see
@@ -1111,23 +1264,14 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             return false;
         }
-        const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
-        // Issue #3213: what the steps split out of this function are keyed by.
-        const ctx = {
-            db,
-            worktree,
-            worktreeId,
-            cliToolId,
-            instanceId,
-            resolvedInstanceId,
-            pollerKey,
-        };
         // 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 (0, pending_scraped_response_1.settleExpiredPendingScrapedResponse)(pollerKey);
+        if (!mayStillActAfter(ctx, 'pending-scrape-settle'))
+            return false;
         // Issue #2317 Phase D: is a human reading this pane at their own terminal
         // size right now, and did they just stop?
         //
@@ -1139,6 +1283,8 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         const delegation = (0, tmux_session_surface_1.isLiveAttachEligibleSession)(sessionName)
             ? await (0, geometry_delegation_1.probeGeometryDelegation)(sessionName)
             : { delegated: false, released: false };
+        if (!mayStillActAfter(ctx, 'geometry-probe'))
+            return false;
         if (delegation.released) {
             // The canvas is 1000 rows again, so a cursor recorded against a 44-row
             // frame indexes into a pane that no longer exists. Zero is the only value
@@ -1165,7 +1311,16 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // taken from the same constant extractResponse() measures saturation against
         // (Issue #1670) — a literal here would silently decouple the two.
         const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES, instanceId);
-        const turn = extractCompletedTurn(ctx, output, lastCapturedLine);
+        // Issue #3705: there is no `await` from here to the transcript reader
+        // inside the save path, so this one answer covers every write in between —
+        // the fault notifier, the TUI accumulator, the prompt sweep, the skip
+        // streaks, the cursor, the in-progress id. A retired tick still READS the
+        // frame and goes on, because the writes that already ask for themselves
+        // (the prompt row #3701, the response hash #3663, the reader and the
+        // scrape decision) are where its refusal is recorded; it writes none of
+        // the rest.
+        const owns = mayStillActAfter(ctx, 'capture');
+        const turn = extractCompletedTurn(ctx, output, lastCapturedLine, owns);
         if (!turn) {
             return false;
         }
@@ -1189,24 +1344,41 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // has lost the position `detectDialog` judges by.
         const promptIsLive = promptDetection.isPrompt && (0, response_checker_dialog_gate_1.isNumberedDialogVouched)(cliToolId, promptDetection, output);
         if (promptIsLive) {
+            // Issue #3552: a live prompt is not the saved reply, so a run of
+            // duplicate response ticks is over; the response hash is kept (a resume
+            // after the answer must not re-save the reply underneath, #2230).
+            if (owns)
+                (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
+            // Asks for itself (#3701), before the prompt dedup.
             return savePromptMessage(ctx, promptDetection, result, isFullScreenTui);
         }
         // Issue #3538: a finished frame without a live prompt ends the run of
         // duplicate prompt ticks, as an unfinished one does in `extractCompletedTurn`.
-        (0, prompt_dedup_1.resetDuplicatePromptSkipStreak)(pollerKey);
+        if (owns)
+            (0, prompt_dedup_1.resetDuplicatePromptSkipStreak)(pollerKey);
         // Validate response content is not empty
         if (!result.response || result.response.trim() === '') {
-            (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
+            // Issue #3552: an empty response is not the saved reply either.
+            if (owns) {
+                (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
+                (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
+            }
             return false;
         }
         // Parse Claude-specific metadata
         const claudeMetadata = cliToolId === 'claude'
             ? (0, claude_output_1.parseClaudeOutput)(result.response)
             : undefined;
-        const cleanedResponse = cleanCompletedResponse(cliToolId, result, pollerKey);
+        const cleanedResponse = cleanCompletedResponse(cliToolId, result, pollerKey, owns);
         // If cleaned response is empty or just "[No content]", skip saving
         if (!cleanedResponse || cleanedResponse.trim() === '' || cleanedResponse === '[No content]') {
-            (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
+            // Issue #3552: nor is one that cleans down to nothing.
+            if (owns) {
+                (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
+                (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
+            }
+            // Left as it was (Issue #3705 sets it aside as harmless): nothing sets the
+            // in-progress id to a non-null value or reads it today.
             (0, db_1.clearInProgressMessageId)(db, worktreeId, cliToolId, resolvedInstanceId);
             return false;
         }
@@ -1221,6 +1393,10 @@ 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) {
+            // A retired tick registers no hash here (#3663, `./response-dedup`), but
+            // it can still MATCH one — the successor's, for the same reply. The
+            // recheck below therefore opens on the ownership question itself before
+            // its claim, its cursor and its read (Issue #3705 review).
             if ((0, response_dedup_1.isDuplicateResponse)(pollerKey, cleanedResponse)) {
                 // `await`, so that a rejection still lands in the catch below.
                 return await recheckDuplicateResponse(ctx, result, claudeMetadata);

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

@@ -55,13 +55,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL = exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = void 0;
 exports.isDuplicateResponse = isDuplicateResponse;
 exports.claimDuplicateResponseSkipLog = claimDuplicateResponseSkipLog;
+exports.resetDuplicateResponseSkipStreak = resetDuplicateResponseSkipStreak;
 exports.markStructuredHistoryRecheckPending = markStructuredHistoryRecheckPending;
 exports.settleStructuredHistoryRecheck = settleStructuredHistoryRecheck;
 exports.claimStructuredHistoryRecheck = claimStructuredHistoryRecheck;
 exports.clearResponseHashCache = clearResponseHashCache;
 exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
+exports.renameResponseHashCacheKeys = renameResponseHashCacheKeys;
 const crypto_1 = require("crypto");
 const global_state_1 = require("../global-state");
+const poller_owner_1 = require("./poller-owner");
 const responseHashCache = (0, global_state_1.getOrInitGlobal)('__responseHashCache', () => new Map());
 /**
  * In-memory cache: pollerKey -> ticks still to wait before the transcript reader
@@ -97,7 +100,9 @@ exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = 3;
  *
  * On `globalThis` for the same reason `responseHashCache` is, and cleared and
  * moved at exactly the same moments — see the module comment. A new
- * (non-duplicate) response restarts it in {@link isDuplicateResponse}.
+ * (non-duplicate) response restarts it in {@link isDuplicateResponse}, and a
+ * tick that reads the frame and finds no reply on it ends the run without
+ * touching the hash — see {@link resetDuplicateResponseSkipStreak} (#3552).
  */
 const duplicateResponseSkipStreak = (0, global_state_1.getOrInitGlobal)('__duplicateResponseSkipStreak', () => new Map());
 /**
@@ -123,6 +128,13 @@ function isDuplicateResponse(pollerKey, content) {
     if (responseHashCache.get(pollerKey) === hash) {
         return true;
     }
+    // Issue #3663: a tick of a stopped chain no longer owns its key, so it does
+    // not register a hash there — the same line the held scrape draws. Left
+    // behind, the hash of a reply that tick never saves (its hold is refused)
+    // would be inherited by the next chain on the key, or moved by a migration,
+    // and make the successor skip it.
+    if (!(0, poller_owner_1.mayActForPollerKey)(pollerKey))
+        return false;
     responseHashCache.set(pollerKey, hash);
     // Issue #3519: a new response starts a new run of duplicate ticks.
     duplicateResponseSkipStreak.delete(pollerKey);
@@ -148,6 +160,28 @@ function claimDuplicateResponseSkipLog(pollerKey) {
     const suppressed = consecutive === 1 ? 0 : exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL - 1;
     return { log, consecutive, suppressed };
 }
+/**
+ * End the current run of duplicate response ticks for this pollerKey without
+ * touching the cached hash (Issue #3552).
+ *
+ * Called by `response-checker` on the ticks that read the frame and decide it
+ * is not a duplicate of the saved reply: an unfinished frame
+ * (`extractCompletedTurn`), a finished frame with a live prompt on it, and a
+ * finished frame whose response is empty. The reply is no longer on screen, so
+ * if the same reply comes back the next duplicate is the first of a new run and
+ * logs. The hash stays: whether the returning reply is saved again is the
+ * guard's question (#1268), and this only thins the log line (#3519).
+ *
+ * Not called at the entrance of a finished frame — that would make every
+ * duplicate tick the first of its run — nor on a tick that skipped extraction
+ * on the line count (null) or returned on the cursor: neither says the reply
+ * has left the screen (the same judgement as #3538).
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ */
+function resetDuplicateResponseSkipStreak(pollerKey) {
+    duplicateResponseSkipStreak.delete(pollerKey);
+}
 /**
  * Note that the transcript reader has unfinished business for this pollerKey
  * (Issue #2399).
@@ -233,6 +267,55 @@ function clearResponseHashCache(pollerKey) {
     // Issue #3519: the skip count is about the same hash.
     duplicateResponseSkipStreak.delete(pollerKey);
 }
+/** Remove everything held under `key` and return it. */
+function takeResponseDedupState(key) {
+    const state = {
+        hash: responseHashCache.get(key),
+        recheck: structuredHistoryRecheckCache.get(key),
+        streak: duplicateResponseSkipStreak.get(key),
+    };
+    responseHashCache.delete(key);
+    structuredHistoryRecheckCache.delete(key);
+    duplicateResponseSkipStreak.delete(key);
+    return state;
+}
+/**
+ * Write state lifted by {@link takeResponseDedupState} under `key`.
+ *
+ * `replaceRecheckWithHash` is the one difference between the batch and the
+ * single rename (Issue #3553): when a hash lands, the batch also replaces the
+ * recheck under `key` — deleting it when the source had none — so a recheck
+ * owed for a different turn is not attached to the hash that just arrived. The
+ * single rename keeps its earlier behaviour and leaves such a recheck alone.
+ */
+function putResponseDedupState(key, state, replaceRecheckWithHash) {
+    if (state.hash !== undefined)
+        responseHashCache.set(key, state.hash);
+    // Issue #2399: the recheck caveat moves with the hash it is about. Leaving it
+    // behind would strand a turn whose transcript is still open — the new key
+    // starts owing nothing, so every later tick returns at the dedup guard and the
+    // Markdown row is never written. It moves without a hash too: the
+    // `lineCountIsCursor` path marks it with no hash cached.
+    if (state.recheck !== undefined) {
+        structuredHistoryRecheckCache.set(key, state.recheck);
+    }
+    else if (replaceRecheckWithHash && state.hash !== undefined) {
+        structuredHistoryRecheckCache.delete(key);
+    }
+    // Issue #3519: the skip count moves with the hash too, so a rename mid-run
+    // does not restart the thinning and log as if a new run had begun.
+    // Issue #3552: whenever the hash under `newKey` is replaced, so is its count
+    // — a count left over from the hash that was there before is about a
+    // different reply (the same rule as `renamePromptHashCacheKey`, #3538).
+    if (state.hash === undefined)
+        return;
+    if (state.streak !== undefined) {
+        duplicateResponseSkipStreak.set(key, state.streak);
+    }
+    else {
+        duplicateResponseSkipStreak.delete(key);
+    }
+}
 /**
  * Move the cached hash from one pollerKey to another.
  *
@@ -241,7 +324,8 @@ function clearResponseHashCache(pollerKey) {
  * during THIS turn?", and the turn does not end just because the ID moved —
  * dropping it would re-save the screen currently on display.
  *
- * No-op when nothing is cached under `oldKey`.
+ * No-op when nothing is cached under `oldKey`. A batch of renames whose keys
+ * overlap must go through {@link renameResponseHashCacheKeys} instead.
  *
  * @param oldKey - Poller key the cache entry lives under
  * @param newKey - Poller key it should live under
@@ -249,22 +333,30 @@ function clearResponseHashCache(pollerKey) {
 function renameResponseHashCacheKey(oldKey, newKey) {
     if (oldKey === newKey)
         return;
-    const hash = responseHashCache.get(oldKey);
-    responseHashCache.delete(oldKey);
-    if (hash !== undefined)
-        responseHashCache.set(newKey, hash);
-    // Issue #2399: the recheck caveat moves with the hash it is about. Leaving it
-    // behind would strand a turn whose transcript is still open — the new key
-    // starts owing nothing, so every later tick returns at the dedup guard and the
-    // Markdown row is never written.
-    const ticksToWait = structuredHistoryRecheckCache.get(oldKey);
-    structuredHistoryRecheckCache.delete(oldKey);
-    if (ticksToWait !== undefined)
-        structuredHistoryRecheckCache.set(newKey, ticksToWait);
-    // Issue #3519: the skip count moves with the hash too, so a rename mid-run
-    // does not restart the thinning and log as if a new run had begun.
-    const streak = duplicateResponseSkipStreak.get(oldKey);
-    duplicateResponseSkipStreak.delete(oldKey);
-    if (streak !== undefined)
-        duplicateResponseSkipStreak.set(newKey, streak);
+    putResponseDedupState(newKey, takeResponseDedupState(oldKey), false);
+}
+/**
+ * Move the response dedup state of a whole batch of pollerKeys (Issue #3553).
+ *
+ * Every source key is lifted before any destination is written, so a swap
+ * (A→B, B→A) or a chain (A→B→C) cannot overwrite a source that has not moved
+ * yet — calling {@link renameResponseHashCacheKey} once per pair would leave
+ * A with its own state and B empty after a swap. Each destination ends up with
+ * exactly what its source held: hash, skip count and recheck, the recheck
+ * moving even without a hash. A recheck already at the destination is
+ * replaced along with the hash, never kept beside the moved one.
+ *
+ * Pairs with `oldKey === newKey` are ignored.
+ *
+ * @param renames - Poller key moves applied together
+ */
+function renameResponseHashCacheKeys(renames) {
+    const lifted = [];
+    for (const { oldKey, newKey } of renames) {
+        if (oldKey === newKey)
+            continue;
+        lifted.push({ newKey, state: takeResponseDedupState(oldKey) });
+    }
+    for (const { newKey, state } of lifted)
+        putResponseDedupState(newKey, state, true);
 }