grepmax 0.15.3 → 0.15.5

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/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/index/ignore-patterns.js

@@ -33,6 +33,7 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     ".gradle",
     ".m2",
     "vendor",
+    ".claude",
     ".gmax",
     ".gmax.json",
     // Minified/generated assets

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.3",
+  "version": "0.15.5",
   "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.3",
+  "version": "0.15.5",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

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.