grepmax 0.15.6 → 0.16.0

package/dist/commands/search.js

@@ -256,9 +256,9 @@ function formatCompactTable(hits, projectRoot, query, opts) {
 }
 // Reuse Skeletonizer instance
 let globalSkeletonizer = null;
-function outputSkeletons(results, projectRoot, limit, db) {
+function outputSkeletons(results, projectRoot, limit, db, precomputed) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b;
         const seenPaths = new Set();
         const filesToProcess = [];
         for (const result of results) {
@@ -288,6 +288,16 @@ function outputSkeletons(results, projectRoot, limit, db) {
             const absPath = path.isAbsolute(filePath)
                 ? filePath
                 : path.resolve(projectRoot, filePath);
+            // 0. Daemon-supplied (preferred — already-warm DB lookup, no cold open)
+            const fromDaemon = (_b = precomputed === null || precomputed === void 0 ? void 0 : precomputed[absPath]) !== null && _b !== void 0 ? _b : precomputed === null || precomputed === void 0 ? void 0 : precomputed[filePath];
+            if (fromDaemon) {
+                skeletonResults.push({
+                    file: filePath,
+                    skeleton: fromDaemon,
+                    tokens: Math.ceil(fromDaemon.length / 4),
+                });
+                continue;
+            }
             // 1. Try DB cache
             if (db) {
                 const cached = yield (0, retriever_1.getStoredSkeleton)(db, absPath);
@@ -378,7 +388,7 @@ Examples:
   gmax "handler" --name "handle.*" --exclude tests/
 `)
     .action((pattern, exec_path, _options, cmd) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
     const options = cmd.optsWithGlobals();
     const root = process.cwd();
     const minScore = Number.isFinite(Number.parseFloat(options.minScore))
@@ -498,79 +508,10 @@ Examples:
         if (project.status === "pending") {
             console.warn("This project is still being indexed. Results may be incomplete.\n");
         }
-        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
-        // Check for active indexing lock and warn if present
-        if (!options.agent && (0, lock_1.isLocked)(paths.dataDir)) {
-            console.warn("⚠️  Warning: Indexing in progress... search results may be incomplete.");
-        }
-        const hasRows = yield vectorDb.hasAnyRows();
-        const needsSync = options.sync || !hasRows;
-        if (needsSync) {
-            const isTTY = process.stdout.isTTY;
-            let abortController;
-            let signal;
-            if (!isTTY) {
-                abortController = new AbortController();
-                signal = abortController.signal;
-                setTimeout(() => {
-                    abortController === null || abortController === void 0 ? void 0 : abortController.abort();
-                }, 60000); // 60 seconds timeout for non-TTY auto-indexing
-            }
-            const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, options.sync ? "Indexing..." : "Indexing repository (first run)...");
-            try {
-                yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
-                const result = yield (0, syncer_1.initialSync)({
-                    projectRoot,
-                    dryRun: options.dryRun,
-                    onProgress,
-                    signal,
-                });
-                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                    spinner.warn(`Indexing timed out (${result.processed}/${result.total}). Results may be partial.`);
-                }
-                if (options.dryRun) {
-                    spinner.succeed(`Dry run complete (${result.processed}/${result.total}) • would have indexed ${result.indexed}`);
-                    console.log((0, sync_helpers_1.formatDryRunSummary)(result, {
-                        actionDescription: "would have indexed",
-                        includeTotal: true,
-                    }));
-                    return;
-                }
-                yield vectorDb.createFTSIndex();
-                // Update registry after sync
-                const { readGlobalConfig } = yield Promise.resolve().then(() => __importStar(require("../lib/index/index-config")));
-                const { registerProject } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/project-registry")));
-                const gc = readGlobalConfig();
-                registerProject({
-                    root: projectRoot,
-                    name: path.basename(projectRoot),
-                    vectorDim: gc.vectorDim,
-                    modelTier: gc.modelTier,
-                    embedMode: gc.embedMode,
-                    lastIndexed: new Date().toISOString(),
-                    chunkCount: result.indexed,
-                    status: "indexed",
-                });
-                const failedSuffix = result.failedFiles > 0 ? ` • ${result.failedFiles} failed` : "";
-                spinner.succeed(`${options.sync ? "Indexing" : "Initial indexing"} complete (${result.processed}/${result.total}) • indexed ${result.indexed}${failedSuffix}`);
-            }
-            catch (e) {
-                spinner.fail("Indexing failed");
-                throw e;
-            }
-        }
-        // Ensure a watcher is running for live reindexing
-        if (!process.env.VITEST && !((_d = process.env.NODE_ENV) === null || _d === void 0 ? void 0 : _d.includes("test"))) {
-            const { launchWatcher } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/watcher-launcher")));
-            const launched = yield launchWatcher(projectRoot);
-            if (!launched.ok && launched.reason === "spawn-failed") {
-                console.warn(`[search] ${launched.message}`);
-            }
-        }
-        const searcher = new searcher_1.Searcher(vectorDb);
-        // Use --root or fall back to project root
+        // Compute effective paths + filters early — both the daemon-mediated
+        // and in-process search paths need them.
         const effectiveRoot = options.root
-            ? (_e = (0, project_root_1.findProjectRoot)(path.resolve(options.root))) !== null && _e !== void 0 ? _e : path.resolve(options.root)
+            ? (_d = (0, project_root_1.findProjectRoot)(path.resolve(options.root))) !== null && _d !== void 0 ? _d : path.resolve(options.root)
             : projectRoot;
         const searchPathPrefix = exec_path
             ? path.resolve(exec_path)
@@ -578,7 +519,6 @@ Examples:
         const pathFilter = searchPathPrefix.endsWith("/")
             ? searchPathPrefix
             : `${searchPathPrefix}/`;
-        // Build filters from CLI options
         const searchFilters = {};
         if (options.file)
             searchFilters.file = options.file;
@@ -588,8 +528,126 @@ Examples:
             searchFilters.language = options.lang;
         if (options.role)
             searchFilters.role = options.role;
-        const searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: true, explain: options.explain }, Object.keys(searchFilters).length > 0 ? searchFilters : undefined, pathFilter);
-        if (!options.agent && ((_f = searchResult.warnings) === null || _f === void 0 ? void 0 : _f.length)) {
+        // Daemon-mediated search: ships query+args over IPC, daemon runs the
+        // hybrid+rerank against its already-warm VectorDB and worker pool.
+        // Drops cold-start cost (~17s wall, 6GB RAM in the CLI) to <1s. Falls
+        // back to in-process on any failure.
+        let searchResult = null;
+        let precomputedSkeletons;
+        let precomputedGraph;
+        if (!options.sync && !options.dryRun) {
+            try {
+                const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+                if (yield isDaemonRunning()) {
+                    const resp = yield sendDaemonCommand({
+                        cmd: "search",
+                        projectRoot: effectiveRoot,
+                        query: pattern,
+                        limit: parseInt(options.m, 10),
+                        filters: Object.keys(searchFilters).length > 0
+                            ? searchFilters
+                            : undefined,
+                        pathPrefix: pathFilter,
+                        rerank: true,
+                        explain: options.explain,
+                        includeSkeletons: options.skeleton,
+                        includeGraph: options.symbol,
+                    }, { timeoutMs: 60000 });
+                    if (resp.ok) {
+                        searchResult = {
+                            data: resp.data,
+                            warnings: resp.warnings,
+                        };
+                        precomputedSkeletons = resp.skeletons;
+                        precomputedGraph = resp.graph;
+                    }
+                    else if (process.env.GMAX_DEBUG === "1") {
+                        console.error(`[search] daemon path unavailable: ${(_e = resp.error) !== null && _e !== void 0 ? _e : "unknown"}`);
+                    }
+                }
+            }
+            catch (err) {
+                if (process.env.GMAX_DEBUG === "1") {
+                    console.error("[search] daemon attempt threw:", err);
+                }
+            }
+        }
+        // In-process fallback: open VectorDB, ensure index, run Searcher.
+        // Only entered when the daemon path didn't produce results.
+        if (!searchResult) {
+            vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+            // Check for active indexing lock and warn if present
+            if (!options.agent && (0, lock_1.isLocked)(paths.dataDir)) {
+                console.warn("⚠️  Warning: Indexing in progress... search results may be incomplete.");
+            }
+            const hasRows = yield vectorDb.hasAnyRows();
+            const needsSync = options.sync || !hasRows;
+            if (needsSync) {
+                const isTTY = process.stdout.isTTY;
+                let abortController;
+                let signal;
+                if (!isTTY) {
+                    abortController = new AbortController();
+                    signal = abortController.signal;
+                    setTimeout(() => {
+                        abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+                    }, 60000); // 60 seconds timeout for non-TTY auto-indexing
+                }
+                const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, options.sync ? "Indexing..." : "Indexing repository (first run)...");
+                try {
+                    yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
+                    const result = yield (0, syncer_1.initialSync)({
+                        projectRoot,
+                        dryRun: options.dryRun,
+                        onProgress,
+                        signal,
+                    });
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        spinner.warn(`Indexing timed out (${result.processed}/${result.total}). Results may be partial.`);
+                    }
+                    if (options.dryRun) {
+                        spinner.succeed(`Dry run complete (${result.processed}/${result.total}) • would have indexed ${result.indexed}`);
+                        console.log((0, sync_helpers_1.formatDryRunSummary)(result, {
+                            actionDescription: "would have indexed",
+                            includeTotal: true,
+                        }));
+                        return;
+                    }
+                    yield vectorDb.createFTSIndex();
+                    // Update registry after sync
+                    const { readGlobalConfig } = yield Promise.resolve().then(() => __importStar(require("../lib/index/index-config")));
+                    const { registerProject } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/project-registry")));
+                    const gc = readGlobalConfig();
+                    registerProject({
+                        root: projectRoot,
+                        name: path.basename(projectRoot),
+                        vectorDim: gc.vectorDim,
+                        modelTier: gc.modelTier,
+                        embedMode: gc.embedMode,
+                        lastIndexed: new Date().toISOString(),
+                        chunkCount: result.indexed,
+                        status: "indexed",
+                    });
+                    const failedSuffix = result.failedFiles > 0 ? ` • ${result.failedFiles} failed` : "";
+                    spinner.succeed(`${options.sync ? "Indexing" : "Initial indexing"} complete (${result.processed}/${result.total}) • indexed ${result.indexed}${failedSuffix}`);
+                }
+                catch (e) {
+                    spinner.fail("Indexing failed");
+                    throw e;
+                }
+            }
+            // Ensure a watcher is running for live reindexing
+            if (!process.env.VITEST && !((_f = process.env.NODE_ENV) === null || _f === void 0 ? void 0 : _f.includes("test"))) {
+                const { launchWatcher } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/watcher-launcher")));
+                const launched = yield launchWatcher(projectRoot);
+                if (!launched.ok && launched.reason === "spawn-failed") {
+                    console.warn(`[search] ${launched.message}`);
+                }
+            }
+            const searcher = new searcher_1.Searcher(vectorDb);
+            searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: true, explain: options.explain }, Object.keys(searchFilters).length > 0 ? searchFilters : undefined, pathFilter);
+        } // end if (!searchResult) — in-process fallback
+        if (!options.agent && ((_g = searchResult.warnings) === null || _g === void 0 ? void 0 : _g.length)) {
             for (const w of searchResult.warnings) {
                 console.warn(`Warning: ${w}`);
             }
@@ -606,7 +664,7 @@ Examples:
                     return defs.some((d) => regex.test(d));
                 });
             }
-            catch (_10) {
+            catch (_11) {
                 // Invalid regex — skip
             }
         }
@@ -632,16 +690,16 @@ Examples:
                 // In agent mode, print imports header per file
                 const seenImportFiles = new Set();
                 for (const r of filteredData) {
-                    const absP = (_j = (_g = r.path) !== null && _g !== void 0 ? _g : (_h = r.metadata) === null || _h === void 0 ? void 0 : _h.path) !== null && _j !== void 0 ? _j : "";
+                    const absP = (_k = (_h = r.path) !== null && _h !== void 0 ? _h : (_j = r.metadata) === null || _j === void 0 ? void 0 : _j.path) !== null && _k !== void 0 ? _k : "";
                     const relPath = absP.startsWith(effectiveRoot)
                         ? absP.slice(effectiveRoot.length + 1)
                         : absP;
-                    const startLine = Math.max(1, ((_o = (_l = (_k = r.startLine) !== null && _k !== void 0 ? _k : r.start_line) !== null && _l !== void 0 ? _l : (_m = r.generated_metadata) === null || _m === void 0 ? void 0 : _m.start_line) !== null && _o !== void 0 ? _o : 0) + 1);
+                    const startLine = Math.max(1, ((_p = (_m = (_l = r.startLine) !== null && _l !== void 0 ? _l : r.start_line) !== null && _m !== void 0 ? _m : (_o = r.generated_metadata) === null || _o === void 0 ? void 0 : _o.start_line) !== null && _p !== void 0 ? _p : 0) + 1);
                     const defs = Array.isArray(r.defined_symbols)
                         ? r.defined_symbols
                         : [];
                     const symbol = defs[0] || "";
-                    const role = ((_p = r.role) !== null && _p !== void 0 ? _p : "")
+                    const role = ((_q = r.role) !== null && _q !== void 0 ? _q : "")
                         .slice(0, 4)
                         .toUpperCase();
                     let hint = "";
@@ -650,7 +708,7 @@ Examples:
                     }
                     else {
                         // Extract first meaningful signature line from content
-                        const raw = (_r = (_q = r.content) !== null && _q !== void 0 ? _q : r.text) !== null && _r !== void 0 ? _r : "";
+                        const raw = (_s = (_r = r.content) !== null && _r !== void 0 ? _r : r.text) !== null && _s !== void 0 ? _s : "";
                         const lines = raw.split("\n");
                         for (const line of lines) {
                             const trimmed = line.trim();
@@ -692,12 +750,17 @@ Examples:
                 }
             }
             // Agent trace (compact)
-            if (options.symbol && vectorDb && filteredData.length > 0) {
+            if (options.symbol && filteredData.length > 0) {
                 try {
-                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
-                    const builder = new GraphBuilder(vectorDb, effectiveRoot);
-                    const graph = yield builder.buildGraphMultiHop(pattern, 1);
-                    if (graph.center) {
+                    let graph = precomputedGraph;
+                    if (!graph) {
+                        if (!vectorDb)
+                            throw new Error("no graph source");
+                        const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
+                        const builder = new GraphBuilder(vectorDb, effectiveRoot);
+                        graph = yield builder.buildGraphMultiHop(pattern, 1);
+                    }
+                    if (graph === null || graph === void 0 ? void 0 : graph.center) {
                         console.log("---");
                         for (const t of graph.callerTree) {
                             const rel = t.node.file.startsWith(effectiveRoot)
@@ -715,12 +778,12 @@ Examples:
                         }
                     }
                 }
-                catch (_11) { }
+                catch (_12) { }
             }
             return;
         }
         if (options.skeleton) {
-            yield outputSkeletons(filteredData, projectRoot, parseInt(options.m, 10), vectorDb);
+            yield outputSkeletons(filteredData, projectRoot, parseInt(options.m, 10), vectorDb, precomputedSkeletons);
             return;
         }
         if (!filteredData.length) {
@@ -747,9 +810,9 @@ Examples:
             let shown = 0;
             console.log(resultCountHeader(filteredData, parseInt(options.m, 10)));
             for (const r of filteredData) {
-                const absP = (_u = (_s = r.path) !== null && _s !== void 0 ? _s : (_t = r.metadata) === null || _t === void 0 ? void 0 : _t.path) !== null && _u !== void 0 ? _u : "";
-                const startLine = (_y = (_w = (_v = r.startLine) !== null && _v !== void 0 ? _v : r.start_line) !== null && _w !== void 0 ? _w : (_x = r.generated_metadata) === null || _x === void 0 ? void 0 : _x.start_line) !== null && _y !== void 0 ? _y : 0;
-                const endLine = (_2 = (_0 = (_z = r.endLine) !== null && _z !== void 0 ? _z : r.end_line) !== null && _0 !== void 0 ? _0 : (_1 = r.generated_metadata) === null || _1 === void 0 ? void 0 : _1.end_line) !== null && _2 !== void 0 ? _2 : startLine;
+                const absP = (_v = (_t = r.path) !== null && _t !== void 0 ? _t : (_u = r.metadata) === null || _u === void 0 ? void 0 : _u.path) !== null && _v !== void 0 ? _v : "";
+                const startLine = (_z = (_x = (_w = r.startLine) !== null && _w !== void 0 ? _w : r.start_line) !== null && _x !== void 0 ? _x : (_y = r.generated_metadata) === null || _y === void 0 ? void 0 : _y.start_line) !== null && _z !== void 0 ? _z : 0;
+                const endLine = (_3 = (_1 = (_0 = r.endLine) !== null && _0 !== void 0 ? _0 : r.end_line) !== null && _1 !== void 0 ? _1 : (_2 = r.generated_metadata) === null || _2 === void 0 ? void 0 : _2.end_line) !== null && _3 !== void 0 ? _3 : startLine;
                 const relPath = absP.startsWith(projectRoot)
                     ? absP.slice(projectRoot.length + 1)
                     : absP;
@@ -782,7 +845,7 @@ Examples:
                     tokensUsed += blobTokens;
                     shown++;
                 }
-                catch (_12) {
+                catch (_13) {
                     console.log(`\n--- ${relPath} (file not readable) ---`);
                     shown++;
                 }
@@ -799,7 +862,7 @@ Examples:
         if (options.imports) {
             const seenFiles = new Set();
             for (const r of filteredData) {
-                const absP = (_5 = (_3 = r.path) !== null && _3 !== void 0 ? _3 : (_4 = r.metadata) === null || _4 === void 0 ? void 0 : _4.path) !== null && _5 !== void 0 ? _5 : "";
+                const absP = (_6 = (_4 = r.path) !== null && _4 !== void 0 ? _4 : (_5 = r.metadata) === null || _5 === void 0 ? void 0 : _5.path) !== null && _6 !== void 0 ? _6 : "";
                 if (absP && !seenFiles.has(absP)) {
                     seenFiles.add(absP);
                     const imports = getImportsForFile(absP);
@@ -826,7 +889,7 @@ Examples:
                 for (const r of filteredData) {
                     const b = r.scoreBreakdown;
                     if (b) {
-                        const absP = (_8 = (_6 = r.path) !== null && _6 !== void 0 ? _6 : (_7 = r.metadata) === null || _7 === void 0 ? void 0 : _7.path) !== null && _8 !== void 0 ? _8 : "";
+                        const absP = (_9 = (_7 = r.path) !== null && _7 !== void 0 ? _7 : (_8 = r.metadata) === null || _8 === void 0 ? void 0 : _8.path) !== null && _9 !== void 0 ? _9 : "";
                         const relPath = absP.startsWith(projectRoot)
                             ? absP.slice(projectRoot.length + 1)
                             : absP;
@@ -845,12 +908,17 @@ Examples:
             console.log(output);
         }
         // Symbol mode: append call graph
-        if (options.symbol && vectorDb) {
+        if (options.symbol) {
             try {
-                const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
-                const builder = new GraphBuilder(vectorDb, effectiveRoot);
-                const graph = yield builder.buildGraphMultiHop(pattern, 1);
-                if (graph.center) {
+                let graph = precomputedGraph;
+                if (!graph) {
+                    if (!vectorDb)
+                        throw new Error("no graph source");
+                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
+                    const builder = new GraphBuilder(vectorDb, effectiveRoot);
+                    graph = yield builder.buildGraphMultiHop(pattern, 1);
+                }
+                if (graph === null || graph === void 0 ? void 0 : graph.center) {
                     const lines = ["\n--- Call graph ---"];
                     const centerRel = path.relative(effectiveRoot, graph.center.file);
                     lines.push(`${graph.center.symbol} [${graph.center.role}] ${centerRel}:${graph.center.line + 1}`);
@@ -883,7 +951,7 @@ Examples:
                     console.log(lines.join("\n"));
                 }
             }
-            catch (_13) {
+            catch (_14) {
                 // Trace failed — skip silently
             }
         }
@@ -903,13 +971,13 @@ Examples:
                 source: "cli",
                 tool: "search",
                 query: pattern,
-                project: (_9 = (0, project_root_1.findProjectRoot)(root)) !== null && _9 !== void 0 ? _9 : root,
+                project: (_10 = (0, project_root_1.findProjectRoot)(root)) !== null && _10 !== void 0 ? _10 : root,
                 results: _searchResultCount,
                 ms: Date.now() - _searchStartMs,
                 error: _searchError,
             });
         }
-        catch (_14) { }
+        catch (_15) { }
         if (vectorDb) {
             try {
                 yield vectorDb.close();

package/dist/lib/daemon/daemon.js

@@ -62,6 +62,8 @@ const config_1 = require("../../config");
 const batch_processor_1 = require("../index/batch-processor");
 const syncer_1 = require("../index/syncer");
 const watcher_1 = require("../index/watcher");
+const searcher_1 = require("../search/searcher");
+const retriever_1 = require("../skeleton/retriever");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
 const process_1 = require("../utils/process");
@@ -76,11 +78,28 @@ const log_rotate_1 = require("../utils/log-rotate");
 const pool_1 = require("../workers/pool");
 const node_child_process_1 = require("node:child_process");
 const http = __importStar(require("node:http"));
-const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+// 30 min was too aggressive — every shutdown is a chance for races, FSEvents
+// drops, and orphan MLX cleanup. 4 hours keeps the daemon resident through a
+// normal workday while still freeing resources overnight. Override with
+// GMAX_DAEMON_IDLE_TIMEOUT_MS=<ms>; set to 0 (or negative) to disable.
+const DEFAULT_IDLE_TIMEOUT_MS = 4 * 60 * 60 * 1000;
+const IDLE_TIMEOUT_MS = (() => {
+    const raw = process.env.GMAX_DAEMON_IDLE_TIMEOUT_MS;
+    if (raw == null)
+        return DEFAULT_IDLE_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return DEFAULT_IDLE_TIMEOUT_MS;
+    return parsed; // <= 0 disables the idle check below
+})();
 const HEARTBEAT_INTERVAL_MS = 60 * 1000;
+// 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"
 class Daemon {
     constructor() {
         this.processors = new Map();
+        this.searchers = new Map();
         this.subscriptions = new Map();
         this.vectorDb = null;
         this.metaCache = null;
@@ -94,6 +113,7 @@ class Daemon {
         this.pendingOps = new Set();
         this.watcherFailCount = new Map();
         this.pollIntervals = new Map();
+        this.pollRecoveryTimers = new Map();
         this.lastOverflowMs = new Map();
         this.lastCatchupEndMs = new Map();
         this.projectLocks = new Map();
@@ -270,14 +290,63 @@ class Daemon {
                 catch (_a) { }
                 (0, log_rotate_1.rotateLogFds)(path.join(config_1.PATHS.logsDir, "daemon.log"));
             }, HEARTBEAT_INTERVAL_MS);
-            // 10. Idle timeout
-            this.idleInterval = setInterval(() => {
-                if (Date.now() - this.lastActivity > IDLE_TIMEOUT_MS) {
-                    console.log("[daemon] Idle for 30 minutes, shutting down");
+            // 10. Idle timeout (skip when disabled via env)
+            if (IDLE_TIMEOUT_MS > 0) {
+                this.idleInterval = setInterval(() => {
+                    var _a;
+                    if (Date.now() - this.lastActivity <= IDLE_TIMEOUT_MS)
+                        return;
+                    // Don't kick off shutdown on top of a live maintenance pass — let it
+                    // finish and check again next tick. close() awaits this anyway, but
+                    // postponing keeps shutdown paths clean and timestamps coherent.
+                    if ((_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.isMaintenanceActive())
+                        return;
+                    const minutes = Math.round(IDLE_TIMEOUT_MS / 60000);
+                    console.log(`[daemon] Idle for ${minutes} minutes, shutting down`);
                     this.shutdown();
-                }
-            }, HEARTBEAT_INTERVAL_MS);
+                }, HEARTBEAT_INTERVAL_MS);
+            }
+            else {
+                console.log("[daemon] Idle shutdown disabled (GMAX_DAEMON_IDLE_TIMEOUT_MS<=0)");
+            }
             console.log(`[daemon] Started (PID: ${process.pid}, ${this.processors.size} projects)`);
+            // Pre-warm the search hot path so the first user-facing search doesn't
+            // pay daemon-side cold costs:
+            //   - LanceDB connection open + first openTable() (~10–15s on a 5GB
+            //     index — this is the dominant cost)
+            //   - FTS index "already exists" round-trip
+            //   - Two parallel encodeQuery calls so the worker pool spawns + warms
+            //     two workers (the reaper keeps min 2 alive). With one worker busy
+            //     on a long indexing batch, the second is always free for searches.
+            // Fire-and-forget; failures are non-fatal — the next real search just
+            // pays the cost once. Delay a few seconds so we don't compete with the
+            // catchup scans dispatched on startup.
+            setTimeout(() => {
+                if (this.shuttingDown)
+                    return;
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    const t0 = Date.now();
+                    try {
+                        if (this.vectorDb) {
+                            yield this.vectorDb.ensureTable();
+                            yield this.vectorDb.createFTSIndex();
+                        }
+                        const { getWorkerPool } = yield Promise.resolve().then(() => __importStar(require("../workers/pool")));
+                        const pool = getWorkerPool();
+                        // Two parallel encodes force the pool to spawn two workers and
+                        // warm both (each worker loads Granite + ColBERT lazily on first
+                        // encode — once warmed, subsequent encodes are ~13ms).
+                        yield Promise.all([
+                            pool.encodeQuery("warmup-a"),
+                            pool.encodeQuery("warmup-b"),
+                        ]);
+                        console.log(`[daemon] Search hot path pre-warmed (${Date.now() - t0}ms)`);
+                    }
+                    catch (err) {
+                        console.log(`[daemon] Search warmup failed (non-fatal): ${err}`);
+                    }
+                }))();
+            }, 5000).unref();
         });
     }
     watchProject(root) {
@@ -394,14 +463,16 @@ class Daemon {
         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
+            // 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.
+            const sub = this.subscriptions.get(root);
+            if (sub) {
+                sub.unsubscribe().catch(() => { });
+                this.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)`);
-                // Unsubscribe the broken watcher
-                const sub = this.subscriptions.get(root);
-                if (sub) {
-                    sub.unsubscribe().catch(() => { });
-                    this.subscriptions.delete(root);
-                }
                 // Run an immediate catchup, then schedule periodic ones
                 this.catchupScan(root, processor).catch((err) => {
                     console.error(`[daemon:${name}] Poll catchup failed:`, err);
@@ -415,6 +486,10 @@ class Daemon {
                     });
                 }, POLL_INTERVAL_MS);
                 this.pollIntervals.set(root, interval);
+                // Schedule periodic attempts to climb back to native FSEvents — after
+                // a transient burst (large git checkout, npm install) the kernel
+                // buffer often calms down within an hour.
+                this.schedulePollModeRecovery(root, processor);
                 (0, watcher_store_1.registerWatcher)({
                     pid: process.pid,
                     projectRoot: root,
@@ -457,6 +532,69 @@ class Daemon {
             }))();
         }, delayMs);
     }
