cursor-guard 4.9.9 → 4.9.15

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 = [];
   }
 }

package/references/vscode-extension/dist/lib/sidebar-webview.js

@@ -2,6 +2,7 @@
 
 const vscode = require('vscode');
 const { getLocale, setLocale } = require('./locale');
+const { guardPath } = require('./paths');
 
 class SidebarDashboardProvider {
   constructor(poller, context) {
@@ -41,6 +42,19 @@ class SidebarDashboardProvider {
         this._postLocale();
       }
       if (msg.cmd === 'exec') vscode.commands.executeCommand(msg.command);
+      if (msg.cmd === 'clearAlert' && msg.projectId) {
+        (async () => {
+          try {
+            const reg = this._poller._dashMgr?.registry;
+            const entry = reg?.get(msg.projectId);
+            if (entry?._path) {
+              const { clearAlert } = require(guardPath('lib', 'core', 'anomaly'));
+              clearAlert(entry._path);
+              await this._poller.forceRefresh();
+            }
+          } catch { /* ignore */ }
+        })();
+      }
     });
 
     webviewView.onDidChangeVisibility(() => {
@@ -1058,6 +1072,7 @@ const I18N = {
     'actions.openDashboard': '打开看板',
     'actions.restore': '恢复',
     'actions.viewDetails': '查看详情',
+    'actions.dismissAlert': '忽略告警',
     'actions.snapshot': '立即快照',
     'actions.watcherOn': '停止 Watcher',
     'actions.watcherOff': '启动 Watcher',
@@ -1290,6 +1305,13 @@ function render(projects) {
       vscode.postMessage({ cmd: 'exec', command: btn.dataset.cmd });
     });
   });
