@ouro.bot/cli 0.1.0-alpha.448 → 0.1.0-alpha.449

package/README.md

@@ -99,7 +99,7 @@ Task docs do not live in this repo anymore. Planning and doing docs live in the
 - Vault unlock material is local machine state. Prefer macOS Keychain, Windows DPAPI, or Linux Secret Service; plaintext fallback is allowed only by explicit human choice.
 - New vault unlock secrets are confirmed before use and rejected if they do not meet the minimum strength requirements.
 - Provider and runtime credentials are loaded into process memory at startup/auth/unlock/refresh and reused. The remote vault is not queried for every model or sense request.
-- Human TTY commands share one CLI surface family: bare `ouro` opens the home deck, `ouro up` uses the boot checklist, `ouro connect`/`ouro auth verify`/`ouro repair` reuse the same readiness truth, and `ouro help`/`ouro whoami`/`ouro versions`/`ouro hatch` render through the same Ouro-branded wizard/guide language instead of raw transcript walls.
+- Human TTY commands share one CLI surface family: bare `ouro` opens the home deck, `ouro up` uses the boot checklist, `ouro connect`/`ouro auth verify`/`ouro repair` agree on provider and vault truth, and `ouro help`/`ouro whoami`/`ouro versions`/`ouro hatch` render through the same Ouro-branded wizard/guide language instead of raw transcript walls. Orientation commands such as root `ouro connect` may use shorter live probes, while startup and verification commands own durable readiness updates.
 - Human-facing CLI commands that can wait on browser auth, vault IO, daemon startup, daemon restart, provider checks, or connector setup use a shared progress checklist. If a cursor may blink for more than a few seconds, the command should print or animate the current step instead of going quiet.
 - CLI commands that mutate bundle config, such as vault setup or `ouro connect bluebubbles`, run bundle sync after the change when `sync.enabled` is true and report a compact `bundle sync:` line.
 - The daemon discovers bundles dynamically from `~/AgentBundles`.

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.449",
+      "changes": [
+        "`ouro connect` now uses a bounded live provider probe before opening the connection menu: it still checks the real selected providers, but it makes one orientation attempt with a 5-second hard timeout instead of spending the full startup retry budget before the human can choose a setup path.",
+        "Provider ping timeouts are now hard timeouts even when an SDK ignores the abort signal. The failing attempt is classified through the same shared retry machinery and reports a clear `provider ping timed out after <ms>ms` message instead of leaving the CLI stuck behind a blinking cursor.",
+        "Root connect provider checks no longer overwrite durable provider readiness. A quick menu probe can show `needs attention` for the current screen, while `ouro up`, `ouro check`, auth verification, and chat startup remain the flows that record lasting ready/failed provider state."
+      ]
+    },
     {
       "version": "0.1.0-alpha.448",
       "changes": [

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

@@ -389,6 +389,7 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
         return { ok: true };
     deps.onProgress?.(selectedProviderPlan(agentName, stateResult.state));
     const ping = deps.pingProvider ?? (await Promise.resolve().then(() => __importStar(require("../provider-ping")))).pingProvider;
+    const shouldRecordReadiness = deps.recordReadiness ?? true;
     const providers = selectedProvidersForState(stateResult.state);
     const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, {
         ...(deps.onProgress ? { onProgress: mapVaultRefreshProgress(agentName, deps.onProgress) } : {}),
@@ -430,6 +431,7 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
     const pingResults = await Promise.all(groups.map(async (group) => {
         const result = await ping(group.provider, providerCredentialConfig(group.record), {
             model: group.model,
+            ...(deps.providerPingOptions ?? {}),
             ...(deps.onProgress
                 ? (0, provider_ping_progress_1.createProviderPingProgressReporter)({
                     provider: group.provider,
@@ -443,29 +445,33 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
     let firstFailure = null;
     for (const { group, result } of pingResults) {
         if (!result.ok) {
+            if (shouldRecordReadiness) {
+                for (const lane of group.lanes) {
+                    writeLaneReadiness({
+                        agentRoot: stateResult.agentRoot,
+                        state: stateResult.state,
+                        lane,
+                        status: "failed",
+                        credentialRevision: group.record.revision,
+                        error: result.message,
+                        attempts: pingAttemptCount(result),
+                    });
+                }
+            }
+            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            continue;
+        }
+        if (shouldRecordReadiness) {
             for (const lane of group.lanes) {
                 writeLaneReadiness({
                     agentRoot: stateResult.agentRoot,
                     state: stateResult.state,
                     lane,
-                    status: "failed",
+                    status: "ready",
                     credentialRevision: group.record.revision,
-                    error: result.message,
                     attempts: pingAttemptCount(result),
                 });
             }
-            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
-            continue;
-        }
-        for (const lane of group.lanes) {
-            writeLaneReadiness({
-                agentRoot: stateResult.agentRoot,
-                state: stateResult.state,
-                lane,
-                status: "ready",
-                credentialRevision: group.record.revision,
-                attempts: pingAttemptCount(result),
-            });
         }
     }
     if (firstFailure)

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

@@ -106,6 +106,10 @@ 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;
+const CONNECT_PROVIDER_ORIENTATION_PING_OPTIONS = {
+    attemptPolicy: { maxAttempts: 1, baseDelayMs: 0, backoffMultiplier: 2 },
+    timeoutMs: 5_000,
+};
 function summarizeCliUpdateCheckStatus(error, timedOut = false) {
     const normalized = error.trim().toLowerCase();
     if (timedOut || normalized.includes("timed out") || normalized.includes("abort")) {
@@ -218,13 +222,20 @@ async function checkAgentProviders(deps, agentsOverride, onProgress) {
     }
     return degraded;
 }
-async function checkAgentProviderHealth(agentName, bundlesRoot, deps, onProgress) {
+async function checkAgentProviderHealth(agentName, bundlesRoot, deps, onProgress, options = {}) {
     const liveDeps = {};
     if (deps.homeDir)
         liveDeps.homeDir = deps.homeDir;
     if (onProgress)
         liveDeps.onProgress = onProgress;
-    if (liveDeps.homeDir || liveDeps.onProgress) {
+    if (options.providerPingOptions)
+        liveDeps.providerPingOptions = options.providerPingOptions;
+    if (options.recordReadiness !== undefined)
+        liveDeps.recordReadiness = options.recordReadiness;
+    if (liveDeps.homeDir ||
+        liveDeps.onProgress ||
+        liveDeps.providerPingOptions ||
+        liveDeps.recordReadiness !== undefined) {
         return (0, agent_config_check_1.checkAgentConfigWithProviderHealth)(agentName, bundlesRoot, liveDeps);
     }
     return (0, agent_config_check_1.checkAgentConfigWithProviderHealth)(agentName, bundlesRoot);
@@ -2040,7 +2051,10 @@ async function buildConnectMenu(agent, deps, onProgress) {
     let providerHealth;
     try {
         onProgress?.("checking selected providers");
-        providerHealth = await checkAgentProviderHealth(agent, bundlesRoot, deps, onProgress);
+        providerHealth = await checkAgentProviderHealth(agent, bundlesRoot, deps, onProgress, {
+            providerPingOptions: CONNECT_PROVIDER_ORIENTATION_PING_OPTIONS,
+            recordReadiness: false,
+        });
     }
     catch (error) {
         providerHealth = {

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

@@ -34,6 +34,8 @@ function providerRetryTiming(delayMs) {
 }
 function formatProviderAttemptProgress(context, attempt, maxAttempts) {
     const prefix = context.subject ? `${context.subject}: ` : "";
+    if (maxAttempts <= 1)
+        return `${prefix}checking ${formatProviderPingLabel(context)}...`;
     return `${prefix}checking ${formatProviderPingLabel(context)} (attempt ${attempt} of ${maxAttempts})...`;
 }
 function formatProviderRetryProgress(context, record, maxAttempts) {

package/dist/heart/provider-ping.js

@@ -83,6 +83,37 @@ async function readGithubCopilotModelPingError(response) {
 function createStatusError(message, status) {
     return Object.assign(new Error(message), { status });
 }
+function normalizePingTimeoutMs(timeoutMs) {
+    if (timeoutMs === undefined)
+        return PING_TIMEOUT_MS;
+    if (!Number.isFinite(timeoutMs))
+        return PING_TIMEOUT_MS;
+    return Math.max(1, Math.floor(timeoutMs));
+}
+function createPingTimeoutError(timeoutMs) {
+    return Object.assign(new Error(`provider ping timed out after ${timeoutMs}ms`), {
+        code: "ETIMEDOUT",
+    });
+}
+async function runPingWithHardTimeout(runtime, timeoutMs) {
+    const controller = new AbortController();
+    let timeout;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+            controller.abort();
+            reject(createPingTimeoutError(timeoutMs));
+        }, timeoutMs);
+    });
+    try {
+        await Promise.race([
+            Promise.resolve().then(() => runtime.ping(controller.signal)),
+            timeoutPromise,
+        ]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 async function pingGithubCopilotModel(baseUrl, token, model, fetchImpl = fetch) {
     const base = baseUrl.replace(/\/+$/, "");
     const isClaude = model.startsWith("claude");
@@ -183,15 +214,7 @@ async function pingProvider(provider, config, options = {}) {
         onAttemptStart: options.onAttemptStart,
         onRetry: options.onRetry,
         run: async () => {
-            const controller = new AbortController();
-            /* v8 ignore next -- timeout callback: only fires after 10s, tests resolve faster @preserve */
-            const timeout = setTimeout(() => controller.abort(), PING_TIMEOUT_MS);
-            try {
-                await runtime.ping(controller.signal);
-            }
-            finally {
-                clearTimeout(timeout);
-            }
+            await runPingWithHardTimeout(runtime, normalizePingTimeoutMs(options.timeoutMs));
         },
     });
     if (attempt.ok) {

package/package.json

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