grepmax 0.26.72 → 0.26.73

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

package/dist/lib/daemon/daemon.js

@@ -74,6 +74,7 @@ const keyed_mutex_1 = require("../utils/keyed-mutex");
 const log_rotate_1 = require("../utils/log-rotate");
 const logger_1 = require("../utils/logger");
 const operation_coordinator_1 = require("../utils/operation-coordinator");
+const pressure_diagnostics_1 = require("../utils/pressure-diagnostics");
 const process_1 = require("../utils/process");
 const process_footprint_1 = require("../utils/process-footprint");
 const project_registry_1 = require("../utils/project-registry");
@@ -263,9 +264,9 @@ class Daemon {
             if (denied !== null && !options.readOnly)
                 throw new Error(`gmax: ${denied}; preserving containment`);
             // Explicit read-only startup preserves every marker and opens no models.
-            const pressure = this.hostPressureDeniedReason();
+            const pressure = this.hostPressureDeniedReason("startup");
             if (pressure === null || pressure === void 0 ? void 0 : pressure.critical) {
-                (0, safety_latch_1.latchSafetyStop)(pressure.reason);
+                (0, safety_latch_1.latchSafetyStop)(pressure.reason, undefined, pressure.diagnostics);
                 throw new Error(`gmax: ${pressure.reason}; startup safety stop`);
             }
             if (options.readOnly || pressure !== null) {
@@ -534,7 +535,7 @@ class Daemon {
                 catch (_a) { }
                 (0, log_rotate_1.rotateLogFds)(path.join(config_1.PATHS.logsDir, "daemon.log"));
                 this.sweepWatchLeases();
-                if (!this.checkKernelZonePressure()) {
+                if (!this.checkKernelZonePressure("heartbeat")) {
                     this.heartbeatTick++;
                     if (this.pausedReason !== null && this.heartbeatTick % 5 === 0)
                         this.logResourceSnapshot("paused-heartbeat", null);
@@ -726,7 +727,7 @@ class Daemon {
                         yield (0, query_timeout_1.withQueryTimeout)(this.pausePromise, "pause transition", paused_reads_1.PAUSED_QUERY_TIMEOUT_MS);
                     if (this.shuttingDown || this.recycling)
                         throw new operation_coordinator_1.OperationClosedError();
-                    this.checkKernelZonePressure();
+                    this.checkKernelZonePressure("operation");
                     if (this.shuttingDown || this.recycling)
                         throw new operation_coordinator_1.OperationClosedError();
                     return fn(operationSignal);
@@ -795,7 +796,7 @@ class Daemon {
         if (denied !== null)
             throw new Error(`${name} refused: ${denied}`);
         // Probe at operation admission, before setup/cache/worker/model side effects.
-        if (!this.checkKernelZonePressure()) {
+        if (!this.checkKernelZonePressure("operation")) {
             throw new Error(`${name} refused: host pressure is unsafe or unknown${this.pausedReason ? `: ${this.pausedReason}` : ""}`);
         }
         if (!this.checkAggregateResources())
@@ -2140,7 +2141,7 @@ class Daemon {
     }
     runHeartbeatMaintenance(sampleFootprint) {
         // Both ordinary probes and deferred-recycle ticks check safety first.
-        if (!this.checkKernelZonePressure())
+        if (!this.checkKernelZonePressure("heartbeat"))
             return;
         if (sampleFootprint && !this.checkAggregateResources())
             return;
@@ -2260,12 +2261,12 @@ class Daemon {
      * Non-macOS hosts have no such probe. On macOS an unavailable sample is
      * explicitly unknown and cannot authorize further mutation.
      */
-    checkKernelZonePressure() {
+    checkKernelZonePressure(action = "pressure-check") {
         if (this.shuttingDown || this.recycling)
             return false;
-        const pressure = this.hostPressureDeniedReason();
+        const pressure = this.hostPressureDeniedReason(action);
         if (pressure === null || pressure === void 0 ? void 0 : pressure.critical) {
-            this.stopForSafety(pressure.reason);
+            this.stopForSafety(pressure.reason, true, pressure.diagnostics);
             return false;
         }
         const denied = (0, autostart_1.daemonStartDeniedReason)();
@@ -2287,39 +2288,48 @@ class Daemon {
                 ? error.message
                 : "aggregate resource admission unavailable";
             if (error instanceof resource_budget_1.ResourceAdmissionError && error.critical)
-                this.stopForSafety(reason);
+                this.stopForSafety(reason, true, error.diagnostics);
             else
                 this.pauseWork(reason);
             return false;
         }
     }
     /** Unknown/warning pauses resource expansion; only known critical shuts down. */
-    hostPressureDeniedReason() {
+    hostPressureDeniedReason(action = "pressure-check") {
         if (process.platform !== "darwin")
             return null;
+        const policy = (0, host_guard_policy_1.hostGuardPolicy)();
+        const probes = {};
+        const diagnostics = () => (0, pressure_diagnostics_1.probeStopDiagnostics)("daemon-pressure", action, policy, probes);
         const memory = (0, kernel_zone_1.probeMemoryPressure)();
+        probes.memoryInitial = memory;
         if (memory.status === "known" && memory.pressure === "critical")
             return {
                 reason: `critical OS memory pressure (${(0, kernel_zone_1.formatPressureProbe)(memory)})`,
                 measured: true,
                 critical: true,
+                diagnostics: diagnostics(),
             };
         // Paused reads still need the kernel-critical guard, even if OS pressure warns.
         const kernel = (0, kernel_zone_1.probeKernelZoneUsage)();
+        probes.kernel = kernel;
         if (kernel.status === "known" && kernel.usage.pressure === "critical")
             return {
                 reason: `critical kernel pressure: ${(0, kernel_zone_1.formatZoneUsage)(kernel.usage)} (${(0, kernel_zone_1.formatPressureProbe)(kernel)})`,
                 measured: true,
                 critical: true,
+                diagnostics: diagnostics(),
             };
         const freshMemory = (0, kernel_zone_1.probeMemoryPressure)();
+        probes.memoryFinal = freshMemory;
         if (freshMemory.status === "known" && freshMemory.pressure === "critical")
             return {
                 reason: `critical OS memory pressure (${(0, kernel_zone_1.formatPressureProbe)(freshMemory)})`,
                 measured: true,
                 critical: true,
+                diagnostics: diagnostics(),
             };
-        if ((0, host_guard_policy_1.hostGuardPolicy)() === "critical-only")
+        if (policy === "critical-only")
             return null;
         for (const sample of [memory, freshMemory]) {
             if (sample.status !== "known")
@@ -2327,12 +2337,14 @@ class Daemon {
                     reason: `OS memory pressure unavailable (${(0, kernel_zone_1.formatPressureProbe)(sample)})`,
                     measured: false,
                     critical: false,
+                    diagnostics: diagnostics(),
                 };
             if (sample.pressure !== "normal")
                 return {
                     reason: `warn OS memory pressure (${(0, kernel_zone_1.formatPressureProbe)(sample)})`,
                     measured: true,
                     critical: false,
+                    diagnostics: diagnostics(),
                 };
         }
         if (kernel.status !== "known")
@@ -2340,21 +2352,23 @@ class Daemon {
                 reason: `kernel pressure unavailable (${(0, kernel_zone_1.formatPressureProbe)(kernel)}); heavy work paused`,
                 measured: false,
                 critical: false,
+                diagnostics: diagnostics(),
             };
         if (kernel.usage.pressure !== "ok")
             return {
                 reason: `warn kernel pressure: ${(0, kernel_zone_1.formatZoneUsage)(kernel.usage)} (${(0, kernel_zone_1.formatPressureProbe)(kernel)})`,
                 measured: true,
                 critical: false,
+                diagnostics: diagnostics(),
             };
         return null;
     }
-    stopForSafety(reason, persist = true) {
+    stopForSafety(reason, persist = true, diagnostics) {
         // Warning already pauses mutation: a stale index costs less than another
         // host crash. Unknown readings are visible stops, never healthy samples.
         try {
             if (persist)
-                (0, safety_latch_1.latchSafetyStop)(reason);
+                (0, safety_latch_1.latchSafetyStop)(reason, undefined, diagnostics);
         }
         catch (error) {
             console.error("[daemon] Failed to persist safety stop; stopping anyway:", error);

package/dist/lib/utils/host-guard-policy.js

@@ -77,6 +77,7 @@ function sampleCriticalPressure() {
         memoryPressure,
         kernelPressure: kernel.status === "known" ? kernel.usage.pressure : "unknown",
         kernelBytes: kernel.status === "known" ? kernel.usage.bytes : null,
+        pressureProbes: { memoryInitial: memory, kernel, memoryFinal: freshMemory },
         incompleteReasons: [
             "aggregate admission disabled by explicit critical-only policy",
         ],

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

@@ -170,11 +170,11 @@ function probeMemoryPressure(overrides = {}) {
     const result = boundedPressureProbe("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], 1000, (output) => {
         switch (output.trim()) {
             case "1":
-                return "normal";
+                return { pressure: "normal", level: 1 };
             case "2":
-                return "warn";
+                return { pressure: "warn", level: 2 };
             case "4":
-                return "critical";
+                return { pressure: "critical", level: 4 };
             default:
                 return null;
         }
@@ -182,7 +182,7 @@ function probeMemoryPressure(overrides = {}) {
     if (result.status !== "known")
         return result;
     const { value } = result, observation = __rest(result, ["value"]);
-    return Object.assign(Object.assign({}, observation), { pressure: value });
+    return Object.assign(Object.assign({}, observation), value);
 }
 function classifyZonePressure(bytes) {
     if (bytes >= CRITICAL_BYTES)

package/dist/lib/utils/pressure-diagnostics.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeStopDiagnostics = sanitizeStopDiagnostics;
+exports.probeStopDiagnostics = probeStopDiagnostics;
+exports.resourceStopDiagnostics = resourceStopDiagnostics;
+const sources = new Set([
+    "resource-admission",
+    "daemon-pressure",
+    "worker-spawn",
+]);
+const actions = new Set([
+    "check",
+    "reserve",
+    "startup",
+    "pressure-check",
+    "heartbeat",
+    "operation",
+    "worker-spawn",
+]);
+const kinds = new Set([
+    "worker",
+    "embedding",
+    "native-store",
+    "llm",
+    "prune-helper",
+    "prune-runtime-setup",
+    "other",
+]);
+const memoryStates = new Set([
+    "normal",
+    "warn",
+    "critical",
+    "unknown",
+    "unsupported",
+]);
+const kernelStates = new Set([
+    "ok",
+    "warn",
+    "critical",
+    "unknown",
+    "unsupported",
+]);
+const reasons = new Set([
+    "timeout",
+    "output-limit",
+    "exit",
+    "execution",
+    "parse",
+    "unsupported-platform",
+]);
+const number = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : undefined;
+const nullableNumber = (n) => { var _a; return (_a = number(n)) !== null && _a !== void 0 ? _a : null; };
+function cleanProbe(p) {
+    if (!["known", "unknown", "unsupported"].includes(p.status))
+        return;
+    return Object.assign({ status: p.status, sampledAtMs: number(p.sampledAtMs), durationMs: number(p.durationMs), outputBytes: number(p.outputBytes), reason: p.reason && reasons.has(p.reason) ? p.reason : undefined }, (p.status === "known"
+        ? {
+            memoryPressure: p.memoryPressure && memoryStates.has(p.memoryPressure)
+                ? p.memoryPressure
+                : undefined,
+            memoryLevel: p.memoryLevel !== undefined && [1, 2, 4].includes(p.memoryLevel)
+                ? p.memoryLevel
+                : undefined,
+            kernelPressure: p.kernelPressure && kernelStates.has(p.kernelPressure)
+                ? p.kernelPressure
+                : undefined,
+            kernelBytes: number(p.kernelBytes),
+            kernelElements: number(p.kernelElements),
+            kernelElementSize: number(p.kernelElementSize),
+        }
+        : {}));
+}
+/** Rebuild the allowlist at persistence, even when a runtime caller supplies extras.
+ * Invalid diagnostic data must never prevent the original stop from persisting. */
+function sanitizeStopDiagnostics(input) {
+    try {
+        if (!sources.has(input.source) ||
+            !actions.has(input.action) ||
+            !["strict", "critical-only"].includes(input.policy) ||
+            !Number.isSafeInteger(input.pid) ||
+            input.pid < 1)
+            return;
+        const s = input.snapshot;
+        const p = input.probes;
+        return {
+            source: input.source,
+            action: input.action,
+            policy: input.policy,
+            pid: input.pid,
+            reservationKind: input.reservationKind && kinds.has(input.reservationKind)
+                ? input.reservationKind
+                : undefined,
+            reservationMb: number(input.reservationMb),
+            snapshot: s
+                ? {
+                    at: nullableNumber(s.at),
+                    completedAt: nullableNumber(s.completedAt),
+                    memoryPressure: memoryStates.has(s.memoryPressure)
+                        ? s.memoryPressure
+                        : "unknown",
+                    kernelPressure: kernelStates.has(s.kernelPressure)
+                        ? s.kernelPressure
+                        : "unknown",
+                    kernelBytes: nullableNumber(s.kernelBytes),
+                    aggregateFootprintMb: nullableNumber(s.aggregateFootprintMb),
+                    physicalFreeMb: nullableNumber(s.physicalFreeMb),
+                    swapUsedMb: nullableNumber(s.swapUsedMb),
+                }
+                : undefined,
+            probes: p
+                ? {
+                    memoryInitial: p.memoryInitial
+                        ? cleanProbe(p.memoryInitial)
+                        : undefined,
+                    kernel: p.kernel ? cleanProbe(p.kernel) : undefined,
+                    memoryFinal: p.memoryFinal ? cleanProbe(p.memoryFinal) : undefined,
+                }
+                : undefined,
+        };
+    }
+    catch (_a) {
+        return;
+    }
+}
+function probeEvidence(p) {
+    return Object.assign({ status: p.status, sampledAtMs: p.sampledAtMs, durationMs: p.durationMs, outputBytes: p.outputBytes }, (p.status !== "known"
+        ? { reason: p.reason }
+        : "usage" in p
+            ? {
+                kernelPressure: p.usage.pressure,
+                kernelBytes: p.usage.bytes,
+                kernelElements: p.usage.elements,
+                kernelElementSize: p.usage.elementSize,
+            }
+            : { memoryPressure: p.pressure, memoryLevel: p.level }));
+}
+function probeStopDiagnostics(source, action, policy, probes) {
+    return {
+        source,
+        action,
+        policy,
+        pid: process.pid,
+        probes: {
+            memoryInitial: probes.memoryInitial && probeEvidence(probes.memoryInitial),
+            kernel: probes.kernel && probeEvidence(probes.kernel),
+            memoryFinal: probes.memoryFinal && probeEvidence(probes.memoryFinal),
+        },
+    };
+}
+function resourceStopDiagnostics(snapshot, policy, action, pid, kind, mb) {
+    return {
+        source: "resource-admission",
+        action,
+        policy,
+        pid,
+        snapshot: {
+            at: snapshot.at,
+            completedAt: snapshot.completedAt,
+            memoryPressure: snapshot.memoryPressure,
+            kernelPressure: snapshot.kernelPressure,
+            kernelBytes: snapshot.kernelBytes,
+            aggregateFootprintMb: snapshot.aggregateFootprintMb,
+            physicalFreeMb: snapshot.physicalFreeMb,
+            swapUsedMb: snapshot.swapUsedMb,
+        },
+        reservationKind: kind
+            ? kinds.has(kind)
+                ? kind
+                : "other"
+            : undefined,
+        reservationMb: mb,
+        probes: snapshot.pressureProbes
+            ? probeStopDiagnostics("daemon-pressure", "pressure-check", policy, snapshot.pressureProbes).probes
+            : undefined,
+    };
+}

package/dist/lib/utils/resource-budget.js

@@ -48,6 +48,7 @@ const config_1 = require("../../config");
 const autostart_1 = require("./autostart");
 const host_guard_policy_1 = require("./host-guard-policy");
 const host_resource_1 = require("./host-resource");
+const pressure_diagnostics_1 = require("./pressure-diagnostics");
 const safety_latch_1 = require("./safety-latch");
 /** Admission thresholds, not an OS-enforced memory cap. Keep enough room for
  * a worker's measured 1536MiB recycle threshold, and charge pending launches
@@ -58,9 +59,10 @@ exports.WORKER_RESOURCE_RESERVE_MB = 1536;
 exports.EMBEDDING_RESOURCE_RESERVE_MB = 1024;
 exports.HELPER_RESOURCE_RESERVE_MB = 512;
 class ResourceAdmissionError extends Error {
-    constructor(message, critical = false) {
+    constructor(message, critical = false, diagnostics) {
         super(message);
         this.critical = critical;
+        this.diagnostics = diagnostics;
         this.code = "HOST_RESOURCE";
         this.name = "ResourceAdmissionError";
     }
@@ -108,7 +110,7 @@ class ResourceBudget {
         this.deps = Object.assign({ root: path.join(config_1.PATHS.sharedRoot, "resource-budget"), platform: process.platform, pid: process.pid, now: Date.now, sample: (extraPids = []) => {
                 const records = this.readExistingRecords();
                 return (0, host_resource_1.sampleHostResources)([...records.map((r) => r.pid), ...extraPids], this.deps.samplerOverrides, records.flatMap((r) => (r.groupPid ? [r.groupPid] : [])));
-            }, signal: (pid) => process.kill(pid, 0), policy: host_guard_policy_1.hostGuardPolicy, requireClientRegistration: true, samplerOverrides: {}, sampleMaxAgeMs: 5000, criticalSample: host_guard_policy_1.sampleCriticalPressure, quarantine: autostart_1.daemonStartDeniedReason, latch: safety_latch_1.latchSafetyStop, processStart: () => (0, node_child_process_1.execFileSync)("ps", ["-p", String(process.pid), "-o", "lstart="], {
+            }, signal: (pid) => process.kill(pid, 0), policy: host_guard_policy_1.hostGuardPolicy, requireClientRegistration: true, samplerOverrides: {}, sampleMaxAgeMs: 5000, criticalSample: host_guard_policy_1.sampleCriticalPressure, quarantine: autostart_1.daemonStartDeniedReason, latch: (reason, diagnostics) => (0, safety_latch_1.latchSafetyStop)(reason, undefined, diagnostics), processStart: () => (0, node_child_process_1.execFileSync)("ps", ["-p", String(process.pid), "-o", "lstart="], {
                 encoding: "utf8",
                 timeout: 500,
                 maxBuffer: 1024,
@@ -263,7 +265,7 @@ class ResourceBudget {
             fs.closeSync(dir);
         }
     }
-    checked(snapshot, records) {
+    checked(snapshot, records, kind, mb) {
         try {
             assertResourceSnapshot(snapshot, this.charge(snapshot, records), resolveResourceBudgetMb(), this.deps.now(), this.deps.sampleMaxAgeMs);
             const legacy = snapshot.processes.filter((p) => p.role === "mcp" &&
@@ -273,8 +275,9 @@ class ResourceBudget {
         }
         catch (error) {
             if (error instanceof ResourceAdmissionError && error.critical) {
+                error.diagnostics = (0, pressure_diagnostics_1.resourceStopDiagnostics)(snapshot, "strict", kind ? "reserve" : "check", this.deps.pid, kind, mb);
                 try {
-                    this.deps.latch(error.message);
+                    this.deps.latch(error.message, error.diagnostics);
                 }
                 catch (_a) {
                     error.message += "; safety stop persistence failed";
@@ -346,7 +349,7 @@ class ResourceBudget {
             throw new ResourceAdmissionError("host containment");
         return snapshot;
     }
-    check(requiredPid) {
+    check(requiredPid, reservation) {
         if (this.deps.platform !== "darwin")
             return null;
         if (requiredPid !== undefined &&
@@ -363,9 +366,9 @@ class ResourceBudget {
             const snapshot = this.deps.criticalSample();
             if (snapshot.memoryPressure === "critical" ||
                 snapshot.kernelPressure === "critical") {
-                const error = new ResourceAdmissionError("critical host pressure; heavy work refused", true);
+                const error = new ResourceAdmissionError("critical host pressure; heavy work refused", true, (0, pressure_diagnostics_1.resourceStopDiagnostics)(snapshot, "critical-only", reservation ? "reserve" : "check", this.deps.pid, reservation === null || reservation === void 0 ? void 0 : reservation.kind, reservation === null || reservation === void 0 ? void 0 : reservation.mb));
                 try {
-                    this.deps.latch(error.message);
+                    this.deps.latch(error.message, error.diagnostics);
                 }
                 catch (_a) {
                     error.message += "; safety stop persistence failed";
@@ -391,7 +394,7 @@ class ResourceBudget {
         if (this.deps.platform !== "darwin")
             return { attach: () => { }, release: () => { } };
         if (this.deps.policy() === "critical-only") {
-            this.check();
+            this.check(undefined, { kind, mb });
             return { attach: () => { }, release: () => { } };
         }
         let record = this.withLock(() => {
@@ -418,7 +421,7 @@ class ResourceBudget {
                 mb: charge,
                 kind,
             };
-            this.checked(snapshot, [...records, next]);
+            this.checked(snapshot, [...records, next], kind, mb);
             this.persist(next);
             return next;
         });

package/dist/lib/utils/safety-latch.js

@@ -41,6 +41,7 @@ const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const pressure_diagnostics_1 = require("./pressure-diagnostics");
 /** Machine-wide stop: changing stores or installing a version cannot clear it. */
 exports.SAFETY_LATCH_NAME = "safety-stop.json";
 function safetyRoot() {
@@ -69,7 +70,7 @@ function safetyStopReason(root = safetyRoot()) {
     }
 }
 /** Atomic durable latch; intentionally no automatic expiry or clear operation. */
-function latchSafetyStop(reason, root = safetyRoot()) {
+function latchSafetyStop(reason, root = safetyRoot(), diagnostics) {
     if (safetyStopReason(root) !== null)
         return;
     fs.mkdirSync(root, { recursive: true, mode: 0o700 });
@@ -83,6 +84,9 @@ function latchSafetyStop(reason, root = safetyRoot()) {
             schemaVersion: 1,
             at: Date.now(),
             reason: reason.replace(/[\r\n\t]/g, " ").slice(0, 512) || "host safety stop",
+            diagnostics: diagnostics
+                ? (0, pressure_diagnostics_1.sanitizeStopDiagnostics)(diagnostics)
+                : undefined,
         };
         fs.writeFileSync(fd, `${JSON.stringify(record)}\n`);
         fs.fsyncSync(fd);

package/dist/lib/workers/pool.js

@@ -61,6 +61,7 @@ const autostart_1 = require("../utils/autostart");
 const host_guard_policy_1 = require("../utils/host-guard-policy");
 const kernel_zone_1 = require("../utils/kernel-zone");
 const logger_1 = require("../utils/logger");
+const pressure_diagnostics_1 = require("../utils/pressure-diagnostics");
 const resource_budget_1 = require("../utils/resource-budget");
 const safety_latch_1 = require("../utils/safety-latch");
 exports.EXISTING_QUERY_WAIT_MS = 2000;
@@ -407,14 +408,14 @@ class WorkerPool {
         var _a;
         return Object.assign(new Error((_a = this.spawnDeniedReason) !== null && _a !== void 0 ? _a : "Worker spawn denied"), { code: "HOST_SAFETY" });
     }
-    denySpawn(reason, persist = false) {
+    denySpawn(reason, persist = false, diagnostics) {
         // 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);
+                (0, safety_latch_1.latchSafetyStop)(this.spawnDeniedReason, undefined, diagnostics);
             }
             catch (_a) {
                 try {
@@ -438,31 +439,37 @@ class WorkerPool {
             const quarantine = (0, autostart_1.daemonStartDeniedReason)();
             if (quarantine)
                 return this.denySpawn(quarantine, false);
-            const strictHostGuard = (0, host_guard_policy_1.hostGuardPolicy)() === "strict";
+            const policy = (0, host_guard_policy_1.hostGuardPolicy)();
+            const strictHostGuard = policy === "strict";
+            const probes = {};
+            const diagnostics = () => (0, pressure_diagnostics_1.probeStopDiagnostics)("worker-spawn", "worker-spawn", policy, probes);
             if (process.platform === "darwin") {
                 const memory = (0, kernel_zone_1.probeMemoryPressure)();
+                probes.memoryInitial = memory;
                 if ((memory.status === "known" && memory.pressure === "critical") ||
                     (strictHostGuard &&
                         (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)}`, memory.status === "known" && memory.pressure === "critical");
+                    return this.denySpawn(`OS memory pressure ${memory.status === "known" ? memory.pressure : memory.status}; ${(0, kernel_zone_1.formatPressureProbe)(memory)}`, memory.status === "known" && memory.pressure === "critical", diagnostics());
                 }
                 const kernel = (0, kernel_zone_1.probeKernelZoneUsage)();
+                probes.kernel = kernel;
                 if ((kernel.status === "known" && kernel.usage.pressure === "critical") ||
                     (strictHostGuard &&
                         (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)}`, kernel.status === "known" && kernel.usage.pressure === "critical");
+                    return this.denySpawn(`kernel pressure ${kernel.status === "known" ? kernel.usage.pressure : kernel.status}; ${(0, kernel_zone_1.formatPressureProbe)(kernel)}`, kernel.status === "known" && kernel.usage.pressure === "critical", diagnostics());
                 }
             }
             if (process.platform === "darwin") {
                 // Refresh the cheap OS sample after the potentially slow kernel probe.
                 const freshMemory = (0, kernel_zone_1.probeMemoryPressure)();
+                probes.memoryFinal = freshMemory;
                 if ((freshMemory.status === "known" &&
                     freshMemory.pressure === "critical") ||
                     (strictHostGuard &&
                         (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)}`, freshMemory.status === "known" &&
-                        freshMemory.pressure === "critical");
+                        freshMemory.pressure === "critical", diagnostics());
                 }
             }
             // Probes are synchronous but another process can quarantine the host

package/package.json

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