@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/daemon/freshness.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * Pipeline freshness — "is this pipe still moving?"
+ *
+ * Every outage this module exists to prevent had the same shape: a health
+ * check verified that something was *configured* or *connected*, and reported
+ * a green tick next to a pipe that had been dead for weeks.
+ *
+ *   - mail: `mail enabled` / `mail config ok` / `45479 messages` all passed
+ *     while zero mail had been ingested for 77 days after a vault key rotation
+ *     changed the mailbox keyIds. The message count is cumulative, so it can
+ *     only ever go up — it is not a liveness signal.
+ *   - bluebubbles: the upstream HTTP probe stayed `ok` for days while inbound
+ *     delivery was dead, because the server was POSTing its webhook to a
+ *     stale port. A reachable upstream does not prove inbound delivery.
+ *   - launchd: checks asserted a plist *file* existed rather than that the
+ *     job was loaded.
+ *
+ * The fix is to assert on *observed data flow*, with three rules baked into
+ * this primitive:
+ *
+ *   1. Age is always stated in the message, in human units, with the
+ *      timestamp it was derived from.
+ *   2. "Never observed any activity" and "could not observe" are distinct
+ *      states from "activity, but stale" — and none of them can read as
+ *      `pass`. An unobservable pipe is unverified, not healthy.
+ *   3. Every non-`pass` result carries a concrete remediation hint.
+ *
+ * Thresholds are always supplied by the caller so freshness policy lives with
+ * the pipe it describes, not in this file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS = exports.FRESHNESS_DAY_MS = exports.FRESHNESS_HOUR_MS = exports.FRESHNESS_MINUTE_MS = void 0;
+exports.formatFreshnessAge = formatFreshnessAge;
+exports.formatFreshnessTimestamp = formatFreshnessTimestamp;
+exports.evaluateFreshness = evaluateFreshness;
+exports.observeCreatePerEventStore = observeCreatePerEventStore;
+exports.observeMirroredStore = observeMirroredStore;
+exports.observeAppendPerEventStore = observeAppendPerEventStore;
+exports.resolveFreshnessThresholds = resolveFreshnessThresholds;
+const runtime_1 = require("../../nerves/runtime");
+exports.FRESHNESS_MINUTE_MS = 60 * 1000;
+exports.FRESHNESS_HOUR_MS = 60 * exports.FRESHNESS_MINUTE_MS;
+exports.FRESHNESS_DAY_MS = 24 * exports.FRESHNESS_HOUR_MS;
+/** Small tolerance before a future timestamp is treated as clock skew. */
+exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS = exports.FRESHNESS_MINUTE_MS;
+/**
+ * Human-readable duration. Always rounds down so the age is never overstated:
+ * "77 days" means at least 77 days have elapsed.
+ */
+function formatFreshnessAge(ms) {
+    const clamped = Math.max(0, ms);
+    const seconds = Math.floor(clamped / 1000);
+    if (seconds < 60)
+        return `${seconds} second${seconds === 1 ? "" : "s"}`;
+    const minutes = Math.floor(clamped / exports.FRESHNESS_MINUTE_MS);
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+    const hours = Math.floor(clamped / exports.FRESHNESS_HOUR_MS);
+    if (hours < 48)
+        return `${hours} hour${hours === 1 ? "" : "s"}`;
+    // The day bucket only starts at 48h, so it is always plural.
+    return `${Math.floor(clamped / exports.FRESHNESS_DAY_MS)} days`;
+}
+/** Minute-precision ISO instant — keeps the incident date visible and unambiguous. */
+function formatFreshnessTimestamp(ms) {
+    return new Date(ms).toISOString().replace(/:\d{2}\.\d{3}Z$/, "Z");
+}
+function joinDetail(parts) {
+    return parts.filter((part) => !!part && part.trim().length > 0).join("; ");
+}
+function statusForAge(ageMs, thresholds) {
+    if (ageMs >= thresholds.failAfterMs)
+        return "fail";
+    if (ageMs >= thresholds.warnAfterMs)
+        return "warn";
+    return "pass";
+}
+/**
+ * Severity for "readable store, nothing ever recorded".
+ *
+ * Floors at `warn` on purpose: a configured-but-never-delivered pipe is never
+ * healthy, but a pipe wired up minutes ago does not deserve a hard failure.
+ */
+function statusForNever(input) {
+    const since = input.configuredSinceMs;
+    if (typeof since !== "number" || !Number.isFinite(since)) {
+        return { status: "fail", configuredForMs: null };
+    }
+    const configuredForMs = Math.max(0, input.nowMs - since);
+    const escalated = statusForAge(configuredForMs, input.thresholds);
+    return { status: escalated === "pass" ? "warn" : escalated, configuredForMs };
+}
+function evaluateActivity(input, atMs) {
+    const tolerance = input.clockSkewToleranceMs ?? exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS;
+    const skewMs = atMs - input.nowMs;
+    const timestamp = formatFreshnessTimestamp(atMs);
+    if (skewMs > tolerance) {
+        return {
+            status: "warn",
+            state: "future",
+            ageMs: 0,
+            detail: joinDetail([
+                input.context,
+                `last ${input.unit} is timestamped ${timestamp}, ${formatFreshnessAge(skewMs)} in the future — clock skew means freshness cannot be trusted`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    const ageMs = Math.max(0, -skewMs);
+    const status = statusForAge(ageMs, input.thresholds);
+    if (status === "pass") {
+        return {
+            status,
+            state: "fresh",
+            ageMs,
+            detail: joinDetail([
+                input.context,
+                `${input.activity} ${formatFreshnessAge(ageMs)} ago (last ${input.unit} ${timestamp})`,
+                input.provenance,
+            ]),
+        };
+    }
+    return {
+        status,
+        state: "stale",
+        ageMs,
+        detail: joinDetail([
+            input.context,
+            `no ${input.activity} in ${formatFreshnessAge(ageMs)} — last ${input.unit} ${timestamp}`,
+            input.provenance,
+            `fix: ${input.remediation}`,
+        ]),
+    };
+}
+/**
+ * Turn a single observation into a status + actionable detail.
+ *
+ * The only path that can return `pass` is an observed activity timestamp
+ * inside the warn threshold. Everything else — no activity, unreadable store,
+ * skewed clock — is surfaced, never swallowed.
+ */
+function evaluateFreshness(input) {
+    const observation = input.observation;
+    if (observation.kind === "unknown") {
+        return {
+            status: "fail",
+            state: "unknown",
+            ageMs: null,
+            detail: joinDetail([
+                input.context,
+                `${input.activity}: last-activity time could not be determined — ${observation.reason}; unverified, not healthy`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    if (observation.kind === "none") {
+        const { status, configuredForMs } = statusForNever(input);
+        return {
+            status,
+            state: "never",
+            ageMs: null,
+            detail: joinDetail([
+                input.context,
+                configuredForMs === null
+                    ? `no ${input.activity} ever — the store is readable and empty`
+                    : `no ${input.activity} ever — the store is readable and empty, and this pipe has been configured for ${formatFreshnessAge(configuredForMs)}`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    if (!Number.isFinite(observation.atMs)) {
+        return evaluateFreshness({
+            ...input,
+            observation: { kind: "unknown", reason: `observed timestamp is not a finite epoch-ms value (${String(observation.atMs)})` },
+        });
+    }
+    return evaluateActivity(input, observation.atMs);
+}
+/**
+ * Last-write probe for **create-per-event** stores — one new file per event,
+ * such as the mailroom's `messages/<id>.json`.
+ *
+ * A directory's mtime advances whenever an entry is created or removed, so it
+ * is an exact answer to "when was a file last added here" for O(1) cost, with
+ * no per-entry stat. That matters: the production mailroom holds ~45k message
+ * files and must never be stat-walked by a health check.
+ *
+ * It is also the semantically *correct* signal here. A message's `receivedAt`
+ * is when the mail was sent, not when this machine ingested it — an mbox
+ * backfill writes month-old `receivedAt` values today — so parsing message
+ * bodies would answer a different question than "is the pipe moving?".
+ *
+ * `hasEntries` is supplied by the caller (which typically already lists the
+ * directory for a count) so an empty directory reports `none` rather than
+ * reporting its own creation time as activity.
+ */
+function observeCreatePerEventStore(dir, deps, options) {
+    const provenance = `derived from ${dir} directory mtime (O(1), no per-entry scan)`;
+    if (!deps.existsSync(dir)) {
+        return { observation: { kind: "none" }, provenance: `${dir} does not exist` };
+    }
+    if (!options.hasEntries) {
+        return { observation: { kind: "none" }, provenance: `${dir} is empty` };
+    }
+    try {
+        return { observation: { kind: "activity", atMs: deps.statSync(dir).mtimeMs }, provenance };
+    }
+    catch (error) {
+        return {
+            observation: { kind: "unknown", reason: `${dir} could not be stat'd: ${error instanceof Error ? error.message : String(error)}` },
+            provenance,
+        };
+    }
+}
+/**
+ * Last-observation probe for a **local mirror of a remote store** — the cache
+ * this machine writes as it reads a store that lives somewhere else, such as
+ * the hosted Mailroom's `state/mail-search/<messageId>.json` documents.
+ *
+ * Mechanically this is `observeCreatePerEventStore`: one file per event, named
+ * by a content-addressed id, so the directory mtime answers "when did this
+ * machine last record something it had never seen before" for O(1) cost.
+ *
+ * One rule differs, and it is the entire reason this exists: an absent or empty
+ * mirror is `unknown`, never `none`. For a local store the directory *is* the
+ * store, so empty means "nothing was ever delivered". For a mirror the
+ * authoritative store is remote and deliberately not read here — a health check
+ * must not need network access or credentials — so empty means only "this
+ * machine holds no record". That is absence of evidence, and rendering it as a
+ * confident "never delivered" would be the same crying-wolf failure as reading
+ * a local directory that nothing writes to any more.
+ */
+function observeMirroredStore(dir, deps, options) {
+    const provenanceReadNote = options.authorityReadNote ?? "which doctor does not read";
+    const unknownReadNote = options.authorityReadNote ?? "is not read by doctor (no network calls, no credentials)";
+    const provenance = `derived from the local mirror at ${dir} (directory mtime, O(1), no per-entry scan); the authoritative store is ${options.remote}, ${provenanceReadNote}`;
+    const exists = deps.existsSync(dir);
+    if (!exists || !options.hasEntries) {
+        return {
+            observation: {
+                kind: "unknown",
+                reason: `the local mirror at ${dir} is ${exists ? "empty" : "absent"}, and ${options.remote} ${unknownReadNote}, so recency cannot be measured on this machine`,
+            },
+            provenance,
+        };
+    }
+    try {
+        return { observation: { kind: "activity", atMs: deps.statSync(dir).mtimeMs }, provenance };
+    }
+    catch (error) {
+        return {
+            observation: { kind: "unknown", reason: `${dir} could not be stat'd: ${error instanceof Error ? error.message : String(error)}` },
+            provenance,
+        };
+    }
+}
+/**
+ * Last-write probe for **append-per-event** stores — a small set of long-lived
+ * logs appended in place, such as the BlueBubbles inbound ndjson (one file per
+ * chat).
+ *
+ * Directory mtime is the wrong signal here: appending to an existing file does
+ * not touch its parent directory, so a busy-but-not-growing log set would look
+ * frozen. This stats each matching entry and takes the newest.
+ *
+ * The scan is bounded by `maxEntries`. When the bound is hit the provenance
+ * says so explicitly — a bounded scan must never masquerade as exhaustive.
+ */
+function observeAppendPerEventStore(dir, deps, options) {
+    if (!deps.existsSync(dir)) {
+        return { observation: { kind: "none" }, provenance: `${dir} does not exist` };
+    }
+    let entries;
+    try {
+        entries = deps.readdirSync(dir).filter((name) => name.endsWith(options.suffix));
+    }
+    catch (error) {
+        return {
+            observation: { kind: "unknown", reason: `${dir} could not be listed: ${error instanceof Error ? error.message : String(error)}` },
+            provenance: `attempted directory listing of ${dir}`,
+        };
+    }
+    if (entries.length === 0) {
+        return { observation: { kind: "none" }, provenance: `${dir} holds no ${options.suffix} logs` };
+    }
+    const scanned = entries.slice(0, options.maxEntries);
+    const truncated = entries.length > scanned.length;
+    const provenance = truncated
+        ? `newest mtime across the first ${scanned.length} of ${entries.length} ${options.suffix} logs in ${dir} — scan bounded, newer activity may exist in the unscanned ${entries.length - scanned.length}`
+        : `newest mtime across ${scanned.length} ${options.suffix} log${scanned.length === 1 ? "" : "s"} in ${dir}`;
+    let newest = Number.NEGATIVE_INFINITY;
+    const failures = [];
+    for (const name of scanned) {
+        try {
+            const mtimeMs = deps.statSync(`${dir}/${name}`).mtimeMs;
+            if (mtimeMs > newest)
+                newest = mtimeMs;
+        }
+        catch (error) {
+            failures.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (newest === Number.NEGATIVE_INFINITY) {
+        return {
+            observation: { kind: "unknown", reason: `none of the ${scanned.length} log(s) in ${dir} could be stat'd: ${failures.slice(0, 3).join("; ")}` },
+            provenance,
+        };
+    }
+    return {
+        observation: { kind: "activity", atMs: newest },
+        provenance: failures.length > 0 ? `${provenance} (${failures.length} unreadable and skipped)` : provenance,
+    };
+}
+/**
+ * Merge an `agent.json` override onto in-repo defaults.
+ *
+ * Configuration lives in a committed config file rather than an environment
+ * variable, per the repo configuration policy. Non-positive and non-finite
+ * values are ignored so a malformed override can never disable the check.
+ */
+function resolveFreshnessThresholds(defaults, override) {
+    const record = override && typeof override === "object" && !Array.isArray(override)
+        ? override
+        : null;
+    const hours = (key) => {
+        const value = record?.[key];
+        return typeof value === "number" && Number.isFinite(value) && value > 0 ? value * exports.FRESHNESS_HOUR_MS : null;
+    };
+    return {
+        warnAfterMs: hours("warnAfterHours") ?? defaults.warnAfterMs,
+        failAfterMs: hours("failAfterHours") ?? defaults.failAfterMs,
+    };
+}
+/* v8 ignore start -- module load observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.pipeline_freshness_loaded",
+    message: "pipeline freshness primitive loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/heart/daemon/habit-private-wake.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHabitPrivateWakeCommand = buildHabitPrivateWakeCommand;
+exports.habitMessageFromPrivateWakeCommand = habitMessageFromPrivateWakeCommand;
+const flight_recorder_1 = require("../../arc/flight-recorder");
+const runtime_1 = require("../../nerves/runtime");
+function buildHabitPrivateWakeCommand(options) {
+    const firedAt = (options.now ?? (() => new Date()))().toISOString();
+    const occurrenceId = options.occurrenceId ?? firedAt;
+    const triggerSource = `habit-${options.trigger}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.habit_private_wake_built",
+        message: "built habit private-runtime wake command",
+        meta: {
+            agent: options.agent,
+            habitName: options.habitName,
+            trigger: options.trigger,
+            triggerSource,
+            occurrenceId,
+        },
+    });
+    return {
+        kind: "private.wake",
+        agent: options.agent,
+        reason: `habit ${options.habitName} fired by ${options.trigger}`,
+        triggerSource,
+        budgetClass: "scheduled",
+        idempotencyKey: `habit:${options.agent}:${options.habitName}:${options.trigger}:${occurrenceId}`,
+        originRefs: [
+            { kind: "habit", id: options.habitName },
+            { kind: "habit-trigger", id: options.trigger },
+            { kind: "habit-occurrence", id: occurrenceId },
+            options.sourceRef,
+            ...(options.noSend ? [{ kind: "capability", id: "no-send" }] : []),
+        ],
+        ...(options.noSend ? { noSend: true } : {}),
+    };
+}
+function habitMessageFromPrivateWakeCommand(command) {
+    if (command.kind !== "private.wake")
+        return null;
+    if (typeof command.triggerSource !== "string" || !command.triggerSource.startsWith("habit-"))
+        return null;
+    const habitRef = command.originRefs?.find((ref) => ref.kind === "habit" && typeof ref.id === "string");
+    const triggerRef = command.originRefs?.find((ref) => ref.kind === "habit-trigger" && typeof ref.id === "string");
+    const noSendRef = command.originRefs?.some((ref) => ref.kind === "capability" && ref.id === "no-send") ?? false;
+    if (!habitRef || typeof habitRef.id !== "string" || !triggerRef || typeof triggerRef.id !== "string")
+        return null;
+    if ((command.noSend === true) !== noSendRef)
+        return null;
+    const habitName = habitRef.id.trim();
+    const trigger = triggerRef.id.trim();
+    if (habitName.length === 0)
+        return null;
+    if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger))
+        return null;
+    if (command.triggerSource !== `habit-${trigger}`)
+        return null;
+    return { habitName, trigger, ...(noSendRef ? { noSend: true } : {}) };
+}

package/dist/heart/daemon/health-monitor.js

@@ -7,37 +7,124 @@ class HealthMonitor {
     scheduler;
     alertSink;
     diskUsagePercent;
+    sentinelChecker;
+    onCriticalAgent;
+    onCriticalSense;
+    senseProbes;
+    senseProbeProvider;
+    intervalHandle = null;
+    lastResults = [];
     constructor(options) {
         this.processManager = options.processManager;
         this.scheduler = options.scheduler;
         this.alertSink = options.alertSink ?? (() => undefined);
         this.diskUsagePercent = options.diskUsagePercent ?? (() => 0);
+        this.sentinelChecker = options.sentinelChecker ?? (() => []);
+        this.onCriticalAgent = options.onCriticalAgent ?? (() => undefined);
+        this.onCriticalSense = options.onCriticalSense ?? (() => undefined);
+        this.senseProbes = options.senseProbes ?? [];
+        this.senseProbeProvider = options.senseProbeProvider ?? (() => []);
+    }
+    triggerSenseRecovery(probe, detail) {
+        if (!probe.managedName)
+            return;
+        try {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.health_check_sense_recovery_attempted",
+                message: "triggering recovery restart for failed sense probe",
+                meta: {
+                    probeName: probe.name,
+                    managedName: probe.managedName,
+                    detail,
+                },
+            });
+            this.onCriticalSense(probe.managedName, probe.name);
+        }
+        catch {
+            // Recovery is best-effort -- callback errors must not crash runChecks
+        }
+    }
+    startPeriodicChecks(intervalMs) {
+        if (this.intervalHandle !== null)
+            return;
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "daemon",
+            event: "daemon.health_check_scheduled",
+            message: "periodic health checks started",
+            meta: { intervalMs },
+        });
+        this.intervalHandle = setInterval(() => {
+            void this.runChecks();
+        }, intervalMs);
+    }
+    stopPeriodicChecks() {
+        if (this.intervalHandle === null)
+            return;
+        clearInterval(this.intervalHandle);
+        this.intervalHandle = null;
     }
     async runChecks() {
         const results = [];
         const snapshots = this.processManager.listAgentSnapshots();
-        const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running");
+        const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running" && snapshot.autoStart !== false);
+        const parked = snapshots.filter((snapshot) => snapshot.status !== "running" && snapshot.autoStart === false);
         if (unhealthy.length > 0) {
+            const unhealthySummary = unhealthy.map((item) => {
+                const detail = [
+                    item.errorReason ?? null,
+                    item.fixHint ? `fix: ${item.fixHint}` : null,
+                ].filter((part) => part !== null).join("; ");
+                return detail.length > 0 ? `${item.name} (${detail})` : item.name;
+            }).join(", ");
             results.push({
                 name: "agent-processes",
                 status: "critical",
-                message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
+                message: `non-running agents: ${unhealthySummary}`,
             });
+            for (const agent of unhealthy) {
+                try {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "daemon",
+                        event: "daemon.health_check_recovery_attempted",
+                        message: "triggering recovery restart for non-running agent",
+                        meta: {
+                            agentName: agent.name,
+                            agentStatus: agent.status,
+                            errorReason: agent.errorReason ?? null,
+                            fixHint: agent.fixHint ?? null,
+                        },
+                    });
+                    this.onCriticalAgent(agent.name);
+                }
+                catch {
+                    // Recovery is best-effort -- callback errors must not crash runChecks
+                }
+            }
         }
         else {
-            results.push({ name: "agent-processes", status: "ok", message: "all managed agents running" });
+            const message = parked.length > 0
+                ? `all auto-start managed agents running; parked agents: ${parked.map((item) => item.name).join(", ")}`
+                : "all managed agents running";
+            results.push({ name: "agent-processes", status: "ok", message });
         }
         const jobs = this.scheduler.listJobs();
-        const neverRan = jobs.filter((job) => !job.lastRun);
-        if (neverRan.length > 0) {
-            results.push({
-                name: "cron-health",
-                status: "warn",
-                message: `jobs never run: ${neverRan.map((job) => job.id).join(", ")}`,
-            });
+        const degradedJobs = this.scheduler.listDegradedJobs?.() ?? [];
+        if (degradedJobs.length > 0) {
+            const degradedSummary = degradedJobs
+                .map((job) => `${job.id} (${job.reason})`)
+                .join(", ");
+            results.push({ name: "cron-health", status: "warn", message: `cron jobs degraded; timer fallback active: ${degradedSummary}` });
         }
         else {
-            results.push({ name: "cron-health", status: "ok", message: "cron jobs are healthy" });
+            const neverRan = jobs.filter((job) => !job.lastRun);
+            const firstRunSuffix = neverRan.length > 0
+                ? `; pending first run: ${neverRan.map((job) => job.id).join(", ")}`
+                : "";
+            results.push({ name: "cron-health", status: "ok", message: `cron jobs are healthy${firstRunSuffix}` });
         }
         const diskPercent = this.diskUsagePercent();
         if (diskPercent >= 90) {
@@ -61,6 +148,47 @@ class HealthMonitor {
                 message: `disk usage healthy (${diskPercent}%)`,
             });
         }
+        const senseProbes = [...this.senseProbes];
+        try {
+            senseProbes.push(...this.senseProbeProvider());
+        }
+        catch (error) {
+            results.push({
+                name: "sense-probes",
+                status: "warn",
+                message: `sense probe discovery failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        for (const probe of senseProbes) {
+            try {
+                const outcome = await probe.check();
+                if (outcome.ok) {
+                    results.push({
+                        name: `sense-probe:${probe.name}`,
+                        status: "ok",
+                        message: `${probe.name} healthy`,
+                    });
+                }
+                else {
+                    this.triggerSenseRecovery(probe, outcome.detail ?? "unknown");
+                    results.push({
+                        name: `sense-probe:${probe.name}`,
+                        status: "critical",
+                        message: `${probe.name} failed: ${outcome.detail ?? "unknown"}`,
+                    });
+                }
+            }
+            catch (error) {
+                this.triggerSenseRecovery(probe, error instanceof Error ? error.message : String(error));
+                results.push({
+                    name: `sense-probe:${probe.name}`,
+                    status: "critical",
+                    message: `${probe.name} error: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        results.push(...await this.sentinelChecker(results.map((result) => ({ ...result }))));
+        this.lastResults = results.map((result) => ({ ...result }));
         for (const result of results) {
             (0, runtime_1.emitNervesEvent)({
                 level: result.status === "critical" ? "error" : result.status === "warn" ? "warn" : "info",
@@ -75,5 +203,8 @@ class HealthMonitor {
         }
         return results;
     }
+    getLastResults() {
+        return this.lastResults.map((result) => ({ ...result }));
+    }
 }
 exports.HealthMonitor = HealthMonitor;

package/dist/heart/daemon/hooks/agent-config-v2.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentConfigV2Hook = agentConfigV2Hook;
+const runtime_1 = require("../../../nerves/runtime");
+const migrate_config_1 = require("../../migrate-config");
+async function agentConfigV2Hook(ctx) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_config_v2_hook_start",
+        message: "running agent-config-v2 update hook",
+        meta: { agentRoot: ctx.agentRoot, currentVersion: ctx.currentVersion },
+    });
+    try {
+        (0, migrate_config_1.migrateAgentConfigV1ToV2)(ctx.agentRoot);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_config_v2_hook_error",
+            message: "agent-config-v2 hook migration failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_config_v2_hook_end",
+        message: "agent-config-v2 hook completed",
+        meta: { agentRoot: ctx.agentRoot },
+    });
+    return { ok: true };
+}