@ouro.bot/cli 0.1.0-alpha.15 → 0.1.0-alpha.151

package/dist/heart/daemon/daemon.js

@@ -34,11 +34,99 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OuroDaemon = void 0;
+exports.killOrphanProcesses = killOrphanProcesses;
+exports.writePidfile = writePidfile;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
+const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_mode_1 = require("./runtime-mode");
+const update_hooks_1 = require("./update-hooks");
+const bundle_meta_1 = require("./hooks/bundle-meta");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const update_checker_1 = require("./update-checker");
+const staged_restart_1 = require("./staged-restart");
+const child_process_1 = require("child_process");
+const pending_1 = require("../../mind/pending");
+const agent_service_1 = require("./agent-service");
+const channel_1 = require("../../mind/friends/channel");
+const mcp_manager_1 = require("../../repertoire/mcp-manager");
+const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
+/**
+ * Kill all ouro processes from the previous daemon instance using the pidfile.
+ * On startup, reads PIDs from ~/.ouro-cli/daemon.pids, kills them all, then
+ * deletes the file. The new daemon writes its own PIDs after spawning.
+ *
+ * Falls back to ps-based scanning if the pidfile doesn't exist (first run
+ * or manual cleanup).
+ */
+/* v8 ignore start -- process lifecycle: uses kill/ps, tested via deployment @preserve */
+function killOrphanProcesses() {
+    try {
+        let pidsToKill = [];
+        // Primary: read pidfile from previous daemon
+        try {
+            const raw = fs.readFileSync(PIDFILE_PATH, "utf-8");
+            pidsToKill = raw.split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
+            fs.unlinkSync(PIDFILE_PATH);
+        }
+        catch {
+            // No pidfile — fall back to ps scan
+        }
+        // Fallback: scan ps for any ouro entry processes we missed
+        if (pidsToKill.length === 0) {
+            try {
+                const result = (0, child_process_1.execSync)("ps -eo pid,command", { encoding: "utf-8", timeout: 5000 });
+                for (const line of result.split("\n")) {
+                    if (!line.includes("agent-entry.js") && !line.includes("daemon-entry.js") && !line.includes("-entry.js --agent"))
+                        continue;
+                    const pid = parseInt(line.trim(), 10);
+                    if (!isNaN(pid) && pid !== process.pid)
+                        pidsToKill.push(pid);
+                }
+            }
+            catch { /* ps failed — best effort */ }
+        }
+        if (pidsToKill.length > 0) {
+            for (const pid of pidsToKill) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch { /* already exited */ }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.orphan_cleanup",
+                message: `killed ${pidsToKill.length} orphaned ouro processes`,
+                meta: { pids: pidsToKill },
+            });
+        }
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.orphan_cleanup_error",
+            message: "failed to clean up orphaned ouro processes",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}
+/**
+ * Write all managed PIDs (daemon + children) to the pidfile.
+ * Called after all agents and senses are spawned.
+ */
+function writePidfile(extraPids = []) {
+    try {
+        const pids = [process.pid, ...extraPids].filter(Boolean);
+        fs.mkdirSync(path.dirname(PIDFILE_PATH), { recursive: true });
+        fs.writeFileSync(PIDFILE_PATH, pids.join("\n") + "\n", "utf-8");
+    }
+    catch { /* best effort */ }
+}
 function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