+    /**
+     * Once a project has fallen back to poll mode, periodically try to upgrade
+     * back to native FSEvents. The buffer overflows that triggered the fallback
+     * are usually transient (big git checkout, npm install, build output) — no
+     * point staying in 5-min poll mode forever.
+     */
+    schedulePollModeRecovery(root, processor) {
+        if (this.pollRecoveryTimers.has(root))
+            return;
+        const name = path.basename(root);
+        const timer = setInterval(() => {
+            if (this.shuttingDown)
+                return;
+            // Skip if a watcher recovery is already in flight or we're not in poll mode anymore.
+            if (!this.pollIntervals.has(root)) {
+                const t = this.pollRecoveryTimers.get(root);
+                if (t)
+                    clearInterval(t);
+                this.pollRecoveryTimers.delete(root);
+                return;
+            }
+            if (this.pendingOps.has(`recover:${root}`))
+                return;
+            void (() => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                console.log(`[daemon:${name}] Attempting to leave poll mode and reattach FSEvents...`);
+                try {
+                    // Reset failure counter so subscribeWatcher's error path treats this
+                    // as a fresh start. If it fails again, we'll fall right back into
+                    // poll mode via the same recoverWatcher path.
+                    this.watcherFailCount.delete(root);
+                    yield this.subscribeWatcher(root, processor);
+                    // 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.shuttingDown)
+                        return;
+                    const lastOverflow = (_a = this.lastOverflowMs.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`);
+                        return; // recoverWatcher will have re-armed poll mode if needed
+                    }
+                    // Healthy — drop poll mode.
+                    const pollInterval = this.pollIntervals.get(root);
+                    if (pollInterval) {
+                        clearInterval(pollInterval);
+                        this.pollIntervals.delete(root);
+                    }
+                    const recoveryTimer = this.pollRecoveryTimers.get(root);
+                    if (recoveryTimer) {
+                        clearInterval(recoveryTimer);
+                        this.pollRecoveryTimers.delete(root);
+                    }
+                    console.log(`[daemon:${name}] FSEvents recovered — poll mode disabled`);
+                }
+                catch (err) {
+                    console.error(`[daemon:${name}] Poll-mode recovery attempt failed:`, err);
+                }
+            }))();
+        }, FSEVENTS_RECOVERY_INTERVAL_MS);
+        timer.unref();
+        this.pollRecoveryTimers.set(root, timer);
+    }
     catchupScan(root, processor) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
@@ -605,12 +743,109 @@ class Daemon {
                 this.subscriptions.delete(root);
             }
             this.processors.delete(root);
+            this.searchers.delete(root);
             this.lastOverflowMs.delete(root);
             this.lastCatchupEndMs.delete(root);
             (0, watcher_store_1.unregisterWatcherByRoot)(root);
             console.log(`[daemon] Unwatched ${root}`);
         });
     }
+    /**
+     * Run a search inside the daemon, reusing the warm VectorDB connection,
+     * worker pool (with embeddings/ColBERT pre-loaded), and per-project Searcher.
+     * The CLI's in-process path costs ~17s wall + 6GB RAM per call; this drops
+     * it to <1s by avoiding cold-start.
+     *
+     * Returns a JSON-serializable response. The IPC handler writes it; the
+     * caller is responsible for binding `signal` to socket close so we abort if
+     * the client disconnects mid-search.
+     */
+    search(payload, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!this.vectorDb) {
+                return { ok: false, error: "daemon not ready" };
+            }
+            const root = payload.projectRoot;
+            if (!this.processors.has(root)) {
+                return {
+                    ok: false,
+                    error: "project not watched",
+                    hint: `run: gmax add ${root}`,
+                };
+            }
+            let searcher = this.searchers.get(root);
+            if (!searcher) {
+                searcher = new searcher_1.Searcher(this.vectorDb);
+                this.searchers.set(root, searcher);
+            }
+            this.lastActivity = Date.now();
+            let result;
+            try {
+                result = yield searcher.search(payload.query, payload.limit, { rerank: payload.rerank !== false, explain: payload.explain === true }, payload.filters, payload.pathPrefix, undefined, signal);
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+                    return { ok: false, error: "aborted" };
+                }
+                const msg = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: "search_failed", hint: msg };
+            }
+            const response = { ok: true, data: result.data };
+            if ((_a = result.warnings) === null || _a === void 0 ? void 0 : _a.length)
+                response.warnings = result.warnings;
+            // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
+            // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
+            // lookup; cheap enough to call for the top N distinct paths.
+            if (payload.includeSkeletons && result.data.length > 0) {
+                const limit = payload.skeletonLimit && payload.skeletonLimit > 0 ? payload.skeletonLimit : 5;
+                const seen = new Set();
+                const skeletons = {};
+                for (const chunk of result.data) {
+                    const p = (_b = chunk.path) !== null && _b !== void 0 ? _b : (_c = chunk.metadata) === null || _c === void 0 ? void 0 : _c.path;
+                    if (!p || seen.has(p))
+                        continue;
+                    seen.add(p);
+                    if (seen.size > limit)
+                        break;
+                    try {
+                        const sk = yield (0, retriever_1.getStoredSkeleton)(this.vectorDb, p);
+                        if (sk)
+                            skeletons[p] = sk;
+                    }
+                    catch (_d) {
+                        // best-effort — drop the entry, keep the search result
+                    }
+                }
+                if (Object.keys(skeletons).length > 0)
+                    response.skeletons = skeletons;
+            }
+            // --symbol support: build a 1-hop graph using the warm vectorDb. ~5
+            // LanceDB queries; doesn't touch the worker pool.
+            if (payload.includeGraph) {
+                try {
+                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../graph/graph-builder")));
+                    const builder = new GraphBuilder(this.vectorDb, root);
+                    response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
+                }
+                catch (_e) {
+                    // best-effort — drop graph, keep results
+                }
+            }
+            // 2 MB cap on the JSON line. Lance can return huge chunks for unusual
+            // queries (very long markdown blobs). Above this we fall back to the
+            // in-process path which writes to stdout instead of a socket.
+            const serialized = JSON.stringify(response);
+            if (serialized.length > 2 * 1024 * 1024) {
+                return {
+                    ok: false,
+                    error: "oversize",
+                    hint: `${serialized.length} bytes — falling back to in-process search`,
+                };
+            }
+            return response;
+        });
+    }
     listProjects() {
         return [...this.processors.keys()].map((root) => ({
             root,
@@ -1093,11 +1328,15 @@ class Daemon {
                 }
                 catch (_f) { }
             }
-            // Stop poll intervals
+            // Stop poll intervals + their FSEvents recovery probes
             for (const interval of this.pollIntervals.values()) {
                 clearInterval(interval);
             }
             this.pollIntervals.clear();
+            for (const interval of this.pollRecoveryTimers.values()) {
+                clearInterval(interval);
+            }
+            this.pollRecoveryTimers.clear();
             // Unsubscribe all watchers
             for (const sub of this.subscriptions.values()) {
                 try {

package/dist/lib/daemon/ipc-handler.js

@@ -120,6 +120,42 @@ function handleCommand(daemon, cmd, conn) {
                     setImmediate(() => daemon.shutdown());
                     return { ok: true };
                 }
+                case "search": {
+                    const projectRoot = String(cmd.projectRoot || "");
+                    if (!projectRoot)
+                        return { ok: false, error: "missing projectRoot" };
+                    const query = String(cmd.query || "");
+                    if (!query)
+                        return { ok: false, error: "missing query" };
+                    // Bind abort to socket close so client ctrl-C cancels the in-flight
+                    // search instead of letting it run on uselessly.
+                    const ac = new AbortController();
+                    const onClose = () => ac.abort();
+                    conn.on("close", onClose);
+                    try {
+                        const limitRaw = typeof cmd.limit === "number" ? cmd.limit : 10;
+                        const skeletonLimitRaw = typeof cmd.skeletonLimit === "number" ? cmd.skeletonLimit : undefined;
+                        const filters = cmd.filters && typeof cmd.filters === "object" && !Array.isArray(cmd.filters)
+                            ? cmd.filters
+                            : undefined;
+                        const resp = yield daemon.search({
+                            projectRoot,
+                            query,
+                            limit: limitRaw,
+                            filters,
+                            pathPrefix: typeof cmd.pathPrefix === "string" ? cmd.pathPrefix : undefined,
+                            rerank: cmd.rerank !== false,
+                            explain: cmd.explain === true,
+                            includeSkeletons: cmd.includeSkeletons === true,
+                            skeletonLimit: skeletonLimitRaw,
+                            includeGraph: cmd.includeGraph === true,
+                        }, ac.signal);
+                        return resp;
+                    }
+                    finally {
+                        conn.off("close", onClose);
+                    }
+                }
                 // --- Streaming commands (daemon manages connection) ---
                 case "add": {
                     const root = String(cmd.root || "");

package/dist/lib/index/batch-processor.js

@@ -66,6 +66,7 @@ class ProjectBatchProcessor {
         this.processing = false;
         this.closed = false;
         this.currentBatchAc = null;
+        this.lastCorruptionLogMs = 0;
         this.projectRoot = opts.projectRoot;
         this.vectorDb = opts.vectorDb;
         this.metaCache = opts.metaCache;
@@ -288,6 +289,23 @@ class ProjectBatchProcessor {
                     // Use batchTimeoutMs slot to signal finally not to reschedule at 2s
                     backoffOverrideMs = 60000;
                 }
+                else if ((0, vector_db_1.isLanceCorruptionError)(err)) {
+                    // Manifest references a missing fragment — retrying every 2s burns CPU
+                    // and floods logs without making progress. Log once per hour, drop the
+                    // batch (per-file retries would just re-fail), and back off 30 min so a
+                    // human can run `gmax index --reset` for the affected project.
+                    const now = Date.now();
+                    if (now - this.lastCorruptionLogMs > 60 * 60 * 1000) {
+                        this.lastCorruptionLogMs = now;
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[${this.wtag}] DATA CORRUPTION: LanceDB manifest references a missing fragment. ` +
+                            `Backing off this project's batch processor for 30 min. ` +
+                            `To repair, run: gmax index --reset (in ${this.projectRoot}). Original: ${msg}`);
+                    }
+                    for (const [absPath] of batch)
+                        this.retryCount.delete(absPath);
+                    backoffOverrideMs = 30 * 60 * 1000;
+                }
                 else {
                     console.error(`[${this.wtag}] Batch processing failed:`, err);
                     const { requeued, dropped, backoffMs } = (0, watcher_batch_1.computeRetryAction)(batch, this.retryCount, MAX_RETRIES, false, 0, DEBOUNCE_MS);

package/dist/lib/store/vector-db.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VectorDB = exports.DiskPressureError = void 0;
+exports.isLanceCorruptionError = isLanceCorruptionError;
 const fs = __importStar(require("node:fs"));
 const lancedb = __importStar(require("@lancedb/lancedb"));
 const apache_arrow_1 = require("apache-arrow");
@@ -57,6 +58,15 @@ class DiskPressureError extends Error {
     }
 }
 exports.DiskPressureError = DiskPressureError;
+/**
+ * Detects "Not found: <hash>.lance" errors from LanceDB — these indicate the
+ * manifest references a fragment file that doesn't exist on disk, typically
+ * caused by an interrupted compaction. Recovery requires `gmax index --reset`.
+ */
+function isLanceCorruptionError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /Not found:.*\.lance(?:[^a-z]|$)/i.test(msg);
+}
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 class VectorDB {
@@ -65,7 +75,9 @@ class VectorDB {
         this.db = null;
         this.closed = false;
         this.maintenanceRunning = false;
+        this.maintenancePromise = null;
         this.maintenanceTimer = null;
+        this.lastCorruptionLogMs = 0;
         this.diskPressure = "ok";
         this.lastDiskCheckMs = 0;
         this.lastLoggedPressure = "ok";
@@ -84,18 +96,51 @@ class VectorDB {
     startMaintenanceLoop() {
         if (this.maintenanceTimer)
             return;
-        this.maintenanceTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        this.maintenanceTimer = setInterval(() => {
             if (this.closed)
                 return;
-            try {
-                yield this.runMaintenance();
-            }
-            catch (err) {
-                (0, logger_1.log)("vectordb", `Periodic maintenance failed: ${err}`);
-            }
-        }), MAINTENANCE_INTERVAL_MS);
+            // Skip if a previous tick is still running so close() has a single
+            // promise to await instead of a chain.
+            if (this.maintenancePromise)
+                return;
+            const run = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.runMaintenance();
+                }
+                catch (err) {
+                    // Suppress the expected close-race error so it stops polluting logs.
+                    // close() awaits maintenancePromise, but the timer can fire and start
+                    // a tick microseconds before shutdown sets `closed`, in which case
+                    // getDb() throws after we've nulled `db`.
+                    const msg = err instanceof Error ? err.message : String(err);
+                    if (this.closed && msg.includes("VectorDB connection is closed"))
+                        return;
+                    if (isLanceCorruptionError(err)) {
+                        // Log once per hour at most — repeating this every 5 min is just noise.
+                        const now = Date.now();
+                        if (now - this.lastCorruptionLogMs > 60 * 60 * 1000) {
+                            this.lastCorruptionLogMs = now;
+                            (0, logger_1.log)("vectordb", `CORRUPTION: LanceDB manifest references a missing fragment file. ` +
+                                `This is usually caused by an interrupted compaction. ` +
+                                `To repair, run: gmax index --reset (per-project). Original: ${msg}`);
+                        }
+                        return;
+                    }
+                    (0, logger_1.log)("vectordb", `Periodic maintenance failed: ${err}`);
+                }
+            }))();
+            this.maintenancePromise = run.finally(() => {
+                if (this.maintenancePromise === run)
+                    this.maintenancePromise = null;
+            });
+        }, MAINTENANCE_INTERVAL_MS);
         this.maintenanceTimer.unref();
     }
