@ouro.bot/cli 0.1.0-alpha.442 → 0.1.0-alpha.443

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.443",
+      "changes": [
+        "`ouro up` now renders as a real boot checklist instead of a loose progress wall: the screen shows the full startup path up front, marks what is running now, and keeps pending steps visible so humans can see where Ouro is in the bring-up flow.",
+        "Provider checks during startup now narrate the providers each selected lane is actually using, translate noisy vault chatter into plain language, and keep the live-check copy truthful instead of implying that every configured provider was checked.",
+        "`ouro up` no longer reports success just because the daemon answered once during startup. Before handing control back, Ouro now performs one final daemon-status handoff check and fails with a clear diagnosis if the background service stopped before boot actually finished."
+      ]
+    },
     {
       "version": "0.1.0-alpha.442",
       "changes": [

package/dist/heart/daemon/agent-config-check.js

@@ -318,6 +318,33 @@ function failedPingResult(agentName, lane, provider, model, result) {
 function credentialRecordForLane(pool, provider) {
     return pool.providers[provider];
 }
+function laneAudienceLabel(lane) {
+    return lane === "outward" ? "chat" : "inner dialog";
+}
+function bindingLabel(binding) {
+    return `${binding.provider} / ${binding.model}`;
+}
+function selectedProviderPlan(agentName, state) {
+    return [
+        `${agentName}: checking the providers this agent uses right now`,
+        ...["outward", "inner"].map((lane) => `- ${laneAudienceLabel(lane)}: ${bindingLabel(state.lanes[lane])}`),
+    ].join("\n");
+}
+function mapVaultRefreshProgress(agentName, onProgress) {
+    return (message) => {
+        if (message.startsWith("reading vault items for ")) {
+            onProgress(`${agentName}: opening saved provider credentials in the vault`);
+            return;
+        }
+        if (message === "parsing provider credentials...") {
+            onProgress(`${agentName}: organizing saved provider credentials`);
+        }
+    };
+}
+function providerPingSubject(agentName, lanes) {
+    const laneList = lanes.map((lane) => laneAudienceLabel(lane)).join(" + ");
+    return `${agentName} (${laneList})`;
+}
 /**
  * Structural validation only. Live provider credential validation belongs to
  * checkAgentConfigWithProviderHealth(), which reads the agent vault and pings.
@@ -352,8 +379,9 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
         return stateResult.result;
     if (stateResult.disabled)
         return { ok: true };
+    deps.onProgress?.(selectedProviderPlan(agentName, stateResult.state));
     const ping = deps.pingProvider ?? (await Promise.resolve().then(() => __importStar(require("../provider-ping")))).pingProvider;
-    const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, deps.onProgress ? { onProgress: deps.onProgress } : undefined);
+    const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, deps.onProgress ? { onProgress: mapVaultRefreshProgress(agentName, deps.onProgress) } : undefined);
     const pingGroups = new Map();
     const lanes = ["outward", "inner"];
     for (const lane of lanes) {
@@ -390,7 +418,11 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
         const result = await ping(group.provider, providerCredentialConfig(group.record), {
             model: group.model,
             ...(deps.onProgress
-                ? (0, provider_ping_progress_1.createProviderPingProgressReporter)({ provider: group.provider, model: group.model }, deps.onProgress)
+                ? (0, provider_ping_progress_1.createProviderPingProgressReporter)({
+                    provider: group.provider,
+                    model: group.model,
+                    subject: providerPingSubject(agentName, group.lanes),
+                }, deps.onProgress)
                 : {}),
         });
         return { group, result };

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

@@ -160,7 +160,6 @@ async function checkAgentProviders(deps, agentsOverride, onProgress) {
     const degraded = [];
     for (const agent of [...new Set(agents)]) {
         try {
-            onProgress?.(`${agent}: checking providers...`);
             const result = await checkAgentProviderHealth(agent, bundlesRoot, deps, onProgress);
             if (result.ok)
                 continue;
@@ -358,9 +357,14 @@ function writeProviderRepairSummary(deps, title, degraded) {
 }
 function providerRepairCountSummary(count) {
     if (count === 0)
-        return "ok";
+        return "selected providers answered live checks";
     return `${count} ${count === 1 ? "needs" : "need"} attention`;
 }
+function bootPhasePlan(daemonAlive) {
+    return daemonAlive
+        ? ["update check", "system setup", "starting daemon", "provider checks", "final daemon check"]
+        : ["update check", "system setup", "provider checks", "starting daemon", "final daemon check"];
+}
 function createHumanCommandProgress(deps, commandName) {
     return new up_progress_1.CommandProgress({
         write: deps.writeRaw ?? deps.writeStdout,
@@ -387,8 +391,67 @@ function daemonProgressSummary(result) {
     if (result.alreadyRunning)
         return "already running";
     if (result.message.includes("replaced"))
-        return "replacement ready";
-    return "ready";
+        return "replacement answered";
+    return "background service answered";
+}
+function finalDaemonFailureMessage(deps, reason) {
+    const lines = [`background service stopped before boot finished: ${reason}`];
+    const recentLogLines = deps.readRecentDaemonLogLines?.(DEFAULT_DAEMON_STARTUP_LOG_LINES) ?? [];
+    if (recentLogLines.length > 0) {
+        lines.push("recent daemon logs:");
+        lines.push(...recentLogLines.map((line) => `  ${line}`));
+    }
+    lines.push("Run `ouro up` again or `ouro doctor` for a deeper diagnosis.");
+    return lines.join("\n");
+}
+async function verifyDaemonReadyForHandoff(deps) {
+    const socketAlive = await deps.checkSocketAlive(deps.socketPath);
+    if (!socketAlive) {
+        return {
+            ok: false,
+            summary: "background service stopped",
+            message: finalDaemonFailureMessage(deps, "the daemon socket is no longer answering"),
+        };
+    }
+    try {
+        const response = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
+        if (!response.ok) {
+            const reason = response.error ?? response.message ?? "daemon status did not answer cleanly";
+            return {
+                ok: false,
+                summary: "daemon status did not answer",
+                message: finalDaemonFailureMessage(deps, reason),
+            };
+        }
+        const payload = (0, cli_render_1.parseStatusPayload)(response.data);
+        if (!payload) {
+            return {
+                ok: true,
+                summary: "daemon answered",
+            };
+        }
+        if (payload.overview.daemon !== "running") {
+            return {
+                ok: false,
+                summary: `daemon reported ${payload.overview.daemon}`,
+                message: finalDaemonFailureMessage(deps, `the daemon reported state ${payload.overview.daemon}`),
+            };
+        }
+        const workerCount = payload.workers.length;
+        return {
+            ok: true,
+            summary: workerCount === 0
+                ? "daemon answered"
+                : `${workerCount} worker${workerCount === 1 ? "" : "s"} still answering`,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            summary: "daemon status did not answer",
+            message: finalDaemonFailureMessage(deps, error instanceof Error ? error.message : String(error)),
+        };
+    }
 }
 async function reportPostRepairProviderHealth(deps, repairedAgents, onProgress) {
     const remainingDegraded = await checkAgentProviders(deps, repairedAgents, onProgress);
@@ -3939,6 +4002,8 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             now: deps.now ?? (() => Date.now()),
             autoRender: true,
         });
+        const daemonAliveAtBootStart = await deps.checkSocketAlive(deps.socketPath);
+        progress.setPhasePlan?.(bootPhasePlan(daemonAliveAtBootStart));
         // ── versioned CLI update check ──
         if (deps.checkForCliUpdate) {
             progress.startPhase("update check");
@@ -4067,6 +4132,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             promptInput: deps.promptInput,
         });
         const daemonAliveBeforeStart = await deps.checkSocketAlive(deps.socketPath);
+        progress.setPhasePlan?.(bootPhasePlan(daemonAliveBeforeStart));
         let providerChecksAlreadyRun = false;
         if (!daemonAliveBeforeStart) {
             progress.startPhase("provider checks");
@@ -4120,6 +4186,17 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             daemonResult.stability = mergeStartupStability(daemonResult.stability, providerDegraded);
             progress.completePhase("provider checks", providerRepairCountSummary(providerDegraded.length));
         }
+        progress.startPhase("final daemon check");
+        const finalDaemonCheck = await verifyDaemonReadyForHandoff(deps);
+        if (!finalDaemonCheck.ok) {
+            ;
+            progress.failPhase?.("final daemon check", finalDaemonCheck.summary);
+            progress.end();
+            const message = finalDaemonCheck.message ?? "background service stopped before boot finished";
+            deps.writeStdout(message);
+            return message;
+        }
+        progress.completePhase("final daemon check", finalDaemonCheck.summary);
         progress.end();
         // Interactive repair for degraded agents (Unit 5) — skipped by --no-repair (Unit 6)
         if (daemonResult.stability?.degraded && daemonResult.stability.degraded.length > 0) {

package/dist/heart/daemon/provider-ping-progress.js

@@ -33,11 +33,16 @@ function providerRetryTiming(delayMs) {
     return `in ${rounded}`;
 }
 function formatProviderAttemptProgress(context, attempt, maxAttempts) {
-    return `checking ${formatProviderPingLabel(context)} (attempt ${attempt} of ${maxAttempts})...`;
+    const prefix = context.subject ? `${context.subject}: ` : "";
+    return `${prefix}checking ${formatProviderPingLabel(context)} (attempt ${attempt} of ${maxAttempts})...`;
 }
-function formatProviderRetryProgress(record, maxAttempts) {
+function formatProviderRetryProgress(context, record, maxAttempts) {
     const nextAttempt = Math.min(record.attempt + 1, maxAttempts);
-    return `${formatProviderPingLabel(record)}: ${providerRetryReason(record)}; retrying ${providerRetryTiming(record.delayMs)} (attempt ${nextAttempt} of ${maxAttempts})`;
+    const retryDetail = `${providerRetryReason(record)}; retrying ${providerRetryTiming(record.delayMs)} (attempt ${nextAttempt} of ${maxAttempts})`;
+    if (context.subject) {
+        return `${context.subject}: ${retryDetail} while checking ${formatProviderPingLabel(context)}`;
+    }
+    return `${formatProviderPingLabel(record)}: ${retryDetail}`;
 }
 function createProviderPingProgressReporter(context, onProgress) {
     return {
@@ -70,7 +75,7 @@ function createProviderPingProgressReporter(context, onProgress) {
                     classification: record.classification ?? "unknown",
                 },
             });
-            onProgress(formatProviderRetryProgress(record, maxAttempts));
+            onProgress(formatProviderRetryProgress(context, record, maxAttempts));
         },
     };
 }

package/dist/heart/daemon/terminal-ui.js

@@ -201,11 +201,11 @@ function renderTerminalOperation(options) {
         summary: options.summary,
         sections: [
             {
-                title: "Right now",
+                title: options.currentTitle ?? "Right now",
                 lines: currentLines,
             },
             {
-                title: "Progress",
+                title: options.stepsTitle ?? "Progress",
                 lines: progressLines,
             },
         ],

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

@@ -22,6 +22,22 @@ 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 [];
@@ -45,6 +61,7 @@ class UpProgress {
     completed = [];
     currentPhase = null;
     currentDetail = null;
+    upPhasePlan = BASE_UP_PHASE_PLAN;
     prevLineCount = 0;
     ended = false;
     renderTimer = null;
@@ -96,6 +113,13 @@ class UpProgress {
             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
@@ -272,39 +296,61 @@ class UpProgress {
         }
         return lines;
     }
+    renderUpStepLabel(label) {
+        return FRIENDLY_UP_PHASE_LABELS[label] ?? label;
+    }
     renderUpScreen(now) {
-        const steps = this.completed.map((phase) => ({
-            label: phase.label,
-            status: phase.status === "failure" ? "failed" : "done",
-            detail: phase.detail,
-        }));
-        let currentStepLabel = "Standing by.";
+        const seenLabels = new Set();
+        const steps = this.completed.map((phase) => {
+            seenLabels.add(phase.label);
+            return {
+                label: this.renderUpStepLabel(phase.label),
+                status: phase.status === "failure" ? "failed" : "done",
+                detail: phase.detail,
+            };
+        });
+        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.currentPhase.label} (${elapsedSec}s)`;
+            currentStepLabel = `${spinner} ${this.renderUpStepLabel(this.currentPhase.label)} (${elapsedSec}s)`;
             currentStepDetails = splitDetailLines(this.currentPhase.detail);
             steps.push({
-                label: this.currentPhase.label,
+                label: this.renderUpStepLabel(this.currentPhase.label),
                 status: "active",
             });
+            seenLabels.add(this.currentPhase.label);
+        }
+        for (const label of this.upPhasePlan) {
+            if (!seenLabels.has(label)) {
+                steps.push({
+                    label: this.renderUpStepLabel(label),
+                    status: "pending",
+                });
+            }
         }
         return (0, terminal_ui_1.renderTerminalOperation)({
             isTTY: true,
             columns: this.columns,
             masthead: {
-                subtitle: "Starting the local agent runtime.",
+                subtitle: "Booting the local agent runtime.",
             },
-            title: "Starting Ouro",
-            summary: "Ouro is starting the background runtime, checking credentials, and surfacing anything that needs attention before chat begins.",
+            title: "Ouro boot checklist",
+            summary: "Ouro will check for updates, prepare this machine, verify the providers your agents use right now, start the background service, and make sure it stays up.",
             currentStep: {
                 label: currentStepLabel,
                 detailLines: currentStepDetails,
             },
             steps,
+            currentTitle: "Doing now",
+            stepsTitle: "Boot checklist",
             suppressEvent: true,
         }).trimEnd().split("\n");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.442",
+  "version": "0.1.0-alpha.443",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",