commandmate 0.29.2 → 0.30.0

package/dist/server/src/lib/hooks/sources/turn-body.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Separating an agent's own words from its tool log (Issue #2234).
+ *
+ * Four readers — `./claude/transcript`, `./opencode/transcript`,
+ * `./codex/transcript` and `./antigravity/transcript` — turn one agent turn into
+ * the single Markdown body that becomes one `chat_messages` row. Each of them
+ * used to lay the pieces out in transcript order and join them, which put a run
+ * of tool-call lines at the **top** of every body that opened with a tool call.
+ * Measured on 400 real Claude Code transcripts (2026-09-02,
+ * `docs/design/2234-turn-prose-tool-separation.md` §1): **141 of 586 non-empty
+ * turns (24 %)** began with `- \`Bash\` — …`. The chat surface (#2232) shows the
+ * body in full, so those 141 bubbles opened with a tool log instead of a reply.
+ *
+ * This module is the one place that decides the layout, and every reader goes
+ * through it. Two rules:
+ *
+ *  1. **Prose leads.** Text the agent wrote — and the folded `Thinking` quotes
+ *     that sit between the sentences — keep their transcript order and come
+ *     first.
+ *  2. **The tool log is one section, at the end**, in transcript order, folded
+ *     into a blockquote under a labelled heading.
+ *
+ * ## Why the order claim from #2041 / #2121 is narrowed rather than dropped
+ *
+ * Those Issues kept strict transcript order on the argument that "the order is
+ * the only record of what happened when, and this row is the record". That is
+ * still true *within* each kind and is still what this module emits: the tool
+ * lines are in call order, and the paragraphs are in the order they were
+ * written. What is given up is the interleaving **between** the two — which
+ * paragraph a given call sat under. It is given up deliberately, because the
+ * surface that reads this row is a chat bubble, and a bubble whose first line is
+ * `- \`Bash\` — git status` has already failed the reader before the ordering
+ * argument gets a hearing.
+ *
+ * ## Why a blockquote and not `<details>`
+ *
+ * Measured, not assumed (§3 of the design note). The card renders with
+ * `remarkGfm` + `rehypeSanitize` + `rehypeHighlight` and deliberately **no**
+ * `rehypeRaw`, so raw HTML never becomes an element: a `<details>` /
+ * `<summary>` wrapper is dropped whole and takes its summary text with it,
+ * leaving a bare list and no label. A blockquote with a bold first line is
+ * Markdown's own way of saying "subordinate", survives the sanitiser untouched,
+ * and is the same shape the four readers already use for `Thinking`.
+ *
+ * @module lib/hooks/sources/turn-body
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TURN_TOOL_LOG_LABEL = void 0;
+exports.separateTurnBody = separateTurnBody;
+/**
+ * The bold first line of the folded tool section.
+ *
+ * English, like the `Thinking` label the four readers already share, and for the
+ * same reason: the string is written into `chat_messages.content` at read time,
+ * so it is baked into rows that outlive any later locale change and cannot be
+ * re-translated by the UI.
+ */
+exports.TURN_TOOL_LOG_LABEL = 'Tool calls';
+/**
+ * Quote one already-rendered tool line.
+ *
+ * The four readers all render a call as a **single-line** list item — their
+ * detail readers collapse whitespace precisely so a heredoc in a shell command
+ * cannot put a newline here — so one prefix per line is enough and the split is
+ * a guard rather than a case that is expected to fire.
+ */
+function quoteToolLine(line) {
+    return line
+        .split('\n')
+        .map((part) => (part.length > 0 ? `> ${part}` : '>'))
+        .join('\n');
+}
+/**
+ * Lay one turn's rendered blocks out as the body a history row stores.
+ *
+ * Pure: same blocks in, same string out, no clock and no I/O. That is what lets
+ * the settled row (each source's `history` module) and the live
+ * `chat_turn_progress` bubble
+ * (#2199) agree — both reach this function through the same renderer, so the
+ * text a reader watches being written is the text that settles.
+ *
+ * A turn with no tool calls comes out **byte-identical** to what the readers
+ * produced before this Issue: the whole change is the section this adds.
+ *
+ * @param blocks - Rendered pieces in transcript order; empty text is the
+ *   caller's to drop
+ * @returns The body and the two halves it was built from
+ */
+function separateTurnBody(blocks) {
+    const prose = [];
+    const tools = [];
+    for (const block of blocks) {
+        if (block.text.length === 0)
+            continue;
+        if (block.kind === 'tool')
+            tools.push(block.text);
+        else
+            prose.push(block.text);
+    }
+    // A blank line between every pair, which is what keeps a paragraph a paragraph
+    // and stops a heading being absorbed into the text above it. #2041's join had
+    // a second rule — consecutive tool lines joined by a single newline so they
+    // stayed one Markdown list — which is gone because no tool line reaches this
+    // list any more.
+    const proseText = prose.join('\n\n');
+    const toolLog = tools.length === 0
+        ? ''
+        : [
+            `> **${exports.TURN_TOOL_LOG_LABEL} (${tools.length})**`,
+            '>',
+            ...tools.map(quoteToolLine),
+        ].join('\n');
+    const body = proseText.length > 0 && toolLog.length > 0
+        ? `${proseText}\n\n${toolLog}`
+        : `${proseText}${toolLog}`;
+    return { body, prose: proseText, toolLog, toolCalls: tools.length };
+}

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

@@ -13,10 +13,8 @@ exports.clearPromptHashCache = clearPromptHashCache;
 exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
-/**
- * In-memory cache: pollerKey -> SHA-256 hash of last saved prompt content.
- */
-const promptHashCache = new Map();
+const promptHashCache = globalThis.__promptHashCache ??
+    (globalThis.__promptHashCache = new Map());
 /**
  * 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.

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

@@ -96,6 +96,35 @@ function observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output)
         matchedText: match?.matchedText,
     }).catch(() => { });
 }
+/**
+ * The `onUpdated` hook for `markPendingPromptsAsAnswered` (Issue #2195).
+ *
+ * The sweep stamps every still-pending prompt row of an instance the moment the
+ * agent is seen to have moved on, which flips a prompt card in the chat surface
+ * from "waiting for your answer" to answered. That was the one history mutation
+ * with no realtime frame behind it, so every open pane kept showing the stale
+ * card until its next `/messages` poll — and #2195 stretches that poll to 15s
+ * whenever a socket is up, so the omission had to be closed in the same change
+ * that introduced the longer interval.
+ *
+ * `message_updated`, never `message`: the row already existed and was already
+ * delivered when it was created, so a client that appended instead of replacing
+ * would show the question twice.
+ */
+function broadcastPromptSweptToAnswered(worktreeId) {
+    return (message) => {
+        try {
+            (0, ws_server_1.broadcastMessage)('message_updated', { worktreeId, message });
+        }
+        catch (error) {
+            // The rows are already stamped; a socket write must not fail the poll.
+            logger.warn('prompt-sweep-broadcast-failed', {
+                worktreeId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+}
 // Issue #1790: arm the waiting-edge push subscription.
 //
 // It has to exist before the first edge, and `server.ts` reaches this module at
@@ -593,7 +622,7 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             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)) {
-                const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId);
+                const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId, broadcastPromptSweptToAnswered(worktreeId));
                 if (answeredCount > 0) {
                     logger.info('marked-answeredcount-pending');
                 }
@@ -809,13 +838,25 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // (the prompt row, Auto-Yes, the waiting episode, the push fan-out), and the
         // liveness answer is only allowed to suppress the two calls that RECORD THE
         // REPLY. See `./structured-history-gate` for the whole argument.
-        const structuredHistoryLive = (0, structured_history_gate_1.isStructuredHistoryWriterLive)(worktreeId, cliToolId, instanceId);
+        //
+        // Issue #2121 adds the second shape. Claude has no stream to be live on; it
+        // has a transcript file, and this is the moment to read it — the turn is
+        // finished (everything above this line established that) and the row is
+        // about to be written. `captureStructuredHistoryTurn` writes the agent's own
+        // 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.
+        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,
+            }));
         // Create Markdown log file for the conversation pair
         if (cleanedResponse && !structuredHistoryLive) {
             await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, cleanedResponse, cliToolId);
         }
         // Mark any pending prompts as answered
