cursor-guard 4.9.0 → 4.9.6

package/references/lib/core/core.test.js

@@ -10,10 +10,11 @@ const { runDiagnostics } = require('./doctor');
 const { createGitSnapshot, createShadowCopy } = require('./snapshot');
 const { listBackups, cleanShadowRetention } = require('./backups');
 const { restoreFile, previewProjectRestore, executeProjectRestore, createPreRestoreSnapshot, validateShadowSource } = require('./restore');
-const { runFixes } = require('./doctor-fix');
-const { getBackupStatus } = require('./status');
-const { createChangeTracker, recordChange, checkAnomaly, getAlertStatus, saveAlert, loadActiveAlert, clearExpiredAlert, clearAlert, alertFilePath } = require('./anomaly');
-const { getDashboard, dirSizeBytes, formatBytes, relativeTime } = require('./dashboard');
+const { runFixes } = require('./doctor-fix');
+const { getBackupStatus } = require('./status');
+const { createChangeTracker, recordChange, checkAnomaly, getAlertStatus, saveAlert, loadActiveAlert, clearExpiredAlert, clearAlert, alertFilePath } = require('./anomaly');
+const { getDashboard, dirSizeBytes, formatBytes, relativeTime } = require('./dashboard');
+const { assessDeletionRisk, recordPreWarning, loadActivePreWarnings, listPreWarningHistory, clearPreWarning } = require('./pre-warning');
 
 let passed = 0;
 let failed = 0;
@@ -369,23 +370,23 @@ test('createGitSnapshot drops files when protect scope narrows', () => {
   }
 });
 
-test('createGitSnapshot with basename-only protect matches nested files', () => {
-  const tmpDir = createTempGitRepo();
-  try {
-    const { loadConfig } = require('../utils');
-    const cfg = { ...loadConfig(tmpDir).cfg, protect: ['app.js'] };
-    const result = createGitSnapshot(tmpDir, cfg);
-    assert.strictEqual(result.status, 'created');
-
-    const treeFiles = execFileSync('git', ['ls-tree', '--name-only', '-r', result.commitHash], {
-      cwd: tmpDir, stdio: 'pipe', encoding: 'utf-8',
-    }).trim().split('\n');
-    assert.ok(treeFiles.includes('src/app.js'), 'basename "app.js" should match nested src/app.js');
-    assert.ok(!treeFiles.includes('hello.txt'), 'unprotected files should be excluded');
-  } finally {
-    cleanupDir(tmpDir);
-  }
-});
+test('createGitSnapshot with basename-only protect does not match nested files in strict mode', () => {
+  const tmpDir = createTempGitRepo();
+  try {
+    const { loadConfig } = require('../utils');
+    const cfg = { ...loadConfig(tmpDir).cfg, protect: ['app.js'] };
+    const result = createGitSnapshot(tmpDir, cfg);
+    assert.strictEqual(result.status, 'created');
+
+    const treeFiles = execFileSync('git', ['ls-tree', '--name-only', '-r', result.commitHash], {
+      cwd: tmpDir, stdio: 'pipe', encoding: 'utf-8',
+    }).trim().split('\n');
+    assert.ok(!treeFiles.includes('src/app.js'), 'basename-only protect should NOT match nested src/app.js');
+    assert.ok(!treeFiles.includes('hello.txt'), 'unprotected files should be excluded');
+  } finally {
+    cleanupDir(tmpDir);
+  }
+});
 
 test('createGitSnapshot with basename-only ignore excludes nested files', () => {
   const tmpDir = createTempGitRepo();
@@ -1369,7 +1370,85 @@ test('clearExpiredAlert removes expired file but leaves active ones', () => {
 
 // ── core/dashboard.js ───────────────────────────────────────────
 
-console.log('\ncore/dashboard:');
+console.log('\ncore/pre-warning:');
+
+test('assessDeletionRisk flags removed methods', () => {
+  const prevText = [
+    'function keepMe() {',
+    '  return true;',
+    '}',
+    '',
+    'function removeMe() {',
+    '  return false;',
+    '}',
+  ].join('\n');
+  const nextText = [
+    'function keepMe() {',
+    '  return true;',
+    '}',
+  ].join('\n');
+
+  const result = assessDeletionRisk(prevText, nextText, { threshold: 30 });
+  assert.strictEqual(result.triggered, true);
+  assert.strictEqual(result.removedMethodCount, 1);
+  assert.ok(result.removedMethods.some(method => method.name === 'removeMe'));
+  assert.ok(result.deletedLines >= 3);
+  assert.ok(result.riskPercent >= 40);
+});
+
+test('recordPreWarning persists active warnings and history', () => {
+  const tmpDir = createTempGitRepo();
+  try {
+    recordPreWarning(tmpDir, {
+      file: 'src/app.js',
+      riskPercent: 68,
+      summary: '1 method removed, 5 lines deleted (risk 68%)',
+      removedMethodCount: 1,
+      removedMethods: [{ name: 'login', lineNumber: 12 }],
+      deletedLines: 5,
+    }, { setActive: true });
+
+    const active = loadActivePreWarnings(tmpDir);
+    const history = listPreWarningHistory(tmpDir, 5);
+    assert.strictEqual(active.length, 1);
+    assert.strictEqual(active[0].file, 'src/app.js');
+    assert.ok(active[0].expiresAt, 'active warning should have expiry');
+    assert.strictEqual(history.length, 1);
+
+    clearPreWarning(tmpDir, 'src/app.js');
+    assert.strictEqual(loadActivePreWarnings(tmpDir).length, 0);
+  } finally {
+    cleanupDir(tmpDir);
+  }
+});
+
+test('getBackupStatus and getDashboard expose active pre-warning state', () => {
+  const tmpDir = createTempGitRepo();
+  try {
+    recordPreWarning(tmpDir, {
+      file: 'src/app.js',
+      riskPercent: 72,
+      summary: '1 method removed, 6 lines deleted (risk 72%)',
+      removedMethodCount: 1,
+      removedMethods: [{ name: 'login', lineNumber: 15 }],
+      deletedLines: 6,
+    }, { setActive: true });
+
+    const status = getBackupStatus(tmpDir);
+    const dashboard = getDashboard(tmpDir);
+
+    assert.strictEqual(status.preWarnings.active, true);
+    assert.strictEqual(status.preWarnings.count, 1);
+    assert.strictEqual(status.preWarnings.latest.file, 'src/app.js');
+    assert.strictEqual(dashboard.preWarnings.active, true);
+    assert.strictEqual(dashboard.preWarnings.count, 1);
+    assert.ok(dashboard.health.issues.some(issue => issue.includes('Pre-warning active')));
+  } finally {
+    cleanupDir(tmpDir);
+  }
+});
+
+console.log('\ncore/dashboard:');
 
 test('formatBytes formats correctly', () => {
   assert.strictEqual(formatBytes(500), '500B');

package/references/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/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/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/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/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 };