grepmax 0.26.55 → 0.26.56

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

package/README.md

@@ -57,7 +57,7 @@ gmax doctor                   # Health check
 gmax doctor --fix             # Repair checks; full-table maintenance is disabled
 ```
 
-**Storage containment:** full-table compaction is disabled, including forced maintenance and doctor repair. Existing retained index copies are not reclaimed by this release. The verified prune-only recovery path is separate work; normal incremental indexing remains available when the host is healthy and not quarantined. A persistent host safety stop blocks mutation and daemon restart. Installing an update preserves existing quarantine.
+**Storage containment:** full-table compaction is disabled, including forced maintenance and doctor repair. Existing retained index copies are not reclaimed by this release. The verified prune-only recovery path is separate work; normal incremental indexing remains available when the host is healthy and not quarantined. A persistent host safety stop blocks mutation and daemon restart. Installing an update preserves existing quarantine. Speculative embedding warmup and maintenance timers are disabled. On macOS, startup, heavy queries, worker forks and MLX launches require known normal OS memory pressure and a healthy kernel-zone sample; unavailable probes report bounded diagnostic details and refuse work.
 
 ### Core Commands
 

package/dist/lib/daemon/daemon.js

@@ -57,6 +57,8 @@ const embedding_status_1 = require("../index/embedding-status");
 const index_config_1 = require("../index/index-config");
 const syncer_1 = require("../index/syncer");
 const server_1 = require("../llm/server");
+const compaction_result_1 = require("../store/compaction-result");
+const maintenance_policy_1 = require("../store/maintenance-policy");
 const meta_cache_1 = require("../store/meta-cache");
 const store_lease_1 = require("../store/store-lease");
 const vector_db_1 = require("../store/vector-db");
@@ -165,6 +167,7 @@ class Daemon {
         });
         this.mlxServerManager = new mlx_server_manager_1.MlxServerManager({
             getShuttingDown: () => this.shuttingDown,
+            assertExpansionAdmission: () => this.assertHeavyOperationAdmission("mlx-start"),
         });
         this.watcherManager = new watcher_manager_1.WatcherManager({
             processors: this.processors,
@@ -242,14 +245,11 @@ class Daemon {
             if (denied !== null)
                 throw new Error(`gmax: ${denied}; preserving containment`);
             // Check before stale-process cleanup, store opening, workers or model setup.
-            if (process.platform === "darwin") {
-                const usage = (0, kernel_zone_1.readKernelZoneUsage)();
-                if (!usage)
-                    throw new Error("gmax: kernel pressure unavailable; startup refused");
-                if (usage.pressure !== "ok") {
-                    (0, safety_latch_1.latchSafetyStop)((0, kernel_zone_1.formatZoneUsage)(usage));
-                    throw new Error(`gmax: ${(0, kernel_zone_1.formatZoneUsage)(usage)}; startup safety stop`);
-                }
+            const pressure = this.hostPressureDeniedReason();
+            if (pressure !== null) {
+                if (pressure.measured)
+                    (0, safety_latch_1.latchSafetyStop)(pressure.reason);
+                throw new Error(`gmax: ${pressure.reason}; startup safety stop`);
             }
             process.title = "gmax-daemon";
             // Read verbs register here rather than at read-verbs.ts module scope: the
@@ -404,7 +404,7 @@ class Daemon {
             const globalConfig = (_a = this.activeConfig) !== null && _a !== void 0 ? _a : (0, index_config_1.readGlobalConfig)();
             const isAppleSilicon = process.arch === "arm64" && process.platform === "darwin";
             if (isAppleSilicon && globalConfig.embedMode === "gpu") {
-                yield this.mlxServerManager.ensureMlxServer(globalConfig.mlxModel);
+                yield this.ensureAdmittedMlxServer(globalConfig.mlxModel);
                 this.assertStartupActive();
             }
             this.publishResourceGeneration(globalConfig, this.activeGeneration, this.vectorDb, this.workerPool, this.mlxMode(globalConfig));
@@ -496,52 +496,59 @@ class Daemon {
                 console.log("[daemon] Idle shutdown disabled (GMAX_DAEMON_IDLE_TIMEOUT_MS<=0)");
             }
             console.log(`[daemon] Started (PID: ${process.pid}, ${this.processors.size} projects)`);
-            // Pre-warm the search hot path so the first user-facing search doesn't
-            // pay daemon-side cold costs:
-            //   - LanceDB connection open + first openTable() (~10–15s on a 5GB
-            //     index — this is the dominant cost)
-            //   - FTS index "already exists" round-trip
-            //   - Two parallel encodeQuery calls so the worker pool spawns + warms
-            //     workers ahead of the first real search. The reaper floor is
-            //     MIN_KEEP_WORKERS = 1 (pool.ts), so only one worker stays resident
-            //     long-term — but the prewarm still pays the model-load cost up front.
-            // Fire-and-forget; failures are non-fatal — the next real search just
-            // pays the cost once. Delay a few seconds so we don't compete with the
-            // catchup scans dispatched on startup.
-            setTimeout(() => {
-                if (this.shuttingDown)
-                    return;
-                void this.runSharedOperation("search-warmup", undefined, () => __awaiter(this, void 0, void 0, function* () {
-                    const t0 = Date.now();
-                    try {
-                        if (this.vectorDb) {
-                            yield this.vectorDb.ensureTable();
-                            yield this.vectorDb.createFTSIndex();
-                            yield this.vectorDb.createVectorIndex(false, 5, true);
-                        }
-                        const pool = this.workerPool;
-                        if (!pool)
-                            throw new Error("worker pool not ready");
-                        // Two parallel encodes force the pool to spawn two workers and
-                        // warm both (each worker loads Granite + ColBERT lazily on first
-                        // encode — once warmed, subsequent encodes are ~13ms).
-                        yield Promise.all([
-                            pool.encodeQuery("warmup-a"),
-                            pool.encodeQuery("warmup-b"),
-                        ]);
-                        console.log(`[daemon] Search hot path pre-warmed (${Date.now() - t0}ms)`);
-                    }
-                    catch (err) {
-                        console.log(`[daemon] Search warmup failed (non-fatal): ${err}`);
-                    }
-                })).catch((err) => {
-                    if (err instanceof operation_coordinator_1.OperationClosedError)
-                        return;
-                    console.log(`[daemon] Search warmup skipped: ${err}`);
-                });
-            }, 5000).unref();
+            this.scheduleSearchWarmup();
         });
     }
+    scheduleSearchWarmup() {
+        // Speculative encodes can spawn/load models even though existing FTS
+        // adoption is read-only. Containment schedules neither work nor admission.
+        if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)())
+            return;
+        // Pre-warm the search hot path so the first user-facing search doesn't
+        // pay daemon-side cold costs:
+        //   - LanceDB connection open + first openTable() (~10–15s on a 5GB
+        //     index — this is the dominant cost)
+        //   - FTS index "already exists" round-trip
+        //   - Two parallel encodeQuery calls so the worker pool spawns + warms
+        //     workers ahead of the first real search. The reaper floor is
+        //     MIN_KEEP_WORKERS = 1 (pool.ts), so only one worker stays resident
+        //     long-term — but the prewarm still pays the model-load cost up front.
+        // Fire-and-forget; failures are non-fatal — the next real search just
+        // pays the cost once. Delay a few seconds so we don't compete with the
+        // catchup scans dispatched on startup.
+        setTimeout(() => {
+            if (this.shuttingDown)
+                return;
+            void this.runSharedOperation("search-warmup", undefined, () => __awaiter(this, void 0, void 0, function* () {
+                const t0 = Date.now();
+                try {
+                    if (this.vectorDb) {
+                        yield this.vectorDb.ensureTable();
+                        yield this.vectorDb.createFTSIndex();
+                        yield this.vectorDb.createVectorIndex(false, 5, true);
+                    }
+                    const pool = this.workerPool;
+                    if (!pool)
+                        throw new Error("worker pool not ready");
+                    // Two parallel encodes force the pool to spawn two workers and
+                    // warm both (each worker loads Granite + ColBERT lazily on first
+                    // encode — once warmed, subsequent encodes are ~13ms).
+                    yield Promise.all([
+                        pool.encodeQuery("warmup-a"),
+                        pool.encodeQuery("warmup-b"),
+                    ]);
+                    console.log(`[daemon] Search hot path pre-warmed (${Date.now() - t0}ms)`);
+                }
+                catch (err) {
+                    console.log(`[daemon] Search warmup failed (non-fatal): ${err}`);
+                }
+            })).catch((err) => {
+                if (err instanceof operation_coordinator_1.OperationClosedError)
+                    return;
+                console.log(`[daemon] Search warmup skipped: ${err}`);
+            });
+        }, 5000).unref();
+    }
     watchProject(root, signal) {
         return this.withProjectLock(root, signal, () => this.runSharedOperation("watch", signal, () => this.watchProjectWithinOperation(root)));
     }
@@ -616,14 +623,25 @@ class Daemon {
         }
     }
     runSharedOperation(name, signal, fn) {
-        const readOnly = (0, read_verbs_1.getReadVerb)(name) !== undefined ||
-            ["search", "project-stats", "unwatch", "llm-stop"].includes(name);
+        const readOnly = ((0, read_verbs_1.getReadVerb)(name) !== undefined && !(0, read_verbs_1.isHeavyReadVerb)(name)) ||
+            ["project-stats", "unwatch", "llm-stop"].includes(name);
         return this.operations.runShared(name, signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+            if (name === "store-maintenance" && (0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                // Retain coordinator close/exclusive checks, but never admit a disabled
+                // callback as heavy work or probe the kernel for a known no-op.
+                return (0, compaction_result_1.skippedCompaction)(maintenance_policy_1.FULL_TABLE_MAINTENANCE_DISABLED_REASON);
+            }
             if (!readOnly)
                 this.assertHeavyOperationAdmission(name);
             return fn(operationSignal);
         }));
     }
+    ensureAdmittedMlxServer(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertHeavyOperationAdmission("mlx-start");
+            yield this.mlxServerManager.ensureMlxServer(model);
+        });
+    }
     assertHeavyOperationAdmission(name) {
         const denied = (0, autostart_1.daemonStartDeniedReason)();
         if (denied !== null)
@@ -632,6 +650,10 @@ class Daemon {
         if (!this.checkKernelZonePressure()) {
             throw new Error(`${name} refused: host pressure is unsafe or unknown`);
         }
+        // Another process can quarantine the machine while the probes run.
+        const finalDenied = (0, autostart_1.daemonStartDeniedReason)();
+        if (finalDenied !== null)
+            throw new Error(`${name} refused: ${finalDenied}`);
     }
     /**
      * Compact + prune on behalf of a CLI caller.
@@ -1474,7 +1496,7 @@ class Daemon {
                             throw new Error(`rebuilt table dimension ${physicalDim !== null && physicalDim !== void 0 ? physicalDim : "missing"} does not match target ${targetGeneration.vectorDim}`);
                         }
                         if (targetConfig.embedMode === "gpu") {
-                            yield this.mlxServerManager.ensureMlxServer(targetGeneration.mlxModel);
+                            yield this.ensureAdmittedMlxServer(targetGeneration.mlxModel);
                         }
                         const targetMlx = this.mlxMode(targetConfig);
                         targetPool = this.createWorkerPool(targetGeneration, targetConfig.embedMode);
@@ -1588,7 +1610,7 @@ class Daemon {
                                         : oldResources.vectorDb;
                                     if (oldResources.config.embedMode === "gpu" &&
                                         oldResources.mlx === "owned") {
-                                        yield this.mlxServerManager.ensureMlxServer(oldResources.embedding.mlxModel);
+                                        yield this.ensureAdmittedMlxServer(oldResources.embedding.mlxModel);
                                     }
                                     restoredPool = this.createWorkerPool(oldResources.embedding, oldResources.config.embedMode);
                                     yield restoredDb.downgradeStoreLease();
@@ -1889,7 +1911,9 @@ class Daemon {
         this.maybeRecycle(sampleFootprint);
         if (this.shuttingDown || this.recycling || !sampleFootprint)
             return;
-        void this.mlxServerManager.checkMlxHealth();
+        void this.mlxServerManager.checkMlxHealth().catch((error) => {
+            console.error("[daemon] MLX health/restart refused:", error instanceof Error ? error.message : "unknown failure");
+        });
         this.processManager.sweepOrphanWorkers();
     }
     logResourceSnapshot(reason, footprintMb) {
@@ -2007,17 +2031,56 @@ class Daemon {
             this.stopForSafety(denied, false);
             return false;
         }
-        if (process.platform !== "darwin")
-            return true;
-        const usage = (0, kernel_zone_1.readKernelZoneUsage)();
-        if ((usage === null || usage === void 0 ? void 0 : usage.pressure) === "ok")
+        const pressure = this.hostPressureDeniedReason();
+        if (pressure === null)
             return true;
-        const reason = usage
-            ? `${usage.pressure} kernel pressure: ${(0, kernel_zone_1.formatZoneUsage)(usage)}`
-            : "kernel pressure unavailable; heavy work cannot be admitted";
-        this.stopForSafety(reason);
+        this.stopForSafety(pressure.reason);
         return false;
     }
+    /** Both measurements must be known and normal before any resource expansion. */
+    hostPressureDeniedReason() {
+        if (process.platform !== "darwin")
+            return null;
+        // This inexpensive probe rejects OS warning before a worker/model starts,
+        // or before paying the bounded but relatively slow kernel-zone probe cost.
+        const memory = (0, kernel_zone_1.probeMemoryPressure)();
+        if (memory.status !== "known") {
+            return {
+                reason: `OS memory pressure unavailable (${(0, kernel_zone_1.formatPressureProbe)(memory)})`,
+                measured: false,
+            };
+        }
+        if (memory.pressure !== "normal") {
+            return {
+                reason: `${memory.pressure} OS memory pressure (${(0, kernel_zone_1.formatPressureProbe)(memory)})`,
+                measured: true,
+            };
+        }
+        const kernel = (0, kernel_zone_1.probeKernelZoneUsage)();
+        if (kernel.status !== "known") {
+            return {
+                reason: `kernel pressure unavailable (${(0, kernel_zone_1.formatPressureProbe)(kernel)}); heavy work cannot be admitted`,
+                measured: false,
+            };
+        }
+        if (kernel.usage.pressure === "ok") {
+            // Kernel sampling can take seconds; use a new inexpensive OS observation
+            // at the actual admission boundary, rather than trusting its first sample.
+            const freshMemory = (0, kernel_zone_1.probeMemoryPressure)();
+            if (freshMemory.status === "known" && freshMemory.pressure === "normal")
+                return null;
+            return {
+                reason: freshMemory.status === "known"
+                    ? `${freshMemory.pressure} OS memory pressure (${(0, kernel_zone_1.formatPressureProbe)(freshMemory)})`
+                    : `OS memory pressure unavailable (${(0, kernel_zone_1.formatPressureProbe)(freshMemory)})`,
+                measured: freshMemory.status === "known",
+            };
+        }
+        return {
+            reason: `${kernel.usage.pressure} kernel pressure: ${(0, kernel_zone_1.formatZoneUsage)(kernel.usage)} (${(0, kernel_zone_1.formatPressureProbe)(kernel)})`,
+            measured: true,
+        };
+    }
     stopForSafety(reason, persist = true) {
         // Warning already pauses mutation: a stale index costs less than another
         // host crash. Unknown readings are visible stops, never healthy samples.

package/dist/lib/daemon/mlx-server-manager.js

@@ -203,8 +203,8 @@ class MlxServerManager {
     }
     ensureInternal(model) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            var _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e;
+            var _f, _g, _h, _j, _k;
             this.phase = "probing";
             const health = yield this.probeHealth(this.port);
             if (this.shouldStop())
@@ -256,15 +256,31 @@ class MlxServerManager {
                 console.warn("[daemon] MLX embed server not found — falling back to CPU embeddings");
                 return;
             }
-            const owner = (_d = (_b = (_a = this.deps).createOwnerToken) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _d !== void 0 ? _d : (0, node_crypto_1.randomUUID)();
-            const openLog = (_e = this.deps.openLog) !== null && _e !== void 0 ? _e : log_rotate_1.openRotatedLog;
-            const closeFd = (_f = this.deps.closeFd) !== null && _f !== void 0 ? _f : fs.closeSync;
+            // A health/termination await may outlive the daemon's outer admission.
+            // Refusal must not leak a log descriptor or look like a successful startup.
+            // Disable automatic retries until an explicit admitted ensure occurs;
+            // fire-and-forget health callers must catch the propagated rejection.
+            try {
+                (_b = (_a = this.deps).assertExpansionAdmission) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+            catch (error) {
+                this.enabled = false;
+                this.phase = "failed";
+                this.lastError = `MLX expansion admission refused: ${error instanceof Error ? error.message : "host admission unavailable"}`;
+                console.error(`[daemon] ${this.lastError}`);
+                throw new Error(this.lastError);
+            }
+            if (this.shouldStop())
+                return;
+            const owner = (_f = (_d = (_c = this.deps).createOwnerToken) === null || _d === void 0 ? void 0 : _d.call(_c)) !== null && _f !== void 0 ? _f : (0, node_crypto_1.randomUUID)();
+            const openLog = (_g = this.deps.openLog) !== null && _g !== void 0 ? _g : log_rotate_1.openRotatedLog;
+            const closeFd = (_h = this.deps.closeFd) !== null && _h !== void 0 ? _h : fs.closeSync;
             const logFd = openLog(path.join(config_1.PATHS.logsDir, "mlx-embed-server.log"));
             const env = Object.assign(Object.assign({}, process.env), { MLX_EMBED_MODEL: model, GMAX_EMBED_OWNER_TOKEN: owner, HF_HOME: (0, mlx_hf_cache_1.resolveMlxHfHome)(model) });
             this.phase = "starting";
             let child;
             try {
-                child = ((_g = this.deps.spawn) !== null && _g !== void 0 ? _g : node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
+                child = ((_j = this.deps.spawn) !== null && _j !== void 0 ? _j : node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
                     cwd: serverDir,
                     detached: true,
                     stdio: ["ignore", logFd, logFd],
@@ -281,7 +297,7 @@ class MlxServerManager {
                 try {
                     closeFd(logFd);
                 }
-                catch (_j) { }
+                catch (_l) { }
             }
             if (!child.pid) {
                 this.lastError = "spawned MLX process has no PID";
@@ -340,7 +356,7 @@ class MlxServerManager {
             child.off("error", onError);
             child.off("exit", onExit);
             yield this.terminateOwned(candidate);
-            this.lastError = (_h = (_c = startup.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _h !== void 0 ? _h : (this.shouldStop() ? "MLX startup cancelled" : "MLX startup timed out");
+            this.lastError = (_k = (_e = startup.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _k !== void 0 ? _k : (this.shouldStop() ? "MLX startup cancelled" : "MLX startup timed out");
             if (!this.shouldStop()) {
                 this.phase = "failed";
                 console.error(`[daemon] ${this.lastError} — falling back to CPU embeddings`);

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

@@ -275,6 +275,10 @@ class VectorDB {
      * Call once from the daemon — replaces per-processor maintenance intervals.
      */
     startMaintenanceLoop(runOperation) {
+        if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+            this.recordSkippedCompaction((0, maintenance_policy_1.recordMaintenanceContainment)(this.lancedbDir));
+            return;
+        }
         if (runOperation)
             this.maintenanceRunner = runOperation;
         if (this.maintenanceTimer)

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

@@ -1,6 +1,20 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZONE_THRESHOLDS = void 0;
+exports.formatPressureProbe = formatPressureProbe;
+exports.probeKernelZoneUsage = probeKernelZoneUsage;
+exports.probeMemoryPressure = probeMemoryPressure;
 exports.classifyZonePressure = classifyZonePressure;
 exports.parseZprintOutput = parseZprintOutput;
 exports.readKernelZoneUsage = readKernelZoneUsage;
@@ -49,6 +63,122 @@ const WARN_BYTES = 4 * Math.pow(1024, 3);
  * is an unplanned reboot.
  */
 const CRITICAL_BYTES = 8 * Math.pow(1024, 3);
+/** Compact diagnostic metadata; never serializes raw probe output or errors. */
+function formatPressureProbe(result) {
+    return JSON.stringify(Object.assign(Object.assign({ status: result.status, sampledAtMs: result.sampledAtMs, durationMs: result.durationMs, outputBytes: result.outputBytes }, (result.status !== "known" ? { reason: result.reason } : {})), (result.status === "unknown"
+        ? {
+            errorCode: result.errorCode,
+            exitCode: result.exitCode,
+            signal: result.signal,
+        }
+        : {})));
+}
+const PROBE_ERROR_CODES = new Set([
+    "ETIMEDOUT",
+    "ENOBUFS",
+    "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
+    "ENOENT",
+    "EACCES",
+    "EPERM",
+]);
+const PROBE_SIGNALS = new Set(["SIGTERM", "SIGKILL", "SIGABRT", "SIGSEGV"]);
+function stdoutBytes(output) {
+    return typeof output === "string"
+        ? Buffer.byteLength(output)
+        : Buffer.isBuffer(output)
+            ? output.length
+            : 0;
+}
+function boundedPressureProbe(command, args, timeout, parse, overrides) {
+    const deps = Object.assign({ platform: process.platform, wallNow: Date.now, monotonicNow: () => performance.now(), run: (cmd, argv, options) => (0, node_child_process_1.execFileSync)(cmd, argv, options) }, overrides);
+    const sampledAtMs = deps.wallNow();
+    const started = deps.monotonicNow();
+    let outputBytes = 0;
+    const observation = () => ({
+        sampledAtMs,
+        durationMs: Math.max(0, deps.monotonicNow() - started),
+        outputBytes,
+    });
+    if (deps.platform !== "darwin")
+        return Object.assign(Object.assign({}, observation()), { status: "unsupported", reason: "unsupported-platform" });
+    try {
+        const output = deps.run(command, args, {
+            encoding: "utf-8",
+            timeout,
+            maxBuffer: 64 * 1024,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        outputBytes = stdoutBytes(output);
+        const value = parse(output);
+        return value === null
+            ? Object.assign(Object.assign({}, observation()), { status: "unknown", reason: "parse", errorCode: null, exitCode: null, signal: null }) : Object.assign(Object.assign({}, observation()), { status: "known", value });
+    }
+    catch (error) {
+        const details = error && typeof error === "object"
+            ? error
+            : {};
+        outputBytes = stdoutBytes(details.stdout);
+        const errorCode = typeof details.code === "string" && PROBE_ERROR_CODES.has(details.code)
+            ? details.code
+            : details.code == null
+                ? null
+                : "UNKNOWN";
+        const exitCode = typeof details.status === "number" && Number.isInteger(details.status)
+            ? details.status
+            : null;
+        const signal = typeof details.signal === "string" && PROBE_SIGNALS.has(details.signal)
+            ? details.signal
+            : null;
+        const reason = errorCode === "ETIMEDOUT"
+            ? "timeout"
+            : errorCode === "ENOBUFS" ||
+                errorCode === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
+                ? "output-limit"
+                : exitCode !== null || signal !== null
+                    ? "exit"
+                    : "execution";
+        return Object.assign(Object.assign({}, observation()), { status: "unknown", reason,
+            errorCode,
+            exitCode,
+            signal });
+    }
+}
+function probeKernelZoneUsage(zoneName = ZONE_NAME, overrides = {}) {
+    const result = boundedPressureProbe("zprint", [zoneName], PROBE_TIMEOUT_MS, (output) => {
+        const parsed = parseZprintOutput(output, zoneName);
+        if (!parsed)
+            return null;
+        const bytes = parsed.elements * parsed.elementSize;
+        if (!Number.isSafeInteger(bytes))
+            return null;
+        return Object.assign(Object.assign({}, parsed), { bytes, pressure: classifyZonePressure(bytes) });
+    }, overrides);
+    if (result.status !== "known")
+        return result;
+    const { value } = result, observation = __rest(result, ["value"]);
+    return Object.assign(Object.assign({}, observation), { usage: value });
+}
+/** XNU publishes dispatch flags NORMAL=1, WARN=2, CRITICAL=4 through this sysctl.
+ * https://github.com/apple-oss-distributions/xnu/blob/main/bsd/kern/kern_memorystatus_notify.c
+ * Other values are unknown, including the unrelated internal kernel enum. */
+function probeMemoryPressure(overrides = {}) {
+    const result = boundedPressureProbe("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], 1000, (output) => {
+        switch (output.trim()) {
+            case "1":
+                return "normal";
+            case "2":
+                return "warn";
+            case "4":
+                return "critical";
+            default:
+                return null;
+        }
+    }, overrides);
+    if (result.status !== "known")
+        return result;
+    const { value } = result, observation = __rest(result, ["value"]);
+    return Object.assign(Object.assign({}, observation), { pressure: value });
+}
 function classifyZonePressure(bytes) {
     if (bytes >= CRITICAL_BYTES)
         return "critical";
@@ -92,24 +222,8 @@ function parseZprintOutput(output, zoneName = ZONE_NAME) {
  * "healthy". macOS startup and heavy-operation admission refuse unknown samples.
  */
 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: PROBE_TIMEOUT_MS,
-            maxBuffer: 64 * 1024,
-            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;
-    }
+    const result = probeKernelZoneUsage(zoneName);
+    return result.status === "known" ? result.usage : null;
 }
 function formatZoneUsage(usage) {
     const gib = (usage.bytes / Math.pow(1024, 3)).toFixed(2);

package/dist/lib/workers/pool.js

@@ -57,7 +57,10 @@ const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
 const embedding_generation_1 = require("../index/embedding-generation");
 const index_config_1 = require("../index/index-config");
+const autostart_1 = require("../utils/autostart");
+const kernel_zone_1 = require("../utils/kernel-zone");
 const logger_1 = require("../utils/logger");
+const safety_latch_1 = require("../utils/safety-latch");
 const TASK_TIMEOUT_MS = (() => {
     var _a;
     const fromEnv = Number.parseInt((_a = process.env.GMAX_WORKER_TASK_TIMEOUT_MS) !== null && _a !== void 0 ? _a : "", 10);
@@ -221,6 +224,7 @@ class WorkerPool {
         this.destroyPromise = null;
         this.consecutiveRespawns = 0;
         this.respawnLimitReached = false;
+        this.spawnDeniedReason = null;
         this.idleReapInterval = null;
         // Re-runs dispatch once the oldest unassigned task reaches SCALE_UP_WAIT_MS.
         this.scaleUpTimer = null;
@@ -237,7 +241,8 @@ class WorkerPool {
         // process environment remains live and is copied at each fork.
         this.embeddingEnvironment = Object.freeze(generatedEmbeddingEnv);
         // Lazy spawn: start with 1 worker, scale up on demand
-        this.spawnWorker();
+        if (!this.spawnWorker())
+            throw this.spawnDeniedError();
         // Periodically reap idle workers back to MIN_KEEP, and force-kill any
         // worker wedged in busy=true (the leak backstop — see STUCK_BUSY_MS).
         this.idleReapInterval = setInterval(() => {
@@ -247,7 +252,7 @@ class WorkerPool {
         }, IDLE_WORKER_TIMEOUT_MS);
     }
     isHealthy() {
-        return !this.destroyed && this.workers.length > 0;
+        return (!this.destroyed && !this.spawnDeniedReason && this.workers.length > 0);
     }
     /** PIDs of workers the pool currently tracks. Used by the daemon's orphan
      * sweep to distinguish live, accounted-for workers from de-listed strays. */
@@ -287,16 +292,16 @@ class WorkerPool {
         });
         return hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
     }
-    rejectUnassignedTasks(message) {
+    rejectUnassignedTasks(message, code) {
         for (const task of Array.from(this.tasks.values())) {
             if (task.worker)
                 continue;
-            task.reject(new Error(message));
+            task.reject(Object.assign(new Error(message), code ? { code } : {}));
             this.completeTask(task, null);
         }
     }
     maybeRespawn(reason, hasPendingTasks) {
-        if (this.destroyed || this.respawnLimitReached)
+        if (this.destroyed || this.spawnDeniedReason || this.respawnLimitReached)
             return false;
         this.consecutiveRespawns++;
         (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after ${reason} (workers=${this.workers.length} pending=${hasPendingTasks})`);