-        const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId);
+        const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId, resolvedInstanceId, broadcastPromptSweptToAnswered(worktreeId));
         if (answeredCount > 0) {
             logger.info('marked-answeredcount-pending');
         }

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

@@ -23,10 +23,8 @@ exports.isDuplicateResponse = isDuplicateResponse;
 exports.clearResponseHashCache = clearResponseHashCache;
 exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
 const crypto_1 = require("crypto");
-/**
- * In-memory cache: pollerKey -> SHA-256 hash of the last saved response content.
- */
-const responseHashCache = new Map();
+const responseHashCache = globalThis.__responseHashCache ??
+    (globalThis.__responseHashCache = new Map());
 /**
  * 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.

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

@@ -1,7 +1,7 @@
 "use strict";
 /** Polling lifecycle management: start, stop, schedule, and state tracking for response polling. */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pollingStartTimes = exports.activePollers = exports.GEMINI_LOADING_INDICATORS = exports.MAX_POLLING_DURATION = exports.POLLING_INTERVAL = void 0;
+exports.pollingStartTimes = exports.activePollers = exports.GEMINI_LOADING_INDICATORS = exports.STALLED_TICK_TIMEOUT = exports.MAX_POLLING_DURATION = exports.POLLING_INTERVAL = void 0;
 exports.getPollerKey = getPollerKey;
 exports.startPolling = startPolling;
 exports.scheduleNextResponsePoll = scheduleNextResponsePoll;
