@ouro.bot/cli 0.1.0-alpha.404 → 0.1.0-alpha.405

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.405",
+      "changes": [
+        "`ouro up` now keeps walking the guided repair path when one successful fix reveals the next runnable issue for the same agent, instead of stopping after the first pass and making you rerun the command.",
+        "The happy repair path still prints `provider checks recovered after repair`, and the chained-flow coverage now exercises vault-unlock-then-auth continuation directly.",
+        "`@ouro.bot/cli` and the `ouro.bot` wrapper are version-synced for the chained preflight repair release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.404",
       "changes": [

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

@@ -1459,13 +1459,65 @@ function readinessReportsFromDegraded(degraded) {
         issues: [readinessIssueFromDegraded(entry)],
     }));
 }
-async function runReadinessRepairForDegraded(degraded, deps) {
-    return (0, readiness_repair_1.runGuidedReadinessRepair)(readinessReportsFromDegraded(degraded), {
-        promptInput: deps.promptInput,
-        writeStdout: deps.writeStdout,
-        runRepairAction: async (agentName, action) => executeReadinessRepairAction(agentName, action, deps),
+function degradedEntrySignature(entry) {
+    const issue = readinessIssueFromDegraded(entry);
+    return JSON.stringify({
+        agent: entry.agent,
+        kind: issue.kind,
+        summary: issue.summary,
+        detail: issue.detail ?? "",
+        actions: issue.actions.map((action) => `${action.kind}:${action.command}:${action.executable === false ? "manual" : "run"}`),
     });
 }
+function mergeRemainingDegraded(untouched, rechecked) {
+    const byAgent = new Map();
+    for (const entry of untouched)
+        byAgent.set(entry.agent, entry);
+    for (const entry of rechecked)
+        byAgent.set(entry.agent, entry);
+    return [...byAgent.values()];
+}
+async function runReadinessRepairForDegraded(degraded, deps) {
+    let current = degraded;
+    let repairsAttempted = false;
+    for (let pass = 0; pass < 3; pass += 1) {
+        const attemptedAgents = new Set();
+        const result = await (0, readiness_repair_1.runGuidedReadinessRepair)(readinessReportsFromDegraded(current), {
+            promptInput: deps.promptInput,
+            writeStdout: deps.writeStdout,
+            onActionAttempted: (agentName) => {
+                attemptedAgents.add(agentName);
+            },
+            runRepairAction: async (agentName, action) => executeReadinessRepairAction(agentName, action, deps),
+        });
+        if (!result.repairsAttempted) {
+            return { repairsAttempted, remainingDegraded: current };
+        }
+        repairsAttempted = true;
+        /* v8 ignore next -- onActionAttempted runs before any runnable repair action, so repairsAttempted implies at least one attempted agent @preserve */
+        if (attemptedAgents.size === 0) {
+            return { repairsAttempted, remainingDegraded: current };
+        }
+        const previousByAgent = new Map();
+        for (const entry of current) {
+            if (attemptedAgents.has(entry.agent)) {
+                previousByAgent.set(entry.agent, degradedEntrySignature(entry));
+            }
+        }
+        const untouched = current.filter((entry) => !attemptedAgents.has(entry.agent));
+        const rechecked = await checkAgentProviders(deps, [...attemptedAgents]);
+        const remaining = mergeRemainingDegraded(untouched, rechecked);
+        if (remaining.length === 0) {
+            return { repairsAttempted, remainingDegraded: remaining };
+        }
+        const nextPrompt = rechecked.filter((entry) => previousByAgent.get(entry.agent) !== degradedEntrySignature(entry));
+        if (nextPrompt.length === 0) {
+            return { repairsAttempted, remainingDegraded: remaining };
+        }
+        current = nextPrompt;
+    }
+    return { repairsAttempted, remainingDegraded: current };
+}
 async function executeLegacyAuthSwitch(command, deps) {
     const { state } = readOrBootstrapProviderState(command.agent, deps);
     const lanes = command.facing
@@ -2246,17 +2298,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 }
                 const repairResult = await runReadinessRepairForDegraded(preflightProviderDegraded, deps);
                 if (!repairResult.repairsAttempted) {
-                    writeProviderRepairSummary(deps, "Provider checks still need repair:", preflightProviderDegraded);
+                    writeProviderRepairSummary(deps, "Provider checks still need repair:", repairResult.remainingDegraded);
                     const message = "daemon not started: provider checks need repair. Run `ouro repair` or rerun `ouro up` to choose a repair path.";
                     deps.writeStdout(message);
                     return message;
                 }
-                const remainingDegraded = await reportPostRepairProviderHealth(deps, preflightProviderDegraded.map((entry) => entry.agent));
+                const remainingDegraded = repairResult.remainingDegraded;
                 if (remainingDegraded.length > 0) {
+                    writeProviderRepairSummary(deps, "Still blocked:", remainingDegraded);
                     const message = "daemon not started: provider checks still need repair.";
                     deps.writeStdout(message);
                     return message;
                 }
+                deps.writeStdout("provider checks recovered after repair");
             }
         }
         progress.startPhase("starting daemon");

package/dist/heart/daemon/readiness-repair.js

@@ -187,6 +187,7 @@ async function runGuidedReadinessRepair(reports, deps) {
                 continue;
             }
             try {
+                deps.onActionAttempted?.(report.agent, action, issue);
                 await deps.runRepairAction(report.agent, action, issue);
                 repairsAttempted = true;
                 deps.writeStdout(`repair step finished for ${report.agent}.`);

package/package.json

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