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

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

@@ -97,6 +97,7 @@ 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;
@@ -386,6 +387,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 +578,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 +617,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 +1439,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 +1529,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 +1746,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 +1816,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 +1830,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 +1878,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 +1926,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 +1965,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 +2013,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 {

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) {

package/dist/heart/runtime-capability-check.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPerplexityCapability = verifyPerplexityCapability;
+exports.verifyEmbeddingsCapability = verifyEmbeddingsCapability;
+const runtime_1 = require("../nerves/runtime");
+function sanitizeCapabilityError(message) {
+    const statusMatch = message.match(/^(\d{3})\s/);
+    if (!statusMatch)
+        return message;
+    const status = statusMatch[1];
+    const body = message.slice(status.length).trim();
+    if (body.startsWith("<") || body.includes("<!DOCTYPE") || body.includes("<html")) {
+        return `HTTP ${status}`;
+    }
+    if (body.startsWith("{")) {
+        try {
+            const json = JSON.parse(body);
+            const inner = json?.error?.message;
+            if (typeof inner === "string" && inner && inner !== "Error") {
+                return `${status} ${inner}`;
+            }
+        }
+        catch {
+            // Keep the HTTP status fallback below.
+        }
+        return `HTTP ${status}`;
+    }
+    return message;
+}
+async function readHttpFailureSummary(response) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    try {
+        const json = await response.json();
+        if (typeof json.error === "string" && json.error.trim()) {
+            detail = `${response.status} ${json.error}`;
+        }
+        else if (typeof json.error === "object" && json.error !== null) {
+            const errObj = json.error;
+            if (typeof errObj.message === "string" && errObj.message.trim()) {
+                detail = `${response.status} ${errObj.message}`;
+            }
+        }
+        else if (typeof json.message === "string" && json.message.trim()) {
+            detail = `${response.status} ${json.message}`;
+        }
+    }
+    catch {
+        // Keep the HTTP status summary if the body is not JSON.
+    }
+    return sanitizeCapabilityError(detail);
+}
+function reportRuntimeCapabilityCheckStart(capability, url) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_capability_check_start",
+        message: "starting runtime capability check",
+        meta: { capability, url },
+    });
+}
+function reportRuntimeCapabilityCheckEnd(capability, url) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_capability_check_end",
+        message: "runtime capability check passed",
+        meta: { capability, url },
+    });
+}
+function reportRuntimeCapabilityCheckError(capability, url, summary) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.runtime_capability_check_error",
+        message: "runtime capability check failed",
+        meta: { capability, url, summary },
+    });
+}
+async function verifyPerplexityCapability(apiKey, fetchImpl = fetch) {
+    const url = "https://api.perplexity.ai/search";
+    reportRuntimeCapabilityCheckStart("perplexity-search", url);
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: "ping",
+                max_results: 1,
+            }),
+        });
+        if (!response.ok) {
+            const summary = await readHttpFailureSummary(response);
+            reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload.results) || payload.results.length === 0) {
+            const summary = "Perplexity returned no search results";
+            reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        reportRuntimeCapabilityCheckEnd("perplexity-search", url);
+        return {
+            ok: true,
+            summary: "live check passed",
+        };
+    }
+    catch (error) {
+        const summary = sanitizeCapabilityError(error instanceof Error ? error.message : String(error));
+        reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+        return {
+            ok: false,
+            summary,
+        };
+    }
+}
+async function verifyEmbeddingsCapability(apiKey, fetchImpl = fetch) {
+    const url = "https://api.openai.com/v1/embeddings";
+    reportRuntimeCapabilityCheckStart("memory-embeddings", url);
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "text-embedding-3-small",
+                input: ["ping"],
+            }),
+        });
+        if (!response.ok) {
+            const summary = await readHttpFailureSummary(response);
+            reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload.data) || payload.data.length !== 1 || !Array.isArray(payload.data[0]?.embedding) || payload.data[0].embedding.length === 0) {
+            const summary = "embeddings response missing expected vectors";
+            reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        reportRuntimeCapabilityCheckEnd("memory-embeddings", url);
+        return {
+            ok: true,
+            summary: "live check passed",
+        };
+    }
+    catch (error) {
+        const summary = sanitizeCapabilityError(error instanceof Error ? error.message : String(error));
+        reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+        return {
+            ok: false,
+            summary,
+        };
+    }
+}