cursor-guard 3.4.0 → 4.1.0

package/references/lib/core/dashboard.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  loadConfig, gitAvailable, git, isGitRepo, gitDir: getGitDir,
+  diskFreeGB, walkDir, filterFiles,
+} = require('../utils');
+const { getBackupStatus } = require('./status');
+const { loadActiveAlert } = require('./anomaly');
+const { parseShadowTimestamp } = require('./backups');
+
+// ── Helpers ─────────────────────────────────────────────────────
+
+function dirSizeBytes(dirPath) {
+  let total = 0;
+  const stack = [dirPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(current, { withFileTypes: true }); }
+    catch { continue; }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile()) {
+        try { total += fs.statSync(full).size; } catch { /* skip */ }
+      }
+    }
+  }
+  return total;
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+
+function relativeTime(isoTimestamp) {
+  if (!isoTimestamp) return null;
+  const ms = Date.now() - new Date(isoTimestamp).getTime();
+  if (ms < 0) return 'just now';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  const d = Math.floor(hr / 24);
+  return `${d}d ago`;
+}
+
+// ── Dashboard ───────────────────────────────────────────────────
+
+/**
+ * Build a comprehensive backup health dashboard.
+ *
+ * @param {string} projectDir
+ * @returns {{
+ *   strategy: string,
+ *   lastBackup: { git?: { timestamp: string, relativeTime: string }, shadow?: { timestamp: string, relativeTime: string } },
+ *   counts: { git: { commits: number }, shadow: { snapshots: number } },
+ *   diskUsage: { git: { bytes: number, display: string }, shadow: { bytes: number, display: string } },
+ *   protectionScope: { protect: string[], ignore: string[], fileCount: number },
+ *   health: { status: string, issues: string[] },
+ *   alerts: { active: boolean, latest?: object },
+ *   watcher: object,
+ *   disk: object,
+ * }}
+ */
+function getDashboard(projectDir) {
+  const status = getBackupStatus(projectDir);
+  const { cfg } = loadConfig(projectDir);
+  const hasGit = gitAvailable();
+  const repo = hasGit && isGitRepo(projectDir);
+  const gDir = repo ? getGitDir(projectDir) : null;
+  const backupDir = path.join(projectDir, '.cursor-guard-backup');
+
+  // ── Strategy ────────────────────────────────────────────────
+  const strategy = cfg.backup_strategy;
+
+  // ── Last backup with relative time ──────────────────────────
+  const lastBackup = {};
+  if (status.lastBackup.git) {
+    lastBackup.git = {
+      timestamp: status.lastBackup.git.timestamp,
+      relativeTime: relativeTime(status.lastBackup.git.timestamp),
+      shortHash: status.lastBackup.git.shortHash,
+    };
+  }
+  if (status.lastBackup.shadow) {
+    const ts = status.lastBackup.shadow.timestamp;
+    const parsed = parseShadowTimestamp(ts);
+    const isoTs = parsed ? parsed.toISOString() : ts;
+    lastBackup.shadow = {
+      timestamp: ts,
+      relativeTime: relativeTime(isoTs),
+    };
+  }
+
+  // ── Counts ──────────────────────────────────────────────────
+  const counts = {
+    git: { commits: status.refs.autoBackup ? status.refs.autoBackup.commitCount : 0 },
+    shadow: { snapshots: 0 },
+  };
+
+  if (fs.existsSync(backupDir)) {
+    try {
+      counts.shadow.snapshots = fs.readdirSync(backupDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && /^\d{8}_\d{6}(_\d{3})?$/.test(d.name))
+        .length;
+    } catch { /* ignore */ }
+  }
+
+  // ── Disk usage breakdown ────────────────────────────────────
+  const diskUsage = {
+    git: { bytes: 0, display: '0B' },
+    shadow: { bytes: 0, display: '0B' },
+  };
+
+  if (repo && gDir) {
+    const objectsDir = path.join(gDir, 'objects');
+    if (fs.existsSync(objectsDir)) {
+      diskUsage.git.bytes = dirSizeBytes(objectsDir);
+      diskUsage.git.display = formatBytes(diskUsage.git.bytes);
+    }
+  }
+
+  if (fs.existsSync(backupDir)) {
+    diskUsage.shadow.bytes = dirSizeBytes(backupDir);
+    diskUsage.shadow.display = formatBytes(diskUsage.shadow.bytes);
+  }
+
+  // ── Protection scope ────────────────────────────────────────
+  const protectionScope = {
+    protect: cfg.protect.length > 0 ? cfg.protect : ['**'],
+    ignore: cfg.ignore,
+    fileCount: 0,
+  };
+
+  try {
+    const allFiles = walkDir(projectDir, projectDir);
+    protectionScope.fileCount = filterFiles(allFiles, cfg).length;
+  } catch { /* ignore */ }
+
+  // ── Health assessment ───────────────────────────────────────
+  const issues = [];
+
+  if (!status.watcher.running) {
+    if (status.watcher.stale) {
+      issues.push('Watcher has a stale lock file (process not running)');
+    } else {
+      issues.push('Auto-backup watcher is not running');
+    }
+  }
+
+  if (strategy === 'git' || strategy === 'both') {
+    if (!repo) issues.push('Strategy requires Git but directory is not a git repo');
+    else if (!status.refs.autoBackup) issues.push('No auto-backup ref found — watcher may not have run yet');
+  }
+
+  if (status.disk.warning === 'critically low') {
+    issues.push(`Disk space critically low (${status.disk.freeGB} GB free)`);
+  } else if (status.disk.warning === 'low') {
+    issues.push(`Disk space low (${status.disk.freeGB} GB free)`);
+  }
+
+  if (status.lastBackup.git) {
+    const lastTs = new Date(status.lastBackup.git.timestamp).getTime();
+    const staleMinutes = (Date.now() - lastTs) / 60000;
+    const staleThreshold = Math.min(cfg.auto_backup_interval_seconds * 5 / 60, 30);
+    if (staleMinutes > staleThreshold) {
+      issues.push(`Last git backup is stale (${relativeTime(status.lastBackup.git.timestamp)})`);
+    }
+  }
+
+  let healthStatus = 'healthy';
+  if (issues.length > 0) healthStatus = 'warning';
+  if (issues.some(i => i.includes('critically') || i.includes('requires Git'))) healthStatus = 'critical';
+
+  // ── Active alerts ───────────────────────────────────────────
+  const activeAlert = loadActiveAlert(projectDir);
+  const alerts = {
+    active: !!activeAlert,
+    latest: activeAlert || undefined,
+  };
+  if (activeAlert) {
+    if (healthStatus === 'healthy') healthStatus = 'warning';
+    issues.push(`Active alert: ${activeAlert.type} — ${activeAlert.fileCount} files in ${activeAlert.windowSeconds}s`);
+  }
+
+  return {
+    strategy,
+    lastBackup,
+    counts,
+    diskUsage,
+    protectionScope,
+    health: { status: healthStatus, issues },
+    alerts,
+    watcher: status.watcher,
+    disk: status.disk,
+  };
+}
+
+module.exports = { getDashboard, dirSizeBytes, formatBytes, relativeTime };