@@ -9,6 +9,7 @@ exports.stopPolling = stopPolling;
 exports.stopAllPolling = stopAllPolling;
 exports.getActivePollers = getActivePollers;
 exports.migrateResponsePollerWorktreeIds = migrateResponsePollerWorktreeIds;
+const async_hooks_1 = require("async_hooks");
 const logger_1 = require("../../lib/logger");
 const tui_accumulator_1 = require("../tui-accumulator");
 const prompt_dedup_1 = require("./prompt-dedup");
@@ -29,6 +30,19 @@ exports.POLLING_INTERVAL = 2000;
  * Previously 5 minutes, which caused silent polling stops for long-running tasks.
  */
 exports.MAX_POLLING_DURATION = 30 * 60 * 1000;
+/**
+ * How long a tick may sit inside `checkForResponse()` before a restart stops
+ * waiting for it (Issue #2223).
+ *
+ * Restarts are normally handed to the in-flight tick so the old and new chains
+ * never run at once. That queue is only safe while the tick is guaranteed to
+ * settle: a `checkForResponse()` that never resolves would otherwise park every
+ * later `startPolling()` for that session *forever*, which is a worse failure
+ * than the overlap the queue avoids. One tmux capture plus the save path is
+ * seconds at the outside, so a minute means the tick is lost, and the restart
+ * goes ahead without it.
+ */
+exports.STALLED_TICK_TIMEOUT = 60 * 1000;
 /**
  * Gemini auth/loading state indicators that should not be treated as complete responses.
  * Braille spinner characters are shared with CLAUDE_SPINNER_CHARS in cli-patterns.ts.
@@ -38,25 +52,38 @@ exports.GEMINI_LOADING_INDICATORS = [
     'Waiting for auth',
     '\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f',
 ];
-// ============================================================================
-// Poller State Management
-// ============================================================================
+const coordinator = globalThis.__responsePollerCoordinator ??
+    (globalThis.__responsePollerCoordinator = {
+        activePollers: new Map(),
+        pollingStartTimes: new Map(),
+        owners: new Map(),
+        running: new Map(),
+        pendingRestart: new Map(),
+        ownerStorage: new async_hooks_1.AsyncLocalStorage(),
+        generationCounter: 0,
+    });
 /**
  * Active pollers map: "worktreeId:instanceId" -> NodeJS.Timeout
  *
- * Module-scope variable (not globalThis). Node.js module cache ensures
- * singleton behavior. See D3-004 in design policy for details.
+ * Shared through `globalThis` (see {@link PollerCoordinator}): the Node module
+ * cache does **not** give this singleton behaviour, because the module is
+ * evaluated once per bundle and `next start` builds more than one bundle that
+ * reaches it (Issue #2223).
  *
  * Issue #868: The key is scoped by instanceId so multiple instances of the
  * same CLI tool on one worktree get independent pollers. For the primary
  * instance (instanceId omitted or equal to cliToolId), the key is identical
  * to the legacy "worktreeId:cliToolId" form for backward compatibility.
+ *
+ * Membership alone does **not** say who owns the chain — a tick that has
+ * already fired leaves its timer here while it runs. Code deciding whether to
+ * keep polling must compare ownership tokens, not call `.has()`.
  */
