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

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.444",
+      "changes": [
+        "`ouro up` now treats daemon startup as one truthful boot story across fresh starts and daemon replacement: both paths wait on the same current-boot readiness check, keep narrating real progress while the background service warms up, and stop calling startup done just because one quick socket probe answered.",
+        "Slow real-world boots now get more patience and better visibility. The default startup timeout was extended to 60 seconds, the boot checklist keeps printing live startup detail instead of stalling on a blinking cursor, and replacement boot failures now land as a failed `starting daemon` step with plain-language diagnosis.",
+        "Startup failures now behave like failures to the shell as well as to the human: `ouro up` sets a non-zero exit code when daemon boot does not finish, and `ouro logs` is wired into the installed CLI again so the recovery path it points to actually opens the live daemon/agent log tail."
+      ]
+    },
+    {
+      "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-defaults.js

@@ -514,11 +514,16 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         sendCommand: socket_client_1.sendDaemonCommand,
         startDaemonProcess: defaultStartDaemonProcess,
         writeStdout: defaultWriteStdout,
+        setExitCode: (code) => {
+            const current = typeof process.exitCode === "number" ? process.exitCode : 0;
+            process.exitCode = Math.max(current, code);
+        },
         writeRaw: defaultWriteRaw,
         isTTY: process.stdout.isTTY === true,
         checkSocketAlive: socket_client_1.checkDaemonSocketAlive,
         cleanupStaleSocket: defaultCleanupStaleSocket,
         fallbackPendingMessage: defaultFallbackPendingMessage,
+        tailLogs: (options) => (0, log_tailer_1.tailLogs)(options),
         healthFilePath: (0, daemon_health_1.getDefaultHealthPath)(),
         readHealthState: daemon_health_1.readHealth,
         readHealthUpdatedAt: defaultReadHealthUpdatedAt,
@@ -528,7 +533,7 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         updateCheckTimeoutMs: update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS,
         startupPollIntervalMs: 250,
         startupStabilityWindowMs: 1_500,
-        startupTimeoutMs: 10_000,
+        startupTimeoutMs: 60_000,
         startupRetryLimit: 1,
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,

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

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeDaemonStartupFailure = summarizeDaemonStartupFailure;
 exports.mergeStartupStability = mergeStartupStability;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.listGithubCopilotModels = listGithubCopilotModels;
@@ -100,7 +101,7 @@ const agent_discovery_1 = require("./agent-discovery");
 const connect_bay_1 = require("./connect-bay");
 const runtime_capability_check_1 = require("../runtime-capability-check");
 // ── ensureDaemonRunning ──
-const DEFAULT_DAEMON_STARTUP_TIMEOUT_MS = 10_000;
+const DEFAULT_DAEMON_STARTUP_TIMEOUT_MS = 60_000;
 const DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS = 500;
 const DEFAULT_DAEMON_STARTUP_STABILITY_WINDOW_MS = 1_500;
 const DEFAULT_DAEMON_STARTUP_RETRY_LIMIT = 1;
@@ -122,6 +123,31 @@ function summarizeCliUpdateCheckStatus(error, timedOut = false) {
     }
     return "skipped; update check unavailable";
 }
