@vibecheck-ai/cli 20.2.0 → 23.0.1

package/dist/runner/FileRunner.js

@@ -110,7 +110,7 @@ var require_path = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertPosixPathToPattern = exports2.convertWindowsPathToPattern = exports2.convertPathToPattern = exports2.escapePosixPath = exports2.escapeWindowsPath = exports2.escape = exports2.removeLeadingDotSegment = exports2.makeAbsolute = exports2.unixify = void 0;
     var os2 = require("os");
-    var path3 = require("path");
+    var path6 = require("path");
     var IS_WINDOWS_PLATFORM = os2.platform() === "win32";
     var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
     var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
@@ -123,7 +123,7 @@ var require_path = __commonJS({
     __name(unixify, "unixify");
     exports2.unixify = unixify;
     function makeAbsolute(cwd, filepath) {
-      return path3.resolve(cwd, filepath);
+      return path6.resolve(cwd, filepath);
     }
     __name(makeAbsolute, "makeAbsolute");
     exports2.makeAbsolute = makeAbsolute;
@@ -1440,7 +1440,7 @@ var require_braces = __commonJS({
 var require_constants2 = __commonJS({
   "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports2, module2) {
     "use strict";
-    var path3 = require("path");
+    var path6 = require("path");
     var WIN_SLASH = "\\\\/";
     var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
     var DOT_LITERAL = "\\.";
@@ -1610,7 +1610,7 @@ var require_constants2 = __commonJS({
       /* | */
       CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
       /* \uFEFF */
-      SEP: path3.sep,
+      SEP: path6.sep,
       /**
        * Create EXTGLOB_CHARS
        */
@@ -1637,7 +1637,7 @@ var require_constants2 = __commonJS({
 var require_utils2 = __commonJS({
   "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports2) {
     "use strict";
-    var path3 = require("path");
+    var path6 = require("path");
     var win32 = process.platform === "win32";
     var {
       REGEX_BACKSLASH,
@@ -1666,7 +1666,7 @@ var require_utils2 = __commonJS({
       if (options && typeof options.windows === "boolean") {
         return options.windows;
       }
-      return win32 === true || path3.sep === "\\";
+      return win32 === true || path6.sep === "\\";
     };
     exports2.escapeLast = (input, char, lastIdx) => {
       const idx = input.lastIndexOf(char, lastIdx);
@@ -2801,7 +2801,7 @@ var require_parse2 = __commonJS({
 var require_picomatch = __commonJS({
   "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
     "use strict";
-    var path3 = require("path");
+    var path6 = require("path");
     var scan = require_scan();
     var parse = require_parse2();
     var utils = require_utils2();
@@ -2886,7 +2886,7 @@ var require_picomatch = __commonJS({
     };
     picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
       const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-      return regex.test(path3.basename(input));
+      return regex.test(path6.basename(input));
     };
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
@@ -3113,7 +3113,7 @@ var require_pattern = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.isAbsolute = exports2.partitionAbsoluteAndRelative = exports2.removeDuplicateSlashes = exports2.matchAny = exports2.convertPatternsToRe = exports2.makeRe = exports2.getPatternParts = exports2.expandBraceExpansion = exports2.expandPatternsWithBraceExpansion = exports2.isAffectDepthOfReadingPattern = exports2.endsWithSlashGlobStar = exports2.hasGlobStar = exports2.getBaseDirectory = exports2.isPatternRelatedToParentDirectory = exports2.getPatternsOutsideCurrentDirectory = exports2.getPatternsInsideCurrentDirectory = exports2.getPositivePatterns = exports2.getNegativePatterns = exports2.isPositivePattern = exports2.isNegativePattern = exports2.convertToNegativePattern = exports2.convertToPositivePattern = exports2.isDynamicPattern = exports2.isStaticPattern = void 0;
-    var path3 = require("path");
+    var path6 = require("path");
     var globParent = require_glob_parent();
     var micromatch = require_micromatch();
     var GLOBSTAR = "**";
@@ -3223,7 +3223,7 @@ var require_pattern = __commonJS({
     __name(endsWithSlashGlobStar, "endsWithSlashGlobStar");
     exports2.endsWithSlashGlobStar = endsWithSlashGlobStar;
     function isAffectDepthOfReadingPattern(pattern) {
-      const basename = path3.basename(pattern);
+      const basename = path6.basename(pattern);
       return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
     }
     __name(isAffectDepthOfReadingPattern, "isAffectDepthOfReadingPattern");
@@ -3290,7 +3290,7 @@ var require_pattern = __commonJS({
     __name(partitionAbsoluteAndRelative, "partitionAbsoluteAndRelative");
     exports2.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
     function isAbsolute(pattern) {
-      return path3.isAbsolute(pattern);
+      return path6.isAbsolute(pattern);
     }
     __name(isAbsolute, "isAbsolute");
     exports2.isAbsolute = isAbsolute;
@@ -3479,10 +3479,10 @@ var require_utils3 = __commonJS({
     exports2.array = array;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs3 = require_fs();
-    exports2.fs = fs3;
-    var path3 = require_path();
-    exports2.path = path3;
+    var fs6 = require_fs();
+    exports2.fs = fs6;
+    var path6 = require_path();
+    exports2.path = path6;
     var pattern = require_pattern();
     exports2.pattern = pattern;
     var stream = require_stream();
@@ -3602,8 +3602,8 @@ var require_async = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.read = void 0;
-    function read(path3, settings, callback) {
-      settings.fs.lstat(path3, (lstatError, lstat) => {
+    function read(path6, settings, callback) {
+      settings.fs.lstat(path6, (lstatError, lstat) => {
         if (lstatError !== null) {
           callFailureCallback(callback, lstatError);
           return;
@@ -3612,7 +3612,7 @@ var require_async = __commonJS({
           callSuccessCallback(callback, lstat);
           return;
         }
-        settings.fs.stat(path3, (statError, stat3) => {
+        settings.fs.stat(path6, (statError, stat4) => {
           if (statError !== null) {
             if (settings.throwErrorOnBrokenSymbolicLink) {
               callFailureCallback(callback, statError);
@@ -3622,9 +3622,9 @@ var require_async = __commonJS({
             return;
           }
           if (settings.markSymbolicLink) {
-            stat3.isSymbolicLink = () => true;
+            stat4.isSymbolicLink = () => true;
           }
-          callSuccessCallback(callback, stat3);
+          callSuccessCallback(callback, stat4);
         });
       });
     }
@@ -3647,17 +3647,17 @@ var require_sync = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.read = void 0;
-    function read(path3, settings) {
-      const lstat = settings.fs.lstatSync(path3);
+    function read(path6, settings) {
+      const lstat = settings.fs.lstatSync(path6);
       if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
         return lstat;
       }
       try {
-        const stat3 = settings.fs.statSync(path3);
+        const stat4 = settings.fs.statSync(path6);
         if (settings.markSymbolicLink) {
-          stat3.isSymbolicLink = () => true;
+          stat4.isSymbolicLink = () => true;
         }
-        return stat3;
+        return stat4;
       } catch (error) {
         if (!settings.throwErrorOnBrokenSymbolicLink) {
           return lstat;
@@ -3676,12 +3676,12 @@ var require_fs2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs3 = require("fs");
+    var fs6 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs3.lstat,
-      stat: fs3.stat,
-      lstatSync: fs3.lstatSync,
-      statSync: fs3.statSync
+      lstat: fs6.lstat,
+      stat: fs6.stat,
+      lstatSync: fs6.lstatSync,
+      statSync: fs6.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -3699,7 +3699,7 @@ var require_settings = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs3 = require_fs2();
+    var fs6 = require_fs2();
     var Settings = class {
       static {
         __name(this, "Settings");
@@ -3707,7 +3707,7 @@ var require_settings = __commonJS({
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs3.createFileSystemAdapter(this._options.fs);
+        this.fs = fs6.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -3729,21 +3729,21 @@ var require_out = __commonJS({
     var sync = require_sync();
     var settings_1 = require_settings();
     exports2.Settings = settings_1.default;
-    function stat3(path3, optionsOrSettingsOrCallback, callback) {
+    function stat4(path6, optionsOrSettingsOrCallback, callback) {
       if (typeof optionsOrSettingsOrCallback === "function") {
-        async.read(path3, getSettings(), optionsOrSettingsOrCallback);
+        async.read(path6, getSettings(), optionsOrSettingsOrCallback);
         return;
       }
-      async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
+      async.read(path6, getSettings(optionsOrSettingsOrCallback), callback);
     }
-    __name(stat3, "stat");
-    exports2.stat = stat3;
-    function statSync(path3, optionsOrSettings) {
+    __name(stat4, "stat");
+    exports2.stat = stat4;
+    function statSync2(path6, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
-      return sync.read(path3, settings);
+      return sync.read(path6, settings);
     }
-    __name(statSync, "statSync");
-    exports2.statSync = statSync;
+    __name(statSync2, "statSync");
+    exports2.statSync = statSync2;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -3873,8 +3873,8 @@ var require_utils4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs3 = require_fs3();
-    exports2.fs = fs3;
+    var fs6 = require_fs3();
+    exports2.fs = fs6;
   }
 });
 
@@ -3970,16 +3970,16 @@ var require_async2 = __commonJS({
           return;
         }
         const tasks = names.map((name) => {
-          const path3 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+          const path6 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
           return (done) => {
-            fsStat.stat(path3, settings.fsStatSettings, (error, stats) => {
+            fsStat.stat(path6, settings.fsStatSettings, (error, stats) => {
               if (error !== null) {
                 done(error);
                 return;
               }
               const entry = {
                 name,
-                path: path3,
+                path: path6,
                 dirent: utils.fs.createDirentFromStats(name, stats)
               };
               if (settings.stats) {
@@ -4079,14 +4079,14 @@ var require_fs4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs3 = require("fs");
+    var fs6 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs3.lstat,
-      stat: fs3.stat,
-      lstatSync: fs3.lstatSync,
-      statSync: fs3.statSync,
-      readdir: fs3.readdir,
-      readdirSync: fs3.readdirSync
+      lstat: fs6.lstat,
+      stat: fs6.stat,
+      lstatSync: fs6.lstatSync,
+      statSync: fs6.statSync,
+      readdir: fs6.readdir,
+      readdirSync: fs6.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -4104,9 +4104,9 @@ var require_settings2 = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var path3 = require("path");
+    var path6 = require("path");
     var fsStat = require_out();
-    var fs3 = require_fs4();
+    var fs6 = require_fs4();
     var Settings = class {
       static {
         __name(this, "Settings");
@@ -4114,8 +4114,8 @@ var require_settings2 = __commonJS({
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs3.createFileSystemAdapter(this._options.fs);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path3.sep);
+        this.fs = fs6.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path6.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
         this.fsStatSettings = new fsStat.Settings({
@@ -4142,18 +4142,18 @@ var require_out2 = __commonJS({
     var sync = require_sync2();
     var settings_1 = require_settings2();
     exports2.Settings = settings_1.default;
-    function scandir(path3, optionsOrSettingsOrCallback, callback) {
+    function scandir(path6, optionsOrSettingsOrCallback, callback) {
       if (typeof optionsOrSettingsOrCallback === "function") {
-        async.read(path3, getSettings(), optionsOrSettingsOrCallback);
+        async.read(path6, getSettings(), optionsOrSettingsOrCallback);
         return;
       }
-      async.read(path3, getSettings(optionsOrSettingsOrCallback), callback);
+      async.read(path6, getSettings(optionsOrSettingsOrCallback), callback);
     }
     __name(scandir, "scandir");
     exports2.scandir = scandir;
-    function scandirSync(path3, optionsOrSettings) {
+    function scandirSync(path6, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
-      return sync.read(path3, settings);
+      return sync.read(path6, settings);
     }
     __name(scandirSync, "scandirSync");
     exports2.scandirSync = scandirSync;
@@ -4454,13 +4454,13 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve, reject) {
+        var p = new Promise(function(resolve2, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve(result);
+            resolve2(result);
           });
         });
         p.catch(noop);
@@ -4468,13 +4468,13 @@ var require_queue = __commonJS({
       }
       __name(push, "push");
       function unshift(value) {
-        var p = new Promise(function(resolve, reject) {
+        var p = new Promise(function(resolve2, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve(result);
+            resolve2(result);
           });
         });
         p.catch(noop);
@@ -4482,15 +4482,15 @@ var require_queue = __commonJS({
       }
       __name(unshift, "unshift");
       function drained() {
-        var p = new Promise(function(resolve) {
+        var p = new Promise(function(resolve2) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve();
+              resolve2();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve();
+                resolve2();
                 queue.drain = previousDrain;
               };
             }
@@ -4850,7 +4850,7 @@ var require_settings3 = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var path3 = require("path");
+    var path6 = require("path");
     var fsScandir = require_out2();
     var Settings = class {
       static {
@@ -4863,7 +4863,7 @@ var require_settings3 = __commonJS({
         this.deepFilter = this._getValue(this._options.deepFilter, null);
         this.entryFilter = this._getValue(this._options.entryFilter, null);
         this.errorFilter = this._getValue(this._options.errorFilter, null);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path3.sep);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path6.sep);
         this.fsScandirSettings = new fsScandir.Settings({
           followSymbolicLinks: this._options.followSymbolicLinks,
           fs: this._options.fs,
@@ -4929,7 +4929,7 @@ var require_reader2 = __commonJS({
   "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/reader.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var path3 = require("path");
+    var path6 = require("path");
     var fsStat = require_out();
     var utils = require_utils3();
     var Reader = class {
@@ -4945,7 +4945,7 @@ var require_reader2 = __commonJS({
         });
       }
       _getFullEntryPath(filepath) {
-        return path3.resolve(this._settings.cwd, filepath);
+        return path6.resolve(this._settings.cwd, filepath);
       }
       _makeEntry(stats, pattern) {
         const entry = {
@@ -5015,9 +5015,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve(stats) : reject(error);
+            return error === null ? resolve2(stats) : reject(error);
           });
         });
       }
@@ -5044,10 +5044,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve(entries);
+              resolve2(entries);
             } else {
               reject(error);
             }
@@ -5057,10 +5057,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve(entries));
+          stream.once("end", () => resolve2(entries));
         });
       }
     };
@@ -5385,7 +5385,7 @@ var require_provider = __commonJS({
   "../../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var path3 = require("path");
+    var path6 = require("path");
     var deep_1 = require_deep();
     var entry_1 = require_entry();
     var error_1 = require_error();
@@ -5402,7 +5402,7 @@ var require_provider = __commonJS({
         this.entryTransformer = new entry_2.default(this._settings);
       }
       _getRootDirectory(task) {
-        return path3.resolve(this._settings.cwd, task.base);
+        return path6.resolve(this._settings.cwd, task.base);
       }
       _getReaderOptions(task) {
         const basePath = task.base === "." ? "" : task.base;
@@ -5595,16 +5595,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs3 = require("fs");
+    var fs6 = require("fs");
     var os2 = require("os");
     var CPU_COUNT = Math.max(os2.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs3.lstat,
-      lstatSync: fs3.lstatSync,
-      stat: fs3.stat,
-      statSync: fs3.statSync,
-      readdir: fs3.readdir,
-      readdirSync: fs3.readdirSync
+      lstat: fs6.lstat,
+      lstatSync: fs6.lstatSync,
+      stat: fs6.stat,
+      statSync: fs6.statSync,
+      readdir: fs6.readdir,
+      readdirSync: fs6.readdirSync
     };
     var Settings = class {
       static {
@@ -5777,10 +5777,10 @@ __export(FileRunner_exports, {
 });
 module.exports = __toCommonJS(FileRunner_exports);
 var import_events = require("events");
-var fs2 = __toESM(require("fs"));
-var fsp = __toESM(require("fs/promises"));
+var fs5 = __toESM(require("fs"));
+var fsp4 = __toESM(require("fs/promises"));
 var os = __toESM(require("os"));
-var path2 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 
 // ../discovery/dist/index.js
 var import_fast_glob = __toESM(require_out4(), 1);
@@ -5994,6 +5994,564 @@ __name(discoverFilesInDirs, "discoverFilesInDirs");
 
 // src/runner/FileRunner.ts
 var import_engines = require("@vibecheck/engines");
+
+// src/cache/ScanCache.ts
+var fs2 = __toESM(require("fs"));
+var fsp = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var CACHE_VERSION = 1;
+var CACHE_FILENAME = "scan-cache.json";
+var CACHE_TTL_MS2 = 7 * 24 * 60 * 60 * 1e3;
+var MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024;
+var PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var ENGINE_VERSION = "3.0.0";
+var ScanCache = class {
+  static {
+    __name(this, "ScanCache");
+  }
+  _cachePath;
+  _entries = /* @__PURE__ */ new Map();
+  _metadata;
+  _dirty = false;
+  _hits = 0;
+  _misses = 0;
+  constructor(workspaceRoot) {
+    const cacheDir = path2.join(workspaceRoot, ".vibecheck");
+    this._cachePath = path2.join(cacheDir, CACHE_FILENAME);
+    this._metadata = {
+      version: CACHE_VERSION,
+      createdAt: Date.now(),
+      lastPruned: Date.now(),
+      totalEntries: 0,
+      totalSizeBytes: 0
+    };
+  }
+  /**
+   * Load cache from disk. Non-blocking — returns immediately if file doesn't exist.
+   */
+  async load() {
+    try {
+      if (!fs2.existsSync(this._cachePath)) return;
+      const raw = await fsp.readFile(this._cachePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.metadata.version !== CACHE_VERSION) {
+        this._entries.clear();
+        this._dirty = true;
+        return;
+      }
+      this._metadata = data.metadata;
+      this._entries = new Map(Object.entries(data.entries));
+      if (Date.now() - this._metadata.lastPruned > PRUNE_INTERVAL_MS) {
+        this._prune();
+      }
+    } catch (err) {
+      this._entries.clear();
+      this._dirty = true;
+    }
+  }
+  /**
+   * Get cached result for a file. Returns null if not cached or invalid.
+   */
+  get(relativePath, contentHash, confidenceThreshold) {
+    const entry = this._entries.get(relativePath);
+    if (!entry) {
+      this._misses++;
+      return null;
+    }
+    if (entry.contentHash !== contentHash) {
+      this._entries.delete(relativePath);
+      this._dirty = true;
+      this._misses++;
+      return null;
+    }
+    if (entry.engineVersion !== ENGINE_VERSION) {
+      this._entries.delete(relativePath);
+      this._dirty = true;
+      this._misses++;
+      return null;
+    }
+    if (entry.confidenceThreshold !== confidenceThreshold) {
+      this._entries.delete(relativePath);
+      this._dirty = true;
+      this._misses++;
+      return null;
+    }
+    if (Date.now() - entry.cachedAt > CACHE_TTL_MS2) {
+      this._entries.delete(relativePath);
+      this._dirty = true;
+      this._misses++;
+      return null;
+    }
+    this._hits++;
+    return entry;
+  }
+  /**
+   * Store scan result in cache.
+   */
+  set(relativePath, contentHash, findings, confidenceThreshold, fileSizeBytes, scanDurationMs) {
+    const entry = {
+      file: relativePath,
+      contentHash,
+      findings,
+      cachedAt: Date.now(),
+      engineVersion: ENGINE_VERSION,
+      confidenceThreshold,
+      fileSizeBytes,
+      scanDurationMs
+    };
+    this._entries.set(relativePath, entry);
+    this._dirty = true;
+  }
+  /**
+   * Invalidate a specific file (e.g., when user edits it).
+   */
+  invalidate(relativePath) {
+    if (this._entries.delete(relativePath)) {
+      this._dirty = true;
+    }
+  }
+  /**
+   * Clear entire cache.
+   */
+  clear() {
+    this._entries.clear();
+    this._dirty = true;
+    this._hits = 0;
+    this._misses = 0;
+  }
+  /**
+   * Persist cache to disk. Only writes if dirty.
+   */
+  async save() {
+    if (!this._dirty) return;
+    try {
+      const cacheDir = path2.dirname(this._cachePath);
+      if (!fs2.existsSync(cacheDir)) {
+        await fsp.mkdir(cacheDir, { recursive: true });
+      }
+      this._metadata.totalEntries = this._entries.size;
+      this._metadata.lastPruned = Date.now();
+      const data = {
+        metadata: this._metadata,
+        entries: Object.fromEntries(this._entries)
+      };
+      const json = JSON.stringify(data, null, 2);
+      this._metadata.totalSizeBytes = Buffer.byteLength(json, "utf-8");
+      if (this._metadata.totalSizeBytes > MAX_CACHE_SIZE_BYTES) {
+        this._prune();
+        const prunedData = {
+          metadata: this._metadata,
+          entries: Object.fromEntries(this._entries)
+        };
+        await fsp.writeFile(this._cachePath, JSON.stringify(prunedData, null, 2), "utf-8");
+      } else {
+        await fsp.writeFile(this._cachePath, json, "utf-8");
+      }
+      this._dirty = false;
+    } catch (err) {
+      process.stderr.write(`[vibecheck] Cache write failed: ${err.message}
+`);
+    }
+  }
+  /**
+   * Get cache statistics.
+   */
+  getStats() {
+    const total = this._hits + this._misses;
+    const hitRate = total > 0 ? this._hits / total : 0;
+    let oldestAge = 0;
+    let newestAge = Infinity;
+    const now = Date.now();
+    for (const entry of this._entries.values()) {
+      const age = now - entry.cachedAt;
+      if (age > oldestAge) oldestAge = age;
+      if (age < newestAge) newestAge = age;
+    }
+    return {
+      hits: this._hits,
+      misses: this._misses,
+      hitRate,
+      totalEntries: this._entries.size,
+      cacheSizeBytes: this._metadata.totalSizeBytes,
+      oldestEntryAge: oldestAge,
+      newestEntryAge: newestAge === Infinity ? 0 : newestAge
+    };
+  }
+  /**
+   * Prune old entries to keep cache size under limit.
+   * Removes oldest entries first (LRU-style).
+   */
+  _prune() {
+    const now = Date.now();
+    const entries = [...this._entries.entries()];
+    for (const [key, entry] of entries) {
+      if (now - entry.cachedAt > CACHE_TTL_MS2) {
+        this._entries.delete(key);
+      }
+    }
+    const remaining = [...this._entries.entries()];
+    remaining.sort((a, b) => a[1].cachedAt - b[1].cachedAt);
+    const avgEntrySize = 2048;
+    const maxEntries = Math.floor(MAX_CACHE_SIZE_BYTES / avgEntrySize);
+    if (remaining.length > maxEntries) {
+      const toRemove = remaining.length - maxEntries;
+      for (let i = 0; i < toRemove; i++) {
+        this._entries.delete(remaining[i][0]);
+      }
+    }
+    this._metadata.lastPruned = now;
+    this._dirty = true;
+  }
+};
+
+// src/cache/ChangeDetector.ts
+var fs3 = __toESM(require("fs"));
+var fsp2 = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_util = require("util");
+var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+var ChangeDetector = class {
+  static {
+    __name(this, "ChangeDetector");
+  }
+  _workspaceRoot;
+  constructor(workspaceRoot) {
+    this._workspaceRoot = workspaceRoot;
+  }
+  /**
+   * Detect changed files using best available strategy.
+   */
+  async detect(options) {
+    const { allFiles, lastScanTime, forceFull } = options;
+    if (forceFull) {
+      return {
+        changedFiles: new Set(allFiles),
+        allFiles,
+        strategy: "full"
+      };
+    }
+    if (!lastScanTime) {
+      return {
+        changedFiles: new Set(allFiles),
+        allFiles,
+        strategy: "full"
+      };
+    }
+    const gitResult = await this._detectViaGit(allFiles, lastScanTime);
+    if (gitResult) return gitResult;
+    const mtimeResult = await this._detectViaMtime(allFiles, lastScanTime);
+    return mtimeResult;
+  }
+  /**
+   * Git-based change detection.
+   * Returns files changed since last scan timestamp.
+   */
+  async _detectViaGit(allFiles, lastScanTime) {
+    try {
+      const { stdout: gitRoot } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: this._workspaceRoot,
+        timeout: 2e3
+      });
+      if (!gitRoot.trim()) return null;
+      const sinceDate = new Date(lastScanTime).toISOString();
+      const { stdout: diffOutput } = await execFileAsync(
+        "git",
+        ["diff", "--name-only", `--since=${sinceDate}`, "HEAD"],
+        {
+          cwd: this._workspaceRoot,
+          timeout: 5e3
+        }
+      );
+      const { stdout: statusOutput } = await execFileAsync(
+        "git",
+        ["status", "--porcelain", "--untracked-files=all"],
+        {
+          cwd: this._workspaceRoot,
+          timeout: 5e3
+        }
+      );
+      const changedPaths = /* @__PURE__ */ new Set();
+      for (const line of diffOutput.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          const absPath = path3.resolve(this._workspaceRoot, trimmed);
+          changedPaths.add(absPath);
+        }
+      }
+      for (const line of statusOutput.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const filename = trimmed.slice(3);
+        if (filename) {
+          const absPath = path3.resolve(this._workspaceRoot, filename);
+          changedPaths.add(absPath);
+        }
+      }
+      const allFilesSet = new Set(allFiles);
+      const changedFiles = new Set(
+        [...changedPaths].filter((f) => allFilesSet.has(f))
+      );
+      if (changedFiles.size === 0) {
+        const newFiles = allFiles.filter((f) => {
+          try {
+            const stat4 = fs3.statSync(f);
+            return stat4.mtimeMs > lastScanTime;
+          } catch {
+            return false;
+          }
+        });
+        for (const f of newFiles) changedFiles.add(f);
+      }
+      return {
+        changedFiles,
+        allFiles,
+        strategy: "git-diff",
+        lastScanTime
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+  /**
+   * Mtime-based change detection (fallback).
+   * Returns files modified after last scan timestamp.
+   */
+  async _detectViaMtime(allFiles, lastScanTime) {
+    const changedFiles = /* @__PURE__ */ new Set();
+    await Promise.all(
+      allFiles.map(async (file) => {
+        try {
+          const stat4 = await fsp2.stat(file);
+          if (stat4.mtimeMs > lastScanTime) {
+            changedFiles.add(file);
+          }
+        } catch {
+        }
+      })
+    );
+    return {
+      changedFiles,
+      allFiles,
+      strategy: "mtime",
+      lastScanTime
+    };
+  }
+  /**
+   * Get list of files changed in git working directory (staged + unstaged).
+   * Used for `vibecheck scan staged` and watch mode.
+   */
+  async getGitChangedFiles() {
+    try {
+      const { stdout } = await execFileAsync(
+        "git",
+        ["status", "--porcelain", "--untracked-files=all"],
+        {
+          cwd: this._workspaceRoot,
+          timeout: 5e3
+        }
+      );
+      const files = [];
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const filename = trimmed.slice(3);
+        if (filename) {
+          const absPath = path3.resolve(this._workspaceRoot, filename);
+          files.push(absPath);
+        }
+      }
+      return files;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get list of staged files only.
+   */
+  async getGitStagedFiles() {
+    try {
+      const { stdout } = await execFileAsync(
+        "git",
+        ["diff", "--cached", "--name-only"],
+        {
+          cwd: this._workspaceRoot,
+          timeout: 5e3
+        }
+      );
+      const files = [];
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          const absPath = path3.resolve(this._workspaceRoot, trimmed);
+          files.push(absPath);
+        }
+      }
+      return files;
+    } catch {
+      return [];
+    }
+  }
+};
+async function saveLastScanTime(workspaceRoot) {
+  const timestampFile = path3.join(workspaceRoot, ".vibecheck", "last-scan.txt");
+  const cacheDir = path3.dirname(timestampFile);
+  try {
+    if (!fs3.existsSync(cacheDir)) {
+      await fsp2.mkdir(cacheDir, { recursive: true });
+    }
+    await fsp2.writeFile(timestampFile, Date.now().toString(), "utf-8");
+  } catch {
+  }
+}
+__name(saveLastScanTime, "saveLastScanTime");
+async function loadLastScanTime(workspaceRoot) {
+  const timestampFile = path3.join(workspaceRoot, ".vibecheck", "last-scan.txt");
+  try {
+    if (!fs3.existsSync(timestampFile)) return void 0;
+    const content = await fsp2.readFile(timestampFile, "utf-8");
+    const timestamp = parseInt(content.trim(), 10);
+    return isNaN(timestamp) ? void 0 : timestamp;
+  } catch {
+    return void 0;
+  }
+}
+__name(loadLastScanTime, "loadLastScanTime");
+
+// src/cache/PerformanceMetrics.ts
+var fs4 = __toESM(require("fs"));
+var fsp3 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
+var PerformanceTracker = class {
+  static {
+    __name(this, "PerformanceTracker");
+  }
+  _startTime = 0;
+  _discoveryStartTime = 0;
+  _discoveryEndTime = 0;
+  _scanStartTime = 0;
+  _scanEndTime = 0;
+  _workspaceRoot;
+  _historyPath;
+  constructor(workspaceRoot) {
+    this._workspaceRoot = workspaceRoot;
+    this._historyPath = path4.join(workspaceRoot, ".vibecheck", "perf-history.json");
+  }
+  /**
+   * Mark CLI startup complete.
+   */
+  markStartup() {
+    this._startTime = performance.now();
+  }
+  /**
+   * Mark discovery phase start.
+   */
+  markDiscoveryStart() {
+    this._discoveryStartTime = performance.now();
+  }
+  /**
+   * Mark discovery phase end.
+   */
+  markDiscoveryEnd() {
+    this._discoveryEndTime = performance.now();
+  }
+  /**
+   * Mark scan phase start.
+   */
+  markScanStart() {
+    this._scanStartTime = performance.now();
+  }
+  /**
+   * Mark scan phase end.
+   */
+  markScanEnd() {
+    this._scanEndTime = performance.now();
+  }
+  /**
+   * Create performance snapshot from current metrics.
+   */
+  createSnapshot(filesScanned, cacheHits, cacheMisses, engineLatencies) {
+    const now = performance.now();
+    const startupMs = this._discoveryStartTime - this._startTime;
+    const discoveryMs = this._discoveryEndTime - this._discoveryStartTime;
+    const totalScanMs = this._scanEndTime - this._scanStartTime;
+    const throughput = totalScanMs > 0 ? filesScanned / totalScanMs * 1e3 : 0;
+    const cacheTotal = cacheHits + cacheMisses;
+    const cacheHitRate = cacheTotal > 0 ? cacheHits / cacheTotal : 0;
+    const memoryUsageMB = process.memoryUsage().heapUsed / 1024 / 1024;
+    return {
+      timestamp: Date.now(),
+      startupMs: Math.round(startupMs),
+      discoveryMs: Math.round(discoveryMs),
+      totalScanMs: Math.round(totalScanMs),
+      filesScanned,
+      throughput: Math.round(throughput * 100) / 100,
+      cacheHitRate: Math.round(cacheHitRate * 100) / 100,
+      cacheHits,
+      cacheMisses,
+      engineLatencies,
+      memoryUsageMB: Math.round(memoryUsageMB * 100) / 100
+    };
+  }
+  /**
+   * Save snapshot to performance history.
+   */
+  async saveSnapshot(snapshot) {
+    try {
+      const cacheDir = path4.dirname(this._historyPath);
+      if (!fs4.existsSync(cacheDir)) {
+        await fsp3.mkdir(cacheDir, { recursive: true });
+      }
+      let history;
+      if (fs4.existsSync(this._historyPath)) {
+        const raw = await fsp3.readFile(this._historyPath, "utf-8");
+        history = JSON.parse(raw);
+      } else {
+        history = { snapshots: [], maxSnapshots: 10 };
+      }
+      history.snapshots.push(snapshot);
+      if (history.snapshots.length > history.maxSnapshots) {
+        history.snapshots = history.snapshots.slice(-history.maxSnapshots);
+      }
+      await fsp3.writeFile(this._historyPath, JSON.stringify(history, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  /**
+   * Load performance history from disk.
+   */
+  async loadHistory() {
+    try {
+      if (!fs4.existsSync(this._historyPath)) return null;
+      const raw = await fsp3.readFile(this._historyPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get performance trend (last N runs).
+   */
+  async getTrend(metric, count = 5) {
+    const history = await this.loadHistory();
+    if (!history) return [];
+    return history.snapshots.slice(-count).map((s) => s[metric]).filter((v) => typeof v === "number");
+  }
+  /**
+   * Detect performance regression.
+   * Returns true if latest run is significantly slower than average.
+   */
+  async detectRegression(threshold = 0.2) {
+    const trend = await this.getTrend("totalScanMs", 5);
+    if (trend.length < 3) return false;
+    const latest = trend[trend.length - 1];
+    const previous = trend.slice(0, -1);
+    const avg = previous.reduce((sum, v) => sum + v, 0) / previous.length;
+    return latest > avg * (1 + threshold);
+  }
+};
+
+// src/runner/FileRunner.ts
 var import_engines2 = require("@vibecheck/engines");
 var DEFAULT_ENGINE_THRESHOLDS = {
   env_var: 0.72,
@@ -6023,16 +6581,16 @@ var IgnoreFilter = class _IgnoreFilter {
   _cache = /* @__PURE__ */ new Map();
   static _CACHE_MAX = 4096;
   constructor(workspaceRoot, ignoreFile, respectGitignore = true) {
-    const vcIgnorePath = ignoreFile ?? path2.join(workspaceRoot, ".vibecheckignore");
+    const vcIgnorePath = ignoreFile ?? path5.join(workspaceRoot, ".vibecheckignore");
     this._loadFile(vcIgnorePath);
     if (respectGitignore) {
-      this._loadFile(path2.join(workspaceRoot, ".gitignore"));
+      this._loadFile(path5.join(workspaceRoot, ".gitignore"));
     }
   }
   _loadFile(filePath) {
     try {
-      if (!fs2.existsSync(filePath)) return;
-      const content = fs2.readFileSync(filePath, "utf-8");
+      if (!fs5.existsSync(filePath)) return;
+      const content = fs5.readFileSync(filePath, "utf-8");
       for (const raw of content.split("\n")) {
         const line = raw.replace(/#.*$/, "").trim();
         if (!line) continue;
@@ -6124,11 +6682,11 @@ async function discoverFiles2(targets, workspaceRoot, filter, signal) {
   for (const target of targets) {
     if (signal?.aborted) break;
     try {
-      const stat3 = await fsp.stat(target);
-      if (stat3.isDirectory()) {
+      const stat4 = await fsp4.stat(target);
+      if (stat4.isDirectory()) {
         dirsToScan.push(target);
-      } else if (stat3.isFile() && CHECKED_EXTS.has(path2.extname(target).toLowerCase())) {
-        const rel = path2.relative(workspaceRoot, target).replace(/\\/g, "/");
+      } else if (stat4.isFile() && CHECKED_EXTS.has(path5.extname(target).toLowerCase())) {
+        const rel = path5.relative(workspaceRoot, target).replace(/\\/g, "/");
         if (!filter.isIgnored(rel)) explicitFiles.push(target);
       }
     } catch (err) {
@@ -6145,7 +6703,7 @@ async function discoverFiles2(targets, workspaceRoot, filter, signal) {
       rootDir: workspaceRoot
     });
     return result.files.filter((f) => {
-      const rel = path2.relative(workspaceRoot, f).replace(/\\/g, "/");
+      const rel = path5.relative(workspaceRoot, f).replace(/\\/g, "/");
       return !filter.isIgnored(rel);
     });
   }
@@ -6173,14 +6731,14 @@ async function discoverFiles2(targets, workspaceRoot, filter, signal) {
     discoveredFiles.sort();
   }
   const filtered = discoveredFiles.filter((f) => {
-    const rel = path2.relative(workspaceRoot, f).replace(/\\/g, "/");
+    const rel = path5.relative(workspaceRoot, f).replace(/\\/g, "/");
     return !filter.isIgnored(rel);
   });
   return [.../* @__PURE__ */ new Set([...explicitFiles, ...filtered])];
 }
 __name(discoverFiles2, "discoverFiles");
 function makeDelta(filePath, text) {
-  const ext = path2.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   const lines = text.split("\n");
   return {
     documentUri: filePath,
@@ -6309,7 +6867,11 @@ async function runOnFiles(targets, options) {
     files: explicitFiles,
     allowlist = {},
     engineToggles = null,
-    suppressRules = []
+    suppressRules = [],
+    enableCache = true,
+    enableIncremental = true,
+    clearCache = false,
+    trackPerformance = false
   } = options;
   const suppressRulesSet = new Set(suppressRules.map((r) => r.toUpperCase()));
   const getThreshold = /* @__PURE__ */ __name((engineId) => engineConfidenceThresholds[engineId] ?? DEFAULT_ENGINE_THRESHOLDS[engineId] ?? confidenceThreshold, "getThreshold");
@@ -6332,6 +6894,15 @@ async function runOnFiles(targets, options) {
       signal.addEventListener("abort", () => ac.abort(), { once: true });
     }
   }
+  const scanCache = enableCache ? new ScanCache(workspaceRoot) : null;
+  const changeDetector = enableIncremental ? new ChangeDetector(workspaceRoot) : null;
+  const perfTracker = trackPerformance ? new PerformanceTracker(workspaceRoot) : null;
+  if (scanCache && clearCache) {
+    await scanCache.clear();
+  }
+  if (perfTracker) {
+    perfTracker.markStartup();
+  }
   const internalSignal = ac.signal;
   (0, import_events.setMaxListeners)(64, internalSignal);
   const emitProgress = /* @__PURE__ */ __name((patch) => {
@@ -6345,13 +6916,31 @@ async function runOnFiles(targets, options) {
       ...patch
     });
   }, "emitProgress");
+  if (perfTracker) {
+    perfTracker.markDiscoveryStart();
+  }
   emitProgress({ phase: "discovery" });
   const filter = new IgnoreFilter(workspaceRoot, ignoreFile, respectGitignore);
-  const files = explicitFiles ? explicitFiles.filter((f) => {
-    const ext = path2.extname(f).toLowerCase();
-    const rel = path2.relative(workspaceRoot, f).replace(/\\/g, "/");
+  let files = explicitFiles ? explicitFiles.filter((f) => {
+    const ext = path5.extname(f).toLowerCase();
+    const rel = path5.relative(workspaceRoot, f).replace(/\\/g, "/");
     return CHECKED_EXTS.has(ext) && !filter.isIgnored(rel);
   }) : await discoverFiles2(targets, workspaceRoot, filter, internalSignal);
+  if (perfTracker) {
+    perfTracker.markDiscoveryEnd();
+  }
+  if (changeDetector && files.length > 0) {
+    const lastScanTime = await loadLastScanTime(workspaceRoot);
+    const changeResult = await changeDetector.detect({
+      workspaceRoot,
+      allFiles: files,
+      lastScanTime,
+      forceFull: false
+    });
+    if (changeResult.strategy !== "full") {
+      files = files.filter((f) => changeResult.changedFiles.has(f));
+    }
+  }
   if (internalSignal.aborted) {
     return { files: [], summary: buildSummary([], 0, performance.now() - startTime) };
   }
@@ -6362,6 +6951,9 @@ async function runOnFiles(targets, options) {
       summary: buildSummary([], 0, performance.now() - startTime)
     };
   }
+  if (perfTracker) {
+    perfTracker.markScanStart();
+  }
   emitProgress({ phase: "activating", filesDiscovered: files.length });
   const allowlistEnvVars = allowlist.envVars;
   const truthpack = await (0, import_engines.loadTruthpack)(workspaceRoot);
@@ -6375,7 +6967,7 @@ async function runOnFiles(targets, options) {
     return loader;
   })();
   const ghostRouteIndex = truthpack ? (0, import_engines.truthpackToRouteIndex)(truthpack.routes, workspaceRoot) : void 0;
-  const sdkMapsDir = path2.join(__dirname, "..", "engines", "sdk-maps");
+  const sdkMapsDir = path5.join(__dirname, "..", "engines", "sdk-maps");
   const registry = (0, import_engines.createDefaultRegistry)();
   registry.register(
     new import_engines.EnvVarEngine(envIndex, {
@@ -6396,7 +6988,7 @@ async function runOnFiles(targets, options) {
   );
   const phantomConfig = {
     confidenceThreshold: getThreshold("phantom_dep"),
-    registryCachePath: path2.join(workspaceRoot, ".vibecheck", "registry-cache.json")
+    registryCachePath: path5.join(workspaceRoot, ".vibecheck", "registry-cache.json")
   };
   registry.register(new import_engines.PhantomDepEngine(workspaceRoot, phantomConfig), {
     timeoutMs: options.engineTimeouts?.["phantom-dep"] ?? 100,
@@ -6443,6 +7035,9 @@ async function runOnFiles(targets, options) {
   }
   let scannedCount = 0;
   let findingsCount = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  const engineLatencyMap = /* @__PURE__ */ new Map();
   const fileResults = await mapPool(
     files,
     concurrency,
@@ -6450,29 +7045,56 @@ async function runOnFiles(targets, options) {
       if (internalSignal.aborted) {
         return makeSkippedResult(file, workspaceRoot, "Scan aborted");
       }
-      let stat3;
+      let stat4;
       try {
-        stat3 = await fsp.stat(file);
+        stat4 = await fsp4.stat(file);
       } catch (err) {
         return makeSkippedResult(file, workspaceRoot, `Stat error: ${err.message}`);
       }
-      if (stat3.size > MAX_FILE_SIZE) {
-        return makeSkippedResult(file, workspaceRoot, `File too large (${Math.round(stat3.size / 1024)}KB > 1MB limit)`);
+      if (stat4.size > MAX_FILE_SIZE) {
+        return makeSkippedResult(file, workspaceRoot, `File too large (${Math.round(stat4.size / 1024)}KB > 1MB limit)`);
       }
-      if (stat3.size === 0) {
+      if (stat4.size === 0) {
         return makeSkippedResult(file, workspaceRoot, "Empty file");
       }
       let text;
       try {
-        text = await fsp.readFile(file, "utf-8");
+        text = await fsp4.readFile(file, "utf-8");
       } catch (err) {
         return makeSkippedResult(file, workspaceRoot, `Read error: ${err.message}`);
       }
       if (text.trim().length === 0) {
         return makeSkippedResult(file, workspaceRoot, "Empty file");
       }
+      if (scanCache) {
+        const cached = await scanCache.get(file, text, confidenceThreshold);
+        if (cached) {
+          cacheHits++;
+          scannedCount++;
+          findingsCount += cached.findings.length;
+          emitProgress({
+            phase: "scanning",
+            filesDiscovered: files.length,
+            filesScanned: scannedCount,
+            filesTotal: files.length,
+            findingsSoFar: findingsCount,
+            currentFile: path5.relative(workspaceRoot, file).replace(/\\/g, "/")
+          });
+          const rel2 = path5.relative(workspaceRoot, file).replace(/\\/g, "/");
+          return {
+            file,
+            relativePath: rel2,
+            findings: cached.findings,
+            engineMetrics: [],
+            scanDurationMs: 0,
+            fileSizeBytes: stat4.size,
+            skipped: false
+          };
+        }
+        cacheMisses++;
+      }
       const delta = makeDelta(file, text);
-      const fileExt = path2.extname(file).toLowerCase();
+      const fileExt = path5.extname(file).toLowerCase();
       const fileStart = performance.now();
       const applicableSlots = registry.getActive().filter((s) => {
         const exts = s.engine.supportedExtensions ?? s.extensions;
@@ -6505,22 +7127,33 @@ async function runOnFiles(targets, options) {
       }
       scannedCount++;
       findingsCount += deduped.length;
+      const scanDurationMs = Math.round(performance.now() - fileStart);
+      if (scanCache) {
+        await scanCache.set(file, text, deduped, confidenceThreshold, stat4.size, scanDurationMs);
+      }
+      for (const metric of metrics) {
+        if (metric.status === "ok") {
+          const latencies = engineLatencyMap.get(metric.engineId) ?? [];
+          latencies.push(metric.durationMs);
+          engineLatencyMap.set(metric.engineId, latencies);
+        }
+      }
       emitProgress({
         phase: "scanning",
         filesDiscovered: files.length,
         filesScanned: scannedCount,
         filesTotal: files.length,
         findingsSoFar: findingsCount,
-        currentFile: path2.relative(workspaceRoot, file).replace(/\\/g, "/")
+        currentFile: path5.relative(workspaceRoot, file).replace(/\\/g, "/")
       });
-      const rel = path2.relative(workspaceRoot, file).replace(/\\/g, "/");
+      const rel = path5.relative(workspaceRoot, file).replace(/\\/g, "/");
       return {
         file,
         relativePath: rel,
         findings: deduped,
         engineMetrics: metrics,
-        scanDurationMs: Math.round(performance.now() - fileStart),
-        fileSizeBytes: stat3.size,
+        scanDurationMs,
+        fileSizeBytes: stat4.size,
         skipped: false
       };
     },
@@ -6530,6 +7163,27 @@ async function runOnFiles(targets, options) {
   registry.dispose();
   const totalMs = performance.now() - startTime;
   const summary = buildSummary(fileResults, files.length, totalMs);
+  if (perfTracker) {
+    perfTracker.markScanEnd();
+    const engineLatencies = {};
+    for (const [engineId, latencies] of engineLatencyMap.entries()) {
+      if (latencies.length > 0) {
+        const sorted = [...latencies].sort((a, b) => a - b);
+        const p95Idx = Math.ceil(sorted.length * 0.95) - 1;
+        engineLatencies[engineId] = sorted[Math.max(0, p95Idx)] ?? 0;
+      }
+    }
+    const snapshot = perfTracker.createSnapshot(
+      summary.filesScanned,
+      cacheHits,
+      cacheMisses,
+      engineLatencies
+    );
+    await perfTracker.saveSnapshot(snapshot);
+  }
+  if (changeDetector) {
+    await saveLastScanTime(workspaceRoot);
+  }
   emitProgress({
     phase: "complete",
     filesDiscovered: files.length,
@@ -6576,7 +7230,7 @@ __name(filterInlineSuppressions, "filterInlineSuppressions");
 function makeSkippedResult(file, workspaceRoot, reason) {
   return {
     file,
-    relativePath: path2.relative(workspaceRoot, file).replace(/\\/g, "/"),
+    relativePath: path5.relative(workspaceRoot, file).replace(/\\/g, "/"),
     findings: [],
     engineMetrics: [],
     scanDurationMs: 0,