claude-code-session-manager 0.21.2 → 0.21.4

package/src/main/scheduler.cjs

@@ -180,12 +180,16 @@ const HEARTBEAT_MAX_BYTES = 1024 * 1024;
 // DEFAULT_PROJECT_CWD imported from lib/schedulerBatch.cjs (single source of truth).
 
 const ENV_CAP = process.env.SM_SCHEDULER_MAX_CONCURRENCY
-  ? Math.max(1, Math.min(20, parseInt(process.env.SM_SCHEDULER_MAX_CONCURRENCY, 10) || 4))
+  ? Math.max(1, Math.min(20, parseInt(process.env.SM_SCHEDULER_MAX_CONCURRENCY, 10) || 3))
   : null;
 
+// Each headless claude -p process can grow past 1 GB; require 1.5 GB headroom
+// per running+pending slot to avoid OOM (incident 2026-06-10).
+const MIN_FREE_MB_PER_JOB = 1500;
+
 const DEFAULT_CONFIG = {
   offsetMinutes: 15,
-  concurrencyCap: ENV_CAP ?? 4,
+  concurrencyCap: ENV_CAP ?? 3,
   defaultCwd: DEFAULT_PROJECT_CWD,
   // 'when-available' = poll usage and fire whenever utilization < threshold.
   // 'on-reset'        = fire offsetMinutes after the next 5h reset (legacy).
@@ -202,6 +206,39 @@ const DEFAULT_CONFIG = {
   },
 };
 
