grepmax 0.23.0 → 0.25.0

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

@@ -50,17 +50,32 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WatcherManager = void 0;
-const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const watcher = __importStar(require("@parcel/watcher"));
 const batch_processor_1 = require("../index/batch-processor");
+const file_policy_1 = require("../index/file-policy");
+const walker_1 = require("../index/walker");
 const watcher_1 = require("../index/watcher");
+const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
 const project_registry_1 = require("../utils/project-registry");
 const watcher_store_1 = require("../utils/watcher-store");
 // Watcher health windows used for FSEvents auto-recovery.
 const FSEVENTS_RECOVERY_INTERVAL_MS = 60 * 60 * 1000; // try recovery hourly
 const FSEVENTS_HEALTH_WINDOW_MS = 5 * 60 * 1000; // 5 min of quiet = "healthy"
+function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(finish, ms);
+        function finish() {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        }
+        signal.addEventListener("abort", finish, { once: true });
+    });
+}
 /**
  * Owns per-project file watching: @parcel/watcher subscriptions, FSEvents
  * overflow recovery, poll-mode fallback, and the offline catchup scan. Holds the
@@ -78,93 +93,161 @@ class WatcherManager {
         this.watcherFailCount = new Map();
         this.pollIntervals = new Map();
         this.pollRecoveryTimers = new Map();
+        this.recoveryTimeouts = new Map();
         this.lastOverflowMs = new Map();
         this.lastCatchupEndMs = new Map();
+        this.catchups = new Map();
+        this.degradedRoots = new Set();
+        this.terminalFailures = new Map();
+        this.watchLifecycles = new Map();
     }
-    watchProject(root) {
-        return __awaiter(this, void 0, void 0, function* () {
+    watchProject(root_1) {
+        return __awaiter(this, arguments, void 0, function* (root, options = {}) {
+            var _a, _b;
             if (this.deps.processors.has(root) || this.pendingOps.has(root))
                 return;
             const vectorDb = this.deps.getVectorDb();
             const metaCache = this.deps.getMetaCache();
-            if (!vectorDb || !metaCache)
+            const workerPool = (_b = (_a = this.deps).getWorkerPool) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (!vectorDb || !metaCache || (this.deps.getWorkerPool && !workerPool))
                 return;
             this.pendingOps.add(root);
-            const processor = new batch_processor_1.ProjectBatchProcessor({
-                projectRoot: root,
-                vectorDb,
-                metaCache,
-                onReindex: (files, ms) => __awaiter(this, void 0, void 0, function* () {
-                    console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
-                    // Update project registry so gmax status shows fresh data
-                    const proj = (0, project_registry_1.getProject)(root);
-                    if (proj) {
-                        let chunkCount = proj.chunkCount;
-                        try {
-                            chunkCount = yield vectorDb.countRowsForPath(root);
-                        }
-                        catch (err) {
-                            console.warn(`[daemon:${path.basename(root)}] Failed to query chunk count: ${err}`);
+            const lifecycle = new AbortController();
+            this.watchLifecycles.set(root, lifecycle);
+            const ownsLifecycle = () => this.watchLifecycles.get(root) === lifecycle &&
+                !lifecycle.signal.aborted &&
+                !this.deps.getShuttingDown();
+            try {
+                const filePolicy = new file_policy_1.ProjectFilePolicy(root);
+                let processor;
+                processor = new batch_processor_1.ProjectBatchProcessor(Object.assign(Object.assign({ projectRoot: root, vectorDb,
+                    metaCache }, (workerPool ? { workerPool } : {})), { filePolicy, onPolicyChange: () => {
+                        void this.runCatchup(root, processor).catch((err) => {
+                            console.error(`[daemon:${path.basename(root)}] Policy reconciliation failed:`, err);
+                        });
+                    }, onReindex: (files, ms) => __awaiter(this, void 0, void 0, function* () {
+                        console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
+                        // Update project registry so gmax status shows fresh data
+                        const proj = (0, project_registry_1.getProject)(root);
+                        if (proj) {
+                            let chunkCount = proj.chunkCount;
+                            try {
+                                chunkCount = yield vectorDb.countRowsForPath(root);
+                            }
+                            catch (err) {
+                                console.warn(`[daemon:${path.basename(root)}] Failed to query chunk count: ${err}`);
+                            }
+                            (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount }));
                         }
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount }));
-                    }
-                    // Back to watching after batch completes
-                    (0, watcher_store_1.registerWatcher)({
-                        pid: process.pid,
-                        projectRoot: root,
-                        startTime: Date.now(),
-                        status: "watching",
-                        lastHeartbeat: Date.now(),
-                        lastReindex: Date.now(),
-                    });
-                }),
-                onActivity: () => {
-                    this.deps.touchActivity();
-                    // Mark as syncing while processing
-                    (0, watcher_store_1.registerWatcher)({
-                        pid: process.pid,
-                        projectRoot: root,
-                        startTime: Date.now(),
-                        status: "syncing",
-                        lastHeartbeat: Date.now(),
+                        // Back to watching after batch completes
+                        (0, watcher_store_1.registerWatcher)({
+                            pid: process.pid,
+                            projectRoot: root,
+                            startTime: Date.now(),
+                            status: this.isRootDegraded(root) ? "degraded" : "watching",
+                            lastHeartbeat: Date.now(),
+                            lastReindex: Date.now(),
+                        });
+                    }), onActivity: () => {
+                        this.deps.touchActivity();
+                        // Mark as syncing while processing
+                        (0, watcher_store_1.registerWatcher)({
+                            pid: process.pid,
+                            projectRoot: root,
+                            startTime: Date.now(),
+                            status: this.isRootDegraded(root) ? "degraded" : "syncing",
+                            lastHeartbeat: Date.now(),
+                        });
+                    }, onTerminalFailure: (absPath) => {
+                        var _a;
+                        const failed = (_a = this.terminalFailures.get(root)) !== null && _a !== void 0 ? _a : new Set();
+                        failed.add(absPath);
+                        this.terminalFailures.set(root, failed);
+                        (0, watcher_store_1.registerWatcher)({
+                            pid: process.pid,
+                            projectRoot: root,
+                            startTime: Date.now(),
+                            status: "degraded",
+                            lastError: `${failed.size} file(s) exhausted automatic retries`,
+                            lastHeartbeat: Date.now(),
+                        });
+                    }, onPathSuccess: (absPath) => {
+                        const failed = this.terminalFailures.get(root);
+                        if (!(failed === null || failed === void 0 ? void 0 : failed.delete(absPath)))
+                            return;
+                        if (failed.size === 0)
+                            this.terminalFailures.delete(root);
+                        (0, watcher_store_1.registerWatcher)({
+                            pid: process.pid,
+                            projectRoot: root,
+                            startTime: Date.now(),
+                            status: this.isRootDegraded(root) ? "degraded" : "watching",
+                            lastHeartbeat: Date.now(),
+                        });
+                    }, runOperation: (fn) => this.deps.runProjectOperation
+                        ? this.deps.runProjectOperation(root, "watch-batch", undefined, fn)
+                        : fn(new AbortController().signal) }));
+                if (!ownsLifecycle()) {
+                    yield processor.close();
+                    return;
+                }
+                this.deps.processors.set(root, processor);
+                // Subscribe with @parcel/watcher — native backend, no polling.
+                // If the kernel refuses (e.g. FSEvents slots stuck after a prior kill -9),
+                // fall straight through to poll mode. The retry/backoff path inside
+                // recoverWatcher is for transient overflows, not hard kernel-level
+                // subscribe failures, so we skip it on startup by priming failCount past
+                // MAX before invoking it.
+                try {
+                    yield this.subscribeWatcher(root, processor);
+                }
+                catch (err) {
+                    if (!ownsLifecycle())
+                        return;
+                    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.recoverWatcher(root, processor);
+                }
+                if (!ownsLifecycle())
+                    return;
+                (0, watcher_store_1.registerWatcher)({
+                    pid: process.pid,
+                    projectRoot: root,
+                    startTime: Date.now(),
+                    status: processor.progress.processing || processor.progress.pendingFiles > 0
+                        ? "syncing"
+                        : "watching",
+                    lastHeartbeat: Date.now(),
+                });
+                // Catchup scan — find files changed while daemon was offline
+                if (options.catchup !== false) {
+                    this.runCatchup(root, processor).catch((err) => {
+                        console.error(`[daemon:${path.basename(root)}] Catchup scan failed:`, err);
                     });
-                },
-            });
-            this.deps.processors.set(root, processor);
-            // Subscribe with @parcel/watcher — native backend, no polling.
-            // If the kernel refuses (e.g. FSEvents slots stuck after a prior kill -9),
-            // fall straight through to poll mode. The retry/backoff path inside
-            // recoverWatcher is for transient overflows, not hard kernel-level
-            // subscribe failures, so we skip it on startup by priming failCount past
-            // MAX before invoking it.
-            try {
-                yield this.subscribeWatcher(root, processor);
+                }
+                console.log(`[daemon] Watching ${root}`);
+            }
+            catch (error) {
+                yield this.unwatchProject(root).catch(() => { });
+                throw error;
             }
-            catch (err) {
-                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.recoverWatcher(root, processor);
+            finally {
+                this.pendingOps.delete(root);
             }
-            (0, watcher_store_1.registerWatcher)({
-                pid: process.pid,
-                projectRoot: root,
-                startTime: Date.now(),
-                status: "watching",
-                lastHeartbeat: Date.now(),
-            });
-            // Catchup scan — find files changed while daemon was offline
-            this.catchupScan(root, processor).catch((err) => {
-                console.error(`[daemon:${path.basename(root)}] Catchup scan failed:`, err);
-            });
-            this.pendingOps.delete(root);
-            console.log(`[daemon] Watching ${root}`);
         });
     }
+    isRootDegraded(root) {
+        var _a, _b;
+        return (this.degradedRoots.has(root) ||
+            ((_b = (_a = this.terminalFailures.get(root)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0);
+    }
     subscribeWatcher(root, processor) {
         return __awaiter(this, void 0, void 0, function* () {
             const name = path.basename(root);
+            if (this.deps.processors.get(root) !== processor)
+                return;
             // Unsubscribe existing watcher if any (e.g. during recovery)
             const existingSub = this.deps.subscriptions.get(root);
             if (existingSub) {
@@ -191,13 +274,18 @@ class WatcherManager {
                 }
                 this.deps.touchActivity();
             }, { ignore: watcher_1.WATCHER_IGNORE_GLOBS });
+            if (this.deps.processors.get(root) !== processor) {
+                yield sub.unsubscribe();
+                return;
+            }
             this.deps.subscriptions.set(root, sub);
         });
     }
     recoverWatcher(root, processor) {
         var _a;
         const name = path.basename(root);
-        if (this.deps.getShuttingDown())
+        if (this.deps.getShuttingDown() ||
+            this.deps.processors.get(root) !== processor)
             return;
         // Debounce: avoid multiple overlapping recovery attempts
         const recoveryKey = `recover:${root}`;
@@ -222,14 +310,15 @@ class WatcherManager {
             if (!this.pollIntervals.has(root)) {
                 console.error(`[daemon:${name}] FSEvents unreliable after ${fails} failures — switching to poll mode (${POLL_INTERVAL_MS / 60000}min interval)`);
                 // Run an immediate catchup, then schedule periodic ones
-                this.catchupScan(root, processor).catch((err) => {
+                this.runCatchup(root, processor).catch((err) => {
                     console.error(`[daemon:${name}] Poll catchup failed:`, err);
                 });
                 const interval = setInterval(() => {
-                    if (this.deps.getShuttingDown())
+                    if (this.deps.getShuttingDown() ||
+                        this.deps.processors.get(root) !== processor)
                         return;
                     this.deps.touchActivity();
-                    this.catchupScan(root, processor).catch((err) => {
+                    this.runCatchup(root, processor).catch((err) => {
                         console.error(`[daemon:${name}] Poll catchup failed:`, err);
                     });
                 }, POLL_INTERVAL_MS);
@@ -252,8 +341,10 @@ 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)...`);
-        setTimeout(() => {
-            if (this.deps.getShuttingDown()) {
+        const timeout = setTimeout(() => {
+            this.recoveryTimeouts.delete(root);
+            if (this.deps.getShuttingDown() ||
+                this.deps.processors.get(root) !== processor) {
                 this.pendingOps.delete(recoveryKey);
                 return;
             }
@@ -261,13 +352,15 @@ class WatcherManager {
                 var _a;
                 try {
                     yield this.subscribeWatcher(root, processor);
+                    if (this.deps.processors.get(root) !== processor)
+                        return;
                     const lastCatchup = (_a = this.lastCatchupEndMs.get(root)) !== null && _a !== void 0 ? _a : 0;
                     const CATCHUP_COOLDOWN_MS = 60000;
                     if (Date.now() - lastCatchup < CATCHUP_COOLDOWN_MS) {
                         console.log(`[daemon:${name}] Skipping catchup scan (last completed ${Math.round((Date.now() - lastCatchup) / 1000)}s ago)`);
                     }
                     else {
-                        yield this.catchupScan(root, processor);
+                        yield this.runCatchup(root, processor);
                     }
                     console.log(`[daemon:${name}] Watcher recovered`);
                 }
@@ -279,6 +372,7 @@ class WatcherManager {
                 }
             }))();
         }, delayMs);
+        this.recoveryTimeouts.set(root, timeout);
     }
     /**
      * Once a project has fallen back to poll mode, periodically try to upgrade
@@ -290,6 +384,9 @@ class WatcherManager {
         if (this.pollRecoveryTimers.has(root))
             return;
         const name = path.basename(root);
+        const lifecycle = this.watchLifecycles.get(root);
+        if (!lifecycle)
+            return;
         const timer = setInterval(() => {
             if (this.deps.getShuttingDown())
                 return;
@@ -305,6 +402,8 @@ class WatcherManager {
                 return;
             void (() => __awaiter(this, void 0, void 0, function* () {
                 var _a;
+                if (this.deps.processors.get(root) !== processor)
+                    return;
                 console.log(`[daemon:${name}] Attempting to leave poll mode and reattach FSEvents...`);
                 try {
                     // Reset failure counter so subscribeWatcher's error path treats this
@@ -312,10 +411,13 @@ class WatcherManager {
                     // poll mode via the same recoverWatcher path.
                     this.watcherFailCount.delete(root);
                     yield this.subscribeWatcher(root, processor);
+                    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.
-                    yield new Promise((r) => setTimeout(r, FSEVENTS_HEALTH_WINDOW_MS));
-                    if (this.deps.getShuttingDown())
+                    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;
                     if (Date.now() - lastOverflow < FSEVENTS_HEALTH_WINDOW_MS) {
@@ -343,50 +445,65 @@ class WatcherManager {
         timer.unref();
         this.pollRecoveryTimers.set(root, timer);
     }
-    catchupScan(root, processor) {
+    catchupScan(root, processor, signal) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
-            const { walk } = yield Promise.resolve().then(() => __importStar(require("../index/walker")));
-            const { INDEXABLE_EXTENSIONS, MAX_FILE_SIZE_BYTES } = yield Promise.resolve().then(() => __importStar(require("../../config")));
+            var _d, _e;
             const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
             const metaCache = this.deps.getMetaCache();
+            processor.filePolicy.invalidateIgnoreCache();
             const rootPrefix = root.endsWith("/") ? root : `${root}/`;
             const cachedPaths = yield metaCache.getKeysWithPrefix(rootPrefix);
+            if (signal.aborted)
+                return false;
             const seenPaths = new Set();
+            const walkState = (0, walker_1.createWalkState)();
             let queued = 0;
             let skipped = 0;
             let debugSamples = 0;
             try {
-                for (var _d = true, _e = __asyncValues(walk(root, {
-                    additionalPatterns: ["**/.git/**", "**/.gmax/**"],
-                })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
+                for (var _f = true, _g = __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;
                     const relPath = _c;
+                    if (signal.aborted)
+                        return false;
                     const absPath = path.join(root, relPath);
-                    const ext = path.extname(absPath).toLowerCase();
-                    const bn = path.basename(absPath).toLowerCase();
-                    if (!INDEXABLE_EXTENSIONS.has(ext) && !INDEXABLE_EXTENSIONS.has(bn))
-                        continue;
                     try {
-                        const stats = yield fs.promises.stat(absPath);
-                        // Skip files that are too large or empty — they'll never be indexed.
-                        // Leave them OUT of seenPaths so a file that became empty/oversized is
-                        // treated as deleted by the purge sweep below and its now-stale chunks
-                        // are removed, rather than lingering as unsearchable-but-present rows.
-                        if (stats.size === 0 || stats.size > MAX_FILE_SIZE_BYTES)
+                        const classification = yield processor.filePolicy.classifyFile(absPath);
+                        if (classification.status === "error") {
+                            walkState.protectedPaths.add(classification.protectedPath);
+                            walkState.errors.push({
+                                path: classification.protectedPath,
+                                error: classification.error,
+                            });
                             continue;
+                        }
+                        if (classification.status !== "indexable")
+                            continue;
+                        const stats = classification.stat;
                         seenPaths.add(absPath);
                         const cached = metaCache.get(absPath);
                         if (!isFileCached(cached, stats)) {
                             // Fast path: if only mtime changed but size is identical and we have a hash,
                             // just verify the hash in-process instead of sending to a worker.
                             if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
-                                const { computeContentHash } = yield Promise.resolve().then(() => __importStar(require("../utils/file-utils")));
-                                const buf = yield fs.promises.readFile(absPath);
-                                const hash = computeContentHash(buf, absPath);
+                                const snapshot = yield (0, file_utils_1.readFileSnapshot)(absPath, {
+                                    projectRoot: root,
+                                });
+                                if (snapshot.size !== stats.size ||
+                                    snapshot.mtimeMs !== stats.mtimeMs) {
+                                    processor.handleFileEvent("change", absPath);
+                                    continue;
+                                }
+                                const hash = (0, file_utils_1.computeContentHash)(snapshot.buffer, absPath);
                                 if (hash === cached.hash) {
                                     // Content unchanged — update mtime in cache and skip worker
+                                    if (signal.aborted)
+                                        return false;
                                     metaCache.put(absPath, Object.assign(Object.assign({}, cached), { mtimeMs: stats.mtimeMs }));
                                     skipped++;
                                     continue;
@@ -397,26 +514,31 @@ class WatcherManager {
                                 (0, logger_1.debug)("catchup", `miss ${relPath}: cached=${cached ? `mtime=${Math.trunc(cached.mtimeMs)} size=${cached.size}` : "null"} stat=mtime=${Math.trunc(stats.mtimeMs)} size=${stats.size}`);
                                 debugSamples++;
                             }
+                            if (signal.aborted)
+                                return false;
                             processor.handleFileEvent("change", absPath);
                             queued++;
                             // Throttle: pause periodically during large catchup scans to let the
                             // batch processor drain and compaction run between bursts.
                             if (queued % 500 === 0) {
                                 (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
-                                yield new Promise((r) => setTimeout(r, 5000));
+                                yield abortableDelay(5000, signal);
                             }
                         }
                         else {
                             skipped++;
                         }
                     }
-                    catch (_g) { }
+                    catch (error) {
+                        walkState.protectedPaths.add(absPath);
+                        walkState.errors.push({ path: absPath, error });
+                    }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -424,11 +546,33 @@ class WatcherManager {
             // Purge files deleted while daemon was offline
             let purged = 0;
             for (const cachedPath of cachedPaths) {
-                if (!seenPaths.has(cachedPath)) {
+                if (signal.aborted)
+                    return false;
+                if (!seenPaths.has(cachedPath) &&
+                    !(0, walker_1.isPathProtectedByWalkState)(cachedPath, walkState)) {
                     processor.handleFileEvent("unlink", cachedPath);
                     purged++;
                 }
             }
+            const complete = walkState.rootComplete && walkState.errors.length === 0;
+            if (!complete) {
+                this.degradedRoots.add(root);
+                (0, watcher_store_1.registerWatcher)({
+                    pid: process.pid,
+                    projectRoot: root,
+                    startTime: Date.now(),
+                    status: "degraded",
+                    lastHeartbeat: Date.now(),
+                    lastError: `${walkState.errors.length} scan path(s) incomplete`,
+                });
+            }
+            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;
+                (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` }
+                    : {})));
+            }
             if (queued > 0 || purged > 0) {
                 const parts = [];
                 if (queued > 0)
@@ -438,13 +582,62 @@ class WatcherManager {
                 console.log(`[daemon:${path.basename(root)}] Catchup: ${parts.join(", ")} file(s) while offline`);
             }
             this.lastCatchupEndMs.set(root, Date.now());
+            return complete;
+        });
+    }
+    runCatchup(root, processor) {
+        const existing = this.catchups.get(root);
+        if (existing) {
+            existing.dirty = true;
+            return existing.promise;
+        }
+        const active = {
+            controller: new AbortController(),
+            dirty: false,
+            promise: Promise.resolve(),
+        };
+        const execute = (signal) => __awaiter(this, void 0, void 0, function* () {
+            let incompleteRetries = 0;
+            do {
+                active.dirty = false;
+                const complete = yield this.catchupScan(root, processor, signal);
+                if (!complete && !signal.aborted && incompleteRetries < 3) {
+                    incompleteRetries++;
+                    active.dirty = true;
+                    yield abortableDelay(1000 * Math.pow(2, (incompleteRetries - 1)), signal);
+                }
+                else if (complete) {
+                    incompleteRetries = 0;
+                }
+            } while (active.dirty && !signal.aborted);
+        });
+        const run = (this.deps.runProjectOperation
+            ? this.deps.runProjectOperation(root, "watch-catchup", active.controller.signal, execute)
+            : execute(active.controller.signal)).finally(() => {
+            if (this.catchups.get(root) === active)
+                this.catchups.delete(root);
+        });
+        active.promise = run;
+        this.catchups.set(root, active);
+        return run;
+    }
+    stopCatchup(root) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const active = this.catchups.get(root);
+            if (!active)
+                return;
+            active.controller.abort();
+            yield active.promise.catch(() => { });
         });
     }
     unwatchProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             // Stop poll-mode timers + their FSEvents recovery probe first, so a removed
             // project can't keep scanning until full daemon shutdown. These live
             // 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);
             const pollInterval = this.pollIntervals.get(root);
             if (pollInterval) {
                 clearInterval(pollInterval);
@@ -455,30 +648,72 @@ class WatcherManager {
                 clearInterval(recoveryTimer);
                 this.pollRecoveryTimers.delete(root);
             }
+            const recoveryTimeout = this.recoveryTimeouts.get(root);
+            if (recoveryTimeout) {
+                clearTimeout(recoveryTimeout);
+                this.recoveryTimeouts.delete(root);
+            }
+            this.pendingOps.delete(`recover:${root}`);
             const processor = this.deps.processors.get(root);
-            if (!processor)
-                return;
-            yield processor.close();
+            this.deps.processors.delete(root);
+            yield this.stopCatchup(root);
+            if (processor)
+                yield processor.close();
             const sub = this.deps.subscriptions.get(root);
             if (sub) {
                 yield sub.unsubscribe();
                 this.deps.subscriptions.delete(root);
             }
-            this.deps.processors.delete(root);
             this.deps.evictSearcher(root);
             this.lastOverflowMs.delete(root);
             this.lastCatchupEndMs.delete(root);
+            this.degradedRoots.delete(root);
+            this.terminalFailures.delete(root);
             (0, watcher_store_1.unregisterWatcherByRoot)(root);
             console.log(`[daemon] Unwatched ${root}`);
         });
     }
+    quiesceAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roots = [
+                ...new Set([
+                    ...this.deps.processors.keys(),
+                    ...this.deps.subscriptions.keys(),
+                    ...this.watchLifecycles.keys(),
+                ]),
+            ];
+            yield this.teardown();
+            yield Promise.all(roots.map((root) => this.unwatchProject(root)));
+            return roots;
+        });
+    }
+    resumeAll(roots_1) {
+        return __awaiter(this, arguments, void 0, function* (roots, options = {}) {
+            if (this.deps.getShuttingDown())
+                return;
+            for (const root of roots)
+                yield this.watchProject(root, options);
+        });
+    }
+    catchupAll(roots) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const root of roots) {
+                const processor = this.deps.processors.get(root);
+                if (processor)
+                    yield this.runCatchup(root, processor);
+            }
+        });
+    }
     /**
      * Stop all poll intervals + their FSEvents recovery probes and unsubscribe
-     * every watcher. Called from the daemon's shutdown after the worker pool is
-     * destroyed (the subscriptions map is shared, so it is cleared here).
+     * every watcher. Processors are closed by quiesceAll/unwatchProject before
+     * worker teardown.
      */
     teardown() {
         return __awaiter(this, void 0, void 0, function* () {
+            for (const lifecycle of this.watchLifecycles.values())
+                lifecycle.abort();
+            this.watchLifecycles.clear();
             for (const interval of this.pollIntervals.values()) {
                 clearInterval(interval);
             }
@@ -487,6 +722,14 @@ class WatcherManager {
                 clearInterval(interval);
             }
             this.pollRecoveryTimers.clear();
+            for (const timeout of this.recoveryTimeouts.values()) {
+                clearTimeout(timeout);
+            }
+            this.recoveryTimeouts.clear();
+            const catchups = [...this.catchups.values()];
+            for (const active of catchups)
+                active.controller.abort();
+            yield Promise.allSettled(catchups.map((active) => active.promise));
             for (const sub of this.deps.subscriptions.values()) {
                 try {
                     yield sub.unsubscribe();