@ouro.bot/cli 0.1.0-alpha.447 → 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,22 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.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": [
+        "`ouro status` and agent prompt provider visibility now distinguish \"the daemon has not loaded provider credentials in this process\" from \"the agent vault is missing credentials.\" A saved live check that passed stays ready instead of being downgraded to stale/missing just because status rendering is running in a fresh daemon process.",
+        "Provider visibility now carries a safe `not-loaded` credential state and renders it as `checked previously`, preserving the last live-check result without reading or printing secrets during ordinary status/prompt rendering.",
+        "Regression coverage locks the installed-product failure shape: an empty in-process provider cache plus ready provider state no longer produces misleading auth repair guidance."
+      ]
+    },
     {
       "version": "0.1.0-alpha.447",
       "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 = {
@@ -2966,7 +2980,7 @@ async function executeProviderCheck(command, deps) {
         throw error;
     }
 }
-function renderProviderCredentialLine(credential) {
+function renderProviderCredentialLine(agentName, credential) {
     if (credential.status === "present") {
         const credentialFields = credential.credentialFields.length > 0 ? ` credentials: ${credential.credentialFields.join(", ")}` : " credentials: none";
         const configFields = credential.configFields.length > 0 ? ` config: ${credential.configFields.join(", ")}` : " config: none";
@@ -2975,6 +2989,9 @@ function renderProviderCredentialLine(credential) {
     if (credential.status === "invalid-pool") {
         return `credentials: vault unavailable (${credential.error}); repair: ${credential.repair.command}`;
     }
+    if (credential.status === "not-loaded") {
+        return `credentials: not loaded in this process; run \`ouro provider refresh --agent ${agentName}\` to read the vault now`;
+    }
     return `credentials: missing; repair: ${credential.repair.command}`;
 }
 async function executeProviderStatus(command, deps) {
@@ -3010,7 +3027,7 @@ async function executeProviderStatus(command, deps) {
         const binding = resolved.binding;
         lines.push(`  ${lane}: ${binding.provider} / ${binding.model} (${binding.source})`);
         lines.push(`    readiness: ${binding.readiness.status}${binding.readiness.error ? ` (${binding.readiness.error})` : ""}`);
-        lines.push(`    ${renderProviderCredentialLine(binding.credential)}`);
+        lines.push(`    ${renderProviderCredentialLine(command.agent, binding.credential)}`);
         for (const warning of binding.warnings) {
             lines.push(`    warning: ${warning.message}`);
         }

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-binding-resolver.js

@@ -89,6 +89,16 @@ function resolveCredential(poolResult, provider, agentName) {
             warnings: [missingCredentialWarning(provider)],
         };
     }
+    if ((0, provider_credentials_1.isProviderCredentialPoolNotLoaded)(poolResult)) {
+        return {
+            credential: {
+                status: "not-loaded",
+                provider,
+                poolPath: poolResult.poolPath,
+            },
+            warnings: [],
+        };
+    }
     if (poolResult.reason === "invalid" || poolResult.reason === "unavailable") {
         return {
             credential: {
@@ -130,6 +140,9 @@ function staleReadiness(readiness, reason) {
 }
 function resolveReadiness(input) {
     if (!input.readiness) {
+        if (input.credential.status === "not-loaded") {
+            return { readiness: { status: "unknown" }, warnings: [] };
+        }
         if (input.credential.status === "missing") {
             return { readiness: { status: "unknown", reason: "credential-missing" }, warnings: [] };
         }
@@ -170,6 +183,9 @@ function resolveReadiness(input) {
             warnings: [],
         };
     }
+    if (input.credential.status === "not-loaded") {
+        return { readiness: readinessFromState(input.readiness), warnings: [] };
+    }
     return { readiness: readinessFromState(input.readiness), warnings: [] };
 }
 function resolveEffectiveProviderBinding(input) {

package/dist/heart/provider-credentials.js

@@ -33,10 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_CREDENTIAL_POOL_NOT_LOADED_ERROR = void 0;
 exports.splitProviderCredentialFields = splitProviderCredentialFields;
 exports.providerCredentialsVaultPath = providerCredentialsVaultPath;
 exports.providerCredentialItemName = providerCredentialItemName;
 exports.providerCredentialMachineHomeDir = providerCredentialMachineHomeDir;
+exports.isProviderCredentialPoolNotLoaded = isProviderCredentialPoolNotLoaded;
 exports.readProviderCredentialPool = readProviderCredentialPool;
 exports.refreshProviderCredentialPool = refreshProviderCredentialPool;
 exports.createProviderCredentialRecord = createProviderCredentialRecord;
@@ -54,6 +56,7 @@ const credential_access_1 = require("../repertoire/credential-access");
 const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot"];
 const VALID_PROVENANCE_SOURCES = ["auth-flow", "manual"];
 const VAULT_ITEM_PREFIX = "providers/";
+exports.PROVIDER_CREDENTIAL_POOL_NOT_LOADED_ERROR = "provider credentials have not been loaded from vault";
 const PROVIDER_FIELD_SPLITS = {
     anthropic: {
         credentials: ["setupToken", "refreshToken", "expiresAt"],
@@ -197,7 +200,7 @@ function recordFromPayload(payload) {
         provenance: { ...payload.provenance },
     };
 }
-function missingPool(agentName, error = "provider credentials have not been loaded from vault") {
+function missingPool(agentName, error = exports.PROVIDER_CREDENTIAL_POOL_NOT_LOADED_ERROR) {
     return {
         ok: false,
         reason: "missing",
@@ -205,6 +208,11 @@ function missingPool(agentName, error = "provider credentials have not been load
         error,
     };
 }
+function isProviderCredentialPoolNotLoaded(result) {
+    return !result.ok
+        && result.reason === "missing"
+        && result.error === exports.PROVIDER_CREDENTIAL_POOL_NOT_LOADED_ERROR;
+}
 function cacheResult(agentName, result) {
     cachedPools.set(agentName, result);
     return result;

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/dist/heart/provider-visibility.js

@@ -21,7 +21,7 @@ function credentialVisibility(binding) {
     }
     return {
         status: credential.status,
-        repairCommand: credential.repair.command,
+        ...("repair" in credential ? { repairCommand: credential.repair.command } : {}),
     };
 }
 function readinessVisibility(binding) {
@@ -87,6 +87,8 @@ function credentialLabel(credential) {
         return credential.source ?? "vault";
     if (credential.status === "invalid-pool")
         return "vault unavailable";
+    if (credential.status === "not-loaded")
+        return "checked previously";
     return "missing";
 }
 function readinessLabel(readiness) {
@@ -102,7 +104,7 @@ function readinessLabel(readiness) {
     return readiness.status;
 }
 function providerStatusDetail(lane) {
-    if (lane.credential.status !== "present")
+    if (lane.credential.status === "missing" || lane.credential.status === "invalid-pool")
         return undefined;
     return lane.readiness.error;
 }

package/package.json

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