@ouro.bot/cli 0.1.0-alpha.51 → 0.1.0-alpha.511

package/dist/heart/daemon/skill-management-installer.js

@@ -0,0 +1,94 @@
+"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.ensureSkillManagement = ensureSkillManagement;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const SKILL_MANAGEMENT_URL = "https://raw.githubusercontent.com/ouroborosbot/ouroboros-skills/main/skills/skill-management/SKILL.md";
+async function ensureSkillManagement() {
+    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    if (!fs.existsSync(bundlesRoot))
+        return;
+    // Find all agent bundles
+    const entries = fs.readdirSync(bundlesRoot).filter(e => e.endsWith(".ouro"));
+    if (entries.length === 0)
+        return;
+    // Check if ANY bundle is missing the skill
+    const missing = entries.filter(e => {
+        const targetPath = path.join(bundlesRoot, e, "skills", "skill-management.md");
+        return !fs.existsSync(targetPath);
+    });
+    if (missing.length === 0)
+        return;
+    // eslint-disable-next-line no-console -- terminal UX: visible install status
+    console.log("installing skill-management from ouroboros-skills...");
+    try {
+        const response = await fetch(SKILL_MANAGEMENT_URL);
+        if (!response.ok) {
+            // eslint-disable-next-line no-console -- terminal UX: visible install status
+            console.error(`✗ failed to fetch skill-management (HTTP ${response.status})`);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.skill_management_install_error",
+                message: "failed to fetch skill-management from GitHub",
+                meta: { status: response.status, url: SKILL_MANAGEMENT_URL },
+            });
+            return;
+        }
+        const content = await response.text();
+        for (const bundle of missing) {
+            const skillsDir = path.join(bundlesRoot, bundle, "skills");
+            const targetPath = path.join(skillsDir, "skill-management.md");
+            fs.mkdirSync(skillsDir, { recursive: true });
+            fs.writeFileSync(targetPath, content, "utf-8");
+        }
+        // eslint-disable-next-line no-console -- terminal UX: visible install status
+        console.log(`✓ installed skill-management (${missing.length} agent${missing.length > 1 ? "s" : ""})`);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console -- terminal UX: visible install status
+        console.error(`✗ failed to install skill-management: ${error instanceof Error ? error.message : String(error)}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.skill_management_install_error",
+            message: "failed to install skill-management skill",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}

package/dist/heart/daemon/socket-client.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.__bypassVitestGuardForTests = __bypassVitestGuardForTests;
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
 exports.requestInnerWake = requestInnerWake;
@@ -41,7 +42,81 @@ const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const runtime_1 = require("../../nerves/runtime");
 exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+/**
+ * Defense-in-depth: detect if we're running under vitest. Tests that forget
+ * to `vi.mock("../../heart/daemon/socket-client")` would otherwise leak real
+ * `inner.wake` commands (with whatever literal agent name the test uses,
+ * commonly "testagent") into whichever real daemon happens to be running on
+ * the developer's machine. That has caused real outages when test loops
+ * flooded the production-on-localhost daemon.
+ *
+ * We detect vitest via `process.argv` (not env vars — the project bans those)
+ * and convert all socket operations into safe no-ops. Individual tests are
+ * still expected to vi.mock this module so they can assert on call counts,
+ * but this guard guarantees that "I forgot to mock" can never again take
+ * down the daemon.
+ *
+ * The socket-client's OWN tests (which exercise the real functions against a
+ * test socket) call `__bypassVitestGuardForTests(true)` to opt out of the
+ * guard. We persist that flag on globalThis so it survives `vi.resetModules`
+ * (which clears the module cache between tests).
+ *
+ * HARDENING (cross-file leak protection): the bypass flag lives on globalThis
+ * and is process-wide. With vitest's default `fileParallelism: true`,
+ * concurrently-running test files in the same worker can have the bypass on
+ * even though they didn't ask for it — and any test that uses
+ * `name: "testagent"` and exercises a code path through this module will
+ * leak `inner.wake testagent` to the production daemon socket. We saw this
+ * cause a real outage on 2026-04-08 (daemon SIGTERMed mid-validation).
+ *
+ * Defense: even when the bypass flag is set, we ALWAYS hard-block calls that
+ * target the production daemon socket path. Test files that legitimately
+ * exercise the real socket-client code paths use a synthetic socket path like
+ * `/tmp/daemon.sock` or `/tmp/some-real-daemon.sock` — those keep working.
+ * Calls to `/tmp/ouroboros-daemon.sock` (DEFAULT_DAEMON_SOCKET_PATH) under
+ * vitest are unconditionally blocked, regardless of bypass state. This makes
+ * the cross-file leak vector impossible without restricting legitimate
+ * socket-client unit tests.
+ */
+const BYPASS_KEY = "__ouro_socket_client_bypass_vitest_guard__";
+/** ONLY for socket-client.test.ts. Do not call from any other test or production code. */
+function __bypassVitestGuardForTests(bypass) {
+    ;
+    globalThis[BYPASS_KEY] = bypass;
+}
+function isVitestProcess() {
+    /* v8 ignore next -- defensive: process and process.argv always exist in node @preserve */
+    if (typeof process === "undefined" || !Array.isArray(process.argv))
+        return false;
+    return process.argv.some((arg) => typeof arg === "string" && arg.includes("vitest"));
+}
+function isProductionDaemonSocket(socketPath) {
+    return socketPath === exports.DEFAULT_DAEMON_SOCKET_PATH;
+}
+/**
+ * Returns true when this socket call should be converted into a safe no-op
+ * because we're under vitest and the call would otherwise leak into a real
+ * daemon. The bypass flag short-circuits the guard for non-production socket
+ * paths only — production socket paths are ALWAYS blocked under vitest.
+ */
+function shouldSuppressSocketCall(socketPath) {
+    if (!isVitestProcess())
+        return false;
+    if (isProductionDaemonSocket(socketPath))
+        return true;
+    return globalThis[BYPASS_KEY] !== true;
+}
 function sendDaemonCommand(socketPath, command) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.socket_command_test_blocked",
+            message: "blocked socket command from leaking into real daemon under vitest",
+            meta: { socketPath, kind: command.kind, isProductionSocket: isProductionDaemonSocket(socketPath) },
+        });
+        return Promise.resolve({ ok: true, message: "test mode: socket call suppressed" });
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_command_start",
@@ -52,8 +127,23 @@ function sendDaemonCommand(socketPath, command) {
         const client = net.createConnection(socketPath);
         let raw = "";
         client.on("connect", () => {
-            client.write(JSON.stringify(command));
-            client.end();
+            // Write the command + newline delimiter. DO NOT call client.end()
+            // afterwards — the server closes the connection once it has written
+            // its response, which triggers our on("end") handler with the full
+            // response in `raw`.
+            //
+            // Calling client.end() here half-closes the TCP connection. The
+            // daemon server uses net.createServer() with the default
+            // allowHalfOpen: false, so when the server sees the client's FIN it
+            // auto-closes its own writable side — and any response the server
+            // tries to write after processing a long-running command (like
+            // agent.senseTurn, which runs a full LLM turn) gets dropped on the
+            // floor. Verified via repro: with client.end(), agent.senseTurn
+            // returns empty in ~149ms; without it, the same call returns the real
+            // response in ~5.8s. This is a regression of the fix in #303 that
+            // was silently reverted by 253e4b1f (commit titled "socket half-close
+            // fix" but actually *added* the half-close back).
+            client.write(JSON.stringify(command) + "\n");
         });
         client.on("data", (chunk) => {
             raw += chunk.toString("utf-8");
@@ -132,6 +222,9 @@ function sendDaemonCommand(socketPath, command) {
     });
 }
 function checkDaemonSocketAlive(socketPath) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        return Promise.resolve(false);
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_alive_check_start",
@@ -161,8 +254,10 @@ function checkDaemonSocketAlive(socketPath) {
             });
         }
         client.on("connect", () => {
-            client.write(JSON.stringify({ kind: "daemon.status" }));
-            client.end();
+            // Same half-close rationale as sendDaemonCommand: do NOT call
+            // client.end() here. The server closes after responding and that
+            // triggers the on("end") handler below.
+            client.write(JSON.stringify({ kind: "daemon.status" }) + "\n");
         });
         client.on("data", (chunk) => {
             raw += chunk.toString("utf-8");
@@ -184,6 +279,16 @@ function checkDaemonSocketAlive(socketPath) {
     });
 }
 async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    if (shouldSuppressSocketCall(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.inner_wake_test_blocked",
+            message: "blocked inner wake from leaking into real daemon under vitest",
+            meta: { agent, socketPath, isProductionSocket: isProductionDaemonSocket(socketPath) },
+        });
+        return null;
+    }
     const socketAvailable = fs.existsSync(socketPath);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",

package/dist/heart/daemon/stale-bundle-prune.js

@@ -0,0 +1,96 @@
+"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.pruneStaleEphemeralBundles = pruneStaleEphemeralBundles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Scan the bundles root for `.ouro` directories that have no `agent.json`
+ * file (definitively dead ephemeral bundles) and delete them.
+ *
+ * Returns a list of pruned bundle directory names (e.g. `["stale.ouro"]`)
+ * for display purposes. Bundles that have `agent.json` -- even if disabled
+ * -- are never deleted. Errors on individual bundles are swallowed so that
+ * one permission-denied doesn't block pruning the rest.
+ */
+function pruneStaleEphemeralBundles(deps = {}) {
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readdirSync = deps.readdirSync ?? fs.readdirSync;
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    let entries;
+    try {
+        entries = readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const pruned = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const bundlePath = path.join(bundlesRoot, entry.name);
+        const agentJsonPath = path.join(bundlePath, "agent.json");
+        if (existsSync(agentJsonPath))
+            continue;
+        try {
+            rmSync(bundlePath, { recursive: true, force: true });
+            pruned.push(entry.name);
+            (0, runtime_1.emitNervesEvent)({
+                level: "info",
+                component: "daemon",
+                event: "daemon.stale_bundle_pruned",
+                message: `pruned stale ephemeral bundle: ${entry.name}`,
+                meta: { bundle: entry.name, bundlePath },
+            });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.stale_bundle_prune_error",
+                message: `failed to prune stale bundle: ${entry.name}`,
+                meta: {
+                    bundle: entry.name,
+                    bundlePath,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    return pruned;
+}

package/dist/heart/daemon/startup-tui.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * Startup TUI — real-time progress display for `ouro up`.
+ *
+ * Replaces the old `verifyDaemonAlive()` socket poll with a richer system
+ * that shows per-agent status, waits for stability, and reports degraded
+ * agents with actionable error information.
+ *
+ * Pure functions (`renderStartupProgress`, `assessStability`) are fully
+ * testable. The polling loop (`pollDaemonStartup`) uses dependency injection
+ * for all I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessStability = assessStability;
+exports.renderStartupProgress = renderStartupProgress;
+exports.renderWaitingForDaemon = renderWaitingForDaemon;
+exports.pollDaemonStartup = pollDaemonStartup;
+const cli_render_1 = require("./cli-render");
+const runtime_1 = require("../../nerves/runtime");
+const terminal_ui_1 = require("./terminal-ui");
+// ── Constants ──
+const SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+const STABILITY_THRESHOLD_MS = 5_000;
+const POLL_INTERVAL_MS = 500;
+// ── ANSI helpers ──
+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;231;76;60m";
+const YELLOW = "\x1b[38;2;230;190;50m";
+// ── Pure functions ──
+/**
+ * Assess whether all workers have reached a terminal state (stable or crashed).
+ * A worker is "stable" when status is "running" and it has been running for
+ * at least STABILITY_THRESHOLD_MS. A worker is "definitively failed" when
+ * status is "crashed". All other states are unresolved.
+ */
+function assessStability(payload, now) {
+    const stable = [];
+    const degraded = [];
+    let allResolved = true;
+    for (const worker of payload.workers) {
+        if (worker.status === "crashed") {
+            degraded.push({
+                agent: worker.agent,
+                errorReason: worker.errorReason ?? "unknown error",
+                fixHint: worker.fixHint ?? "check daemon logs",
+            });
+        }
+        else if (worker.status === "running" && worker.startedAt !== null) {
+            const startedMs = new Date(worker.startedAt).getTime();
+            const runningMs = now - startedMs;
+            if (runningMs >= STABILITY_THRESHOLD_MS) {
+                stable.push(worker.agent);
+            }
+            else {
+                allResolved = false;
+            }
+        }
+        else {
+            // starting, stopped, or running with null startedAt — not yet resolved
+            allResolved = false;
+        }
+    }
+    return { resolved: allResolved, stable, degraded };
+}
+/**
+ * Build an ANSI string for in-place terminal display during polling.
+ * Uses cursor-up and line-clear escapes to overwrite previous output.
+ */
+function renderStartupProgress(payload, elapsed, prevLineCount = 0, options = {}) {
+    const isTTY = options.isTTY ?? true;
+    const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const lines = [];
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    lines.push(isTTY
+        ? `${spinner} ${BOLD}waiting for agents${RESET} ${DIM}(${elapsedSec}s)${RESET}`
+        : `${spinner} waiting for agents (${elapsedSec}s)`);
+    for (const worker of payload.workers) {
+        const statusText = isTTY ? colorStatus(worker.status) : worker.status;
+        lines.push(`  ${worker.agent}/${worker.worker}: ${statusText}`);
+    }
+    return renderStartupLines(lines, prevLineCount, isTTY);
+}
+/**
+ * Render a pre-socket status line showing what the daemon is doing.
+ */
+function renderWaitingForDaemon(elapsed, latestEvent, prevLineCount = 0, options = {}) {
+    const isTTY = options.isTTY ?? true;
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const lines = [];
+    lines.push(isTTY
+        ? `${spinner} ${BOLD}starting background service${RESET} ${DIM}(${elapsedSec}s)${RESET}`
+        : `${spinner} starting background service (${elapsedSec}s)`);
+    if (latestEvent) {
+        const detail = `latest daemon event: ${latestEvent}`;
+        lines.push(isTTY ? `  ${DIM}${detail}${RESET}` : `  ${detail}`);
+    }
+    return renderStartupLines(lines, prevLineCount, isTTY);
+}
+/**
+ * Render the final summary after all agents have resolved.
+ */
+function renderFinalSummary(result, isTTY) {
+    const lines = [];
+    for (const agent of result.stable) {
+        lines.push(isTTY ? `  ${GREEN}\u2713${RESET} ${agent}: ${GREEN}stable${RESET}` : `  \u2713 ${agent}: stable`);
+    }
+    for (const d of result.degraded) {
+        lines.push(isTTY ? `  ${RED}\u2717${RESET} ${d.agent}: ${RED}degraded${RESET}` : `  \u2717 ${d.agent}: degraded`);
+        if (d.errorReason !== "unknown error") {
+            lines.push(isTTY ? `    ${DIM}error: ${d.errorReason}${RESET}` : `    error: ${d.errorReason}`);
+        }
+        if (d.fixHint !== "check daemon logs") {
+            lines.push(isTTY ? `    ${DIM}fix:   ${d.fixHint}${RESET}` : `    fix:   ${d.fixHint}`);
+        }
+    }
+    if (!isTTY)
+        return lines.join("\n") + "\n";
+    return lines.map((line) => `\x1b[2K${line}`).join("\n") + "\n";
+}
+// ── Polling loop ──
+/**
+ * Poll the daemon's status socket until all agents are stable or definitively
+ * failed, rendering real-time progress to the terminal.
+ *
+ * Detects daemon process death: if the spawned PID is no longer alive and the
+ * socket never came up, reports the failure immediately instead of spinning.
+ */
+async function pollDaemonStartup(deps) {
+    const startTime = deps.now();
+    let prevLineCount = 0;
+    const isTTY = deps.isTTY ?? true;
+    const isAlive = deps.isProcessAlive ?? defaultIsProcessAlive;
+    const shouldRender = deps.render ?? true;
+    let lastProgress = null;
+    const reportProgress = (message) => {
+        if (!deps.onProgress || message === lastProgress)
+            return;
+        lastProgress = message;
+        deps.onProgress(message);
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.startup_poll_start",
+        message: "beginning startup stability polling",
+        meta: { socketPath: deps.socketPath, daemonPid: deps.daemonPid },
+    });
+    while (true) {
+        const now = deps.now();
+        const elapsed = now - startTime;
+        let payload = null;
+        try {
+            const response = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
+            payload = (0, cli_render_1.parseStatusPayload)(response.data);
+        }
+        catch {
+            // Socket not yet available — check if the daemon process is still alive
+            if (deps.daemonPid !== null && !isAlive(deps.daemonPid)) {
+                const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+                const errorMsg = latestEvent ?? "daemon process died during startup";
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.startup_process_died",
+                    message: "daemon process died before socket came up",
+                    meta: { pid: deps.daemonPid, lastEvent: latestEvent },
+                });
+                // Clear the waiting line
+                if (isTTY && prevLineCount > 0) {
+                    let clear = `\x1b[${prevLineCount}A`;
+                    for (let i = 0; i < prevLineCount; i++)
+                        clear += `\x1b[2K\n`;
+                    deps.writeRaw(clear);
+                }
+                return {
+                    stable: [],
+                    degraded: [{ agent: "daemon", errorReason: errorMsg, fixHint: "check daemon logs or run `ouro doctor`" }],
+                };
+            }
+            // Show what the daemon is doing from its log
+            const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+            reportProgress([
+                "waiting for Ouro to answer",
+                latestEvent ? `- latest daemon event: ${latestEvent}` : "- background service is still starting",
+            ].join("\n"));
+            if (shouldRender) {
+                const output = renderWaitingForDaemon(elapsed, latestEvent, prevLineCount, { isTTY });
+                deps.writeRaw(output);
+                prevLineCount = latestEvent ? 2 : 1;
+            }
+        }
+        if (payload) {
+            reportProgress(formatStartupProgressDetail(payload));
+            if (shouldRender) {
+                const output = renderStartupProgress(payload, elapsed, prevLineCount, { isTTY });
+                deps.writeRaw(output);
+                prevLineCount = payload.workers.length + 1;
+            }
+            const assessment = assessStability(payload, now);
+            if (assessment.resolved) {
+                const result = {
+                    stable: assessment.stable,
+                    degraded: assessment.degraded,
+                };
+                if (shouldRender) {
+                    const summary = renderFinalSummary(result, isTTY);
+                    deps.writeRaw(summary);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.startup_poll_end",
+                    message: "startup polling complete",
+                    meta: {
+                        stableCount: result.stable.length,
+                        degradedCount: result.degraded.length,
+                        elapsedMs: elapsed,
+                    },
+                });
+                return result;
+            }
+        }
+        await deps.sleep(POLL_INTERVAL_MS);
+    }
+}
+function formatStartupWorkerLine(payload) {
+    const base = `- ${payload.agent}/${payload.worker}: ${payload.status}`;
+    if (payload.status === "crashed" && payload.errorReason) {
+        return `${base} (${payload.errorReason})`;
+    }
+    return base;
+}
+function formatStartupProgressDetail(payload) {
+    if (payload.workers.length === 0)
+        return "Ouro answered";
+    return [
+        "Ouro answered",
+        ...payload.workers.map((worker) => formatStartupWorkerLine(worker)),
+    ].join("\n");
+}
+function colorStatus(status) {
+    const statusColor = status === "running" ? GREEN
+        : status === "crashed" ? RED
+            : YELLOW;
+    return `${statusColor}${status}${RESET}`;
+}
+function renderStartupLines(lines, prevLineCount, isTTY) {
+    return (0, terminal_ui_1.renderOverwriteFrame)(lines, prevLineCount, isTTY);
+}
+/* v8 ignore start -- process liveness check: uses real process.kill(0), tested via deployment @preserve */
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/* v8 ignore stop */

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

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const parser_1 = require("../../repertoire/tasks/parser");
+const cadence_1 = require("./cadence");
 function walkMarkdownFiles(root, readdirSync, existsSync, files) {
     if (!existsSync(root))
         return;
@@ -53,29 +54,6 @@ function walkMarkdownFiles(root, readdirSync, existsSync, files) {
         }
     }
 }
-function parseCadence(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;
-    const unit = cadenceMatch[2];
-    if (unit === "m")
-        return `*/${interval} * * * *`;
-    if (unit === "h")
-        return `0 */${interval} * * *`;
-    return `0 0 */${interval} * *`;
-}
 function parseScheduledAt(raw) {
     if (typeof raw !== "string")
         return null;
@@ -140,7 +118,7 @@ class TaskDrivenScheduler {
         const nextTaskPaths = new Map();
         for (const agent of this.agents) {
             const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
-            const collections = ["one-shots", "ongoing", "habits"];
+            const collections = ["one-shots", "ongoing"];
             const files = [];
             for (const collection of collections) {
                 walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
@@ -157,7 +135,7 @@ class TaskDrivenScheduler {
                 nextTaskPaths.set(`${agent}:${taskId}`, filePath);
                 if (task.status === "done")
                     continue;
-                const cadence = parseCadence(task.frontmatter.cadence);
+                const cadence = (0, cadence_1.parseCadenceToCron)(task.frontmatter.cadence);
                 if (cadence) {
                     const id = `${agent}:${taskId}:cadence`;
                     nextJobs.set(id, {