cursor-guard 4.9.1 → 4.9.6

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

@@ -1 +1 @@
-{"version":"4.9.1"}
+{"version":"4.9.6"}

package/references/vscode-extension/dist/lib/auto-backup.js

@@ -22,6 +22,45 @@ function isProcessAlive(pid) {
   catch { return false; }
 }
 
+/**
+ * Ignore fs.watch events that originate inside the Git directory (including our snapshots).
+ * This is the **full** fix for the feedback loop: snapshot writes under `.git/` must never
+ * schedule another backup. No time-based cooldown — rely entirely on path semantics.
+ *
+ * On Windows, `filename` is often relative to the repo root but WITHOUT a `.git/` prefix
+ * (e.g. `HEAD`, `objects/ab/...`, `refs/guard/auto-backup`).
+ */
+const GIT_ONLY_TOP_NAMES = new Set([
+  'HEAD', 'FETCH_HEAD', 'ORIG_HEAD', 'MERGE_HEAD', 'COMMIT_EDITMSG', 'index', 'packed-refs',
+  'cursor-guard-index', 'cursor-guard-index.lock', 'cursor-guard.lock',
+  'refs', 'objects', 'logs', 'hooks', 'info', 'worktrees', 'modules', 'description',
+]);
+
+function shouldIgnoreFsWatchEvent(projectDir, filename, realGitDir) {
+  if (!filename) return true;
+  const norm = String(filename).replace(/\\/g, '/');
+  if (norm.startsWith('.git/') || norm === '.git') return true;
+  if (norm.startsWith('.cursor-guard-backup')) return true;
+
+  const gitRoot = realGitDir || path.join(projectDir, '.git');
+
+  try {
+    if (norm.includes('/') || GIT_ONLY_TOP_NAMES.has(norm)) {
+      const candidate = path.join(gitRoot, norm);
+      if (fs.existsSync(candidate)) return true;
+    }
+  } catch { /* ignore */ }
+
+  try {
+    const abs = path.resolve(projectDir, filename);
+    const gitDirAbs = path.resolve(gitRoot);
+    const rel = path.relative(gitDirAbs, abs);
+    if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))) return true;
+  } catch { /* ignore */ }
+
+  return false;
+}
+
 // ── Main ────────────────────────────────────────────────────────
 
 async function runBackup(projectDir, intervalOverride, opts = {}) {
@@ -323,9 +362,8 @@ async function runBackup(projectDir, intervalOverride, opts = {}) {
 
     watcher.on('change', (_eventType, filename) => {
       if (!filename) return;
+      if (shouldIgnoreFsWatchEvent(projectDir, filename, gDir)) return;
       const f = filename.replace(/\\/g, '/');
-      if (f.startsWith('.git/') || f.startsWith('.git\\')) return;
-      if (f.startsWith('.cursor-guard-backup')) return;
       if (f === '.cursor-guard.json') {
         hotReloadConfig();
         return;

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

@@ -400,9 +400,38 @@ function cleanGitRetention(branchRef, gitDirPath, cfg, cwd) {
 
 // ── Get backup file details ─────────────────────────────────────
 
+/** Git's canonical empty tree (used as diff base for root/orphan commits). */
+const GIT_EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+
+/** Normalize paths so numstat / name-status keys match (Windows vs /, quotes). */
+function _normalizeBackupPath(p) {
+  if (!p) return p;
+  let s = String(p).replace(/\\/g, '/');
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    s = s.slice(1, -1).replace(/\\"/g, '"');
+  }
+  return s;
+}
+
+/** Parse one line of `git diff --numstat` (same semantics as CLI; binary => `- -`). */
+function _parseGitDiffNumstatLine(add, del) {
+  if (add === '-' || del === '-') {
+    return { added: 0, deleted: 0, binary: true };
+  }
+  const a = parseInt(add, 10);
+  const d = parseInt(del, 10);
+  return {
+    added: Number.isNaN(a) ? 0 : a,
+    deleted: Number.isNaN(d) ? 0 : d,
+    binary: false,
+  };
+}
+
 /**
  * Get structured file-level changes for a specific git backup commit.
- * Runs diff-tree --numstat + --name-status against parent (or ls-tree for root).
+ * Uses **only** `git diff --numstat` + `git diff --name-status` (same as terminal),
+ * so +/- counts match `git diff parent..commit` 100%. Root/orphan commits diff
+ * against the standard empty tree.
  *
  * @param {string} projectDir
  * @param {string} commitHash - Full or short commit hash
@@ -418,25 +447,18 @@ function getBackupFiles(projectDir, commitHash) {
     return { files: [], error: `cannot resolve commit: ${commitHash}` };
   }
 
-  const parentCheck = git(['rev-parse', '--verify', `${resolved}^`], { cwd: projectDir, allowFail: true });
+  const parentCommit = git(['rev-parse', '--verify', `${resolved}^`], { cwd: projectDir, allowFail: true });
+  const parent = parentCommit || GIT_EMPTY_TREE_SHA;
 
-  if (!parentCheck) {
-    const lsOut = git(['ls-tree', '--name-only', '-r', resolved], { cwd: projectDir, allowFail: true });
-    if (!lsOut) return { files: [] };
-    return {
-      files: lsOut.split('\n').filter(Boolean).map(f => ({ path: f, action: 'added', added: 0, deleted: 0 })),
-    };
-  }
-
-  const nameStatusOut = git(['diff-tree', '--no-commit-id', '--name-status', '-r', `${resolved}^`, resolved], { cwd: projectDir, allowFail: true });
-  const numstatOut = git(['diff-tree', '--no-commit-id', '--numstat', '-r', `${resolved}^`, resolved], { cwd: projectDir, allowFail: true });
+  const numstatOut = git(['diff', '--numstat', parent, resolved], { cwd: projectDir, allowFail: true });
+  const nameStatusOut = git(['diff', '--name-status', parent, resolved], { cwd: projectDir, allowFail: true });
 
   const stats = {};
   if (numstatOut) {
     for (const line of numstatOut.split('\n').filter(Boolean)) {
       const [add, del, ...nameParts] = line.split('\t');
-      const fname = nameParts.join('\t');
-      stats[fname] = { added: add === '-' ? 0 : parseInt(add, 10), deleted: del === '-' ? 0 : parseInt(del, 10) };
+      const fname = _normalizeBackupPath(nameParts.join('\t'));
+      stats[fname] = _parseGitDiffNumstatLine(add, del);
     }
   }
 
@@ -448,9 +470,17 @@ function getBackupFiles(projectDir, commitHash) {
       if (tab < 0) continue;
       const code = line.substring(0, tab).trim();
       const filePart = line.substring(tab + 1);
-      const action = code.startsWith('R') ? 'renamed' : (ACTION_MAP[code] || 'modified');
+      let action = ACTION_MAP[code];
+      if (code.startsWith('R')) action = 'renamed';
+      else if (code.startsWith('C')) action = 'copied';
+      else if (!action) action = 'modified';
+
       const fileName = filePart.split('\t').pop();
-      const s = stats[fileName] || { added: 0, deleted: 0 };
+      const norm = _normalizeBackupPath(fileName);
+      let s = stats[norm];
+      if (!s && fileName !== norm) s = stats[fileName];
+      if (!s) s = { added: 0, deleted: 0, binary: false };
+
       files.push({ path: fileName, action, added: s.added, deleted: s.deleted });
     }
   }

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

@@ -6,9 +6,10 @@ const {
   loadConfig, gitAvailable, git, isGitRepo, gitDir: getGitDir,
   diskFreeGB, walkDir, filterFiles,
 } = require('../utils');
-const { getBackupStatus } = require('./status');
-const { loadActiveAlert } = require('./anomaly');
-const { parseShadowTimestamp } = require('./backups');
+const { getBackupStatus } = require('./status');
+const { loadActiveAlert } = require('./anomaly');
+const { loadActivePreWarnings } = require('./pre-warning');
+const { parseShadowTimestamp } = require('./backups');
 
 // ── Helpers ─────────────────────────────────────────────────────
 
@@ -184,26 +185,39 @@ function getDashboard(projectDir) {
 
   // ── 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,
+  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`);
+  }
+
+  const activePreWarnings = loadActivePreWarnings(projectDir);
+  const preWarnings = {
+    active: activePreWarnings.length > 0,
+    count: activePreWarnings.length,
+    latest: activePreWarnings[0] || undefined,
+    warnings: activePreWarnings,
+  };
+  if (preWarnings.active) {
+    if (healthStatus === 'healthy') healthStatus = 'warning';
+    issues.push(`Pre-warning active: ${preWarnings.latest?.summary || `${preWarnings.count} pending destructive edit warning(s)`}`);
+  }
+
+  return {
+    strategy,
+    lastBackup,
+    counts,
     diskUsage,
-    protectionScope,
-    health: { status: healthStatus, issues },
-    alerts,
-    watcher: status.watcher,
-    disk: status.disk,
-  };
-}
+    protectionScope,
+    health: { status: healthStatus, issues },
+    alerts,
+    preWarnings,
+    watcher: status.watcher,
+    disk: status.disk,
+  };
+}
 
 module.exports = { getDashboard, dirSizeBytes, formatBytes, relativeTime };

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

@@ -170,19 +170,25 @@ function runDiagnostics(projectDir) {
       check('Config: backup_strategy', 'FAIL', `invalid value '${cfg.backup_strategy}'`);
     }
     const validPreRestore = ['always', 'ask', 'never'];
-    if (cfg.pre_restore_backup && !validPreRestore.includes(cfg.pre_restore_backup)) {
-      check('Config: pre_restore_backup', 'FAIL', `invalid value '${cfg.pre_restore_backup}'`);
-    } else if (cfg.pre_restore_backup === 'never') {
-      check('Config: pre_restore_backup', 'WARN', "set to 'never' — restores won't auto-preserve current version");
-    }
-    if (cfg.auto_backup_interval_seconds && cfg.auto_backup_interval_seconds < 5) {
-      check('Config: interval', 'WARN', `${cfg.auto_backup_interval_seconds}s is below minimum (5s), will be clamped`);
-    }
-    if (cfg.retention && cfg.retention.mode) {
-      const validModes = ['days', 'count', 'size'];
-      if (!validModes.includes(cfg.retention.mode)) {
-        check('Config: retention.mode', 'FAIL', `invalid value '${cfg.retention.mode}'`);
-      }
+    if (cfg.pre_restore_backup && !validPreRestore.includes(cfg.pre_restore_backup)) {
+      check('Config: pre_restore_backup', 'FAIL', `invalid value '${cfg.pre_restore_backup}'`);
+    } else if (cfg.pre_restore_backup === 'never') {
+      check('Config: pre_restore_backup', 'WARN', "set to 'never' — restores won't auto-preserve current version");
+    }
+    if (cfg.auto_backup_interval_seconds && cfg.auto_backup_interval_seconds < 5) {
+      check('Config: interval', 'WARN', `${cfg.auto_backup_interval_seconds}s is below minimum (5s), will be clamped`);
+    }
+    if (cfg.pre_warning_threshold < 1 || cfg.pre_warning_threshold > 100) {
+      check('Config: pre_warning_threshold', 'FAIL', `invalid value '${cfg.pre_warning_threshold}'`);
+    }
+    if (!['popup', 'dashboard', 'silent'].includes(cfg.pre_warning_mode)) {
+      check('Config: pre_warning_mode', 'FAIL', `invalid value '${cfg.pre_warning_mode}'`);
+    }
+    if (cfg.retention && cfg.retention.mode) {
+      const validModes = ['days', 'count', 'size'];
+      if (!validModes.includes(cfg.retention.mode)) {
+        check('Config: retention.mode', 'FAIL', `invalid value '${cfg.retention.mode}'`);
+      }
     }
     if (cfg.git_retention && cfg.git_retention.mode) {
       const validGitModes = ['days', 'count'];

package/references/vscode-extension/dist/lib/core/pre-warning.js

@@ -0,0 +1,296 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { isGitRepo, gitDir: getGitDir, matchesAny } = require('../utils');
+
+const DEFAULT_EXPIRY_MS = 10 * 60 * 1000;
+const MAX_ACTIVE_WARNINGS = 20;
+const MAX_HISTORY = 100;
+
+function warningFilePath(projectDir) {
+  if (isGitRepo(projectDir)) {
+    const gDir = getGitDir(projectDir);
+    if (gDir) return path.join(gDir, 'cursor-guard-pre-warning.json');
+  }
+  return path.join(projectDir, '.cursor-guard-backup', 'cursor-guard-pre-warning.json');
+}
+
+function historyFilePath(projectDir) {
+  if (isGitRepo(projectDir)) {
+    const gDir = getGitDir(projectDir);
+    if (gDir) return path.join(gDir, 'cursor-guard-pre-warning-history.json');
+  }
+  return path.join(projectDir, '.cursor-guard-backup', 'cursor-guard-pre-warning-history.json');
+}
+
+function _readActiveStore(projectDir) {
+  const filePath = warningFilePath(projectDir);
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    const warnings = Array.isArray(parsed?.warnings) ? parsed.warnings : [];
+    return warnings.filter(w => w && typeof w.file === 'string');
+  } catch { return []; }
+}
+
+function _writeActiveStore(projectDir, warnings) {
+  const filePath = warningFilePath(projectDir);
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify({
+      updatedAt: new Date().toISOString(),
+      warnings,
+    }, null, 2));
+  } catch { /* best-effort */ }
+}
+
+function _readHistory(projectDir) {
+  const filePath = historyFilePath(projectDir);
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch { return []; }
+}
+
+function _writeHistory(projectDir, warnings) {
+  const filePath = historyFilePath(projectDir);
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(warnings.slice(0, MAX_HISTORY), null, 2));
+  } catch { /* best-effort */ }
+}
+
+function _normalizeWarning(warning, opts = {}) {
+  const now = warning.detectedAt || Date.now();
+  return {
+    type: 'destructive_edit_risk',
+    detectedAt: now,
+    timestamp: warning.timestamp || new Date(now).toISOString(),
+    expiresAt: warning.expiresAt || new Date(now + (opts.expiryMs || DEFAULT_EXPIRY_MS)).toISOString(),
+    ...warning,
+  };
+}
+
+function isPreWarningEnabled(cfg) {
+  return cfg?.enable_pre_warning === true;
+}
+
+function shouldExcludePreWarning(file, cfg) {
+  if (!file || !Array.isArray(cfg?.pre_warning_exclude_patterns)) return false;
+  return matchesAny(cfg.pre_warning_exclude_patterns, file);
+}
+
+function recordPreWarning(projectDir, warning, opts = {}) {
+  const normalized = _normalizeWarning(warning, opts);
+
+  const history = _readHistory(projectDir);
+  _writeHistory(projectDir, [normalized, ...history]);
+
+  if (opts.setActive === false) return normalized;
+
+  const active = loadActivePreWarnings(projectDir)
+    .filter(w => w.file !== normalized.file);
+  active.unshift(normalized);
+  _writeActiveStore(projectDir, active.slice(0, MAX_ACTIVE_WARNINGS));
+  return normalized;
+}
+
+function loadActivePreWarnings(projectDir) {
+  const now = Date.now();
+  return _readActiveStore(projectDir)
+    .filter(w => !w.expiresAt || now < new Date(w.expiresAt).getTime())
+    .sort((a, b) => (b.detectedAt || 0) - (a.detectedAt || 0));
+}
+
+function loadActivePreWarning(projectDir) {
+  return loadActivePreWarnings(projectDir)[0] || null;
+}
+
+function listPreWarningHistory(projectDir, limit = 20) {
+  return _readHistory(projectDir)
+    .sort((a, b) => (b.detectedAt || 0) - (a.detectedAt || 0))
+    .slice(0, limit);
+}
+
+function clearPreWarning(projectDir, file) {
+  if (!file) {
+    _writeActiveStore(projectDir, []);
+    return;
+  }
+  const active = loadActivePreWarnings(projectDir).filter(w => w.file !== file);
+  if (active.length === 0) {
+    const filePath = warningFilePath(projectDir);
+    try { fs.unlinkSync(filePath); } catch { /* ignore */ }
+    return;
+  }
+  _writeActiveStore(projectDir, active);
+}
+
+function clearExpiredPreWarnings(projectDir) {
+  const active = loadActivePreWarnings(projectDir);
+  if (active.length === 0) {
+    const filePath = warningFilePath(projectDir);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        return true;
+      }
+    } catch { /* ignore */ }
+    return false;
+  }
+  _writeActiveStore(projectDir, active);
+  return false;
+}
+
+function _splitLines(text) {
+  return String(text || '').replace(/\r\n/g, '\n').split('\n');
+}
+
+function _normalizeLine(line) {
+  return String(line || '').trim().replace(/\s+/g, ' ');
+}
+
+function _countLines(lines) {
+  const counts = new Map();
+  for (const line of lines) {
+    const normalized = _normalizeLine(line);
+    if (!normalized) continue;
+    counts.set(normalized, (counts.get(normalized) || 0) + 1);
+  }
+  return counts;
+}
+
+function _extractRemovedLines(prevLines, nextLines) {
+  const nextCounts = _countLines(nextLines);
+  const removed = [];
+  for (let i = 0; i < prevLines.length; i++) {
+    const raw = prevLines[i];
+    const normalized = _normalizeLine(raw);
+    if (!normalized) continue;
+    const remaining = nextCounts.get(normalized) || 0;
+    if (remaining > 0) {
+      nextCounts.set(normalized, remaining - 1);
+      continue;
+    }
+    removed.push({
+      line: raw,
+      normalized,
+      lineNumber: i + 1,
+    });
+  }
+  return removed;
+}
+
+function _extractDefinitions(lines) {
+  const defs = [];
+  const patterns = [
+    /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/,
+    /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^=]*\)\s*=>/,
+    /^\s*(?:public|private|protected|static|async|get|set|\s)*([A-Za-z_$][\w$]*)\s*\([^;]*\)\s*(?:\{|=>)\s*$/,
+    /^\s*(?:public|private|protected|internal|static|final|virtual|override|abstract|synchronized|\s)+(?:[\w<>\[\],.?]+\s+)+([A-Za-z_]\w*)\s*\([^;]*\)\s*(?:\{|=>)\s*$/,
+    /^\s*def\s+([A-Za-z_]\w*[!?=]?)\s*\(/,
+    /^\s*func\s+(?:\([^)]+\)\s*)?([A-Za-z_]\w*)\s*\(/,
+    /^\s*(?:public|private|protected|static|\s)*function\s+([A-Za-z_]\w*)\s*\(/,
+  ];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (!match) continue;
+      defs.push({
+        name: match[1],
+        signature: _normalizeLine(line),
+        lineNumber: i + 1,
+      });
+      break;
+    }
+  }
+
+  return defs;
+}
+
+function _removedDefinitions(prevLines, nextLines) {
+  const prevDefs = _extractDefinitions(prevLines);
+  const nextDefs = _extractDefinitions(nextLines);
+  const nextNames = new Set(nextDefs.map(d => d.name));
+  return prevDefs.filter(d => !nextNames.has(d.name));
+}
+
+function assessDeletionRisk(prevText, nextText, opts = {}) {
+  const threshold = Math.max(1, parseInt(opts.threshold, 10) || 30);
+  const prevLines = _splitLines(prevText);
+  const nextLines = _splitLines(nextText);
+  const previousNonEmptyLines = prevLines.filter(line => _normalizeLine(line)).length;
+  const nextNonEmptyLines = nextLines.filter(line => _normalizeLine(line)).length;
+
+  if (String(prevText || '') === String(nextText || '')) {
+    return {
+      triggered: false,
+      threshold,
+      previousNonEmptyLines,
+      nextNonEmptyLines,
+      deletedLines: 0,
+      removedMethodCount: 0,
+      removedMethods: [],
+      riskPercent: 0,
+      summary: 'No deletion risk detected.',
+    };
+  }
+
+  const removedLines = _extractRemovedLines(prevLines, nextLines);
+  const removedMethods = _removedDefinitions(prevLines, nextLines);
+  const deletedLines = removedLines.length;
+  const baseRisk = previousNonEmptyLines > 0
+    ? Math.round((deletedLines / previousNonEmptyLines) * 100)
+    : 0;
+  const methodBoost = removedMethods.length > 0
+    ? Math.min(100, baseRisk + removedMethods.length * 20)
+    : baseRisk;
+  const riskPercent = Math.min(100, Math.max(baseRisk, methodBoost));
+  const triggered = deletedLines > 0 && (riskPercent >= threshold || removedMethods.length > 0);
+
+  const methodSummary = removedMethods.length > 0
+    ? `${removedMethods.length} method${removedMethods.length === 1 ? '' : 's'} removed`
+    : null;
+  const lineSummary = deletedLines > 0
+    ? `${deletedLines} line${deletedLines === 1 ? '' : 's'} deleted`
+    : null;
+  const summaryParts = [methodSummary, lineSummary].filter(Boolean);
+  const deletedLineSamples = removedLines
+    .map(r => r.normalized)
+    .filter(Boolean)
+    .slice(0, 5);
+
+  return {
+    triggered,
+    threshold,
+    previousNonEmptyLines,
+    nextNonEmptyLines,
+    deletedLines,
+    netLineDelta: nextNonEmptyLines - previousNonEmptyLines,
+    removedMethodCount: removedMethods.length,
+    removedMethods,
+    riskPercent,
+    deletedLineSamples,
+    summary: summaryParts.length > 0
+      ? `${summaryParts.join(', ')} (risk ${riskPercent}%)`
+      : `Deletion risk ${riskPercent}%`,
+  };
+}
+
+module.exports = {
+  assessDeletionRisk,
+  isPreWarningEnabled,
+  shouldExcludePreWarning,
+  recordPreWarning,
+  loadActivePreWarning,
+  loadActivePreWarnings,
+  listPreWarningHistory,
+  clearPreWarning,
+  clearExpiredPreWarnings,
+  warningFilePath,
+  historyFilePath,
+};

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

