@evomap/evolver-core 2.0.0-beta.0

package/dist/observers/observerBus.d.ts

@@ -0,0 +1,44 @@
+import type { RootEvent } from '../events/eventSchema.js';
+import type { EventSink } from '../events/sink.js';
+export interface ObserverMeta {
+    name: string;
+    eventTypes?: readonly string[];
+    idempotent: boolean;
+    timeoutMs: number;
+}
+export interface Observer {
+    readonly meta: ObserverMeta;
+    handle(event: Readonly<RootEvent>): void | Promise<void>;
+}
+export interface DlqEntry {
+    observer: string;
+    event: Readonly<RootEvent>;
+    error: string;
+    at: string;
+    reason: 'throw' | 'timeout';
+}
+export declare class InvalidObserverMetaError extends Error {
+    constructor(msg: string);
+}
+/** 进程内 observer bus (军杰§8): meta 强制 + quarantine + DLQ; 旁路, 故障绝不影响主写路径. */
+export declare class ObserverBus implements EventSink {
+    private readonly observers;
+    private readonly quarantined;
+    private readonly dlq;
+    private readonly failCounts;
+    private inflight;
+    private readonly poisonThreshold;
+    constructor(opts?: {
+        poisonThreshold?: number;
+    });
+    register(observer: Observer): void;
+    /** fan-out: 非阻塞, observer 故障隔离, 绝不向调用方抛. */
+    dispatch(event: RootEvent): void;
+    private run;
+    private withTimeout;
+    /** 等所有 inflight 完成 (优雅关闭/测试). */
+    drain(): Promise<void>;
+    isQuarantined(name: string): boolean;
+    reset(name: string): void;
+    deadLetters(): readonly DlqEntry[];
+}

package/dist/observers/observerBus.js

@@ -0,0 +1,73 @@
+export class InvalidObserverMetaError extends Error {
+    constructor(msg) { super(`observer meta 非法: ${msg}`); this.name = 'InvalidObserverMetaError'; }
+}
+function deepFreeze(o) {
+    if (o && typeof o === 'object') {
+        for (const v of Object.values(o))
+            deepFreeze(v);
+        Object.freeze(o);
+    }
+    return o;
+}
+/** 进程内 observer bus (军杰§8): meta 强制 + quarantine + DLQ; 旁路, 故障绝不影响主写路径. */
+export class ObserverBus {
+    observers = new Map();
+    quarantined = new Set();
+    dlq = [];
+    failCounts = new Map();
+    inflight = [];
+    poisonThreshold;
+    constructor(opts = {}) { this.poisonThreshold = opts.poisonThreshold ?? 1; }
+    register(observer) {
+        const m = observer.meta;
+        if (!m || typeof m.name !== 'string' || m.name.length === 0)
+            throw new InvalidObserverMetaError('name 必填');
+        if (typeof m.idempotent !== 'boolean')
+            throw new InvalidObserverMetaError('idempotent 必填(boolean)');
+        if (typeof m.timeoutMs !== 'number' || m.timeoutMs <= 0)
+            throw new InvalidObserverMetaError('timeoutMs 必填(>0)');
+        if (this.observers.has(m.name))
+            throw new InvalidObserverMetaError(`重名 observer: ${m.name}`);
+        this.observers.set(m.name, observer);
+    }
+    /** fan-out: 非阻塞, observer 故障隔离, 绝不向调用方抛. */
+    dispatch(event) {
+        const frozen = deepFreeze(structuredClone(event));
+        for (const obs of this.observers.values()) {
+            if (this.quarantined.has(obs.meta.name))
+                continue;
+            if (obs.meta.eventTypes && !obs.meta.eventTypes.includes(event.type))
+                continue;
+            this.inflight.push(this.run(obs, frozen));
+        }
+    }
+    async run(obs, event) {
+        try {
+            await this.withTimeout(Promise.resolve(obs.handle(event)), obs.meta.timeoutMs, obs.meta.name);
+            this.failCounts.delete(obs.meta.name);
+        }
+        catch (e) {
+            const reason = e._timeout ? 'timeout' : 'throw';
+            this.dlq.push({ observer: obs.meta.name, event, error: e.message, at: new Date().toISOString(), reason });
+            const n = (this.failCounts.get(obs.meta.name) ?? 0) + 1;
+            this.failCounts.set(obs.meta.name, n);
+            if (n >= this.poisonThreshold || reason === 'timeout')
+                this.quarantined.add(obs.meta.name);
+        }
+    }
+    withTimeout(p, ms, name) {
+        return new Promise((resolve, reject) => {
+            const t = setTimeout(() => {
+                const err = new Error(`observer ${name} 超时 ${ms}ms`);
+                err._timeout = true;
+                reject(err);
+            }, ms);
+            p.then((v) => { clearTimeout(t); resolve(v); }, (e) => { clearTimeout(t); reject(e instanceof Error ? e : new Error(String(e))); });
+        });
+    }
+    /** 等所有 inflight 完成 (优雅关闭/测试). */
+    async drain() { const cur = this.inflight; this.inflight = []; await Promise.allSettled(cur); }
+    isQuarantined(name) { return this.quarantined.has(name); }
+    reset(name) { this.quarantined.delete(name); this.failCounts.delete(name); }
+    deadLetters() { return this.dlq; }
+}

