@ouro.bot/cli 0.1.0-alpha.147 → 0.1.0-alpha.149

package/changelog.json

@@ -1,6 +1,33 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.149",
+      "changes": [
+        "Daemon tombstone: writeDaemonTombstone persists crash context (reason, stack, uptime) to ~/.ouro-cli/daemon-death.json on uncaught exceptions and startup failures.",
+        "Global exception handlers: daemon-entry installs uncaughtException (tombstone + graceful 5s shutdown) and unhandledRejection (warn, no exit) handlers.",
+        "Log rotation: ndjson file sink rotates logs at 50MB (configurable), keeping .1 and .2 backups. Throttled stat checks via byte counter.",
+        "Socket connection error handling: connection.on('error') prevents server crash on client disconnect, connection.end() wrapped for EPIPE safety, persistent server.on('error') after listen.",
+        "Crash context in status: DaemonAgentSnapshot includes lastExitCode/lastSignal, Workers table shows last exit info, stopped-daemon status reads tombstone for 'Last death' line.",
+        "Cooldown recovery: after restart exhaustion, agents schedule recovery after cooldownRecoveryMs (default 5min). Reset crash history on recovery. maxCooldownRetries (default 3) before permanent give-up.",
+        "Defensive handleCommand: extracted handleCommandInner, outer handleCommand wraps with try/catch logging daemon.command_error with kind/error/stack before re-throw."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.148",
+      "changes": [
+        "Habits extracted from task system as first-class bundle concept at habits/ (peer to diary/, friends/, tasks/).",
+        "Name-based identity: heartbeat.md, not YYYY-MM-DD-HHMM-heartbeat.md. Simple schema: title, cadence, status (active/paused), body, lastRun, created.",
+        "HabitScheduler with OS cron (LaunchdCronManager/CrontabCronManager): each habit fires independently via its own cron entry.",
+        "Event-driven discovery: fs.watch + CLI notify trigger reconcile. No polling.",
+        "Worker rerun queue replaces single-slot mechanism, prevents dropped pokes. Each habit turn includes also-due line for agent triage.",
+        "Contextual heartbeat includes habit body: agent sees own instructions when heartbeat fires.",
+        "Daemon auto-migration from tasks/habits/ on startup. Strips timestamp prefix, maps statuses, removes task-only fields.",
+        "ouro habit list and ouro habit create CLI commands. Parse error reporting via nerves events + inner dialog nudge.",
+        "Metacognitive framing teaches agent about habits/ directory, rhythms, schema, read_file/write_file, and CLI commands.",
+        "HeartbeatTimer deleted, replaced by HabitScheduler. habit type removed from task system entirely."
+      ]
+    },
     {
       "version": "0.1.0-alpha.147",
       "changes": [

package/dist/heart/daemon/cadence.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CADENCE_MS = void 0;
+exports.parseCadenceToCron = parseCadenceToCron;
+exports.parseCadenceToMs = parseCadenceToMs;
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_CADENCE_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into a cron string.
+ * Also accepts raw cron strings (5 space-separated fields) and passes them through.
+ * Returns null for invalid input.
+ */
+function parseCadenceToCron(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    // Cron format (minute hour day month weekday)
+    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
+        return value;
+    }
+    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
+    if (!cadenceMatch)
+        return null;
+    const interval = Number.parseInt(cadenceMatch[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed",
+        component: "daemon",
+        message: "parsed cadence shorthand to cron",
+        meta: { raw: value, interval, unit: cadenceMatch[2] },
+    });
+    const unit = cadenceMatch[2];
+    if (unit === "m")
+        return `*/${interval} * * * *`;
+    if (unit === "h")
+        return `0 */${interval} * * *`;
+    return `0 0 */${interval} * *`;
+}
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into milliseconds.
+ * Returns null for invalid input.
+ */
+function parseCadenceToMs(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const match = /^(\d+)(m|h|d)$/.exec(value);
+    if (!match)
+        return null;
+    const interval = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed_ms",
+        component: "daemon",
+        message: "parsed cadence shorthand to milliseconds",
+        meta: { raw: value, interval, unit: match[2] },
+    });
+    const unit = match[2];
+    if (unit === "m")
+        return interval * 60 * 1000;
+    if (unit === "h")
+        return interval * 60 * 60 * 1000;
+    return interval * 24 * 60 * 60 * 1000;
+}

package/dist/heart/daemon/daemon-cli.js

