@ouro.bot/cli 0.1.0-alpha.430 → 0.1.0-alpha.432

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

@@ -53,6 +53,7 @@ const runtime_1 = require("../../nerves/runtime");
 const ouro_path_installer_1 = require("../versioning/ouro-path-installer");
 const ouro_uti_1 = require("../versioning/ouro-uti");
 const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
+const update_checker_1 = require("../versioning/update-checker");
 const skill_management_installer_1 = require("./skill-management-installer");
 const hatch_flow_1 = require("../hatch/hatch-flow");
 const specialist_orchestrator_1 = require("../hatch/specialist-orchestrator");
@@ -144,6 +145,29 @@ function defaultReadRecentDaemonLogLines(lines = 10) {
     }
     return recentLines.slice(-lines).map((line) => (0, log_tailer_1.formatLogLine)(line));
 }
+/* v8 ignore start -- CLI npm registry fetch wrapper: integration code @preserve */
+async function defaultFetchCliRegistryJson(timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    try {
+        const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli", {
+            signal: controller.signal,
+        });
+        return res.json();
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`update check timed out after ${Math.max(1, Math.round(timeoutMs / 1000))}s`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/* v8 ignore stop */
 function defaultSleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -501,6 +525,7 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         readRecentDaemonLogLines: defaultReadRecentDaemonLogLines,
         sleep: defaultSleep,
         now: () => Date.now(),
+        updateCheckTimeoutMs: update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS,
         startupPollIntervalMs: 250,
         startupStabilityWindowMs: 1_500,
         startupTimeoutMs: 10_000,
@@ -540,10 +565,7 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         checkForCliUpdate: async () => {
             const { checkForUpdate } = await Promise.resolve().then(() => __importStar(require("../versioning/update-checker")));
             return checkForUpdate((0, bundle_manifest_1.getPackageVersion)(), {
-                fetchRegistryJson: async () => {
-                    const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli");
-                    return res.json();
-                },
+                fetchRegistryJson: () => defaultFetchCliRegistryJson(update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS),
                 distTag: "latest",
             });
         },

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

@@ -76,6 +76,7 @@ const provider_state_1 = require("../provider-state");
 const machine_identity_1 = require("../machine-identity");
 const provider_models_1 = require("../provider-models");
 const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
+const update_checker_1 = require("../versioning/update-checker");
 const sync_1 = require("../sync");
 const cli_parse_1 = require("./cli-parse");
 const cli_parse_2 = require("./cli-parse");
@@ -97,12 +98,62 @@ const up_progress_1 = require("./up-progress");
 const provider_ping_1 = require("../provider-ping");
 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_POLL_INTERVAL_MS = 500;
 const DEFAULT_DAEMON_STARTUP_STABILITY_WINDOW_MS = 1_500;
 const DEFAULT_DAEMON_STARTUP_RETRY_LIMIT = 1;
 const DEFAULT_DAEMON_STARTUP_LOG_LINES = 10;
+function summarizeCliUpdateCheckStatus(error, timedOut = false) {
+    const normalized = error.trim().toLowerCase();
+    if (timedOut || normalized.includes("timed out") || normalized.includes("abort")) {
+        return "skipped; registry did not answer";
+    }
+    if (normalized.includes("registry unavailable")) {
+        return "skipped; registry unavailable";
+    }
+    if (normalized.includes("network") ||
+        normalized.includes("fetch failed") ||
+        normalized.includes("enotfound") ||
+        normalized.includes("eai_again") ||
+        normalized.includes("econnreset")) {
+        return "skipped; registry unavailable";
+    }
+    return "skipped; update check unavailable";
+}
+async function runCliUpdateCheckWithTimeout(checkForCliUpdate, timeoutMs = update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const timeoutId = setTimeout(() => {
+            settled = true;
+            resolve({
+                timedOut: true,
+                result: {
+                    available: false,
+                    error: `update check timed out after ${Math.max(1, Math.round(timeoutMs / 1000))}s`,
+                },
+            });
+        }, timeoutMs);
+        /* v8 ignore start -- Promise-settlement wiring is exercised by command tests; v8 misses these callback lines @preserve */
+        void checkForCliUpdate()
+            .then((result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            resolve({ result, timedOut: false });
+        })
+            .catch((error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            reject(error);
+        });
+        /* v8 ignore stop */
+    });
+}
 async function checkAgentProviders(deps, agentsOverride, onProgress) {
     const agents = agentsOverride ?? await listCliAgents(deps);
     const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
@@ -386,6 +437,17 @@ function renderCommandBoard(deps, options) {
         sections: options.sections,
     }).trimEnd();
 }