+    /** True iff a maintenance tick is currently running. Used by the daemon to
+     *  defer idle shutdown so we don't tear down LanceDB mid-optimize. */
+    isMaintenanceActive() {
+        return this.maintenancePromise !== null;
+    }
     /** Pause the maintenance timer (e.g. during a full index that calls runMaintenance itself). */
     pauseMaintenanceLoop() {
         if (this.maintenanceTimer) {
@@ -387,7 +432,7 @@ class VectorDB {
         });
     }
     createFTSIndex() {
-        return __awaiter(this, arguments, void 0, function* (rebuild = false) {
+        return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5) {
             const table = yield this.ensureTable();
             if (rebuild) {
                 try {
@@ -395,29 +440,42 @@ class VectorDB {
                 }
                 catch (_a) { }
             }
-            try {
-                yield table.createIndex("content", {
-                    config: lancedb.Index.fts({ withPosition: true }),
-                });
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                if (msg.includes("already exists")) {
+            for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                    yield table.createIndex("content", {
+                        config: lancedb.Index.fts({ withPosition: true }),
+                    });
                     return;
                 }
-                // If position error, try dropping and recreating
-                if (msg.includes("position")) {
-                    try {
-                        yield table.dropIndex("content_idx");
-                        yield table.createIndex("content", {
-                            config: lancedb.Index.fts({ withPosition: true }),
-                        });
-                        (0, logger_1.log)("vectordb", "Rebuilt FTS index with position support");
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    if (msg.includes("already exists")) {
                         return;
                     }
-                    catch (_b) { }
+                    // Retry on the same Lance commit-conflict pattern that optimize() handles —
+                    // FTS rebuild and compaction race when both try to write the manifest.
+                    if (attempt < retries &&
+                        (msg.includes("conflict") || msg.includes("Retryable"))) {
+                        const delay = 1000 * Math.pow(2, (attempt - 1));
+                        (0, logger_1.log)("vectordb", `createFTSIndex conflict (attempt ${attempt}/${retries}), retrying in ${delay}ms`);
+                        yield new Promise((r) => setTimeout(r, delay));
+                        continue;
+                    }
+                    // If position error, try dropping and recreating once
+                    if (msg.includes("position")) {
+                        try {
+                            yield table.dropIndex("content_idx");
+                            yield table.createIndex("content", {
+                                config: lancedb.Index.fts({ withPosition: true }),
+                            });
+                            (0, logger_1.log)("vectordb", "Rebuilt FTS index with position support");
+                            return;
+                        }
+                        catch (_b) { }
+                    }
+                    console.warn("Failed to create FTS index:", e);
+                    return;
                 }
-                console.warn("Failed to create FTS index:", e);
             }
         });
     }
@@ -740,6 +798,15 @@ class VectorDB {
                 clearInterval(this.maintenanceTimer);
                 this.maintenanceTimer = null;
             }
+            // Drain in-flight maintenance before tearing down the connection — otherwise
+            // optimize/createIndex will hit a null db and log "VectorDB connection is closed".
+            if (this.maintenancePromise) {
+                yield Promise.race([
+                    this.maintenancePromise,
+                    new Promise((resolve) => setTimeout(resolve, 10000)),
+                ]);
+                this.maintenancePromise = null;
+            }
             (_a = this.unregisterCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
             this.unregisterCleanup = undefined;
             if (this.db) {

package/dist/lib/workers/pool.js

@@ -111,9 +111,17 @@ function resolveProcessWorker() {
     throw new Error("Process worker file not found");
 }
 const IDLE_WORKER_TIMEOUT_MS = 60000; // reap idle workers after 60s
+// Methods that must skip the indexing backlog. encodeQuery is the search hot
+// path: a single query is ~17ms but waits behind every queued processFile.
+// rerank is similarly small and latency-sensitive.
+const PRIORITY_METHODS = new Set(["encodeQuery", "rerank"]);
 class WorkerPool {
     constructor() {
         this.workers = [];
+        // Two queues so searches don't wait behind a long indexing backlog. Priority
+        // tasks (encodeQuery/rerank) are dispatched first; processFile tasks queue
+        // in the regular queue. FIFO is preserved within each priority class.
+        this.priorityQueue = [];
         this.taskQueue = [];
         this.tasks = new Map();
         this.abortedTasks = new Set();
@@ -141,6 +149,9 @@ class WorkerPool {
         }
     }
     removeFromQueue(taskId) {
+        const pi = this.priorityQueue.indexOf(taskId);
+        if (pi !== -1)
+            this.priorityQueue.splice(pi, 1);
         const idx = this.taskQueue.indexOf(taskId);
         if (idx !== -1)
             this.taskQueue.splice(idx, 1);
@@ -170,10 +181,11 @@ class WorkerPool {
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
             // Only respawn if we have no workers left or there are pending tasks
-            const hasPendingTasks = this.taskQueue.some((id) => {
+            const hasUnassigned = (queue) => queue.some((id) => {
                 const t = this.tasks.get(id);
                 return t && !t.worker;
             });
+            const hasPendingTasks = hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
             if (this.workers.length === 0 || hasPendingTasks) {
                 this.consecutiveRespawns++;
                 (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after exit (workers=${this.workers.length} pending=${hasPendingTasks})`);
@@ -269,10 +281,14 @@ class WorkerPool {
             };
             if (signal) {
                 signal.addEventListener("abort", () => {
-                    // If task is still in queue, remove it
+                    // If task is still queued (in either queue), remove it
+                    const pi = this.priorityQueue.indexOf(id);
+                    if (pi !== -1)
+                        this.priorityQueue.splice(pi, 1);
                     const idx = this.taskQueue.indexOf(id);
-                    if (idx !== -1) {
-                        this.taskQueue.splice(idx, 1);
+                    if (pi !== -1 || idx !== -1) {
+                        if (idx !== -1)
+                            this.taskQueue.splice(idx, 1);
                         this.tasks.delete(id);
                         const err = new Error("Aborted");
                         err.name = "AbortError";
@@ -292,7 +308,12 @@ class WorkerPool {
                 }, { once: true });
             }
             this.tasks.set(id, task);
-            this.taskQueue.push(id);
+            if (PRIORITY_METHODS.has(method)) {
+                this.priorityQueue.push(id);
+            }
+            else {
+                this.taskQueue.push(id);
+            }
             this.dispatch();
         });
     }
@@ -318,14 +339,17 @@ class WorkerPool {
         this.dispatch();
     }
     dispatch() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         if (this.destroyed)
             return;
         let idle = this.workers.find((w) => !w.busy);
-        const nextTaskId = this.taskQueue.find((id) => {
+        // Drain priority queue first so search tasks never wait behind an
+        // indexing batch.
+        const findUnassigned = (queue) => queue.find((id) => {
             const t = this.tasks.get(id);
             return t && !t.worker;
         });
+        const nextTaskId = (_a = findUnassigned(this.priorityQueue)) !== null && _a !== void 0 ? _a : findUnassigned(this.taskQueue);
         if (nextTaskId === undefined)
             return;
         // Lazy spawn: if no idle worker and below max, spawn one
@@ -346,9 +370,9 @@ class WorkerPool {
         task.worker = idle;
         task.startTime = Date.now();
         task.timeout = setTimeout(() => this.handleTaskTimeout(task, idle), TASK_TIMEOUT_MS);
-        const filePath = (_d = (_b = (_a = task.payload) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : (_c = task.payload) === null || _c === void 0 ? void 0 : _c.absolutePath) !== null && _d !== void 0 ? _d : "";
+        const filePath = (_e = (_c = (_b = task.payload) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : (_d = task.payload) === null || _d === void 0 ? void 0 : _d.absolutePath) !== null && _e !== void 0 ? _e : "";
         const busyCount = this.workers.filter((w) => w.busy).length;
-        (0, logger_1.debug)("pool", `dispatch task=${task.id} method=${task.method}${filePath ? ` file=${filePath}` : ""} → PID:${idle.child.pid} (busy=${busyCount}/${this.workers.length} queue=${this.taskQueue.length})`);
+        (0, logger_1.debug)("pool", `dispatch task=${task.id} method=${task.method}${filePath ? ` file=${filePath}` : ""} → PID:${idle.child.pid} (busy=${busyCount}/${this.workers.length} queue=${this.taskQueue.length}+${this.priorityQueue.length}p)`);
         try {
             idle.child.send({
                 id: task.id,
@@ -375,16 +399,19 @@ class WorkerPool {
         return this.enqueue("rerank", input, signal);
     }
     /**
-     * Reap idle workers back down to 1. Keeps the most recently active worker.
-     * Called on a timer — never removes the last worker or busy workers.
+     * Reap idle workers back down to MIN_KEEP. Keeps the most recently active.
+     * Called on a timer — never removes busy workers. Min=2 so a search task
+     * always has spare capacity even when one worker is busy with a long
+     * indexing batch (a fresh worker takes 10–15s to boot + load models, which
+     * dwarfs a ~13ms encodeQuery).
      */
     reapIdleWorkers() {
-        if (this.destroyed || this.workers.length <= 1)
+        const MIN_KEEP = 2;
+        if (this.destroyed || this.workers.length <= MIN_KEEP)
             return;
         const now = Date.now();
         const toReap = this.workers.filter((w) => !w.busy && now - w.lastBusyTime > IDLE_WORKER_TIMEOUT_MS);
-        // Always keep at least 1 worker alive
-        const keepCount = Math.max(1, this.workers.length - toReap.length);
+        const keepCount = Math.max(MIN_KEEP, this.workers.length - toReap.length);
         const reapCount = this.workers.length - keepCount;
         if (reapCount <= 0)
             return;
@@ -420,6 +447,7 @@ class WorkerPool {
             }
             this.tasks.clear();
             this.taskQueue = [];
+            this.priorityQueue = [];
             const killPromises = this.workers.map((w) => new Promise((resolve) => {
                 w.child.removeAllListeners("message");
                 w.child.removeAllListeners("exit");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.15.6",
+  "version": "0.16.0",
   "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.15.6",
+  "version": "0.16.0",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",