grepmax 0.26.72 → 0.26.74

package/dist/lib/index/watcher.js

@@ -59,6 +59,7 @@ const ignore_patterns_1 = require("./ignore-patterns");
 const walker_1 = require("./walker");
 const watcher_errors_1 = require("./watcher-errors");
 const watcher_ignore_1 = require("./watcher-ignore");
+const watcher_recovery_1 = require("./watcher-recovery");
 // Directory names ignored at ANY depth. @parcel/watcher treats a non-glob
 // ignore entry as a literal path resolved against the watch root, so a bare
 // "dist" only covered <root>/dist — nested build dirs (packages/*/dist,
@@ -114,6 +115,7 @@ function startWatcher(opts) {
         const { projectRoot } = opts;
         const wtag = `watch:${projectRoot.split("/").pop()}`;
         const filePolicy = new file_policy_1.ProjectFilePolicy(projectRoot);
+        const recovery = new watcher_recovery_1.WatcherRecoveryTracker();
         let reconciliation = null;
         let reconcileRequested = false;
         let closing = false;
@@ -143,6 +145,7 @@ function startWatcher(opts) {
                 subscriptionFailed = false;
                 yield subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
                 subscription = null;
+                recovery.detached();
                 if (closing)
                     return;
                 const { subscription: next, policy: attachedPolicy } = yield (0, watcher_ignore_1.subscribeWithNativeExclusions)(projectRoot, (err, events) => {
@@ -150,6 +153,7 @@ function startWatcher(opts) {
                     if (closing || generation !== subscriptionGeneration)
                         return;
                     if (err) {
+                        recovery.error(err);
                         console.error(`[${wtag}] Watcher error:`, err);
                         scanHealthy = false;
                         (_a = opts.onHealthChange) === null || _a === void 0 ? void 0 : _a.call(opts, false, 1);
@@ -171,6 +175,7 @@ function startWatcher(opts) {
                 }
                 subscription = next;
                 subscriptionPolicy = attachedPolicy;
+                recovery.attached(attachedPolicy);
             }));
             subscriptionUpdate = update;
             return update;
@@ -199,76 +204,88 @@ function startWatcher(opts) {
                     reconcileRequested = false;
                     lastReconcileStart = Date.now();
                     const observedGapGeneration = gapGeneration;
-                    filePolicy.invalidateIgnoreCache();
-                    yield updateSubscription();
-                    if (closing)
-                        return;
-                    const rootPrefix = projectRoot.endsWith("/")
-                        ? projectRoot
-                        : `${projectRoot}/`;
-                    const cached = yield opts.metaCache.getKeysWithPrefix(rootPrefix);
-                    const vectorPaths = yield opts.vectorDb.getDistinctPathsForPrefix(rootPrefix);
-                    const knownPaths = new Set([...cached, ...vectorPaths]);
-                    const seen = new Set();
-                    const state = (0, walker_1.createWalkState)();
+                    const scan = recovery.beginScan();
+                    let outcome = "failed";
+                    let retryDelayMs = 0;
                     try {
-                        for (var _e = true, _f = (e_1 = void 0, __asyncValues((0, walker_1.walk)(projectRoot, {
-                            policy: filePolicy,
-                            state,
-                        }))), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
-                            _c = _g.value;
-                            _e = false;
-                            const relative = _c;
+                        filePolicy.invalidateIgnoreCache();
+                        yield updateSubscription();
+                        if (closing)
+                            return;
+                        const rootPrefix = projectRoot.endsWith("/")
+                            ? projectRoot
+                            : `${projectRoot}/`;
+                        const cached = yield opts.metaCache.getKeysWithPrefix(rootPrefix);
+                        const vectorPaths = yield opts.vectorDb.getDistinctPathsForPrefix(rootPrefix);
+                        const knownPaths = new Set([...cached, ...vectorPaths]);
+                        const seen = new Set();
+                        const state = (0, walker_1.createWalkState)();
+                        try {
+                            for (var _e = true, _f = (e_1 = void 0, __asyncValues((0, walker_1.walk)(projectRoot, {
+                                policy: filePolicy,
+                                state,
+                            }))), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                                _c = _g.value;
+                                _e = false;
+                                const relative = _c;
+                                if (closing)
+                                    return;
+                                const absolute = path.join(projectRoot, relative);
+                                seen.add(absolute);
+                                const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absolute, opts.metaCache.get(absolute), vectorPaths.has(absolute));
+                                if (reconciliation.action === "stamp") {
+                                    opts.metaCache.put(absolute, reconciliation.entry);
+                                }
+                                processor.handleFileEvent("change", absolute, {
+                                    forceReprocess: reconciliation.action === "reprocess",
+                                    workKind: "catchup",
+                                });
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        for (const cachedPath of knownPaths) {
                             if (closing)
                                 return;
-                            const absolute = path.join(projectRoot, relative);
-                            seen.add(absolute);
-                            const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absolute, opts.metaCache.get(absolute), vectorPaths.has(absolute));
-                            if (reconciliation.action === "stamp") {
-                                opts.metaCache.put(absolute, reconciliation.entry);
+                            if (!seen.has(cachedPath) &&
+                                !(0, walker_1.isPathProtectedByWalkState)(cachedPath, state)) {
+                                processor.handleFileEvent("unlink", cachedPath, {
+                                    forceDelete: true,
+                                    workKind: "cleanup",
+                                });
                             }
-                            processor.handleFileEvent("change", absolute, {
-                                forceReprocess: reconciliation.action === "reprocess",
-                                workKind: "catchup",
-                            });
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
                         }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    for (const cachedPath of knownPaths) {
-                        if (closing)
-                            return;
-                        if (!seen.has(cachedPath) &&
-                            !(0, walker_1.isPathProtectedByWalkState)(cachedPath, state)) {
-                            processor.handleFileEvent("unlink", cachedPath, {
-                                forceDelete: true,
-                                workKind: "cleanup",
-                            });
+                        if (!state.rootComplete || state.errors.length > 0) {
+                            outcome = "incomplete";
+                            scanHealthy = false;
+                            (_d = opts.onHealthChange) === null || _d === void 0 ? void 0 : _d.call(opts, false, state.errors.length);
+                            console.error(`[${wtag}] Reconciliation incomplete at ${state.errors.length} path(s)`);
+                            if (incompleteRetries < 3) {
+                                incompleteRetries++;
+                                reconcileRequested = true;
+                                retryDelayMs = 1000 * Math.pow(2, (incompleteRetries - 1));
+                            }
                         }
-                    }
-                    if (!state.rootComplete || state.errors.length > 0) {
-                        scanHealthy = false;
-                        (_d = opts.onHealthChange) === null || _d === void 0 ? void 0 : _d.call(opts, false, state.errors.length);
-                        console.error(`[${wtag}] Reconciliation incomplete at ${state.errors.length} path(s)`);
-                        if (incompleteRetries < 3) {
-                            incompleteRetries++;
-                            reconcileRequested = true;
-                            yield new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, (incompleteRetries - 1))));
+                        else {
+                            outcome = "complete";
+                            scanHealthy = observedGapGeneration === gapGeneration;
+                            if (ingestionDegraded && processor.progress.pendingFiles > 0) {
+                                degradedRepairQueued = true;
+                            }
+                            reportHealthyIfSettled();
+                            incompleteRetries = 0;
                         }
                     }
-                    else {
-                        scanHealthy = observedGapGeneration === gapGeneration;
-                        if (ingestionDegraded && processor.progress.pendingFiles > 0) {
-                            degradedRepairQueued = true;
-                        }
-                        reportHealthyIfSettled();
-                        incompleteRetries = 0;
+                    finally {
+                        recovery.finishScan(scan, closing ? "aborted" : outcome);
                     }
+                    if (retryDelayMs > 0)
+                        yield new Promise((resolve) => setTimeout(resolve, retryDelayMs));
                 } while (reconcileRequested && !closing);
             }))()
                 .catch((err) => console.error(`[${wtag}] Reconciliation failed:`, err))
@@ -313,6 +330,24 @@ function startWatcher(opts) {
         yield updateSubscription();
         reconcile();
         return {
+            get health() {
+                const progress = processor.progress;
+                const state = recovery.snapshot();
+                return {
+                    indexing: progress.processing || progress.pendingFiles > 0,
+                    pendingFiles: progress.pendingFiles,
+                    queue: progress.queue,
+                    failedFiles: Math.max(terminalFailures.size, progress.failedFiles),
+                    degraded: !scanHealthy || ingestionDegraded || terminalFailures.size > 0,
+                    watcherMode: closing
+                        ? undefined
+                        : subscriptionFailed || gapScanTimer || state.reconciliationNeeded
+                            ? "recovering"
+                            : "native",
+                    catchupRunning: reconciliation !== null,
+                    watcherRecovery: state,
+                };
+            },
             get progress() {
                 return processor.progress;
             },
@@ -322,6 +357,7 @@ function startWatcher(opts) {
                 clearTimeout(gapScanTimer);
                 yield subscriptionUpdate.catch(() => { });
                 yield subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+                recovery.detached();
                 yield reconciliation;
                 yield processor.close();
             }),

package/dist/lib/output/index-state-footer.js

@@ -7,6 +7,7 @@
 // agent can decide to caveat its answer or retry once indexing settles.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatWatchQueue = formatWatchQueue;
+exports.formatWatcherRecovery = formatWatcherRecovery;
 exports.formatIndexStateFooter = formatIndexStateFooter;
 function formatWatchQueue(queue) {
     const age = queue.oldestLiveEditAgeMs === null
@@ -14,6 +15,13 @@ function formatWatchQueue(queue) {
         : `${Math.ceil(queue.oldestLiveEditAgeMs / 1000)}s`;
     return `live=${queue.live} catchup=${queue.catchup} cleanup=${queue.cleanup} active=${queue.activeFiles} oldestLiveEdit=${age}`;
 }
+function formatWatcherRecovery(state) {
+    var _a, _b;
+    var _c, _d;
+    if (!state)
+        return null;
+    return `gaps=${state.gapCount} covered=${state.coveredGapCount} outstanding=${state.outstandingGapCount} terminalErrors=${state.terminalErrorCount} reconciliationNeeded=${state.reconciliationNeeded} scan=${(_c = (_a = state.lastScan) === null || _a === void 0 ? void 0 : _a.id) !== null && _c !== void 0 ? _c : "none"}/${(_d = (_b = state.lastScan) === null || _b === void 0 ? void 0 : _b.outcome) !== null && _d !== void 0 ? _d : "none"} exclusions=${state.exclusions ? `${state.exclusions.attached ? "attached" : "detached"}:${state.exclusions.literalCount}+${state.exclusions.filterCount}:${state.exclusions.fingerprint}` : "unknown"}`;
+}
 /**
  * One-line footer describing an in-progress index, or null when there's
  * nothing to say (no state, or the index is settled). Suppressing the

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/utils/watcher-store.js

@@ -109,11 +109,12 @@ function updateWatcherStatus(pid, status, lastReindex, lastError) {
         }
     }
 }
-function heartbeat(pid) {
+function heartbeat(pid, indexState) {
     const db = getDb();
     for (const { key, value } of db.getRange()) {
         if (value && value.pid === pid) {
-            db.put(String(key), Object.assign(Object.assign({}, value), { lastHeartbeat: Date.now() }));
+            const now = Date.now();
+            db.put(String(key), Object.assign(Object.assign(Object.assign({}, value), { lastHeartbeat: now }), (indexState ? { indexState, indexStateAt: now } : {})));
         }
     }
 }

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