+function returnCliFailure(deps, message, exitCode = 1) {
+    deps.setExitCode?.(exitCode);
+    deps.writeStdout(message);
+    return message;
+}
+function summarizeDaemonStartupFailure(result) {
+    if (result.startupFailureReason && result.startupFailureReason.trim().length > 0) {
+        return result.startupFailureReason;
+    }
+    const firstLine = result.message.split(/\r?\n/, 1)[0]?.trim();
+    return firstLine && firstLine.length > 0
+        ? firstLine
+        : "background service failed to finish booting";
+}
+function formatDaemonStartupProgressLine(serviceLabel, status, latestEvent) {
+    const base = status === "waiting"
+        ? `waiting for the ${serviceLabel} to answer`
+        : status === "answering"
+            ? `${serviceLabel} answered\n- waiting for this boot to publish its ready signal`
+            : `${serviceLabel} answered\n- ready signal received; making sure it holds`;
+    const trimmedEvent = latestEvent?.trim();
+    return trimmedEvent && status !== "stabilizing"
+        ? `${base}\n- latest daemon event: ${trimmedEvent}`
+        : base;
+}
 async function runCliUpdateCheckWithTimeout(checkForCliUpdate, timeoutMs = update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS) {
     return await new Promise((resolve, reject) => {
         let settled = false;
@@ -160,7 +186,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 +383,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 +417,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);
@@ -566,7 +655,7 @@ async function ensureDaemonRunning(deps, options = {}) {
             // The daemon writes structured events to daemon.ndjson in the first
             // agent bundle's state/daemon/logs/ directory. Read the last line to
             // surface what it's currently doing (e.g., "starting auto-start agents").
-            const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+            const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
             if (!fs.existsSync(bundlesRoot))
                 return null;
             const agents = fs.readdirSync(bundlesRoot).filter((d) => d.endsWith(".ouro"));
@@ -643,9 +732,27 @@ async function ensureDaemonRunning(deps, options = {}) {
             startDaemonProcess: deps.startDaemonProcess,
             checkSocketAlive: deps.checkSocketAlive,
             onProgress: deps.reportDaemonStartupPhase,
+            waitForDaemonStartup: async ({ pid }) => {
+                const startupFailure = await waitForDaemonStartup(deps, {
+                    bootStartedAtMs: (deps.now ?? Date.now)(),
+                    pid,
+                    serviceLabel: "replacement background service",
+                    readLatestDaemonEvent: readLatestDaemonStartupEvent,
+                });
+                return startupFailure
+                    ? { ok: false, reason: startupFailure.reason }
+                    : { ok: true };
+            },
         });
-        if (!runtimeResult.verifyStartupStatus) {
-            return runtimeResult;
+        if (!runtimeResult.ok) {
+            return {
+                ok: false,
+                alreadyRunning: runtimeResult.alreadyRunning,
+                message: runtimeResult.message,
+                verifyStartupStatus: runtimeResult.verifyStartupStatus,
+                startedPid: runtimeResult.startedPid,
+                startupFailureReason: runtimeResult.startupFailureReason ?? null,
+            };
         }
         const stability = await (0, startup_tui_1.pollDaemonStartup)({
             sendCommand: deps.sendCommand,
@@ -666,8 +773,12 @@ async function ensureDaemonRunning(deps, options = {}) {
             render: !deps.reportDaemonStartupPhase,
         });
         return {
+            ok: true,
             alreadyRunning: runtimeResult.alreadyRunning,
             message: runtimeResult.message,
+            verifyStartupStatus: runtimeResult.verifyStartupStatus,
+            startedPid: runtimeResult.startedPid,
+            startupFailureReason: null,
             stability,
         };
     }
@@ -687,6 +798,8 @@ async function ensureDaemonRunning(deps, options = {}) {
         const startupFailure = await waitForDaemonStartup(deps, {
             bootStartedAtMs,
             pid: lastPid,
+            serviceLabel: "new background service",
+            readLatestDaemonEvent: readLatestDaemonStartupEvent,
         });
         if (!startupFailure) {
             const stability = await (0, startup_tui_1.pollDaemonStartup)({
@@ -708,8 +821,10 @@ async function ensureDaemonRunning(deps, options = {}) {
                 render: !deps.reportDaemonStartupPhase,
             });
             return {
+                ok: true,
                 alreadyRunning: false,
                 message: `daemon started (pid ${lastPid ?? "unknown"})`,
+                startupFailureReason: null,
                 stability,
             };
         }
@@ -720,8 +835,10 @@ async function ensureDaemonRunning(deps, options = {}) {
         deps.reportDaemonStartupPhase?.("background service startup went sideways once; trying one more time");
     }
     return {
+        ok: false,
         alreadyRunning: false,
         message: formatDaemonStartupFailureMessage(lastPid, lastFailure, deps),
+        startupFailureReason: lastFailure.reason,
     };
 }
 function hasStartupHealthMonitor(deps) {
@@ -746,14 +863,14 @@ function hasFreshCurrentBootHealthSignal(deps, bootStartedAtMs, pid) {
 }
 function formatDaemonStartupFailureMessage(pid, failure, deps) {
     const lines = [
-        `daemon spawned (pid ${pid ?? "unknown"}) but failed to stabilize: ${failure.reason}`,
+        `background service started (pid ${pid ?? "unknown"}) but did not finish booting: ${failure.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("fix hint for daemon: check daemon logs or run `ouro doctor`");
+    lines.push("Run `ouro logs` to watch live startup logs or `ouro doctor` for a deeper diagnosis.");
     return lines.join("\n");
 }
 async function waitForDaemonStartup(deps, options) {
@@ -767,13 +884,17 @@ async function waitForDaemonStartup(deps, options) {
     let stableSinceMs = null;
     let sawSocket = false;
     if (!useHealthMonitor) {
-        const verified = await verifyDaemonAlive(deps.checkSocketAlive, deps.socketPath, timeoutMs, pollIntervalMs, sleep, now);
-        return verified
-            ? null
-            : {
-                reason: `daemon failed to respond within ${Math.ceil(timeoutMs / 1000)}s`,
-                retryable: false,
-            };
+        while (now() < deadline) {
+            await sleep(pollIntervalMs);
+            const latestEvent = options.readLatestDaemonEvent?.() ?? null;
+            deps.reportDaemonStartupPhase?.(formatDaemonStartupProgressLine(options.serviceLabel, "waiting", latestEvent));
+            if (await deps.checkSocketAlive(deps.socketPath))
+                return null;
+        }
+        return {
+            reason: `${options.serviceLabel} did not answer within ${Math.ceil(timeoutMs / 1000)}s`,
+            retryable: false,
+        };
     }
     while (now() < deadline) {
         await sleep(pollIntervalMs);
@@ -781,40 +902,37 @@ async function waitForDaemonStartup(deps, options) {
         if (!aliveNow) {
             if (sawSocket) {
                 return {
-                    reason: "daemon socket disappeared during startup",
+                    reason: `${options.serviceLabel} answered once and then disappeared during startup`,
                     retryable: true,
                 };
             }
+            const latestEvent = options.readLatestDaemonEvent?.() ?? null;
+            deps.reportDaemonStartupPhase?.(formatDaemonStartupProgressLine(options.serviceLabel, "waiting", latestEvent));
             continue;
         }
         if (!sawSocket) {
             sawSocket = true;
             stableSinceMs = now();
-            deps.reportDaemonStartupPhase?.("verifying daemon health");
+            const latestEvent = options.readLatestDaemonEvent?.() ?? null;
+            deps.reportDaemonStartupPhase?.(formatDaemonStartupProgressLine(options.serviceLabel, "answering", latestEvent));
         }
         if (!hasFreshCurrentBootHealthSignal(deps, options.bootStartedAtMs, options.pid)) {
+            const latestEvent = options.readLatestDaemonEvent?.() ?? null;
+            deps.reportDaemonStartupPhase?.(formatDaemonStartupProgressLine(options.serviceLabel, "answering", latestEvent));
             continue;
         }
+        deps.reportDaemonStartupPhase?.(formatDaemonStartupProgressLine(options.serviceLabel, "stabilizing"));
         if (stableSinceMs !== null && now() - stableSinceMs >= stabilityWindowMs) {
             return null;
         }
     }
     return {
         reason: sawSocket
-            ? "daemon did not publish fresh health for the current boot attempt"
-            : `daemon failed to respond within ${Math.ceil(timeoutMs / 1000)}s`,
+            ? `${options.serviceLabel} answered but this boot never published a ready signal within ${Math.ceil(timeoutMs / 1000)}s`
+            : `${options.serviceLabel} did not answer within ${Math.ceil(timeoutMs / 1000)}s`,
         retryable: sawSocket,
     };
 }
-async function verifyDaemonAlive(checkSocketAlive, socketPath, maxWaitMs = 10_000, pollIntervalMs = 500, sleep = defaultSleep, now = Date.now) {
-    const deadline = now() + maxWaitMs;
-    while (now() < deadline) {
-        await sleep(pollIntervalMs);
-        if (await checkSocketAlive(socketPath))
-            return true;
-    }
-    return false;
-}
 function defaultSleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -3939,6 +4057,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 +4187,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");
@@ -4078,22 +4199,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 if (command.noRepair) {
                     writeProviderRepairSummary(deps, "Provider checks need attention", preflightProviderDegraded);
                     const message = "daemon not started: provider checks need repair. Run `ouro repair` or rerun `ouro up` to choose a repair path.";
-                    deps.writeStdout(message);
-                    return message;
+                    return returnCliFailure(deps, message);
                 }
                 const repairResult = await runReadinessRepairForDegraded(preflightProviderDegraded, deps);
                 if (!repairResult.repairsAttempted) {
                     writeProviderRepairSummary(deps, "Provider checks still need attention", repairResult.remainingDegraded);
                     const message = "daemon not started: provider checks need repair. Run `ouro repair` or rerun `ouro up` to choose a repair path.";
-                    deps.writeStdout(message);
-                    return message;
+                    return returnCliFailure(deps, message);
                 }
                 const remainingDegraded = repairResult.remainingDegraded;
                 if (remainingDegraded.length > 0) {
                     writeProviderRepairSummary(deps, "Still needs attention", remainingDegraded);
                     const message = "daemon not started: provider checks still need repair.";
-                    deps.writeStdout(message);
-                    return message;
+                    return returnCliFailure(deps, message);
                 }
                 deps.writeStdout("All set. Provider checks recovered after repair.");
             }
@@ -4106,12 +4224,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 progress.announceStep?.(label);
             },
         }, { initialAlive: daemonAliveBeforeStart });
-        if (daemonResult.verifyStartupStatus === false) {
+        if (!daemonResult.ok) {
             ;
-            progress.announceStep?.("replacement daemon did not answer in time");
+            progress.failPhase?.("starting daemon", summarizeDaemonStartupFailure(daemonResult));
             progress.end();
-            deps.writeStdout(daemonResult.message);
-            return daemonResult.message;
+            return returnCliFailure(deps, daemonResult.message);
         }
         progress.completePhase("starting daemon", daemonProgressSummary(daemonResult));
         if (!providerChecksAlreadyRun || daemonResult.alreadyRunning) {
@@ -4120,6 +4237,16 @@ 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";
+            return returnCliFailure(deps, 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/daemon-cli.js

@@ -14,7 +14,7 @@
  * ouro-entry.ts, ouro-bot-wrapper.ts) continue to work unchanged.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFirstBundleMetaVersion = exports.createDefaultOuroCliDeps = exports.pingGithubCopilotModel = exports.listGithubCopilotModels = exports.ensureDaemonRunning = exports.runOuroCli = exports.parseOuroCommand = void 0;
+exports.readFirstBundleMetaVersion = exports.createDefaultOuroCliDeps = exports.pingGithubCopilotModel = exports.summarizeDaemonStartupFailure = exports.listGithubCopilotModels = exports.ensureDaemonRunning = exports.runOuroCli = exports.parseOuroCommand = void 0;
 // ── Parsing ──
 var cli_parse_1 = require("./cli-parse");
 Object.defineProperty(exports, "parseOuroCommand", { enumerable: true, get: function () { return cli_parse_1.parseOuroCommand; } });
@@ -23,6 +23,7 @@ var cli_exec_1 = require("./cli-exec");
 Object.defineProperty(exports, "runOuroCli", { enumerable: true, get: function () { return cli_exec_1.runOuroCli; } });
 Object.defineProperty(exports, "ensureDaemonRunning", { enumerable: true, get: function () { return cli_exec_1.ensureDaemonRunning; } });
 Object.defineProperty(exports, "listGithubCopilotModels", { enumerable: true, get: function () { return cli_exec_1.listGithubCopilotModels; } });
+Object.defineProperty(exports, "summarizeDaemonStartupFailure", { enumerable: true, get: function () { return cli_exec_1.summarizeDaemonStartupFailure; } });
 var provider_ping_1 = require("../provider-ping");
 Object.defineProperty(exports, "pingGithubCopilotModel", { enumerable: true, get: function () { return provider_ping_1.pingGithubCopilotModel; } });
 // ── Defaults ──

package/dist/heart/daemon/daemon-runtime-sync.js

@@ -111,10 +111,14 @@ async function ensureCurrentDaemonRuntime(deps) {
             catch (error) {
                 const reason = formatErrorReason(error);
                 result = {
+                    ok: false,
                     alreadyRunning: true,
                     message: includesVersionDrift
                         ? `daemon already running (${deps.socketPath}; could not replace the older background service ${runningVersion} -> ${deps.localVersion}: ${reason})`
                         : `daemon already running (${deps.socketPath}; could not replace the older background service after runtime drift ${publicDriftSummary}: ${reason})`,
+                    startupFailureReason: includesVersionDrift
+                        ? "could not replace the older background service"
+                        : "could not replace the older background service after runtime drift",
                 };
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
@@ -144,16 +148,23 @@ async function ensureCurrentDaemonRuntime(deps) {
             deps.onProgress?.("starting the replacement background service");
             const started = await deps.startDaemonProcess(deps.socketPath);
             const pid = started.pid ?? "unknown";
-            const verified = await verifyDaemonStarted(deps);
+            const startupCheck = deps.waitForDaemonStartup
+                ? await deps.waitForDaemonStartup({ pid: started.pid ?? null })
+                : { ok: await verifyDaemonStarted(deps) };
+            const verified = startupCheck.ok;
             /* v8 ignore next -- daemon liveness failure: requires real daemon crash timing @preserve */
-            const suffix = verified ? "" : "\nreplacement daemon did not answer in time; check logs with `ouro logs` or run `ouro doctor`.";
+            const suffix = verified
+                ? ""
+                : `\n${startupCheck.reason ?? "replacement background service did not answer in time"}; check logs with \`ouro logs\` or run \`ouro doctor\`.`;
             result = {
+                ok: verified,
                 alreadyRunning: false,
                 message: includesVersionDrift
                     ? `replaced an older background service ${runningVersion} -> ${deps.localVersion} (pid ${pid})${suffix}`
                     : `replaced an older background service after runtime drift: ${publicDriftSummary} (pid ${pid})${suffix}`,
                 verifyStartupStatus: verified,
                 startedPid: started.pid ?? null,
+                startupFailureReason: verified ? null : (startupCheck.reason ?? "replacement background service did not answer in time"),
             };
             (0, runtime_1.emitNervesEvent)({
                 component: "daemon",
@@ -180,6 +191,7 @@ async function ensureCurrentDaemonRuntime(deps) {
         }
         if (!isKnownVersion(localRuntime.version) || !isKnownVersion(runningVersion)) {
             result = {
+                ok: true,
                 alreadyRunning: true,
                 message: `daemon already running (${deps.socketPath}; unable to verify version)`,
             };
@@ -208,6 +220,7 @@ async function ensureCurrentDaemonRuntime(deps) {
     catch (error) {
         const reason = formatErrorReason(error);
         const result = {
+            ok: true,
             alreadyRunning: true,
             message: `daemon already running (${deps.socketPath}; unable to verify version: ${reason})`,
         };
@@ -230,10 +243,12 @@ async function ensureCurrentDaemonRuntime(deps) {
         return result;
     }
     const result = {
+        ok: true,
         alreadyRunning: true,
         message: `daemon already running (${deps.socketPath})`,
         verifyStartupStatus: true,
         startedPid: null,
+        startupFailureReason: null,
     };
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",

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.444",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",