@ouro.bot/cli 0.1.0-alpha.426 → 0.1.0-alpha.428

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_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.428",
+      "changes": [
+        "Root `ouro connect` now renders through a dedicated width-aware connect-bay renderer with a framed header, one recommended next move, and separate `Provider core`, `Portable`, and `This machine` sections instead of flattening everything inside one long menu string.",
+        "The connect bay keeps using the same live provider verification truth path as `ouro up` and `ouro auth verify`, while tightening lane-specific status and next-action mapping so locked vaults, failed live checks, and missing setup each point at the right repair move.",
+        "Added direct connect-bay renderer coverage for wide, narrow, wrapping, lane-summary, and non-TTY branches, plus a nerves event so the new renderer stays under the same file-completeness and audit rules as the rest of the runtime.",
+        "Auth, cross-machine, and testing docs now describe the root connect surface as the framed responsive bay it really is, and `@ouro.bot/cli` plus the `ouro.bot` wrapper are version-synced for the connect-bay polish release."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.427",
+      "changes": [
+        "Root `ouro connect` now runs the same shared live provider verification path as `ouro up` and `ouro auth verify` before it renders the connect bay, so freshly authed providers and failed live checks show their real current state.",
+        "The root connect bay now groups capabilities into a clearer `Next best move`, `Provider core`, `Portable`, and `This machine` layout, with truthful lane-specific status for outward and inner providers.",
+        "Shared provider health checks now refresh readiness for every selected provider/model pair instead of stopping after the first failure, and `ouro connect` keeps working when provider selection is missing so repair guidance can still render.",
+        "Auth/provider/testing docs now describe the live-verifying connect bay behavior, and `@ouro.bot/cli` plus the `ouro.bot` wrapper are version-synced for the truthful connect release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.426",
       "changes": [

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

@@ -378,7 +378,9 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             });
         }
     }
+    let firstFailure = null;
     for (const group of pingGroups.values()) {
+        deps.onProgress?.(`checking ${group.provider} / ${group.model}...`);
         const result = await ping(group.provider, providerCredentialConfig(group.record), { model: group.model });
         if (!result.ok) {
             for (const lane of group.lanes) {
@@ -392,7 +394,8 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
                     attempts: pingAttemptCount(result),
                 });
             }
-            return failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            continue;
         }
         for (const lane of group.lanes) {
             writeLaneReadiness({
@@ -405,6 +408,8 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             });
         }
     }
+    if (firstFailure)
+        return firstFailure;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",

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

@@ -93,6 +93,7 @@ const stale_bundle_prune_1 = require("./stale-bundle-prune");
 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");
 // ── ensureDaemonRunning ──
 const DEFAULT_DAEMON_STARTUP_TIMEOUT_MS = 10_000;
 const DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS = 500;
@@ -1625,29 +1626,43 @@ function enableAgentSense(agent, sense, deps) {
     };
     fs.writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
+const CONNECT_MENU_PROMPT = "Choose [1-6] or type a name: ";
+function connectMenuIsTTY(deps) {
+    return deps.isTTY ?? process.stdout.isTTY === true;
+}
+function readConnectBaySenseFlags(agent, deps) {
+    const configPath = path.join(providerCliAgentRoot({ agent }, deps), "agent.json");
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return {
+        teamsEnabled: parsed.senses?.teams?.enabled === true,
+        blueBubblesEnabled: parsed.senses?.bluebubbles?.enabled === true,
+    };
+}
 async function buildConnectMenu(agent, deps, onProgress) {
+    const bundlesRoot = path.dirname(providerCliAgentRoot({ agent }, deps));
+    let providerHealth;
+    try {
+        onProgress?.("checking selected providers");
+        providerHealth = await checkAgentProviderHealth(agent, bundlesRoot, deps, onProgress);
+    }
+    catch (error) {
+        providerHealth = {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            fix: `Run 'ouro auth verify --agent ${agent}' to inspect provider health.`,
+        };
+    }
     const providerVisibility = (0, provider_visibility_1.buildAgentProviderVisibility)({
         agentName: agent,
         agentRoot: providerCliAgentRoot({ agent }, deps),
         homeDir: providerCliHomeDir(deps),
     });
-    const providerStatus = providerVisibility.lanes.some((lane) => lane.status === "unconfigured")
-        ? "needs setup"
-        : providerVisibility.lanes.some((lane) => lane.status === "configured" && lane.credential.status !== "present")
-            ? "needs auth"
-            : providerVisibility.lanes.some((lane) => lane.status === "configured" && (lane.readiness.status === "failed" || lane.readiness.status === "stale"))
-                ? "needs attention"
-                : "ready";
-    const providerDetail = providerVisibility.lanes.map((lane) => lane.status === "configured"
-        ? `${lane.lane}: ${lane.provider} / ${lane.model}`
-        : `${lane.lane}: choose provider/model`).join(" | ");
+    const providerSummary = (0, connect_bay_1.summarizeProvidersForConnect)(agent, providerVisibility, providerHealth);
     onProgress?.("loading portable settings");
     const runtimeConfig = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agent, { preserveCachedOnFailure: true });
     onProgress?.("loading this machine's settings");
     const machineRuntime = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agent, currentMachineId(deps), { preserveCachedOnFailure: true });
