@ouro.bot/cli 0.1.0-alpha.53 → 0.1.0-alpha.531

package/dist/heart/daemon/cli-render.js

@@ -0,0 +1,728 @@
+"use strict";
+/**
+ * CLI output formatting and rendering helpers.
+ *
+ * Pure functions that transform data into human-readable CLI output.
+ * No side effects — callers handle writing to stdout.
+ */
+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.parseStatusPayload = parseStatusPayload;
+exports.humanizeSenseName = humanizeSenseName;
+exports.formatTable = formatTable;
+exports.formatDaemonStatusOutput = formatDaemonStatusOutput;
+exports.formatVersionOutput = formatVersionOutput;
+exports.buildStoppedStatusPayload = buildStoppedStatusPayload;
+exports.renderRollupStatusLine = renderRollupStatusLine;
+exports.daemonUnavailableStatusOutput = daemonUnavailableStatusOutput;
+exports.isDaemonUnavailableError = isDaemonUnavailableError;
+exports.formatMcpResponse = formatMcpResponse;
+const path = __importStar(require("path"));
+const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_mode_1 = require("./runtime-mode");
+const identity_1 = require("../identity");
+const daemon_tombstone_1 = require("./daemon-tombstone");
+const daemon_health_1 = require("./daemon-health");
+const agent_discovery_1 = require("./agent-discovery");
+// ── Field extractors ──
+function stringField(value) {
+    return typeof value === "string" ? value : null;
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function formatDurationMs(ms) {
+    if (ms < 1_000)
+        return `${Math.round(ms)}ms`;
+    if (ms < 60_000)
+        return `${Math.round(ms / 1_000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    if (ms < 86_400_000)
+        return `${Math.round(ms / 3_600_000)}h`;
+    return `${Math.round(ms / 86_400_000)}d`;
+}
+function formatSenseDetail(row) {
+    const details = [row.detail];
+    const proofParts = [];
+    if (row.proofMethod)
+        proofParts.push(`proof=${row.proofMethod}`);
+    if (row.lastProofAt)
+        proofParts.push(`lastProof=${row.lastProofAt}`);
+    if (row.proofAgeMs !== undefined)
+        proofParts.push(`proofAge=${formatDurationMs(row.proofAgeMs)}`);
+    if (proofParts.length > 0)
+        details.push(proofParts.join(" "));
+    const recoveryParts = [];
+    if (row.pendingRecoveryCount !== undefined)
+        recoveryParts.push(`pendingRecovery=${row.pendingRecoveryCount}`);
+    if (row.failedRecoveryCount !== undefined)
+        recoveryParts.push(`failedRecovery=${row.failedRecoveryCount}`);
+    if (row.oldestPendingRecoveryAt)
+        recoveryParts.push(`oldestPending=${row.oldestPendingRecoveryAt}`);
+    if (row.oldestPendingRecoveryAgeMs !== undefined)
+        recoveryParts.push(`oldestPendingAge=${formatDurationMs(row.oldestPendingRecoveryAgeMs)}`);
+    if (recoveryParts.length > 0)
+        details.push(recoveryParts.join(" "));
+    const failureParts = [];
+    if (row.failureLayer)
+        failureParts.push(`failureLayer=${row.failureLayer}`);
+    if (row.lastFailure)
+        failureParts.push(`lastFailure=${row.lastFailure}`);
+    if (row.recoveryAction)
+        failureParts.push(`recovery=${row.recoveryAction}`);
+    if (failureParts.length > 0)
+        details.push(failureParts.join(" "));
+    return details.filter(Boolean).join("; ");
+}
+// ── Parsers ──
+function parseStatusPayload(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    const raw = data;
+    const overview = raw.overview;
+    const senses = raw.senses;
+    const workers = raw.workers;
+    const sync = raw.sync;
+    const agents = raw.agents;
+    const providers = raw.providers;
+    if (!overview || typeof overview !== "object" || Array.isArray(overview))
+        return null;
+    if (!Array.isArray(senses) || !Array.isArray(workers))
+        return null;
+    // sync, agents, and providers are optional for backward compatibility — older daemons may omit them
+    if (sync !== undefined && !Array.isArray(sync))
+        return null;
+    if (agents !== undefined && !Array.isArray(agents))
+        return null;
+    if (providers !== undefined && !Array.isArray(providers))
+        return null;
+    const parsedOverview = {
+        daemon: stringField(overview.daemon) ?? "unknown",
+        health: stringField(overview.health) ?? "unknown",
+        socketPath: stringField(overview.socketPath) ?? "unknown",
+        mailboxUrl: stringField(overview.mailboxUrl)
+            ?? stringField(overview.outlookUrl)
+            ?? "unavailable",
+        outlookUrl: stringField(overview.outlookUrl) ?? undefined,
+        version: stringField(overview.version) ?? "unknown",
+        lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
+        repoRoot: stringField(overview.repoRoot) ?? "unknown",
+        configFingerprint: stringField(overview.configFingerprint) ?? "unknown",
+        workerCount: numberField(overview.workerCount) ?? 0,
+        senseCount: numberField(overview.senseCount) ?? 0,
+        entryPath: stringField(overview.entryPath) ?? "unknown",
+        mode: stringField(overview.mode) ?? "unknown",
+    };
+    const parsedSenses = senses.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const sense = stringField(row.sense);
+        const status = stringField(row.status);
+        const detail = stringField(row.detail);
+        const enabled = booleanField(row.enabled);
+        if (!agent || !sense || !status || detail === null || enabled === null)
+            return null;
+        const parsed = {
+            agent,
+            sense,
+            label: stringField(row.label) ?? undefined,
+            enabled,
+            status,
+            detail,
+        };
+        const proofMethod = stringField(row.proofMethod);
+        const lastProofAt = stringField(row.lastProofAt);
+        const proofAgeMs = numberField(row.proofAgeMs);
+        const lastFailure = stringField(row.lastFailure);
+        const failureLayer = stringField(row.failureLayer);
+        const recoveryAction = stringField(row.recoveryAction);
+        const pendingRecoveryCount = numberField(row.pendingRecoveryCount);
+        const failedRecoveryCount = numberField(row.failedRecoveryCount);
+        const oldestPendingRecoveryAt = stringField(row.oldestPendingRecoveryAt);
+        const oldestPendingRecoveryAgeMs = numberField(row.oldestPendingRecoveryAgeMs);
+        if (proofMethod !== null)
+            parsed.proofMethod = proofMethod;
+        if (lastProofAt !== null)
+            parsed.lastProofAt = lastProofAt;
+        if (proofAgeMs !== null)
+            parsed.proofAgeMs = proofAgeMs;
+        if (lastFailure !== null)
+            parsed.lastFailure = lastFailure;
+        if (failureLayer !== null)
+            parsed.failureLayer = failureLayer;
+        if (recoveryAction !== null)
+            parsed.recoveryAction = recoveryAction;
+        if (pendingRecoveryCount !== null)
+            parsed.pendingRecoveryCount = pendingRecoveryCount;
+        if (failedRecoveryCount !== null)
+            parsed.failedRecoveryCount = failedRecoveryCount;
+        if (oldestPendingRecoveryAt !== null)
+            parsed.oldestPendingRecoveryAt = oldestPendingRecoveryAt;
+        if (oldestPendingRecoveryAgeMs !== null)
+            parsed.oldestPendingRecoveryAgeMs = oldestPendingRecoveryAgeMs;
+        return parsed;
+    });
+    const parsedWorkers = workers.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const worker = stringField(row.worker);
+        const status = stringField(row.status);
+        const restartCount = numberField(row.restartCount);
+        const hasPid = Object.prototype.hasOwnProperty.call(row, "pid");
+        const pid = row.pid === null ? null : numberField(row.pid);
+        const pidInvalid = !hasPid || (row.pid !== null && pid === null);
+        if (!agent || !worker || !status || restartCount === null || pidInvalid)
+            return null;
+        return {
+            agent,
+            worker,
+            status,
+            pid,
+            restartCount,
+            lastExitCode: numberField(row.lastExitCode) ?? null,
+            lastSignal: stringField(row.lastSignal) ?? null,
+            startedAt: stringField(row.startedAt) ?? null,
+            errorReason: stringField(row.errorReason) ?? null,
+            fixHint: stringField(row.fixHint) ?? null,
+        };
+    });
+    const parsedSync = (sync ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const enabled = booleanField(row.enabled);
+        const remote = stringField(row.remote);
+        if (!agent || enabled === null || !remote)
+            return null;
+        const parsed = { agent, enabled, remote };
+        const remoteUrl = stringField(row.remoteUrl);
+        if (remoteUrl !== null)
+            parsed.remoteUrl = remoteUrl;
+        const gitInitialized = booleanField(row.gitInitialized);
+        if (gitInitialized !== null)
+            parsed.gitInitialized = gitInitialized;
+        return parsed;
+    });
+    const parsedAgents = (agents ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const name = stringField(row.name);
+        const enabled = booleanField(row.enabled);
+        if (!name || enabled === null)
+            return null;
+        return { name, enabled };
+    });
+    const parsedProviders = (providers ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const lane = stringField(row.lane);
+        const provider = stringField(row.provider);
+        const model = stringField(row.model);
+        const source = stringField(row.source);
+        const readiness = stringField(row.readiness);
+        const credential = stringField(row.credential);
+        if (!agent || !lane || !provider || !model || !source || !readiness || !credential)
+            return null;
+        const parsed = {
+            agent,
+            lane,
+            provider,
+            model,
+            source,
+            readiness,
+            credential,
+        };
+        const detail = stringField(row.detail);
+        if (detail !== null)
+            parsed.detail = detail;
+        return parsed;
+    });
+    if (parsedSenses.some((row) => row === null) ||
+        parsedWorkers.some((row) => row === null) ||
+        parsedSync.some((row) => row === null) ||
+        parsedAgents.some((row) => row === null) ||
+        parsedProviders.some((row) => row === null))
+        return null;
+    return {
+        overview: parsedOverview,
+        senses: parsedSenses,
+        workers: parsedWorkers,
+        sync: parsedSync,
+        agents: parsedAgents,
+        providers: parsedProviders,
+    };
+}
+// ── ANSI color helpers (private) ──
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const TEAL = "\x1b[38;2;78;201;176m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const RED = "\x1b[38;2;231;76;60m";
+const YELLOW = "\x1b[38;2;230;190;50m";
+/* v8 ignore start -- cosmetic ANSI wrappers @preserve */
+function teal(text) { return `${TEAL}${text}${RESET}`; }
+function green(text) { return `${GREEN}${text}${RESET}`; }
+function red(text) { return `${RED}${text}${RESET}`; }
+function yellow(text) { return `${YELLOW}${text}${RESET}`; }
+function bold(text) { return `${BOLD}${text}${RESET}`; }
+function dim(text) { return `${DIM}${text}${RESET}`; }
+/* v8 ignore stop */
+/* v8 ignore start -- cosmetic display: status dot color mapping tested visually @preserve */
+function statusDot(status) {
+    switch (status) {
+        case "running":
+        case "ok":
+        case "interactive":
+        case "enabled":
+        case "ready":
+            return green("●");
+        case "crashed":
+        case "warn":
+        case "error":
+        case "failed":
+            return red("●");
+        case "needs_config":
+        case "not_attached":
+        case "stale":
+            return yellow("●");
+        case "disabled":
+        case "stopped":
+            return dim("○");
+        default:
+            return dim("●");
+    }
+}
+/* v8 ignore stop */
+// ── Formatters ──
+function humanizeSenseName(sense, label) {
+    if (label)
+        return label;
+    if (sense === "cli")
+        return "CLI";
+    if (sense === "bluebubbles")
+        return "BlueBubbles";
+    if (sense === "teams")
+        return "Teams";
+    return sense;
+}
+/* v8 ignore start -- utility formatter; retained for non-status table output @preserve */
+function formatTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
+    const renderRow = (row) => `| ${row.map((cell, index) => (index === row.length - 1
+        ? cell
+        : cell.padEnd(widths[index]))).join(" | ")} |`;
+    const divider = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
+    return [
+        renderRow(headers),
+        divider,
+        ...rows.map(renderRow),
+    ].join("\n");
+}
+/* v8 ignore stop */
+function formatDaemonStatusOutput(response, fallback) {
+    const payload = parseStatusPayload(response.data);
+    if (!payload)
+        return fallback;
+    const ov = payload.overview;
+    const lines = [];
+    // ── Header banner ──
+    const modeTag = ov.mode === "dev" ? "dev" : "";
+    const daemonStatus = ov.daemon === "running" ? green("●") + "  " + bold("running") : red("●") + "  " + bold(ov.daemon);
+    const modeStr = modeTag ? `  ${dim(`(${modeTag})`)}` : "";
+    const bannerContent = `  ${bold(ov.version)}  ${daemonStatus}${modeStr}  `;
+    // Measure raw content width (strip ANSI for width calc)
+    const rawBanner = bannerContent.replace(/\x1b\[[0-9;]*m/g, "");
+    const bannerWidth = Math.max(rawBanner.length, 42);
+    const titleLabel = " ouroboros daemon ";
+    const topRightPad = Math.max(0, bannerWidth - titleLabel.length - 2);
+    lines.push(`  ${teal("╭─")}${teal(titleLabel)}${teal("─".repeat(topRightPad))}${teal("╮")}`);
+    lines.push(`  ${teal("│")}${bannerContent}${" ".repeat(Math.max(0, bannerWidth - rawBanner.length))}${teal("│")}`);
+    lines.push(`  ${teal("╰")}${teal("─".repeat(bannerWidth))}${teal("╯")}`);
+    lines.push("");
+    // ── Key-value overview ──
+    const kvLine = (label, value) => `  ${teal(label.padEnd(11))} ${value}`;
+    lines.push(kvLine("Socket", ov.socketPath));
+    lines.push(kvLine("Mailbox", ov.mailboxUrl));
+    lines.push(kvLine("Health", `${statusDot(ov.health)} ${ov.health}`));
+    lines.push(kvLine("Updated", ov.lastUpdated));
+    lines.push("");
+    // ── Agents ──
+    // Every discovered bundle, including disabled ones. The Senses/Workers/
+    // Git Sync sections below only show enabled bundles, so without this
+    // section disabled agents would be invisible in `ouro status`.
+    if (payload.agents.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Agents")} ${teal("─".repeat(37))}`);
+        const agentNameWidth = Math.max(12, ...payload.agents.map((r) => r.name.length));
+        for (const row of payload.agents) {
+            const name = row.name.padEnd(agentNameWidth);
+            const dot = row.enabled ? green("●") : dim("○");
+            const stateText = row.enabled ? "enabled " : "disabled";
+            lines.push(`    ${name} ${dot} ${stateText}`);
+        }
+        lines.push("");
+    }
+    // ── Providers ──
+    if (payload.providers.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Providers")} ${teal("─".repeat(34))}`);
+        const agentLaneWidth = Math.max(16, ...payload.providers.map((r) => `${r.agent} ${r.lane}`.length));
+        for (const row of payload.providers) {
+            const agentLane = `${row.agent} ${row.lane}`.padEnd(agentLaneWidth);
+            const model = `${row.provider} / ${row.model}`;
+            const detail = [row.readiness, row.detail, row.source, row.credential].filter(Boolean).join("; ");
+            lines.push(`    ${agentLane} ${statusDot(row.readiness)} ${model}  ${dim(detail)}`);
+        }
+        lines.push("");
+    }
+    // ── Senses ──
+    if (payload.senses.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Senses")} ${teal("─".repeat(37))}`);
+        // Group senses by agent
+        const sensesByAgent = new Map();
+        for (const row of payload.senses) {
+            const list = sensesByAgent.get(row.agent) ?? [];
+            list.push(row);
+            sensesByAgent.set(row.agent, list);
+        }
+        // Calculate column widths for alignment
+        const allSenseNames = payload.senses.map((r) => humanizeSenseName(r.sense, r.label));
+        const nameWidth = Math.max(12, ...allSenseNames.map((n) => n.length));
+        const allStatuses = payload.senses.map((r) => r.status);
+        const statusWidth = Math.max(10, ...allStatuses.map((s) => s.length));
+        for (const [agent, rows] of sensesByAgent) {
+            lines.push(`  ${bold(agent)}`);
+            for (const row of rows) {
+                const name = humanizeSenseName(row.sense, row.label).padEnd(nameWidth);
+                const dot = row.enabled ? statusDot(row.status) : dim("○");
+                const statusText = (row.enabled ? row.status : "disabled").padEnd(statusWidth);
+                lines.push(`    ${name} ${dot} ${statusText}  ${dim(formatSenseDetail(row))}`);
+            }
+        }
+        lines.push("");
+    }
+    // ── Workers ──
+    if (payload.workers.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Workers")} ${teal("─".repeat(36))}`);
+        // Group workers by agent
+        const workersByAgent = new Map();
+        for (const row of payload.workers) {
+            const list = workersByAgent.get(row.agent) ?? [];
+            list.push(row);
+            workersByAgent.set(row.agent, list);
+        }
+        const allWorkerNames = payload.workers.map((r) => r.worker);
+        const workerNameWidth = Math.max(12, ...allWorkerNames.map((n) => n.length));
+        for (const [agent, rows] of workersByAgent) {
+            lines.push(`  ${bold(agent)}`);
+            for (const row of rows) {
+                const name = row.worker.padEnd(workerNameWidth);
+                const dot = statusDot(row.status);
+                const pidStr = row.pid !== null ? `pid ${row.pid}` : "";
+                const restartStr = `restarts: ${row.restartCount}`;
+                /* v8 ignore start — exit info branches tested via daemon-crash-context; v8 misreports conditional chains @preserve */
+                let exitStr = "";
+                if (row.lastExitCode !== null)
+                    exitStr = `exit=${row.lastExitCode}`;
+                if (row.lastSignal !== null)
+                    exitStr = row.lastExitCode !== null ? `exit=${row.lastExitCode} sig=${row.lastSignal}` : `sig=${row.lastSignal}`;
+                /* v8 ignore stop */
+                const details = [pidStr, restartStr, exitStr].filter(Boolean).join("  ");
+                lines.push(`    ${name} ${dot} ${row.status.padEnd(10)}  ${dim(details)}`);
+                if (row.errorReason) {
+                    lines.push(`      ${dim(`error: ${row.errorReason}`)}`);
+                }
+                if (row.fixHint) {
+                    lines.push(`      ${dim(`fix:   ${row.fixHint}`)}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    // ── Git Sync (per agent) ──
+    if (payload.sync.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Git Sync")} ${teal("─".repeat(35))}`);
+        const agentNameWidth = Math.max(12, ...payload.sync.map((r) => r.agent.length));
+        for (const row of payload.sync) {
+            const name = row.agent.padEnd(agentNameWidth);
+            // Three states for enabled rows: error (not a repo), ok (remote URL), ok (local only).
+            // Disabled rows show the usual dim dot + "disabled".
+            let dot;
+            let stateText;
+            let detail;
+            if (!row.enabled) {
+                dot = dim("○");
+                stateText = "disabled".padEnd(10);
+                detail = "";
+            }
+            else if (row.gitInitialized === false) {
+                dot = red("●");
+                stateText = "error   ".padEnd(10);
+                detail = "not a git repo — run `git init` to enable sync";
+            }
+            else if (row.remoteUrl !== undefined) {
+                dot = green("●");
+                stateText = "enabled ".padEnd(10);
+                detail = `${row.remote} → ${row.remoteUrl}`;
+            }
+            else {
+                dot = green("●");
+                stateText = "enabled ".padEnd(10);
+                detail = "local only";
+            }
+            lines.push(`    ${name} ${dot} ${stateText}  ${dim(detail)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatVersionOutput() {
+    const version = (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const mode = (0, runtime_mode_1.detectRuntimeMode)((0, identity_1.getRepoRoot)());
+    /* v8 ignore start — cosmetic display toggle; dev mode always true in test env */
+    return mode === "dev" ? `${version} (dev)` : version;
+    /* v8 ignore stop */
+}
+function buildStoppedStatusPayload(socketPath, syncRows = [], agentRows = []) {
+    const metadata = (0, runtime_metadata_1.getRuntimeMetadata)();
+    const repoRoot = (0, identity_1.getRepoRoot)();
+    return {
+        overview: {
+            daemon: "stopped",
+            health: "warn",
+            socketPath,
+            mailboxUrl: "unavailable",
+            outlookUrl: "unavailable",
+            version: metadata.version,
+            lastUpdated: metadata.lastUpdated,
+            repoRoot: metadata.repoRoot,
+            configFingerprint: metadata.configFingerprint,
+            workerCount: 0,
+            senseCount: 0,
+            entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+            mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
+        },
+        senses: [],
+        workers: [],
+        sync: syncRows,
+        agents: agentRows,
+        providers: [],
+    };
+}
+/**
+ * Render the cached daemon-rollup status as a one-line string for the
+ * "daemon not running" view. Each `DaemonStatus` literal maps to a
+ * label + a brief explanatory copy fragment. The default branch is
+ * `never`-typed so future widening of `DaemonStatus` compile-errors
+ * here — Layer 1's compiler-forced exhaustiveness contract.
+ *
+ * The `degraded` literal splits into two copy variants based on the
+ * cached health file's `agents` map:
+ * - empty map → "no agents configured" (fresh-install copy).
+ * - non-empty map → "none ready" (all-agents-failed-live-check copy).
+ *
+ * The split lives at the render layer (not in the rollup status itself)
+ * so the same status can carry distinct UX copy without inflating the
+ * type union.
+ */
+function renderRollupStatusLine(health) {
+    const status = health.status;
+    const tail = `(pid ${health.pid}, uptime ${health.uptimeSeconds}s)`;
+    /* v8 ignore next -- v8 instruments the switch statement itself as a branch; the never-typed default below is unreachable by construction so v8 cannot observe its branch firing @preserve */
+    switch (status) {
+        case "healthy":
+            return `Last known status: healthy ${tail}`;
+        case "partial": {
+            // `partial` arises from two independent sources:
+            //   (a) some enabled agents not in `running` state, or
+            //   (b) Layer-4 drift between agent.json (intent) and state/providers.json (observed).
+            // Either or both can be true. Render mentions both when applicable so
+            // the operator isn't misled into thinking agents are unhealthy when the
+            // only anomaly is configuration drift.
+            const unhealthyCount = Object.values(health.agents).filter((agent) => agent.status !== "running").length;
+            const driftCount = (health.drift ?? []).length;
+            const parts = [];
+            if (unhealthyCount > 0) {
+                parts.push(`${unhealthyCount} agent${unhealthyCount === 1 ? "" : "s"} unhealthy`);
+            }
+            if (driftCount > 0) {
+                parts.push(`drift on ${driftCount} agent${driftCount === 1 ? "" : "s"}`);
+            }
+            // Fallback for legacy cached files: status="partial" with no
+            // visible cause (no unhealthy agents AND no drift array). This
+            // happens when the file pre-dates Layer 4 and the daemon flagged
+            // partial via some signal that's no longer expressible. Prompt
+            // refresh via `ouro up` rather than asserting a specific cause.
+            const detail = parts.length > 0
+                ? ` — ${parts.join("; ")}`
+                : " — stale cache, run `ouro up` to refresh";
+            return `Last known status: partial${detail} ${tail}`;
+        }
+        case "degraded": {
+            // Three-way copy split based on the cached agents map:
+            // - empty map → fresh install / no agents configured.
+            // - non-empty + any agent reports "running" → legacy stale cache:
+            //   pre-Layer-1, status="degraded" meant "any sick component," so a
+            //   running agent could coexist with a degraded daemon. Post-Layer-1,
+            //   degraded means "zero serving" — mutually exclusive with a running
+            //   agent. A live disagreement therefore implies the cache pre-dates
+            //   the rollup-semantics fix; prompt for `ouro up` to refresh rather
+            //   than falsely claim "none ready."
+            // - non-empty + zero agents reporting "running" → all-failed copy.
+            const agentEntries = Object.values(health.agents);
+            if (agentEntries.length === 0) {
+                return `Last known status: degraded — no agents configured (run \`ouro hatch\` to add one) ${tail}`;
+            }
+            const anyRunning = agentEntries.some((agent) => agent.status === "running");
+            if (anyRunning) {
+                return `Last known status: degraded — stale cache, run \`ouro up\` to refresh ${tail}`;
+            }
+            return `Last known status: degraded — agents configured but none ready (run \`ouro doctor\`) ${tail}`;
+        }
+        case "safe-mode":
+            return `Last known status: safe-mode — crash loop tripped ${tail}`;
+        case "down":
+            return `Last known status: down ${tail}`;
+        /* v8 ignore start -- compiler-forced exhaustiveness: the never-typed default branch is unreachable by construction; if DaemonStatus widens, tsc errors at the assignment before the throw can run @preserve */
+        default: {
+            // Compiler-forced exhaustiveness. If DaemonStatus grows a new
+            // literal, this `never` cast errors at tsc, forcing every
+            // consumer to handle it explicitly. NEVER replace this with a
+            // permissive `default:` returning a fallback string — that's
+            // exactly how the old "ok | degraded" semantics leaked through.
+            const _exhaustive = status;
+            throw new Error(`unhandled daemon status: ${_exhaustive}`);
+        }
+        /* v8 ignore stop */
+    }
+}
+function daemonUnavailableStatusOutput(socketPath, healthFilePath) {
+    // Read per-agent sync config and bundle list from disk so the user still
+    // sees them when the daemon is down. Best-effort: any fs error returns []
+    // and the corresponding section is omitted.
+    let syncRows = [];
+    let agentRows = [];
+    try {
+        syncRows = (0, agent_discovery_1.listBundleSyncRows)();
+    }
+    catch {
+        // listBundleSyncRows already swallows fs errors internally; this catch is a defensive
+        // safety net for environments where the fs module itself is partially mocked.
+    }
+    try {
+        agentRows = (0, agent_discovery_1.listAllBundleAgents)();
+    }
+    catch {
+        // Same defensive safety net for the bundle list.
+    }
+    /* v8 ignore start — tombstone read tested in daemon-status-tombstone.test; branch misreported @preserve */
+    const tombstone = (0, daemon_tombstone_1.readDaemonTombstone)();
+    const deathLine = tombstone
+        ? `Last death: ${tombstone.timestamp} -- ${tombstone.reason}: ${tombstone.message}`
+        : null;
+    /* v8 ignore stop */
+    const lines = [
+        formatDaemonStatusOutput({
+            ok: true,
+            summary: "daemon not running",
+            data: buildStoppedStatusPayload(socketPath, syncRows, agentRows),
+        }, "daemon not running"),
+        "",
+    ];
+    /* v8 ignore start — tombstone presence requires real daemon crash @preserve */
+    if (deathLine) {
+        lines.push(deathLine);
+        lines.push("");
+        /* v8 ignore stop */
+    }
+    // Read health file for last-known state (best-effort)
+    const resolvedHealthPath = healthFilePath ?? (0, daemon_health_1.getDefaultHealthPath)();
+    const health = (0, daemon_health_1.readHealth)(resolvedHealthPath);
+    if (health) {
+        lines.push(renderRollupStatusLine(health));
+        if (health.safeMode?.active) {
+            lines.push(`SAFE MODE: ${health.safeMode.reason}`);
+        }
+        if (health.degraded.length > 0) {
+            lines.push("");
+            lines.push("Degraded:");
+            for (const d of health.degraded) {
+                lines.push(`  ${d.component}: ${d.reason} (since ${d.since})`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("daemon not running; run `ouro up`");
+    return lines.join("\n");
+}
+function isDaemonUnavailableError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    return code === "ENOENT" || code === "ECONNREFUSED";
+}
+function formatMcpResponse(command, response) {
+    if (command.kind === "mcp.list") {
+        const allTools = response.data;
+        if (!allTools || allTools.length === 0) {
+            return response.message ?? "no tools available from connected MCP servers";
+        }
+        const lines = [];
+        for (const entry of allTools) {
+            lines.push(`[${entry.server}]`);
+            for (const tool of entry.tools) {
+                lines.push(`  ${tool.name}: ${tool.description}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // mcp.call
+    const result = response.data;
+    if (!result) {
+        return response.message ?? "no result";
+    }
+    return result.content.map((c) => c.text).join("\n");
+}