package/references/lib/core/doctor-fix.js

@@ -183,7 +183,7 @@ function runFixes(projectDir, opts = {}) {
     let stale = false;
     try {
       const content = fs.readFileSync(lockFile, 'utf-8').trim();
-      const pidMatch = content.match(/pid[:\s]+(\d+)/i);
+      const pidMatch = content.match(/pid[=:\s]+(\d+)/i);
       if (pidMatch) {
         const pid = parseInt(pidMatch[1], 10);
         try { process.kill(pid, 0); } catch { stale = true; }

package/references/lib/core/doctor.js

@@ -111,7 +111,7 @@ function runDiagnostics(projectDir) {
     let totalBytes = 0;
     try {
       const dirs = fs.readdirSync(backupDir, { withFileTypes: true })
-        .filter(d => d.isDirectory() && (/^\d{8}_\d{6}$/.test(d.name) || d.name.startsWith('pre-restore-')));
+        .filter(d => d.isDirectory() && (/^\d{8}_\d{6}(_\d{3})?$/.test(d.name) || d.name.startsWith('pre-restore-')));
       snapCount = dirs.length;
     } catch { /* ignore */ }
     try {
@@ -217,17 +217,35 @@ function runDiagnostics(projectDir) {
 
   let mcpSdkAvailable = false;
   let mcpSdkVersion = null;
-  try {
-    const mcpPkgPath = require.resolve('@modelcontextprotocol/sdk/package.json');
-    const mcpPkg = JSON.parse(fs.readFileSync(mcpPkgPath, 'utf-8'));
-    mcpSdkAvailable = true;
-    mcpSdkVersion = mcpPkg.version;
-  } catch { /* not installed */ }
+  // Try resolving SDK from the skill package's own node_modules first,
+  // then fall back to the running process's require paths.
+  const skillRoot = path.resolve(__dirname, '../../..');
+  const sdkCandidates = [
+    path.join(skillRoot, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json'),
+  ];
+  for (const candidate of sdkCandidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        const mcpPkg = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+        mcpSdkAvailable = true;
+        mcpSdkVersion = mcpPkg.version;
+        break;
+      }
+    } catch { /* ignore */ }
+  }
+  if (!mcpSdkAvailable) {
+    try {
+      const mcpPkgPath = require.resolve('@modelcontextprotocol/sdk/package.json');
+      const mcpPkg = JSON.parse(fs.readFileSync(mcpPkgPath, 'utf-8'));
+      mcpSdkAvailable = true;
+      mcpSdkVersion = mcpPkg.version;
+    } catch { /* not installed */ }
+  }
 
   if (mcpServerExists && mcpSdkAvailable) {
     check('MCP server', 'PASS', `server.js found, SDK ${mcpSdkVersion}`);
   } else if (mcpServerExists && !mcpSdkAvailable) {
-    check('MCP server', 'WARN', 'server.js found but @modelcontextprotocol/sdk not installed — run npm install');
+    check('MCP server', 'WARN', 'server.js found but @modelcontextprotocol/sdk not installed — run: cd <skill-dir> && npm install');
   } else if (!mcpServerExists && mcpSdkAvailable) {
     check('MCP server', 'WARN', `SDK installed (${mcpSdkVersion}) but server.js not found at expected path`);
   } else {

package/references/lib/core/restore.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const {
-  git, isGitRepo, gitDir: getGitDir, loadConfig,
+  git, isGitRepo, gitDir: getGitDir, loadConfig, unquoteGitPath,
 } = require('../utils');
 const { createGitSnapshot, formatTimestamp, removeSecretsFromIndex } = require('./snapshot');
 
@@ -18,7 +18,7 @@ function validateRelativePath(file) {
   return { valid: true, normalized };
 }
 
-const VALID_SHADOW_SOURCE = /^\d{8}_\d{6}$|^pre-restore-\d{8}_\d{6}$/;
+const VALID_SHADOW_SOURCE = /^\d{8}_\d{6}(_\d{3})?$|^pre-restore-\d{8}_\d{6}(_\d{3})?$/;
 
 function validateShadowSource(source) {
   if (!VALID_SHADOW_SOURCE.test(source)) {
@@ -88,11 +88,20 @@ function restoreFile(projectDir, file, source, opts = {}) {
     const targetFile = path.join(projectDir, file);
     if (fs.existsSync(targetFile)) {
       try {
-        const ts = formatTimestamp(new Date());
-        const preRestoreDir = path.join(projectDir, '.cursor-guard-backup', `pre-restore-${ts}`);
+        const preNow = new Date();
+        const preBaseTs = formatTimestamp(preNow);
+        let preTs = preBaseTs;
+        let preRestoreDir = path.join(projectDir, '.cursor-guard-backup', `pre-restore-${preTs}`);
+        if (fs.existsSync(preRestoreDir)) {
+          let seq = preNow.getMilliseconds();
+          for (let i = 0; i < 1000 && fs.existsSync(preRestoreDir); i++, seq++) {
+            preTs = `${preBaseTs}_${String(seq % 1000).padStart(3, '0')}`;
+            preRestoreDir = path.join(projectDir, '.cursor-guard-backup', `pre-restore-${preTs}`);
+          }
+        }
         fs.mkdirSync(path.join(preRestoreDir, path.dirname(file)), { recursive: true });
         fs.copyFileSync(targetFile, path.join(preRestoreDir, file));
-        result.preRestoreShadow = `pre-restore-${ts}`;
+        result.preRestoreShadow = `pre-restore-${preTs}`;
       } catch (e) {
         return { status: 'error', restoredFrom: source, error: `pre-restore shadow copy failed: ${e.message}` };
       }
@@ -164,24 +173,39 @@ function previewProjectRestore(projectDir, source) {
       return { status: 'error', error: `cannot resolve git source: ${source}` };
     }
 
+    const files = [];
+
     const diffOutput = git(
       ['diff', '--name-status', resolved],
       { cwd: projectDir, allowFail: true }
     );
 
-    if (!diffOutput) {
-      return { status: 'ok', files: [], totalChanged: 0 };
+    if (diffOutput) {
+      for (const line of diffOutput.split('\n').filter(Boolean)) {
+        const parts = line.split('\t');
+        const code = parts[0].trim();
+        if (code.startsWith('R') || code.startsWith('C')) {
+          const oldPath = unquoteGitPath(parts[1] || '');
+          const newPath = unquoteGitPath(parts[2] || '');
+          files.push({ path: newPath, oldPath, change: code.startsWith('R') ? 'renamed' : 'copied' });
+        } else {
+          const filePath = unquoteGitPath(parts[1] || '');
+          let change = 'modified';
+          if (code === 'A') change = 'added';
+          else if (code === 'D') change = 'deleted';
+          files.push({ path: filePath, change });
+        }
+      }
     }
 
-    const files = [];
-    for (const line of diffOutput.split('\n').filter(Boolean)) {
-      const tab = line.indexOf('\t');
-      const code = line.substring(0, tab).trim();
-      const filePath = line.substring(tab + 1).trim();
-      let change = 'modified';
-      if (code === 'A') change = 'added';
-      else if (code === 'D') change = 'deleted';
-      files.push({ path: filePath, change });
+    const untrackedOutput = git(
+      ['ls-files', '--others', '--exclude-standard'],
+      { cwd: projectDir, allowFail: true }
+    );
+    if (untrackedOutput) {
+      for (const f of untrackedOutput.split('\n').filter(Boolean)) {
+        files.push({ path: unquoteGitPath(f), change: 'untracked' });
+      }
     }
 
     return { status: 'ok', files, totalChanged: files.length };
@@ -195,16 +219,18 @@ function previewProjectRestore(projectDir, source) {
 /**
  * Execute a full project restore to a given source commit.
  * Creates a pre-restore snapshot first (unless opted out), then
- * restores all changed files.
+ * restores all tracked files and optionally removes untracked files.
  *
  * @param {string} projectDir
  * @param {string} source - Commit hash or ref
  * @param {object} [opts]
  * @param {boolean} [opts.preserveCurrent=true]
- * @returns {{ status: 'restored'|'error', preRestoreRef?: string, preRestoreShortHash?: string, filesRestored: number, files?: Array<{path: string, change: string}>, error?: string }}
+ * @param {boolean} [opts.cleanUntracked=true] - Remove untracked non-ignored files after restore
+ * @returns {{ status: 'restored'|'error', preRestoreRef?: string, preRestoreShortHash?: string, filesRestored: number, untrackedCleaned?: number, files?: Array<{path: string, change: string}>, error?: string }}
  */
 function executeProjectRestore(projectDir, source, opts = {}) {
   const preserveCurrent = resolvePreserve(projectDir, opts);
+  const cleanUntracked = opts.cleanUntracked !== false;
 
   if (!isGitRepo(projectDir)) {
     return { status: 'error', filesRestored: 0, error: 'not a git repository' };
@@ -219,11 +245,14 @@ function executeProjectRestore(projectDir, source, opts = {}) {
   if (preview.status === 'error') {
     return { status: 'error', filesRestored: 0, error: preview.error };
   }
-  if (preview.totalChanged === 0) {
+  const trackedFiles = preview.files.filter(f => f.change !== 'untracked');
+  const effectiveFiles = cleanUntracked ? preview.files : trackedFiles;
+
+  if (effectiveFiles.length === 0) {
     return { status: 'restored', filesRestored: 0, files: [], preRestoreRef: null };
   }
 
-  const result = { filesRestored: 0, files: preview.files };
+  const result = { filesRestored: 0, files: effectiveFiles };
 
   if (preserveCurrent) {
     const snap = createPreRestoreSnapshot(projectDir, null);
@@ -239,8 +268,27 @@ function executeProjectRestore(projectDir, source, opts = {}) {
     execFileSync('git', ['restore', `--source=${resolved}`, '--', '.'], {
       cwd: projectDir, stdio: 'pipe',
     });
+
+    let untrackedCleaned = 0;
+    if (cleanUntracked) {
+      const untrackedOutput = git(
+        ['ls-files', '--others', '--exclude-standard'],
+        { cwd: projectDir, allowFail: true }
+      );
+      if (untrackedOutput) {
+        for (const raw of untrackedOutput.split('\n').filter(Boolean)) {
+          const f = unquoteGitPath(raw);
+          try {
+            fs.unlinkSync(path.join(projectDir, f));
+            untrackedCleaned++;
+          } catch { /* skip files that can't be removed */ }
+        }
+      }
+    }
+
     result.status = 'restored';
-    result.filesRestored = preview.totalChanged;
+    result.filesRestored = trackedFiles.length;
+    result.untrackedCleaned = untrackedCleaned;
     return result;
   } catch (e) {
     return { status: 'error', filesRestored: 0, error: e.message };
@@ -261,8 +309,15 @@ function createPreRestoreSnapshot(projectDir, scope) {
   const gDir = getGitDir(projectDir);
   if (!gDir) return { status: 'error', error: 'not a git repository' };
 
-  const ts = formatTimestamp(new Date());
-  const ref = `refs/guard/pre-restore/${ts}`;
+  const now = new Date();
+  const baseTs = formatTimestamp(now);
+  let seq = now.getMilliseconds();
+  let ts, ref;
+  for (let i = 0; i < 1000; i++, seq++) {
+    ts = `${baseTs}_${String(seq % 1000).padStart(3, '0')}`;
+    ref = `refs/guard/pre-restore/${ts}`;
+    if (!git(['rev-parse', '--verify', ref], { cwd: projectDir, allowFail: true })) break;
+  }
   const guardIdx = path.join(gDir, 'guard-pre-restore-index');
   const env = { ...process.env, GIT_INDEX_FILE: guardIdx };
   const cwd = projectDir;

package/references/lib/core/snapshot.js

@@ -14,14 +14,28 @@ function formatTimestamp(d) {
   return `${d.getFullYear()}${pad(d.getMonth()+1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 
-function removeSecretsFromIndex(secretsPatterns, cwd, env) {
-  let files;
+function listIndexFiles(cwd, env) {
   try {
     const out = execFileSync('git', ['ls-files', '--cached'], {
       cwd, env, stdio: 'pipe', encoding: 'utf-8',
     }).trim();
-    files = out ? out.split('\n').filter(Boolean) : [];
+    return out ? out.split('\n').filter(Boolean) : [];
   } catch { return []; }
+}
+
+function pruneIndexFiles(cwd, env, shouldRemove) {
+  for (const f of listIndexFiles(cwd, env)) {
+    if (!shouldRemove(f)) continue;
+    try {
+      execFileSync('git', ['rm', '--cached', '--ignore-unmatch', '-q', '--', f], {
+        cwd, env, stdio: 'pipe',
+      });
+    } catch { /* ignore */ }
+  }
+}
+
+function removeSecretsFromIndex(secretsPatterns, cwd, env) {
+  const files = listIndexFiles(cwd, env);
 
   const excluded = [];
   for (const f of files) {
@@ -64,21 +78,24 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
 
   try {
     const parentHash = git(['rev-parse', '--verify', branchRef], { cwd, allowFail: true });
-    if (parentHash) {
-      execFileSync('git', ['read-tree', branchRef], { cwd, env, stdio: 'pipe' });
-    }
 
     if (cfg.protect.length > 0) {
-      for (const p of cfg.protect) {
-        execFileSync('git', ['add', '--', p], { cwd, env, stdio: 'pipe' });
-      }
+      // Add everything then prune — 'git add -- <pattern>' treats bare names as
+      // root-relative pathspecs, but matchesAny() also checks basenames (e.g.
+      // "settings.json" matches "src/settings.json").  Pruning via matchesAny
+      // keeps the semantics consistent with filterFiles().
+      execFileSync('git', ['add', '-A'], { cwd, env, stdio: 'pipe' });
+      pruneIndexFiles(cwd, env, f => !matchesAny(cfg.protect, f));
     } else {
+      if (parentHash) {
+        execFileSync('git', ['read-tree', branchRef], { cwd, env, stdio: 'pipe' });
+      }
       execFileSync('git', ['add', '-A'], { cwd, env, stdio: 'pipe' });
     }
 
-    for (const ig of cfg.ignore) {
-      execFileSync('git', ['rm', '--cached', '--ignore-unmatch', '-rq', '--', ig], { cwd, env, stdio: 'pipe' });
-    }
+    // Keep ignore semantics aligned with filterFiles()/matchesAny(), including
+    // basename-only patterns like "settings.json" for nested files.
+    pruneIndexFiles(cwd, env, f => matchesAny(cfg.ignore, f));
 
     const secretsExcluded = removeSecretsFromIndex(cfg.secrets_patterns, cwd, env);
 
@@ -104,13 +121,13 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
 
     git(['update-ref', branchRef, commitHash], { cwd });
 
-    let fileCount = 0;
+    const lsOut = git(['ls-tree', '--name-only', '-r', newTree], { cwd, allowFail: true });
+    const fileCount = lsOut ? lsOut.split('\n').filter(Boolean).length : 0;
+
+    let changedCount;
     if (parentTree) {
       const diff = git(['diff-tree', '--no-commit-id', '--name-only', '-r', parentTree, newTree], { cwd, allowFail: true });
-      fileCount = diff ? diff.split('\n').filter(Boolean).length : 0;
-    } else {
-      const all = git(['ls-tree', '--name-only', '-r', newTree], { cwd, allowFail: true });
-      fileCount = all ? all.split('\n').filter(Boolean).length : 0;
+      changedCount = diff ? diff.split('\n').filter(Boolean).length : 0;
     }
 
     return {
@@ -118,6 +135,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
       commitHash,
       shortHash: commitHash.substring(0, 7),
       fileCount,
+      changedCount,
       secretsExcluded: secretsExcluded.length > 0 ? secretsExcluded : undefined,
     };
   } catch (e) {
@@ -140,10 +158,18 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
  */
 function createShadowCopy(projectDir, cfg, opts = {}) {
   const backupDir = opts.backupDir || path.join(projectDir, '.cursor-guard-backup');
-  const ts = formatTimestamp(new Date());
-  const snapDir = path.join(backupDir, ts);
+  let ts = formatTimestamp(new Date());
+  let snapDir = path.join(backupDir, ts);
 
   try {
+    if (fs.existsSync(snapDir)) {
+      const baseTs = ts;
+      let seq = new Date().getMilliseconds();
+      for (let i = 0; i < 1000 && fs.existsSync(snapDir); i++, seq++) {
+        ts = `${baseTs}_${String(seq % 1000).padStart(3, '0')}`;
+        snapDir = path.join(backupDir, ts);
+      }
+    }
     fs.mkdirSync(snapDir, { recursive: true });
 
     const allFiles = walkDir(projectDir, projectDir);

package/references/lib/core/status.js

@@ -74,7 +74,7 @@ function getBackupStatus(projectDir) {
     const autoExists = git(['rev-parse', '--verify', autoRef], { cwd: projectDir, allowFail: true });
     if (autoExists) {
       const logLine = git(
-        ['log', autoRef, '--format=%H %aI %s', '-1'],
+        ['log', autoRef, '--format=%H %aI %s', '-1', '--grep=^guard:'],
         { cwd: projectDir, allowFail: true }
       );
       if (logLine) {
@@ -97,7 +97,7 @@ function getBackupStatus(projectDir) {
   if (fs.existsSync(backupDir)) {
     try {
       const dirs = fs.readdirSync(backupDir, { withFileTypes: true })
-        .filter(d => d.isDirectory() && /^\d{8}_\d{6}$/.test(d.name))
+        .filter(d => d.isDirectory() && /^\d{8}_\d{6}(_\d{3})?$/.test(d.name))
         .sort((a, b) => b.name.localeCompare(a.name));
 
       if (dirs.length > 0) {
@@ -133,10 +133,10 @@ function getBackupStatus(projectDir) {
     const autoRef = 'refs/guard/auto-backup';
     const autoHash = git(['rev-parse', '--verify', autoRef], { cwd: projectDir, allowFail: true });
     if (autoHash) {
-      const count = git(['rev-list', '--count', autoRef], { cwd: projectDir, allowFail: true });
+      const countOutput = git(['log', autoRef, '--grep=^guard:', '--format=%H'], { cwd: projectDir, allowFail: true });
       refs.autoBackup = {
         hash: autoHash.substring(0, 7),
-        commitCount: count ? parseInt(count, 10) : 0,
+        commitCount: countOutput ? countOutput.split('\n').filter(Boolean).length : 0,
       };
     }