@ouro.bot/cli 0.1.0-alpha.553 → 0.1.0-alpha.555

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

@@ -41,13 +41,15 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const provider_models_1 = require("../provider-models");
-const machine_identity_1 = require("../machine-identity");
-const provider_state_1 = require("../provider-state");
 const provider_credentials_1 = require("../provider-credentials");
+const provider_readiness_cache_1 = require("../provider-readiness-cache");
 const vault_unlock_1 = require("../../repertoire/vault-unlock");
 const readiness_repair_1 = require("./readiness-repair");
 const provider_ping_progress_1 = require("./provider-ping-progress");
-const drift_detection_1 = require("./drift-detection");
+const LANES = [
+    { lane: "outward", facing: "humanFacing" },
+    { lane: "inner", facing: "agentFacing" },
+];
 function isAgentProvider(value) {
     return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
 }
@@ -57,6 +59,9 @@ function agentRootFor(agentName, bundlesRoot) {
 function configPathFor(agentName, bundlesRoot) {
     return path.join(agentRootFor(agentName, bundlesRoot), "agent.json");
 }
+function laneForFacing(facing) {
+    return facing === "humanFacing" ? "outward" : "inner";
+}
 function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
     const raw = parsed[facing];
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -90,9 +95,13 @@ function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
             },
         };
     }
-    return { ok: true, selected: { facing, provider } };
+    const rawModel = raw.model;
+    const model = typeof rawModel === "string" && rawModel.trim().length > 0
+        ? rawModel.trim()
+        : (0, provider_models_1.getDefaultModelForProvider)(provider);
+    return { ok: true, selected: { facing, lane: laneForFacing(facing), provider, model } };
 }
