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

package/dist/heart/daemon/daemon.js

@@ -135,6 +135,8 @@ function buildWorkerRows(snapshots) {
         pid: snapshot.pid,
         restartCount: snapshot.restartCount,
         startedAt: snapshot.startedAt,
+        lastExitCode: snapshot.lastExitCode ?? null,
+        lastSignal: snapshot.lastSignal ?? null,
     }));
 }
 function formatStatusSummary(payload) {
@@ -269,12 +271,36 @@ class OuroDaemon {
         this.server = net.createServer((connection) => {
             let raw = "";
             let responded = false;
+            /* v8 ignore start — connection error handler requires real socket error @preserve */
+            connection.on("error", (err) => {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.connection_error",
+                    message: "socket connection error",
+                    meta: { error: err.message, code: err.code ?? null },
+                });
+            });
+            /* v8 ignore stop */
             const flushResponse = async () => {
                 if (responded)
                     return;
                 responded = true;
                 const response = await this.handleRawPayload(raw);
-                connection.end(response);
+                try {
+                    connection.end(response);
+                    /* v8 ignore start — EPIPE catch requires real socket disconnect @preserve */
+                }
+                catch (err) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "daemon",
+                        event: "daemon.connection_end_error",
+                        message: "failed to send response to client (EPIPE)",
+                        meta: { error: err instanceof Error ? err.message : String(err) },
+                    });
+                }
+                /* v8 ignore stop */
             };
             connection.on("data", (chunk) => {
                 raw += chunk.toString("utf-8");
@@ -287,7 +313,22 @@ class OuroDaemon {
         const server = this.server;
         await new Promise((resolve, reject) => {
             server.once("error", reject);
-            server.listen(this.socketPath, () => resolve());
+            server.listen(this.socketPath, () => {
+                // Replace the one-time error listener with a persistent one after successful listen
+                server.removeAllListeners("error");
+                /* v8 ignore start — server error after listen requires real socket race condition @preserve */
+                server.on("error", (err) => {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "daemon",
+                        event: "daemon.server_error",
+                        message: "daemon server error after listen",
+                        meta: { error: err.message, code: err.code ?? null },
+                    });
+                });
+                /* v8 ignore stop */
+                resolve();
+            });
         });
     }
     async drainPendingBundleMessages() {
@@ -467,6 +508,27 @@ class OuroDaemon {
             message: "handling daemon command",
             meta: { kind: command.kind },
         });