@@ -71,6 +71,7 @@ const thoughts_1 = require("./thoughts");
 const ouro_bot_global_installer_1 = require("./ouro-bot-global-installer");
 const launchd_1 = require("./launchd");
 const socket_client_1 = require("./socket-client");
+const daemon_tombstone_1 = require("./daemon-tombstone");
 const session_activity_1 = require("../session-activity");
 const auth_flow_1 = require("./auth-flow");
 function stringField(value) {
@@ -145,6 +146,8 @@ function parseStatusPayload(data) {
             status,
             pid,
             restartCount,
+            lastExitCode: numberField(row.lastExitCode) ?? null,
+            lastSignal: stringField(row.lastSignal) ?? null,
         };
     });
     if (parsedSenses.some((row) => row === null) || parsedWorkers.some((row) => row === null))
@@ -198,13 +201,23 @@ function formatDaemonStatusOutput(response, fallback) {
         row.status,
         row.detail,
     ]);
-    const workerRows = payload.workers.map((row) => [
-        row.agent,
-        row.worker,
-        row.status,
-        row.pid === null ? "n/a" : String(row.pid),
-        String(row.restartCount),
-    ]);
+    const workerRows = payload.workers.map((row) => {
+        /* v8 ignore start — exit info branches tested via daemon-crash-context; v8 misreports conditional chains @preserve */
+        let exitInfo = "n/a";
+        if (row.lastExitCode !== null)
+            exitInfo = `code=${row.lastExitCode}`;
+        if (row.lastSignal !== null)
+            exitInfo = row.lastExitCode !== null ? `code=${row.lastExitCode} sig=${row.lastSignal}` : `sig=${row.lastSignal}`;
+        /* v8 ignore stop */
+        return [
+            row.agent,
+            row.worker,
+            row.status,
+            row.pid === null ? "n/a" : String(row.pid),
+            String(row.restartCount),
+            exitInfo,
+        ];
+    });
     return [
         "Overview",
         formatTable(["Item", "Value"], overviewRows),
@@ -213,7 +226,7 @@ function formatDaemonStatusOutput(response, fallback) {
         formatTable(["Agent", "Sense", "Enabled", "State", "Detail"], senseRows),
         "",
         "Workers",
-        formatTable(["Agent", "Worker", "State", "PID", "Restarts"], workerRows),
+        formatTable(["Agent", "Worker", "State", "PID", "Restarts", "Last Exit"], workerRows),
     ].join("\n");
 }
 async function ensureDaemonRunning(deps) {
@@ -283,6 +296,9 @@ function usage() {
         "  ouro chat <agent>",
         "  ouro msg --to <agent> [--session <id>] [--task <ref>] <message>",
         "  ouro poke <agent> --task <task-id>",
+        "  ouro poke <agent> --habit <name>",
+        "  ouro habit list [--agent <name>]",
+        "  ouro habit create [--agent <name>] <name> [--cadence <interval>]",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
         "  ouro task board [<status>] [--agent <name>]",
         "  ouro task create <title> [--type <type>] [--agent <name>]",
@@ -335,15 +351,28 @@ function buildStoppedStatusPayload(socketPath) {
     };
 }
 function daemonUnavailableStatusOutput(socketPath) {
-    return [
+    /* v8 ignore start — tombstone read tested in daemon-status-tombstone.test; branch misreported @preserve */
+    const tombstone = (0, daemon_tombstone_1.readDaemonTombstone)();
+    const deathLine = tombstone
+        ? `Last death: ${tombstone.timestamp} -- ${tombstone.reason}: ${tombstone.message}`
+        : null;
+    /* v8 ignore stop */
+    const lines = [
         formatDaemonStatusOutput({
             ok: true,
             summary: "daemon not running",
             data: buildStoppedStatusPayload(socketPath),
         }, "daemon not running"),
         "",
-        "daemon not running; run `ouro up`",
-    ].join("\n");
+    ];
+    /* v8 ignore start — tombstone presence requires real daemon crash @preserve */
+    if (deathLine) {
+        lines.push(deathLine);
+        lines.push("");
+        /* v8 ignore stop */
+    }
+    lines.push("daemon not running; run `ouro up`");
+    return lines.join("\n");
 }
 function isDaemonUnavailableError(error) {
     const code = typeof error === "object" && error !== null && "code" in error
@@ -392,16 +421,55 @@ function parsePokeCommand(args) {
     if (!agent)
         throw new Error(`Usage\n${usage()}`);
     let taskId;
+    let habitName;
     for (let i = 1; i < args.length; i += 1) {
         if (args[i] === "--task") {
             taskId = args[i + 1];
             i += 1;
         }
+        if (args[i] === "--habit") {
+            habitName = args[i + 1];
+            i += 1;
+        }
     }
+    // --habit takes priority over --task
+    if (habitName)
+        return { kind: "habit.poke", agent, habitName };
     if (!taskId)
         throw new Error(`Usage\n${usage()}`);
     return { kind: "task.poke", agent, taskId };
 }
+function parseHabitCommand(args) {
+    const { agent, rest } = extractAgentFlag(args);
+    const sub = rest[0];
+    if (sub === "list") {
+        return { kind: "habit.list", ...(agent ? { agent } : {}) };
+    }
+    if (sub === "create") {
+        const nameArgs = rest.slice(1);
+        let name;
+        let cadence;
+        const positional = [];
+        for (let i = 0; i < nameArgs.length; i++) {
+            if (nameArgs[i] === "--cadence" && nameArgs[i + 1]) {
+                cadence = nameArgs[++i];
+                continue;
+            }
+            /* v8 ignore start -- defensive: --agent already extracted by extractAgentFlag; guard prevents regression if parsing flow changes @preserve */
+            if (nameArgs[i] === "--agent" && nameArgs[i + 1]) {
+                i++; // skip --agent value (already extracted)
+                continue;
+            }
+            /* v8 ignore stop */
+            positional.push(nameArgs[i]);
+        }
+        name = positional[0];
+        if (!name)
+            throw new Error(`Usage\n${usage()}`);
+        return { kind: "habit.create", name, ...(agent ? { agent } : {}), ...(cadence ? { cadence } : {}) };
+    }
+    throw new Error(`Usage\n${usage()}`);
+}
 function parseLinkCommand(args, kind = "friend.link") {
     const agent = args[0];
     if (!agent)
@@ -1008,6 +1076,8 @@ function parseOuroCommand(args) {
         return parseTaskCommand(args.slice(1));
     if (head === "reminder")
         return parseReminderCommand(args.slice(1));
+    if (head === "habit")
+        return parseHabitCommand(args.slice(1));
     if (head === "friend")
         return parseFriendCommand(args.slice(1));
     if (head === "config")
@@ -1825,7 +1895,7 @@ function executeReminderCommand(command, taskMod) {
     try {
         const created = taskMod.createTask({
             title: command.title,
-            type: command.cadence ? "habit" : "one-shot",
+            type: command.cadence ? "ongoing" : "one-shot",
             category: command.category ?? "reminder",
             body: command.body,
             scheduledAt: command.scheduledAt,
@@ -2509,6 +2579,61 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.writeStdout(message);
         return message;
     }
+    // ── habit subcommands (local, no daemon socket needed) ──
+    if (command.kind === "habit.list" || command.kind === "habit.create") {
+        const { parseHabitFile, renderHabitFile } = await Promise.resolve().then(() => __importStar(require("./habit-parser")));
+        /* v8 ignore start -- production default: uses real bundle root @preserve */
+        const agentName = command.agent ?? (0, identity_1.getAgentName)();
+        const bundleRoot = deps.agentBundleRoot ?? path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`);
+        /* v8 ignore stop */
+        const habitsDir = path.join(bundleRoot, "habits");
+        if (command.kind === "habit.list") {
+            let files;
+            try {
+                files = fs.readdirSync(habitsDir).filter((f) => f.endsWith(".md") && f !== "README.md");
+            }
+            catch {
+                const message = "no habits found";
+                deps.writeStdout(message);
+                return message;
+            }
+            if (files.length === 0) {
+                const message = "no habits found";
+                deps.writeStdout(message);
+                return message;
+            }
+            const lines = [];
+            for (const file of files) {
+                const content = fs.readFileSync(path.join(habitsDir, file), "utf-8");
+                const habit = parseHabitFile(content, path.join(habitsDir, file));
+                const lastRunStr = habit.lastRun ?? "never";
+                lines.push(`${habit.name}  cadence=${habit.cadence ?? "none"}  status=${habit.status}  lastRun=${lastRunStr}`);
+            }
+            const message = lines.join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        // habit.create
+        const filePath = path.join(habitsDir, `${command.name}.md`);
+        if (fs.existsSync(filePath)) {
+            const message = `error: habit '${command.name}' already exists`;
+            deps.writeStdout(message);
+            return message;
+        }
+        fs.mkdirSync(habitsDir, { recursive: true });
+        const now = new Date().toISOString();
+        const content = renderHabitFile({
+            title: command.name,
+            cadence: command.cadence ?? "null",
+            status: "active",
+            lastRun: now,
+            created: now,
+        }, `Habit: ${command.name}`);
+        fs.writeFileSync(filePath, content, "utf-8");
+        const message = `created: ${filePath}`;
+        deps.writeStdout(message);
+        return message;
+    }
     // ── friend subcommands (local, no daemon socket needed) ──
     if (command.kind === "friend.list" || command.kind === "friend.show" || command.kind === "friend.create" ||
         command.kind === "friend.update" || command.kind === "friend.link" || command.kind === "friend.unlink") {
@@ -2860,7 +2985,7 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             const agentRoot = (0, identity_1.getAgentRoot)(agentName);
             const { buildInnerStatusOutput } = await Promise.resolve().then(() => __importStar(require("./inner-status")));
             const { sessionPath: getSessionPath } = await Promise.resolve().then(() => __importStar(require("../config")));
-            const { parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./heartbeat-timer")));
+            const { parseCadenceToMs: parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./cadence")));
             const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require("../../repertoire/tasks/parser")));
             const { listActiveObligations } = await Promise.resolve().then(() => __importStar(require("../../mind/obligations")));
             // Read runtime state
@@ -2889,11 +3014,10 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             let heartbeat = null;
             try {
                 const habitsDir = path.join(agentRoot, "habits");
-                const habitFiles = fs.readdirSync(habitsDir);
-                const heartbeatFile = habitFiles.find((f) => f.endsWith("-heartbeat.md"));
+                const heartbeatPath = path.join(habitsDir, "heartbeat.md");
                 let cadenceMs = DEFAULT_CADENCE_MS;
-                if (heartbeatFile) {
-                    const content = fs.readFileSync(path.join(habitsDir, heartbeatFile), "utf-8");
+                if (fs.existsSync(heartbeatPath)) {
+                    const content = fs.readFileSync(heartbeatPath, "utf-8");
                     const lines = content.split(/\r?\n/);
                     if (lines[0]?.trim() === "---") {
                         const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");

package/dist/heart/daemon/daemon-entry.js

@@ -47,7 +47,11 @@ const sense_manager_1 = require("./sense-manager");
 const agent_discovery_1 = require("./agent-discovery");
 const identity_1 = require("../identity");
 const runtime_mode_1 = require("./runtime-mode");
-const heartbeat_timer_1 = require("./heartbeat-timer");
+const habit_scheduler_1 = require("./habit-scheduler");
+const habit_migration_1 = require("./habit-migration");
+const os_cron_deps_1 = require("./os-cron-deps");
+const os_cron_1 = require("./os-cron");
+const daemon_tombstone_1 = require("./daemon-tombstone");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -116,44 +120,90 @@ const daemon = new daemon_1.OuroDaemon({
     router,
     mode,
 });
-const heartbeatTimers = [];
-/* v8 ignore start -- heartbeat wiring: lambdas delegate to processManager/fs; tested via HeartbeatTimer unit tests @preserve */
+const habitSchedulers = [];
+/* v8 ignore start -- habit wiring: lambdas delegate to processManager/fs; tested via HabitScheduler unit tests @preserve */
 void daemon.start().then(() => {
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    const ouroPath = (0, os_cron_deps_1.resolveOuroBinaryPath)();
+    const osCronDeps = (0, os_cron_deps_1.createRealOsCronDeps)();
     for (const agent of managedAgents) {
         const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
-        const timer = new heartbeat_timer_1.HeartbeatTimer({
+        const habitsDir = path.join(bundleRoot, "habits");
+        // Migrate old tasks/habits/ to habits/ at bundle root
+        (0, habit_migration_1.migrateHabitsFromTaskSystem)(bundleRoot);
+        const osCronManager = new os_cron_1.LaunchdCronManager(osCronDeps);
+        const scheduler = new habit_scheduler_1.HabitScheduler({
             agent,
-            sendToAgent: (a, msg) => processManager.sendToAgent(a, msg),
+            habitsDir,
+            osCronManager,
+            onHabitFire: (habitName) => {
+                processManager.sendToAgent(agent, { type: "habit", habitName });
+            },
             deps: {
-                readFileSync: (p, enc) => fs.readFileSync(p, enc),
-                readdirSync: (p) => fs.readdirSync(p).map((e) => (typeof e === "string" ? e : e)),
-                heartbeatTaskDir: path.join(bundleRoot, "tasks", "habits"),
-                runtimeStatePath: path.join(bundleRoot, "state", "sessions", "self", "inner", "runtime.json"),
+                readdir: (dir) => fs.readdirSync(dir),
+                readFile: (p, enc) => fs.readFileSync(p, enc),
+                writeFile: (p, c, enc) => fs.writeFileSync(p, c, enc),
+                existsSync: (p) => fs.existsSync(p),
+                now: () => Date.now(),
+                ouroPath,
+                watch: (dir, cb) => fs.watch(dir, cb),
             },
         });
-        timer.start();
-        heartbeatTimers.push(timer);
+        scheduler.start();
+        scheduler.watchForChanges();
+        habitSchedulers.push(scheduler);
     }
-}).catch(async () => {
+}).catch(async (err) => {
+    /* v8 ignore stop */
+    /* v8 ignore start — instanceof branch defensive; catch always receives Error in practice @preserve */
+    const error = err instanceof Error ? err : new Error(String(err));
     /* v8 ignore stop */
+    (0, daemon_tombstone_1.writeDaemonTombstone)("startupFailure", error);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
         event: "daemon.entry_error",
         message: "daemon entrypoint failed",
-        meta: {},
+        meta: { error: error.message },
     });
     await daemon.stop();
     process.exit(1);
 });
 process.on("SIGINT", () => {
-    for (const timer of heartbeatTimers)
-        timer.stop();
+    for (const s of habitSchedulers) {
+        s.stopWatching();
+        s.stop();
+    }
     void daemon.stop().then(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
-    for (const timer of heartbeatTimers)
-        timer.stop();
+    for (const s of habitSchedulers) {
+        s.stopWatching();
+        s.stop();
+    }
     void daemon.stop().then(() => process.exit(0));
 });
+/* v8 ignore start -- global exception handlers: genuinely untestable in vitest; exercised by real daemon crashes @preserve */
+process.on("uncaughtException", (error) => {
+    (0, daemon_tombstone_1.writeDaemonTombstone)("uncaughtException", error);
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.uncaught_exception",
+        message: "uncaught exception in daemon process",
+        meta: { error: error.message, stack: error.stack ?? null },
+    });
+    // Graceful 5-second shutdown window
+    setTimeout(() => process.exit(1), 5_000).unref();
+    void daemon.stop().then(() => process.exit(1));
+});
+process.on("unhandledRejection", (reason) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.unhandled_rejection",
+        message: "unhandled promise rejection in daemon process",
+        meta: { reason: reason instanceof Error ? reason.message : String(reason) },
+    });
+});
+/* v8 ignore stop */

package/dist/heart/daemon/daemon-tombstone.js

@@ -0,0 +1,106 @@
+"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.getTombstonePath = getTombstonePath;
+exports.setTombstonePath = setTombstonePath;
+exports.writeDaemonTombstone = writeDaemonTombstone;
+exports.readDaemonTombstone = readDaemonTombstone;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+let _tombstonePath = null;
+function getTombstonePath() {
+    if (!_tombstonePath) {
+        _tombstonePath = path.join(os.homedir(), ".ouro-cli", "daemon-death.json");
+    }
+    return _tombstonePath;
+}
+/** Overrides the tombstone path for testing. Pass null to reset. */
+function setTombstonePath(p) {
+    _tombstonePath = p;
+}
+function writeDaemonTombstone(reason, error) {
+    const tombstone = {
+        reason,
+        message: error?.message ?? reason,
+        stack: error?.stack ?? null,
+        timestamp: new Date().toISOString(),
+        pid: process.pid,
+        uptimeSeconds: Math.floor(process.uptime()),
+    };
+    const filePath = getTombstonePath();
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(tombstone, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Best-effort: if we can't write, we're already dying.
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.tombstone_written",
+        message: `daemon tombstone written: ${reason}`,
+        meta: { reason, errorMessage: error?.message ?? null, filePath },
+    });
+}
+function readDaemonTombstone() {
+    const filePath = getTombstonePath();
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.reason !== "string" || typeof parsed.timestamp !== "string") {
+            return null;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.tombstone_read",
+            message: "read daemon tombstone",
+            meta: { filePath },
+        });
+        return {
+            reason: parsed.reason,
+            message: typeof parsed.message === "string" ? parsed.message : String(parsed.reason),
+            stack: typeof parsed.stack === "string" ? parsed.stack : null,
+            timestamp: parsed.timestamp,
+            pid: typeof parsed.pid === "number" ? parsed.pid : 0,
+            uptimeSeconds: typeof parsed.uptimeSeconds === "number" ? parsed.uptimeSeconds : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}