@@ -308,8 +313,7 @@ class WorkerPool {
                 this.rejectUnassignedTasks(message);
             return false;
         }
-        this.spawnWorker();
-        return true;
+        return this.spawnWorker();
     }
     completeTask(task, worker) {
         this.clearTaskTimeout(task);
@@ -357,8 +361,69 @@ class WorkerPool {
             this.dispatch();
         }
     }
+    spawnDeniedError() {
+        var _a;
+        return Object.assign(new Error((_a = this.spawnDeniedReason) !== null && _a !== void 0 ? _a : "Worker spawn denied"), { code: "HOST_SAFETY" });
+    }
+    denySpawn(reason, persist = true) {
+        // A pool cannot automatically recover after a failed admission. In
+        // particular, timer/exit callbacks must not retry forks or strand queues.
+        this.spawnDeniedReason = `Worker spawn denied: ${reason}`;
+        this.clearScaleUpTimer();
+        if (persist) {
+            try {
+                (0, safety_latch_1.latchSafetyStop)(this.spawnDeniedReason);
+            }
+            catch (_a) {
+                try {
+                    (0, logger_1.log)("pool", "worker admission denied; safety latch persistence failed");
+                }
+                catch (_b) { }
+            }
+        }
+        this.rejectUnassignedTasks(this.spawnDeniedReason, "HOST_SAFETY");
+        try {
+            (0, logger_1.log)("pool", this.spawnDeniedReason);
+        }
+        catch (_c) { }
+        return false;
+    }
     spawnWorker() {
-        const worker = new ProcessWorker(this.modulePath, this.execArgv, this.embeddingEnvironment, config_1.MAX_WORKER_MEMORY_MB);
+        if (this.destroyed || this.spawnDeniedReason)
+            return false;
+        let worker;
+        try {
+            const quarantine = (0, autostart_1.daemonStartDeniedReason)();
+            if (quarantine)
+                return this.denySpawn(quarantine, false);
+            if (process.platform === "darwin") {
+                const memory = (0, kernel_zone_1.probeMemoryPressure)();
+                if (memory.status !== "known" || memory.pressure !== "normal") {
+                    return this.denySpawn(`OS memory pressure ${memory.status === "known" ? memory.pressure : memory.status}; ${(0, kernel_zone_1.formatPressureProbe)(memory)}`);
+                }
+                const kernel = (0, kernel_zone_1.probeKernelZoneUsage)();
+                if (kernel.status !== "known" || kernel.usage.pressure !== "ok") {
+                    return this.denySpawn(`kernel pressure ${kernel.status === "known" ? kernel.usage.pressure : kernel.status}; ${(0, kernel_zone_1.formatPressureProbe)(kernel)}`);
+                }
+            }
+            if (process.platform === "darwin") {
+                // Refresh the cheap OS sample after the potentially slow kernel probe.
+                const freshMemory = (0, kernel_zone_1.probeMemoryPressure)();
+                if (freshMemory.status !== "known" ||
+                    freshMemory.pressure !== "normal") {
+                    return this.denySpawn(`OS memory pressure ${freshMemory.status === "known" ? freshMemory.pressure : freshMemory.status}; ${(0, kernel_zone_1.formatPressureProbe)(freshMemory)}`);
+                }
+            }
+            // Probes are synchronous but another process can quarantine the host
+            // while they run. Recheck the shared markers immediately before fork.
+            const finalQuarantine = (0, autostart_1.daemonStartDeniedReason)();
+            if (finalQuarantine)
+                return this.denySpawn(finalQuarantine, false);
+            worker = new ProcessWorker(this.modulePath, this.execArgv, this.embeddingEnvironment, config_1.MAX_WORKER_MEMORY_MB);
+        }
+        catch (_a) {
+            return this.denySpawn("host admission or fork failed");
+        }
         (0, logger_1.log)("pool", `spawn PID:${worker.child.pid} (${this.workers.length + 1}/${Math.max(1, config_1.CONFIG.WORKER_THREADS)})`);
         const onMessage = (msg) => {
             var _a, _b, _c, _d;
@@ -409,11 +474,14 @@ class WorkerPool {
         worker.child.on("exit", onExit);
         worker.child.on("error", onError);
         this.workers.push(worker);
+        return true;
     }
     enqueue(method, payload, signal) {
         if (this.destroyed) {
             return Promise.reject(new Error("Worker pool destroyed"));
         }
+        if (this.spawnDeniedReason)
+            return Promise.reject(this.spawnDeniedError());
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             const err = new Error("Aborted");
             err.name = "AbortError";
@@ -502,6 +570,23 @@ class WorkerPool {
         var _c, _d, _e;
         if (this.destroyed)
             return;
+        if (this.spawnDeniedReason) {
+            this.rejectUnassignedTasks(this.spawnDeniedReason, "HOST_SAFETY");
+            return;
+        }
+        // Work admitted before another process quarantines the host may still
+        // be queued. Do not send it to an existing worker after that stop.
+        try {
+            const quarantine = (0, autostart_1.daemonStartDeniedReason)();
+            if (quarantine) {
+                this.denySpawn(quarantine, false);
+                return;
+            }
+        }
+        catch (_f) {
+            this.denySpawn("quarantine check failed");
+            return;
+        }
         let idle = this.workers.find((w) => !w.busy);
         // Drain priority queue first so search tasks never wait behind an
         // indexing batch.
@@ -528,7 +613,8 @@ class WorkerPool {
                 this.armScaleUpTimer(waitMs);
                 return;
             }
-            this.spawnWorker();
+            if (!this.spawnWorker())
+                return;
             idle = this.workers[this.workers.length - 1];
         }
         if (!idle)
@@ -723,7 +809,8 @@ class WorkerPool {
         }
         // Replace anything we dropped below the floor with fresh, lean workers.
         while (!this.destroyed && this.workers.length < MIN_KEEP_WORKERS) {
-            this.spawnWorker();
+            if (!this.spawnWorker())
+                break;
         }
     }
     /**

package/package.json

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