package/dist/observers/reflectionObserver.d.ts

@@ -0,0 +1,31 @@
+import type { Ingestor } from '../events/ingest.js';
+import type { Observer } from './observerBus.js';
+export declare const REFLECTION_RECORDED_EVENT_TYPE = "reflection.recorded";
+export declare const REFLECTION_SOURCE_EVENT_TYPES: readonly ["cycle.solidified", "cycle.failed"];
+export type ReflectionOutcome = 'success' | 'failed' | 'inert';
+export type ReflectionAction = 'reinforce_successful_pattern' | 'investigate_failure_pattern' | 'avoid_inert_loop';
+export interface ReflectionSummaryInput {
+    type: string;
+    sourceEventId: string;
+    cycleId: string;
+    geneId?: string;
+    outcome?: ReflectionOutcome;
+    score?: number;
+    producedValue?: boolean;
+    error?: string;
+}
+export interface ReflectionSummary {
+    sourceEventId: string;
+    cycleId: string;
+    outcome: ReflectionOutcome;
+    action: ReflectionAction;
+    summary: string;
+    geneId?: string;
+    score?: number;
+}
+export interface ReflectionObserverDeps {
+    ingestor: Ingestor;
+    timeoutMs?: number;
+}
+export declare function buildReflectionSummary(input: ReflectionSummaryInput): ReflectionSummary;
+export declare function reflectionObserver(deps: ReflectionObserverDeps): Observer;

package/dist/observers/reflectionObserver.js

