@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.700

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

@@ -0,0 +1,56 @@
+"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,
+        ],
+    };
+}
+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");
+    if (!habitRef || typeof habitRef.id !== "string" || !triggerRef || typeof triggerRef.id !== "string")
+        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 };
+}

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 };
+}

package/dist/heart/daemon/hooks/bundle-meta.js

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleMetaHook = bundleMetaHook;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const record_paths_1 = require("../../../mind/record-paths");
+/**
+ * Migrate bundle from schema 1 to schema 2:
+ * - Move state/{episodes,obligations,cares,intentions}/* to arc/{name}/*
+ * - Move legacy record stores into desk/_record/
+ * Idempotent: skips missing sources; on collision, newer mtime wins.
+ */
+function migrateToSchema2(agentRoot) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_start",
+        message: "migrating bundle to schema 2",
+        meta: { agentRoot },
+    });
+    // Migrate arc entities
+    for (const name of ["episodes", "obligations", "cares", "intentions"]) {
+        const src = path.join(agentRoot, "state", name);
+        const dest = path.join(agentRoot, "arc", name);
+        migrateDirectory(src, dest);
+    }
+    // Stage legacy diary files for schema 3 to canonicalize into Desk record.
+    const legacyDiarySrc = path.join(agentRoot, "psyche", "mem" + "ory");
+    const diaryDest = path.join(agentRoot, "diary");
+    migrateDirectory(legacyDiarySrc, diaryDest);
+    // Update bundle .gitignore
+    updateBundleGitignore(agentRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_end",
+        message: "bundle migration to schema 2 complete",
+        meta: { agentRoot },
+    });
+}
+/**
+ * Ensure bundle .gitignore has state/ ignored and does NOT ignore tracked record roots.
+ */
+function updateBundleGitignore(agentRoot) {
+    const gitignorePath = path.join(agentRoot, ".gitignore");
+    let lines = [];
+    try {
+        if (fs.existsSync(gitignorePath)) {
+            lines = fs.readFileSync(gitignorePath, "utf-8").split("\n");
+        }
+    }
+    catch {
+        // If we can't read, start fresh
+    }
+    // Remove tracked bundle roots from ignore.
+    const toRemove = new Set(["arc/", "desk/", "diary/", "journal/"]);
+    lines = lines.filter((line) => !toRemove.has(line.trim()));
+    // Ensure state/ is in the ignore list
+    const hasState = lines.some((line) => line.trim() === "state/");
+    if (!hasState) {
+        lines.push("state/");
+    }
+    // Write back, trimming trailing empty lines and ensuring trailing newline
+    const content = lines.join("\n").replace(/\n+$/, "") + "\n";
+    try {
+        fs.writeFileSync(gitignorePath, content, "utf-8");
+    }
+    catch {
+        // Non-blocking: if we can't write .gitignore, migration still succeeds
+    }
+}
+function migrateToSchema3(agentRoot) {
+    (0, record_paths_1.migrateLegacyRecordStores)(agentRoot);
+    updateBundleGitignore(agentRoot);
+}
+/**
+ * Recursively copy files from src to dest.
+ * Creates destination directories as needed. Skips if source doesn't exist.
+ * When both source and destination exist, compares mtimes: newer file wins.
+ * Logs a warning either way when a collision is detected.
+ */
+function migrateDirectory(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            migrateDirectory(srcPath, destPath);
+        }
+        else if (!fs.existsSync(destPath)) {
+            fs.copyFileSync(srcPath, destPath);
+        }
+        else {
+            // Collision: both source and destination exist — compare mtimes
+            const srcMtime = fs.statSync(srcPath).mtimeMs;
+            const destMtime = fs.statSync(destPath).mtimeMs;
+            if (srcMtime > destMtime) {
+                fs.copyFileSync(srcPath, destPath);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: source newer, overwriting destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+            else {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: destination newer or equal, keeping destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+        }
+    }
+}
+async function bundleMetaHook(ctx) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_meta_hook_start",
+        message: "running bundle-meta update hook",
+        meta: { agentRoot: ctx.agentRoot, currentVersion: ctx.currentVersion },
+    });
+    const metaPath = path.join(ctx.agentRoot, "bundle-meta.json");
+    let existing;
+    try {
+        if (fs.existsSync(metaPath)) {
+            const raw = fs.readFileSync(metaPath, "utf-8");
+            existing = JSON.parse(raw);
+        }
+    }
+    catch {
+        // Malformed JSON -- treat as missing, will overwrite with fresh
+        existing = undefined;
+    }
+    // Run schema migrations if needed.
+    const currentSchema = existing?.bundleSchemaVersion ?? 1;
+    try {
+        if (currentSchema < 2) {
+            migrateToSchema2(ctx.agentRoot);
+        }
+        if (currentSchema < 3) {
+            migrateToSchema3(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.bundle_meta_hook_error",
+            message: "bundle-meta hook migration failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    const updated = {
+        runtimeVersion: ctx.currentVersion,
+        bundleSchemaVersion: currentSchema < 3 ? 3 : currentSchema,
+        lastUpdated: new Date().toISOString(),
+    };
+    // Save old runtimeVersion as previousRuntimeVersion (if there was one)
+    if (existing?.runtimeVersion) {
+        updated.previousRuntimeVersion = existing.runtimeVersion;
+    }
+    try {
+        fs.writeFileSync(metaPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    }
+    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.bundle_meta_hook_error",
+            message: "bundle-meta hook write failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_meta_hook_end",
+        message: "bundle-meta updated",
+        meta: {
+            agentRoot: ctx.agentRoot,
+            runtimeVersion: updated.runtimeVersion,
+            previousRuntimeVersion: updated.previousRuntimeVersion,
+        },
+    });
+    return { ok: true };
+}

package/dist/heart/daemon/http-health-probe.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpHealthProbe = createHttpHealthProbe;
+const http = __importStar(require("node:http"));
+function createHttpHealthProbe(name, port, timeoutMs = 5000) {
+    return {
+        name,
+        check: () => new Promise((resolve) => {
+            const req = http.get({
+                hostname: "127.0.0.1",
+                port,
+                path: "/health",
+                timeout: timeoutMs,
+            }, (res) => {
+                let body = "";
+                res.on("data", (chunk) => {
+                    body += chunk.toString();
+                });
+                res.on("end", () => {
+                    if (res.statusCode !== 200) {
+                        resolve({ ok: false, detail: `HTTP ${res.statusCode}` });
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(body);
+                        if (parsed.status === "ok") {
+                            resolve({ ok: true });
+                        }
+                        else {
+                            resolve({ ok: false, detail: `unexpected status: ${String(parsed.status)}` });
+                        }
+                    }
+                    catch {
+                        resolve({ ok: false, detail: "invalid JSON response" });
+                    }
+                });
+            });
+            req.on("timeout", () => {
+                req.destroy();
+                resolve({ ok: false, detail: "timeout" });
+            });
+            req.on("error", (err) => {
+                resolve({ ok: false, detail: err.message });
+            });
+        }),
+    };
+}