grepmax 0.15.4 → 0.15.6

package/dist/commands/add.js

@@ -43,6 +43,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.add = void 0;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const grammar_loader_1 = require("../lib/index/grammar-loader");
@@ -56,10 +58,41 @@ const project_marker_1 = require("../lib/utils/project-marker");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
 const watcher_launcher_1 = require("../lib/utils/watcher-launcher");
+function getBlockedRoots() {
+    const home = os.homedir();
+    return new Set([
+        home,
+        path.dirname(home),
+        "/",
+        "/tmp",
+        "/private",
+        "/private/tmp",
+        "/private/var",
+        "/var",
+        "/usr",
+        "/opt",
+        "/etc",
+        "/System",
+        "/Library",
+        "/Applications",
+    ].map((p) => path.resolve(p)));
+}
+function logBlockedAttempt(reason, attempted, extra) {
+    var _a, _b;
+    try {
+        const logPath = path.join(os.homedir(), ".gmax", "logs", "blocked-add.log");
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        const entry = Object.assign({ ts: new Date().toISOString(), reason,
+            attempted, cwd: process.cwd(), pid: process.pid, ppid: process.ppid, argv: process.argv, env_claude_session: (_a = process.env.CLAUDE_SESSION_ID) !== null && _a !== void 0 ? _a : null, env_claude_project_dir: (_b = process.env.CLAUDE_PROJECT_DIR) !== null && _b !== void 0 ? _b : null }, extra);
+        fs.appendFileSync(logPath, `${JSON.stringify(entry)}\n`);
+    }
+    catch (_c) { }
+}
 exports.add = new commander_1.Command("add")
     .description("Add a project to the gmax index")
     .argument("[dir]", "Directory to add (defaults to current directory)")
     .option("--no-index", "Register the project without indexing it")