-function readAgentConfigForProviderState(agentName, bundlesRoot) {
+function readAgentConfigForProviderCheck(agentName, bundlesRoot) {
     const agentJsonPath = configPathFor(agentName, bundlesRoot);
     let raw;
     try {
@@ -127,83 +136,25 @@ function readAgentConfigForProviderState(agentName, bundlesRoot) {
     }
     return { ok: true, disabled: false, agentJsonPath, parsed };
 }
-function readFacingForBootstrap(parsed, facing, agentName, agentJsonPath) {
-    const providerResult = resolveFacingProvider(parsed, facing, agentName, agentJsonPath);
-    if (!providerResult.ok) {
-        return {
-            ok: false,
-            result: {
-                ok: false,
-                error: providerResult.result.error,
-                fix: `Run 'ouro use --agent ${agentName} --lane ${facing === "humanFacing" ? "outward" : "inner"} --provider <provider> --model <model>' to configure this machine's provider binding.`,
-            },
-        };
-    }
-    const raw = parsed[facing];
-    const model = typeof raw.model === "string" && raw.model.trim().length > 0
-        ? raw.model.trim()
-        : (0, provider_models_1.getDefaultModelForProvider)(providerResult.selected.provider);
-    return { ok: true, provider: providerResult.selected.provider, model };
-}
-function bootstrapMissingProviderState(input) {
-    const outward = readFacingForBootstrap(input.parsed, "humanFacing", input.agentName, input.agentJsonPath);
-    if (!outward.ok)
-        return { ok: false, error: outward.result.error, fix: outward.result.fix };
-    const inner = readFacingForBootstrap(input.parsed, "agentFacing", input.agentName, input.agentJsonPath);
-    if (!inner.ok)
-        return { ok: false, error: inner.result.error, fix: inner.result.fix };
-    const now = new Date();
-    const homeDir = (0, provider_credentials_1.providerCredentialMachineHomeDir)(input.homeDir);
-    const machine = (0, machine_identity_1.loadOrCreateMachineIdentity)({ homeDir, now: () => now });
-    const state = (0, provider_state_1.bootstrapProviderStateFromAgentConfig)({
-        machineId: machine.machineId,
-        now,
-        agentConfig: {
-            humanFacing: { provider: outward.provider, model: outward.model },
-            agentFacing: { provider: inner.provider, model: inner.model },
-        },
-    });
-    const agentRoot = agentRootFor(input.agentName, input.bundlesRoot);
-    (0, provider_state_1.writeProviderState)(agentRoot, state);
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.provider_state_bootstrapped",
-        message: "bootstrapped local provider state from agent config",
-        meta: { agent: input.agentName, agentRoot },
-    });
-    return { ok: true, agentRoot, state };
-}
-function readOrBootstrapProviderStateForCheck(agentName, bundlesRoot, deps = {}) {
-    const configResult = readAgentConfigForProviderState(agentName, bundlesRoot);
+function readProviderSelectionForCheck(agentName, bundlesRoot) {
+    const configResult = readAgentConfigForProviderCheck(agentName, bundlesRoot);
     if (!configResult.ok)
         return { ok: false, result: configResult.result };
     if (configResult.disabled)
         return { ok: true, disabled: true };
-    const agentRoot = agentRootFor(agentName, bundlesRoot);
-    const stateResult = (0, provider_state_1.readProviderState)(agentRoot);
-    if (stateResult.ok) {
-        return { ok: true, disabled: false, agentRoot, state: stateResult.state };
-    }
-    if (stateResult.reason === "invalid") {
-        return {
-            ok: false,
-            result: {
-                ok: false,
-                error: `provider state for ${agentName} is invalid at ${stateResult.statePath}: ${stateResult.error}`,
-                fix: `Run 'ouro use --agent ${agentName} --lane outward --provider <provider> --model <model> --force' to rewrite this machine's provider binding.`,
-            },
-        };
+    const bindings = {};
+    for (const { lane, facing } of LANES) {
+        const selected = resolveFacingProvider(configResult.parsed, facing, agentName, configResult.agentJsonPath);
+        if (!selected.ok)
+            return { ok: false, result: selected.result };
+        bindings[lane] = selected.selected;
     }
-    const bootstrap = bootstrapMissingProviderState({
-        agentName,
-        bundlesRoot,
-        parsed: configResult.parsed,
-        agentJsonPath: configResult.agentJsonPath,
-        homeDir: deps.homeDir,
-    });
-    if (!bootstrap.ok)
-        return { ok: false, result: bootstrap };
-    return { ok: true, disabled: false, agentRoot: bootstrap.agentRoot, state: bootstrap.state };
+    return {
+        ok: true,
+        disabled: false,
+        agentRoot: agentRootFor(agentName, bundlesRoot),
+        bindings,
+    };
 }
 function providerCredentialConfig(record) {
     return {
@@ -216,21 +167,6 @@ function pingAttemptCount(result) {
         return result.attempts.length;
     return undefined;
 }
-function writeLaneReadiness(input) {
-    const binding = input.state.lanes[input.lane];
-    const checkedAt = new Date().toISOString();
-    input.state.updatedAt = checkedAt;
-    input.state.readiness[input.lane] = {
-        status: input.status,
-        provider: binding.provider,
-        model: binding.model,
-        checkedAt,
-        credentialRevision: input.credentialRevision,
-        ...(input.error ? { error: input.error } : {}),
-        ...(input.attempts !== undefined ? { attempts: input.attempts } : {}),
-    };
-    (0, provider_state_1.writeProviderState)(input.agentRoot, input.state);
-}
 function missingCredentialResult(agentName, lane, provider, model, credentialPath) {
     return {
         ok: false,
@@ -325,14 +261,14 @@ function laneAudienceLabel(lane) {
 function bindingLabel(binding) {
     return `${binding.provider} / ${binding.model}`;
 }
-function selectedProviderPlan(agentName, state) {
+function selectedProviderPlan(agentName, bindings) {
     return [
-        `${agentName}: checking the providers this agent uses right now`,
-        ...["outward", "inner"].map((lane) => `- ${laneAudienceLabel(lane)}: ${bindingLabel(state.lanes[lane])}`),
+        `${agentName}: checking the providers in agent.json`,
+        ...LANES.map(({ lane }) => `- ${laneAudienceLabel(lane)}: ${bindingLabel(bindings[lane])}`),
     ].join("\n");
 }
-function selectedProvidersForState(state) {
-    return [...new Set(["outward", "inner"].map((lane) => state.lanes[lane].provider))];
+function selectedProvidersForBindings(bindings) {
+    return [...new Set(LANES.map(({ lane }) => bindings[lane].provider))];
 }
 function mapVaultRefreshProgress(agentName, onProgress) {
     return (message) => {
@@ -359,80 +295,52 @@ function providerPingSubject(agentName, lanes) {
  * checkAgentConfigWithProviderHealth(), which reads the agent vault and pings.
  */
 function checkAgentConfig(agentName, bundlesRoot) {
-    const configResult = readAgentConfigForProviderState(agentName, bundlesRoot);
-    if (!configResult.ok)
-        return configResult.result;
-    if (configResult.disabled)
+    const selectionResult = readProviderSelectionForCheck(agentName, bundlesRoot);
+    if (!selectionResult.ok)
+        return selectionResult.result;
+    if (selectionResult.disabled)
         return { ok: true };
-    const outward = readFacingForBootstrap(configResult.parsed, "humanFacing", agentName, configResult.agentJsonPath);
-    if (!outward.ok)
-        return outward.result;
-    const inner = readFacingForBootstrap(configResult.parsed, "agentFacing", agentName, configResult.agentJsonPath);
-    if (!inner.ok)
-        return inner.result;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",
         message: "agent config validation passed",
         meta: {
             agent: agentName,
-            providers: [...new Set([outward.provider, inner.provider])],
+            providers: selectedProvidersForBindings(selectionResult.bindings),
             liveProviderCheck: false,
         },
     });
     return { ok: true };
 }
 async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps = {}) {
-    const stateResult = readOrBootstrapProviderStateForCheck(agentName, bundlesRoot, deps);
-    if (!stateResult.ok)
-        return stateResult.result;
-    if (stateResult.disabled)
+    const selectionResult = readProviderSelectionForCheck(agentName, bundlesRoot);
+    if (!selectionResult.ok)
+        return selectionResult.result;
+    if (selectionResult.disabled)
         return { ok: true };
-    // Layer 4 drift detection. Runs once per call after state setup so that
-    // drift findings ride along regardless of ping outcome — consumers
-    // (Layer 4 rollup, Layer 3 RepairGuide) want to see drift even when a
-    // live-check is failing for unrelated reasons. Drift detection is pure
-    // and never throws on a malformed agent.json: any read error here would
-    // indicate the bundle disappeared between state setup and now (a
-    // race), which we surface as `[]` rather than a hard failure.
-    let driftFindings = [];
-    try {
-        const inputs = (0, drift_detection_1.loadDriftInputsForAgent)(bundlesRoot, agentName);
-        driftFindings = (0, drift_detection_1.detectProviderBindingDrift)({
-            agentName,
-            agentJson: inputs.agentJson,
-            providerState: inputs.providerState,
-        });
-    }
-    catch {
-        /* v8 ignore next 1 -- defensive race-window guard: agent.json went away after state setup. Tested via Unit 5 integration when at all. @preserve */
-        driftFindings = [];
-    }
-    deps.onProgress?.(selectedProviderPlan(agentName, stateResult.state));
+    deps.onProgress?.(selectedProviderPlan(agentName, selectionResult.bindings));
     const ping = deps.pingProvider ?? (await Promise.resolve().then(() => __importStar(require("../provider-ping")))).pingProvider;
-    const shouldRecordReadiness = deps.recordReadiness ?? true;
-    const providers = selectedProvidersForState(stateResult.state);
+    const providers = selectedProvidersForBindings(selectionResult.bindings);
     const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, {
         ...(deps.onProgress ? { onProgress: mapVaultRefreshProgress(agentName, deps.onProgress) } : {}),
         providers,
         preserveCachedOnFailure: true,
     });
     const pingGroups = new Map();
-    const lanes = ["outward", "inner"];
-    for (const lane of lanes) {
-        const binding = stateResult.state.lanes[lane];
+    for (const { lane } of LANES) {
+        const binding = selectionResult.bindings[lane];
         if (!poolResult.ok) {
             if (poolResult.reason === "missing") {
-                return { ...missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath), driftFindings };
+                return missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath);
             }
-            return { ...invalidPoolResult(agentName, lane, binding.provider, binding.model, {
-                    ...poolResult,
-                    reason: poolResult.reason,
-                }), driftFindings };
+            return invalidPoolResult(agentName, lane, binding.provider, binding.model, {
+                ...poolResult,
+                reason: poolResult.reason,
+            });
         }
         const record = credentialRecordForLane(poolResult.pool, binding.provider);
         if (!record) {
-            return { ...missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath), driftFindings };
+            return missingCredentialResult(agentName, lane, binding.provider, binding.model, poolResult.poolPath);
         }
         const key = `${binding.provider}\0${binding.model}\0${record.revision}`;
         const group = pingGroups.get(key);
@@ -466,37 +374,37 @@ 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,
+                (0, provider_readiness_cache_1.recordProviderLaneReadiness)({
+                    agentName,
                     lane,
-                    status: "ready",
+                    provider: group.provider,
+                    model: group.model,
                     credentialRevision: group.record.revision,
+                    status: "failed",
+                    checkedAt: new Date().toISOString(),
+                    error: result.message,
                     attempts: pingAttemptCount(result),
                 });
             }
+            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            continue;
+        }
+        for (const lane of group.lanes) {
+            (0, provider_readiness_cache_1.recordProviderLaneReadiness)({
+                agentName,
+                lane,
+                provider: group.provider,
+                model: group.model,
+                credentialRevision: group.record.revision,
+                status: "ready",
+                checkedAt: new Date().toISOString(),
+                attempts: pingAttemptCount(result),
+            });
         }
     }
     if (firstFailure)
-        return { ...firstFailure, driftFindings };
+        return firstFailure;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",
@@ -505,8 +413,7 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             agent: agentName,
             providers: [...new Set([...pingGroups.values()].map((group) => group.provider))],
             liveProviderCheck: true,
-            driftCount: driftFindings.length,
         },
     });
-    return { ok: true, driftFindings };
+    return { ok: true };
 }

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

@@ -68,7 +68,7 @@ function buildSystemPrompt(degraded) {
         "and the simplest fix the user can apply.",
     ].join("\n");
 }
