grepmax 0.26.14 → 0.26.16

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.14",
+      "version": "0.26.16",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/lib/daemon/daemon.js

@@ -61,6 +61,7 @@ const store_lease_1 = require("../store/store-lease");
 const vector_db_1 = require("../store/vector-db");
 const daemon_client_1 = require("../utils/daemon-client");
 const daemon_launcher_1 = require("../utils/daemon-launcher");
+const kernel_zone_1 = require("../utils/kernel-zone");
 const keyed_mutex_1 = require("../utils/keyed-mutex");
 const log_rotate_1 = require("../utils/log-rotate");
 const logger_1 = require("../utils/logger");
@@ -127,6 +128,8 @@ class Daemon {
         this.heartbeatInterval = null;
         this.idleInterval = null;
         this.heartbeatTick = 0;
+        /** Rate-limits the kernel-zone warn log — see checkKernelZonePressure. */
+        this.lastZoneWarnMs = 0;
         this.shuttingDown = false;
         this.recycling = false;
         // False until LanceDB + MetaCache are open. The socket starts listening early
@@ -406,6 +409,7 @@ class Daemon {
                     void this.mlxServerManager.checkMlxHealth();
                     this.processManager.sweepOrphanWorkers();
                     this.maybeRecycle();
+                    this.checkKernelZonePressure();
                 }
             }, HEARTBEAT_INTERVAL_MS);
             // 10. Idle timeout (skip when disabled via env)
@@ -1698,6 +1702,50 @@ class Daemon {
         this.recycling = true;
         void this.shutdown({ relaunch: true }).finally(() => process.exit(0));
     }
