@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

package/dist/heart/daemon/up-progress.js

@@ -0,0 +1,366 @@
+"use strict";
+/**
+ * UpProgress — accumulated-checklist progress renderer.
+ *
+ * Displays completed phases with checkmarks, the current phase with a
+ * spinner and elapsed time, and pending phases as plain text. Uses ANSI
+ * cursor control for in-place overwriting in TTY mode, and falls back to
+ * static line-per-phase output in non-TTY mode.
+ *
+ * The caller can drive animation by calling `render(now)`. In production CLI
+ * use, `autoRender` starts a short-lived timer while a TTY phase is active so
+ * long operations never leave a dead-looking cursor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandProgress = exports.UpProgress = void 0;
+const runtime_1 = require("../../nerves/runtime");
+const terminal_ui_1 = require("./terminal-ui");
+// ── ANSI constants (shared with startup-tui.ts pattern) ──
+const SPINNER_FRAMES = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const RED = "\x1b[38;2;255;106;106m";
+const BASE_UP_PHASE_PLAN = [
+    "update check",
+    "system setup",
+    "provider checks",
+    "starting daemon",
+    "final daemon check",
+];
+const FRIENDLY_UP_PHASE_LABELS = {
+    "update check": "Check for updates",
+    "system setup": "Prepare this machine",
+    "agent updates": "Update installed agents",
+    "bundle cleanup": "Clean up stale bundles",
+    "provider checks": "Check the providers your agents use right now",
+    "starting daemon": "Start the background service",
+    "final daemon check": "Confirm the background service stayed up",
+};
+function splitDetailLines(detail) {
+    if (!detail)
+        return [];
+    return detail
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+}
+// ── UpProgress class ──
+class UpProgress {
+    write;
+    isTTY;
+    columns;
+    now;
+    autoRender;
+    renderIntervalMs;
+    setTimer;
+    clearTimer;
+    eventScope;
+    commandName;
+    completed = [];
+    currentPhase = null;
+    currentDetail = null;
+    upPhasePlan = BASE_UP_PHASE_PLAN;
+    prevLineCount = 0;
+    ended = false;
+    renderTimer = null;
+    constructor(options) {
+        /* v8 ignore next -- thin wrapper: raw process.stdout.write for ANSI cursor control @preserve */
+        this.write = options?.write ?? ((text) => process.stdout.write(text));
+        /* v8 ignore next -- thin wrapper: real isTTY check injected for testability @preserve */
+        this.isTTY = options?.isTTY ?? (process.stdout.isTTY === true);
+        this.columns = options?.columns;
+        /* v8 ignore next -- thin wrapper: real Date.now injected for testability @preserve */
+        this.now = options?.now ?? (() => Date.now());
+        this.autoRender = options?.autoRender ?? false;
+        this.renderIntervalMs = options?.renderIntervalMs ?? 80;
+        /* v8 ignore start -- real timers are injected in tests when needed @preserve */
+        this.setTimer = options?.setInterval ?? ((callback, ms) => setInterval(callback, ms));
+        this.clearTimer = options?.clearInterval ?? ((handle) => clearInterval(handle));
+        /* v8 ignore stop */
+        this.eventScope = options?.eventScope ?? "up";
+        this.commandName = options?.commandName ?? null;
+    }
+    /**
+     * Begin a new phase with spinner. If a phase is already active, it is
+     * auto-completed (no detail text).
+     */
+    startPhase(label) {
+        if (this.currentPhase) {
+            this.completePhase(this.currentPhase.label);
+        }
+        this.currentPhase = { label, startedAt: this.now() };
+        this.currentDetail = null;
+        if (this.isTTY) {
+            this.ensureAutoRender();
+            this.flushRender();
+        }
+        else {
+            this.write(`  ... ${label}\n`);
+        }
+    }
+    /**
+     * Emit a one-line status breadcrumb in non-TTY mode without affecting the
+     * accumulated checklist state. Used for daemon startup sub-steps.
+     */
+    announceStep(label) {
+        if (this.currentPhase) {
+            this.updateDetail(label);
+            return;
+        }
+        if (this.isTTY)
+            return;
+        this.write(`    ${label}\n`);
+    }
+    setPhasePlan(labels) {
+        const nextPlan = [...new Set(labels.map((label) => label.trim()).filter((label) => label.length > 0))];
+        this.upPhasePlan = nextPlan.length > 0 ? nextPlan : BASE_UP_PHASE_PLAN;
+        if (this.isTTY && this.eventScope === "up") {
+            this.flushRender();
+        }
+    }
+    /**
+     * Update the sub-step detail on the current spinner phase. Rendered as
+     * "label (Xs) -- detail" in TTY mode. In non-TTY mode, writes changed
+     * detail lines so long operations remain visible in logs and captured output.
+     */
+    updateDetail(detail) {
+        if (!this.currentPhase || detail === this.currentDetail)
+            return;
+        this.currentDetail = detail;
+        this.currentPhase.detail = detail;
+        if (this.isTTY) {
+            this.flushRender();
+            return;
+        }
+        for (const line of splitDetailLines(detail)) {
+            this.write(`    ${line}\n`);
+        }
+    }
+    /**
+     * Mark the current phase as done. In non-TTY mode, immediately writes
+     * a static line. Emits a nerves event for observability.
+     */
+    completePhase(label, detail) {
+        if (!this.currentPhase) {
+            return;
+        }
+        const elapsedMs = this.now() - this.currentPhase.startedAt;
+        this.completed.push({ status: "success", label, detail });
+        this.currentPhase = null;
+        this.currentDetail = null;
+        this.stopAutoRender();
+        if (this.eventScope === "command") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.cli_progress_phase_complete",
+                message: `phase complete: ${label}`,
+                meta: { command: this.commandName, phase: label, detail: detail ?? null, elapsedMs },
+            });
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.up_phase_complete",
+                message: `phase complete: ${label}`,
+                meta: { phase: label, detail: detail ?? null, elapsedMs },
+            });
+        }
+        if (this.isTTY) {
+            this.flushRender();
+        }
+        else {
+            const detailStr = detail ? ` \u2014 ${detail}` : "";
+            this.write(`  \u2713 ${label}${detailStr}\n`);
+        }
+    }
+    failPhase(label, detail) {
+        if (!this.currentPhase) {
+            return;
+        }
+        const elapsedMs = this.now() - this.currentPhase.startedAt;
+        this.completed.push({ status: "failure", label, detail });
+        this.currentPhase = null;
+        this.currentDetail = null;
+        this.stopAutoRender();
+        if (this.eventScope === "command") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.cli_progress_phase_failed",
+                message: `phase failed: ${label}`,
+                meta: { command: this.commandName, phase: label, detail: detail ?? null, elapsedMs },
+            });
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.up_phase_failed",
+                message: `phase failed: ${label}`,
+                meta: { phase: label, detail: detail ?? null, elapsedMs },
+            });
+        }
+        if (this.isTTY) {
+            this.flushRender();
+        }
+        else {
+            const detailStr = detail ? ` \u2014 ${detail}` : "";
+            this.write(`  \u2717 ${label}${detailStr}\n`);
+        }
+    }
+    /**
+     * Build an ANSI string for in-place terminal display. Returns empty
+     * string in non-TTY mode (output is written eagerly in completePhase).
+     */
+    render(now) {
+        if (!this.isTTY) {
+            return "";
+        }
+        const lines = this.renderLines(now);
+        const output = (0, terminal_ui_1.renderOverwriteFrame)(lines, this.prevLineCount, true);
+        this.prevLineCount = lines.length;
+        return output;
+    }
+    /**
+     * Finalize the progress display. Clears the current phase (if any) and
+     * writes the final checklist state. Idempotent.
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        if (this.currentPhase) {
+            this.currentPhase = null;
+            this.currentDetail = null;
+        }
+        this.stopAutoRender();
+        if (this.isTTY) {
+            this.flushRender();
+        }
+    }
+    ensureAutoRender() {
+        if (!this.autoRender || !this.isTTY || this.renderTimer !== null) {
+            return;
+        }
+        this.renderTimer = this.setTimer(() => this.flushRender(), this.renderIntervalMs);
+    }
+    stopAutoRender() {
+        if (this.renderTimer === null) {
+            return;
+        }
+        this.clearTimer(this.renderTimer);
+        this.renderTimer = null;
+    }
+    flushRender() {
+        const output = this.render(this.now());
+        this.write(output);
+    }
+    renderLines(now) {
+        if (this.eventScope === "up") {
+            return this.renderUpScreen(now);
+        }
+        const lines = [];
+        for (const phase of this.completed) {
+            const detailStr = phase.detail ? ` ${DIM}\u2014 ${phase.detail}${RESET}` : "";
+            if (phase.status === "failure") {
+                lines.push(`  ${RED}\u2717${RESET} ${phase.label}${detailStr}`);
+            }
+            else {
+                lines.push(`  ${GREEN}\u2713${RESET} ${phase.label}${detailStr}`);
+            }
+        }
+        if (this.currentPhase) {
+            const elapsed = now - this.currentPhase.startedAt;
+            const elapsedSec = (elapsed / 1000).toFixed(1);
+            const frameIndex = Math.floor(elapsed / 80) % SPINNER_FRAMES.length;
+            const spinner = SPINNER_FRAMES[frameIndex];
+            lines.push(`  ${BOLD}${spinner}${RESET} ${this.currentPhase.label} ${DIM}(${elapsedSec}s)${RESET}`);
+            for (const detailLine of splitDetailLines(this.currentPhase.detail)) {
+                lines.push(`    ${DIM}${detailLine}${RESET}`);
+            }
+        }
+        return lines;
+    }
+    renderUpStepLabel(label) {
+        return FRIENDLY_UP_PHASE_LABELS[label] ?? label;
+    }
+    renderUpScreen(now) {
+        const seenLabels = new Set();
+        const completedByLabel = new Map(this.completed.map((phase) => [phase.label, phase]));
+        const steps = [];
+        let currentStepLabel = this.completed.some((phase) => phase.status === "failure")
+            ? "Boot paused."
+            : this.completed.length > 0
+                ? "Boot checklist complete."
+                : "Waiting to begin.";
+        let currentStepDetails = [];
+        if (this.currentPhase) {
+            const elapsed = now - this.currentPhase.startedAt;
+            const elapsedSec = (elapsed / 1000).toFixed(1);
+            const frameIndex = Math.floor(elapsed / 80) % SPINNER_FRAMES.length;
+            const spinner = SPINNER_FRAMES[frameIndex];
+            currentStepLabel = `${spinner} ${this.renderUpStepLabel(this.currentPhase.label)} (${elapsedSec}s)`;
+            currentStepDetails = splitDetailLines(this.currentPhase.detail);
+        }
+        for (const label of this.upPhasePlan) {
+            seenLabels.add(label);
+            const completedPhase = completedByLabel.get(label);
+            if (completedPhase) {
+                steps.push({
+                    label: this.renderUpStepLabel(label),
+                    status: completedPhase.status === "failure" ? "failed" : "done",
+                    detail: completedPhase.detail,
+                });
+                continue;
+            }
+            if (this.currentPhase?.label === label) {
+                steps.push({
+                    label: this.renderUpStepLabel(label),
+                    status: "active",
+                });
+                continue;
+            }
+            steps.push({
+                label: this.renderUpStepLabel(label),
+                status: "pending",
+            });
+        }
+        for (const phase of this.completed) {
+            if (!seenLabels.has(phase.label)) {
+                steps.push({
+                    label: this.renderUpStepLabel(phase.label),
+                    status: phase.status === "failure" ? "failed" : "done",
+                    detail: phase.detail,
+                });
+            }
+        }
+        if (this.currentPhase && !seenLabels.has(this.currentPhase.label)) {
+            steps.push({
+                label: this.renderUpStepLabel(this.currentPhase.label),
+                status: "active",
+            });
+        }
+        return (0, terminal_ui_1.renderTerminalOperation)({
+            isTTY: true,
+            columns: this.columns,
+            masthead: {
+                subtitle: "Booting the local agent runtime.",
+            },
+            title: "Starting Ouro",
+            summary: "Ouro is bringing the local agent runtime online and will stop here if anything needs attention.",
+            currentStep: {
+                label: currentStepLabel,
+                detailLines: currentStepDetails,
+            },
+            steps,
+            currentTitle: "Doing now",
+            stepsTitle: "Boot checklist",
+            suppressEvent: true,
+        }).trimEnd().split("\n");
+    }
+}
+exports.UpProgress = UpProgress;
+exports.CommandProgress = UpProgress;

package/dist/heart/daemon/vault-items.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PORKBUN_OPS_COMPATIBILITY_ALIAS = exports.PORKBUN_OPS_CREDENTIAL_PREFIX = void 0;
+exports.isVaultItemTemplate = isVaultItemTemplate;
+exports.normalizeVaultItemName = normalizeVaultItemName;
+exports.normalizeVaultItemFieldName = normalizeVaultItemFieldName;
+exports.vaultItemTemplateSecretFields = vaultItemTemplateSecretFields;
+exports.normalizePorkbunOpsAccount = normalizePorkbunOpsAccount;
+exports.porkbunOpsCredentialItemName = porkbunOpsCredentialItemName;
+exports.porkbunOpsAccountFromItemName = porkbunOpsAccountFromItemName;
+exports.requireVaultItemSecret = requireVaultItemSecret;
+exports.PORKBUN_OPS_CREDENTIAL_PREFIX = "ops/registrars/porkbun/accounts";
+exports.PORKBUN_OPS_COMPATIBILITY_ALIAS = "vault ops porkbun";
+const VAULT_ITEM_NAME_FORBIDDEN = /[\r\n\t]/;
+const VAULT_ITEM_FIELD_FORBIDDEN = /[\r\n\t=]/;
+const PORKBUN_OPS_ACCOUNT_FORBIDDEN = /[\/\r\n\t]/;
+function isVaultItemTemplate(value) {
+    return value === "porkbun-api";
+}
+function normalizeVaultItemName(item) {
+    const normalized = item?.trim() ?? "";
+    if (!normalized || VAULT_ITEM_NAME_FORBIDDEN.test(normalized) || normalized.startsWith("/") || normalized.endsWith("/")) {
+        throw new Error("Vault item name/path must be non-empty, relative, and free of control characters.");
+    }
+    return normalized;
+}
+function normalizeVaultItemFieldName(field) {
+    const normalized = field?.trim() ?? "";
+    if (!normalized || VAULT_ITEM_FIELD_FORBIDDEN.test(normalized)) {
+        throw new Error("Vault item field names must be non-empty and free of control characters or '='.");
+    }
+    return normalized;
+}
+function vaultItemTemplateSecretFields(_template) {
+    return ["apiKey", "secretApiKey"];
+}
+function normalizePorkbunOpsAccount(account) {
+    const normalized = account?.trim() ?? "";
+    if (!normalized || PORKBUN_OPS_ACCOUNT_FORBIDDEN.test(normalized)) {
+        throw new Error("Porkbun account must be a non-empty account label without slashes or control characters.");
+    }
+    return normalized;
+}
+function porkbunOpsCredentialItemName(account) {
+    return `${exports.PORKBUN_OPS_CREDENTIAL_PREFIX}/${normalizePorkbunOpsAccount(account)}`;
+}
+function porkbunOpsAccountFromItemName(itemName) {
+    const prefix = `${exports.PORKBUN_OPS_CREDENTIAL_PREFIX}/`;
+    return itemName.startsWith(prefix) ? itemName.slice(prefix.length) : undefined;
+}
+function requireVaultItemSecret(value, label) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(`${label} cannot be blank`);
+    return trimmed;
+}

package/dist/heart/delegation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideDelegation = decideDelegation;
+const runtime_1 = require("../nerves/runtime");
+const CROSS_SESSION_TOOLS = new Set(["query_session", "send_message", "bridge_manage"]);
+const FAST_PATH_TOOLS = new Set(["settle"]);
+const REFLECTION_PATTERN = /\b(think|reflect|ponder|surface|surfaces|surfaced|sit with|metaboli[sz]e)\b/i;
+const CROSS_SESSION_PATTERN = /\b(other chat|other session|across chats?|across sessions?|keep .* aligned|relay|carry .* across)\b/i;
+function hasExplicitReflection(ingressTexts) {
+    return ingressTexts.some((text) => REFLECTION_PATTERN.test(text));
+}
+function hasCrossSessionPressure(ingressTexts, requestedToolNames) {
+    if (requestedToolNames.some((name) => CROSS_SESSION_TOOLS.has(name))) {
+        return true;
+    }
+    return ingressTexts.some((text) => CROSS_SESSION_PATTERN.test(text));
+}
+function hasNonFastPathToolRequest(requestedToolNames) {
+    return requestedToolNames.some((name) => !FAST_PATH_TOOLS.has(name));
+}
+function decideDelegation(input) {
+    const requestedToolNames = (input.requestedToolNames ?? [])
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+    const reasons = [];
+    if (hasExplicitReflection(input.ingressTexts)) {
+        reasons.push("explicit_reflection");
+    }
+    if (hasCrossSessionPressure(input.ingressTexts, requestedToolNames)) {
+        reasons.push("cross_session");
+    }
+    if (input.activeWork.centerOfGravity === "shared-work" || input.activeWork.bridges.some((bridge) => bridge.lifecycle === "active")) {
+        reasons.push("bridge_state");
+    }
+    if (input.activeWork.taskPressure.liveTaskNames.length > 0) {
+        reasons.push("task_state");
+    }
+    if (hasNonFastPathToolRequest(requestedToolNames)) {
+        reasons.push("non_fast_path_tool");
+    }
+    if (input.mustResolveBeforeHandoff || input.activeWork.mustResolveBeforeHandoff) {
+        reasons.push("unresolved_obligation");
+    }
+    const target = reasons.length === 0 ? "fast-path" : "delegate-inward";
+    const decision = {
+        target,
+        reasons,
+        outwardClosureRequired: target === "delegate-inward" && input.channel !== "inner",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.delegation_decide",
+        message: "computed delegation hint",
+        meta: {
+            channel: input.channel,
+            target: decision.target,
+            reasons: decision.reasons,
+            outwardClosureRequired: decision.outwardClosureRequired,
+        },
+    });
+    return decision;
+}

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

@@ -0,0 +1,189 @@
+"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 habit_runtime_state_1 = require("./habit-runtime-state");
+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;
+        }
+        const legacyLastRun = typeof frontmatter.lastRun === "string" && frontmatter.lastRun !== "null"
+            ? frontmatter.lastRun
+            : typeof frontmatter.last_run === "string" && frontmatter.last_run !== "null"
+                ? frontmatter.last_run
+                : null;
+        // 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.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 === "lastRun" || key === "last_run")
+                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");
+        if (legacyLastRun) {
+            (0, habit_runtime_state_1.writeHabitLastRun)(bundleRoot, path.basename(slugName, ".md"), legacyLastRun);
+        }
+        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 },
+        });
+    }
+}