-function buildUserMessage(degraded, logsTail, driftFindings = [], syncFindings = []) {
+function buildUserMessage(degraded, logsTail, syncFindings = []) {
     const agentDetails = degraded
         .map((d) => `Agent: ${d.agent}\n  Error: ${d.errorReason}\n  Fix hint: ${d.fixHint}`)
         .join("\n\n");
@@ -80,13 +80,6 @@ function buildUserMessage(degraded, logsTail, driftFindings = [], syncFindings =
         "Recent daemon logs:",
         logsTail,
     ];
-    // Layer 3: thread Layer 4's structured drift findings into the prompt as
-    // a JSON block. The `diagnose-bootstrap-drift` skill (loaded into the
-    // system prompt by `buildSystemPromptWithRepairGuide`) instructs the LLM
-    // how to read this shape and what `ouro use` repair to propose.
-    if (driftFindings.length > 0) {
-        sections.push("", "driftFindings (DriftFinding[]):", "```json", JSON.stringify(driftFindings, null, 2), "```");
-    }
     // Layer 3: thread Layer 2's structured sync-probe findings into the
     // prompt as a JSON block. `diagnose-broken-remote` (auth/404/network/
     // timeout-hard) and `diagnose-sync-blocked` (dirty/non-fast-forward/
@@ -158,7 +151,7 @@ async function tryAgenticDiagnosis(degraded, provider, deps) {
     const repoRoot = deps.repoRootOverride ?? (0, identity_1.getRepoRoot)();
     const repairGuide = loadRepairGuideContent(repoRoot);
     const systemPrompt = buildSystemPromptWithRepairGuide(degraded, repairGuide);
-    const userMessage = buildUserMessage(degraded, logsTail, deps.driftFindings, deps.syncFindings);
+    const userMessage = buildUserMessage(degraded, logsTail, deps.syncFindings);
     const messages = [
         { role: "system", content: systemPrompt },
         { role: "user", content: userMessage },