+    .option("--force", "Allow adding a parent of existing projects (will REMOVE absorbed children)")
     .addHelpText("after", `
 Examples:
   gmax add                     Add the current directory
@@ -73,6 +106,16 @@ Examples:
         const targetDir = dir ? path.resolve(dir) : process.cwd();
         const projectRoot = (_a = (0, project_root_1.findProjectRoot)(targetDir)) !== null && _a !== void 0 ? _a : targetDir;
         const projectName = path.basename(projectRoot);
+        const blocked = getBlockedRoots();
+        if (blocked.has(path.resolve(projectRoot))) {
+            logBlockedAttempt("blocked_root", projectRoot);
+            console.error(`Refusing to add ${projectRoot}: this path is blocked from indexing.\n` +
+                `(Blocked: home, /, /Users, /tmp, /private, /var, /usr, /opt, /etc, /System, /Library, /Applications.)\n` +
+                `Pick a specific project subdirectory instead.\n` +
+                `Diagnostic logged to ~/.gmax/logs/blocked-add.log (cwd=${process.cwd()} ppid=${process.ppid}).`);
+            process.exitCode = 1;
+            return;
+        }
         // Check if already registered
         const existing = (0, project_registry_1.getProject)(projectRoot);
         if (existing) {
@@ -90,6 +133,17 @@ Examples:
         // If this is a parent of existing projects, absorb them
         const children = (0, project_registry_1.getChildProjects)(projectRoot);
         if (children.length > 0) {
+            if (!opts.force) {
+                logBlockedAttempt("would_absorb_children", projectRoot, {
+                    children: children.map((c) => ({ name: c.name, root: c.root })),
+                });
+                console.error(`Refusing to add ${projectRoot}: would absorb ${children.length} existing project(s):\n` +
+                    `${children.map((c) => `  - ${c.name} (${c.root})`).join("\n")}\n` +
+                    `Re-run with --force to proceed (this will REMOVE the listed projects and their indexed data).\n` +
+                    `Diagnostic logged to ~/.gmax/logs/blocked-add.log (cwd=${process.cwd()} ppid=${process.ppid}).`);
+                process.exitCode = 1;
+                return;
+            }
             const names = children.map((c) => c.name).join(", ");
             console.log(`Absorbing ${children.length} sub-project(s): ${names}`);
             const { ensureDaemonRunning: checkDaemon, sendStreamingCommand: sendCmd } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));

package/dist/commands/mcp.js

@@ -53,7 +53,6 @@ exports.mcp = void 0;
 exports.toStringArray = toStringArray;
 exports.ok = ok;
 exports.err = err;
-const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
@@ -363,8 +362,6 @@ exports.mcp = new commander_1.Command("mcp")
     let _searcher = null;
     let _skeletonizer = null;
     let _indexReady = false;
-    let _indexing = false;
-    let _indexProgress = "";
     const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         if (_vectorDb) {
             try {
@@ -421,70 +418,15 @@ exports.mcp = new commander_1.Command("mcp")
         });
     }
     // --- Index sync ---
-    let _indexChildPid = null;
-    function isIndexProcessRunning() {
-        if (!_indexChildPid)
-            return false;
-        try {
-            process.kill(_indexChildPid, 0);
-            return true;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
     function ensureIndexReady() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             if (_indexReady)
                 return;
-            // Check if a previously spawned index process finished
-            if (_indexing && !isIndexProcessRunning()) {
-                _indexing = false;
-                _indexProgress = "";
-                _indexChildPid = null;
-            }
-            // Check project registry — more reliable than querying the DB.
-            // Avoids false negatives from lock contention and cascade re-indexing.
             const projects = (0, project_registry_1.listProjects)();
             const isRegistered = projects.some((p) => p.root === projectRoot);
             if (isRegistered) {
                 _indexReady = true;
-                return;
             }
-            // Truly first-time: no registry entry at all
-            if (_indexing)
-                return;
-            _indexing = true;
-            _indexProgress = "starting...";
-            console.log("[MCP] First-time setup for this project...");
-            const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "add", projectRoot], { detached: true, stdio: "ignore" });
-            _indexChildPid = (_a = child.pid) !== null && _a !== void 0 ? _a : null;
-            child.unref();
-            _indexProgress = `PID ${_indexChildPid}`;
-            const indexTimeout = setTimeout(() => {
-                try {
-                    child.kill("SIGKILL");
-                }
-                catch (_a) { }
-                _indexing = false;
-                _indexProgress = "";
-                _indexChildPid = null;
-                console.error("[MCP] Background indexing timed out after 30 minutes");
-            }, 30 * 60 * 1000);
-            child.on("exit", (code) => {
-                clearTimeout(indexTimeout);
-                _indexing = false;
-                _indexProgress = "";
-                _indexChildPid = null;
-                if (code === 0) {
-                    _indexReady = true;
-                    console.log("[MCP] First-time setup complete.");
-                }
-                else {
-                    console.error(`[MCP] Indexing failed (exit code: ${code})`);
-                }
-            });
         });
     }
     // --- Background watcher ---
@@ -511,12 +453,11 @@ exports.mcp = new commander_1.Command("mcp")
             const searchAll = isSearchAll || args.scope === "all";
             const limit = Math.min(Math.max(Number(args.limit) || 3, 1), 50);
             ensureWatcher();
-            if (_indexing) {
-                return ok(`Indexing in progress (${_indexProgress}). Results may be incomplete or empty — try again shortly.`);
-            }
-            // Check if project is pending or has no chunks
             const proj = (0, project_registry_1.getProject)(projectRoot);
-            if ((proj === null || proj === void 0 ? void 0 : proj.status) === "pending" || (proj && proj.chunkCount === 0)) {
+            if (!proj) {
+                return err("Project not added to gmax yet. Run `gmax add` to index it first.");
+            }
+            if (proj.status === "pending" || proj.chunkCount === 0) {
                 return err("Project not indexed yet. Run `gmax add` to index it first.");
             }
             try {
@@ -875,8 +816,9 @@ exports.mcp = new commander_1.Command("mcp")
             const symbol = String(args.symbol || "");
             if (!symbol)
                 return err("Missing required parameter: symbol");
-            if (_indexing) {
-                return ok(`Indexing in progress (${_indexProgress}). trace_calls requires a complete index — try again shortly.`);
+            const proj = (0, project_registry_1.getProject)(projectRoot);
+            if (!proj) {
+                return err("Project not added to gmax yet. Run `gmax add` to index it first.");
             }
             try {
                 const db = getVectorDb();
@@ -1177,8 +1119,9 @@ exports.mcp = new commander_1.Command("mcp")
             const pattern = typeof args.pattern === "string" ? args.pattern : undefined;
             const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
             const pathPrefix = typeof args.path === "string" ? args.path : undefined;
-            if (_indexing) {
-                return ok(`Indexing in progress (${_indexProgress}). list_symbols requires a complete index — try again shortly.`);
+            const proj = (0, project_registry_1.getProject)(projectRoot);
+            if (!proj) {
+                return err("Project not added to gmax yet. Run `gmax add` to index it first.");
             }
             try {
                 const db = getVectorDb();
@@ -1273,9 +1216,6 @@ exports.mcp = new commander_1.Command("mcp")
                         watcherLine += " — search results may be incomplete";
                     }
                 }
-                const indexingLine = _indexing
-                    ? `Indexing: in progress (${_indexProgress})`
-                    : "";
                 const lines = [
                     `Index: ~/.gmax/lancedb (${stats.chunks} chunks, ${fileCount} files)`,
                     `Model: ${globalConfig.embedMode === "gpu" ? ((_d = (_c = (_b = config_1.MODEL_TIERS[globalConfig.modelTier]) === null || _b === void 0 ? void 0 : _b.mlxModel) !== null && _c !== void 0 ? _c : config === null || config === void 0 ? void 0 : config.embedModel) !== null && _d !== void 0 ? _d : "unknown") : ((_e = config === null || config === void 0 ? void 0 : config.embedModel) !== null && _e !== void 0 ? _e : "unknown")} (${(_f = config === null || config === void 0 ? void 0 : config.vectorDim) !== null && _f !== void 0 ? _f : "?"}d, ${globalConfig.embedMode})`,
@@ -1283,7 +1223,6 @@ exports.mcp = new commander_1.Command("mcp")
                         ? `Last indexed: ${config.indexedAt}`
                         : "",
                     watcherLine,
-                    indexingLine,
                     "",
                     "Indexed directories:",
                     ...(yield Promise.all(projects.map((p) => __awaiter(this, void 0, void 0, function* () {

package/dist/commands/watch.js

@@ -81,7 +81,7 @@ exports.watch = new commander_1.Command("watch")
             // Skip spawn if daemon already running at the same version.
             // If version mismatches (e.g. after npm install -g), shut down the old
             // daemon so we can start a fresh one with the new code.
-            const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+            const { isDaemonRunning, isDaemonHeartbeatFresh, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
             if (yield isDaemonRunning()) {
                 const cliVersion = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8")).version;
                 const resp = yield sendDaemonCommand({ cmd: "ping" });
@@ -89,10 +89,23 @@ exports.watch = new commander_1.Command("watch")
                     process.exit(0);
                 }
                 console.log(`Daemon version mismatch (${resp.version} → ${cliVersion}), restarting...`);
-                yield sendDaemonCommand({ cmd: "shutdown" });
+                yield sendDaemonCommand({
+                    cmd: "shutdown",
+                    reason: "version-mismatch",
+                    from_pid: process.pid,
+                    from_ppid: process.ppid,
+                    from_version: cliVersion,
+                    from_argv: process.argv.slice(0, 4),
+                });
                 // Brief wait for old daemon to release socket/lock
                 yield new Promise((r) => setTimeout(r, 2000));
             }
+            else if (isDaemonHeartbeatFresh()) {
+                // Ping failed but daemon.lock mtime is fresh — another daemon is
+                // alive but too busy to answer (e.g. mid-index). Don't spawn a
+                // competitor; the startup code would only kill the busy peer.
+                process.exit(0);
+            }
             const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
             const out = (0, log_rotate_1.openRotatedLog)(logFile);
             const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon"], {
@@ -126,7 +139,7 @@ exports.watch = new commander_1.Command("watch")
         process.on("SIGTERM", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
         process.on("uncaughtException", (err) => {
             console.error("[daemon] uncaughtException:", err);
-            daemon.shutdown().then(() => process.exit(1));
+            daemon.shutdown().then(() => (0, exit_1.gracefulExit)(1));
         });
         process.on("unhandledRejection", (reason) => {
             console.error("[daemon] unhandledRejection:", reason);
@@ -298,7 +311,20 @@ exports.watch
     let stoppedDaemon = false;
     // Try shutting down daemon first
     if (yield isDaemonRunning()) {
-        yield sendDaemonCommand({ cmd: "shutdown" });
+        let parentCmd = "?";
+        try {
+            const { execSync } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+            parentCmd = execSync(`ps -o command= -p ${process.ppid}`, { encoding: "utf8" }).trim();
+        }
+        catch (_b) { }
+        yield sendDaemonCommand({
+            cmd: "shutdown",
+            reason: "gmax-watch-stop",
+            from_pid: process.pid,
+            from_ppid: process.ppid,
+            from_argv: process.argv.slice(0, 4),
+            from_parent_cmd: parentCmd,
+        });
         console.log("Daemon stopped.");
         stoppedDaemon = true;
     }

package/dist/lib/daemon/daemon.js

@@ -71,9 +71,9 @@ const server_1 = require("../llm/server");
 const ipc_handler_1 = require("./ipc-handler");
 const logger_1 = require("../utils/logger");
 const daemon_client_1 = require("../utils/daemon-client");
-const watcher_store_2 = require("../utils/watcher-store");
 const index_config_1 = require("../index/index-config");
 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
@@ -104,26 +104,8 @@ class Daemon {
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             process.title = "gmax-daemon";
-            // 0. Singleton enforcement: check PID file for existing daemon
-            try {
-                const pidStr = fs.readFileSync(config_1.PATHS.daemonPidFile, "utf-8").trim();
-                const existingPid = parseInt(pidStr, 10);
-                if (existingPid && existingPid !== process.pid && (0, watcher_store_2.isProcessRunning)(existingPid)) {
-                    (0, logger_1.log)("daemon", `found existing daemon PID:${existingPid}, checking socket...`);
-                    const responsive = yield (0, daemon_client_1.isDaemonRunning)();
-                    if (responsive) {
-                        (0, logger_1.log)("daemon", "existing daemon is responsive — exiting");
-                        process.exit(0);
-                    }
-                    // Unresponsive but alive — kill it
-                    (0, logger_1.log)("daemon", `existing daemon PID:${existingPid} unresponsive — killing`);
-                    yield (0, process_1.killProcess)(existingPid);
-                    (0, logger_1.log)("daemon", `killed stale daemon PID:${existingPid}`);
-                }
-            }
-            catch (_a) {
-                // No PID file or unreadable — proceed normally
-            }
+            // 0. Singleton enforcement: find and kill ALL stale daemon/worker processes
+            yield this.killStaleProcesses();
             // 1. Acquire exclusive lock — kernel-enforced, atomic, auto-released on death
             fs.mkdirSync(path.dirname(config_1.PATHS.daemonLockFile), { recursive: true });
             fs.writeFileSync(config_1.PATHS.daemonLockFile, "", { flag: "a" }); // ensure file exists
@@ -158,7 +140,7 @@ class Daemon {
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_b) { }
+            catch (_a) { }
             this.server = net.createServer((conn) => {
                 (0, logger_1.debug)("daemon", "client connected");
                 let buf = "";
@@ -259,13 +241,25 @@ class Daemon {
                     console.error(`[daemon] Failed to watch ${path.basename(p.root)}:`, err);
                 }
             }
-            // 8b. Index pending/error projects in the background
+            // 8b. Index pending/error projects in the background, serialized to avoid
+            // racing on shared LanceDB table creation (only one ensureTable() may win the
+            // first createTable; the rest crash with "Table 'chunks' already exists").
+            // Re-check shuttingDown each iteration: shutdown's pendingLocks drain is a
+            // snapshot, so a new project op kicked off after the snapshot would race
+            // with vectorDb.close() and fail with "VectorDB connection is closed".
             const pending = allProjects.filter((p) => (p.status === "pending" || p.status === "error") && fs.existsSync(p.root));
-            for (const p of pending) {
-                this.indexPendingProject(p.root).catch((err) => {
-                    console.error(`[daemon] Failed to index pending ${path.basename(p.root)}:`, err);
-                });
-            }
+            void (() => __awaiter(this, void 0, void 0, function* () {
+                for (const p of pending) {
+                    if (this.shuttingDown)
+                        return;
+                    try {
+                        yield this.indexPendingProject(p.root);
+                    }
+                    catch (err) {
+                        console.error(`[daemon] Failed to index pending ${path.basename(p.root)}:`, err);
+                    }
+                }
+            }))();
             // 9. Heartbeat + refresh lockfile mtime to prevent stale detection
             this.heartbeatInterval = setInterval(() => {
                 (0, watcher_store_1.heartbeat)(process.pid);
@@ -560,6 +554,11 @@ class Daemon {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
                 var _a;
+                // Bail if shutdown raced ahead of us between IIFE iteration and lock
+                // acquisition — otherwise we'd start writing to a DB that shutdown is
+                // about to close, leaving the project status as "error".
+                if (this.shuttingDown)
+                    return;
                 if (!this.vectorDb || !this.metaCache)
                     return;
                 const name = path.basename(root);
@@ -968,14 +967,92 @@ class Daemon {
     }
     stopMlxServer() {
         var _a;
-        if (!((_a = this.mlxChild) === null || _a === void 0 ? void 0 : _a.pid))
-            return;
-        try {
-            process.kill(this.mlxChild.pid, "SIGTERM");
+        // The spawned process is `uv`, which forks `python` then exits. Killing the
+        // recorded PID alone leaves python orphaned (the orphan source for port 8100
+        // collisions across daemon restarts). Always also kill whoever owns the port.
+        if ((_a = this.mlxChild) === null || _a === void 0 ? void 0 : _a.pid) {
+            try {
+                process.kill(-this.mlxChild.pid, "SIGTERM");
+            }
+            catch (_b) {
+                try {
+                    process.kill(this.mlxChild.pid, "SIGTERM");
+                }
+                catch (_c) { }
+            }
             console.log(`[daemon] Stopped MLX embed server (PID: ${this.mlxChild.pid})`);
+            this.mlxChild = null;
+        }
+        const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+        const portOwner = this.getPortPid(port);
+        if (portOwner) {
+            try {
+                process.kill(portOwner, "SIGTERM");
+                console.log(`[daemon] Killed orphan MLX on port ${port} (PID: ${portOwner})`);
+            }
+            catch (_d) { }
+        }
+    }
+    /**
+     * Find and kill all stale gmax-daemon and gmax-worker processes.
+     * Uses pgrep to scan by process title rather than relying solely on
+     * the PID file, which becomes stale when a daemon is orphaned through
+     * the lock-compromise path.
+     */
+    killStaleProcesses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Check for other daemon processes
+            const daemonPids = this.findProcessesByTitle("gmax-daemon")
+                .filter((pid) => pid !== process.pid);
+            const workerPids = this.findProcessesByTitle("gmax-worker");
+            if (daemonPids.length === 0 && workerPids.length === 0) {
+                (0, logger_1.log)("daemon", "No stale processes found");
+                return;
+            }
+            for (const pid of daemonPids) {
+                (0, logger_1.log)("daemon", `found daemon PID:${pid}, checking liveness...`);
+                // A busy daemon (mid-index, compaction, big LMDB write) can block the
+                // event loop long enough to miss a ping. Two independent liveness
+                // probes — if either says "alive", defer to the running peer instead
+                // of killing its workers mid-flight.
+                //   1. daemon.lock mtime (refreshed by heartbeat every 60s)
+                //   2. socket ping with a generous 10s timeout
+                const heartbeatFresh = (0, daemon_client_1.isDaemonHeartbeatFresh)();
+                const responsive = yield (0, daemon_client_1.isDaemonRunning)({ timeoutMs: 10000 });
+                if (heartbeatFresh || responsive) {
+                    (0, logger_1.log)("daemon", `existing daemon PID:${pid} is alive (heartbeat=${heartbeatFresh} ping=${responsive}) — exiting`);
+                    process.exit(0);
+                }
+                (0, logger_1.log)("daemon", `stale daemon PID:${pid} unresponsive and heartbeat stale — killing`);
+                yield (0, process_1.killProcess)(pid);
+                (0, logger_1.log)("daemon", `killed stale daemon PID:${pid}`);
+            }
+            // 2. Kill orphaned workers from previous daemon instances.
+            // Safe because this runs before the new daemon's worker pool is initialized.
+            for (const pid of workerPids) {
+                (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
+                yield (0, process_1.killProcess)(pid);
+            }
+            (0, logger_1.log)("daemon", `Cleaned up ${daemonPids.length} stale daemon(s), ${workerPids.length} orphaned worker(s)`);
+        });
+    }
+    findProcessesByTitle(title) {
+        try {
+            const out = (0, node_child_process_1.execSync)(`pgrep -x "${title}"`, {
+                timeout: 5000,
+                encoding: "utf-8",
+            }).trim();
+            if (!out)
+                return [];
+            return out
+                .split("\n")
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => Number.isFinite(n) && n > 0);
+        }
+        catch (_a) {
+            // pgrep exits 1 when no processes match — not an error
+            return [];
         }
-        catch (_b) { }
-        this.mlxChild = null;
     }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1009,6 +1086,13 @@ class Daemon {
             catch (_e) { }
             // Stop MLX embed server if we started it
             this.stopMlxServer();
+            // Destroy worker pool to prevent orphaned child processes
+            if ((0, pool_1.isWorkerPoolInitialized)()) {
+                try {
+                    yield (0, pool_1.destroyWorkerPool)();
+                }
+                catch (_f) { }
+            }
             // Stop poll intervals
             for (const interval of this.pollIntervals.values()) {
                 clearInterval(interval);
@@ -1019,7 +1103,7 @@ class Daemon {
                 try {
                     yield sub.unsubscribe();
                 }
-                catch (_f) { }
+                catch (_g) { }
             }
             this.subscriptions.clear();
             // Close server + socket + PID file + lock
@@ -1027,16 +1111,16 @@ class Daemon {
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_g) { }
+            catch (_h) { }
             try {
                 fs.unlinkSync(config_1.PATHS.daemonPidFile);
             }
-            catch (_h) { }
+            catch (_j) { }
             if (this.releaseLock) {
                 try {
                     yield this.releaseLock();
                 }
-                catch (_j) { }
+                catch (_k) { }
                 this.releaseLock = null;
             }
             // Unregister all
@@ -1049,11 +1133,11 @@ class Daemon {
             try {
                 yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_k) { }
+            catch (_l) { }
             try {
                 yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
             }
-            catch (_l) { }
+            catch (_m) { }
             console.log("[daemon] Shutdown complete");
         });
     }

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

@@ -81,6 +81,7 @@ function writeDone(conn, data) {
  */
 function handleCommand(daemon, cmd, conn) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
         try {
             (0, logger_1.debug)("daemon", `ipc cmd=${cmd.cmd}${cmd.root ? ` root=${cmd.root}` : ""}`);
             switch (cmd.cmd) {
@@ -108,10 +109,17 @@ function handleCommand(daemon, cmd, conn) {
                         projects: daemon.listProjects(),
                         diskPressure: daemon.getDiskPressure(),
                     };
-                case "shutdown":
-                    // Respond before shutting down so the client gets the response
+                case "shutdown": {
+                    const reason = String((_a = cmd.reason) !== null && _a !== void 0 ? _a : "unknown");
+                    const fromPid = (_b = cmd.from_pid) !== null && _b !== void 0 ? _b : "?";
+                    const fromPpid = (_c = cmd.from_ppid) !== null && _c !== void 0 ? _c : "?";
+                    const fromVer = (_d = cmd.from_version) !== null && _d !== void 0 ? _d : "?";
+                    const fromArgv = Array.isArray(cmd.from_argv) ? cmd.from_argv.join(" ") : "?";
+                    const fromParentCmd = (_e = cmd.from_parent_cmd) !== null && _e !== void 0 ? _e : "?";
+                    console.log(`[daemon] shutdown command received via IPC: reason=${reason} from_pid=${fromPid} from_ppid=${fromPpid} from_version=${fromVer} from_argv=[${fromArgv}] from_parent_cmd=[${fromParentCmd}]`);
                     setImmediate(() => daemon.shutdown());
                     return { ok: true };
+                }
                 // --- Streaming commands (daemon manages connection) ---
                 case "add": {
                     const root = String(cmd.root || "");

package/dist/lib/utils/daemon-client.js

@@ -44,11 +44,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.isDaemonRunning = isDaemonRunning;
+exports.isDaemonHeartbeatFresh = isDaemonHeartbeatFresh;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.sendStreamingCommand = sendStreamingCommand;
+const fs = __importStar(require("node:fs"));
 const net = __importStar(require("node:net"));
 const config_1 = require("../../config");
 const DEFAULT_TIMEOUT_MS = 5000;
+// A live daemon refreshes daemon.lock mtime every 60s (HEARTBEAT_INTERVAL_MS).
+// Treat mtime younger than 2.5x that as proof of life, even if a ping times
+// out — a busy daemon with a blocked event loop can still be heartbeating.
+const HEARTBEAT_FRESH_THRESHOLD_MS = 150000;
 /**
  * Send a JSON command to the daemon over the Unix domain socket.
  * Returns the parsed response, or {ok: false, error} on failure.
@@ -100,14 +106,32 @@ function sendDaemonCommand(cmd, opts) {
     });
 }
 /**
- * Check if the daemon is running by sending a ping.
+ * Check if the daemon is running by sending a ping. Pass a larger timeoutMs
+ * when a busy daemon is plausible (e.g. before killing what might be a live
+ * peer) — the default 2s is tight enough that a daemon blocking the event
+ * loop mid-index can miss it.
  */
-function isDaemonRunning() {
+function isDaemonRunning(opts) {
     return __awaiter(this, void 0, void 0, function* () {
-        const resp = yield sendDaemonCommand({ cmd: "ping" }, { timeoutMs: 2000 });
+        var _a;
+        const resp = yield sendDaemonCommand({ cmd: "ping" }, { timeoutMs: (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : 2000 });
         return resp.ok === true;
     });
 }
+/**
+ * Lock-file-based liveness probe. A running daemon refreshes daemon.lock's
+ * mtime every 60s via its heartbeat loop; a fresh mtime means the daemon is
+ * alive even if its socket ping times out under load.
+ */
+function isDaemonHeartbeatFresh() {
+    try {
+        const stats = fs.statSync(config_1.PATHS.daemonLockFile);
+        return Date.now() - stats.mtimeMs < HEARTBEAT_FRESH_THRESHOLD_MS;
+    }
+    catch (_a) {
+        return false;
+    }
+}
 /**
  * Ensure the daemon is running — start it if needed, poll up to 5s.
  * Returns true if daemon is ready, false if it couldn't be started.

package/package.json

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

package/plugins/grepmax/hooks/cwd-changed.js

@@ -1,6 +1,6 @@
 const fs = require("node:fs");
 const _path = require("node:path");
-const { spawn, execFileSync } = require("node:child_process");
+const { execFileSync } = require("node:child_process");
 
 function readStdin() {
   return new Promise((resolve) => {
@@ -34,51 +34,19 @@ function isProjectRegistered(dir) {
   }
 }
 
-function isGitRepo(dir) {
-  try {
-    // Walk up to find .git (handles worktrees and nested repos)
-    let current = dir;
-    while (current !== _path.dirname(current)) {
-      if (fs.existsSync(_path.join(current, ".git"))) return true;
-      current = _path.dirname(current);
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-
 async function main() {
   const input = await readStdin();
   const newCwd = input.new_cwd || process.cwd();
 
-  // Already indexed — nothing to do
-  if (isProjectRegistered(newCwd)) return;
-
-  // Only auto-add git repos
-  if (!isGitRepo(newCwd)) return;
+  if (!isProjectRegistered(newCwd)) return;
 
-  // Spawn `gmax add` fully detached so it doesn't block the hook timeout
   try {
-    const child = spawn("gmax", ["add", newCwd], {
-      detached: true,
-      stdio: "ignore",
-    });
-    child.unref();
+    execFileSync("gmax", ["watch", "--daemon", "-b"], { timeout: 5000, stdio: "ignore" });
   } catch {
-    // gmax not in PATH or spawn failed — silently ignore
-    return;
+    try {
+      execFileSync("gmax", ["watch", "-b"], { timeout: 5000, stdio: "ignore" });
+    } catch {}
   }
-
-  // Tell Claude that indexing is starting
-  const dirName = _path.basename(newCwd);
-  const response = {
-    hookSpecificOutput: {
-      hookEventName: "CwdChanged",
-      additionalContext: `gmax: indexing "${dirName}" in background. Search results may be incomplete until indexing finishes. Run Bash(gmax status) to check progress.`,
-    },
-  };
-  process.stdout.write(JSON.stringify(response));
 }
 
 main();

package/plugins/grepmax/hooks/stop.js

@@ -1,6 +1,9 @@
-try {
-  const { execFileSync } = require("node:child_process");
-  execFileSync("gmax", ["watch", "stop"], { timeout: 5000, stdio: "ignore" });
-} catch {
-  // Watcher may not be running or gmax not in PATH — ignore
-}
+// Intentionally a no-op.
+//
+// Previously this ran `gmax watch stop` on every Claude SessionEnd. With
+// multiple concurrent Claude sessions sharing one daemon, that meant *any*
+// session ending killed the daemon for every *other* session — silently
+// breaking their search/index and forcing repeated daemon restarts.
+//
+// The daemon's own 30-minute idle timeout handles cleanup when nothing is
+// using it, so SessionEnd has no work to do here.