-    const agentConfig = (0, auth_flow_1.readAgentConfigForAgent)(agent, deps.bundlesRoot).config;
-    const teamsEnabled = agentConfig.senses?.teams?.enabled === true;
-    const blueBubblesEnabled = agentConfig.senses?.bluebubbles?.enabled === true;
+    const { teamsEnabled, blueBubblesEnabled } = readConnectBaySenseFlags(agent, deps);
     const perplexityStatus = runtimeConfig.ok
         ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.perplexityApiKey") ? "ready" : "missing"
         : runtimeConfigReadStatus(runtimeConfig);
@@ -1669,29 +1684,77 @@ async function buildConnectMenu(agent, deps, onProgress) {
             ? "attached"
             : "not attached"
         : machineRuntimeReadStatus(machineRuntime);
-    return [
-        `${agent} // connect bay`,
-        "Bring one capability online at a time.",
-        "",
-        `  1. [${providerStatus}] Providers`,
-        `     ${providerDetail}`,
-        "",
-        `  2. [${perplexityStatus}] Perplexity search`,
-        "     Portable. Web search via Perplexity.",
-        "",
-        `  3. [${embeddingsStatus}] Memory embeddings`,
-        "     Portable. Memory retrieval and note search.",
-        "",
-        `  4. [${teamsStatus}] Teams`,
-        "     Portable. Microsoft Teams sense credentials.",
-        "",
-        `  5. [${blueBubblesStatus}] BlueBubbles iMessage`,
-        "     This machine only. Local Mac Messages bridge.",
-        "",
-        "  6. Cancel",
-        "",
-        "Choose [1-6] or type a name: ",
-    ].join("\n");
+    const entries = [
+        {
+            option: "1",
+            name: "Providers",
+            section: "Provider core",
+            status: providerSummary.status,
+            detailLines: providerSummary.detailLines,
+            laneSummaries: providerSummary.laneSummaries,
+            nextAction: providerSummary.nextAction,
+            nextNote: providerSummary.nextNote,
+        },
+        {
+            option: "2",
+            name: "Perplexity search",
+            section: "Portable",
+            status: perplexityStatus,
+            description: "Web search via Perplexity.",
+            nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
+                option: "2",
+                name: "Perplexity search",
+                section: "Portable",
+                status: perplexityStatus,
+            }) ? `ouro connect perplexity --agent ${agent}` : undefined,
+        },
+        {
+            option: "3",
+            name: "Memory embeddings",
+            section: "Portable",
+            status: embeddingsStatus,
+            description: "Memory retrieval and note search.",
+            nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
+                option: "3",
+                name: "Memory embeddings",
+                section: "Portable",
+                status: embeddingsStatus,
+            }) ? `ouro connect embeddings --agent ${agent}` : undefined,
+        },
+        {
+            option: "4",
+            name: "Teams",
+            section: "Portable",
+            status: teamsStatus,
+            description: "Microsoft Teams sense credentials.",
+            nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
+                option: "4",
+                name: "Teams",
+                section: "Portable",
+                status: teamsStatus,
+            }) ? `ouro connect teams --agent ${agent}` : undefined,
+        },
+        {
+            option: "5",
+            name: "BlueBubbles iMessage",
+            section: "This machine",
+            status: blueBubblesStatus,
+            description: "Local Mac Messages bridge.",
+            nextAction: (0, connect_bay_1.connectEntryNeedsAttention)({
+                option: "5",
+                name: "BlueBubbles iMessage",
+                section: "This machine",
+                status: blueBubblesStatus,
+            }) ? `ouro connect bluebubbles --agent ${agent}` : undefined,
+        },
+    ];
+    const isTTY = connectMenuIsTTY(deps);
+    return (0, connect_bay_1.renderConnectBay)(entries, {
+        agent,
+        isTTY,
+        columns: deps.stdoutColumns ?? process.stdout.columns,
+        prompt: CONNECT_MENU_PROMPT,
+    });
 }
 async function executeConnectPerplexity(agent, deps) {
     if (agent === "SerpentGuide") {

package/dist/heart/daemon/connect-bay.js

@@ -0,0 +1,428 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeProviderLane = summarizeProviderLane;
+exports.summarizeProvidersForConnect = summarizeProvidersForConnect;
+exports.connectEntryNeedsAttention = connectEntryNeedsAttention;
+exports.renderConnectBay = renderConnectBay;
+const runtime_1 = require("../../nerves/runtime");
+const CONNECT_STATUS_PRIORITY = {
+    "needs attention": 0,
+    locked: 1,
+    "needs credentials": 2,
+    "needs setup": 3,
+    missing: 4,
+    "not attached": 5,
+    ready: 6,
+    attached: 6,
+};
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const TEAL = "\x1b[38;2;78;201;176m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const GOLD = "\x1b[38;2;230;190;50m";
+const BONE = "\x1b[38;2;238;242;234m";
+const MIST = "\x1b[38;2;165;184;168m";
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, "");
+}
+function visibleLength(text) {
+    return stripAnsi(text).length;
+}
+function padAnsi(text, width) {
+    const missing = Math.max(0, width - visibleLength(text));
+    return `${text}${" ".repeat(missing)}`;
+}
+function wrapPlain(text, width) {
+    const normalized = text.trim();
+    if (!normalized)
+        return [""];
+    const words = normalized.split(/\s+/);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if (!current) {
+            current = word;
+            continue;
+        }
+        const candidate = `${current} ${word}`;
+        if (candidate.length <= width) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current);
+        current = word;
+    }
+    lines.push(current);
+    return lines;
+}
+function tty(text, color, bold = false) {
+    if (bold)
+        return `${color}${BOLD}${text}${RESET}`;
+    return `${color}${text}${RESET}`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cleanExtractedCommand(command) {
+    const cleaned = command?.trim().replace(/[`'",;:.)]+$/g, "").trim();
+    return cleaned && cleaned.length > 0 ? cleaned : undefined;
+}
+function extractCommand(fixHint, commandPrefix) {
+    const escapedPrefix = escapeRegExp(commandPrefix);
+    const commandBody = `${escapedPrefix}(?=\\s|$)[^\`'"]*`;
+    const quoted = fixHint.match(new RegExp(`[\`'"](${commandBody})[\`'"]`, "i"))?.[1];
+    const unquoted = fixHint.match(new RegExp(`(${escapedPrefix}(?=\\s|$)[^\\n,;.]+)`, "i"))?.[1];
+    return cleanExtractedCommand(quoted) ?? cleanExtractedCommand(unquoted);
+}
+function resolveProviderHealthStatus(providerHealth) {
+    if (!providerHealth || providerHealth.ok)
+        return undefined;
+    const error = String(providerHealth.error).toLowerCase();
+    const fix = String(providerHealth.fix).toLowerCase();
+    if (error.includes("failed live check"))
+        return "needs attention";
+    if (error.includes("has no credentials"))
+        return "needs credentials";
+    if (error.includes("missing") && error.includes("provider"))
+        return "needs setup";
+    if (error.includes("vault is locked") || error.includes("vault locked"))
+        return "locked";
+    if (fix.includes("ouro auth verify"))
+        return "needs attention";
+    if (fix.includes("ouro auth"))
+        return "needs credentials";
+    if (fix.includes("ouro use"))
+        return "needs setup";
+    if (fix.includes("vault unlock"))
+        return "locked";
+    return "needs attention";
+}
+function resolveProviderHealthCommand(fixHint, status) {
+    if (!fixHint)
+        return undefined;
+    const prefixes = status === "locked"
+        ? ["ouro vault unlock", "ouro vault replace", "ouro vault recover"]
+        : status === "needs credentials"
+            ? ["ouro auth", "ouro connect", "ouro provider refresh", "ouro up"]
+            : status === "needs setup"
+                ? ["ouro use", "ouro connect", "ouro auth", "ouro up"]
+                : ["ouro auth verify", "ouro auth", "ouro provider refresh", "ouro use", "ouro connect", "ouro vault unlock", "ouro up"];
+    for (const prefix of prefixes) {
+        const command = extractCommand(fixHint, prefix);
+        if (command)
+            return command;
+    }
+    return undefined;
+}
+function isProblemStatus(status) {
+    return status !== "ready" && status !== "attached";
+}
+function statusChip(status) {
+    const symbol = status === "ready" || status === "attached"
+        ? "●"
+        : status === "not attached"
+            ? "◌"
+            : "◆";
+    const label = `${symbol} ${status}`;
+    if (status === "ready" || status === "attached")
+        return tty(label, GREEN, true);
+    if (status === "not attached")
+        return tty(label, MIST);
+    return tty(label, GOLD, true);
+}
+function sectionTitle(title, width) {
+    const plain = `╭─ ${title} `;
+    const rule = "─".repeat(Math.max(0, width - plain.length - 1));
+    return `${tty("╭─ ", TEAL)}${tty(title, BONE, true)}${tty(` ${rule}╮`, TEAL)}`;
+}
+function bottomRule(width) {
+    const line = `╰${"─".repeat(Math.max(0, width - 2))}╯`;
+    return tty(line, TEAL);
+}
+function bodyLine(text, width) {
+    const padded = padAnsi(text, Math.max(0, width - 4));
+    return `${tty("│ ", TEAL)}${padded}${tty(" │", TEAL)}`;
+}
+function panel(title, body, width) {
+    const lines = [sectionTitle(title, width)];
+    for (const line of body) {
+        lines.push(bodyLine(line, width));
+    }
+    lines.push(bottomRule(width));
+    return lines;
+}
+function renderHeader(agent, width) {
+    return panel(`${agent} connect bay`, [
+        tty("Bring one capability online.", BONE, true),
+        tty("Everything on this screen was checked live just now.", MIST),
+    ], width);
+}
+function nextMoveBody(entry) {
+    if (!entry) {
+        return [
+            tty("Everything here is ready.", BONE, true),
+            tty("Pick what you want to review or refresh.", MIST),
+        ];
+    }
+    const lines = [
+        `${entry.name}  ${statusChip(entry.status)}`,
+    ];
+    if (entry.nextNote)
+        lines.push(entry.nextNote);
+    if (entry.nextAction)
+        lines.push(tty(entry.nextAction, MIST));
+    return lines;
+}
+function renderProviderBody(entry, width) {
+    const lines = [
+        `${entry.option}  ${entry.name}  ${statusChip(entry.status)}`,
+    ];
+    const lanes = entry.laneSummaries ?? [];
+    for (const [index, lane] of lanes.entries()) {
+        if (index > 0)
+            lines.push("");
+        const laneLabel = lane.lane === "outward" ? "Outward lane" : "Inner lane";
+        lines.push(tty(laneLabel, BONE, true));
+        lines.push(lane.title);
+        lines.push(isProblemStatus(lane.status) ? lane.detail : tty(lane.detail, MIST));
+    }
+    if (lanes.length === 0) {
+        for (const detail of entry.detailLines ?? [])
+            lines.push(detail);
+    }
+    return normalizeWrappedBody(lines, width);
+}
+function renderCapabilityBody(entries, width) {
+    const lines = [];
+    for (const [index, entry] of entries.entries()) {
+        if (index > 0)
+            lines.push("");
+        lines.push(`${entry.option}  ${entry.name}  ${statusChip(entry.status)}`);
+        if (entry.description) {
+            lines.push(isProblemStatus(entry.status) ? entry.description : tty(entry.description, MIST));
+        }
+        for (const detail of entry.detailLines ?? []) {
+            lines.push(detail);
+        }
+    }
+    return normalizeWrappedBody(lines, width);
+}
+function normalizeWrappedBody(lines, width) {
+    const wrapped = [];
+    for (const line of lines) {
+        if (!line) {
+            wrapped.push("");
+            continue;
+        }
+        const plain = stripAnsi(line);
+        if (plain.length <= width - 4) {
+            wrapped.push(line);
+            continue;
+        }
+        const segments = wrapPlain(plain, width - 4);
+        wrapped.push(...segments);
+    }
+    return wrapped;
+}
+function stackPanels(panels) {
+    const lines = [];
+    for (const [index, panelLines] of panels.entries()) {
+        if (index > 0)
+            lines.push("");
+        lines.push(...panelLines);
+    }
+    return lines;
+}
+function combineColumns(left, right, leftWidth, rightWidth, gap = 2) {
+    const total = Math.max(left.length, right.length);
+    const lines = [];
+    for (let index = 0; index < total; index += 1) {
+        const leftLine = left[index] ?? " ".repeat(leftWidth);
+        const rightLine = right[index] ?? " ".repeat(rightWidth);
+        lines.push(`${padAnsi(leftLine, leftWidth)}${" ".repeat(gap)}${padAnsi(rightLine, rightWidth)}`);
+    }
+    return lines;
+}
+function renderTtyBay(entries, options) {
+    const columns = Math.max(options.columns ?? 108, 72);
+    const fullWidth = Math.max(56, columns - 2);
+    const header = renderHeader(options.agent, fullWidth);
+    const nextEntry = entries.find((entry) => isProblemStatus(entry.status));
+    const providerEntry = entries.find((entry) => entry.section === "Provider core");
+    const portableEntries = entries.filter((entry) => entry.section === "Portable");
+    const machineEntries = entries.filter((entry) => entry.section === "This machine");
+    const wide = columns >= 118;
+    const footer = [
+        tty("Pick a path. Type the number or the name.", MIST),
+        options.prompt,
+    ];
+    if (!wide) {
+        const panels = [
+            header,
+            panel("Next best move", nextMoveBody(nextEntry), fullWidth),
+            panel("Provider core", renderProviderBody(providerEntry, fullWidth), fullWidth),
+            panel("Portable", renderCapabilityBody(portableEntries, fullWidth), fullWidth),
+            panel("This machine", renderCapabilityBody(machineEntries, fullWidth), fullWidth),
+        ];
+        return [...stackPanels(panels), "", ...footer].join("\n");
+    }
+    const gap = 2;
+    const leftWidth = Math.max(52, Math.floor((fullWidth - gap) / 2));
+    const rightWidth = Math.max(40, fullWidth - gap - leftWidth);
+    const topRow = combineColumns(panel("Next best move", nextMoveBody(nextEntry), leftWidth), panel("This machine", renderCapabilityBody(machineEntries, rightWidth), rightWidth), leftWidth, rightWidth, gap);
+    const bottomRow = combineColumns(panel("Provider core", renderProviderBody(providerEntry, leftWidth), leftWidth), panel("Portable", renderCapabilityBody(portableEntries, rightWidth), rightWidth), leftWidth, rightWidth, gap);
+    return [...header, "", ...topRow, "", ...bottomRow, "", ...footer].join("\n");
+}
+function renderNonTtyBay(entries, options) {
+    const nextEntry = entries.find((entry) => isProblemStatus(entry.status));
+    const lines = [
+        `${options.agent} connect bay`,
+        "Bring one capability online. Provider status was checked live just now.",
+        "",
+        "Next best move",
+        "--------------",
+    ];
+    if (!nextEntry) {
+        lines.push("Everything here is ready. Pick what you want to review or refresh.");
+    }
+    else {
+        lines.push(`${nextEntry.name} - ${nextEntry.status}`);
+        if (nextEntry.nextNote)
+            lines.push(nextEntry.nextNote);
+        if (nextEntry.nextAction)
+            lines.push(`run: ${nextEntry.nextAction}`);
+    }
+    lines.push("");
+    for (const section of ["Provider core", "Portable", "This machine"]) {
+        lines.push(section);
+        lines.push("-".repeat(Math.max(6, section.length + 4)));
+        for (const entry of entries.filter((candidate) => candidate.section === section)) {
+            lines.push(`${entry.option}. ${entry.name} [${entry.status}]`);
+            if (entry.laneSummaries && entry.laneSummaries.length > 0) {
+                for (const lane of entry.laneSummaries) {
+                    const laneLabel = lane.lane === "outward" ? "Outward lane" : "Inner lane";
+                    lines.push(`   ${laneLabel}: ${lane.title}`);
+                    lines.push(`     ${lane.detail}`);
+                }
+            }
+            else {
+                for (const detail of entry.detailLines ?? [])
+                    lines.push(`   ${detail}`);
+            }
+            if (entry.description)
+                lines.push(`   ${entry.description}`);
+            lines.push("");
+        }
+    }
+    lines.push("6. Not now");
+    lines.push("");
+    lines.push("Pick a path. Type the number or the name.");
+    lines.push(options.prompt);
+    return lines.join("\n");
+}
+function summarizeProviderLane(agent, lane, providerHealth) {
+    const providerHealthStatus = resolveProviderHealthStatus(providerHealth);
+    const providerHealthCommand = resolveProviderHealthCommand(providerHealth?.fix, providerHealthStatus);
+    if (lane.status === "unconfigured") {
+        return {
+            lane: lane.lane,
+            status: "needs setup",
+            title: "choose provider and model",
+            detail: "needs setup",
+            action: lane.repairCommand,
+        };
+    }
+    const fallbackAction = providerHealthCommand ?? lane.credential.repairCommand;
+    if (lane.credential.status === "missing") {
+        return {
+            lane: lane.lane,
+            status: "needs credentials",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: "credentials missing",
+            action: fallbackAction,
+        };
+    }
+    if (lane.credential.status === "invalid-pool") {
+        return {
+            lane: lane.lane,
+            status: providerHealthStatus === "locked" ? "locked" : "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: providerHealthStatus === "locked" ? "vault locked on this machine" : "vault unavailable",
+            action: fallbackAction,
+        };
+    }
+    if (lane.readiness.status === "failed") {
+        return {
+            lane: lane.lane,
+            status: "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: `failed live check: ${lane.readiness.error ?? "unknown error"}`,
+            action: providerHealth?.fix ?? `ouro auth --agent ${agent} --provider ${lane.provider}`,
+        };
+    }
+    if (lane.readiness.status === "stale") {
+        return {
+            lane: lane.lane,
+            status: "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: ["live check is stale", lane.readiness.reason].filter(Boolean).join(": "),
+            action: providerHealth?.fix,
+        };
+    }
+    if (lane.readiness.status === "ready") {
+        return {
+            lane: lane.lane,
+            status: "ready",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: "ready",
+        };
+    }
+    return {
+        lane: lane.lane,
+        status: "needs attention",
+        title: `${lane.provider} / ${lane.model}`,
+        detail: "live check did not complete yet",
+        action: providerHealth?.fix,
+    };
+}
+function summarizeProvidersForConnect(agent, visibility, providerHealth) {
+    const laneSummaries = visibility.lanes.map((lane) => summarizeProviderLane(agent, lane, providerHealth));
+    const worstLaneStatus = laneSummaries.reduce((worst, lane) => CONNECT_STATUS_PRIORITY[lane.status] < CONNECT_STATUS_PRIORITY[worst] ? lane.status : worst, "ready");
+    const providerHealthStatus = resolveProviderHealthStatus(providerHealth);
+    const providerHealthCommand = resolveProviderHealthCommand(providerHealth?.fix, providerHealthStatus);
+    const nextLane = laneSummaries.find((lane) => isProblemStatus(lane.status));
+    return {
+        status: providerHealthStatus ?? worstLaneStatus,
+        laneSummaries,
+        detailLines: laneSummaries.flatMap((lane) => [
+            `${lane.lane === "outward" ? "Outward lane" : "Inner lane"}: ${lane.title}`,
+            lane.detail,
+        ]),
+        nextAction: providerHealthCommand ?? nextLane?.action,
+        nextNote: providerHealthStatus === "locked"
+            ? "Unlock this agent's credential vault on this machine."
+            : nextLane
+                ? `${nextLane.lane === "outward" ? "Outward lane" : "Inner lane"}: ${nextLane.detail}`
+                : undefined,
+    };
+}
+function connectEntryNeedsAttention(entry) {
+    return isProblemStatus(entry.status);
+}
+function renderConnectBay(entries, options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.connect_bay_rendered",
+        message: "rendered connect bay",
+        meta: {
+            agent: options.agent,
+            isTTY: options.isTTY,
+            entryCount: entries.length,
+            columns: options.columns ?? null,
+        },
+    });
+    if (!options.isTTY)
+        return renderNonTtyBay(entries, options);
+    return renderTtyBay(entries, options);
+}

package/package.json

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