@@ -47,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) {
@@ -87,6 +177,7 @@ class OuroDaemon {
     router;
     senseManager;
     bundlesRoot;
+    mode;
     server = null;
     constructor(options) {
         this.socketPath = options.socketPath;
@@ -96,6 +187,7 @@ class OuroDaemon {
         this.router = options.router;
         this.senseManager = options.senseManager ?? null;
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        this.mode = options.mode ?? "production";
     }
     async start() {
         if (this.server)
@@ -106,23 +198,109 @@ class OuroDaemon {
             message: "starting daemon server",
             meta: { socketPath: this.socketPath },
         });
+        // Register update hooks and apply pending updates before starting agents
+        (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
+        const currentVersion = (0, bundle_manifest_1.getPackageVersion)();
+        await (0, update_hooks_1.applyPendingUpdates)(this.bundlesRoot, currentVersion);
+        // Start periodic update checker (polls npm registry every 30 minutes)
+        // Skip in dev mode — dev builds should not auto-update from npm
+        const bundlesRoot = this.bundlesRoot;
+        if (this.mode === "dev") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.update_checker_skip",
+                message: "skipping update checker in dev mode",
+                meta: { reason: "dev mode" },
+            });
+        }
+        else {
+            const daemon = this;
+            (0, update_checker_1.startUpdateChecker)({
+                currentVersion,
+                deps: {
+                    distTag: "alpha",
+                    fetchRegistryJson: /* v8 ignore next -- integration: real HTTP fetch @preserve */ async () => {
+                        const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli");
+                        return res.json();
+                    },
+                },
+                onUpdate: /* v8 ignore start -- integration: real npm install + process spawn @preserve */ async (result) => {
+                    if (!result.latestVersion)
+                        return;
+                    await (0, staged_restart_1.performStagedRestart)(result.latestVersion, {
+                        execSync: (cmd) => (0, child_process_1.execSync)(cmd, { stdio: "inherit" }),
+                        spawnSync: child_process_1.spawnSync,
+                        resolveNewCodePath: (_version) => {
+                            try {
+                                const resolved = (0, child_process_1.execSync)(`node -e "console.log(require.resolve('@ouro.bot/cli/package.json'))"`, { encoding: "utf-8" }).trim();
+                                return resolved ? path.dirname(resolved) : null;
+                            }
+                            catch {
+                                return null;
+                            }
+                        },
+                        gracefulShutdown: () => daemon.stop(),
+                        nodePath: process.execPath,
+                        bundlesRoot,
+                    });
+                },
+                /* v8 ignore stop */
+            });
+        }
+        // Pre-initialize MCP connections so they're ready for the first command (non-blocking)
+        /* v8 ignore next -- catch callback: getSharedMcpManager logs errors internally @preserve */
+        (0, mcp_manager_1.getSharedMcpManager)().catch(() => { });
+        /* v8 ignore start -- orphan cleanup + pidfile: calls process management functions @preserve */
+        killOrphanProcesses();
+        /* v8 ignore stop */
         await this.processManager.startAutoStartAgents();
         await this.senseManager?.startAutoStartSenses();
+        // Write all managed PIDs to disk so the next daemon can clean up
+        /* v8 ignore start -- pidfile write: collects PIDs from process managers @preserve */
+        const agentPids = this.processManager.listAgentSnapshots().map((s) => s.pid).filter((p) => p !== null);
+        const sensePids = this.senseManager?.listManagedPids?.() ?? [];
+        writePidfile([...agentPids, ...sensePids]);
+        /* v8 ignore stop */
         this.scheduler.start?.();
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
+        await this.drainPendingSenseMessages();
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
         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");
@@ -135,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() {
@@ -186,6 +379,93 @@ class OuroDaemon {
             fs.writeFileSync(pendingPath, next, "utf-8");
         }
     }
+    /** Drains per-sense pending dirs for always-on senses across all agents. */
+    static ALWAYS_ON_SENSES = new Set((0, channel_1.getAlwaysOnSenseNames)());
+    async drainPendingSenseMessages() {
+        if (!fs.existsSync(this.bundlesRoot))
+            return;
+        let bundleDirs;
+        try {
+            bundleDirs = fs.readdirSync(this.bundlesRoot, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const bundleDir of bundleDirs) {
+            if (!bundleDir.isDirectory() || !bundleDir.name.endsWith(".ouro"))
+                continue;
+            const agentName = bundleDir.name.replace(/\.ouro$/, "");
+            const pendingRoot = path.join(this.bundlesRoot, bundleDir.name, "state", "pending");
+            if (!fs.existsSync(pendingRoot))
+                continue;
+            let friendDirs;
+            try {
+                friendDirs = fs.readdirSync(pendingRoot, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const friendDir of friendDirs) {
+                if (!friendDir.isDirectory())
+                    continue;
+                const friendPath = path.join(pendingRoot, friendDir.name);
+                let channelDirs;
+                try {
+                    channelDirs = fs.readdirSync(friendPath, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const channelDir of channelDirs) {
+                    if (!channelDir.isDirectory())
+                        continue;
+                    if (!OuroDaemon.ALWAYS_ON_SENSES.has(channelDir.name))
+                        continue;
+                    const channelPath = path.join(friendPath, channelDir.name);
+                    let keyDirs;
+                    try {
+                        keyDirs = fs.readdirSync(channelPath, { withFileTypes: true });
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const keyDir of keyDirs) {
+                        if (!keyDir.isDirectory())
+                            continue;
+                        const leafDir = path.join(channelPath, keyDir.name);
+                        const messages = (0, pending_1.drainPending)(leafDir);
+                        for (const msg of messages) {
+                            try {
+                                await this.router.send({
+                                    from: msg.from,
+                                    to: agentName,
+                                    content: msg.content,
+                                    priority: "normal",
+                                });
+                            }
+                            catch {
+                                // Best-effort delivery — log and continue
+                            }
+                        }
+                        if (messages.length > 0) {
+                            (0, runtime_1.emitNervesEvent)({
+                                component: "daemon",
+                                event: "daemon.startup_sense_drain",
+                                message: "drained pending sense messages on startup",
+                                meta: {
+                                    agent: agentName,
+                                    channel: channelDir.name,
+                                    friendId: friendDir.name,
+                                    key: keyDir.name,
+                                    count: messages.length,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
     async stop() {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
@@ -193,6 +473,8 @@ class OuroDaemon {
             message: "stopping daemon server",
             meta: { socketPath: this.socketPath },
         });
+        (0, update_checker_1.stopUpdateChecker)();
+        (0, mcp_manager_1.shutdownSharedMcpManager)();
         this.scheduler.stop?.();
         await this.processManager.stopAll();
         await this.senseManager?.stopAll();
@@ -226,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();
@@ -237,13 +540,17 @@ class OuroDaemon {
                 const snapshots = this.processManager.listAgentSnapshots();
                 const workers = buildWorkerRows(snapshots);
                 const senses = this.senseManager?.listSenseRows() ?? [];
+                const repoRoot = (0, identity_1.getRepoRoot)();
                 const data = {
                     overview: {
                         daemon: "running",
                         health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
                         socketPath: this.socketPath,
+                        ...(0, runtime_metadata_1.getRuntimeMetadata)(),
                         workerCount: workers.length,
                         senseCount: senses.length,
+                        entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+                        mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
                     },
                     workers,
                     senses,
@@ -264,7 +571,7 @@ class OuroDaemon {
                     ok: true,
                     summary: "logs: use `ouro logs` to tail daemon and agent output",
                     message: "log streaming available via ouro logs",
-                    data: { logDir: "~/.agentstate/daemon/logs" },
+                    data: { logDir: "~/AgentBundles/<agent>.ouro/state/daemon/logs" },
                 };
             case "agent.start":
                 await this.processManager.startAgent(command.agent);
@@ -275,6 +582,32 @@ class OuroDaemon {
             case "agent.restart":
                 await this.processManager.restartAgent?.(command.agent);
                 return { ok: true, message: `restarted ${command.agent}` };
+            case "agent.ask":
+                return (0, agent_service_1.handleAgentAsk)(command);
+            case "agent.status":
+                return (0, agent_service_1.handleAgentStatus)(command);
+            case "agent.catchup":
+                return (0, agent_service_1.handleAgentCatchup)(command);
+            case "agent.delegate":
+                return (0, agent_service_1.handleAgentDelegate)(command);
+            case "agent.getContext":
+                return (0, agent_service_1.handleAgentGetContext)(command);
+            case "agent.searchMemory":
+                return (0, agent_service_1.handleAgentSearchMemory)(command);
+            case "agent.getTask":
+                return (0, agent_service_1.handleAgentGetTask)(command);
+            case "agent.checkScope":
+                return (0, agent_service_1.handleAgentCheckScope)(command);
+            case "agent.requestDecision":
+                return (0, agent_service_1.handleAgentRequestDecision)(command);
+            case "agent.checkGuidance":
+                return (0, agent_service_1.handleAgentCheckGuidance)(command);
+            case "agent.reportProgress":
+                return (0, agent_service_1.handleAgentReportProgress)(command);
+            case "agent.reportBlocker":
+                return (0, agent_service_1.handleAgentReportBlocker)(command);
+            case "agent.reportComplete":
+                return (0, agent_service_1.handleAgentReportComplete)(command);
             case "cron.list": {
                 const jobs = this.scheduler.listJobs();
                 const summary = jobs.length === 0
@@ -306,6 +639,13 @@ class OuroDaemon {
                     data: messages,
                 };
             }
+            case "inner.wake":
+                await this.processManager.startAgent(command.agent);
+                this.processManager.sendToAgent?.(command.agent, { type: "message" });
+                return {
+                    ok: true,
+                    message: `woke inner dialog for ${command.agent}`,
+                };
             case "chat.connect":
                 await this.processManager.startAgent(command.agent);
                 return {
@@ -328,6 +668,35 @@ 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) {
+                    return { ok: true, data: [], message: "no MCP servers configured" };
+                }
+                return { ok: true, data: mcpManager.listAllTools() };
+            }
+            case "mcp.call": {
+                const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                if (!mcpCallManager) {
+                    return { ok: false, error: "no MCP servers configured" };
+                }
+                try {
+                    const parsedArgs = command.args ? JSON.parse(command.args) : {};
+                    const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
+                    return { ok: true, data: result };
+                }
+                catch (error) {
+                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            }
             case "hatch.start":
                 return {
                     ok: true,

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