@@ -0,0 +1,124 @@
+export const REFLECTION_RECORDED_EVENT_TYPE = 'reflection.recorded';
+export const REFLECTION_SOURCE_EVENT_TYPES = ['cycle.solidified', 'cycle.failed'];
+export function buildReflectionSummary(input) {
+    const outcome = normalizeOutcome(input);
+    const action = actionFor(outcome);
+    const genePart = input.geneId ? ` using ${input.geneId}` : '';
+    const scorePart = typeof input.score === 'number' ? ` score=${trimScore(input.score)}` : '';
+    const errorPart = input.error ? ` Error: ${clip(input.error, 80)}` : '';
+    const summary = clip(outcome === 'success'
+        ? `Cycle ${input.cycleId} succeeded${genePart}${scorePart}; keep this pattern available for similar signals.`
+        : outcome === 'inert'
+            ? `Cycle ${input.cycleId} produced no value${genePart}${scorePart}; avoid reinforcing an inert loop.`
+            : `Cycle ${input.cycleId} failed${genePart}${scorePart}; inspect the failure before reusing this pattern.${errorPart}`, 220);
+    return cleanUndefined({ sourceEventId: input.sourceEventId, cycleId: input.cycleId, outcome, action, summary, geneId: input.geneId, score: input.score });
+}
+export function reflectionObserver(deps) {
+    const seen = new Set();
+    const inFlight = new Map();
+    const meta = {
+        name: 'reflection',
+        eventTypes: REFLECTION_SOURCE_EVENT_TYPES,
+        idempotent: true,
+        timeoutMs: deps.timeoutMs ?? 5_000,
+    };
+    return {
+        meta,
+        async handle(event) {
+            const input = reflectionInputFromEvent(event);
+            if (!input)
+                return;
+            if (seen.has(input.sourceEventId))
+                return;
+            const pending = inFlight.get(input.sourceEventId);
+            if (pending) {
+                await pending;
+                return;
+            }
+            const recording = Promise.resolve()
+                .then(async () => {
+                const reflection = buildReflectionSummary(input);
+                await deps.ingestor.ingest({
+                    type: REFLECTION_RECORDED_EVENT_TYPE,
+                    human: {
+                        title: `reflection ${reflection.cycleId}`,
+                        detail: reflection.summary,
+                        why: 'deterministic post-cycle reflection observer',
+                    },
+                    payload: reflection,
+                });
+                seen.add(input.sourceEventId);
+            })
+                .finally(() => {
+                inFlight.delete(input.sourceEventId);
+            });
+            inFlight.set(input.sourceEventId, recording);
+            await recording;
+        },
+    };
+}
+function reflectionInputFromEvent(event) {
+    if (!REFLECTION_SOURCE_EVENT_TYPES.includes(event.type))
+        return null;
+    const payload = asRecord(event.payload);
+    const cycleId = stringOf(payload?.['cycleId']);
+    if (!cycleId)
+        return null;
+    const outcomeRecord = asRecord(payload?.['outcome']);
+    const status = stringOf(outcomeRecord?.['status']);
+    const outcome = status === 'success' ? 'success' : status === 'failed' ? 'failed' : undefined;
+    const producedValue = boolOf(payload?.['producedValue']);
+    const error = stringOf(payload?.['error'])
+        ?? stringOf(payload?.['reason'])
+        ?? stringOf(outcomeRecord?.['reason'])
+        ?? stringOf(payload?.['failure_class_reason']);
+    return cleanUndefined({
+        type: event.type,
+        sourceEventId: event.eventId,
+        cycleId,
+        geneId: stringOf(payload?.['gene']),
+        outcome,
+        score: numberOf(outcomeRecord?.['score']),
+        producedValue,
+        error,
+    });
+}
+function normalizeOutcome(input) {
+    if (input.type === 'cycle.failed')
+        return 'failed';
+    if (input.producedValue === false)
+        return 'inert';
+    return input.outcome ?? 'success';
+}
+function actionFor(outcome) {
+    if (outcome === 'success')
+        return 'reinforce_successful_pattern';
+    if (outcome === 'inert')
+        return 'avoid_inert_loop';
+    return 'investigate_failure_pattern';
+}
+function clip(value, max) {
+    return value.length <= max ? value : `${value.slice(0, max - 3)}...`;
+}
+function trimScore(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+function numberOf(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function boolOf(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function cleanUndefined(record) {
+    for (const key of Object.keys(record)) {
+        if (record[key] === undefined)
+            delete record[key];
+    }
+    return record;
+}

package/dist/observers/valueDigestObserver.d.ts

@@ -0,0 +1,50 @@
+import type { Observer } from './observerBus.js';
+import type { ValueSummary, SummaryWindow } from '../ops/valueLedger.js';
+/** A delivery channel for a built digest. Local file + terminal MOTD to start; webhook/desktop later. */
+export interface DigestSink {
+    readonly name: string;
+    deliver(markdown: string, meta: {
+        period: string;
+        at: string;
+    }): void | Promise<void>;
+}
+/** Persists the last delivery time so the cadence survives restarts (the bus is in-process; weeks are not). */
+export interface DigestStateStore {
+    /** Epoch ms of the last delivery, or undefined if never delivered. */
+    lastDeliveredAt(): number | undefined;
+    /** Record a delivery at epoch ms. */
+    markDelivered(at: number): void;
+}
+/** In-memory state store (tests / ephemeral runs). Production injects a file-backed one. */
+export declare class InMemoryDigestState implements DigestStateStore {
+    private last;
+    constructor(seed?: number);
+    lastDeliveredAt(): number | undefined;
+    markDelivered(at: number): void;
+}
+export declare const DEFAULT_DIGEST_CADENCE_MS: number;
+export interface ValueDigestObserverDeps {
+    /** Aggregate the value summary for a window (composition wires this to loadValueSummary over trace+events). */
+    summaryProvider(window: SummaryWindow): ValueSummary;
+    /** Where a built digest goes. */
+    sink: DigestSink;
+    /** Cadence state (last-delivery persistence). Default in-memory (no persistence across process restarts). */
+    state?: DigestStateStore;
+    /** Injected clock (epoch ms). Default Date.now. */
+    now?: () => number;
+    /** Minimum interval between deliveries. Default weekly. */
+    cadenceMs?: number;
+    /** Observer handle timeout (the bus quarantines on timeout). Default 5s — plenty for format + a local sink. */
+    timeoutMs?: number;
+}
+/**
+ * Build the value-digest observer. Subscribes to ALL events (it is cadence-driven, not event-type-driven: any
+ * event is just a "tick" that prompts the due-check). On each tick:
+ *   1. cadence gate — skip unless `cadenceMs` has elapsed since the last delivery;
+ *   2. value gate   — aggregate the past `cadenceMs` window and skip unless it has MEASURED value (digestShouldSend);
+ *   3. deliver      — build the markdown digest and hand it to the sink, then record the delivery time.
+ * The handler swallows nothing on its own — it lets the bus's fault isolation catch a throwing sink (so a broken
+ * sink quarantines the observer without touching the main write path). idempotent=false: a delivery has an
+ * external side effect (a file write / a printed MOTD), so the bus must not assume it can re-run it freely.
+ */
+export declare function valueDigestObserver(deps: ValueDigestObserverDeps): Observer;

package/dist/observers/valueDigestObserver.js

@@ -0,0 +1,70 @@
+// Value digest observer (#113) — the observer bus's FIRST built-in observer. The bus has shipped (fault
+// isolation + DLQ + timeout) with zero members; this is the first notification side-effect hung off it.
+//
+// What it does: on each dispatched event it asks "is a weekly digest due?" — and only when (a) at least the
+// cadence has elapsed since the last delivery AND (b) this period produced MEASURED value does it build a digest
+// and hand it to a pluggable sink. Everything else is a no-op. The cadence + the "measured value only" gate are
+// the frequency controls the issue makes first-class ("宁可少触达，不可惹人烦").
+//
+// Boundaries: the observer NEVER derives savings itself — a `summaryProvider` is injected (the composition layer
+// wires it to loadValueSummary over trace+events). The sink is injected too (file / MOTD / future webhook). The
+// observer only orchestrates: cadence check → gate → format → deliver → record delivery. All side-effecting
+// dependencies (clock, last-delivery state, sink) are injected so it is fully testable without real I/O.
+import { buildValueDigest, digestShouldSend } from '../ops/valueOutreach.js';
+/** In-memory state store (tests / ephemeral runs). Production injects a file-backed one. */
+export class InMemoryDigestState {
+    last;
+    constructor(seed) { this.last = seed; }
+    lastDeliveredAt() { return this.last; }
+    markDelivered(at) { this.last = at; }
+}
+export const DEFAULT_DIGEST_CADENCE_MS = 7 * 24 * 60 * 60 * 1000; // weekly
+/** Period label "YYYY-MM-DD..YYYY-MM-DD" for the window [since, now). Deterministic given the two epochs. */
+function periodLabel(sinceMs, nowMs) {
+    const d = (ms) => new Date(ms).toISOString().slice(0, 10);
+    return `${d(sinceMs)}..${d(nowMs)}`;
+}
+/**
+ * Build the value-digest observer. Subscribes to ALL events (it is cadence-driven, not event-type-driven: any
+ * event is just a "tick" that prompts the due-check). On each tick:
+ *   1. cadence gate — skip unless `cadenceMs` has elapsed since the last delivery;
+ *   2. value gate   — aggregate the past `cadenceMs` window and skip unless it has MEASURED value (digestShouldSend);
+ *   3. deliver      — build the markdown digest and hand it to the sink, then record the delivery time.
+ * The handler swallows nothing on its own — it lets the bus's fault isolation catch a throwing sink (so a broken
+ * sink quarantines the observer without touching the main write path). idempotent=false: a delivery has an
+ * external side effect (a file write / a printed MOTD), so the bus must not assume it can re-run it freely.
+ */
+export function valueDigestObserver(deps) {
+    const state = deps.state ?? new InMemoryDigestState();
+    const now = deps.now ?? (() => Date.now());
+    const cadenceMs = deps.cadenceMs ?? DEFAULT_DIGEST_CADENCE_MS;
+    const meta = {
+        name: 'value-digest',
+        idempotent: false,
+        timeoutMs: deps.timeoutMs ?? 5_000,
+    };
+    return {
+        meta,
+        async handle() {
+            const t = now();
+            const last = state.lastDeliveredAt();
+            // 1. cadence gate.
+            if (last !== undefined && t - last < cadenceMs)
+                return;
+            // 2. value gate — only a window WITH measured value is worth an unsolicited push.
+            const since = t - cadenceMs;
+            const window = { since: new Date(since).toISOString(), until: new Date(t).toISOString() };
+            const summary = deps.summaryProvider(window);
+            if (!digestShouldSend(summary))
+                return; // zero-measured-value week → produce nothing
+            const period = periodLabel(since, t);
+            const markdown = buildValueDigest(summary, period);
+            if (markdown === null)
+                return; // belt-and-suspenders: gate already passed, but never deliver a null
+            // 3. deliver, then record the delivery time so the cadence advances. If the sink throws, the bus isolates
+            // it (DLQ + quarantine) and the delivery time is NOT advanced, so a fixed sink retries next tick.
+            await deps.sink.deliver(markdown, { period, at: new Date(t).toISOString() });
+            state.markDelivered(t);
+        },
+    };
+}

package/dist/ops/cleanup.d.ts

@@ -0,0 +1,23 @@
+export interface CleanupPolicy {
+    /** Delete files older than this (ms), beyond the minKeep newest. Default 7 days. */
+    maxAgeMs?: number;
+    /** Always keep at least this many newest files regardless of age. Default 10. */
+    minKeep?: number;
+    /** Hard cap: keep at most this many files total (newest wins). Default 50. */
+    maxFiles?: number;
+    /** Clock (test seam). Default: Date.now. */
+    now?: () => number;
+}
+export interface CleanupResult {
+    scanned: number;
+    deleted: number;
+    deletedPaths: string[];
+}
+/**
+ * Reclaim stale artifacts matching `pattern` in `dir`. Returns what was scanned/deleted (for audit/logging).
+ * Two phases: age-based (keep the minKeep newest, delete the rest older than maxAgeMs), then a maxFiles count
+ * cap. A non-existent dir → a clean zero result. Never throws.
+ */
+export declare function cleanupArtifacts(dir: string, pattern: RegExp, policy?: CleanupPolicy): CleanupResult;
+/** Convenience: GC the exec bridge's leftover patch files (`evolver-patch-*.diff`) in a temp dir. */
+export declare function cleanupExecPatches(tmpDir: string, policy?: CleanupPolicy): CleanupResult;

package/dist/ops/cleanup.js

@@ -0,0 +1,68 @@
+// Artifact GC (ported + generalized from v1 src/ops/cleanup.js). A resident daemon accumulates artifacts —
+// exec patch files (proof.gitDiff.patchRef under tmpdir), old event logs, scratch prompts — that nothing ever
+// reclaims. This applies a two-phase retention policy to a directory: (1) age-based, always keeping the N
+// newest regardless of age; (2) a hard count cap as a safety backstop. Generic over a filename pattern so the
+// daemon can GC each artifact kind. Best-effort + graceful: a missing dir or an undeletable file never throws.
+import { existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+function listMatching(dir, pattern) {
+    return readdirSync(dir)
+        .filter((f) => pattern.test(f))
+        .map((f) => {
+        const path = join(dir, f);
+        try {
+            return { path, mtimeMs: statSync(path).mtimeMs };
+        }
+        catch {
+            return { path, mtimeMs: 0 };
+        } // raced/removed — sorts oldest, deletion is a no-op
+    })
+        .sort((a, b) => b.mtimeMs - a.mtimeMs); // newest first
+}
+function safeBatchDelete(paths) {
+    const deleted = [];
+    for (const p of paths) {
+        try {
+            unlinkSync(p);
+            deleted.push(p);
+        }
+        catch { /* best-effort */ }
+    }
+    return deleted;
+}
+/**
+ * Reclaim stale artifacts matching `pattern` in `dir`. Returns what was scanned/deleted (for audit/logging).
+ * Two phases: age-based (keep the minKeep newest, delete the rest older than maxAgeMs), then a maxFiles count
+ * cap. A non-existent dir → a clean zero result. Never throws.
+ */
+export function cleanupArtifacts(dir, pattern, policy = {}) {
+    const maxAgeMs = policy.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
+    const minKeep = policy.minKeep ?? 10;
+    const maxFiles = policy.maxFiles ?? 50;
+    const now = policy.now ?? (() => Date.now());
+    if (!existsSync(dir))
+        return { scanned: 0, deleted: 0, deletedPaths: [] };
+    let files;
+    try {
+        files = listMatching(dir, pattern);
+    }
+    catch {
+        return { scanned: 0, deleted: 0, deletedPaths: [] };
+    }
+    const scanned = files.length;
+    const t = now();
+    const deletedPaths = [];
+    // Phase 1: age-based, but always keep the minKeep newest.
+    const ageVictims = files.slice(minKeep).filter((e) => t - e.mtimeMs > maxAgeMs).map((e) => e.path);
+    deletedPaths.push(...safeBatchDelete(ageVictims));
+    // Phase 2: hard count cap (newest wins) over whatever remains.
+    const remaining = files.filter((e) => !deletedPaths.includes(e.path));
+    if (remaining.length > maxFiles) {
+        deletedPaths.push(...safeBatchDelete(remaining.slice(maxFiles).map((e) => e.path)));
+    }
+    return { scanned, deleted: deletedPaths.length, deletedPaths };
+}
+/** Convenience: GC the exec bridge's leftover patch files (`evolver-patch-*.diff`) in a temp dir. */
+export function cleanupExecPatches(tmpDir, policy) {
+    return cleanupArtifacts(tmpDir, /^evolver-patch-.*\.diff$/, policy);
+}

package/dist/ops/health.d.ts

@@ -0,0 +1,37 @@
+export type Severity = 'info' | 'warning' | 'critical';
+export interface HealthCheck {
+    name: string;
+    ok: boolean;
+    status: string;
+    severity?: Severity;
+}
+export interface HealthReport {
+    status: 'ok' | 'warning' | 'error';
+    timestamp: string;
+    checks: HealthCheck[];
+}
+export interface HealthThresholds {
+    /** disk % used → warning (default 80) / critical (default 90). */
+    diskWarnPct: number;
+    diskCritPct: number;
+    /** memory % used → critical (default 95). */
+    memCritPct: number;
+    /** process count → warning (default 2000; possible fork bomb / leak). */
+    procWarn: number;
+}
+export interface HealthProbes {
+    /** Disk % used (0-100), or -1 if unknown. Default: statfs of the cwd's root. */
+    diskPctUsed?: () => number;
+    /** Memory % used (0-100). Default: os.freemem/totalmem. */
+    memPctUsed?: () => number;
+    /** Live process count, or -1 if unavailable on this platform. Default: count of /proc/<pid> (Linux only). */
+    procCount?: () => number;
+    /** Clock (test seam). Default: real time. */
+    now?: () => Date;
+    thresholds?: Partial<HealthThresholds>;
+}
+/**
+ * Snapshot host health for the daemon supervisor. Returns the overall status (ok | warning | error) plus a
+ * per-check breakdown. Pure given its probes — inject HealthProbes to test each branch deterministically.
+ */
+export declare function runHealthCheck(probes?: HealthProbes): HealthReport;

package/dist/ops/health.js

@@ -0,0 +1,96 @@
+// Resident-daemon health check (ported from v1 src/ops/health_check.js). A long-running autonomous loop should
+// know when its host is unhealthy — out of disk (it writes patches/event logs), memory-pressured, or leaking
+// processes (a hung-agent fork bomb) — so the supervisor can pause or alert rather than crash mid-cycle. The
+// resource probes are injected seams (default = real OS readings) so the policy is deterministic to test.
+import { statfsSync } from 'node:fs';
+import { readdirSync } from 'node:fs';
+import { freemem, totalmem } from 'node:os';
+import { parse as parsePath } from 'node:path';
+const DEFAULT_THRESHOLDS = { diskWarnPct: 80, diskCritPct: 90, memCritPct: 95, procWarn: 2000 };
+function defaultDiskPctUsed() {
+    try {
+        const root = process.platform === 'win32' ? (parsePath(process.cwd()).root || 'C:\\') : '/';
+        const s = statfsSync(root);
+        const total = Number(s.blocks) * Number(s.bsize);
+        const free = Number(s.bavail) * Number(s.bsize); // available to unprivileged users
+        if (!(total > 0))
+            return -1;
+        return Math.round(((total - free) / total) * 100);
+    }
+    catch {
+        return -1;
+    }
+}
+function defaultMemPctUsed() {
+    const total = totalmem();
+    if (!(total > 0))
+        return -1;
+    return Math.round(((total - freemem()) / total) * 100);
+}
+let procCache = -1;
+let procCacheAt = 0;
+function defaultProcCount(now) {
+    if (process.platform !== 'linux')
+        return -1;
+    try {
+        const t = now().getTime();
+        if (procCache < 0 || t - procCacheAt > 60_000) { // readdir('/proc') is heavy — cache 60s
+            procCache = readdirSync('/proc').filter((f) => /^\d+$/.test(f)).length;
+            procCacheAt = t;
+        }
+        return procCache;
+    }
+    catch {
+        return -1;
+    }
+}
+/**
+ * Snapshot host health for the daemon supervisor. Returns the overall status (ok | warning | error) plus a
+ * per-check breakdown. Pure given its probes — inject HealthProbes to test each branch deterministically.
+ */
+export function runHealthCheck(probes = {}) {
+    const now = probes.now ?? (() => new Date());
+    const th = { ...DEFAULT_THRESHOLDS, ...(probes.thresholds ?? {}) };
+    const diskPctUsed = probes.diskPctUsed ?? defaultDiskPctUsed;
+    const memPctUsed = probes.memPctUsed ?? defaultMemPctUsed;
+    const procCount = probes.procCount ?? (() => defaultProcCount(now));
+    const checks = [];
+    let critical = 0;
+    let warnings = 0;
+    const disk = diskPctUsed();
+    if (disk < 0) {
+        checks.push({ name: 'disk_space', ok: false, status: 'unavailable', severity: 'warning' });
+        warnings++;
+    }
+    else if (disk > th.diskCritPct) {
+        checks.push({ name: 'disk_space', ok: false, status: `${disk}% used`, severity: 'critical' });
+        critical++;
+    }
+    else if (disk > th.diskWarnPct) {
+        checks.push({ name: 'disk_space', ok: false, status: `${disk}% used`, severity: 'warning' });
+        warnings++;
+    }
+    else {
+        checks.push({ name: 'disk_space', ok: true, status: `${disk}% used` });
+    }
+    const mem = memPctUsed();
+    if (mem >= 0 && mem > th.memCritPct) {
+        checks.push({ name: 'memory', ok: false, status: `${mem}% used`, severity: 'critical' });
+        critical++;
+    }
+    else {
+        checks.push({ name: 'memory', ok: true, status: `${mem < 0 ? 'unknown' : mem + '% used'}` });
+    }
+    const procs = procCount();
+    if (procs >= 0) {
+        if (procs > th.procWarn) {
+            checks.push({ name: 'process_count', ok: false, status: `${procs} procs`, severity: 'warning' });
+            warnings++;
+        }
+        else {
+            checks.push({ name: 'process_count', ok: true, status: `${procs} procs` });
+        }
+    }
+    const status = critical > 0 ? 'error' : warnings > 0 ? 'warning' : 'ok';
+    return { status, timestamp: now().toISOString(), checks };
+}

package/dist/ops/index.d.ts

@@ -0,0 +1,7 @@
+export * from './health.js';
+export * from './cleanup.js';
+export * from './selfUpdate.js';
+export * from './valueLedger.js';
+export * from './valueOutreach.js';
+export * from './recall.js';
+export * from './reuseOutcomes.js';

package/dist/ops/index.js

@@ -0,0 +1,7 @@
+export * from './health.js';
+export * from './cleanup.js';
+export * from './selfUpdate.js';
+export * from './valueLedger.js';
+export * from './valueOutreach.js';
+export * from './recall.js';
+export * from './reuseOutcomes.js';