+// ---------- memory gate ----------
+
+/**
+ * Returns available system memory in MB.  Reads /proc/meminfo on Linux; fails
+ * open (returns Infinity) on darwin or on any parse/read error so the gate
+ * never blocks scheduling on unsupported platforms.
+ */
+function getAvailableMemMb() {
+  if (process.platform !== 'linux') return Infinity;
+  try {
+    const raw = fs.readFileSync('/proc/meminfo', 'utf8');
+    const m = raw.match(/^MemAvailable:\s+(\d+)\s+kB/m);
+    if (!m) return Infinity;
+    return Math.floor(parseInt(m[1], 10) / 1024);
+  } catch {
+    return Infinity;
+  }
+}
+
+/**
+ * Pure helper: clamp a batch down so launching `toLaunch` more jobs doesn't
+ * drop available memory below MIN_FREE_MB_PER_JOB per active slot.
+ * Exported for unit tests.
+ */
+function memoryLimitedBatchSize(availableMb, minPerJob, runningCount, batchLen) {
+  if (availableMb === Infinity) return batchLen;
+  let allowed = batchLen;
+  while (allowed > 0 && availableMb < minPerJob * (runningCount + allowed)) {
+    allowed--;
+  }
+  return allowed;
+}
+
 // ---------- fs helpers ----------
 
 /**
@@ -539,6 +576,8 @@ let heartbeatInterval = null;
 // double-spawn when runDueJobs() is called while jobs are in flight.
 const runningSet = new Set();
 let cancelToken = { cancelled: false };
+// Last memory-gate observation; included in snapshot for renderer visibility.
+let lastMemGate = null;
 
 function attachWindow(w) { mainWindow = w; }
 
@@ -557,6 +596,13 @@ function buildScheduleStatePayload(state, { withPaths = false } = {}) {
     nextReset: getNextResetCached(),
     paused: state.paused,
     utilization: cachedUtilization,
+    pollHealth: {
+      lastPollAt,
+      lastPollOk,
+      consecutiveFailures,
+      lastFailureKind,
+    },
+    memGate: lastMemGate,
   };
   if (withPaths) {
     payload.paths = { root: ROOT, prds: PRDS_DIR, runs: RUNS_DIR, queue: QUEUE_PATH };
@@ -743,7 +789,7 @@ async function executeJob(job, runDir, defaultCwd, onPid) {
   // before handing it to the child process.
   try { fs.accessSync(cwd, fs.constants.X_OK); }
   catch {
-    const errMsg = `cwd no longer exists: ${cwd}`;
+    const errMsg = `cwd does not exist on this machine: ${cwd}`;
     safeLog(`[scheduler] ${errMsg}\n`);
     closeFd();
     // Sync write: this is an early-exit error path inside an async function,
@@ -1356,11 +1402,29 @@ function tickQueue() {
     const batch = pickNextBatch(state.jobs, runningSet, cap);
     if (batch.length === 0) return;
 
+    const availableMb = getAvailableMemMb();
+    const allowed = memoryLimitedBatchSize(availableMb, MIN_FREE_MB_PER_JOB, runningSet.size, batch.length);
+    if (allowed === 0) {
+      const threshold = MIN_FREE_MB_PER_JOB * (runningSet.size + 1);
+      console.log(`[scheduler] memory gate: available=${availableMb} MB < threshold=${threshold} MB — deferring ${batch.length} job(s)`);
+      lastMemGate = { availableMb, threshold, deferred: true, at: new Date().toISOString() };
+      return;
+    }
+    const gatedBatch = batch.slice(0, allowed);
+    if (gatedBatch.length < batch.length) {
+      console.log(`[scheduler] memory gate: available=${availableMb} MB — clamped batch ${batch.length} → ${gatedBatch.length}`);
+      lastMemGate = { availableMb, threshold: MIN_FREE_MB_PER_JOB * (runningSet.size + gatedBatch.length), deferred: false, clamped: true, at: new Date().toISOString() };
+    } else {
+      // Ungated full batch: clear stale gate snapshot so status doesn't show
+      // a stale deferral from a previous tick.
+      lastMemGate = null;
+    }
+
     await mutate((s) => { s.lastRunAt = new Date().toISOString(); });
     await broadcast();
 
     const { runId, dir: runDir } = pickRunDir();
-    for (const job of batch) {
+    for (const job of gatedBatch) {
       if (cancelToken.cancelled) break;
       // spawnJob is fire-and-forget; it calls tickQueue() on completion.
       spawnJob(job, runId, runDir, state.config.defaultCwd).catch(() => {});
@@ -1450,6 +1514,18 @@ async function reapDeadRunningJobs() {
 
 // ---------- poll loop with exponential backoff ----------
 
+/**
+ * Pure: given the current pause reason and whether a reset timestamp is cached,
+ * return which clearPause source to pass after a successful billing poll, or null.
+ * Exported for unit testing.
+ */
+function pollRecoveryClearSource(pauseReason, hasCachedReset) {
+  if (pauseReason === 'network') return 'network-recovered';
+  if (pauseReason === 'auth') return 'auth-recovered';
+  if (pauseReason === 'reset_failure' && hasCachedReset) return 'reset-recovered';
+  return null;
+}
+
 async function pollLoop() {
   try {
     await reapDeadRunningJobs().catch(() => {});
@@ -1468,15 +1544,10 @@ async function pollLoop() {
       lastPollOk = true;
       persistSchedulerState();
 
-      // If a 'network' pause resolved, clear it now that we have a good reading.
+      // Clear any pause that was waiting for a successful billing read.
       const cur = await readQueue();
-      if (cur.paused?.reason === 'network') {
-        await clearPause('network-recovered');
-      }
-      // If 'reset_failure' was set and we now have a valid reset, clear it.
-      if (cur.paused?.reason === 'reset_failure' && cachedNextReset) {
-        await clearPause('reset-recovered');
-      }
+      const clearSrc = pollRecoveryClearSource(cur.paused?.reason ?? null, !!cachedNextReset);
+      if (clearSrc) await clearPause(clearSrc);
 
       await maybeLaunchWhenAvailable(cur);
       await broadcast();
@@ -1558,6 +1629,66 @@ function selectHistoryJobs(jobs, limit) {
     .slice(0, cap);
 }
 
+// Transcript-scan verdicts that re-running verifyRun can re-evaluate. NOT
+// 'uncommitted_changes' — that comes from the git commit-guard, which verifyRun
+// does not inspect, so re-scanning it would always return 'clean' and wrongly
+// heal a genuinely-unfinished job.
+const RESCANNABLE_VERDICTS = new Set(['transcript_errors', 'verify_unavailable']);
+
+/**
+ * Pure predicate: is this job eligible for the boot re-verify self-heal? Only
+ * needs_review jobs with a run log AND a transcript-scan verdict. Crucially
+ * EXCLUDES 'uncommitted_changes' (git commit-guard) — verifyRun can't see git,
+ * so re-scanning it would falsely heal an unfinished job. Exported for tests.
+ */
+function isRescanCandidate(job) {
+  return !!job
+    && job.status === 'needs_review'
+    && !!job.runId
+    && RESCANNABLE_VERDICTS.has(job.verifierVerdict);
+}
+
+/**
+ * Self-healing pass over needs_review jobs. The verifier runs in-process, so a
+ * fix to runVerify.cjs only takes effect for jobs verified AFTER an app
+ * restart — jobs flagged by the old (buggy) verifier stay stuck in needs_review
+ * forever. On boot we re-run the CURRENT verifier over every transcript-scan
+ * needs_review job and auto-complete the ones that now pass clean, so verifier
+ * improvements retroactively clear their own false positives (2026-06-10:
+ * anchored ImportError detectors + harness-tool-error exemption healed 8 jobs).
+ *
+ * @returns {Promise<{rescanned:number, healed:string[]}>}
+ */
+async function reverifyNeedsReview() {
+  const snap = await readQueue();
+  const candidates = snap.jobs.filter(isRescanCandidate);
+  const healed = [];
+  for (const job of candidates) {
+    const runDir = path.join(RUNS_DIR, job.runId);
+    const prdPath = path.join(PRDS_DIR, `${job.slug}.md`);
+    let v = null;
+    try {
+      v = await verifyRun({ runDir, prdPath, queueEntry: job, allJobs: snap.jobs });
+    } catch { continue; } // unreadable log etc. — leave for human review
+    if (v && v.verdict === 'clean') healed.push(job.slug);
+  }
+  if (healed.length) {
+    const healSet = new Set(healed);
+    await mutate((s) => {
+      for (const j of s.jobs) {
+        if (j.status === 'needs_review' && healSet.has(j.slug)) {
+          j.status = 'completed';
+          j.error = null;
+          delete j.verifierVerdict;
+        }
+      }
+    });
+    console.log(`[scheduler] boot reverify: healed ${healed.length} stale needs_review → completed (${healed.join(', ')})`);
+    await broadcast();
+  }
+  return { rescanned: candidates.length, healed };
+}
+
 function registerScheduleHandlers() {
   ensureDirs();
   supervisor.registerHandlers();
@@ -1595,6 +1726,13 @@ function registerScheduleHandlers() {
     };
   });
 
+  ipcMain.handle('schedule:reverify-needs-review', async () => {
+    // Manual trigger for the boot self-heal pass — re-scan needs_review jobs
+    // with the current verifier and auto-complete the ones that now pass clean.
+    const result = await reverifyNeedsReview();
+    return { ok: true, ...result };
+  });
+
   ipcMain.handle('schedule:force-tick', async () => {
     // Bypass the billing-poll gate entirely — fire pending jobs immediately regardless of meter state.
     // Clears any existing pause first (same semantics as run-now).
@@ -1850,6 +1988,13 @@ async function init() {
     await setPaused(boot.paused.reason, boot.paused.resumeAt);
   }
 
+  // Self-heal stale needs_review flags using the current verifier (see
+  // reverifyNeedsReview). Runs once on boot so a shipped verifier fix clears
+  // its own historical false positives without manual retagging.
+  await reverifyNeedsReview().catch((e) => {
+    console.error(`[scheduler] boot reverify failed: ${e?.message ?? e}`);
+  });
+
   await rescheduleTimer();
   // Refresh next-reset every 10 minutes — billing window can shift if usage
   // resets early or the auth token rotates. Tracked so re-init doesn't leak.
@@ -1961,6 +2106,19 @@ const remote = {
     const resolved = safeSlugPath(slug);
     if (!resolved) return { ok: false, error: 'invalid slug' };
     try {
+      // Symlink defense, matching readPrd/readLog: safeSlugPath is lexical and
+      // does NOT resolve symlinks, so a rogue job could plant prds/x.md → an
+      // arbitrary $HOME path and have writeTextAtomic clobber it. Resolve the
+      // real parent dir (the file itself may not exist yet) and re-assert
+      // containment; also reject the target if it is already a symlink.
+      const realParent = await fsp.realpath(path.dirname(resolved));
+      if (realParent !== PRDS_DIR && !realParent.startsWith(PRDS_DIR + path.sep)) {
+        return { ok: false, error: 'invalid slug' };
+      }
+      const existing = await fsp.lstat(resolved).catch(() => null);
+      if (existing && existing.isSymbolicLink()) {
+        return { ok: false, error: 'invalid slug' };
+      }
       await config.writeTextAtomic(resolved, body);
       const stat = await fsp.stat(resolved);
       return { ok: true, bytesWritten: stat.size };
@@ -2005,4 +2163,4 @@ const remote = {
   },
 };
 
-module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs };
+module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, reverifyNeedsReview, isRescanCandidate };

package/src/main/transcripts.cjs

@@ -43,6 +43,44 @@ function transcriptPath(cwd, sessionUuid) {
   return path.join(os.homedir(), '.claude', 'projects', encodeCwd(cwd), `${sessionUuid}.jsonl`);
 }
 
+const MAX_RAW_STR = 4096;
+
+// Block types whose text/content fields are parsed structurally by
+// orchestrator.ts / race.ts — truncating them produces mid-token "…" and
+// unparseable JSON, so they are exempt from the size cap.
+const EXEMPT_TYPES = new Set(['tool_result', 'tool_use']);
+
+/**
+ * Cap string fields in a content block array so arbitrary tool output doesn't
+ * bloat the ring buffer. Blocks whose type is in EXEMPT_TYPES are passed
+ * through intact so that structured result payloads survive to the digest
+ * parsers in race.ts / orchestrator.ts.
+ */
+function trimContentArray(content) {
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => {
+    if (!block || typeof block !== 'object') return block;
+    if (EXEMPT_TYPES.has(block.type)) return block;
+    const b = { ...block };
+    if (typeof b.text === 'string' && b.text.length > MAX_RAW_STR) {
+      b.text = b.text.slice(0, MAX_RAW_STR) + '…';
+    }
+    if (typeof b.content === 'string' && b.content.length > MAX_RAW_STR) {
+      b.content = b.content.slice(0, MAX_RAW_STR) + '…';
+    }
+    if (Array.isArray(b.content)) {
+      b.content = trimContentArray(b.content);
+    }
+    return b;
+  });
+}
+
+/** Build the slim raw projection used by race.ts and orchestrator.ts. */
+function makeRaw(obj) {
+  const msgContent = obj?.message?.content;
+  return { message: { content: trimContentArray(msgContent) } };
+}
+
 /**
  * Parse one JSONL line defensively. Real schema drifts, so we pass through
  * anything that parses and tag a coarse `kind`.
@@ -56,7 +94,7 @@ function classifyLine(obj) {
 
   // Usage rollups arrive as summary events.
   if (obj.usage || msg?.usage) {
-    return { kind: 'usage', data: obj.usage || msg.usage, raw: obj };
+    return { kind: 'usage', data: obj.usage || msg.usage, raw: makeRaw(obj) };
   }
 
   // Tool uses: scan content array for tool_use blocks.
@@ -64,31 +102,31 @@ function classifyLine(obj) {
     for (const block of content) {
       if (block?.type === 'tool_use') {
         if (block.name === 'TodoWrite') {
-          return { kind: 'todo_write', data: block.input?.todos || block.input || [], raw: obj };
+          return { kind: 'todo_write', data: block.input?.todos || block.input || [], raw: makeRaw(obj) };
         }
         if (block.name === 'ExitPlanMode' || block.name === 'EnterPlanMode') {
-          return { kind: 'plan', data: block.input, raw: obj };
+          return { kind: 'plan', data: block.input, raw: makeRaw(obj) };
         }
         if (block.name === 'Agent' || block.name === 'Task') {
           // Include block.id as toolUseId so the live store can match the
           // corresponding tool_result and update per-agent lastActivityAt.
-          return { kind: 'agent_spawn', data: { ...block.input, toolUseId: block.id }, raw: obj };
+          return { kind: 'agent_spawn', data: { ...block.input, toolUseId: block.id }, raw: makeRaw(obj) };
         }
         return {
           kind: 'tool_use',
           data: { name: block.name, input: block.input, id: block.id },
-          raw: obj,
+          raw: makeRaw(obj),
         };
       }
       // tool_result carries the tool_use_id of the completed Task/Agent call.
       // The live store uses this to update the agent's lastActivityAt bookend.
       if (block?.type === 'tool_result' && block.tool_use_id) {
-        return { kind: 'tool_result', data: { toolUseId: block.tool_use_id }, raw: obj };
+        return { kind: 'tool_result', data: { toolUseId: block.tool_use_id }, raw: makeRaw(obj) };
       }
     }
   }
 
-  return { kind: type || 'message', data: obj, raw: obj };
+  return { kind: type || 'message', data: obj, raw: makeRaw(obj) };
 }
 
 /**
@@ -129,7 +167,7 @@ async function readDelta(sub) {
   }
 }
 
-async function flush(sub, { emit = true } = {}) {
+async function doFlush(sub, { emit = true, replay = false } = {}) {
   const lines = await readDelta(sub);
   for (const line of lines) {
     let obj;
@@ -150,6 +188,7 @@ async function flush(sub, { emit = true } = {}) {
       cwd: sub.cwd,
       sessionUuid: sub.sessionUuid,
       ev,
+      replay,
     });
     if (emit) sendIfAlive(window, `transcript:event:${sub.tabId}`, ev);
     // Mirror to OTEL — no-op when disabled. We emit on the initial drain too
@@ -164,10 +203,86 @@ async function flush(sub, { emit = true } = {}) {
   }
 }
 
+// Serialised flush scheduler — at most one readDelta per sub in flight at a
+// time. Uses a dirty flag for trailing-edge re-run: if a chokidar event fires
+// while a flush is in progress, dirty stays true and the loop runs one more
+// time after the current read completes, guaranteeing no event is dropped.
+function scheduleFlush(sub) {
+  sub.dirty = true;
+  if (sub.flushing) return sub.flushing;
+  sub.flushing = (async () => {
+    while (sub.dirty) {
+      sub.dirty = false;
+      await doFlush(sub);
+    }
+  })()
+    .catch((e) => {
+      logs.writeLine({ level: 'warn', scope: 'transcripts', message: 'flush error', meta: { error: e?.message } });
+    })
+    .finally(() => {
+      sub.flushing = null;
+    });
+  return sub.flushing;
+}
+
 const MAX_TRANSCRIPT_SUBS = 20;
 
+/**
+ * LRU pool of released-but-cached subscriptions. When a renderer consumer
+ * calls release(), the sub stays alive (offset + buffer preserved) so a
+ * subsequent tab-switch back resumes from the current offset instead of
+ * re-reading the entire transcript from byte 0. Oldest entries are evicted
+ * once the pool exceeds LRU_CAP.
+ */
+const LRU_CAP = 6;
+const lruReleased = []; // tabIds with no active consumer, ordered oldest→newest
+
+function _closeSub(tabId) {
+  const sub = subs.get(tabId);
+  if (!sub) return;
+  sub.watcher?.close().catch(() => {});
+  subs.delete(tabId);
+  usageMatrix.removeTab(tabId);
+  const i = lruReleased.indexOf(tabId);
+  if (i !== -1) lruReleased.splice(i, 1);
+}
+
+/**
+ * release(tabId) — called when the renderer's last consumer unmounts (view
+ * switch). Keeps the sub alive in the LRU cache so a quick revisit resumes
+ * from the persisted offset. Evicts the oldest cached sub if over LRU_CAP.
+ */
+function release(tabId) {
+  if (!subs.has(tabId)) return;
+  if (!lruReleased.includes(tabId)) {
+    lruReleased.push(tabId);
+  }
+  while (lruReleased.length > LRU_CAP) {
+    const oldest = lruReleased.shift();
+    _closeSub(oldest);
+  }
+}
+
+/** closeTab(tabId) — genuine tab close; always destroys the sub immediately. */
+function closeTab(tabId) {
+  _closeSub(tabId);
+}
+
 async function subscribe({ tabId, cwd, sessionUuid }) {
-  if (subs.has(tabId)) return { ok: true, path: subs.get(tabId).filePath };
+  if (subs.has(tabId)) {
+    // Tab is in the LRU cache — promote it back to active.
+    const i = lruReleased.indexOf(tabId);
+    if (i !== -1) lruReleased.splice(i, 1);
+    return { ok: true, path: subs.get(tabId).filePath };
+  }
+  if (subs.size >= MAX_TRANSCRIPT_SUBS) {
+    // Before rejecting a genuinely new subscription, evict an idle LRU-cached
+    // entry — it occupies a slot but has no active consumer. Only reject if no
+    // idle entries are available to free.
+    if (lruReleased.length > 0) {
+      _closeSub(lruReleased[0]);
+    }
+  }
   if (subs.size >= MAX_TRANSCRIPT_SUBS) {
     logs.writeLine({
       level: 'warn',
@@ -189,34 +304,33 @@ async function subscribe({ tabId, cwd, sessionUuid }) {
     pending: '',
     buffer: [],
     watcher: null,
+    flushing: null,
+    dirty: false,
   };
   // If the file already exists, read current content as replay. Do not emit
   // during this initial drain — the renderer drains sub.buffer via
   // `transcript:buffer` after `transcript:subscribe` resolves. Emitting here
   // would race the renderer's onEvent listener registration and drop events.
+  // replay:true prevents historical usage events from entering the 5-min window.
   if (fs.existsSync(filePath)) {
-    await flush(sub, { emit: false });
+    await doFlush(sub, { emit: false, replay: true });
   }
   const watcher = chokidar.watch(filePath, {
     ignoreInitial: false,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 30, pollInterval: 20 },
   });
-  watcher.on('add', () => flush(sub).catch(() => {}));
-  watcher.on('change', () => flush(sub).catch(() => {}));
+  watcher.on('add', () => scheduleFlush(sub));
+  watcher.on('change', () => scheduleFlush(sub));
   watcher.on('error', (err) => logs.writeLine({ level: 'warn', scope: 'transcripts', message: 'chokidar watcher error', meta: { error: err?.message } }));
   sub.watcher = watcher;
   subs.set(tabId, sub);
   return { ok: true, path: filePath };
 }
 
+/** @deprecated Use release() for view-switch, closeTab() for genuine close. */
 function unsubscribe(tabId) {
-  const sub = subs.get(tabId);
-  if (!sub) return;
-  sub.watcher?.close().catch(() => {});
-  subs.delete(tabId);
-  // Drop the tab from the AgOps matrix — "active sessions" only.
-  usageMatrix.removeTab(tabId);
+  release(tabId);
 }
 
 function getBuffer(tabId) {
@@ -233,8 +347,14 @@ function closeAll() {
 function registerTranscriptHandlers() {
   const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
   ipcMain.handle('transcript:subscribe', v(s.transcriptSubscribe, (payload) => subscribe(payload)));
+  // transcript:unsubscribe is now an alias for release (view-switch, not close).
   ipcMain.handle('transcript:unsubscribe', v(s.transcriptTabId, ({ tabId }) => {
-    unsubscribe(tabId);
+    release(tabId);
+    return { ok: true };
+  }));
+  // transcript:close is the genuine close used when a tab is removed.
+  ipcMain.handle('transcript:close', v(s.transcriptTabId, ({ tabId }) => {
+    closeTab(tabId);
     return { ok: true };
   }));
   ipcMain.handle('transcript:buffer', v(s.transcriptTabId, ({ tabId }) => getBuffer(tabId)));
@@ -245,6 +365,8 @@ module.exports = {
   attachWindow,
   registerTranscriptHandlers,
   closeAll,
+  release,
+  closeTab,
   encodeCwd,
   transcriptPath,
   classifyLine,

package/src/main/usageMatrix.cjs

@@ -85,7 +85,7 @@ function ensureTab(tabId, cwd, sessionUuid) {
  * Feed one classified transcript event into the per-tab aggregator. Called
  * from transcripts.cjs for every event, both during replay and live.
  */
-function recordEvent({ tabId, cwd, sessionUuid, ev }) {
+function recordEvent({ tabId, cwd, sessionUuid, ev, replay = false }) {
   if (!tabId || !ev) return;
   const t = ensureTab(tabId, cwd, sessionUuid);
   const now = Date.now();
@@ -109,8 +109,12 @@ function recordEvent({ tabId, cwd, sessionUuid, ev }) {
       t.perTurnInputTokens.push(inTok);
       if (t.perTurnInputTokens.length > TURN_RING) t.perTurnInputTokens.shift();
 
-      t.tokenWindow.push({ ts: now, tokens: inTok + outTok });
-      pruneWindow(t.tokenWindow, now);
+      // Historical events must not enter the 5-min sliding window — doing so
+      // would make tokensPerMin spike to "critical" on every tab switch.
+      if (!replay) {
+        t.tokenWindow.push({ ts: now, tokens: inTok + outTok });
+        pruneWindow(t.tokenWindow, now);
+      }
       dirty = true;
       break;
     }