grepmax 0.26.63 → 0.26.64

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.63",
+      "version": "0.26.64",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/README.md

@@ -240,7 +240,7 @@ gmax status                   # See all projects + watcher status
 
 Adding or indexing a project can start the daemon automatically. MCP acquires primary-project watch leases lazily when an index-reading tool is used; discovery and catalog listing start no background work. It shuts down after 4 hours of inactivity, and hands off to a fresh daemon after 24 hours or once its memory footprint passes 2.5 GB. File-change batches are processed on up to four worker processes by default, added only when work backs up, with one kept free for searches; full-table compaction and new FTS/ANN index builds are disabled by containment. Existing indexes remain readable. Host safety stops persist across restart and block heavy operations.
 
-`gmax watch status` reports failed files, native watcher recovery or polling, dropped-event counts, and the last complete filesystem reconciliation. Polling scans run every five minutes, so recent edits can lag. Search and MCP responses retain health warnings even after the file queue drains. A complete reconciliation means the filesystem scan completed; queued embedding work can still be pending.
+`gmax watch status` reports failed files, native watcher recovery or polling, dropped-event counts, and the last complete filesystem reconciliation. FSEvents dropped-event warnings keep the native stream attached and preserve the accompanying events. A reconciliation covers the gap; repeated warnings coalesce into one later scan, with a 30-second scan interval. Recovery stays visible until a complete scan covers the latest gap. Other backend errors still trigger subscription recovery; repeated terminal failures fall back to five-minute polling, where recent edits can lag. Search and MCP responses retain health warnings even after the file queue drains. A complete reconciliation means the filesystem scan completed; queued embedding work can still be pending.
 
 Live filesystem edits take priority over background catchup and cleanup. Background batches dispatch one file at a time, with at most four catchup files or 50 cleanup paths. They yield between files when a live edit arrives or the two-second dispatch window is reached; an active file or store commit finishes before yielding. Catchup and cleanup alternate, and one background file is admitted after three consecutive live batches so cleanup continues during sustained editing. Existing retry backoff and worker limits remain in effect.
 

package/dist/lib/daemon/watcher-manager.js

@@ -57,6 +57,7 @@ const cache_coherence_1 = require("../index/cache-coherence");
 const file_policy_1 = require("../index/file-policy");
 const walker_1 = require("../index/walker");
 const watcher_1 = require("../index/watcher");
+const watcher_errors_1 = require("../index/watcher-errors");
 const watcher_ignore_1 = require("../index/watcher-ignore");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
@@ -68,7 +69,7 @@ const watcher_store_1 = require("../utils/watcher-store");
 // overflows has passed. Probe often; a failed probe just drops back to polling.
 const FSEVENTS_RECOVERY_INTERVAL_MS = 15 * 60 * 1000;
 const FSEVENTS_HEALTH_WINDOW_MS = 5 * 60 * 1000; // 5 min of quiet = "healthy"
-// Overflows arrive in bursts (a build, a checkout, a venv install). Every
+// Terminal subscription failures can arrive in bursts. Every
 // recovery inside this window folds into one deferred catchup scan instead of
 // each rescanning the project (~25s on a 26k-file tree) or skipping outright
 // and leaving its drop window uncovered.
