@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.561

package/dist/heart/daemon/thoughts.js

@@ -37,15 +37,18 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSurfacedValue = formatSurfacedValue;
 exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.deriveInnerJob = deriveInnerJob;
 exports.formatInnerDialogStatus = formatInnerDialogStatus;
 exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
 exports.parseInnerDialogSession = parseInnerDialogSession;
 exports.formatThoughtTurns = formatThoughtTurns;
 exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
 exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.readInnerDialogRawData = readInnerDialogRawData;
 exports.followThoughts = followThoughts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function contentToText(content) {
     if (typeof content === "string")
@@ -91,7 +94,7 @@ function extractToolNames(messages) {
         if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
             for (const tc of msg.tool_calls) {
                 const toolFunction = extractToolFunction(tc);
-                if (toolFunction?.name && toolFunction.name !== "final_answer")
+                if (toolFunction?.name && toolFunction.name !== "settle")
                     names.push(toolFunction.name);
             }
         }
@@ -149,6 +152,21 @@ function formatSurfacedValue(text, maxLength = 120) {
         return `"${firstLine}"`;
     return `"${firstLine.slice(0, maxLength - 3)}..."`;
 }
+function extractEnrichedFields(pendingMessages) {
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    if (!delegated?.delegatedFrom)
+        return {};
+    const snippet = delegated.content.length > 80 ? delegated.content.slice(0, 77) + "..." : delegated.content;
+    return {
+        origin: {
+            friendId: delegated.delegatedFrom.friendId,
+            channel: delegated.delegatedFrom.channel,
+            key: delegated.delegatedFrom.key,
+        },
+        contentSnippet: snippet,
+        ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
+    };
+}
 function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
     if (runtimeState?.status === "running") {
         if (pendingMessages.length > 0) {
@@ -157,6 +175,7 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
                 wake: "queued behind active turn",
                 processing: "pending",
                 surfaced: "nothing yet",
+                ...extractEnrichedFields(pendingMessages),
             };
         }
         return {
@@ -172,6 +191,7 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
             wake: "awaiting inner session",
             processing: "pending",
             surfaced: "nothing yet",
+            ...extractEnrichedFields(pendingMessages),
         };
     }
     const latestProcessedPendingTurn = [...turns]
@@ -192,23 +212,125 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
         surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
     };
 }
+function deriveInnerJob(pendingMessages, turns, runtimeState) {
+    const isRunning = runtimeState?.status === "running";
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    const enriched = extractEnrichedFields(pendingMessages);
+    const pendingMode = delegated && "mode" in delegated && delegated.mode ? delegated.mode : "reflect";
+    const origin = enriched.origin ?? null;
+    const content = delegated?.content ?? null;
+    const obligationStatus = delegated?.obligationStatus ?? null;
+    const queuedAt = delegated?.timestamp ?? null;
+    if (isRunning) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "running",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: runtimeState?.startedAt ?? null,
+            surfacedAt: null,
+        };
+    }
+    if (pendingMessages.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "queued",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    // No pending, not running -- check for surfaced result
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (latestProcessedPendingTurn) {
+        const surfacedResult = extractThoughtResponseFromMessages([
+            { role: "assistant", content: latestProcessedPendingTurn.response },
+        ]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
+        });
+        return {
+            status: "surfaced",
+            content: null,
+            origin: null,
+            mode: "reflect",
+            obligationStatus: null,
+            /* v8 ignore next -- defensive: surfacedResult fallback @preserve */
+            surfacedResult: surfacedResult || null,
+            queuedAt: null,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.inner_job_derive",
+        message: "derived inner job state",
+        meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
+    });
+    return {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+}
 function formatInnerDialogStatus(status) {
-    return [
+    const lines = [
         `queue: ${status.queue}`,
         `wake: ${status.wake}`,
         `processing: ${status.processing}`,
         `surfaced: ${status.surfaced}`,
-    ].join("\n");
+    ];
+    if (status.origin) {
+        lines.push(`origin: ${status.origin.friendId}/${status.origin.channel}/${status.origin.key}`);
+    }
+    if (status.contentSnippet) {
+        lines.push(`asked: ${status.contentSnippet}`);
+    }
+    if (status.obligationPending) {
+        lines.push("obligation: pending");
+    }
+    return lines.join("\n");
 }
