commandmate 0.29.2 → 0.30.1

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);