+        try {
+            return await this.handleCommandInner(command);
+            /* v8 ignore start — command error catch tested in daemon-command-error.test; instanceof branches defensive @preserve */
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.command_error",
+                message: "unexpected error handling daemon command",
+                meta: {
+                    kind: command.kind,
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack ?? null : null,
+                },
+            });
+            throw error;
+        }
+        /* v8 ignore stop */
+    }
+    async handleCommandInner(command) {
         switch (command.kind) {
             case "daemon.start":
                 await this.start();
@@ -606,6 +668,13 @@ class OuroDaemon {
                     data: receipt,
                 };
             }
+            case "habit.poke": {
+                this.processManager.sendToAgent?.(command.agent, { type: "habit", habitName: command.habitName });
+                return {
+                    ok: true,
+                    message: `poked habit ${command.habitName} for ${command.agent}`,
+                };
+            }
             case "mcp.list": {
                 const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
                 if (!mcpManager) {

package/dist/heart/daemon/habit-migration.js

@@ -0,0 +1,181 @@
+"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.migrateHabitsFromTaskSystem = migrateHabitsFromTaskSystem;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const habit_parser_1 = require("./habit-parser");
+const parser_1 = require("../../repertoire/tasks/parser");
+/** Fields that belong to the task system and should be stripped from migrated habits. */
+const TASK_ONLY_FIELDS = new Set([
+    "type",
+    "category",
+    "requester",
+    "validator",
+    "scheduledAt",
+    "updated",
+    "depends_on",
+    "parent_task",
+    "artifacts",
+]);
+/** Regex matching the YYYY-MM-DD-HHMM- timestamp prefix in task filenames. */
+const TIMESTAMP_PREFIX = /^\d{4}-\d{2}-\d{2}-\d{4}-/;
+/** Map old task statuses to habit statuses. */
+function mapStatus(taskStatus) {
+    if (taskStatus === "processing")
+        return "active";
+    if (taskStatus === "paused")
+        return "paused";
+    if (taskStatus === "done")
+        return null; // skip done habits
+    return "active"; // default to active for unknown statuses
+}
+/** Strip timestamp prefix from filename to get the slug name. */
+function stripTimestampPrefix(filename) {
+    return filename.replace(TIMESTAMP_PREFIX, "");
+}
+/**
+ * Migrate habit files from the old `tasks/habits/` location to the new `habits/` bundle root.
+ * - Strips timestamp prefix from filenames
+ * - Maps task statuses to habit statuses
+ * - Strips task-only frontmatter fields
+ * - Preserves body text
+ * - Skips done habits, README files, and already-migrated habits
+ * - No-op if `tasks/habits/` does not exist
+ */
+function migrateHabitsFromTaskSystem(bundleRoot) {
+    const oldHabitsDir = path.join(bundleRoot, "tasks", "habits");
+    if (!fs.existsSync(oldHabitsDir)) {
+        return;
+    }
+    let files;
+    try {
+        files = fs.readdirSync(oldHabitsDir);
+    }
+    catch {
+        /* v8 ignore next -- race condition: dir removed between existsSync and readdirSync @preserve */
+        return;
+    }
+    const mdFiles = files.filter((f) => f.endsWith(".md") && f !== "README.md");
+    if (mdFiles.length === 0)
+        return;
+    const newHabitsDir = path.join(bundleRoot, "habits");
+    fs.mkdirSync(newHabitsDir, { recursive: true });
+    let migratedCount = 0;
+    for (const file of mdFiles) {
+        const slugName = stripTimestampPrefix(file);
+        const targetPath = path.join(newHabitsDir, slugName);
+        // Skip if already migrated
+        if (fs.existsSync(targetPath)) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.habit_migration_skip",
+                message: "habit already exists at target, skipping",
+                meta: { file, targetPath },
+            });
+            continue;
+        }
+        const sourcePath = path.join(oldHabitsDir, file);
+        let content;
+        try {
+            content = fs.readFileSync(sourcePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        // Parse frontmatter and body
+        const lines = content.split(/\r?\n/);
+        if (lines[0]?.trim() !== "---")
+            continue;
+        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+        if (closing === -1)
+            continue;
+        const rawFrontmatter = lines.slice(1, closing).join("\n");
+        const body = lines.slice(closing + 1).join("\n").trim();
+        const frontmatter = (0, parser_1.parseFrontmatter)(rawFrontmatter);
+        // Check status — skip done habits
+        const rawStatus = typeof frontmatter.status === "string" ? frontmatter.status : "processing";
+        const habitStatus = mapStatus(rawStatus);
+        if (habitStatus === null) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.habit_migration_skip",
+                message: "skipping done habit",
+                meta: { file, status: rawStatus },
+            });
+            continue;
+        }
+        // Build new frontmatter, stripping task-only fields
+        const newFrontmatter = {};
+        if (typeof frontmatter.title === "string")
+            newFrontmatter.title = frontmatter.title;
+        if (typeof frontmatter.cadence === "string")
+            newFrontmatter.cadence = frontmatter.cadence;
+        newFrontmatter.status = habitStatus;
+        newFrontmatter.lastRun = typeof frontmatter.lastRun === "string" && frontmatter.lastRun !== "null"
+            ? frontmatter.lastRun
+            : "null";
+        newFrontmatter.created = typeof frontmatter.created === "string" ? frontmatter.created : "null";
+        // Add any other non-task fields from original
+        for (const [key, value] of Object.entries(frontmatter)) {
+            if (TASK_ONLY_FIELDS.has(key))
+                continue;
+            if (key in newFrontmatter)
+                continue;
+            /* v8 ignore next -- dead code: status is caught by `key in newFrontmatter` above since newFrontmatter.status is always set @preserve */
+            if (key === "status")
+                continue; // already mapped
+            newFrontmatter[key] = value;
+        }
+        const rendered = (0, habit_parser_1.renderHabitFile)(newFrontmatter, body);
+        fs.writeFileSync(targetPath, rendered, "utf-8");
+        migratedCount++;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_migrated",
+            message: "migrated habit from task system",
+            meta: { from: sourcePath, to: targetPath },
+        });
+    }
+    if (migratedCount > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_migration_complete",
+            message: "habit migration complete",
+            meta: { bundleRoot, count: migratedCount },
+        });
+    }
+}