+    /**
+     * Stand down before our own write volume exhausts a leaking kernel zone.
+     *
+     * On macOS 26.5.2 sustained filesystem writes leak `data.kalloc.1024`
+     * irreversibly, and exhausting it panics the host with no warning of any kind —
+     * the daemon does not get to observe the failure, it just dies with the machine.
+     * This host lost three sessions that way before the compactor was identified as
+     * the largest write source on it.
+     *
+     * So the daemon watches the zone it is pressurizing. A warn-level reading is
+     * logged and left alone; a critical reading exits without relaunch, because
+     * relaunching would resume the writes that caused it. Nothing here can reclaim
+     * the leaked memory — only a reboot does that — so the only useful move is to
+     * stop adding to it while the user still has a working machine.
+     *
+     * Deliberately does nothing when the sample is unavailable or unparseable
+     * (non-macOS, no `zprint`, changed output format): an unknown reading must never
+     * shut the daemon down.
+     */
+    checkKernelZonePressure() {
+        if (this.shuttingDown || this.recycling)
+            return;
+        const usage = (0, kernel_zone_1.readKernelZoneUsage)();
+        if (!usage || usage.pressure === "ok")
+            return;
+        if (usage.pressure === "warn") {
+            // Rate-limited to once an hour: at the 5-minute heartbeat this would
+            // otherwise print 12 identical lines an hour for as long as the condition
+            // holds, which on a leaking host is until reboot.
+            const now = Date.now();
+            if (now - this.lastZoneWarnMs < 60 * 60 * 1000)
+                return;
+            this.lastZoneWarnMs = now;
+            console.log(`[daemon] WARNING: ${(0, kernel_zone_1.formatZoneUsage)(usage)} — macOS kernel zone is leaking ` +
+                `under write pressure. The daemon will stop itself at ` +
+                `${(kernel_zone_1.ZONE_THRESHOLDS.criticalBytes / Math.pow(1024, 3)).toFixed(0)}GiB. ` +
+                `Only a reboot reclaims this memory.`);
+            return;
+        }
+        console.log(`[daemon] CRITICAL: ${(0, kernel_zone_1.formatZoneUsage)(usage)} — stopping to avoid a kernel panic. ` +
+            `Reboot to reclaim the zone; the index will catch up on next start.`);
+        this.recycling = true;
+        void this.shutdown().finally(() => process.exit(0));
+    }
     shutdown(opts = {}) {
         if (!this.shutdownPromise) {
             this.shutdownPromise = this.performShutdown(opts);

package/dist/lib/index/syncer.js

@@ -324,9 +324,13 @@ function initialSync(options) {
                         yield currentFlush;
                         (0, logger_1.debug)("index", `flush done: ${Date.now() - flushStart}ms`);
                         flushCount++;
-                        // Periodically compact during sync to prevent fragment accumulation
+                        // Periodically compact during sync to prevent fragment accumulation.
+                        // Uses the shared threshold deliberately: a hardcoded 30 here meant
+                        // the full-index path kept compacting at the old rate long after the
+                        // threshold was raised to 400, re-triggering the whole-table rewrite
+                        // that raising it exists to avoid.
                         if (flushCount % 10 === 0) {
-                            yield vectorDb.compactIfNeeded(30);
+                            yield vectorDb.compactIfNeeded(config_1.FRAGMENT_COMPACT_THRESHOLD);
                         }
                     }
                     catch (err) {

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

@@ -157,6 +157,36 @@ function isMissingTableError(err) {
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 const CLEAN_MAINTENANCE_INTERVAL_MS = 60 * 60 * 1000;
+/**
+ * Floor between opportunistic full-table compactions.
+ *
+ * A compaction rewrites the whole table, so its cost scales with store size, not
+ * with how much changed. Neither opportunistic caller was rate-limited: the
+ * 5-minute maintenance tick re-optimizes whenever the write epoch moved, and
+ * `compactIfNeeded` fires whenever small fragments cross a threshold. On a store
+ * under continuous reindex pressure both are true essentially always, so the
+ * table gets rewritten every few minutes forever.
+ *
+ * That is not hypothetical. On 2026-08-16..17 this store (16 GB) took 43 full
+ * compactions in two days — an accelerating 6 → 30 → 63 → 54 per day — which a
+ * microstackshot measured as 549.76 GB of file-backed writes in 12.3 hours. On
+ * macOS 26.5.2 that write volume exhausted the `data.kalloc.1024` kernel zone and
+ * panicked the host. See docs/2026-08-04-macos-kernel-zone-panic-incident.md.
+ *
+ * The floor caps compaction at twice an hour regardless of how much churn arrives.
+ * Fragments accumulating between passes cost read performance, which is recoverable;
+ * unbounded rewrite volume was not.
+ */
+const COMPACTION_MIN_INTERVAL_MS = 30 * 60 * 1000;
+/**
+ * Ceiling for the unproductive-compaction backoff.
+ *
+ * A compaction that removes no fragments and frees no bytes rewrote the table for
+ * nothing, and the next one a few minutes later will almost certainly do the same.
+ * The interval doubles on each such pass and resets the moment one does real work,
+ * so a store that cannot be improved stops paying for the attempt.
+ */
+const COMPACTION_MAX_INTERVAL_MS = 6 * 60 * 60 * 1000;
 class VectorDB {
     constructor(lancedbDir, vectorDim, suppliedLease) {
         this.lancedbDir = lancedbDir;
@@ -174,6 +204,9 @@ class VectorDB {
         /** Only an index owner may create/rebuild shared indexes — see markIndexOwner. */
         this.indexOwner = false;
         this.lastOptimizeDidWork = false;
+        /** Compaction rate limiter — see COMPACTION_MIN_INTERVAL_MS. */
+        this.lastCompactionMs = 0;
+        this.compactionIntervalMs = COMPACTION_MIN_INTERVAL_MS;
         this.maintenanceRunner = (fn) => fn();
         /** Latched when a from-scratch FTS rebuild failed to stop an optimize
          *  panic. Stops the (expensive) rebuild from re-running every maintenance
@@ -1152,13 +1185,30 @@ class VectorDB {
                 }
                 yield this.createFTSIndex();
                 yield this.createVectorIndex();
-                if (pressure === "low") {
+                // Index creation above is idempotent and self-guarding, so it stays on the
+                // 5-minute cadence. Compaction is the expensive half — it rewrites the whole
+                // table — and gets rate-limited. Without this the tick compacts every 5
+                // minutes for as long as writes keep arriving, which is how this store
+                // reached 43 full rewrites in two days and panicked the host.
+                const throttleMs = options.force
+                    ? 0
+                    : this.compactionThrottleRemainingMs();
+                if (throttleMs > 0) {
+                    (0, logger_1.debug)("vectordb", `Compaction throttled — ${Math.ceil(throttleMs / 60000)}min until next full pass ` +
+                        `(interval ${Math.round(this.compactionIntervalMs / 60000)}min)`);
+                }
+                else if (pressure === "low") {
                     (0, logger_1.log)("vectordb", `Low disk — single-pass optimize (no bloat retry)`);
                     yield this.optimize(1, 0, true);
+                    this.noteCompaction(this.lastOptimizeDidWork);
                 }
                 else {
                     // Normal maintenance: full optimize + bloat check
                     yield this.optimize(5, 0, true);
+                    // Track across both passes: `lastOptimizeDidWork` is reset per optimize()
+                    // call, so a productive first pass followed by a barren bloat retry would
+                    // otherwise read as unproductive and trigger a spurious backoff.
+                    let didWork = this.lastOptimizeDidWork;
                     if (this.lastOptimizeDidWork) {
                         const table = yield this.openExistingTableUnsafe();
                         if (table) {
@@ -1180,9 +1230,11 @@ class VectorDB {
                                 (0, logger_1.log)("vectordb", `Bloat detected after optimize: ${(diskSize / 1024 / 1024).toFixed(0)}MB disk vs ${(logicalSize / 1024 / 1024).toFixed(0)}MB logical (${bloatRatio.toFixed(1)}x) — retrying`);
                                 yield new Promise((r) => setTimeout(r, 2000));
                                 yield this.optimize(5, 0, true);
+                                didWork = didWork || this.lastOptimizeDidWork;
                             }
                         }
                     }
+                    this.noteCompaction(didWork);
                 }
                 const maintainedTable = yield this.openExistingTableUnsafe();
                 this.maintainedTableVersion =
@@ -1195,6 +1247,47 @@ class VectorDB {
             }
         });
     }
+    /**
+     * Milliseconds until an opportunistic full-table compaction is allowed again,
+     * or 0 if one may run now. Forced callers (`gmax index`, `doctor --fix`) are
+     * expected to bypass this rather than consult it.
+     */
+    compactionThrottleRemainingMs(now = Date.now()) {
+        if (this.lastCompactionMs === 0)
+            return 0;
+        const elapsed = now - this.lastCompactionMs;
+        // A clock that jumped backwards would otherwise wedge compaction shut.
+        if (elapsed < 0)
+            return 0;
+        return Math.max(0, this.compactionIntervalMs - elapsed);
+    }
+    /**
+     * Record a completed compaction and adjust the interval. Productive passes reset
+     * to the floor; unproductive ones double up to the ceiling so a store that cannot
+     * be improved stops being rewritten every few minutes.
+     */
+    noteCompaction(didWork) {
+        this.lastCompactionMs = Date.now();
+        if (didWork) {
+            if (this.compactionIntervalMs !== COMPACTION_MIN_INTERVAL_MS) {
+                (0, logger_1.debug)("vectordb", "Productive compaction — interval reset to floor");
+            }
+            this.compactionIntervalMs = COMPACTION_MIN_INTERVAL_MS;
+            return;
+        }
+        const next = Math.min(this.compactionIntervalMs * 2, COMPACTION_MAX_INTERVAL_MS);
+        if (next !== this.compactionIntervalMs) {
+            (0, logger_1.log)("vectordb", `Compaction reclaimed nothing — backing off to ${Math.round(next / 60000)}min`);
+        }
+        this.compactionIntervalMs = next;
+    }
+    /** Test/diagnostic view of the rate limiter. */
+    getCompactionThrottleState() {
+        return {
+            intervalMs: this.compactionIntervalMs,
+            remainingMs: this.compactionThrottleRemainingMs(),
+        };
+    }
     compactIfNeeded() {
         return __awaiter(this, arguments, void 0, function* (threshold = config_1.FRAGMENT_COMPACT_THRESHOLD) {
             if (this.maintenanceRunning)
@@ -1206,8 +1299,14 @@ class VectorDB {
                 const table = yield this.ensureTable();
                 const stats = yield table.stats();
                 if (stats.fragmentStats.numSmallFragments > threshold) {
+                    const throttleMs = this.compactionThrottleRemainingMs();
+                    if (throttleMs > 0) {
+                        (0, logger_1.debug)("vectordb", `Fragment threshold exceeded (${stats.fragmentStats.numSmallFragments} > ${threshold}) — throttled, ${Math.ceil(throttleMs / 60000)}min remaining`);
+                        return false;
+                    }
                     (0, logger_1.log)("vectordb", `Fragment threshold exceeded (${stats.fragmentStats.numSmallFragments} > ${threshold}) — compacting`);
                     yield this.optimize(2, 0, true);
+                    this.noteCompaction(this.lastOptimizeDidWork);
                     return true;
                 }
             }

package/dist/lib/utils/file-utils.js

@@ -187,22 +187,115 @@ function isIndexableFile(filePath, size) {
 function isIndexablePath(filePath) {
     return isIndexableFile(filePath);
 }
-// Well-known machine-generated markers emitted at the top of codegen output.
-// Tools (protoc, graphql-codegen, Apollo, Relay, Go `stringer`, OpenAPI, etc.)
-// stamp one of these in a banner comment. Matched against only the first few KB
-// because the banner is always at the very top — this keeps a hand-written
-// "do not edit this section" note deep in a real file from being misclassified.
-const GENERATED_MARKER = /@generated\b|\bDO NOT EDIT\b|Code generated by |auto-?generated by |This (?:file|code) (?:is|was) (?:\w+[ -])?generated|machine generated|@autogenerated\b/i;
+// Markers that only ever appear in a codegen banner. Any one of these, on its
+// own, is enough. Tools (protoc, graphql-codegen, Apollo, Relay, Go `stringer`,
+// OpenAPI) stamp one of these; doc generators fence their output with the
+// `generated-body` / `AUTO-GENERATED-CONTENT` style directives.
+const STRONG_GENERATED_MARKER = /@generated\b|@autogenerated\b|\bCode generated by |\bauto-?generated by |\bThis (?:file|code) (?:is|was) (?:\w+[ -])?generated|\bmachine[ -]generated\b|\bauto-?generated[-_ ]?content\b|\bgenerated[-_](?:body|content|section|block)\b|\bBEGIN GENERATED\b/i;
+// "DO NOT EDIT" is not proof of codegen on its own — humans write it on prose
+// they want left alone (archived vendor snapshots, verbatim captures). Real
+// codegen banners pair it with a generation word, so require that pairing.
+const DO_NOT_EDIT_MARKER = /\bDO NOT EDIT\b/i;
+const GENERATION_CONTEXT = /generat|codegen|autogen/i;
 const GENERATED_SNIFF_BYTES = 2048;
+const DOC_LIKE_EXTENSIONS = /\.(?:md|mdx|markdown|txt|rst|adoc|asciidoc)$/i;
+/**
+ * Extract the leading banner: the run of shebang, frontmatter, blank, and
+ * comment lines at the very top, stopping at the first line of actual code.
+ *
+ * Scanning raw head bytes instead was the bug this replaces. Two ways it
+ * misfired, both silently erasing hand-written files from the index:
+ *
+ *  - A *generator* was classified as its own output, because the banner it
+ *    emits appears as a string literal in its body
+ *    (`lines.push('# Auto-generated by ...')`).
+ *  - A comment quoting another file's rules ("its README says do not edit")
+ *    counted as a banner.
+ *
+ * A real codegen banner precedes all code, so anchoring here removes both
+ * without weakening detection.
+ *
+ * In doc-like files `#` starts a heading, not a comment, so only frontmatter
+ * and HTML comments count — otherwise the whole document body would be read as
+ * banner.
+ */
+function leadingBanner(head, filePath) {
+    var _a, _b;
+    const docLike = filePath ? DOC_LIKE_EXTENSIONS.test(filePath) : false;
+    const lines = head.split("\n");
+    const banner = [];
+    let i = 0;
+    if (!docLike && ((_a = lines[0]) === null || _a === void 0 ? void 0 : _a.startsWith("#!"))) {
+        banner.push(lines[0]);
+        i = 1;
+    }
+    // YAML frontmatter is metadata, not code — a generated-doc marker often sits
+    // directly after it.
+    if (((_b = lines[i]) === null || _b === void 0 ? void 0 : _b.trim()) === "---") {
+        banner.push(lines[i]);
+        i++;
+        while (i < lines.length && lines[i].trim() !== "---")
+            banner.push(lines[i++]);
+        if (i < lines.length)
+            banner.push(lines[i++]);
+    }
+    let blockEnd;
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (blockEnd) {
+            banner.push(line);
+            if (trimmed.includes(blockEnd))
+                blockEnd = undefined;
+            continue;
+        }
+        if (trimmed === "") {
+            banner.push(line);
+            continue;
+        }
+        if (trimmed.startsWith("<!--")) {
+            banner.push(line);
+            if (!trimmed.includes("-->"))
+                blockEnd = "-->";
+            continue;
+        }
+        if (!docLike) {
+            if (trimmed.startsWith("/*")) {
+                banner.push(line);
+                if (!trimmed.includes("*/"))
+                    blockEnd = "*/";
+                continue;
+            }
+            if (trimmed.startsWith("//") ||
+                trimmed.startsWith("#") ||
+                trimmed.startsWith("--") ||
+                trimmed.startsWith(";") ||
+                trimmed.startsWith("*")) {
+                banner.push(line);
+                continue;
+            }
+        }
+        break; // first real line of content — the banner is over
+    }
+    return banner.join("\n");
+}
 /**
  * Detect machine-generated source by its banner. Generated files flood both the
  * vector index and the symbol graph (codegen types rank as god nodes), so they
  * are skipped at index time. Path globs in `ignore-patterns.ts` catch the
  * obvious filenames; this catches the rest by content.
+ *
+ * `filePath` is optional but worth passing: without it, doc-like files are
+ * scanned with code comment rules, so a markdown `# Heading` reads as a comment.
  */
-function isGeneratedContent(buffer) {
+function isGeneratedContent(buffer, filePath) {
     const head = buffer.subarray(0, GENERATED_SNIFF_BYTES).toString("utf-8");
-    return GENERATED_MARKER.test(head);
+    const banner = leadingBanner(head, filePath);
+    if (!banner.trim())
+        return false;
+    if (STRONG_GENERATED_MARKER.test(banner))
+        return true;
+    return DO_NOT_EDIT_MARKER.test(banner) && GENERATION_CONTEXT.test(banner);
 }
 function formatDenseSnippet(text, maxLength = 1500) {
     const clean = text !== null && text !== void 0 ? text : "";

package/dist/lib/utils/kernel-zone.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZONE_THRESHOLDS = void 0;
+exports.classifyZonePressure = classifyZonePressure;
+exports.parseZprintOutput = parseZprintOutput;
+exports.readKernelZoneUsage = readKernelZoneUsage;
+exports.formatZoneUsage = formatZoneUsage;
+const node_child_process_1 = require("node:child_process");
+/**
+ * macOS kernel-zone pressure guard.
+ *
+ * On macOS 26.5.2 (build 25F84) the `data.kalloc.1024` kernel zone leaks under
+ * sustained filesystem write pressure and is never reclaimed. Exhausting it panics
+ * the host outright — no jetsam, no swap warning, no chance to intervene, because
+ * the failing resource is wired kernel memory rather than anything the VM system
+ * manages.
+ *
+ * This host panicked three times that way. The third time the zone sat near 1.4 GB
+ * for twelve days, then climbed to 17.9 GB in eight hours while gmax's compactor
+ * dirtied 549.76 GB of file-backed memory. See
+ * docs/2026-08-04-macos-kernel-zone-panic-incident.md.
+ *
+ * gmax cannot fix the kernel defect, but it can decline to be the thing that
+ * detonates it. Sampling the zone is cheap (~0.2 s), so the daemon watches its own
+ * blast radius and stands down while there are still hours of headroom.
+ */
+/** The zone that leaks. Named explicitly so `zprint` returns a single line. */
+const ZONE_NAME = "data.kalloc.1024";
+/**
+ * Warn threshold.
+ *
+ * Twelve days of ordinary use held this zone between 0.67 and 1.37 GiB, so 4 GiB is
+ * roughly 3x anything a healthy host has been observed to reach. During the
+ * August 17 burst the zone crossed this about 90 minutes in — early enough that
+ * stopping then would have avoided the panic with hours to spare.
+ */
+const WARN_BYTES = 4 * Math.pow(1024, 3);
+/**
+ * Critical threshold — the daemon stands down here.
+ *
+ * The observed zone map cap on this hardware is ~17.6 GiB. Eight GiB is under half
+ * of it, and at the burst rate actually measured (~2.0 GiB/hour) it still leaves
+ * roughly five hours before exhaustion. The margin is deliberately generous: the
+ * cost of standing down early is a stale index, and the cost of standing down late
+ * is an unplanned reboot.
+ */
+const CRITICAL_BYTES = 8 * Math.pow(1024, 3);
+function classifyZonePressure(bytes) {
+    if (bytes >= CRITICAL_BYTES)
+        return "critical";
+    if (bytes >= WARN_BYTES)
+        return "warn";
+    return "ok";
+}
+/**
+ * Parse one `zprint <zone>` report.
+ *
+ * Exported for tests; the column layout is a stable but undocumented text format,
+ * so this validates rather than trusting it:
+ *
+ * ```
+ *                             elem         cur         max        cur         max         cur  alloc  alloc
+ * zone name                   size        size        size      #elts       #elts       inuse   size  count
+ * data.kalloc.1024            1024          0K          0K          0           0        3416     0K      0
+ * ```
+ *
+ * The `cur size` column reads `0K` on this build, which is why the byte figure is
+ * derived from `cur inuse` x `elem size` rather than read directly.
+ */
+function parseZprintOutput(output, zoneName = ZONE_NAME) {
+    for (const line of output.split("\n")) {
+        const fields = line.trim().split(/\s+/);
+        if (fields[0] !== zoneName)
+            continue;
+        const elementSize = Number(fields[1]);
+        const elements = Number(fields[6]);
+        if (!Number.isInteger(elementSize) || elementSize <= 0)
+            return null;
+        if (!Number.isInteger(elements) || elements < 0)
+            return null;
+        return { elements, elementSize };
+    }
+    return null;
+}
+/**
+ * Sample the zone. Returns null off macOS, or whenever the sample cannot be
+ * trusted — an unparseable report must read as "unknown", never as "healthy" and
+ * never as a reason to stop working.
+ */
+function readKernelZoneUsage(zoneName = ZONE_NAME) {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        const output = (0, node_child_process_1.execFileSync)("zprint", [zoneName], {
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const parsed = parseZprintOutput(output, zoneName);
+        if (!parsed)
+            return null;
+        const bytes = parsed.elements * parsed.elementSize;
+        return Object.assign(Object.assign({}, parsed), { bytes, pressure: classifyZonePressure(bytes) });
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function formatZoneUsage(usage) {
+    const gib = (usage.bytes / Math.pow(1024, 3)).toFixed(2);
+    return `${ZONE_NAME} at ${gib}GiB (${usage.elements.toLocaleString()} elements)`;
+}
+exports.ZONE_THRESHOLDS = {
+    warnBytes: WARN_BYTES,
+    criticalBytes: CRITICAL_BYTES,
+    zoneName: ZONE_NAME,
+};

package/dist/lib/workers/orchestrator.js

@@ -256,7 +256,7 @@ class WorkerOrchestrator {
                 (0, logger_1.debug)("orch", `skip ${input.path} (empty or binary)`);
                 return { vectors: [], hash, mtimeMs, size, shouldDelete: true };
             }
-            if ((0, file_utils_1.isGeneratedContent)(buffer)) {
+            if ((0, file_utils_1.isGeneratedContent)(buffer, absolutePath)) {
                 (0, logger_1.debug)("orch", `skip ${input.path} (machine-generated header)`);
                 return { vectors: [], hash, mtimeMs, size, shouldDelete: true };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.14",
+  "version": "0.26.16",
   "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.14",
+  "version": "0.26.16",
   "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

@@ -78,7 +78,23 @@ function isProjectRegistered() {
   }
 }
 
+// A kill switch for the auto-start. Create ~/.gmax/autostart-disabled (or export
+// 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.
+function isAutostartDisabled() {
+  if (process.env.GMAX_NO_AUTOSTART === "1") return true;
+  try {
+    return require("node:fs").existsSync(
+      _path.join(require("node:os").homedir(), ".gmax", "autostart-disabled"),
+    );
+  } catch {
+    return false;
+  }
+}
+
 function startWatcher() {
+  if (isAutostartDisabled()) return;
   if (!isProjectRegistered()) return;
   try {
     execFileSync("gmax", ["watch", "--daemon", "-b"], {