cursor-guard 4.9.9 → 4.9.12

package/references/vscode-extension/dist/dashboard/server.js

@@ -14,6 +14,7 @@ function coreDeps() {
     runDiagnostics: require('../lib/core/doctor').runDiagnostics,
     listBackups: require('../lib/core/backups').listBackups,
     getBackupFiles: require('../lib/core/backups').getBackupFiles,
+    clearAlert: require('../lib/core/anomaly').clearAlert,
   };
 }
 
@@ -196,7 +197,21 @@ function handleApi(pathname, query, registry, res, req) {
     return json(res, { error: `Project directory not accessible: ${project.pathLabel}` }, 500);
   }
 
-  const { getDashboard, runDiagnostics, listBackups, getBackupFiles } = coreDeps();
+  const { getDashboard, runDiagnostics, listBackups, getBackupFiles, clearAlert } = coreDeps();
+
+  if (pathname === '/api/dismiss-alert') {
+    if (req.method !== 'POST') {
+      res.writeHead(405);
+      return res.end('Method Not Allowed');
+    }
+    try {
+      clearAlert(pp);
+      if (_instance?.hub && id) broadcastGuardChanged(_instance.hub, id);
+      return json(res, { ok: true });
+    } catch (e) {
+      return json(res, { ok: false, error: e.message }, 500);
+    }
+  }
 
   if (pathname === '/api/page-data') {
     const scope = query.get('scope');
@@ -245,6 +260,164 @@ function handleApi(pathname, query, registry, res, req) {
   return notFound(res);
 }
 
+/* ── Live push (SSE) + fs.watch on Guard refs / backups ─────── */
+
+function broadcastGuardChanged(hub, projectId) {
+  if (!hub?.sseClients?.size) return;
+  const line = `data: ${JSON.stringify({ type: 'guard-changed', projectId })}\n\n`;
+  for (const c of hub.sseClients) {
+    try {
+      if (c.projectId && c.projectId !== projectId) continue;
+      c.res.write(line);
+    } catch {
+      hub.sseClients.delete(c);
+    }
+  }
+}
+
+function teardownGuardWatchersOnly(hub) {
+  if (hub._reattachTimer) {
+    clearTimeout(hub._reattachTimer);
+    hub._reattachTimer = null;
+  }
+  if (hub.guardDebounce) {
+    for (const t of hub.guardDebounce.values()) clearTimeout(t);
+    hub.guardDebounce.clear();
+  }
+  for (const w of hub.guardWatchers) {
+    try { w.close(); } catch { /* ignore */ }
+  }
+  hub.guardWatchers = [];
+}
+
+function tryWatchDirRecursive(dir, cb) {
+  try {
+    return fs.watch(dir, { recursive: true }, cb);
+  } catch {
+    try {
+      return fs.watch(dir, cb);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * When Git refs under refs/guard/, shadow backup dir, or alert/lock change, notify SSE clients.
+ */
+function attachGuardWatchers(hub) {
+  const { isGitRepo, gitDir: getGitDir } = require('../lib/utils');
+  teardownGuardWatchersOnly(hub);
+  if (!hub.guardDebounce) hub.guardDebounce = new Map();
+
+  function schedule(projectId) {
+    const prev = hub.guardDebounce.get(projectId);
+    if (prev) clearTimeout(prev);
+    hub.guardDebounce.set(projectId, setTimeout(() => {
+      hub.guardDebounce.delete(projectId);
+      broadcastGuardChanged(hub, projectId);
+    }, 400));
+  }
+
+  for (const proj of hub.registry.values()) {
+    const pp = proj._path;
+    const pid = proj.id;
+
+    if (isGitRepo(pp)) {
+      const gDir = getGitDir(pp);
+      if (gDir && fs.existsSync(gDir)) {
+        try {
+          const w = fs.watch(gDir, (ev, fname) => {
+            if (fname === 'cursor-guard-alert.json' || fname === 'cursor-guard.lock') schedule(pid);
+          });
+          hub.guardWatchers.push(w);
+        } catch { /* ignore */ }
+
+        const refsDir = path.join(gDir, 'refs');
+        if (fs.existsSync(refsDir)) {
+          try {
+            const w = fs.watch(refsDir, (ev, fname) => {
+              if (!fname) return;
+              if (fname === 'guard' || fname.startsWith('guard')) {
+                schedule(pid);
+                if (!hub._reattachTimer) {
+                  hub._reattachTimer = setTimeout(() => {
+                    hub._reattachTimer = null;
+                    attachGuardWatchers(hub);
+                  }, 600);
+                }
+              }
+            });
+            hub.guardWatchers.push(w);
+          } catch { /* ignore */ }
+        }
+
+        const guardDir = path.join(gDir, 'refs', 'guard');
+        if (fs.existsSync(guardDir)) {
+          const w = tryWatchDirRecursive(guardDir, () => schedule(pid));
+          if (w) hub.guardWatchers.push(w);
+          const preRestoreDir = path.join(guardDir, 'pre-restore');
+          if (fs.existsSync(preRestoreDir)) {
+            const w2 = tryWatchDirRecursive(preRestoreDir, () => schedule(pid));
+            if (w2) hub.guardWatchers.push(w2);
+          }
+        }
+      }
+    }
+
+    const backupDir = path.join(pp, '.cursor-guard-backup');
+    if (fs.existsSync(backupDir)) {
+      const w = tryWatchDirRecursive(backupDir, () => schedule(pid));
+      if (w) hub.guardWatchers.push(w);
+    }
+  }
+}
+
+function teardownLivePush(hub) {
+  teardownGuardWatchersOnly(hub);
+  for (const c of hub.sseClients) {
+    try { c.res.end(); } catch { /* ignore */ }
+  }
+  hub.sseClients.clear();
+  if (hub.ssePingTimer) {
+    clearInterval(hub.ssePingTimer);
+    hub.ssePingTimer = null;
+  }
+}
+
+function openSseStream(query, hub, res, req) {
+  const subscribeId = query.get('id') || null;
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-store, no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no',
+    'Access-Control-Allow-Origin': '*',
+  });
+  res.write(': connected\n\n');
+  const client = { res, projectId: subscribeId };
+  hub.sseClients.add(client);
+  req.on('close', () => {
+    hub.sseClients.delete(client);
+    if (hub.sseClients.size === 0 && hub.ssePingTimer) {
+      clearInterval(hub.ssePingTimer);
+      hub.ssePingTimer = null;
+    }
+  });
+  if (!hub.ssePingTimer) {
+    hub.ssePingTimer = setInterval(() => {
+      if (hub.sseClients.size === 0) return;
+      for (const c of hub.sseClients) {
+        try {
+          c.res.write(': ping\n\n');
+        } catch {
+          hub.sseClients.delete(c);
+        }
+      }
+    }, 25000);
+  }
+}
+
 /* ── Server (singleton) ─────────────────────────────────────── */
 
 let _instance = null;
@@ -280,8 +453,11 @@ function _mergeProjects(registry, paths) {
 function startDashboardServer(paths, opts = {}) {
   if (_instance) {
     const added = _mergeProjects(_instance.registry, paths);
-    if (added > 0 && !opts.silent) {
-      console.log(`  [dashboard] Hot-added ${added} project(s) — total: ${_instance.registry.size} on port ${_instance.port}`);
+    if (added > 0) {
+      attachGuardWatchers(_instance.hub);
+      if (!opts.silent) {
+        console.log(`  [dashboard] Hot-added ${added} project(s) — total: ${_instance.registry.size} on port ${_instance.port}`);
+      }
     }
     return Promise.resolve(_instance);
   }
@@ -290,6 +466,14 @@ function startDashboardServer(paths, opts = {}) {
   const silent = opts.silent || false;
   const registry = buildRegistry(paths);
   const token = crypto.randomBytes(16).toString('hex');
+  const hub = {
+    registry,
+    token,
+    sseClients: new Set(),
+    guardWatchers: [],
+    guardDebounce: new Map(),
+    ssePingTimer: null,
+  };
 
   return new Promise((resolve, reject) => {
     let currentPort = port;
@@ -326,6 +510,13 @@ function startDashboardServer(paths, opts = {}) {
           res.writeHead(403);
           return res.end('Forbidden: invalid token');
         }
+        if (parsed.pathname === '/api/events') {
+          if (req.method !== 'GET') {
+            res.writeHead(405);
+            return res.end('Method Not Allowed');
+          }
+          return openSseStream(parsed.searchParams, hub, res, req);
+        }
         handleApi(parsed.pathname, parsed.searchParams, registry, res, req);
       } else {
         if (req.method !== 'GET') { res.writeHead(405); return res.end('Method Not Allowed'); }
@@ -345,7 +536,8 @@ function startDashboardServer(paths, opts = {}) {
 
     server.on('listening', () => {
       const addr = server.address();
-      _instance = { server, port: addr.port, registry, token };
+      _instance = { server, port: addr.port, registry, token, hub };
+      attachGuardWatchers(hub);
       if (!silent) {
         console.log('');
         console.log('  Cursor Guard Dashboard');
@@ -371,6 +563,7 @@ async function restartDashboard() {
   const paths = [..._instance.registry.values()].map(p => p._path);
   const port = _instance.port;
 
+  if (_instance.hub) teardownLivePush(_instance.hub);
   _instance.server.close();
   _instance = null;
 

package/references/vscode-extension/dist/guard-version.json

@@ -1 +1 @@
-{"version":"4.9.9"}
+{"version":"4.9.12"}

package/references/vscode-extension/dist/lib/core/backups.js

@@ -51,6 +51,8 @@ const TRAILER_MAP = {
   'From':          { key: 'from' },
   'Restore-To':   { key: 'restoreTo' },
   'File':          { key: 'restoreFile' },
+  'Guard-Diff-Base': { key: 'guardDiffBase' },
+  'Guard-Scope':     { key: 'guardScope' },
 };
 
 function parseCommitTrailers(body) {
@@ -61,7 +63,9 @@ function parseCommitTrailers(body) {
     const m = line.match(pattern);
     if (m) {
       const def = TRAILER_MAP[m[1]];
-      result[def.key] = def.parse ? def.parse(m[2]) : m[2];
+      const raw = m[2].replace(/\r/g, '');
+      const val = def.parse ? def.parse(raw) : raw.trim();
+      result[def.key] = typeof val === 'string' ? val.trim() : val;
     }
   }
   return result;
@@ -158,26 +162,37 @@ function listBackups(projectDir, opts = {}) {
       }
     }
 
-    // Agent snapshot ref
-    const snapshotHash = git(['rev-parse', '--verify', 'refs/guard/snapshot'], { cwd: projectDir, allowFail: true });
-    if (snapshotHash) {
-      const snapLog = git(['log', '-1', '--format=%aI\x1f%B', 'refs/guard/snapshot'], { cwd: projectDir, allowFail: true });
-      const snapParts = snapLog ? snapLog.split('\x1f') : [];
-      const ts = snapParts[0] || null;
-      const snapBody = snapParts[1] || '';
-      const snapTrailers = parseCommitTrailers(snapBody);
-      const snapSubject = snapBody.split('\n')[0] || '';
-      const include = !beforeDate || (ts && Date.parse(ts) <= beforeDate.getTime());
-      if (include) {
-        sources.push({
-          type: 'git-snapshot',
-          ref: 'refs/guard/snapshot',
-          commitHash: snapshotHash,
-          shortHash: snapshotHash.substring(0, 7),
-          timestamp: ts,
-          message: snapSubject || undefined,
-          ...snapTrailers,
-        });
+    // Manual / IDE snapshot ref (full history on dedicated ref; no subject grep so test/custom messages still list)
+    const snapRef = 'refs/guard/snapshot';
+    const snapshotExists = git(['rev-parse', '--verify', snapRef], { cwd: projectDir, allowFail: true });
+    if (snapshotExists) {
+      const snapLogArgs = ['log', snapRef, '--format=%H\x1f%aI\x1f%B\x1e', `-${limit}`];
+      if (opts.before) snapLogArgs.push(`--before=${opts.before}`);
+      if (opts.file) snapLogArgs.push('--', opts.file);
+      const snapOut = git(snapLogArgs, { cwd: projectDir, allowFail: true });
+      if (snapOut) {
+        for (const record of snapOut.split('\x1e').filter(r => r.trim())) {
+          const parts = record.split('\x1f');
+          if (parts.length < 3) continue;
+          const hash = parts[0].trim();
+          const timestamp = parts[1];
+          const body = parts[2];
+          const subject = body.split('\n')[0];
+          const trailers = parseCommitTrailers(body);
+          if (beforeDate && timestamp) {
+            const ms = Date.parse(timestamp);
+            if (!isNaN(ms) && ms > beforeDate.getTime()) continue;
+          }
+          sources.push({
+            type: 'git-snapshot',
+            ref: snapRef,
+            commitHash: hash,
+            shortHash: hash.substring(0, 7),
+            timestamp,
+            message: subject || undefined,
+            ...trailers,
+          });
+        }
       }
     }
   }

package/references/vscode-extension/dist/lib/core/snapshot.js

@@ -14,6 +14,36 @@ function formatTimestamp(d) {
   return `${d.getFullYear()}${pad(d.getMonth()+1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 
+const REF_GUARD_AUTO_BACKUP = 'refs/guard/auto-backup';
+const REF_GUARD_SNAPSHOT = 'refs/guard/snapshot';
+
+/**
+ * Parent commit for the next Guard Git snapshot (first parent of `commit-tree`).
+ *
+ * For **refs/guard/auto-backup** and **refs/guard/snapshot** only: pick whichever tip is
+ * **newer in commit time** between the two refs. That matches the human reading: "changes
+ * since the **last** Guard backup, automatic or manual" — one shared baseline for +/- and file counts.
+ *
+ * For any **other** `branchRef` (e.g. tests using refs/guard/test-*): chain that ref only.
+ */
+function resolveGuardParentHash(cwd, branchRef) {
+  if (branchRef !== REF_GUARD_AUTO_BACKUP && branchRef !== REF_GUARD_SNAPSHOT) {
+    return git(['rev-parse', '--verify', branchRef], { cwd, allowFail: true });
+  }
+  const autoH = git(['rev-parse', '--verify', REF_GUARD_AUTO_BACKUP], { cwd, allowFail: true });
+  const snapH = git(['rev-parse', '--verify', REF_GUARD_SNAPSHOT], { cwd, allowFail: true });
+  if (!autoH && !snapH) return null;
+  if (!autoH) return snapH;
+  if (!snapH) return autoH;
+  const commitUnix = h => {
+    const s = git(['log', '-1', '--format=%ct', h], { cwd, allowFail: true });
+    return s ? parseInt(String(s).trim(), 10) : 0;
+  };
+  const tAuto = commitUnix(autoH);
+  const tSnap = commitUnix(snapH);
+  return tSnap > tAuto ? snapH : autoH;
+}
+
 function listIndexFiles(cwd, env) {
   try {
     const out = execFileSync('git', ['ls-files', '--cached'], {
@@ -94,6 +124,8 @@ function buildCommitMessage(ts, opts) {
  * @param {boolean} [opts.allowEmptyTree] - If true, still create a commit when the snapshot tree equals the previous ref (empty / bookmark commit). Auto-backup should omit this; explicit manual snapshots should set it.
  * @param {boolean} [opts.fullWorkspaceSnapshot] - If true, ignore `cfg.protect` when building the snapshot tree (still apply `ignore` / secrets). Use for IDE/MCP "snapshot everything" so edits outside protect patterns are not invisible to the snapshot.
  * @returns {{ status: 'created'|'skipped'|'error', commitHash?: string, shortHash?: string, fileCount?: number, reason?: string, error?: string, secretsExcluded?: string[] }}
+ * @remarks For refs/guard/auto-backup and refs/guard/snapshot, the first parent is always the
+ * newer of those two tips (by commit time), so incremental stats mean "since last Guard backup" in the human sense.
  */
 function createGitSnapshot(projectDir, cfg, opts = {}) {
   const branchRef = opts.branchRef || 'refs/guard/auto-backup';
@@ -111,7 +143,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
   try { fs.unlinkSync(guardIndexLock); } catch { /* doesn't exist */ }
 
   try {
-    const parentHash = git(['rev-parse', '--verify', branchRef], { cwd, allowFail: true });
+    const parentHash = resolveGuardParentHash(cwd, branchRef);
 
     if (narrowProtect) {
       // protect uses strict matching (full path only, no basename fallback)
@@ -120,7 +152,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
       pruneIndexFiles(cwd, env, f => !matchesAny(cfg.protect, f, { strict: true }));
     } else {
       if (parentHash) {
-        execFileSync('git', ['read-tree', branchRef], { cwd, env, stdio: 'pipe' });
+        execFileSync('git', ['read-tree', parentHash], { cwd, env, stdio: 'pipe' });
       }
       execFileSync('git', ['add', '-A'], { cwd, env, stdio: 'pipe' });
     }
@@ -133,7 +165,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
 
     const newTree = execFileSync('git', ['write-tree'], { cwd, env, stdio: 'pipe', encoding: 'utf-8' }).trim();
     const parentTree = parentHash
-      ? git(['rev-parse', `${branchRef}^{tree}`], { cwd, allowFail: true })
+      ? git(['rev-parse', `${parentHash}^{tree}`], { cwd, allowFail: true })
       : null;
 
     if (newTree === parentTree && !opts.allowEmptyTree) {
@@ -246,7 +278,22 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
     }
 
     const ts = formatTimestamp(new Date());
-    const msg = buildCommitMessage(ts, opts);
+    let msg = buildCommitMessage(ts, opts);
+
+    const autoTip = git(['rev-parse', '--verify', REF_GUARD_AUTO_BACKUP], { cwd, allowFail: true });
+    const snapTip = git(['rev-parse', '--verify', REF_GUARD_SNAPSHOT], { cwd, allowFail: true });
+    const autoTipTrim = autoTip ? String(autoTip).trim() : '';
+    const snapTipTrim = snapTip ? String(snapTip).trim() : '';
+    let diffBaseLabel = 'initial';
+    if (parentHash) {
+      if (parentHash === autoTipTrim) diffBaseLabel = 'auto-backup';
+      else if (parentHash === snapTipTrim) diffBaseLabel = 'snapshot';
+      else diffBaseLabel = 'other';
+    }
+    const scopeTrailer = narrowProtect ? 'narrow' : 'full';
+    const guardBlock = `Guard-Diff-Base: ${diffBaseLabel}\nGuard-Scope: ${scopeTrailer}`;
+    msg = msg.includes('\n\n') ? `${msg}\n${guardBlock}` : `${msg}\n\n${guardBlock}`;
+
     const commitArgs = parentHash
       ? ['commit-tree', newTree, '-p', parentHash, '-m', msg]
       : ['commit-tree', newTree, '-m', msg];

package/references/vscode-extension/dist/lib/poller.js

@@ -1,8 +1,23 @@
 'use strict';
 
-const vscode = require('vscode');
+const fs = require('fs');
+const path = require('path');
+const { guardPath } = require('./paths');
 
-const HEARTBEAT_INTERVAL = 30000;
+/** Safety net if fs.watch misses (platform limits); primary updates are filesystem events. */
+const FALLBACK_POLL_MS = 180000;
+
+function tryWatchDirRecursive(dir, cb) {
+  try {
+    return fs.watch(dir, { recursive: true }, cb);
+  } catch {
+    try {
+      return fs.watch(dir, cb);
+    } catch {
+      return null;
+    }
+  }
+}
 
 class Poller {
   constructor(dashMgr) {
@@ -11,6 +26,12 @@ class Poller {
     this._listeners = [];
     this._data = new Map();
     this._pollRunning = false;
+    this._pollAgainAfter = false;
+    this._pollWaiters = [];
+    this._fsWatchers = [];
+    this._watchedRegistryKey = '';
+    this._fsDebounceTimer = null;
+    this._reattachTimer = null;
   }
 
   get data() { return this._data; }
@@ -26,10 +47,107 @@ class Poller {
     }
   }
 
+  _teardownFsWatchers() {
+    if (this._reattachTimer) {
+      clearTimeout(this._reattachTimer);
+      this._reattachTimer = null;
+    }
+    if (this._fsDebounceTimer) {
+      clearTimeout(this._fsDebounceTimer);
+      this._fsDebounceTimer = null;
+    }
+    for (const w of this._fsWatchers) {
+      try { w.close(); } catch { /* ignore */ }
+    }
+    this._fsWatchers = [];
+  }
+
+  _scheduleFsRefresh() {
+    if (this._fsDebounceTimer) clearTimeout(this._fsDebounceTimer);
+    this._fsDebounceTimer = setTimeout(() => {
+      this._fsDebounceTimer = null;
+      void this.forceRefresh();
+    }, 400);
+  }
+
+  _syncFileWatchers() {
+    const reg = this._dashMgr?.registry;
+    if (!reg) return;
+    const key = [...reg.entries()].map(([k, v]) => `${k}:${v._path}`).sort().join('|');
+    if (key === this._watchedRegistryKey) return;
+    this._watchedRegistryKey = key;
+
+    this._teardownFsWatchers();
+
+    let utils;
+    try {
+      utils = require(guardPath('lib', 'utils'));
+    } catch {
+      return;
+    }
+    const { isGitRepo, gitDir: getGitDir } = utils;
+
+    for (const proj of reg.values()) {
+      const pp = proj._path;
+      const pid = proj.id;
+
+      if (isGitRepo(pp)) {
+        const gDir = getGitDir(pp);
+        if (gDir && fs.existsSync(gDir)) {
+          try {
+            const w = fs.watch(gDir, (ev, fname) => {
+              if (fname === 'cursor-guard-alert.json' || fname === 'cursor-guard.lock') {
+                this._scheduleFsRefresh();
+              }
+            });
+            this._fsWatchers.push(w);
+          } catch { /* ignore */ }
+
+          const refsDir = path.join(gDir, 'refs');
+          if (fs.existsSync(refsDir)) {
+            try {
+              const w = fs.watch(refsDir, (ev, fname) => {
+                if (!fname) return;
+                if (fname === 'guard' || fname.startsWith('guard')) {
+                  this._scheduleFsRefresh();
+                  if (!this._reattachTimer) {
+                    this._reattachTimer = setTimeout(() => {
+                      this._reattachTimer = null;
+                      this._watchedRegistryKey = '';
+                      this._syncFileWatchers();
+                    }, 600);
+                  }
+                }
+              });
+              this._fsWatchers.push(w);
+            } catch { /* ignore */ }
+          }
+
+          const guardDir = path.join(gDir, 'refs', 'guard');
+          if (fs.existsSync(guardDir)) {
+            const w = tryWatchDirRecursive(guardDir, () => this._scheduleFsRefresh());
+            if (w) this._fsWatchers.push(w);
+            const preRestoreDir = path.join(guardDir, 'pre-restore');
+            if (fs.existsSync(preRestoreDir)) {
+              const w2 = tryWatchDirRecursive(preRestoreDir, () => this._scheduleFsRefresh());
+              if (w2) this._fsWatchers.push(w2);
+            }
+          }
+        }
+      }
+
+      const backupDir = path.join(pp, '.cursor-guard-backup');
+      if (fs.existsSync(backupDir)) {
+        const w = tryWatchDirRecursive(backupDir, () => this._scheduleFsRefresh());
+        if (w) this._fsWatchers.push(w);
+      }
+    }
+  }
+
   start() {
     if (this._timer) return;
-    this._poll();
-    this._timer = setInterval(() => this._poll(), HEARTBEAT_INTERVAL);
+    void this._poll();
+    this._timer = setInterval(() => void this._poll(), FALLBACK_POLL_MS);
   }
 
   stop() {
@@ -37,33 +155,55 @@ class Poller {
   }
 
   async _poll() {
-    if (this._pollRunning) return;
+    if (this._pollRunning) {
+      this._pollAgainAfter = true;
+      return;
+    }
     this._pollRunning = true;
     try {
-      if (!this._dashMgr.running) return;
-      const projects = await this._dashMgr.getProjects();
-      if (!Array.isArray(projects)) return;
-      for (const p of projects) {
-        const fullData = await this._dashMgr.getFullPageData(p.id);
-        this._data.set(p.id, {
-          ...p,
-          dashboard: fullData?.dashboard || null,
-          backups: fullData?.backups || [],
-          scope: fullData?.scope || null,
-          doctor: fullData?.doctor || null,
-        });
-      }
-      this._emit();
+      do {
+        this._pollAgainAfter = false;
+        if (!this._dashMgr.running) break;
+        const projects = await this._dashMgr.getProjects();
+        if (!Array.isArray(projects)) break;
+        for (const p of projects) {
+          const fullData = await this._dashMgr.getFullPageData(p.id);
+          this._data.set(p.id, {
+            ...p,
+            dashboard: fullData?.dashboard || null,
+            backups: fullData?.backups || [],
+            scope: fullData?.scope || null,
+            doctor: fullData?.doctor || null,
+          });
+        }
+        this._emit();
+      } while (this._pollAgainAfter);
     } catch { /* non-critical */ }
-    finally { this._pollRunning = false; }
+    finally {
+      this._pollRunning = false;
+      const waiters = this._pollWaiters.splice(0);
+      for (const fn of waiters) {
+        try { fn(); } catch { /* ignore */ }
+      }
+      try {
+        this._syncFileWatchers();
+      } catch { /* ignore */ }
+    }
   }
 
   async forceRefresh() {
-    await this._poll();
+    return new Promise(resolve => {
+      this._pollWaiters.push(resolve);
+      this._pollAgainAfter = true;
+      if (!this._pollRunning) {
+        void this._poll();
+      }
+    });
   }
 
   dispose() {
     this.stop();
+    this._teardownFsWatchers();
     this._listeners = [];
   }
 }