package/dist/heart/daemon/habit-parser.js

@@ -0,0 +1,119 @@
+"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.parseHabitFile = parseHabitFile;
+exports.renderHabitFile = renderHabitFile;
+const path = __importStar(require("path"));
+const parser_1 = require("../../repertoire/tasks/parser");
+const runtime_1 = require("../../nerves/runtime");
+function isHabitStatus(value) {
+    return value === "active" || value === "paused";
+}
+function extractFrontmatterAndBody(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        return null;
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        return null;
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    return { frontmatter: (0, parser_1.parseFrontmatter)(rawFrontmatter), body };
+}
+function parseHabitFile(content, filePath) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.habit_parse",
+        component: "daemon",
+        message: "parsing habit file",
+        meta: { filePath },
+    });
+    const stem = path.basename(filePath, ".md");
+    const parsed = extractFrontmatterAndBody(content);
+    if (!parsed) {
+        return {
+            name: stem,
+            title: stem,
+            cadence: null,
+            status: "active",
+            lastRun: null,
+            created: null,
+            body: content.trim(),
+        };
+    }
+    const { frontmatter, body } = parsed;
+    const rawTitle = frontmatter.title;
+    const title = typeof rawTitle === "string" && rawTitle.length > 0 ? rawTitle : stem;
+    const rawCadence = frontmatter.cadence;
+    const cadence = typeof rawCadence === "string" && rawCadence.length > 0 ? rawCadence : null;
+    const rawStatus = frontmatter.status;
+    const status = typeof rawStatus === "string" && isHabitStatus(rawStatus) ? rawStatus : "active";
+    const rawLastRun = frontmatter.lastRun;
+    const lastRun = typeof rawLastRun === "string" && rawLastRun.length > 0 ? rawLastRun : null;
+    const rawCreated = frontmatter.created;
+    const created = typeof rawCreated === "string" && rawCreated.length > 0 ? rawCreated : null;
+    return {
+        name: stem,
+        title,
+        cadence,
+        status,
+        lastRun,
+        created,
+        body,
+    };
+}
+function formatFrontmatterValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    return String(value);
+}
+function renderHabitFile(frontmatter, body) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.habit_render",
+        component: "daemon",
+        message: "rendering habit file",
+        meta: {},
+    });
+    const lines = ["---"];
+    for (const key of Object.keys(frontmatter)) {
+        lines.push(`${key}: ${formatFrontmatterValue(frontmatter[key])}`);
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/heart/daemon/habit-scheduler.js

@@ -0,0 +1,244 @@
+"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.HabitScheduler = void 0;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const habit_parser_1 = require("./habit-parser");
+const cadence_1 = require("./cadence");
+const WATCH_DEBOUNCE_MS = 200;
+class HabitScheduler {
+    agent;
+    habitsDir;
+    osCronManager;
+    onHabitFire;
+    deps;
+    watcher = null;
+    debounceTimer = null;
+    parseErrors = [];
+    constructor(options) {
+        this.agent = options.agent;
+        this.habitsDir = options.habitsDir;
+        this.osCronManager = options.osCronManager;
+        this.onHabitFire = options.onHabitFire;
+        this.deps = options.deps;
+    }
+    start() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_start",
+            message: "habit scheduler starting",
+            meta: { agent: this.agent, habitsDir: this.habitsDir },
+        });
+        const habits = this.scanHabits();
+        const jobs = this.buildJobs(habits);
+        this.osCronManager.sync(jobs);
+        // Fire overdue habits immediately
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            const nowMs = this.deps.now();
+            if (habit.lastRun === null) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_fire",
+                    message: "firing overdue habit (never run)",
+                    meta: { habitName: habit.name, agent: this.agent },
+                });
+                this.onHabitFire(habit.name);
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            const elapsed = nowMs - lastRunMs;
+            if (elapsed >= cadenceMs) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_fire",
+                    message: "firing overdue habit",
+                    meta: { habitName: habit.name, agent: this.agent, elapsedMs: elapsed },
+                });
+                this.onHabitFire(habit.name);
+            }
+        }
+    }
+    reconcile() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_reconcile",
+            message: "habit scheduler reconciling",
+            meta: { agent: this.agent },
+        });
+        const habits = this.scanHabits();
+        const jobs = this.buildJobs(habits);
+        this.osCronManager.sync(jobs);
+    }
+    stop() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_stop",
+            message: "habit scheduler stopping",
+            meta: { agent: this.agent },
+        });
+        this.osCronManager.removeAll();
+    }
+    listOverdueHabits() {
+        const habits = this.scanHabits();
+        const nowMs = this.deps.now();
+        const overdue = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            if (habit.lastRun === null) {
+                overdue.push({ name: habit.name, elapsedMs: Infinity });
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            const elapsed = nowMs - lastRunMs;
+            if (elapsed >= cadenceMs) {
+                overdue.push({ name: habit.name, elapsedMs: elapsed });
+            }
+        }
+        return overdue;
+    }
+    getParseErrors() {
+        return [...this.parseErrors];
+    }
+    getHabitFile(name) {
+        const filePath = path.join(this.habitsDir, `${name}.md`);
+        try {
+            const content = this.deps.readFile(filePath, "utf-8");
+            return (0, habit_parser_1.parseHabitFile)(content, filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    watchForChanges() {
+        const watchFn = this.deps.watch;
+        if (!watchFn)
+            return;
+        this.watcher = watchFn(this.habitsDir, (_event, _filename) => {
+            if (this.debounceTimer !== null) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.debounceTimer = null;
+                this.reconcile();
+            }, WATCH_DEBOUNCE_MS);
+        });
+    }
+    stopWatching() {
+        if (this.debounceTimer !== null) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher !== null) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    scanHabits() {
+        let files;
+        try {
+            files = this.deps.readdir(this.habitsDir);
+        }
+        catch {
+            this.parseErrors = [];
+            return [];
+        }
+        const habits = [];
+        const errors = [];
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = path.join(this.habitsDir, file);
+            try {
+                const content = this.deps.readFile(filePath, "utf-8");
+                const habit = (0, habit_parser_1.parseHabitFile)(content, filePath);
+                habits.push(habit);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                errors.push({ file, error: errorMessage });
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.habit_parse_error",
+                    message: "failed to parse habit file",
+                    meta: {
+                        file,
+                        error: errorMessage,
+                        agent: this.agent,
+                    },
+                });
+            }
+        }
+        this.parseErrors = errors;
+        return habits;
+    }
+    buildJobs(habits) {
+        const jobs = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cronSchedule = (0, cadence_1.parseCadenceToCron)(habit.cadence);
+            if (cronSchedule === null)
+                continue;
+            jobs.push({
+                id: `${this.agent}:${habit.name}:cadence`,
+                agent: this.agent,
+                taskId: habit.name,
+                schedule: cronSchedule,
+                lastRun: habit.lastRun,
+                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name}`,
+                taskPath: path.join(this.habitsDir, `${habit.name}.md`),
+            });
+        }
+        return jobs;
+    }
+}
+exports.HabitScheduler = HabitScheduler;