commandmate 0.45.0 → 0.46.0

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

@@ -6,15 +6,54 @@
  * Uses SHA-256 content hash with an in-memory cache (Map<pollerKey, hash>).
  * Design decision [DR1-006]: In-memory only (no DB layer).
  * Process restart may cause a single duplicate, which is acceptable (KISS).
+ *
+ * ## How often the skip says so (Issue #3538)
+ *
+ * A full-screen TUI (copilot, opencode) keeps polling while it sits on a
+ * prompt, so the same prompt is a duplicate on every 2 s tick until it is
+ * answered, and `duplicate-prompt-skipped` used to be logged on each of them.
+ * The run of duplicate ticks is counted here, the same way `response-dedup`
+ * counts `duplicate-response-skipped` (#3519): the line is written on the first
+ * tick of a run and then once per {@link DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL}
+ * ticks. The count is about one particular cached hash, so it never outlives
+ * it — the functions below that drop or move the hash drop or move the count
+ * too. The one exception runs the other way: a tick that reads a frame with no
+ * live prompt on it ends the run without touching the hash
+ * ({@link resetDuplicatePromptSkipStreak}), because the prompt left the screen
+ * while the guard still has to keep it from being saved twice. A returning
+ * prompt is then still suppressed, but its first duplicate logs as the first
+ * of a new run.
+ *
+ * Only the log line is thinned. `recordPromptDedupSkip` (#1695) is still called
+ * on every duplicate tick; its tally is what `capture --json` reports.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL = void 0;
 exports.isDuplicatePrompt = isDuplicatePrompt;
+exports.claimDuplicatePromptSkipLog = claimDuplicatePromptSkipLog;
+exports.resetDuplicatePromptSkipStreak = resetDuplicatePromptSkipStreak;
 exports.clearPromptHashCache = clearPromptHashCache;
 exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
+exports.renamePromptHashCacheKeys = renamePromptHashCacheKeys;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
 const global_state_1 = require("../global-state");
+const response_dedup_1 = require("./response-dedup");
 const promptHashCache = (0, global_state_1.getOrInitGlobal)('__promptHashCache', () => new Map());
+/**
+ * In-memory cache: pollerKey -> how many duplicate ticks in a row the current
+ * cached prompt hash has been skipped (Issue #3538). Absence means none yet.
+ *
+ * On `globalThis` for the same reason `promptHashCache` is, and cleared and
+ * moved at exactly the same moments — see the module comment.
+ */
+const duplicatePromptSkipStreak = (0, global_state_1.getOrInitGlobal)('__duplicatePromptSkipStreak', () => new Map());
+/**
+ * How many duplicate ticks separate two `duplicate-prompt-skipped` lines
+ * (Issue #3538). Shared with `duplicate-response-skipped` (#3519): one line a
+ * minute at the poller's 2 s tick.
+ */
+exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL = response_dedup_1.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL;
 /**
  * Check if the given prompt content is a duplicate of the last saved prompt
  * for the same pollerKey. If not a duplicate, updates the cache.
@@ -29,8 +68,50 @@ function isDuplicatePrompt(pollerKey, content) {
         return true;
     }
     promptHashCache.set(pollerKey, hash);
+    // Issue #3538: a new prompt starts a new run of duplicate ticks.
+    duplicatePromptSkipStreak.delete(pollerKey);
     return false;
 }
+/**
+ * Count one duplicate prompt tick for this pollerKey and say whether it should
+ * be logged (Issue #3538).
+ *
+ * A claim: it advances the count, so call it exactly once per duplicate tick.
+ * Logs on the first tick of a run and then on every
+ * {@link DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL}th tick after it (ticks 1,
+ * 1+N, 1+2N, …).
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ * @returns Whether to log, the run length so far, and the ticks left unlogged
+ *   since the previous line
+ */
+function claimDuplicatePromptSkipLog(pollerKey) {
+    const consecutive = (duplicatePromptSkipStreak.get(pollerKey) ?? 0) + 1;
+    duplicatePromptSkipStreak.set(pollerKey, consecutive);
+    const log = (consecutive - 1) % exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL === 0;
+    const suppressed = consecutive === 1 ? 0 : exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL - 1;
+    return { log, consecutive, suppressed };
+}
+/**
+ * End the current run of duplicate prompt ticks for this pollerKey without
+ * touching the cached hash (Issue #3538).
+ *
+ * Called by `response-checker` in two places: `extractCompletedTurn`, when the
+ * frame was read and is unfinished (a working screen), and `checkForResponse`,
+ * when a finished frame carries no live prompt (a reply). The prompt is no
+ * longer on screen, so if the same prompt comes back the next duplicate is the
+ * first of a new run and logs. Not called on a tick that skipped extraction on
+ * the line count (a null result) or returned on the cursor, nor on a tick that
+ * ended before extraction: none of them says the prompt has left the screen,
+ * so the run carries on through them. The hash stays: whether the
+ * returning prompt is saved again is the guard's question (#565), and this
+ * Issue only thins the log line.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ */
+function resetDuplicatePromptSkipStreak(pollerKey) {
+    duplicatePromptSkipStreak.delete(pollerKey);
+}
 /**
  * Clear the prompt hash cache for a specific pollerKey.
  * Called during session cleanup / stopPolling.
@@ -39,6 +120,8 @@ function isDuplicatePrompt(pollerKey, content) {
  */
 function clearPromptHashCache(pollerKey) {
     promptHashCache.delete(pollerKey);
+    // Issue #3538: the skip count is about the same hash.
+    duplicatePromptSkipStreak.delete(pollerKey);
 }
 /**
  * Move the cached hash from one pollerKey to another.
@@ -48,18 +131,54 @@ function clearPromptHashCache(pollerKey) {
  * re-save the prompt it is currently sitting on as a fresh message, which is
  * the duplicate this module exists to prevent.
  *
- * 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 renamePromptHashCacheKeys} instead.
  *
  * @param oldKey - Poller key the cache entry lives under
  * @param newKey - Poller key it should live under
  */
 function renamePromptHashCacheKey(oldKey, newKey) {
-    if (oldKey === newKey)
-        return;
-    const hash = promptHashCache.get(oldKey);
-    promptHashCache.delete(oldKey);
-    if (hash !== undefined)
+    renamePromptHashCacheKeys([{ oldKey, newKey }]);
+}
+/**
+ * Move the prompt hash and its skip count for 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. Per pair this is exactly {@link renamePromptHashCacheKey}: nothing
+ * happens at the destination when the source held no hash.
+ *
+ * @param renames - Poller key moves applied together; `oldKey === newKey` is ignored
+ */
+function renamePromptHashCacheKeys(renames) {
+    const lifted = [];
+    for (const { oldKey, newKey } of renames) {
+        if (oldKey === newKey)
+            continue;
+        lifted.push({
+            newKey,
+            hash: promptHashCache.get(oldKey),
+            streak: duplicatePromptSkipStreak.get(oldKey),
+        });
+        promptHashCache.delete(oldKey);
+        duplicatePromptSkipStreak.delete(oldKey);
+    }
+    for (const { newKey, hash, streak } of lifted) {
+        if (hash === undefined)
+            continue;
         promptHashCache.set(newKey, hash);
+        // Issue #3538: the skip count moves with the hash, so a rename mid-run does
+        // not restart the thinning and log as if a new run had begun. 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 prompt.
+        if (streak !== undefined) {
+            duplicatePromptSkipStreak.set(newKey, streak);
+        }
+        else {
+            duplicatePromptSkipStreak.delete(newKey);
+        }
+    }
 }
 /**
  * Normalize prompt content before deduplication check.

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

@@ -491,6 +491,20 @@ function extractCompletedTurn(ctx, output, lastCapturedLine) {
     // Extract response
     const result = extractResponse(output, lastCapturedLine, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES);
     if (!result || !result.isComplete) {
+        // Issue #3538: an unfinished frame was read and carries no live prompt (the
+        // early prompt check in `extractResponse` would have returned it complete),
+        // so a run of duplicate prompt ticks is over; the hash is kept — see the
+        // helper. Only when the frame WAS read: a null result is extraction being
+        // 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.
+        //
+        // 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 (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);
@@ -565,7 +579,19 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
         // classified (#1676) look identical from the CLI — both say "nothing was
         // recorded". Count the skip so the payload can tell them apart.
         (0, prompt_dedup_state_1.recordPromptDedupSkip)(worktreeId, cliToolId, instanceId);
-        logger.info('duplicate-prompt-skipped', { worktreeId, cliToolId });
+        // Issue #3538: the tally above is counted on every tick; the log line is
+        // not. A full-screen TUI sits on its prompt for as long as it stays
+        // unanswered, a duplicate every 2 s. The first tick of a run logs exactly
+        // as before; after that one line per `DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL`
+        // ticks, with the run length and how many ticks went unlogged (#3519).
+        const skipLog = (0, prompt_dedup_1.claimDuplicatePromptSkipLog)(pollerKey);
+        if (skipLog.log) {
+            logger.info('duplicate-prompt-skipped', {
+                worktreeId,
+                cliToolId,
+                ...(skipLog.consecutive > 1 ? { consecutive: skipLog.consecutive, suppressed: skipLog.suppressed } : {}),
+            });
+        }
         return false;
     }
     // Issue #571: Clean TUI decorations from Copilot prompt content before saving
@@ -723,7 +749,21 @@ async function recheckDuplicateResponse(ctx, result, claudeMetadata) {
     // logged nothing at all, so a reply that never reached History left no
     // trace anywhere. Same action name shape as its sibling so both skips
     // are found by one grep.
-    logger.info('duplicate-response-skipped', { worktreeId, cliToolId, instanceId: resolvedInstanceId });
+    //
+    // Issue #3519: but not on every tick. A finished screen that stays up is a
+    // duplicate on each of the cycle's 900 ticks, and logging all of them was
+    // 51,933 lines a day. The first tick of a run logs exactly as before; after
+    // that one line per `DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL` ticks, with
+    // the run length and how many ticks went unlogged since the last line.
+    const skipLog = (0, response_dedup_1.claimDuplicateResponseSkipLog)(pollerKey);
+    if (skipLog.log) {
+        logger.info('duplicate-response-skipped', {
+            worktreeId,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            ...(skipLog.consecutive > 1 ? { consecutive: skipLog.consecutive, suppressed: skipLog.suppressed } : {}),
+        });
+    }
     (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
     // Issue #2399: the skip above is about the SCREEN, and until this Issue
     // it also ended the tick for the TRANSCRIPT READER 100 lines below —
@@ -1154,10 +1194,19 @@ 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).
+            (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
             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);
         // Validate response content is not empty
         if (!result.response || result.response.trim() === '') {
+            // Issue #3552: an empty response is not the saved reply either.
+            (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
             (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
             return false;
         }
@@ -1168,6 +1217,8 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         const cleanedResponse = cleanCompletedResponse(cliToolId, result, pollerKey);
         // If cleaned response is empty or just "[No content]", skip saving
         if (!cleanedResponse || cleanedResponse.trim() === '' || cleanedResponse === '[No content]') {
+            // Issue #3552: nor is one that cleans down to nothing.
+            (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
             (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
             (0, db_1.clearInProgressMessageId)(db, worktreeId, cliToolId, resolvedInstanceId);
             return false;

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

@@ -39,15 +39,29 @@
  * hash, and the worktree rename all have to treat the two the same, and the
  * only way to guarantee that without touching `response-poller-core` (which
  * owns those three calls) is for one function to clear both.
+ *
+ * ## The third cache: how often the skip says so (#3519)
+ *
+ * The skip logs `duplicate-response-skipped` so a reply missing from History
+ * leaves a grep-able trace (#1695). Logged on every tick, a screen that stays
+ * up writes that line every 2 s for the whole cycle — 51,933 lines in 24 h,
+ * 80% of the server log. The run of duplicate ticks is counted here so the line
+ * is written on the first tick of a run and then once per
+ * {@link DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL} ticks. The count is about
+ * one particular cached hash, so it lives and dies with it for the same reason
+ * the recheck does.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = void 0;
+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 responseHashCache = (0, global_state_1.getOrInitGlobal)('__responseHashCache', () => new Map());
@@ -79,6 +93,27 @@ const structuredHistoryRecheckCache = (0, global_state_1.getOrInitGlobal)('__str
  * or the cycle ends, the entry is gone.
  */
 exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = 3;
+/**
+ * In-memory cache: pollerKey -> how many duplicate ticks in a row the current
+ * cached hash has been skipped (Issue #3519). Absence means none yet.
+ *
+ * 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}, 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());
+/**
+ * How many duplicate ticks separate two `duplicate-response-skipped` lines
+ * (Issue #3519).
+ *
+ * At the poller's 2 s tick this is one line a minute while a finished screen
+ * stays up, so a 900-tick cycle writes 30 lines instead of 899. The first tick
+ * of a run always logs, so the #1695 trace — "this reply was skipped, at this
+ * time" — is still there for every run; what is dropped is the repetition.
+ */
+exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL = 30;
 /**
  * Check whether the given response content was already saved during the current
  * polling cycle for the same pollerKey. If it is new, updates the cache.
@@ -93,8 +128,52 @@ function isDuplicateResponse(pollerKey, content) {
         return true;
     }
     responseHashCache.set(pollerKey, hash);
+    // Issue #3519: a new response starts a new run of duplicate ticks.
+    duplicateResponseSkipStreak.delete(pollerKey);
     return false;
 }
+/**
+ * Count one duplicate tick for this pollerKey and say whether it should be
+ * logged (Issue #3519).
+ *
+ * A claim, like {@link claimStructuredHistoryRecheck}: it advances the count, so
+ * call it exactly once per duplicate tick. Logs on the first tick of a run and
+ * then on every {@link DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL}th tick after
+ * it (ticks 1, 1+N, 1+2N, …).
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @returns Whether to log, the run length so far, and the ticks left unlogged
+ *   since the previous line
+ */
+function claimDuplicateResponseSkipLog(pollerKey) {
+    const consecutive = (duplicateResponseSkipStreak.get(pollerKey) ?? 0) + 1;
+    duplicateResponseSkipStreak.set(pollerKey, consecutive);
+    const log = (consecutive - 1) % exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL === 0;
+    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).
@@ -177,6 +256,57 @@ function claimStructuredHistoryRecheck(pollerKey) {
 function clearResponseHashCache(pollerKey) {
     responseHashCache.delete(pollerKey);
     structuredHistoryRecheckCache.delete(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.
@@ -186,7 +316,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
@@ -194,16 +325,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);
+    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);
 }

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

@@ -532,8 +532,11 @@ function splitPollerKey(pollerKey) {
  * one in-flight TUI response may be truncated at the rename boundary; the next
  * turn accumulates normally.
  *
- * Takes the whole batch because IDs can swap (A→B, B→A): every source key is
- * removed before any destination key is written.
+ * Takes the whole batch because IDs can swap (A→B, B→A) or chain (A→B→C):
+ * every source key is removed before any destination key is written. That
+ * includes the dedup state (Issue #3553) — of running pollers and paused chains
+ * alike — which is lifted off every source key in one pass and only then
+ * written, so a pair handled early cannot overwrite a source handled later.
  *
  * @param renames - Worktree ID pairs being applied
  * @param resolveCliToolId - Maps a poller's (worktree, instance) back to its CLI
@@ -596,33 +599,21 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
         coordinator.pendingRestart.delete(move.oldKey);
         carried.set(move.newKey, { startedAt: exports.pollingStartTimes.get(move.oldKey) });
         exports.pollingStartTimes.delete(move.oldKey);
-        (0, prompt_dedup_1.renamePromptHashCacheKey)(move.oldKey, move.newKey);
-        (0, response_dedup_1.renameResponseHashCacheKey)(move.oldKey, move.newKey);
-        // Issue #1695: the prompt hash moved on the line above, so the guard keeps
-        // suppressing the prompt on screen under the new ID. Its tally has to move
-        // with it, or `capture --json` reports zero skips for a session that is
-        // still skipping. Old worktree ID comes back out of the key we just left.
-        const movedFrom = splitPollerKey(move.oldKey);
-        if (movedFrom) {
-            (0, prompt_dedup_state_1.renamePromptDedupSkips)(movedFrom.worktreeId, move.newWorktreeId, move.cliToolId, move.instanceId);
-        }
         (0, tui_accumulator_1.clearTuiAccumulator)(move.oldKey);
     }
+    // Stop the abandoned pollers before any dedup state is written: the stop
+    // clears every cache under its key, and that key can be the destination of
+    // another move in this batch (A:x paused → B:x while B:x is abandoned).
+    // Stopped afterwards, it erased the state that had just arrived (#3553).
+    // An abandoned key is never a move source, so nothing still to be moved is
+    // lost here; and the paused chains are collected after it, as before, so a
+    // pause the stop ends is not carried.
     for (const pollerKey of abandoned) {
         stopPollingByKey(pollerKey);
         logger.warn('poller:migrate-abandoned', { pollerKey });
     }
-    // Phase 2: restart each poller under its new identity.
-    for (const move of moves) {
-        const startedAt = carried.get(move.newKey)?.startedAt;
-        exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
-        if (isFullScreenTui(move.cliToolId)) {
-            (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
-        }
-        scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
-    }
-    // Issue #2230: a chain paused on a prompt has no timer, so the loop above
-    // never sees it — but it is holding the response hash for the turn it paused
+    // Issue #2230: a chain paused on a prompt has no timer, so the loops here
+    // never see it — but it is holding the response hash for the turn it paused
     // on, and `/respond` will resume it under the NEW ID. Move the hash and the
     // pause mark with it; the chain itself stays paused until that resume.
     const pausedMoves = [];
@@ -635,11 +626,41 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
             continue;
         pausedMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}` });
     }
+    // Issue #3553: the dedup state of the whole batch moves in one call per map
+    // family, each lifting every source before writing any destination. Re-keyed
+    // pair by pair, a swap left A with its own state and B empty.
+    (0, prompt_dedup_1.renamePromptHashCacheKeys)(moves);
+    (0, response_dedup_1.renameResponseHashCacheKeys)([...moves, ...pausedMoves]);
+    // Issue #1695: the prompt hash moved above, so the guard keeps suppressing
+    // the prompt on screen under the new ID. Its tally has to move with it, or
+    // `capture --json` reports zero skips for a session that is still skipping.
+    // Old worktree ID comes back out of the key being left.
+    (0, prompt_dedup_state_1.renamePromptDedupSkipsBatch)(moves.flatMap((move) => {
+        const movedFrom = splitPollerKey(move.oldKey);
+        return movedFrom
+            ? [{
+                    oldWorktreeId: movedFrom.worktreeId,
+                    newWorktreeId: move.newWorktreeId,
+                    cliToolId: move.cliToolId,
+                    instanceId: move.instanceId,
+                }]
+            : [];
+    }));
+    // Phase 2: restart each poller under its new identity.
+    for (const move of moves) {
+        const startedAt = carried.get(move.newKey)?.startedAt;
+        exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
+        if (isFullScreenTui(move.cliToolId)) {
+            (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
+        }
+        scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
+    }
+    // Issue #2230: the pause marks of the chains collected above follow their
+    // hashes (moved with the batch). All removed before any is added, for the
+    // same swap reason.
     for (const move of pausedMoves)
         coordinator.pausedOnPrompt.delete(move.oldKey);
-    for (const move of pausedMoves) {
-        (0, response_dedup_1.renameResponseHashCacheKey)(move.oldKey, move.newKey);
+    for (const move of pausedMoves)
         coordinator.pausedOnPrompt.add(move.newKey);
-    }
     return moves;
 }

package/dist/server/src/lib/session/next-action-helper.js

@@ -3,14 +3,14 @@
  * Next Action Helper - Derived state for worktree next actions and review status.
  *
  * Issue #600: UX refresh - provides getNextAction() and getReviewStatus()
- * for Review screen and WorktreeCard display.
+ * for the Review screen (via `/api/worktrees`) and the sidebar row
+ * (`toBranchItem` in `src/types/sidebar.ts`).
  *
  * Uses exhaustive check (satisfies never) pattern to catch future
  * SessionStatus extensions at compile time [DR2-005].
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NEXT_ACTION_KEYS = void 0;
-exports.isNextActionKey = isNextActionKey;
 exports.getNextAction = getNextAction;
 exports.getReviewStatus = getReviewStatus;
 /**
@@ -31,19 +31,6 @@ exports.NEXT_ACTION_KEYS = {
     checkStalled: 'nextAction.checkStalled',
     running: 'nextAction.running',
 };
-const NEXT_ACTION_KEY_SET = new Set(Object.values(exports.NEXT_ACTION_KEYS));
-/**
- * Whether a value is a key this module produces (Issue #1787).
- *
- * `Worktree.nextAction` is a plain `string` on the wire, and a server that
- * predates this Issue still sends the old English literal. Callers must gate
- * `t()` on this: next-intl reports a missing key by rendering the key path, so
- * feeding it `"Approve / Reject"` would put `worktree.Approve / Reject` on
- * screen. Anything that fails this test is rendered verbatim instead.
- */
-function isNextActionKey(value) {
-    return NEXT_ACTION_KEY_SET.has(value);
-}
 /**
  * Determine the next action for a given session state.
  *

package/dist/server/src/lib/verification/env-clean-gate.js

@@ -39,6 +39,7 @@ exports.ENV_CLEAN_GUIDANCE = exports.MAX_REPORTED_ENV_CHANGES = exports.isLivePi
 exports.resolveRequireEnvClean = resolveRequireEnvClean;
 exports.attributeSessionName = attributeSessionName;
 exports.attributeAnchor = attributeAnchor;
+exports.isZcompdumpEntry = isZcompdumpEntry;
 exports.demoVitestPid = demoVitestPid;
 exports.attributeHomeEntry = attributeHomeEntry;
 exports.resolveTaskSessionName = resolveTaskSessionName;
@@ -200,6 +201,17 @@ exports.readLivePidCwd = readLivePidCwd;
  * established.
  */
 const DEMO_VITEST_HOME_ENTRY = /^\.commandmate-demo-vitest-([1-9]\d*)$/;
+/**
+ * zsh's `compinit` cache: `~/.zcompdump` itself, and the `~/.zcompdump.<host>.<pid>`
+ * scratch file it writes before renaming (#3664). A worker's shell start makes
+ * it; the pid in it is already gone by the time the gate looks. Only these two
+ * shapes — any other `.zcompdump*` name stays a violation.
+ */
+const ZCOMPDUMP_HOME_ENTRY = /^\.zcompdump(?:\.[A-Za-z0-9._-]+\.[1-9]\d*)?$/;
+/** Whether a `$HOME` entry name is a zsh compinit cache file (#3664). */
+function isZcompdumpEntry(name) {
+    return ZCOMPDUMP_HOME_ENTRY.test(name);
+}
 const isLivePid = (pid) => {
     try {
         process.kill(pid, 0);
@@ -581,7 +593,8 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
         const afterKeys = new Set(after.entries.map((entry) => entry.key));
         // Only `home-entries`, and only by the whole name: the same string under
         // `~/.commandmate` is a different directory and stays counted.
-        const isIgnoredByConfig = (entry) => probeId === 'home-entries' && ignoredHomeEntries.has(entry.key);
+        const isIgnoredByConfig = (entry) => probeId === 'home-entries' &&
+            (ignoredHomeEntries.has(entry.key) || isZcompdumpEntry(entry.key));
         const added = [];
         const ignoredAdded = [];
         const taskSessionAdded = [];