-exports.activePollers = new Map();
+exports.activePollers = coordinator.activePollers;
 /**
  * Polling start times map: "worktreeId:instanceId" -> timestamp
  */
-exports.pollingStartTimes = new Map();
+exports.pollingStartTimes = coordinator.pollingStartTimes;
 /**
  * Generate poller key from worktree ID and agent instance.
  *
@@ -70,12 +97,31 @@ exports.pollingStartTimes = new Map();
 function getPollerKey(worktreeId, cliToolId, instanceId) {
     return `${worktreeId}:${instanceId ?? cliToolId}`;
 }
+/** Hand `pollerKey` to a brand-new chain, retiring whichever chain held it. */
+function takeOwnership(pollerKey) {
+    const previous = coordinator.owners.get(pollerKey);
+    if (previous)
+        previous.superseded = true;
+    const owner = {
+        pollerKey,
+        generation: ++coordinator.generationCounter,
+        superseded: false,
+        stopped: false,
+    };
+    coordinator.owners.set(pollerKey, owner);
+    return owner;
+}
 // ============================================================================
 // Polling lifecycle (public API)
 // ============================================================================
 /**
  * Start polling for CLI tool response
  *
+ * Issue #2223: at most one chain per poller key exists in the whole process,
+ * and starting one while a tick of the previous chain is still inside
+ * `checkForResponse()` does **not** run the two side by side — the restart is
+ * handed to that tick's epilogue and applied when it settles.
+ *
  * @param worktreeId - Worktree ID
  * @param cliToolId - CLI tool ID (claude, codex, gemini)
  * @param instanceId - Optional agent instance ID (defaults to primary)
@@ -87,30 +133,87 @@ function getPollerKey(worktreeId, cliToolId, instanceId) {
  */
 function startPolling(worktreeId, cliToolId, instanceId) {
     const pollerKey = getPollerKey(worktreeId, cliToolId, instanceId);
+    const target = { worktreeId, cliToolId, instanceId };
+    const inFlight = coordinator.running.get(pollerKey);
+    if (inFlight) {
+        // Whatever happens next, the tick that is mid-flight has lost the key: it
+        // must not reschedule itself over the new chain, and its snapshot is of the
+        // previous turn.
+        inFlight.owner.superseded = true;
+        if (Date.now() - inFlight.since < exports.STALLED_TICK_TIMEOUT) {
+            coordinator.pendingRestart.set(pollerKey, target);
+            return;
+        }
+        logger.warn('poller:restart-past-stalled-tick', {
+            pollerKey,
+            generation: inFlight.owner.generation,
+            runningForMs: Date.now() - inFlight.since,
+        });
+        coordinator.running.delete(pollerKey);
+    }
     // Stop existing poller if any
     stopPolling(worktreeId, cliToolId, instanceId);
+    beginPolling(target);
+}
+/** Seed a fresh polling cycle (start time, TUI accumulator) and schedule its first tick. */
+function beginPolling(target) {
+    const pollerKey = getPollerKey(target.worktreeId, target.cliToolId, target.instanceId);
     // Record start time
-    exports.pollingStartTimes.set(pollerKey, Date.now());
+    coordinator.pollingStartTimes.set(pollerKey, Date.now());
     // Initialize TUI accumulator for full-screen TUI tools (Layer 2 safety net)
-    if (cliToolId === 'opencode' || cliToolId === 'copilot') {
+    if (target.cliToolId === 'opencode' || target.cliToolId === 'copilot') {
         (0, tui_accumulator_1.initTuiAccumulator)(pollerKey);
     }
     // Start polling with setTimeout chain to prevent race conditions
-    scheduleNextResponsePoll(worktreeId, cliToolId, instanceId);
+    scheduleNextResponsePoll(target.worktreeId, target.cliToolId, target.instanceId);
 }
-/** Schedule next checkForResponse() after current one completes (setTimeout chain) */
+/**
+ * Take over `pollerKey` with a new chain and schedule its first tick.
+ *
+ * Public because {@link migrateResponsePollerWorktreeIds} restarts a poller
+ * under a new worktree ID with it. The chain's own continuation does *not* go
+ * through here: it keeps its ownership token, so its generation survives the
+ * whole cycle.
+ */
 function scheduleNextResponsePoll(worktreeId, cliToolId, instanceId) {
     const pollerKey = getPollerKey(worktreeId, cliToolId, instanceId);
-    const timerId = setTimeout(async () => {
+    scheduleTick({ worktreeId, cliToolId, instanceId }, takeOwnership(pollerKey));
+}
+/** Arm the next tick of an existing chain, keeping its ownership token. */
+function scheduleTick(target, owner) {
+    const timerId = setTimeout(() => {
+        void runPollTick(target, owner);
+    }, exports.POLLING_INTERVAL);
+    coordinator.activePollers.set(owner.pollerKey, timerId);
+}
+/**
+ * One poll: check for a response, push a snapshot, and arm the next tick.
+ *
+ * Every decision after the `await` is made against `owner`, never against the
+ * presence of a key in {@link activePollers}. `clearTimeout()` cannot cancel a
+ * timer that has already fired, so a tick of a chain that was stopped or
+ * superseded while it was awaiting `checkForResponse()` still gets here — and
+ * before #2223 it read `activePollers.has()` as "I am still the poller",
+ * re-registering its own timer over the live one and leaving that poller's
+ * timer running but untracked (Issue #2223).
+ */
+async function runPollTick(target, owner) {
+    const pollerKey = owner.pollerKey;
+    // The timer fired for a chain that has since lost the key. Nothing to do:
+    // whoever retired it also armed (or deliberately did not arm) the successor.
+    if (owner.superseded || owner.stopped)
+        return;
+    coordinator.running.set(pollerKey, { owner, since: Date.now() });
+    try {
         // Check if max duration exceeded
-        const startTime = exports.pollingStartTimes.get(pollerKey);
+        const startTime = coordinator.pollingStartTimes.get(pollerKey);
         if (startTime && Date.now() - startTime > exports.MAX_POLLING_DURATION) {
-            stopPolling(worktreeId, cliToolId, instanceId);
+            stopPollingByKey(pollerKey);
             return;
         }
         // Check for response
         try {
-            await (0, response_checker_1.checkForResponse)(worktreeId, cliToolId, instanceId);
+            await coordinator.ownerStorage.run(owner, () => (0, response_checker_1.checkForResponse)(target.worktreeId, target.cliToolId, target.instanceId));
         }
         catch (error) {
             logger.error('error:', { error: error instanceof Error ? error.message : String(error) });
@@ -118,25 +221,65 @@ function scheduleNextResponsePoll(worktreeId, cliToolId, instanceId) {
         // Issue #1120: push the current terminal snapshot to WS subscribers so the
         // output streams during generation. No-op (and no tmux capture) when nobody
         // is subscribed to the worktree room. Best-effort; polling is the fallback.
-        void (0, terminal_broadcast_1.broadcastTerminalSnapshot)(worktreeId, cliToolId, instanceId);
+        //
+        // Issue #2223: skipped once another chain owns the key — a superseded tick
+        // would push the previous turn's screen on top of the live one, and its
+        // `version` counter would make the client drop the real frame that follows.
+        if (!owner.superseded) {
+            void (0, terminal_broadcast_1.broadcastTerminalSnapshot)(target.worktreeId, target.cliToolId, target.instanceId);
+        }
         // Schedule next poll ONLY after current one completes
-        // Guard: only if poller is still active (not stopped during checkForResponse)
-        if (exports.activePollers.has(pollerKey)) {
-            scheduleNextResponsePoll(worktreeId, cliToolId, instanceId);
+        // Guard: only if THIS chain is still the poller for the key (Issue #2223)
+        if (!owner.superseded && !owner.stopped) {
+            scheduleTick(target, owner);
         }
-    }, exports.POLLING_INTERVAL);
-    exports.activePollers.set(pollerKey, timerId);
+    }
+    finally {
+        if (coordinator.running.get(pollerKey)?.owner === owner) {
+            coordinator.running.delete(pollerKey);
+        }
+        // Apply a restart that arrived while this tick was in flight. Doing it here
+        // rather than in startPolling() is what keeps the old and new chains from
+        // polling the same pane at the same time.
+        const pending = coordinator.pendingRestart.get(pollerKey);
+        if (pending) {
+            coordinator.pendingRestart.delete(pollerKey);
+            stopPollingByKey(pollerKey);
+            beginPolling(pending);
+        }
+    }
 }
 /**
  * Stop the poller identified by an already-computed poller key.
  * Shared by stopPolling() and stopAllPolling() so cleanup logic stays in one place.
  */
 function stopPollingByKey(pollerKey) {
-    const timerId = exports.activePollers.get(pollerKey);
+    // Issue #2223: a tick that has been superseded still runs to completion, and
+    // `checkForResponse()` ends the turn with `stopPolling()` on four paths
+    // (worktree gone, session not running, prompt detected, TUI reply saved).
+    // Honouring that verdict would kill the chain that replaced it — the old
+    // tick is describing a turn that is already over.
+    const caller = coordinator.ownerStorage.getStore();
+    if (caller && caller.pollerKey === pollerKey && (caller.superseded || caller.stopped)) {
+        logger.info('poller:stale-stop-ignored', {
+            pollerKey,
+            generation: caller.generation,
+        });
+        return;
+    }
+    const owner = coordinator.owners.get(pollerKey);
+    if (owner) {
+        owner.stopped = true;
+        coordinator.owners.delete(pollerKey);
+    }
+    // A restart queued behind an in-flight tick is cancelled by an explicit stop:
+    // "start then stop" must leave the session stopped.
+    coordinator.pendingRestart.delete(pollerKey);
+    const timerId = coordinator.activePollers.get(pollerKey);
     if (timerId) {
         clearTimeout(timerId);
-        exports.activePollers.delete(pollerKey);
-        exports.pollingStartTimes.delete(pollerKey);
+        coordinator.activePollers.delete(pollerKey);
+        coordinator.pollingStartTimes.delete(pollerKey);
     }
     // Clean up TUI accumulator if present
     (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
@@ -166,9 +309,14 @@ function stopPolling(worktreeId, cliToolId, instanceId) {
  * Used for cleanup on server shutdown
  */
 function stopAllPolling() {
-    for (const pollerKey of Array.from(exports.activePollers.keys())) {
+    const keys = new Set([
+        ...Array.from(coordinator.activePollers.keys()),
+        ...Array.from(coordinator.owners.keys()),
+    ]);
+    for (const pollerKey of keys) {
         stopPollingByKey(pollerKey);
     }
+    coordinator.pendingRestart.clear();
 }
 /**
  * Get list of active pollers
@@ -176,7 +324,7 @@ function stopAllPolling() {
  * @returns Array of worktree IDs currently being polled
  */
 function getActivePollers() {
-    return Array.from(exports.activePollers.keys());
+    return Array.from(coordinator.activePollers.keys());
 }
 /** Split a poller key into its worktree and instance halves. */
 function splitPollerKey(pollerKey) {
@@ -200,8 +348,9 @@ function splitPollerKey(pollerKey) {
  * would go on capturing `mcbd-<cli>-<OLD id>` (a session that no longer exists
  * after the rename), writing its messages against an ID no row carries, and
  * re-registering the old key the moment it fired. So each poller is torn down
- * and restarted under the new ID, with everything that represents *progress*
- * carried across:
+ * and restarted under the new ID — ownership token included (Issue #2223), so a
+ * tick already inside `checkForResponse()` cannot come back and act on the old
+ * ID — with everything that represents *progress* carried across:
  *
  * - `pollingStartTimes`, so MAX_POLLING_DURATION still measures from when the
  *   turn actually began rather than restarting the 30-minute budget;
@@ -264,6 +413,19 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
         if (timerId)
             clearTimeout(timerId);
         exports.activePollers.delete(move.oldKey);
+        // Issue #2223: retire the ownership token as well. A tick that is inside
+        // `checkForResponse()` right now cannot be cancelled by `clearTimeout`, and
+        // without this it would resume, find its key gone and — before #2223 —
+        // still be able to act on the old worktree ID. Marked superseded rather
+        // than merely stopped: Phase 2 below arms a replacement chain, so the old
+        // tick's snapshot would land on top of the new one's.
+        const retired = coordinator.owners.get(move.oldKey);
+        if (retired) {
+            retired.superseded = true;
+            retired.stopped = true;
+            coordinator.owners.delete(move.oldKey);
+        }
+        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);