@@ -197,6 +197,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
         if (parts.length) incrementalSummary = parts.join('; ');
       }
     } else {
+      const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf899d15f3b60ea6a';
       const lsInitial = git(['ls-tree', '--name-only', '-r', newTree], { cwd, allowFail: true });
       if (lsInitial) {
         const files = lsInitial.split('\n').filter(Boolean)
@@ -204,8 +205,29 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
           .filter(f => cfg.protect.length === 0 || matchesAny(cfg.protect, f, { strict: true }));
         changedCount = files.length;
         const sample = files.slice(0, 5).join(', ');
-        incrementalSummary = `Added ${files.length}: ${sample}${files.length > 5 ? ', ...' : ''}`;
-        changedFiles = files.map(f => ({ path: f, action: 'added', added: 0, deleted: 0 }));
+
+        const numstatInit = git(['diff-tree', '--no-commit-id', '--numstat', '-r', EMPTY_TREE, newTree], { cwd, allowFail: true });
+        const stats = {};
+        if (numstatInit) {
+          for (const line of numstatInit.split('\n').filter(Boolean)) {
+            const [add, del, ...nameParts] = line.split('\t');
+            const fname = nameParts.join('\t');
+            stats[fname] = { added: add === '-' ? 0 : parseInt(add, 10), deleted: del === '-' ? 0 : parseInt(del, 10) };
+          }
+        }
+
+        changedFiles = files.map(f => {
+          const s = stats[f] || { added: 0, deleted: 0 };
+          return { path: f, action: 'added', added: s.added, deleted: s.deleted };
+        });
+
+        function fmtFilesInit(arr) {
+          return arr.slice(0, 5).map(f => {
+            const s = stats[f];
+            return s ? `${f} (+${s.added} -${s.deleted})` : f;
+          }).join(', ');
+        }
+        incrementalSummary = `Added ${files.length}: ${fmtFilesInit(files)}${files.length > 5 ? ', ...' : ''}`;
       }
     }
 

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

@@ -1,10 +1,11 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
-const {
-  loadConfig, gitAvailable, git, isGitRepo, gitDir: getGitDir, diskFreeGB,
-} = require('../utils');
+const fs = require('fs');
+const path = require('path');
+const {
+  loadConfig, gitAvailable, git, isGitRepo, gitDir: getGitDir, diskFreeGB,
+} = require('../utils');
+const { loadActivePreWarnings } = require('./pre-warning');
 
 /**
  * Gather comprehensive backup system status.
@@ -157,7 +158,14 @@ function getBackupStatus(projectDir) {
     else if (freeGB < 5) disk.warning = 'low';
   }
 
-  return { watcher, config, lastBackup, refs, disk };
-}
+  const activePreWarnings = loadActivePreWarnings(projectDir);
+  const preWarnings = {
+    active: activePreWarnings.length > 0,
+    count: activePreWarnings.length,
+    latest: activePreWarnings[0] || undefined,
+  };
+
+  return { watcher, config, lastBackup, refs, disk, preWarnings };
+}
 
 module.exports = { getBackupStatus };