+function writeConnectorIntro(deps, options) {
+    const text = ttyBoardEnabled(deps)
+        ? renderCommandBoard(deps, {
+            title: options.title,
+            subtitle: options.subtitle,
+            summary: options.summary,
+            sections: options.sections,
+        })
+        : options.fallbackLines.join("\n");
+    deps.writeStdout(text);
+}
 async function promptForNamedAgent(title, subtitle, agents, deps) {
     if (!deps.promptInput)
         throw new Error("agent selection requires interactive input");
@@ -566,8 +628,8 @@ async function ensureDaemonRunning(deps, options = {}) {
     };
     let lastPid = null;
     for (let attempt = 0; attempt <= retryLimit; attempt += 1) {
-        deps.reportDaemonStartupPhase?.("launching daemon process");
-        deps.reportDaemonStartupPhase?.("waiting for daemon socket");
+        deps.reportDaemonStartupPhase?.("starting a fresh background service");
+        deps.reportDaemonStartupPhase?.("waiting for the new background service to answer");
         deps.cleanupStaleSocket(deps.socketPath);
         const bootStartedAtMs = (deps.now ?? Date.now)();
         const started = await deps.startDaemonProcess(deps.socketPath);
@@ -605,7 +667,7 @@ async function ensureDaemonRunning(deps, options = {}) {
         if (!startupFailure.retryable || attempt >= retryLimit) {
             break;
         }
-        deps.reportDaemonStartupPhase?.("daemon startup lost stability; retrying once");
+        deps.reportDaemonStartupPhase?.("background service startup went sideways once; trying one more time");
     }
     return {
         alreadyRunning: false,
@@ -1427,14 +1489,17 @@ const DEFAULT_DAEMON_STATUS_TIMEOUT_MS = 4_000;
 const DEFAULT_AGENT_RESTART_TIMEOUT_MS = 8_000;
 const CONNECT_PROVIDER_CHOICES = ["openai-codex", "anthropic", "minimax", "azure", "github-copilot"];
 function hasRuntimeConfigValue(config, key) {
+    return readRuntimeConfigString(config, key) !== null;
+}
+function readRuntimeConfigString(config, key) {
     const segments = key.split(".");
     let cursor = config;
     for (const segment of segments) {
         if (!cursor || typeof cursor !== "object" || Array.isArray(cursor))
-            return false;
+            return null;
         cursor = cursor[segment];
     }
-    return typeof cursor === "string" && cursor.trim().length > 0;
+    return typeof cursor === "string" && cursor.trim().length > 0 ? cursor : null;
 }
 function runtimeConfigReadStatus(runtime) {
     if (runtime.reason === "missing")
@@ -1514,46 +1579,47 @@ function readRuntimeApplyWorker(payload, agent) {
 }
 async function applyRuntimeChangeToRunningAgent(agent, deps, onProgress) {
     try {
-        onProgress?.("checking daemon socket");
+        onProgress?.("checking whether Ouro is already running");
         const alive = await deps.checkSocketAlive(deps.socketPath);
         if (!alive)
             return "daemon is not running; next `ouro up` will load the change";
-        onProgress?.("requesting restart from daemon");
+        onProgress?.(`asking Ouro to reload ${agent}`);
         const response = await withCliTimeout(DEFAULT_AGENT_RESTART_TIMEOUT_MS, "daemon restart request timed out", () => deps.sendCommand(deps.socketPath, { kind: "agent.restart", agent }));
         if (!response.ok)
             return `daemon restart skipped: ${response.error ?? response.message ?? "unknown daemon error"}`;
         const deadline = cliNowMs(deps) + DEFAULT_RUNTIME_APPLY_TIMEOUT_MS;
-        onProgress?.(`waiting for ${agent} to report running state`);
+        onProgress?.(`waiting for ${agent} to come back\n- reload request accepted`);
         while (cliNowMs(deps) < deadline) {
             try {
                 const statusResponse = await withCliTimeout(DEFAULT_DAEMON_STATUS_TIMEOUT_MS, "daemon status timed out", () => deps.sendCommand(deps.socketPath, { kind: "daemon.status" }));
                 if (statusResponse.ok) {
                     const payload = (0, cli_render_1.parseStatusPayload)(statusResponse.data);
                     if (!payload) {
-                        onProgress?.("daemon status did not include structured worker state");
+                        onProgress?.("waiting for Ouro to confirm the reload\n- daemon status did not include structured worker state");
                         return "restart requested; daemon status is unavailable, so verify with `ouro status` if needed";
                     }
                     const worker = readRuntimeApplyWorker(payload, agent);
                     if (!worker) {
-                        onProgress?.(`still waiting: ${agent} is not listed by daemon`);
+                        onProgress?.(`waiting for ${agent} to come back\n- ${agent} is not listed by daemon yet`);
                     }
                     else if (worker.status === "running") {
-                        onProgress?.(`daemon reports ${agent}/${worker.worker} running`);
+                        onProgress?.(`waiting for ${agent} to come back\n- daemon reports ${agent}/${worker.worker} running`);
                         return `restarted ${agent} and the daemon reports it running`;
                     }
                     else if (worker.status === "crashed") {
+                        onProgress?.(`waiting for ${agent} to come back\n- daemon reports ${agent}/${worker.worker} crashed`);
                         return `restart requested, but ${agent}/${worker.worker} crashed before reporting running${worker.errorReason ? `: ${worker.errorReason}` : worker.fixHint ? `: ${worker.fixHint}` : ""}`;
                     }
                     else {
-                        onProgress?.(`still waiting: ${agent}/${worker.worker} is ${worker.status}`);
+                        onProgress?.(`waiting for ${agent} to come back\n- current worker state: ${worker.status}`);
                     }
                 }
                 else {
-                    onProgress?.(`still waiting: daemon status returned ${statusResponse.error ?? statusResponse.message ?? "unknown error"}`);
+                    onProgress?.(`waiting for ${agent} to come back\n- latest status check: ${statusResponse.error ?? statusResponse.message ?? "unknown error"}`);
                 }
             }
             catch (error) {
-                onProgress?.(`still waiting: ${error instanceof Error ? error.message : String(error)}`);
+                onProgress?.(`waiting for ${agent} to come back\n- latest status check: ${error instanceof Error ? error.message : String(error)}`);
             }
             if (cliNowMs(deps) >= deadline - DEFAULT_RUNTIME_APPLY_POLL_INTERVAL_MS)
                 break;
@@ -1730,12 +1796,44 @@ async function buildConnectMenu(agent, deps, onProgress) {
     onProgress?.("loading this machine's settings");
     const machineRuntime = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agent, currentMachineId(deps), { preserveCachedOnFailure: true });
     const { teamsEnabled, blueBubblesEnabled } = readConnectBaySenseFlags(agent, deps);
-    const perplexityStatus = runtimeConfig.ok
-        ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.perplexityApiKey") ? "ready" : "missing"
-        : runtimeConfigReadStatus(runtimeConfig);
-    const embeddingsStatus = runtimeConfig.ok
-        ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.openaiEmbeddingsApiKey") ? "ready" : "missing"
-        : runtimeConfigReadStatus(runtimeConfig);
+    let perplexityStatus;
+    let perplexityDetailLines;
+    const perplexityApiKey = runtimeConfig.ok
+        ? readRuntimeConfigString(runtimeConfig.config, "integrations.perplexityApiKey")
+        : null;
+    if (!runtimeConfig.ok) {
+        perplexityStatus = runtimeConfigReadStatus(runtimeConfig);
+        perplexityDetailLines = [];
+    }
+    else if (!perplexityApiKey) {
+        perplexityStatus = "missing";
+        perplexityDetailLines = ["no API key saved yet"];
+    }
+    else {
+        onProgress?.("verifying Perplexity search");
+        const verification = await (0, runtime_capability_check_1.verifyPerplexityCapability)(perplexityApiKey);
+        perplexityStatus = verification.ok ? "ready" : "needs attention";
+        perplexityDetailLines = [verification.ok ? "verified live just now" : `live check failed: ${verification.summary}`];
+    }
+    let embeddingsStatus;
+    let embeddingsDetailLines;
+    const embeddingsApiKey = runtimeConfig.ok
+        ? readRuntimeConfigString(runtimeConfig.config, "integrations.openaiEmbeddingsApiKey")
+        : null;
+    if (!runtimeConfig.ok) {
+        embeddingsStatus = runtimeConfigReadStatus(runtimeConfig);
+        embeddingsDetailLines = [];
+    }
+    else if (!embeddingsApiKey) {
+        embeddingsStatus = "missing";
+        embeddingsDetailLines = ["no API key saved yet"];
+    }
+    else {
+        onProgress?.("verifying memory embeddings");
+        const verification = await (0, runtime_capability_check_1.verifyEmbeddingsCapability)(embeddingsApiKey);
+        embeddingsStatus = verification.ok ? "ready" : "needs attention";
+        embeddingsDetailLines = [verification.ok ? "verified live just now" : `live check failed: ${verification.summary}`];
+    }
     const teamsStatus = runtimeConfig.ok
         ? hasRuntimeConfigValue(runtimeConfig.config, "teams.clientId")
             && hasRuntimeConfigValue(runtimeConfig.config, "teams.clientSecret")
@@ -1768,6 +1866,7 @@ async function buildConnectMenu(agent, deps, onProgress) {
             section: "Portable",
             status: perplexityStatus,
             description: "Web search via Perplexity.",
+            detailLines: perplexityDetailLines,
             nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
                 option: "2",
                 name: "Perplexity search",
@@ -1781,6 +1880,7 @@ async function buildConnectMenu(agent, deps, onProgress) {
             section: "Portable",
             status: embeddingsStatus,
             description: "Memory retrieval and note search.",
+            detailLines: embeddingsDetailLines,
             nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
                 option: "3",
                 name: "Memory embeddings",
@@ -1828,16 +1928,44 @@ async function executeConnectPerplexity(agent, deps) {
         throw new Error("SerpentGuide has no persistent runtime credentials. Connect Perplexity on the hatchling agent instead.");
     }
     const promptSecret = requirePromptSecret(deps, "Perplexity API key entry");
-    deps.writeStdout([
-        `Connect Perplexity for ${agent}`,
-        "The API key stays hidden while you type.",
-        `Ouro stores it in ${agent}'s vault runtime/config item.`,
-    ].join("\n"));
+    writeConnectorIntro(deps, {
+        title: "Connect Perplexity",
+        subtitle: `${agent} gets portable web search.`,
+        summary: "Add one hidden API key, verify it live, and make web search travel with this agent.",
+        sections: [
+            {
+                title: "Unlocks",
+                lines: [
+                    "Portable web search inside Ouro.",
+                ],
+            },
+            {
+                title: "What you need",
+                lines: [
+                    "One Perplexity API key.",
+                    "It stays hidden while you type.",
+                ],
+            },
+            {
+                title: "Where it lives",
+                lines: [
+                    `${agent}'s vault runtime/config item.`,
+                    "It travels with the agent across machines.",
+                ],
+            },
+        ],
+        fallbackLines: [
+            `Connect Perplexity for ${agent}`,
+            "The API key stays hidden while you type.",
+            `Ouro stores it in ${agent}'s vault runtime/config item.`,
+        ],
+    });
     const key = (await promptSecret("Perplexity API key: ")).trim();
     if (!key)
         throw new Error("Perplexity API key cannot be blank");
     const progress = createHumanCommandProgress(deps, "connect perplexity");
     let stored;
+    let verification;
     let reload;
     try {
         stored = await runCommandProgressPhase(progress, "saving Perplexity search", () => storeRuntimeConfigKey({
@@ -1848,6 +1976,23 @@ async function executeConnectPerplexity(agent, deps) {
             deps,
             onProgress: (message) => progress.updateDetail(message),
         }), () => "secret stored");
+        progress.startPhase("verifying Perplexity search");
+        verification = await (0, runtime_capability_check_1.verifyPerplexityCapability)(key);
+        if (!verification.ok) {
+            progress.failPhase("verifying Perplexity search", verification.summary);
+            progress.end();
+            const message = [
+                `Perplexity key was saved for ${agent}, but the live check failed.`,
+                `stored: ${stored.itemPath}`,
+                `live check: ${verification.summary}`,
+                "secret was not printed",
+                "",
+                `Next: rerun \`ouro connect perplexity --agent ${agent}\` with a working key.`,
+            ].join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        progress.completePhase("verifying Perplexity search", verification.summary);
         reload = await runCommandProgressPhase(progress, `applying change to running ${agent}`, () => applyRuntimeChangeToRunningAgent(agent, deps, (message) => progress.updateDetail(message)), (result) => result);
     }
     finally {
@@ -1870,16 +2015,44 @@ async function executeConnectEmbeddings(agent, deps) {
         throw new Error("SerpentGuide has no persistent runtime credentials. Connect embeddings on the hatchling agent instead.");
     }
     const promptSecret = requirePromptSecret(deps, "OpenAI embeddings API key entry");
-    deps.writeStdout([
-        `Connect embeddings for ${agent}`,
-        "The API key stays hidden while you type.",
-        `Ouro stores it in ${agent}'s vault runtime/config item.`,
-    ].join("\n"));
+    writeConnectorIntro(deps, {
+        title: "Connect Embeddings",
+        subtitle: `${agent} gets portable note and memory search.`,
+        summary: "Add one hidden API key, verify it live, and let semantic memory travel with this agent.",
+        sections: [
+            {
+                title: "Unlocks",
+                lines: [
+                    "Portable note search and memory retrieval.",
+                ],
+            },
+            {
+                title: "What you need",
+                lines: [
+                    "One OpenAI embeddings API key.",
+                    "It stays hidden while you type.",
+                ],
+            },
+            {
+                title: "Where it lives",
+                lines: [
+                    `${agent}'s vault runtime/config item.`,
+                    "It travels with the agent across machines.",
+                ],
+            },
+        ],
+        fallbackLines: [
+            `Connect embeddings for ${agent}`,
+            "The API key stays hidden while you type.",
+            `Ouro stores it in ${agent}'s vault runtime/config item.`,
+        ],
+    });
     const key = (await promptSecret("OpenAI embeddings API key: ")).trim();
     if (!key)
         throw new Error("OpenAI embeddings API key cannot be blank");
     const progress = createHumanCommandProgress(deps, "connect embeddings");
     let stored;
+    let verification;
     let reload;
     try {
         stored = await runCommandProgressPhase(progress, "saving memory embeddings", () => storeRuntimeConfigKey({
@@ -1890,6 +2063,23 @@ async function executeConnectEmbeddings(agent, deps) {
             deps,
             onProgress: (message) => progress.updateDetail(message),
         }), () => "secret stored");
+        progress.startPhase("verifying memory embeddings");
+        verification = await (0, runtime_capability_check_1.verifyEmbeddingsCapability)(key);
+        if (!verification.ok) {
+            progress.failPhase("verifying memory embeddings", verification.summary);
+            progress.end();
+            const message = [
+                `Embeddings key was saved for ${agent}, but the live check failed.`,
+                `stored: ${stored.itemPath}`,
+                `live check: ${verification.summary}`,
+                "secret was not printed",
+                "",
+                `Next: rerun \`ouro connect embeddings --agent ${agent}\` with a working key.`,
+            ].join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        progress.completePhase("verifying memory embeddings", verification.summary);
         reload = await runCommandProgressPhase(progress, `applying change to running ${agent}`, () => applyRuntimeChangeToRunningAgent(agent, deps, (message) => progress.updateDetail(message)), (result) => result);
     }
     finally {
@@ -3450,9 +3640,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         // ── versioned CLI update check ──
         if (deps.checkForCliUpdate) {
             progress.startPhase("update check");
+            progress.updateDetail("checking npm registry\ncontinuing startup if it stays quiet");
             let pendingReExec = false;
+            let updateCheckStatus = "up to date";
             try {
-                const updateResult = await deps.checkForCliUpdate();
+                const { result: updateResult, timedOut } = await runCliUpdateCheckWithTimeout(deps.checkForCliUpdate, deps.updateCheckTimeoutMs ?? update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS);
                 if (updateResult.available && updateResult.latestVersion) {
                     /* v8 ignore next -- fallback: getCurrentCliVersion always injected in tests @preserve */
                     const currentVersion = linkedVersionBeforeUp ?? "unknown";
@@ -3466,9 +3658,13 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                     }
                     pendingReExec = true;
                 }
+                else if (updateResult.error) {
+                    updateCheckStatus = summarizeCliUpdateCheckStatus(updateResult.error, timedOut);
+                }
                 /* v8 ignore start -- update check error: tested via daemon-cli-update-flow.test.ts @preserve */
             }
             catch (error) {
+                updateCheckStatus = summarizeCliUpdateCheckStatus(error instanceof Error ? error.message : String(error));
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
                     component: "daemon",
@@ -3483,7 +3679,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 deps.reExecFromNewVersion(args);
             }
             else {
-                progress.completePhase("update check", "up to date");
+                progress.completePhase("update check", updateCheckStatus);
             }
         }
         progress.startPhase("system setup");
@@ -3888,16 +4084,16 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         const sections = [localSection];
         if (deps.checkForCliUpdate) {
             try {
-                const updateResult = await deps.checkForCliUpdate();
+                const { result: updateResult, timedOut } = await runCliUpdateCheckWithTimeout(deps.checkForCliUpdate, deps.updateCheckTimeoutMs ?? update_checker_1.CLI_UPDATE_CHECK_TIMEOUT_MS);
                 if (updateResult.latestVersion) {
                     sections.push(`published latest: ${updateResult.latestVersion} (${updateResult.available ? "update available" : "up to date"})`);
                 }
                 else if (updateResult.error) {
-                    sections.push(`published latest: unavailable (${updateResult.error})`);
+                    sections.push(`published latest: unavailable (${summarizeCliUpdateCheckStatus(updateResult.error, timedOut)})`);
                 }
             }
             catch (err) {
-                const reason = err instanceof Error ? err.message : String(err);
+                const reason = summarizeCliUpdateCheckStatus(err instanceof Error ? err.message : String(err));
                 sections.push(`published latest: unavailable (${reason})`);
             }
         }

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

@@ -9,7 +9,7 @@ async function verifyDaemonStarted(deps) {
     const maxWaitMs = 10_000;
     const pollIntervalMs = 500;
     const deadline = Date.now() + maxWaitMs;
-    deps.onProgress?.("waiting for the new background service to answer");
+    deps.onProgress?.("waiting for the replacement background service to answer");
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, pollIntervalMs));
         if (await deps.checkSocketAlive(deps.socketPath))
@@ -88,7 +88,7 @@ function formatRuntimeDriftPublicSummary(reasons) {
     return reasons.map((reason) => reason.label).join(", ");
 }
 async function ensureCurrentDaemonRuntime(deps) {
-    deps.onProgress?.("checking the running background service");
+    deps.onProgress?.("checking whether an older background service is already running");
     const localRuntime = normalizeRuntimeIdentity({
         version: deps.localVersion,
         lastUpdated: deps.localLastUpdated,
@@ -105,7 +105,7 @@ async function ensureCurrentDaemonRuntime(deps) {
             const includesVersionDrift = driftReasons.some((entry) => entry.key === "version");
             const publicDriftSummary = formatRuntimeDriftPublicSummary(driftReasons);
             try {
-                deps.onProgress?.("stopping the old background service");
+                deps.onProgress?.("stopping the older background service");
                 await deps.stopDaemon();
             }
             catch (error) {
@@ -113,8 +113,8 @@ async function ensureCurrentDaemonRuntime(deps) {
                 result = {
                     alreadyRunning: true,
                     message: includesVersionDrift
-                        ? `daemon already running (${deps.socketPath}; could not replace the running background service ${runningVersion} -> ${deps.localVersion}: ${reason})`
-                        : `daemon already running (${deps.socketPath}; could not replace the running background service after runtime drift ${publicDriftSummary}: ${reason})`,
+                        ? `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})`,
                 };
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
@@ -141,7 +141,7 @@ async function ensureCurrentDaemonRuntime(deps) {
                 return result;
             }
             deps.cleanupStaleSocket(deps.socketPath);
-            deps.onProgress?.("starting the new background service");
+            deps.onProgress?.("starting the replacement background service");
             const started = await deps.startDaemonProcess(deps.socketPath);
             const pid = started.pid ?? "unknown";
             const verified = await verifyDaemonStarted(deps);
@@ -150,8 +150,8 @@ async function ensureCurrentDaemonRuntime(deps) {
             result = {
                 alreadyRunning: false,
                 message: includesVersionDrift
-                    ? `replaced the running background service ${runningVersion} -> ${deps.localVersion} (pid ${pid})${suffix}`
-                    : `replaced the running background service after runtime drift: ${publicDriftSummary} (pid ${pid})${suffix}`,
+                    ? `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,
             };

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

@@ -93,10 +93,11 @@ function renderWaitingForDaemon(elapsed, latestEvent, prevLineCount = 0, options
     const spinner = SPINNER_FRAMES[frameIndex];
     const lines = [];
     lines.push(isTTY
-        ? `${spinner} ${BOLD}waiting for daemon${RESET} ${DIM}(${elapsedSec}s)${RESET}`
-        : `${spinner} waiting for daemon (${elapsedSec}s)`);
+        ? `${spinner} ${BOLD}starting background service${RESET} ${DIM}(${elapsedSec}s)${RESET}`
+        : `${spinner} starting background service (${elapsedSec}s)`);
     if (latestEvent) {
-        lines.push(isTTY ? `  ${DIM}${latestEvent}${RESET}` : `  ${latestEvent}`);
+        const detail = `latest daemon event: ${latestEvent}`;
+        lines.push(isTTY ? `  ${DIM}${detail}${RESET}` : `  ${detail}`);
     }
     return renderStartupLines(lines, prevLineCount, isTTY);
 }
@@ -182,7 +183,10 @@ async function pollDaemonStartup(deps) {
             }
             // Show what the daemon is doing from its log
             const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
-            reportProgress(latestEvent ?? "waiting for daemon");
+            reportProgress([
+                "waiting for Ouro to answer",
+                latestEvent ? `- latest daemon event: ${latestEvent}` : "- background service is still starting",
+            ].join("\n"));
             if (shouldRender) {
                 const output = renderWaitingForDaemon(elapsed, latestEvent, prevLineCount, { isTTY });
                 deps.writeRaw(output);
@@ -222,11 +226,20 @@ async function pollDaemonStartup(deps) {
         await deps.sleep(POLL_INTERVAL_MS);
     }
 }
+function formatStartupWorkerLine(payload) {
+    const base = `- ${payload.agent}/${payload.worker}: ${payload.status}`;
+    if (payload.status === "crashed" && payload.errorReason) {
+        return `${base} (${payload.errorReason})`;
+    }
+    return base;
+}
 function formatStartupProgressDetail(payload) {
     if (payload.workers.length === 0)
-        return "daemon answered";
-    const workers = payload.workers.map((worker) => `${worker.agent}/${worker.worker} ${worker.status}`).join(", ");
-    return `waiting for agents: ${workers}`;
+        return "Ouro answered";
+    return [
+        "Ouro answered",
+        ...payload.workers.map((worker) => formatStartupWorkerLine(worker)),
+    ].join("\n");
 }
 function colorStatus(status) {
     const statusColor = status === "running" ? GREEN

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

@@ -21,6 +21,14 @@ const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const GREEN = "\x1b[38;2;46;204;64m";
 const RED = "\x1b[38;2;255;106;106m";
+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;
@@ -99,7 +107,9 @@ class UpProgress {
             this.flushRender();
             return;
         }
-        this.write(`    ${detail}\n`);
+        for (const line of splitDetailLines(detail)) {
+            this.write(`    ${line}\n`);
+        }
     }
     /**
      * Mark the current phase as done. In non-TTY mode, immediately writes
@@ -198,8 +208,10 @@ class UpProgress {
             const elapsedSec = (elapsed / 1000).toFixed(1);
             const frameIndex = Math.floor(elapsed / 80) % SPINNER_FRAMES.length;
             const spinner = SPINNER_FRAMES[frameIndex];
-            const detailSuffix = this.currentPhase.detail ? ` \u2014 ${this.currentPhase.detail}` : "";
-            lines.push(`  ${BOLD}${spinner}${RESET} ${this.currentPhase.label} ${DIM}(${elapsedSec}s)${detailSuffix}${RESET}`);
+            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}`);
+            }
         }
         let output = "";
         if (this.prevLineCount > 0) {