+
+  root.querySelectorAll('[data-dismiss-alert]').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const pid = btn.getAttribute('data-dismiss-alert');
+      if (pid) vscode.postMessage({ cmd: 'clearAlert', projectId: pid });
+    });
+  });
 }
 
 function renderProject(dashboard, projectId) {

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.9",
+      version: "4.9.15",
       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",
@@ -35633,6 +35633,7 @@ var require_package = __commonJS({
         "README.md",
         "README.zh-CN.md",
         "docs/RELEASE.md",
+        "docs/SNAPSHOT-BOOKMARK.md",
         "ROADMAP.md",
         "LICENSE",
         "references/auto-backup.ps1",
@@ -36014,6 +36015,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"], {
@@ -36059,6 +36079,10 @@ var require_snapshot = __commonJS({
       }
       return excluded;
     }
+    function trailerScalar2(val, maxLen = 500) {
+      if (val == null) return "";
+      return String(val).replace(/\r\n/g, " ").replace(/\r/g, " ").replace(/\n/g, " ").trim().slice(0, maxLen);
+    }
     function buildCommitMessage(ts, opts) {
       if (opts.message && !opts.context) return opts.message;
       const ctx = opts.context || {};
@@ -36066,11 +36090,12 @@ var require_snapshot = __commonJS({
       const subject = opts.message || `guard: auto-backup ${ts}${countTag}`;
       const trailers = [];
       if (ctx.changedFileCount != null) trailers.push(`Files-Changed: ${ctx.changedFileCount}`);
-      if (ctx.summary) trailers.push(`Summary: ${ctx.summary}`);
-      if (ctx.trigger) trailers.push(`Trigger: ${ctx.trigger}`);
-      if (ctx.intent) trailers.push(`Intent: ${ctx.intent}`);
-      if (ctx.agent) trailers.push(`Agent: ${ctx.agent}`);
-      if (ctx.session) trailers.push(`Session: ${ctx.session}`);
+      if (ctx.summary) trailers.push(`Summary: ${trailerScalar2(ctx.summary, 2e3)}`);
+      if (ctx.trigger) trailers.push(`Trigger: ${trailerScalar2(ctx.trigger)}`);
+      if (ctx.intent) trailers.push(`Intent: ${trailerScalar2(ctx.intent)}`);
+      if (ctx.agent) trailers.push(`Agent: ${trailerScalar2(ctx.agent)}`);
+      if (ctx.session) trailers.push(`Session: ${trailerScalar2(ctx.session)}`);
+      if (ctx.guardEvent) trailers.push(`Guard-Event: ${trailerScalar2(ctx.guardEvent)}`);
       if (trailers.length === 0) return subject;
       return subject + "\n\n" + trailers.join("\n");
     }
@@ -36092,23 +36117,24 @@ var require_snapshot = __commonJS({
       } catch {
       }
       try {
-        const parentHash = git(["rev-parse", "--verify", branchRef], { cwd, allowFail: true });
+        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;
+        const parentTree = parentHash ? git(["rev-parse", `${parentHash}^{tree}`], { cwd, allowFail: true }) : null;
         if (newTree === parentTree && !opts.allowEmptyTree) {
           return { status: "skipped", reason: "tree unchanged" };
         }
+        const isBookmarkCommit = !!(opts.allowEmptyTree && parentTree && newTree === parentTree);
         let changedCount;
         let incrementalSummary;
         let changedFiles;
@@ -36197,8 +36223,32 @@ var require_snapshot = __commonJS({
         if (changedCount != null && opts.context) {
           opts.context.changedFileCount = changedCount;
         }
+        if (isBookmarkCommit && opts.context) {
+          const s = opts.context.summary;
+          if (s == null || String(s).trim() === "") {
+            opts.context.summary = "No file changes since last Guard baseline (bookmark).";
+          }
+          if (opts.context.changedFileCount == null) opts.context.changedFileCount = 0;
+        }
         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}${isBookmarkCommit ? "\nGuard-Bookmark: true" : ""}`;
+        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) {
@@ -36215,7 +36265,8 @@ var require_snapshot = __commonJS({
           changedCount,
           changedFiles,
           incrementalSummary,
-          secretsExcluded: secretsExcluded.length > 0 ? secretsExcluded : void 0
+          secretsExcluded: secretsExcluded.length > 0 ? secretsExcluded : void 0,
+          ...isBookmarkCommit ? { bookmark: true } : {}
         };
       } catch (e) {
         return { status: "error", error: e.message };
@@ -36299,7 +36350,7 @@ var require_snapshot = __commonJS({
         return { status: "error", error: e.message };
       }
     }
-    module2.exports = { createGitSnapshot: createGitSnapshot2, createShadowCopy: createShadowCopy2, formatTimestamp, removeSecretsFromIndex };
+    module2.exports = { createGitSnapshot: createGitSnapshot2, createShadowCopy: createShadowCopy2, formatTimestamp, removeSecretsFromIndex, trailerScalar: trailerScalar2 };
   }
 });
 
@@ -36351,9 +36402,13 @@ var require_backups = __commonJS({
       "Intent": { key: "intent" },
       "Agent": { key: "agent" },
       "Session": { key: "session" },
+      "Guard-Event": { key: "guardEvent" },
       "From": { key: "from" },
       "Restore-To": { key: "restoreTo" },
-      "File": { key: "restoreFile" }
+      "File": { key: "restoreFile" },
+      "Guard-Diff-Base": { key: "guardDiffBase" },
+      "Guard-Scope": { key: "guardScope" },
+      "Guard-Bookmark": { key: "guardBookmark", parse: (v) => String(v).trim().toLowerCase() === "true" }
     };
     function parseCommitTrailers(body) {
       if (!body) return {};
@@ -36363,7 +36418,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;
@@ -36438,25 +36495,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
+              });
+            }
           }
         }
       }
@@ -38050,7 +38118,7 @@ var { McpServer } = require_mcp();
 var { StdioServerTransport } = require_stdio2();
 var { z } = require_zod();
 var { runDiagnostics } = require_doctor();
-var { createGitSnapshot, createShadowCopy } = require_snapshot();
+var { createGitSnapshot, createShadowCopy, trailerScalar } = require_snapshot();
 var { listBackups } = require_backups();
 var { restoreFile, previewProjectRestore, executeProjectRestore } = require_restore();
 var { runFixes } = require_doctor_fix();
@@ -38172,7 +38240,7 @@ server.tool(
 );
 server.tool(
   "snapshot_now",
-  "Create an immediate backup snapshot of the current project state. Use before risky operations to preserve a restore point.",
+  "Create an immediate backup snapshot of the current project state. Use before risky operations to preserve a restore point. If the snapshot tree matches the previous Guard baseline (no file changes), a bookmark commit is still created on refs/guard/snapshot so intent/time stay visible \u2014 not silently skipped.",
   {
     path: z.string().describe("Absolute path to the project directory"),
     strategy: z.enum(["git", "shadow", "both"]).optional().describe('Backup strategy (default: from config, or "git")'),
@@ -38217,6 +38285,55 @@ server.tool(
     };
   }
 );
+server.tool(
+  "record_guard_event",
+  "Create a Git bookmark on refs/guard/snapshot focused on MCP/agent audit: stores Guard-Event (what happened), optional detail/summary, intent, agent, session. When the tree matches the previous baseline, still creates a commit (same as snapshot_now) so the timeline shows the event with no silent skip. Use after other MCP calls when you need a visible record without relying on file diffs alone.",
+  {
+    path: z.string().describe("Absolute path to the project directory"),
+    event: z.string().describe("Short event label, e.g. restore_project:execute, doctor_fix, list_backups:query"),
+    detail: z.string().optional().describe("Longer text stored in Summary trailer (optional)"),
+    intent: z.string().optional().describe("Human-readable intent; defaults to event if omitted"),
+    agent: z.string().optional().describe("AI model identifier"),
+    session: z.string().optional().describe("Conversation or session ID")
+  },
+  async ({ path: projectPath, event, detail, intent, agent, session }) => {
+    const resolved = path.resolve(projectPath);
+    ensureWatcher(resolved);
+    const { cfg } = loadConfig(resolved);
+    const ev = trailerScalar(event);
+    if (!ev) {
+      const err = { git: { status: "error", error: "event must be a non-empty string" } };
+      injectPreWarning(resolved, injectAlert(resolved, err));
+      injectWatcherWarning(resolved, err);
+      return { content: [{ type: "text", text: JSON.stringify(err, null, 2) }] };
+    }
+    const context = {
+      trigger: "mcp-event",
+      guardEvent: ev,
+      summary: detail ? trailerScalar(detail, 2e3) : `MCP event: ${ev}`
+    };
+    if (intent) context.intent = trailerScalar(intent);
+    if (agent) context.agent = trailerScalar(agent);
+    if (session) context.session = trailerScalar(session);
+    const results = {
+      git: createGitSnapshot(resolved, cfg, {
+        branchRef: "refs/guard/snapshot",
+        message: `guard: MCP event ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        context,
+        allowEmptyTree: true,
+        fullWorkspaceSnapshot: true
+      })
+    };
+    injectPreWarning(resolved, injectAlert(resolved, results));
+    injectWatcherWarning(resolved, results);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(results, null, 2)
+      }]
+    };
+  }
+);
 server.tool(
   "restore_file",
   "Restore a single file from a backup source (git commit/ref or shadow copy timestamp). By default, preserves the current version in a pre-restore snapshot before restoring.",

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.9",
+  "version": "4.9.15",
   "publisher": "zhangqiang8vipp",
   "license": "BUSL-1.1",
   "engines": {
@@ -67,6 +67,12 @@
         "category": "Cursor Guard",
         "icon": "$(search)"
       },
+      {
+        "command": "cursorGuard.setupSkill",
+        "title": "Install Agent Skill",
+        "category": "Cursor Guard",
+        "icon": "$(book)"
+      },
       {
         "command": "cursorGuard.addToProtect",
         "title": "Add to Protected",