-/** Extract text from a final_answer tool call's arguments. */
-function extractFinalAnswer(messages) {
+/** Extract text from a settle tool call's arguments. */
+function extractSettleAnswer(messages) {
     for (let k = messages.length - 1; k >= 0; k--) {
         const msg = messages[k];
         if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
             continue;
         for (const tc of msg.tool_calls) {
             const toolFunction = extractToolFunction(tc);
-            if (toolFunction?.name !== "final_answer")
+            if (toolFunction?.name !== "settle")
                 continue;
             try {
                 const parsed = JSON.parse(toolFunction.arguments ?? "{}");
@@ -227,7 +349,7 @@ function extractThoughtResponseFromMessages(messages) {
     const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
     return lastAssistant
         ? contentToText(lastAssistant.content).trim()
-        : extractFinalAnswer(messages);
+        : extractSettleAnswer(messages);
 }
 function parseInnerDialogSession(sessionPath) {
     (0, runtime_1.emitNervesEvent)({
@@ -243,21 +365,34 @@ function parseInnerDialogSession(sessionPath) {
     catch {
         return [];
     }
-    let data;
+    let parsedRaw;
     try {
-        data = JSON.parse(raw);
+        parsedRaw = JSON.parse(raw);
     }
     catch {
         return [];
     }
-    if (data.version !== 1 || !Array.isArray(data.messages))
+    const legacyRecord = parsedRaw && typeof parsedRaw === "object"
+        ? parsedRaw
+        : null;
+    const messages = legacyRecord?.version === 1 && Array.isArray(legacyRecord.messages)
+        ? legacyRecord.messages
+        : (() => {
+            const envelope = (0, session_events_1.parseSessionEnvelope)(parsedRaw, {
+                recordedAt: new Date().toISOString(),
+            });
+            if (!envelope)
+                return null;
+            return (0, session_events_1.projectProviderMessages)(envelope);
+        })();
+    if (!messages)
         return [];
+    const normalizedMessages = messages;
     const turns = [];
-    const messages = data.messages;
     // Walk messages, pairing user → (tool calls) → assistant sequences
     let i = 0;
-    while (i < messages.length) {
-        const msg = messages[i];
+    while (i < normalizedMessages.length) {
+        const msg = normalizedMessages[i];
         if (msg.role === "system") {
             i++;
             continue;
@@ -271,12 +406,12 @@ function parseInnerDialogSession(sessionPath) {
         // Collect all messages until the next user message (or end)
         const turnMessages = [];
         let j = i + 1;
-        while (j < messages.length && messages[j].role !== "user") {
-            turnMessages.push(messages[j]);
+        while (j < normalizedMessages.length && normalizedMessages[j].role !== "user") {
+            turnMessages.push(normalizedMessages[j]);
             j++;
         }
         // Find the last assistant text response in this turn.
-        // With tool_choice="required", the response may be inside a final_answer tool call.
+        // With tool_choice="required", the response may be inside a settle tool call.
         const response = extractThoughtResponseFromMessages(turnMessages);
         const tools = extractToolNames(turnMessages);
         turns.push({
@@ -347,6 +482,13 @@ function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDi
     const runtimeState = readInnerDialogRuntimeState(runtimePath);
     return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
 }
+function readInnerDialogRawData(sessionPath, pendingDir) {
+    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return { pendingMessages, turns, runtimeState };
+}
 /**
  * Watch a session file and emit new turns as they appear.
  * Returns a cleanup function that stops the watcher.
@@ -369,9 +511,12 @@ function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
     });
     return () => {
         fs.unwatchFile(sessionPath);
+        // Must be named `_end` (not `_stop`) to satisfy the nerves audit's
+        // start/end pairing rule — see src/nerves/coverage/audit-rules.ts which
+        // pairs `<prefix>_start` with `<prefix>_end` or `<prefix>_error`.
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
-            event: "daemon.thoughts_follow_stop",
+            event: "daemon.thoughts_follow_end",
             message: "stopped following inner dialog session",
             meta: { sessionPath, totalTurns: displayedCount },
         });

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;