cursor-guard 4.9.8 → 4.9.12

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

@@ -35594,7 +35594,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "cursor-guard",
-      version: "4.9.8",
+      version: "4.9.12",
       description: "Protects code from accidental AI overwrite or deletion in Cursor IDE \u2014 mandatory pre-write snapshots, review-before-apply, local Git safety net, and deterministic recovery. | \u4FDD\u62A4\u4EE3\u7801\u514D\u53D7 Cursor AI \u4EE3\u7406\u610F\u5916\u8986\u5199\u6216\u5220\u9664\u2014\u2014\u5F3A\u5236\u5199\u524D\u5FEB\u7167\u3001\u9884\u89C8\u518D\u6267\u884C\u3001\u672C\u5730 Git \u5B89\u5168\u7F51\u3001\u786E\u5B9A\u6027\u6062\u590D\u3002",
       keywords: [
         "cursor",
@@ -35632,6 +35632,7 @@ var require_package = __commonJS({
         "SKILL.md",
         "README.md",
         "README.zh-CN.md",
+        "docs/RELEASE.md",
         "ROADMAP.md",
         "LICENSE",
         "references/auto-backup.ps1",
@@ -36013,6 +36014,25 @@ var require_snapshot = __commonJS({
       const pad = (n) => String(n).padStart(2, "0");
       return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
     }
+    var REF_GUARD_AUTO_BACKUP = "refs/guard/auto-backup";
+    var REF_GUARD_SNAPSHOT = "refs/guard/snapshot";
+    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"], {
@@ -36078,6 +36098,7 @@ var require_snapshot = __commonJS({
       const cwd = projectDir;
       const gDir = getGitDir2(projectDir);
       if (!gDir) return { status: "error", error: "not a git repository" };
+      const narrowProtect = cfg.protect.length > 0 && !opts.fullWorkspaceSnapshot;
       const guardIndex = path2.join(gDir, "cursor-guard-index");
       const guardIndexLock = guardIndex + ".lock";
       const env = { ...process.env, GIT_INDEX_FILE: guardIndex };
@@ -36090,21 +36111,21 @@ var require_snapshot = __commonJS({
       } catch {
       }
       try {
-        const parentHash = git(["rev-parse", "--verify", branchRef], { cwd, allowFail: true });
-        if (cfg.protect.length > 0) {
+        const parentHash = resolveGuardParentHash(cwd, branchRef);
+        if (narrowProtect) {
           execFileSync("git", ["add", "-A"], { cwd, env, stdio: "pipe" });
           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" });
         }
         pruneIndexFiles(cwd, env, (f) => matchesAny(cfg.ignore, f));
         const secretsExcluded = removeSecretsFromIndex(cfg.secrets_patterns, cwd, env);
         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 }) : null;
-        if (newTree === parentTree) {
+        const parentTree = parentHash ? git(["rev-parse", `${parentHash}^{tree}`], { cwd, allowFail: true }) : null;
+        if (newTree === parentTree && !opts.allowEmptyTree) {
           return { status: "skipped", reason: "tree unchanged" };
         }
         let changedCount;
@@ -36129,7 +36150,7 @@ var require_snapshot = __commonJS({
               const key = code.startsWith("R") ? "R" : code === "D" ? "D" : code === "A" ? "A" : "M";
               const fileName = filePart.split("	").pop();
               if (matchesAny(cfg.ignore, fileName) || matchesAny(cfg.ignore, path2.basename(fileName))) continue;
-              if (cfg.protect.length > 0 && !matchesAny(cfg.protect, fileName, { strict: true })) continue;
+              if (narrowProtect && !matchesAny(cfg.protect, fileName, { strict: true })) continue;
               groups[key].push(fileName);
             }
             changedCount = Object.values(groups).reduce((sum, arr) => sum + arr.length, 0);
@@ -36168,7 +36189,7 @@ var require_snapshot = __commonJS({
                 return s ? `${f} (+${s.added} -${s.deleted})` : f;
               }).join(", ");
             };
-            const files = lsInitial.split("\n").filter(Boolean).filter((f) => !matchesAny(cfg.ignore, f) && !matchesAny(cfg.ignore, path2.basename(f))).filter((f) => cfg.protect.length === 0 || matchesAny(cfg.protect, f, { strict: true }));
+            const files = lsInitial.split("\n").filter(Boolean).filter((f) => !matchesAny(cfg.ignore, f) && !matchesAny(cfg.ignore, path2.basename(f))).filter((f) => !narrowProtect || matchesAny(cfg.protect, f, { strict: true }));
             changedCount = files.length;
             const sample = files.slice(0, 5).join(", ");
             const numstatInit = git(["diff-tree", "--no-commit-id", "--numstat", "-r", EMPTY_TREE, newTree], { cwd, allowFail: true });
@@ -36196,7 +36217,24 @@ var require_snapshot = __commonJS({
           opts.context.changedFileCount = changedCount;
         }
         const ts = formatTimestamp(/* @__PURE__ */ 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}
+Guard-Scope: ${scopeTrailer}`;
+        msg = msg.includes("\n\n") ? `${msg}
+${guardBlock}` : `${msg}
+
+${guardBlock}`;
         const commitArgs = parentHash ? ["commit-tree", newTree, "-p", parentHash, "-m", msg] : ["commit-tree", newTree, "-m", msg];
         const commitHash = execFileSync("git", commitArgs, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
         if (!commitHash) {
@@ -36351,7 +36389,9 @@ var require_backups = __commonJS({
       "Session": { key: "session" },
       "From": { key: "from" },
       "Restore-To": { key: "restoreTo" },
-      "File": { key: "restoreFile" }
+      "File": { key: "restoreFile" },
+      "Guard-Diff-Base": { key: "guardDiffBase" },
+      "Guard-Scope": { key: "guardScope" }
     };
     function parseCommitTrailers(body) {
       if (!body) return {};
@@ -36361,7 +36401,9 @@ var require_backups = __commonJS({
         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;
@@ -36436,25 +36478,36 @@ var require_backups = __commonJS({
             sources.push(entry);
           }
         }
-        const snapshotHash = git(["rev-parse", "--verify", "refs/guard/snapshot"], { cwd: projectDir, allowFail: true });
-        if (snapshotHash) {
-          const snapLog = git(["log", "-1", "--format=%aI%B", "refs/guard/snapshot"], { cwd: projectDir, allowFail: true });
-          const snapParts = snapLog ? snapLog.split("") : [];
-          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 || void 0,
-              ...snapTrailers
-            });
+        const snapRef = "refs/guard/snapshot";
+        const snapshotExists = git(["rev-parse", "--verify", snapRef], { cwd: projectDir, allowFail: true });
+        if (snapshotExists) {
+          const snapLogArgs = ["log", snapRef, "--format=%H%aI%B", `-${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("").filter((r) => r.trim())) {
+              const parts = record.split("");
+              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 || void 0,
+                ...trailers
+              });
+            }
           }
         }
       }
@@ -38198,7 +38251,8 @@ server.tool(
       results.git = createGitSnapshot(resolved, cfg, {
         branchRef: "refs/guard/snapshot",
         message: message || `guard: manual snapshot ${(/* @__PURE__ */ new Date()).toISOString()}`,
-        context
+        context,
+        allowEmptyTree: true
       });
     }
     if (effectiveStrategy === "shadow" || effectiveStrategy === "both") {

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

@@ -2,7 +2,7 @@
   "name": "cursor-guard-ide",
   "displayName": "Cursor Guard",
   "description": "AI code protection dashboard embedded in your IDE — real-time alerts, backup history, one-click snapshots",
-  "version": "4.9.8",
+  "version": "4.9.12",
   "publisher": "zhangqiang8vipp",
   "license": "BUSL-1.1",
   "engines": {

package/references/vscode-extension/dist/skill/ROADMAP.md

@@ -3,8 +3,8 @@
 > 本文档描述 cursor-guard 从 V2 到 V7 的长期演进方向。
 > 每一代向下兼容，低版本功能永远不废弃。
 >
-> **当前版本**：`V4.9.8`
-> **文档状态**：`V2` ~ `V4.9.8` 已完成交付（含 V5 intent/audit 基础），`V5` 主体规划中
+> **当前版本**：`V4.9.12`
+> **文档状态**：`V2` ~ `V4.9.12` 已完成交付（含 V5 intent/audit 基础），`V5` 主体规划中
 
 ## 阅读导航
 
@@ -734,6 +734,34 @@ V4 经过 4 轮系统性代码审查，修复了以下关键问题：
 }
 ```
 
+### V4.9.9：独立发版指南（人 + AI）✅
+| 能力 | 说明 |
+|------|------|
+| **docs/RELEASE.md** | 中英双语完整发版流程：版本源、VSIX、Git、GitHub Release、npm OTP；**Windows 下 `gh` 须用 UTF-8 文件 + `--notes-file`** 避免 Release 正文乱码；专设「给其他 AI 助手」摘要 |
+| **入口** | README / README.zh-CN 顶部与发版小节链接；`print-release-checklist.js` 末尾提示；`package.json` `files` 纳入该文档以便 npm  tarball 携带 |
+
+### V4.9.11：仪表盘推送同步 + 备份元数据/交互收口 ✅
+
+| 能力 | 说明 |
+|------|------|
+| **推送优先于轮询** | Dashboard HTTP：`GET /api/events`（SSE）+ `fs.watch` 监听 `refs/guard/*`、`.cursor-guard-backup/`、`.git` 下 `cursor-guard-alert.json` / `cursor-guard.lock`；`refs` 下首次出现 `guard` 时自动重挂 watcher。前端 `EventSource` 收 `guard-changed` 即刷新；仅保留 3min（前台）/ 10min（后台标签）兜底拉取 |
+| **扩展 Poller** | 以 `fs.watch` 同上路径触发 `forceRefresh`，HTTP 心跳改为约 **3min** 兜底（不再高频轮询） |
+| **活跃告警忽略** | `POST /api/dismiss-alert` + 仪表盘/侧边栏「忽略」；dismiss 后主动 SSE 广播 |
+| **备份列表可读性** | Git 提交 `Guard-Diff-Base` / `Guard-Scope` trailer；`listBackups` 解析 + 仪表盘「范围/基线」列；`refs/guard/snapshot` 完整历史；`Summary` trailer 去 `\r` + 列表行合计 `+/-` 行数 |
+| **5.x 后续（已记入下方 V5 规划）** | watcher 进程与仪表盘 **进程内/管道事件**、MCP `notifications`、统一事件总线——见「V5.x 深化：仪表盘与 watcher 联动」 |
+
+### V4.9.12：仪表盘 Intent 展示修复 ✅
+
+| 能力 | 说明 |
+|------|------|
+| **变更列 Intent** | 仅当备份类型为 **`git-pre-restore` / `shadow-pre-restore`** 时使用 `From` + `Restore-To` 琥珀色恢复条；自动备份与手动快照不再被误解析的 `from`/`restoreTo` 抢占，**Intent** 蓝条正常显示 |
+
+### V4.9.10：扩展版本线对齐 ✅
+
+| 说明 |
+|------|
+| IDE 扩展与根目录 `package.json` 版本对齐发版（VSIX 构建链 `build-vsix.js` 以根版本为准）。 |
+
 ### V4.9.8：发版流程文档化 + 侧边栏品牌占位 ✅
 | 能力 | 说明 |
 |------|------|
@@ -1137,6 +1165,19 @@ Phase 2 (V5.x):
   └── 完整审计链闭环，支持 restore_from_event
 ```
 
+### V5.x 深化：仪表盘与 watcher 联动（建议纳入 5.x 更新）
+
+> V4.9.11 已用 **文件系统监听 + SSE** 实现「备份/告警变更 → 仪表盘几乎实时更新」，无需依赖高频 HTTP 轮询。以下能力适合在 **V5.x** 与 embedded watcher / 审计事件链一并演进：
+
+| 方向 | 说明 |
+|------|------|
+| **跨进程显式通知** | 独立 `auto-backup` 子进程在 snapshot 成功后，通过 **本地 socket / 命名管道 / 向 dashboard 进程发 UDP** 等方式推送 `backup_completed`（含 project root、shortHash、timestamp），补全 `fs.watch` 在少数 OS/网络盘上的漏事件 |
+| **MCP / LSP 式通知** | 若 MCP 宿主支持 `notifications`，由 server 在备份/告警状态变化时向客户端推送，IDE 与 Web 共用同一语义字段 |
+| **统一事件模型** | 将 `guard-changed`、intent 事件、审计 JSONL 写入映射到同一 **event type + payload schema**，便于 dashboard 时间线与 `restore_from_event` 对齐 |
+| **可观测性** | 可选：推送失败降级策略、SSE 连接数上限、watch 句柄泄漏检测（长会话桌面环境） |
+
+**原则**：V4.9.x 保持「零新常驻依赖 + 本地回环」；V5.x 可在确认架构（embedded watcher）后引入更重的 IPC，且不破坏现有 SSE/Watch 降级路径。
+
 #### 与"意图队列"方案的本质区别
 
 | | 意图队列（已否决） | embedded watcher + begin_edit |
@@ -1620,7 +1661,11 @@ V4.3.5 ─────  ✅ Summary 增量 diff-tree 修复 + 变更列堆叠布
 V4.4.0 ─────  ✅ V4 收官：首次快照 summary + doctor 完整性/retention 检查 + init 升级检测
 V4.9.0 ─────  ✅ 事件驱动 watcher + 实时侧边栏计时
 V4.9.5 ─────  ✅ 修复 `.git` 写入导致的疯狂自触发备份
-V4.9.8 ─────  ✅ 发版清单（README 双语 + checklist 脚本）+ 侧边栏品牌图  ← 当前版本
+V4.9.12 ────  ✅ 仪表盘变更列：Intent 仅被真正的恢复前快照类型让位给 From→Restore-To；常规备份正确显示 Intent  ← 当前版本
+V4.9.11 ────  ✅ 仪表盘 SSE + fs.watch 推送；Poller 事件驱动；告警忽略；Guard trailer 列；Summary/列表行数；snapshot 历史列表
+V4.9.10 ────  ✅ 扩展版本线与根包对齐（VSIX 发版链）
+V4.9.9 ─────  ✅ docs/RELEASE.md 发版指南（人 + AI）+ gh UTF-8 说明
+V4.9.8 ─────  ✅ 发版清单（README 双语 + checklist 脚本）+ 侧边栏品牌图
 V4.9.7 ─────  ✅ 预警体验打磨 + 语言同步 + watcher 单例保护
                │
                │  前提：MVP 已跑通，需要把提示从“能用”打磨到“适合常开”
@@ -1709,5 +1754,5 @@ V7 的"可验证治理"是这条产品线的逻辑终点——该保护的都保
 
 ---
 
-*最后更新：2026-03-22*
-*版本：v1.8（V4.9.8，在 V4.9.7 基础上增加发版流程文档与侧边栏品牌资源；历史能力含事件驱动 watcher、自触发备份反馈环修复、`pre_warning` 事先预警 MVP）*
+*最后更新：2026-03-23*
+*版本：v1.11（V4.9.12：仪表盘 Intent 列修复；V4.9.11 起 SSE/fs.watch、Poller 事件驱动等；历史含 V4.9.9 发版指南、V4.9.0 事件驱动 watcher、`pre_warning` 等）*

package/references/vscode-extension/extension.js

@@ -414,9 +414,16 @@ async function activate(context) {
       const projectPath = folders[0].uri.fsPath;
       const result = await dashMgr.snapshotNow(projectPath);
       if (result?.status === 'created') {
-        vscode.window.showInformationMessage(`Cursor Guard: snapshot created (${result.changedCount || 0} changes)`);
+        const n = result.changedCount ?? 0;
+        const msg =
+          n > 0
+            ? `Cursor Guard: snapshot created (${n} file change(s))`
+            : 'Cursor Guard: snapshot created (restore point saved; no file changes since last snapshot)';
+        vscode.window.showInformationMessage(msg);
       } else if (result?.status === 'unchanged' || result?.status === 'skipped') {
-        vscode.window.showInformationMessage('Cursor Guard: no changes to snapshot');
+        vscode.window.showInformationMessage(
+          `Cursor Guard: no snapshot created (${result.reason || 'unchanged'})`
+        );
       } else if (result?.status === 'error') {
         vscode.window.showWarningMessage(`Cursor Guard: ${result.error}`);
       } else {

package/references/vscode-extension/lib/dashboard-manager.js

@@ -3,18 +3,18 @@
 const fs = require('fs');
 const path = require('path');
 const http = require('http');
-const { spawn } = require('child_process');
-const { guardPath } = require('./paths');
-
-const CONFIG_FILE = '.cursor-guard.json';
-const WATCHER_START_GRACE_MS = 8000;
-
-class DashboardManager {
-  constructor() {
-    this._instance = null;
-    this._serverModule = null;
-    this._startingWatchers = new Map();
-  }
+const { spawn } = require('child_process');
+const { guardPath } = require('./paths');
+
+const CONFIG_FILE = '.cursor-guard.json';
+const WATCHER_START_GRACE_MS = 8000;
+
+class DashboardManager {
+  constructor() {
+    this._instance = null;
+    this._serverModule = null;
+    this._startingWatchers = new Map();
+  }
 
   get running() { return !!this._instance; }
   get port() { return this._instance?.port; }
@@ -85,108 +85,115 @@ class DashboardManager {
     return this.fetchApi(`/api/backup-files?id=${projectId}&hash=${hash}`);
   }
 
-  async snapshotNow(projectPath) {
+  async snapshotNow(projectPath) {
     if (!projectPath) return;
     try {
       const { createGitSnapshot } = require(guardPath('lib', 'core', 'snapshot'));
       const { loadConfig } = require(guardPath('lib', 'utils'));
       const { cfg } = loadConfig(projectPath);
-      return createGitSnapshot(projectPath, cfg, { message: 'guard: manual snapshot via IDE extension' });
+      return createGitSnapshot(projectPath, cfg, {
+        branchRef: 'refs/guard/snapshot',
+        message: `guard: manual snapshot via IDE (${new Date().toISOString()})`,
+        context: { trigger: 'manual' },
+        allowEmptyTree: true,
+        // Match user expectation: "Snapshot now" captures the whole repo (except ignore/secrets), not only protect globs
+        fullWorkspaceSnapshot: true,
+      });
     } catch (e) {
       return { status: 'error', error: e.message };
     }
-  }
-
-  _getWatcherLockPath(projectPath) {
-    try {
-      const { gitAvailable, isGitRepo, gitDir: getGitDir } = require(guardPath('lib', 'utils'));
-      const repo = gitAvailable() && isGitRepo(projectPath);
-      if (repo) {
-        const gDir = getGitDir(projectPath);
-        if (gDir) return path.join(gDir, 'cursor-guard.lock');
-      }
-    } catch { /* ignore */ }
-    return path.join(projectPath, '.cursor-guard-backup', 'cursor-guard.lock');
-  }
-
-  _getPendingWatcherPid(projectPath) {
-    const pending = this._startingWatchers.get(projectPath);
-    if (!pending) return null;
-    try {
-      process.kill(pending.pid, 0);
-      return pending.pid;
-    } catch {
-      this._startingWatchers.delete(projectPath);
-      return null;
-    }
-  }
-
-  _clearPendingWatcher(projectPath, pid) {
-    const pending = this._startingWatchers.get(projectPath);
-    if (!pending) return;
-    if (pid == null || pending.pid === pid) {
-      this._startingWatchers.delete(projectPath);
-    }
-  }
-
-  startWatcher(projectPath) {
-    if (!projectPath) return null;
-    const existingPid = this.getWatcherPid(projectPath);
-    if (existingPid) return existingPid;
-    const cliScript = guardPath('bin', 'cursor-guard-backup.js');
+  }
+
+  _getWatcherLockPath(projectPath) {
+    try {
+      const { gitAvailable, isGitRepo, gitDir: getGitDir } = require(guardPath('lib', 'utils'));
+      const repo = gitAvailable() && isGitRepo(projectPath);
+      if (repo) {
+        const gDir = getGitDir(projectPath);
+        if (gDir) return path.join(gDir, 'cursor-guard.lock');
+      }
+    } catch { /* ignore */ }
+    return path.join(projectPath, '.cursor-guard-backup', 'cursor-guard.lock');
+  }
+
+  _getPendingWatcherPid(projectPath) {
+    const pending = this._startingWatchers.get(projectPath);
+    if (!pending) return null;
+    try {
+      process.kill(pending.pid, 0);
+      return pending.pid;
+    } catch {
+      this._startingWatchers.delete(projectPath);
+      return null;
+    }
+  }
+
+  _clearPendingWatcher(projectPath, pid) {
+    const pending = this._startingWatchers.get(projectPath);
+    if (!pending) return;
+    if (pid == null || pending.pid === pid) {
+      this._startingWatchers.delete(projectPath);
+    }
+  }
+
+  startWatcher(projectPath) {
+    if (!projectPath) return null;
+    const existingPid = this.getWatcherPid(projectPath);
+    if (existingPid) return existingPid;
+    const cliScript = guardPath('bin', 'cursor-guard-backup.js');
     const child = spawn(process.execPath, [cliScript, '--path', projectPath], {
       cwd: projectPath,
       stdio: 'ignore',
-      detached: true,
-      env: { ...process.env, GUARD_SPAWNED_BY_EXT: '1' },
-    });
-    this._startingWatchers.set(projectPath, { pid: child.pid, startedAt: Date.now() });
-    const clearPending = () => this._clearPendingWatcher(projectPath, child.pid);
-    child.once('exit', clearPending);
-    child.once('error', clearPending);
-    setTimeout(clearPending, WATCHER_START_GRACE_MS);
-    child.unref();
-    return child.pid;
-  }
-
-  stopWatcher(projectPath) {
-    if (!projectPath) return false;
-    const pendingPid = this._getPendingWatcherPid(projectPath);
-    if (pendingPid) {
-      try { process.kill(pendingPid, 'SIGTERM'); } catch { /* ignore */ }
-      this._clearPendingWatcher(projectPath, pendingPid);
-    }
-    try {
-      const lockPath = this._getWatcherLockPath(projectPath);
-      if (!fs.existsSync(lockPath)) return false;
-      const content = fs.readFileSync(lockPath, 'utf-8');
-      const pidMatch = content.match(/pid=(\d+)/);
-      if (pidMatch) {
-        process.kill(parseInt(pidMatch[1], 10), 'SIGTERM');
-      }
-      try { fs.unlinkSync(lockPath); } catch { /* ok */ }
-      return true;
-    } catch { /* ok */ }
-    return !!pendingPid;
-  }
-
-  getWatcherPid(projectPath) {
-    const pendingPid = this._getPendingWatcherPid(projectPath);
-    if (pendingPid) return pendingPid;
-    try {
-      const lockPath = this._getWatcherLockPath(projectPath);
-      if (!fs.existsSync(lockPath)) return null;
-      const content = fs.readFileSync(lockPath, 'utf-8');
-      const pidMatch = content.match(/pid=(\d+)/);
-      if (pidMatch) {
-        const pid = parseInt(pidMatch[1], 10);
-        process.kill(pid, 0);
-        this._clearPendingWatcher(projectPath, pid);
-        return pid;
-      }
-    } catch { /* not running */ }
-    return null;
-  }
+      detached: true,
+      env: { ...process.env, GUARD_SPAWNED_BY_EXT: '1' },
+    });
+    this._startingWatchers.set(projectPath, { pid: child.pid, startedAt: Date.now() });
+    const clearPending = () => this._clearPendingWatcher(projectPath, child.pid);
+    child.once('exit', clearPending);
+    child.once('error', clearPending);
+    setTimeout(clearPending, WATCHER_START_GRACE_MS);
+    child.unref();
+    return child.pid;
+  }
+
+  stopWatcher(projectPath) {
+    if (!projectPath) return false;
+    const pendingPid = this._getPendingWatcherPid(projectPath);
+    if (pendingPid) {
+      try { process.kill(pendingPid, 'SIGTERM'); } catch { /* ignore */ }
+      this._clearPendingWatcher(projectPath, pendingPid);
+    }
+    try {
+      const lockPath = this._getWatcherLockPath(projectPath);
+      if (!fs.existsSync(lockPath)) return false;
+      const content = fs.readFileSync(lockPath, 'utf-8');
+      const pidMatch = content.match(/pid=(\d+)/);
+      if (pidMatch) {
+        process.kill(parseInt(pidMatch[1], 10), 'SIGTERM');
+      }
+      try { fs.unlinkSync(lockPath); } catch { /* ok */ }
+      return true;
+    } catch { /* ok */ }
+    return !!pendingPid;
+  }
+
+  getWatcherPid(projectPath) {
+    const pendingPid = this._getPendingWatcherPid(projectPath);
+    if (pendingPid) return pendingPid;
+    try {
+      const lockPath = this._getWatcherLockPath(projectPath);
+      if (!fs.existsSync(lockPath)) return null;
+      const content = fs.readFileSync(lockPath, 'utf-8');
+      const pidMatch = content.match(/pid=(\d+)/);
+      if (pidMatch) {
+        const pid = parseInt(pidMatch[1], 10);
+        process.kill(pid, 0);
+        this._clearPendingWatcher(projectPath, pid);
+        return pid;
+      }
+    } catch { /* not running */ }
+    return null;
+  }
 
   dispose() {
     this._instance = null;