@ouro.bot/cli 0.1.0-alpha.146 → 0.1.0-alpha.148

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.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": [
+        "Feedback signals as social cues: Teams thumbs-up/down and BlueBubbles reactions reach the agent as first-class social signals with full cognitive tools.",
+        "AI-generated labels: all outbound Teams messages include AIGeneratedContent entity and feedbackLoopEnabled for native AI badge and feedback UI.",
+        "BlueBubbles reaction enrichment: reactions include original message text (truncated to 80 chars) via best-effort BB API lookup.",
+        "Streaming refinements: hybrid MIN_INITIAL_CHARS (phrase rotation until 20+ real chars), proactive >4000 finalization with follow-up messages.",
+        "Welcome card: Adaptive Card with prompt starters on Teams bot install.",
+        "Observe gate: available in 1:1 chats for reaction signals (natural silence case).",
+        "Per-context prompt framing: 1:1 vs group framing for feedback signal processing."
+      ]
+    },
     {
       "version": "0.1.0-alpha.146",
       "changes": [

package/dist/heart/core.js

@@ -539,7 +539,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ...filteredBaseTools,
             tools_1.ponderTool,
             ...(isInnerDialog ? [surface_tool_1.surfaceToolDef, tools_1.restTool] : []),
-            ...(currentContext?.isGroupChat && !isInnerDialog ? [tools_1.observeTool] : []),
+            ...((currentContext?.isGroupChat || options?.isReactionSignal) && !isInnerDialog ? [tools_1.observeTool] : []),
             ...(!isInnerDialog ? [tools_1.settleTool] : []),
         ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
@@ -725,7 +725,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     (0, runtime_1.emitNervesEvent)({
                         component: "engine",
                         event: "engine.observe",
-                        message: "agent declined to respond in group chat",
+                        message: "agent observed without responding",
                         meta: { ...(reason ? { reason } : {}) },
                     });
                     callbacks.onToolEnd("observe", (0, tools_1.summarizeArgs)("observe", observeArgs), true);

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

@@ -283,6 +283,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>]",
@@ -392,16 +395,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 +1050,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 +1869,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 +2553,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 +2959,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 +2988,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,10 @@ 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");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -116,24 +119,38 @@ 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 () => {
     /* v8 ignore stop */
@@ -148,12 +165,16 @@ void daemon.start().then(() => {
     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));
 });

package/dist/heart/daemon/daemon.js

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