grepmax 0.26.16 → 0.26.19

package/.claude-plugin/marketplace.json

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

package/dist/commands/add.js

@@ -54,6 +54,7 @@ const sync_helpers_1 = require("../lib/index/sync-helpers");
 const syncer_1 = require("../lib/index/syncer");
 const setup_helpers_1 = require("../lib/setup/setup-helpers");
 const vector_db_1 = require("../lib/store/vector-db");
+const autostart_1 = require("../lib/utils/autostart");
 const blocked_roots_1 = require("../lib/utils/blocked-roots");
 const exit_1 = require("../lib/utils/exit");
 const project_marker_1 = require("../lib/utils/project-marker");
@@ -98,6 +99,12 @@ Examples:
             process.exitCode = 1;
             return;
         }
+        if ((0, blocked_roots_1.isGitWorktreeRoot)(projectRoot)) {
+            logBlockedAttempt("git_worktree", projectRoot);
+            console.error(`Refusing to add ${projectRoot}: ${blocked_roots_1.WORKTREE_REFUSAL}`);
+            process.exitCode = 1;
+            return;
+        }
         // Check if already registered
         const existing = (0, project_registry_1.getProject)(projectRoot);
         if (existing) {
@@ -220,6 +227,12 @@ Examples:
         }
         else {
             // Fallback: direct mode with lock
+            const notice = (0, autostart_1.autostartDisabledNotice)();
+            if (notice) {
+                spinner.stop();
+                console.log(notice);
+                spinner.start();
+            }
             const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
             vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
             try {

package/dist/commands/index.js

@@ -51,6 +51,7 @@ const sync_helpers_1 = require("../lib/index/sync-helpers");
 const syncer_1 = require("../lib/index/syncer");
 const setup_helpers_1 = require("../lib/setup/setup-helpers");
 const vector_db_1 = require("../lib/store/vector-db");
+const autostart_1 = require("../lib/utils/autostart");
 const exit_1 = require("../lib/utils/exit");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
@@ -149,6 +150,9 @@ Examples:
         }
         else {
             // Fallback: direct mode with lock — stop any watcher first
+            const notice = (0, autostart_1.autostartDisabledNotice)();
+            if (notice)
+                console.log(notice);
             const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
             vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
             let restartWatcher = false;

package/dist/config.js

@@ -229,6 +229,10 @@ exports.PATHS = {
     // never SIGKILLs a peer mid-cleanup once the peer has already dropped its
     // socket/PID/lock liveness markers.
     daemonDrainingFile: path.join(GLOBAL_ROOT, "daemon.draining"),
+    // Kill switch for implicit daemon auto-start (see lib/utils/autostart.ts).
+    // Its presence stops hooks and CLI commands from reviving a quarantined
+    // daemon; explicit `gmax watch --daemon` still works.
+    autostartDisabledFile: path.join(GLOBAL_ROOT, "autostart-disabled"),
     // Centralized index storage — one database for all indexed directories
     lancedbDir: path.join(GLOBAL_ROOT, "lancedb"),
     cacheDir: path.join(GLOBAL_ROOT, "cache"),

package/dist/lib/daemon/daemon.js

@@ -59,6 +59,7 @@ const server_1 = require("../llm/server");
 const meta_cache_1 = require("../store/meta-cache");
 const store_lease_1 = require("../store/store-lease");
 const vector_db_1 = require("../store/vector-db");
+const blocked_roots_1 = require("../utils/blocked-roots");
 const daemon_client_1 = require("../utils/daemon-client");
 const daemon_launcher_1 = require("../utils/daemon-launcher");
 const kernel_zone_1 = require("../utils/kernel-zone");
@@ -789,6 +790,10 @@ class Daemon {
                         return;
                     }
                     const project = (0, project_registry_1.getProject)(root);
+                    if (!project && (0, blocked_roots_1.isGitWorktreeRoot)(root)) {
+                        (0, ipc_handler_1.writeDone)(conn, { ok: false, error: blocked_roots_1.WORKTREE_REFUSAL });
+                        return;
+                    }
                     if ((project === null || project === void 0 ? void 0 : project.status) === "indexed") {
                         if (!this.activeGeneration ||
                             (0, embedding_generation_1.compareEmbeddingGeneration)(project, this.activeGeneration)
@@ -854,6 +859,10 @@ class Daemon {
                 (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
                 return;
             }
+            if (!(0, project_registry_1.getProject)(root) && (0, blocked_roots_1.isGitWorktreeRoot)(root)) {
+                (0, ipc_handler_1.writeDone)(conn, { ok: false, error: blocked_roots_1.WORKTREE_REFUSAL });
+                return;
+            }
             if (!(0, project_registry_1.getProject)(root)) {
                 (0, project_registry_1.registerProject)({
                     root,

package/dist/lib/store/store-lease.js

@@ -47,6 +47,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoreLease = exports.StoreLeaseTimeoutError = void 0;
 exports.storeLeasePaths = storeLeasePaths;
+exports.defaultProbeOwner = defaultProbeOwner;
 exports.hasStoreExclusiveIntent = hasStoreExclusiveIntent;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
@@ -97,19 +98,37 @@ function currentProcessStart(pid) {
         return fallback;
     }
 }
-function defaultProbeOwner(owner) {
+const defaultProbeDeps = {
+    signal: (pid) => {
+        process.kill(pid, 0);
+    },
+    processStartOf: (pid) => (0, node_child_process_1.execFileSync)("ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf8",
+        timeout: 1000,
+    }).trim(),
+};
+function defaultProbeOwner(owner, deps = defaultProbeDeps) {
     try {
-        process.kill(owner.pid, 0);
+        deps.signal(owner.pid);
     }
     catch (error) {
-        return error.code === "ESRCH"
-            ? "dead"
-            : "unknown";
+        const code = error.code;
+        if (code === "ESRCH")
+            return "dead";
+        // EPERM means the PID exists but is not signalable by us -- the signature
+        // of a recycled PID that now belongs to another user. That is not evidence
+        // the lease owner is alive, so fall through to the processStart comparison
+        // below, which `ps` answers across user boundaries. Returning "unknown"
+        // here instead would make the reader marker immortal and hang every
+        // exclusive operation for the life of the store.
+        if (code !== "EPERM")
+            return "unknown";
     }
     if (owner.processStart.startsWith(`pid:${owner.pid}:started:`))
         return "same";
     try {
-        const start = (0, node_child_process_1.execFileSync)("ps", ["-p", String(owner.pid), "-o", "lstart="], { encoding: "utf8", timeout: 1000 }).trim();
+        const start = deps.processStartOf(owner.pid);
+        // Reserve "unknown" for a start-time lookup that could not answer.
         if (!start)
             return "unknown";
         return start === owner.processStart ? "same" : "reused";

package/dist/lib/utils/autostart.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autostartDisabledReason = autostartDisabledReason;
+exports.isAutostartDisabled = isAutostartDisabled;
+exports.autostartDisabledNotice = autostartDisabledNotice;
+const fs = __importStar(require("node:fs"));
+const config_1 = require("../../config");
+/**
+ * Kill switch for *implicit* daemon auto-start. Create
+ * ~/.gmax/autostart-disabled (or export GMAX_NO_AUTOSTART=1) to keep session
+ * hooks and ordinary commands (`gmax add`, `gmax index`, search, MCP) from
+ * reviving the daemon — needed when the host is quarantined and the daemon's
+ * write volume is the thing under investigation.
+ *
+ * Explicit `gmax watch --daemon` is never gated: typing it is the user asking
+ * for a daemon in that moment.
+ *
+ * plugins/grepmax/hooks/start.js carries a plain-JS copy of these semantics
+ * (env var checked first, then the file) because a SessionStart hook cannot
+ * import from dist. Keep the two in sync.
+ */
+function autostartDisabledReason() {
+    if (process.env.GMAX_NO_AUTOSTART === "1")
+        return "env";
+    try {
+        return fs.existsSync(config_1.PATHS.autostartDisabledFile) ? "file" : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function isAutostartDisabled() {
+    return autostartDisabledReason() !== null;
+}
+/**
+ * One-line notice for commands that fell back to in-process work because the
+ * kill switch is on, or null when it isn't. Names the specific undo step so
+ * the message is actionable whichever way autostart was disabled.
+ */
+function autostartDisabledNotice() {
+    const reason = autostartDisabledReason();
+    if (!reason)
+        return null;
+    const undo = reason === "env"
+        ? "unset GMAX_NO_AUTOSTART"
+        : `rm ${config_1.PATHS.autostartDisabledFile}`;
+    return `Daemon autostart is disabled — running in-process. Re-enable with: ${undo}`;
+}

package/dist/lib/utils/blocked-roots.js

@@ -33,9 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLOCKED_ROOTS_DESCRIPTION = void 0;
+exports.WORKTREE_REFUSAL = exports.BLOCKED_ROOTS_DESCRIPTION = void 0;
 exports.getBlockedProjectRoots = getBlockedProjectRoots;
 exports.isBlockedProjectRoot = isBlockedProjectRoot;
+exports.isGitWorktreeRoot = isGitWorktreeRoot;
+const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 exports.BLOCKED_ROOTS_DESCRIPTION = "home, /, /Users, /tmp, /private, /var, /usr, /opt, /etc, /System, /Library, /Applications";
@@ -61,3 +63,27 @@ function getBlockedProjectRoots() {
 function isBlockedProjectRoot(root) {
     return getBlockedProjectRoots().has(path.resolve(root));
 }
+/**
+ * A linked git worktree has a `.git` FILE (not a directory) pointing back into
+ * the main repo's `.git/worktrees/<name>`. Indexing one duplicates the whole
+ * corpus of the repo it was cut from — three platform worktrees once put 680k
+ * duplicate chunks in the index and pinned seven embed workers at ~1GB each.
+ */
+function isGitWorktreeRoot(root) {
+    const gitPath = path.join(path.resolve(root), ".git");
+    let contents;
+    try {
+        if (!fs.statSync(gitPath).isFile())
+            return false;
+        contents = fs.readFileSync(gitPath, "utf8");
+    }
+    catch (_a) {
+        return false;
+    }
+    const match = /^gitdir:\s*(.+)$/m.exec(contents);
+    if (!(match === null || match === void 0 ? void 0 : match[1]))
+        return false;
+    const gitdir = match[1].trim().replace(/\\/g, "/");
+    return /(^|\/)\.git\/worktrees\//.test(gitdir);
+}
+exports.WORKTREE_REFUSAL = "gmax does not index git worktrees — they duplicate the repository they were cut from. Add the main repository root instead.";

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

@@ -269,12 +269,19 @@ function isDaemonDraining(pid) {
 /**
  * Ensure the daemon is running — start it if needed, then wait for resources.
  * Returns true if daemon is ready, false if it couldn't be started.
+ *
+ * This is the implicit spawn path, so it honors the autostart kill switch: with
+ * it on, an already-running daemon is still used, but a dead one is not
+ * revived and callers fall back to in-process work.
  */
 function ensureDaemonRunning() {
     return __awaiter(this, void 0, void 0, function* () {
         if (yield isDaemonReady())
             return true;
         if (!(yield isDaemonRunning())) {
+            const { isAutostartDisabled } = yield Promise.resolve().then(() => __importStar(require("./autostart")));
+            if (isAutostartDisabled())
+                return false;
             const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
             const pid = yield spawnDaemon();
             if (!pid)

package/dist/lib/utils/project-registry.js

@@ -63,6 +63,7 @@ const path = __importStar(require("node:path"));
 const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
 const config_1 = require("../../config");
 const embedding_generation_1 = require("../index/embedding-generation");
+const blocked_roots_1 = require("./blocked-roots");
 const REGISTRY_PATH = path.join(config_1.PATHS.globalRoot, "projects.json");
 const REBUILD_JOURNAL_PATH = path.join(config_1.PATHS.globalRoot, "rebuild-journal.json");
 class ProjectRegistryConflictError extends Error {
@@ -207,6 +208,10 @@ function registerProject(entry) {
     }
     withRegistryLock(() => {
         const entries = loadRegistry();
+        if (!entries.some((e) => e.root === entry.root) &&
+            (0, blocked_roots_1.isGitWorktreeRoot)(entry.root)) {
+            throw new Error(`${blocked_roots_1.WORKTREE_REFUSAL} (${entry.root})`);
+        }
         let canonicalRoot;
         try {
             canonicalRoot = fs.realpathSync(entry.root);

package/dist/lib/utils/watcher-launcher.js

@@ -16,6 +16,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchWatcher = launchWatcher;
 const node_child_process_1 = require("node:child_process");
+const autostart_1 = require("./autostart");
 const daemon_client_1 = require("./daemon-client");
 const daemon_launcher_1 = require("./daemon-launcher");
 const project_registry_1 = require("./project-registry");
@@ -48,7 +49,13 @@ function launchWatcher(projectRoot) {
         if (resp.ok && typeof resp.pid === "number") {
             return { ok: true, pid: resp.pid, reused: true };
         }
-        // 4. Daemon not running — try to start it, poll until ready
+        // 4. Daemon not running — try to start it, poll until ready.
+        // Both remaining steps spawn a background process, so stop here when the
+        // autostart kill switch is on: a quarantined daemon must stay down.
+        const notice = (0, autostart_1.autostartDisabledNotice)();
+        if (notice) {
+            return { ok: false, reason: "autostart-disabled", message: notice };
+        }
         const error = resp.error;
         if (error === "ENOENT" || error === "ECONNREFUSED") {
             const daemonPid = yield (0, daemon_launcher_1.spawnDaemon)();

package/package.json

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

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

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

package/plugins/grepmax/hooks/start.js

@@ -82,6 +82,9 @@ function isProjectRegistered() {
 // GMAX_NO_AUTOSTART=1) to keep sessions from reviving the daemon — needed when the
 // host is quarantined after a kernel-zone incident and the daemon's write volume is
 // the thing under investigation. Delete the file to restore normal behavior.
+//
+// The CLI honors the same switch via src/lib/utils/autostart.ts (PATHS.autostartDisabledFile).
+// This copy exists because a hook cannot import from dist — keep the two in sync.
 function isAutostartDisabled() {
   if (process.env.GMAX_NO_AUTOSTART === "1") return true;
   try {