@@ -104,18 +105,21 @@ class WatcherManager {
         this.pollIntervals = new Map();
         this.pollRecoveryTimers = new Map();
         this.recoveryTimeouts = new Map();
-        this.lastOverflowMs = new Map();
+        this.lastWatcherFailureMs = new Map();
         this.lastWatcherErrorLogMs = new Map();
         this.overflowCounts = new Map();
         this.reconciledAt = new Map();
         this.catchupDurations = new Map();
         this.lastCatchupEndMs = new Map();
+        this.lastCatchupStartMs = new Map();
+        this.overflowPendingRoots = new Set();
         this.deferredCatchups = new Map();
         this.catchups = new Map();
         this.degradedRoots = new Set();
         this.terminalFailures = new Map();
         this.watchLifecycles = new Map();
         this.subscriptionUpdates = new Map();
+        this.watcherGenerations = new Map();
     }
     health(root) {
         var _a;
@@ -126,7 +130,8 @@ class WatcherManager {
             watcherMode: this.pollIntervals.has(root)
                 ? "polling"
                 : this.pendingOps.has(`recover:${root}`) ||
-                    this.deferredCatchups.has(root)
+                    this.deferredCatchups.has(root) ||
+                    this.overflowPendingRoots.has(root)
                     ? "recovering"
                     : "native",
             catchupRunning: this.catchups.has(root),
@@ -250,7 +255,7 @@ class WatcherManager {
                     const name = path.basename(root);
                     console.error(`[daemon:${name}] Subscribe failed at startup (${err instanceof Error ? err.message : err}) — switching to poll mode`);
                     this.watcherFailCount.set(root, 1000); // > MAX_WATCHER_RETRIES
-                    this.lastOverflowMs.set(root, Date.now());
+                    this.lastWatcherFailureMs.set(root, Date.now());
                     this.recoverWatcher(root, processor);
                 }
                 if (!ownsLifecycle())
@@ -311,6 +316,8 @@ class WatcherManager {
             if (this.deps.processors.get(root) !== processor ||
                 ((_b = (_a = this.deps).getShuttingDown) === null || _b === void 0 ? void 0 : _b.call(_a)))
                 return;
+            const generation = Symbol(root);
+            this.watcherGenerations.set(root, generation);
             // Unsubscribe existing watcher if any (e.g. during recovery)
             const existingSub = this.deps.subscriptions.get(root);
             if (existingSub) {
@@ -322,21 +329,30 @@ class WatcherManager {
             }
             const sub = yield watcher.subscribe(root, (err, events) => {
                 var _a, _b;
-                if (this.deps.processors.get(root) !== processor)
+                var _c, _d;
+                if (this.deps.processors.get(root) !== processor ||
+                    this.watcherGenerations.get(root) !== generation ||
+                    ((_b = (_a = this.deps).getShuttingDown) === null || _b === void 0 ? void 0 : _b.call(_a)))
                     return;
                 if (err) {
-                    this.overflowCounts.set(root, ((_a = this.overflowCounts.get(root)) !== null && _a !== void 0 ? _a : 0) + 1);
+                    this.overflowCounts.set(root, ((_c = this.overflowCounts.get(root)) !== null && _c !== void 0 ? _c : 0) + 1);
                     const now = Date.now();
                     if (!this.lastWatcherErrorLogMs.has(root) ||
                         now - this.lastWatcherErrorLogMs.get(root) >= 60000) {
                         this.lastWatcherErrorLogMs.set(root, now);
                         console.error(`[daemon:${name}] Watcher error (total=${this.overflowCounts.get(root)}):`, err);
                     }
-                    this.recoverWatcher(root, processor);
-                    return;
+                    if ((0, watcher_errors_1.isFSEventsGap)(err)) {
+                        this.overflowPendingRoots.add(root);
+                        this.requestOverflowCatchup(root, processor);
+                    }
+                    else {
+                        this.recoverWatcher(root, processor);
+                    }
                 }
-                // Only reset fail counter after sustained health (5min since last overflow)
-                const lastOverflow = (_b = this.lastOverflowMs.get(root)) !== null && _b !== void 0 ? _b : 0;
+                // Gaps do not kill Parcel's stream. Only a terminal failure should
+                // reset the subscription health window or prevent leaving poll mode.
+                const lastOverflow = (_d = this.lastWatcherFailureMs.get(root)) !== null && _d !== void 0 ? _d : 0;
                 if (Date.now() - lastOverflow > 5 * 60 * 1000) {
                     this.watcherFailCount.delete(root);
                 }
@@ -350,13 +366,30 @@ class WatcherManager {
                     ...(yield (0, watcher_ignore_1.readProjectWatcherIgnores)(root)),
                 ],
             });
-            if (this.deps.processors.get(root) !== processor) {
+            if (this.deps.processors.get(root) !== processor ||
+                this.watcherGenerations.get(root) !== generation) {
                 yield sub.unsubscribe();
                 return;
             }
             this.deps.subscriptions.set(root, sub);
         });
     }
+    requestOverflowCatchup(root, processor) {
+        const started = this.lastCatchupStartMs.get(root);
+        const remaining = started === undefined
+            ? 0
+            : watcher_errors_1.FSEVENTS_GAP_SCAN_INTERVAL_MS - (Date.now() - started);
+        // A gap during a scan may concern a path already visited. Keep one later
+        // scan rather than treating the current walk as coverage of that gap.
+        if (this.catchups.has(root) || remaining > 0) {
+            this.deferCatchup(root, processor, Math.max(remaining, watcher_errors_1.FSEVENTS_GAP_SCAN_INTERVAL_MS));
+            return;
+        }
+        this.cancelDeferredCatchup(root);
+        this.runCatchup(root, processor).catch((err) => {
+            console.error(`[daemon:${path.basename(root)}] Overflow catchup failed:`, err);
+        });
+    }
     recoverWatcher(root, processor) {
         var _a;
         const name = path.basename(root);
@@ -370,11 +403,11 @@ class WatcherManager {
         this.pendingOps.add(recoveryKey);
         const fails = ((_a = this.watcherFailCount.get(root)) !== null && _a !== void 0 ? _a : 0) + 1;
         this.watcherFailCount.set(root, fails);
-        this.lastOverflowMs.set(root, Date.now());
+        this.lastWatcherFailureMs.set(root, Date.now());
         const MAX_WATCHER_RETRIES = 3;
         const POLL_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
         if (fails > MAX_WATCHER_RETRIES) {
-            // FSEvents can't handle this project — degrade to periodic catchup scans
+            // Repeated terminal subscription failures require periodic catchup scans.
             // Always tear down the broken sub, even if poll mode is already active —
             // this can happen if a recovery attempt resubscribed successfully then
             // re-overflowed during the 5-min health window.
@@ -384,7 +417,7 @@ class WatcherManager {
                 this.deps.subscriptions.delete(root);
             }
             if (!this.pollIntervals.has(root)) {
-                console.error(`[daemon:${name}] FSEvents unreliable after ${fails} failures — switching to poll mode (${POLL_INTERVAL_MS / 60000}min interval)`);
+                console.error(`[daemon:${name}] Native watcher failed after ${fails} terminal errors — switching to poll mode (${POLL_INTERVAL_MS / 60000}min interval)`);
                 // Run an immediate catchup, then schedule periodic ones
                 this.runCatchup(root, processor).catch((err) => {
                     console.error(`[daemon:${name}] Poll catchup failed:`, err);
@@ -416,7 +449,7 @@ class WatcherManager {
         }
         // Backoff: wait before re-subscribing (3s, 6s, 12s)
         const delayMs = 3000 * Math.pow(2, (fails - 1));
-        console.error(`[daemon:${name}] Recovering watcher (attempt ${fails}/${MAX_WATCHER_RETRIES}, backoff ${delayMs}ms)...`);
+        console.error(`[daemon:${name}] Recovering failed watcher (attempt ${fails}/${MAX_WATCHER_RETRIES}, backoff ${delayMs}ms)...`);
         const timeout = setTimeout(() => {
             this.recoveryTimeouts.delete(root);
             if (this.deps.getShuttingDown() ||
@@ -520,14 +553,14 @@ class WatcherManager {
                     if (this.deps.processors.get(root) !== processor)
                         return;
                     // Wait one health window — if the new subscription survives without
-                    // another overflow, we consider it recovered and tear down poll mode.
+                    // another terminal failure, we consider it recovered and tear down poll mode.
                     yield abortableDelay(FSEVENTS_HEALTH_WINDOW_MS, lifecycle.signal);
                     if (this.deps.getShuttingDown() ||
                         this.deps.processors.get(root) !== processor)
                         return;
-                    const lastOverflow = (_a = this.lastOverflowMs.get(root)) !== null && _a !== void 0 ? _a : 0;
+                    const lastOverflow = (_a = this.lastWatcherFailureMs.get(root)) !== null && _a !== void 0 ? _a : 0;
                     if (Date.now() - lastOverflow < FSEVENTS_HEALTH_WINDOW_MS) {
-                        console.log(`[daemon:${name}] FSEvents recovery aborted — fresh overflow within health window, staying in poll mode`);
+                        console.log(`[daemon:${name}] FSEvents recovery aborted — terminal failure within health window, staying in poll mode`);
                         return; // recoverWatcher will have re-armed poll mode if needed
                     }
                     // Healthy — drop poll mode.
@@ -555,8 +588,9 @@ class WatcherManager {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
             var _d;
-            var _e;
+            var _e, _f, _g;
             const scanStart = Date.now();
+            const overflowCountAtStart = (_e = this.overflowCounts.get(root)) !== null && _e !== void 0 ? _e : 0;
             const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
             const metaCache = this.deps.getMetaCache();
             const vectorDb = this.deps.getVectorDb();
@@ -573,12 +607,12 @@ class WatcherManager {
             let skipped = 0;
             let debugSamples = 0;
             try {
-                for (var _f = true, _g = __asyncValues((0, walker_1.walk)(root, {
+                for (var _h = true, _j = __asyncValues((0, walker_1.walk)(root, {
                     policy: processor.filePolicy,
                     state: walkState,
-                })), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
-                    _c = _h.value;
-                    _f = false;
+                })), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
+                    _c = _k.value;
+                    _h = false;
                     const relPath = _c;
                     if (signal.aborted)
                         return false;
@@ -668,7 +702,7 @@ class WatcherManager {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -701,7 +735,7 @@ class WatcherManager {
             }
             else {
                 this.degradedRoots.delete(root);
-                const failedFiles = (_e = (_d = this.terminalFailures.get(root)) === null || _d === void 0 ? void 0 : _d.size) !== null && _e !== void 0 ? _e : 0;
+                const failedFiles = (_f = (_d = this.terminalFailures.get(root)) === null || _d === void 0 ? void 0 : _d.size) !== null && _f !== void 0 ? _f : 0;
                 (0, watcher_store_1.registerWatcher)(Object.assign({ pid: process.pid, projectRoot: root, startTime: Date.now(), status: this.isRootDegraded(root) ? "degraded" : "watching", lastHeartbeat: Date.now() }, (failedFiles > 0
                     ? { lastError: `${failedFiles} file(s) exhausted automatic retries` }
                     : {})));
@@ -717,8 +751,12 @@ class WatcherManager {
             const ended = Date.now();
             this.lastCatchupEndMs.set(root, ended);
             this.catchupDurations.set(root, ended - scanStart);
-            if (complete)
+            if (complete) {
                 this.reconciledAt.set(root, ended);
+                // A later gap still needs its deferred scan, even if this walk succeeded.
+                if (((_g = this.overflowCounts.get(root)) !== null && _g !== void 0 ? _g : 0) === overflowCountAtStart)
+                    this.overflowPendingRoots.delete(root);
+            }
             return complete;
         });
     }
@@ -737,6 +775,7 @@ class WatcherManager {
             let incompleteRetries = 0;
             do {
                 active.dirty = false;
+                this.lastCatchupStartMs.set(root, Date.now());
                 const complete = yield this.catchupScan(root, processor, signal);
                 if (!complete && !signal.aborted && incompleteRetries < 3) {
                     incompleteRetries++;
@@ -775,6 +814,7 @@ class WatcherManager {
             // independently of the processor, so clear them even on the early return.
             (_a = this.watchLifecycles.get(root)) === null || _a === void 0 ? void 0 : _a.abort();
             this.watchLifecycles.delete(root);
+            this.watcherGenerations.delete(root);
             const pollInterval = this.pollIntervals.get(root);
             if (pollInterval) {
                 clearInterval(pollInterval);
@@ -804,8 +844,10 @@ class WatcherManager {
                 this.deps.subscriptions.delete(root);
             }
             this.deps.evictSearcher(root);
-            this.lastOverflowMs.delete(root);
+            this.lastWatcherFailureMs.delete(root);
             this.lastCatchupEndMs.delete(root);
+            this.lastCatchupStartMs.delete(root);
+            this.overflowPendingRoots.delete(root);
             this.degradedRoots.delete(root);
             this.terminalFailures.delete(root);
             (0, watcher_store_1.unregisterWatcherByRoot)(root);

package/dist/lib/index/watcher-errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSEVENTS_GAP_SCAN_INTERVAL_MS = void 0;
+exports.isFSEventsGap = isFSEventsGap;
+/** Parcel reports these gaps without closing its FSEvents stream. Other errors
+ * may clear the native callbacks and still require subscription recovery. */
+function isFSEventsGap(error) {
+    return (error.message ===
+        "Events were dropped by the FSEvents client. File system must be re-scanned." ||
+        error.message ===
+            "Events were dropped by the kernel. File system must be re-scanned." ||
+        error.message === "Too many events. File system must be re-scanned.");
+}
+// Bound reconciliation under sustained churn without abandoning native edits
+// for the five-minute polling fallback used by a failed subscription.
+exports.FSEVENTS_GAP_SCAN_INTERVAL_MS = 30000;

package/dist/lib/index/watcher.js

@@ -58,6 +58,7 @@ const cache_coherence_1 = require("./cache-coherence");
 const file_policy_1 = require("./file-policy");
 const ignore_patterns_1 = require("./ignore-patterns");
 const walker_1 = require("./walker");
+const watcher_errors_1 = require("./watcher-errors");
 const watcher_ignore_1 = require("./watcher-ignore");
 // Directory names ignored at ANY depth. @parcel/watcher treats a non-glob
 // ignore entry as a literal path resolved against the watch root, so a bare
@@ -125,6 +126,11 @@ function startWatcher(opts) {
         let subscription = null;
         let subscriptionUpdate = Promise.resolve();
         let subscriptionPolicy = "";
+        let subscriptionFailed = false;
+        let subscriptionGeneration = 0;
+        let gapScanTimer;
+        let lastReconcileStart;
+        let gapGeneration = 0;
         const updateSubscription = () => {
             const update = subscriptionUpdate
                 .catch(() => { })
@@ -134,16 +140,31 @@ function startWatcher(opts) {
                     ...(yield (0, watcher_ignore_1.readProjectWatcherIgnores)(projectRoot)),
                 ];
                 const policy = JSON.stringify(ignores);
-                if (closing || (subscription && subscriptionPolicy === policy))
+                if (closing ||
+                    (subscription && !subscriptionFailed && subscriptionPolicy === policy))
                     return;
+                const generation = ++subscriptionGeneration;
+                subscriptionFailed = false;
                 yield subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
                 subscription = null;
                 if (closing)
                     return;
                 const next = yield watcher.subscribe(projectRoot, (err, events) => {
+                    var _a;
+                    if (closing || generation !== subscriptionGeneration)
+                        return;
                     if (err) {
                         console.error(`[${wtag}] Watcher error:`, err);
-                        return;
+                        scanHealthy = false;
+                        (_a = opts.onHealthChange) === null || _a === void 0 ? void 0 : _a.call(opts, false, 1);
+                        gapGeneration++;
+                        if ((0, watcher_errors_1.isFSEventsGap)(err))
+                            requestGapScan();
+                        else {
+                            // Terminal backend errors can clear Parcel's callbacks.
+                            subscriptionFailed = true;
+                            reconcile();
+                        }
                     }
                     for (const event of events)
                         processor.handleFileEvent(event.type === "delete" ? "unlink" : "change", event.path);
@@ -180,6 +201,8 @@ function startWatcher(opts) {
                 let incompleteRetries = 0;
                 do {
                     reconcileRequested = false;
+                    lastReconcileStart = Date.now();
+                    const observedGapGeneration = gapGeneration;
                     filePolicy.invalidateIgnoreCache();
                     yield updateSubscription();
                     if (closing)
@@ -243,7 +266,7 @@ function startWatcher(opts) {
                         }
                     }
                     else {
-                        scanHealthy = true;
+                        scanHealthy = observedGapGeneration === gapGeneration;
                         if (ingestionDegraded && processor.progress.pendingFiles > 0) {
                             degradedRepairQueued = true;
                         }
@@ -257,6 +280,21 @@ function startWatcher(opts) {
                 reconciliation = null;
             });
         };
+        const requestGapScan = () => {
+            if (closing || gapScanTimer)
+                return;
+            const remaining = lastReconcileStart === undefined
+                ? 0
+                : watcher_errors_1.FSEVENTS_GAP_SCAN_INTERVAL_MS - (Date.now() - lastReconcileStart);
+            if (reconciliation || remaining > 0) {
+                gapScanTimer = setTimeout(() => {
+                    gapScanTimer = undefined;
+                    reconcile();
+                }, Math.max(remaining, watcher_errors_1.FSEVENTS_GAP_SCAN_INTERVAL_MS));
+                return;
+            }
+            reconcile();
+        };
         processor = new batch_processor_1.ProjectBatchProcessor(Object.assign(Object.assign({}, opts), { filePolicy, onPolicyChange: reconcile, onReindex: (files, durationMs) => {
                 var _a;
                 (_a = opts.onReindex) === null || _a === void 0 ? void 0 : _a.call(opts, files, durationMs);
@@ -284,6 +322,8 @@ function startWatcher(opts) {
             },
             close: () => __awaiter(this, void 0, void 0, function* () {
                 closing = true;
+                subscriptionGeneration++;
+                clearTimeout(gapScanTimer);
                 yield subscriptionUpdate.catch(() => { });
                 yield subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
                 yield reconciliation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.63",
+  "version": "0.26.64",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.63",
+  "version": "0.26.64",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",