@ouro.bot/cli 0.1.0-alpha.352 → 0.1.0-alpha.354

package/README.md

@@ -11,7 +11,8 @@ Ouroboros is a TypeScript harness for daemon-managed agents that live in externa
 - `ouro up` starts the daemon from the installed production version, syncs the launcher, installs workflow helpers, and reconciles stale runtime state.
 - `ouro dev` starts the daemon from a local repo build. It auto-builds from source, disables launchd auto-restart (so the installed daemon doesn't respawn underneath you), persists the repo path in `~/.ouro-cli/dev-config.json` for next time, and force-restarts the daemon. If you run `ouro dev` from inside the repo, it detects the CWD automatically. Run `ouro up` to return to production mode (this also cleans up `dev-config.json`).
 - Agent bundles live outside the repo at `~/AgentBundles/<agent>.ouro/`.
-- Secrets live outside the repo at `~/.agentsecrets/<agent>/secrets.json`.
+- Provider credentials live outside the repo at `~/.agentsecrets/providers.json`.
+- Sense-specific secrets live outside the repo at `~/.agentsecrets/<agent>/secrets.json`.
 - Machine-scoped test and runtime spillover lives under `~/.agentstate/...`.
 
 Current first-class senses:
@@ -90,8 +91,10 @@ Task docs do not live in this repo anymore. Planning and doing docs live in the
 
 ## Runtime Truths
 
-- `agent.json` is the source of truth for provider+model selection per facing (`humanFacing` and `agentFacing`), phrase pools, context settings, and enabled senses.
-- `configPath` must point to `~/.agentsecrets/<agent>/secrets.json`.
+- `agent.json` is the source of truth for phrase pools, context settings, enabled senses, and the agent's `configPath`. Legacy `humanFacing`/`agentFacing` values are bootstrap inputs, not live machine fallback.
+- `configPath` must point to `~/.agentsecrets/<agent>/secrets.json` for sense-specific secrets.
+- `state/providers.json` is the local source of truth for provider+model selection on this machine. It has two lanes: `outward` for CLI, Teams, and BlueBubbles turns, and `inner` for inner dialogue.
+- `~/.agentsecrets/providers.json` is the machine credential pool. It stores provider credentials only, records which agent contributed them, and is shared by all agents on that machine.
 - The daemon discovers bundles dynamically from `~/AgentBundles`.
 - `ouro status` reports version, last-updated time, discovered agents, senses, and workers.
 - `bundle-meta.json` tracks the runtime version that last touched a bundle.
@@ -104,17 +107,22 @@ Task docs do not live in this repo anymore. Planning and doing docs live in the
   - `running`
   - `error`
 
-When a model provider needs first-time setup, reauth, or an explicit switch, use:
+When a model provider needs first-time setup or reauth, use:
 
 ```bash
 ouro auth --agent <name>
 ouro auth --agent <name> --provider <provider>
-ouro auth --agent <name> --facing agent --provider <provider>
 ```
 
-The default form reauths the human-facing provider already selected in `agent.json`. The
-`--provider` form is for adding or switching providers. The `--facing` flag (values: `human`
-or `agent`) controls which facing gets updated; it defaults to `human` when omitted.
+`ouro auth` stores credentials only. It does not switch a lane or write provider/model selection.
+
+When you want this machine to use a provider/model for a lane, use:
+
+```bash
+ouro use --agent <name> --lane <outward|inner> --provider <provider> --model <model>
+```
+
+The outward lane handles user-facing senses. The inner lane handles the agent's private thinking. `ouro use` performs the provider/model check before committing the lane, so a broken local choice fails fast with a repair path instead of surprising the next turn.
 
 ## Quickstart
 
@@ -159,6 +167,7 @@ ouro logs
 ouro stop
 ouro auth --agent <name>
 ouro auth --agent <name> --provider <provider>
+ouro use --agent <name> --lane <outward|inner> --provider <provider> --model <model>
 ouro hatch
 ouro chat <agent>
 ouro msg --to <agent> [--session <id>] [--task <ref>] <message>

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_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.354",
+      "changes": [
+        "Provider visibility now surfaces the effective local outward/inner lanes across start-of-turn context, system prompts, pulse, Outlook, and daemon status, using the shared provider binding resolver with safe credential provenance and no raw secret exposure.",
+        "Provider auth docs now state the runtime model plainly: `state/providers.json` selects provider/model per machine, `~/.agentsecrets/providers.json` stores machine credentials, `ouro use` switches lanes, and `ouro auth` stores credentials only."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.353",
+      "changes": [
+        "Provider failover now uses the machine-wide credential pool and local provider-state lanes: terminal errors build ready-provider choices with safe credential provenance, `switch to <provider>` carries lane/model/revision context, and the retry path updates only the failed `state/providers.json` lane instead of mutating both synced `agent.json` facings."
+      ]
+    },
     {
       "version": "0.1.0-alpha.352",
       "changes": [
@@ -9,6 +22,16 @@
         "Autonomous execution prompt contract added: when told to work autonomously, agents use ponder to absorb new messages and continue using tools, settling only with the final result."
       ]
     },
+    {
+      "version": "0.1.0-alpha.351",
+      "changes": [
+        "Surface tool description rewritten from 'surface progress' to 'send a message to someone' — makes it clear the tool is for interpersonal messaging, not status reporting.",
+        "Inner dialog prompt contract now guides agents to use rest(note) for heartbeat state and ponder(reflection) for deeper thoughts, keeping surface strictly for words meant for another person.",
+        "Removed [surfaced from inner dialog] prefix from synthetic session messages — provenance is tracked via captureKind: 'synthetic', the prefix was redundant and created echo loops.",
+        "Obligation summaries and attention queue headers reframed as structured internal data ([internal] tags) instead of surface-ready prose.",
+        "Shared proactive-content-guard module blocks internal content (heartbeat, check-in, task board, obligation status, meta markers) from BlueBubbles and Teams proactive sends."
+      ]
+    },
     {
       "version": "0.1.0-alpha.350",
       "changes": [

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

@@ -75,15 +75,18 @@ function parseStatusPayload(data) {
     const workers = raw.workers;
     const sync = raw.sync;
     const agents = raw.agents;
+    const providers = raw.providers;
     if (!overview || typeof overview !== "object" || Array.isArray(overview))
         return null;
     if (!Array.isArray(senses) || !Array.isArray(workers))
         return null;
-    // sync and agents are optional for backward compatibility — older daemons may omit them
+    // sync, agents, and providers are optional for backward compatibility — older daemons may omit them
     if (sync !== undefined && !Array.isArray(sync))
         return null;
     if (agents !== undefined && !Array.isArray(agents))
         return null;
+    if (providers !== undefined && !Array.isArray(providers))
+        return null;
     const parsedOverview = {
         daemon: stringField(overview.daemon) ?? "unknown",
         health: stringField(overview.health) ?? "unknown",
@@ -172,10 +175,38 @@ function parseStatusPayload(data) {
             return null;
         return { name, enabled };
     });
+    const parsedProviders = (providers ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const lane = stringField(row.lane);
+        const provider = stringField(row.provider);
+        const model = stringField(row.model);
+        const source = stringField(row.source);
+        const readiness = stringField(row.readiness);
+        const credential = stringField(row.credential);
+        if (!agent || !lane || !provider || !model || !source || !readiness || !credential)
+            return null;
+        const parsed = {
+            agent,
+            lane,
+            provider,
+            model,
+            source,
+            readiness,
+            credential,
+        };
+        const detail = stringField(row.detail);
+        if (detail !== null)
+            parsed.detail = detail;
+        return parsed;
+    });
     if (parsedSenses.some((row) => row === null) ||
         parsedWorkers.some((row) => row === null) ||
         parsedSync.some((row) => row === null) ||
-        parsedAgents.some((row) => row === null))
+        parsedAgents.some((row) => row === null) ||
+        parsedProviders.some((row) => row === null))
         return null;
     return {
         overview: parsedOverview,
@@ -183,6 +214,7 @@ function parseStatusPayload(data) {
         workers: parsedWorkers,
         sync: parsedSync,
         agents: parsedAgents,
+        providers: parsedProviders,
     };
 }
 // ── ANSI color helpers (private) ──
@@ -208,12 +240,15 @@ function statusDot(status) {
         case "ok":
         case "interactive":
         case "enabled":
+        case "ready":
             return green("●");
         case "crashed":
         case "warn":
         case "error":
+        case "failed":
             return red("●");
         case "needs_config":
+        case "stale":
             return yellow("●");
         case "disabled":
         case "stopped":
@@ -291,6 +326,18 @@ function formatDaemonStatusOutput(response, fallback) {
         }
         lines.push("");
     }
+    // ── Providers ──
+    if (payload.providers.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Providers")} ${teal("─".repeat(34))}`);
+        const agentLaneWidth = Math.max(16, ...payload.providers.map((r) => `${r.agent} ${r.lane}`.length));
+        for (const row of payload.providers) {
+            const agentLane = `${row.agent} ${row.lane}`.padEnd(agentLaneWidth);
+            const model = `${row.provider} / ${row.model}`;
+            const detail = [row.readiness, row.detail, row.source, row.credential].filter(Boolean).join("; ");
+            lines.push(`    ${agentLane} ${statusDot(row.readiness)} ${model}  ${dim(detail)}`);
+        }
+        lines.push("");
+    }
     // ── Senses ──
     if (payload.senses.length > 0) {
         lines.push(`  ${teal("──")} ${bold("Senses")} ${teal("─".repeat(37))}`);
@@ -421,6 +468,7 @@ function buildStoppedStatusPayload(socketPath, syncRows = [], agentRows = []) {
         workers: [],
         sync: syncRows,
         agents: agentRows,
+        providers: [],
     };
 }
 function daemonUnavailableStatusOutput(socketPath, healthFilePath) {

package/dist/heart/daemon/daemon.js

@@ -64,6 +64,7 @@ const outlook_http_1 = require("../outlook/outlook-http");
 const outlook_types_1 = require("../outlook/outlook-types");
 const outlook_read_1 = require("../outlook/outlook-read");
 const outlook_view_1 = require("../outlook/outlook-view");
+const provider_visibility_1 = require("../provider-visibility");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
  * Defense-in-depth: detect if we're running under vitest. The pidfile lives
@@ -427,6 +428,10 @@ class OuroDaemon {
         const repoRoot = (0, identity_1.getRepoRoot)();
         const sync = (0, agent_discovery_1.listBundleSyncRows)({ bundlesRoot: this.bundlesRoot });
         const agents = (0, agent_discovery_1.listAllBundleAgents)({ bundlesRoot: this.bundlesRoot });
+        const providers = agents.flatMap((agent) => (0, provider_visibility_1.providerVisibilityStatusRows)((0, provider_visibility_1.buildAgentProviderVisibility)({
+            agentName: agent.name,
+            agentRoot: path.join(this.bundlesRoot, `${agent.name}.ouro`),
+        })));
         return {
             overview: {
                 daemon: "running",
@@ -443,6 +448,7 @@ class OuroDaemon {
             senses,
             sync,
             agents,
+            ...(providers.length > 0 ? { providers } : {}),
         };
     }
     async start() {

package/dist/heart/daemon/pulse.js

@@ -52,6 +52,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const provider_visibility_1 = require("../provider-visibility");
 /* v8 ignore next 3 -- path defaults: tests always inject @preserve */
 function defaultPulsePath() {
     return path.join(os.homedir(), ".ouro-cli", "pulse.json");
@@ -136,7 +137,7 @@ function readAgentActivity(bundlePath, readFile = (p) => fs.readFileSync(p, "utf
  * directly, we just compute where it lives so sibling agents have a
  * starting point if they want to navigate there manually.
  */
-function buildPulseState(snapshots, bundlesRoot, daemonVersion, now, readActivity = readAgentActivity) {
+function buildPulseState(snapshots, bundlesRoot, daemonVersion, now, readActivity = readAgentActivity, readProviderVisibility = () => null) {
     const agents = snapshots.map((snap) => {
         const errorReason = snap.errorReason;
         const bundlePath = path.join(bundlesRoot, `${snap.name}.ouro`);
@@ -151,6 +152,7 @@ function buildPulseState(snapshots, bundlesRoot, daemonVersion, now, readActivit
             // Only read activity for agents that are actually running. For
             // crashed/stopped agents, the runtime.json is stale at best.
             currentActivity: snap.status === "running" ? readActivity(bundlePath) : null,
+            providerVisibility: readProviderVisibility(snap.name, bundlePath),
         };
     });
     return {
@@ -294,7 +296,17 @@ function readPulse(deps = {}) {
         return {
             generatedAt: parsed.generatedAt,
             daemonVersion: parsed.daemonVersion,
-            agents: parsed.agents.filter(isValidPulseAgentEntry),
+            agents: parsed.agents.filter(isValidPulseAgentEntry).map((agent) => {
+                const rawAgent = agent;
+                if (!Object.prototype.hasOwnProperty.call(rawAgent, "providerVisibility"))
+                    return agent;
+                return {
+                    ...agent,
+                    providerVisibility: (0, provider_visibility_1.isAgentProviderVisibility)(rawAgent.providerVisibility)
+                        ? rawAgent.providerVisibility
+                        : null,
+                };
+            }),
         };
     }
     catch {
@@ -390,7 +402,7 @@ function pruneDeliveredState(delivered, state) {
  * for production callers.
  */
 function flushPulse(deps) {
-    const state = buildPulseState(deps.snapshots, deps.bundlesRoot, deps.daemonVersion, deps.now);
+    const state = buildPulseState(deps.snapshots, deps.bundlesRoot, deps.daemonVersion, deps.now, readAgentActivity, (agentName, bundlePath) => (0, provider_visibility_1.buildAgentProviderVisibility)({ agentName, agentRoot: bundlePath }));
     /* v8 ignore start -- dep defaults: production daemon path; the arrow functions only fire when the corresponding dep is omitted, which only happens in production code paths. Tests inject all deps explicitly. @preserve */
     const readPrev = deps.readPrev ?? (() => readPulse());
     const writeNext = deps.writeNext ?? ((s) => writePulse(s));

package/dist/heart/outlook/outlook-view.js

@@ -173,6 +173,7 @@ function buildOutlookAgentView(input) {
             agentRoot: input.agent.agentRoot,
             enabled: input.agent.enabled,
             provider: input.agent.provider,
+            providers: input.agent.providers ?? null,
             senses: input.agent.senses,
             freshness: input.agent.freshness,
             degraded: input.agent.degraded,

package/dist/heart/outlook/readers/agent-machine.js

@@ -46,6 +46,7 @@ const session_activity_1 = require("../../session-activity");
 const identity_1 = require("../../identity");
 const agent_discovery_1 = require("../../daemon/agent-discovery");
 const runtime_metadata_1 = require("../../daemon/runtime-metadata");
+const provider_visibility_1 = require("../../provider-visibility");
 const thoughts_1 = require("../../daemon/thoughts");
 const outlook_types_1 = require("../outlook-types");
 const shared_1 = require("./shared");
@@ -266,6 +267,7 @@ function summarizeAgent(state) {
     return {
         agentName: state.agentName,
         enabled: state.enabled,
+        providers: state.providers,
         freshness: state.freshness,
         degraded: state.degraded,
         tasks: {
@@ -296,6 +298,7 @@ function readOutlookAgentState(agentName, options = {}) {
     issues.push(...inner.issues);
     const coding = readCodingSummary(agentRoot);
     issues.push(...coding.issues);
+    const providers = (0, provider_visibility_1.buildAgentProviderVisibility)({ agentName, agentRoot, homeDir: options.homeDir });
     const latestActivityAt = collectLatestActivityTimestamps({
         obligations: obligations.items,
         sessions: sessions.items,
@@ -308,6 +311,7 @@ function readOutlookAgentState(agentName, options = {}) {
         agentRoot,
         enabled: config.summary.enabled,
         provider: config.summary.provider,
+        providers,
         senses: config.summary.senses,
         freshness: summarizeFreshness(latestActivityAt, now),
         degraded: summarizeDegraded(issues),

package/dist/heart/provider-failover.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCredentialProvenanceLabel = formatCredentialProvenanceLabel;
+exports.formatReadyProviderLabel = formatReadyProviderLabel;
 exports.buildFailoverContext = buildFailoverContext;
 exports.handleFailoverReply = handleFailoverReply;
+exports.runMachineProviderFailoverInventory = runMachineProviderFailoverInventory;
+const identity_1 = require("./identity");
+const provider_ping_1 = require("./provider-ping");
 const provider_models_1 = require("./provider-models");
+const provider_credential_pool_1 = require("./provider-credential-pool");
 const runtime_1 = require("../nerves/runtime");
 const CLASSIFICATION_LABELS = {
     "auth-failure": "authentication failed",
@@ -26,6 +32,23 @@ function formatErrorDetail(errorMessage, errorSummary) {
         return "";
     return detail.length > 300 ? `${detail.slice(0, 297)}...` : detail;
 }
+function formatCredentialProvenanceLabel(candidate) {
+    if (candidate.contributedByAgent && candidate.source) {
+        return `credentials from ${candidate.contributedByAgent} via ${candidate.source}`;
+    }
+    if (candidate.contributedByAgent) {
+        return `credentials from ${candidate.contributedByAgent}`;
+    }
+    if (candidate.source) {
+        return `credentials from this machine via ${candidate.source}`;
+    }
+    return undefined;
+}
+function formatReadyProviderLabel(candidate) {
+    const provenance = formatCredentialProvenanceLabel(candidate);
+    const provenanceSuffix = provenance ? `; ${provenance}` : "";
+    return `${candidate.provider} (${candidate.model}${provenanceSuffix})`;
+}
 function formatFailingProviderLine(provider, classification, agentName) {
     const authCommand = `ouro auth --agent ${agentName} --provider ${provider}`;
     switch (classification) {
@@ -43,27 +66,64 @@ function formatFailingProviderLine(provider, classification, agentName) {
             return `  - ${provider}: could not be reached. Run \`${authCommand}\` if credentials may be stale.`;
     }
 }
-function buildFailoverContext(errorMessage, classification, currentProvider, currentModel, agentName, inventory, providerModels) {
-    const label = CLASSIFICATION_LABELS[classification];
-    const providerWithModel = formatProviderWithModel(currentProvider, currentModel);
-    const errorSummary = `${providerWithModel} ${label}`;
-    const errorDetail = formatErrorDetail(errorMessage, errorSummary);
-    const modelMismatch = (0, provider_models_1.getProviderModelMismatchMessage)(currentProvider, currentModel);
-    const workingProviders = [];
-    const unconfiguredProviders = [];
-    const failingProviders = [];
+function isProviderFailoverInventory(inventory) {
+    const candidate = inventory;
+    return Array.isArray(candidate.ready) && Array.isArray(candidate.unavailable) && Array.isArray(candidate.unconfigured);
+}
+function normalizeLegacyInventory(inventory, providerModels) {
+    const ready = [];
+    const unavailable = [];
+    const unconfigured = [];
     for (const [provider, result] of Object.entries(inventory)) {
         if (result.ok) {
-            workingProviders.push(provider);
+            ready.push({
+                provider,
+                model: (0, provider_models_1.resolveModelForProviderDisplay)(provider, providerModels[provider]),
+                result,
+            });
         }
         else if (result.classification === "auth-failure" && result.message === "no credentials configured") {
-            unconfiguredProviders.push(provider);
+            unconfigured.push(provider);
         }
         else {
             // Configured but ping failed (expired token, provider also down, etc.)
-            failingProviders.push({ provider, classification: result.classification });
+            unavailable.push({
+                provider,
+                model: (0, provider_models_1.resolveModelForProviderDisplay)(provider, providerModels[provider]),
+                result,
+            });
         }
     }
+    return { ready, unavailable, unconfigured };
+}
+function normalizeFailoverInventory(inventory, providerModels) {
+    if (!isProviderFailoverInventory(inventory)) {
+        return normalizeLegacyInventory(inventory, providerModels);
+    }
+    return {
+        ready: inventory.ready.map((candidate) => ({
+            ...candidate,
+            model: (0, provider_models_1.resolveModelForProviderDisplay)(candidate.provider, candidate.model),
+        })),
+        unavailable: inventory.unavailable.map((candidate) => ({
+            ...candidate,
+            model: candidate.model ? (0, provider_models_1.resolveModelForProviderDisplay)(candidate.provider, candidate.model) : undefined,
+        })),
+        unconfigured: [...inventory.unconfigured],
+    };
+}
+function buildFailoverContext(errorMessage, classification, currentProvider, currentModel, agentName, inventory, providerModels, options = {}) {
+    const currentLane = options.currentLane ?? "outward";
+    const label = CLASSIFICATION_LABELS[classification];
+    const providerWithModel = formatProviderWithModel(currentProvider, currentModel);
+    const errorSummary = `${providerWithModel} ${label}`;
+    const errorDetail = formatErrorDetail(errorMessage, errorSummary);
+    const modelMismatch = (0, provider_models_1.getProviderModelMismatchMessage)(currentProvider, currentModel);
+    const normalizedInventory = normalizeFailoverInventory(inventory, providerModels);
+    const readyProviders = normalizedInventory.ready;
+    const workingProviders = readyProviders.map((candidate) => candidate.provider);
+    const unconfiguredProviders = normalizedInventory.unconfigured;
+    const failingProviders = normalizedInventory.unavailable;
     const lines = [`${errorSummary}.`];
     if (errorDetail) {
         lines.push(`provider detail: ${errorDetail}`);
@@ -79,22 +139,20 @@ function buildFailoverContext(errorMessage, classification, currentProvider, cur
         lines.push("Config warning:");
         lines.push(`  - ${modelMismatch}`);
         lines.push("  - Repair the configured model with:");
-        lines.push(`    \`ouro config model --agent ${agentName} --facing human ${defaultModel}\``);
-        lines.push(`    \`ouro config model --agent ${agentName} --facing agent ${defaultModel}\``);
+        lines.push(`    \`ouro use --agent ${agentName} --lane ${currentLane} --provider ${currentProvider} --model ${defaultModel}\``);
     }
-    if (workingProviders.length > 0) {
+    if (readyProviders.length > 0) {
         lines.push("");
         lines.push("Ready providers:");
-        for (const provider of workingProviders) {
-            const model = (0, provider_models_1.resolveModelForProviderDisplay)(provider, providerModels[provider]);
-            lines.push(`  - ${provider} (${model}): reply "switch to ${provider}"`);
+        for (const candidate of readyProviders) {
+            lines.push(`  - ${formatReadyProviderLabel(candidate)}: reply "switch to ${candidate.provider}"`);
         }
     }
     if (failingProviders.length > 0) {
         lines.push("");
         lines.push("Configured but unavailable:");
-        for (const { provider, classification } of failingProviders) {
-            lines.push(formatFailingProviderLine(provider, classification, agentName));
+        for (const candidate of failingProviders) {
+            lines.push(formatFailingProviderLine(candidate.provider, candidate.result.classification, agentName));
         }
     }
     if (unconfiguredProviders.length > 0) {
@@ -112,24 +170,105 @@ function buildFailoverContext(errorMessage, classification, currentProvider, cur
         component: "engine",
         event: "engine.failover_context_built",
         message: "built provider failover context",
-        meta: { currentProvider, classification, workingProviders, unconfiguredProviders },
+        meta: { currentProvider, currentLane, classification, workingProviders, unconfiguredProviders },
     });
     return {
         errorSummary,
         classification,
         currentProvider,
+        currentLane,
         agentName,
         workingProviders,
+        readyProviders,
         unconfiguredProviders,
         userMessage: lines.join("\n"),
     };
 }
 function handleFailoverReply(reply, context) {
     const lower = reply.toLowerCase().trim();
-    for (const provider of context.workingProviders) {
-        if (lower.includes(`switch to ${provider}`) || lower === provider) {
-            return { action: "switch", provider };
+    const readyProviders = context.readyProviders ?? context.workingProviders.map((provider) => ({
+        provider,
+        model: (0, provider_models_1.resolveModelForProviderDisplay)(provider),
+    }));
+    const currentLane = context.currentLane ?? "outward";
+    for (const candidate of readyProviders) {
+        if (lower.includes(`switch to ${candidate.provider}`) || lower === candidate.provider) {
+            return {
+                action: "switch",
+                provider: candidate.provider,
+                model: candidate.model,
+                lane: currentLane,
+                ...(candidate.credentialRevision ? { credentialRevision: candidate.credentialRevision } : {}),
+                ...(candidate.source ? { source: candidate.source } : {}),
+                ...(candidate.contributedByAgent ? { contributedByAgent: candidate.contributedByAgent } : {}),
+            };
         }
     }
     return { action: "dismiss" };
 }
+function candidateFromCredentialRecord(record) {
+    return {
+        provider: record.provider,
+        credentialRevision: record.revision,
+        source: record.provenance.source,
+        contributedByAgent: record.provenance.contributedByAgent,
+    };
+}
+async function runMachineProviderFailoverInventory(agentName, currentProvider, options = {}) {
+    const ping = options.ping ?? provider_ping_1.pingProvider;
+    const poolResult = (0, provider_credential_pool_1.readProviderCredentialPool)(options.homeDir);
+    const providers = Object.keys(identity_1.PROVIDER_CREDENTIALS).filter((provider) => provider !== currentProvider);
+    const inventory = { ready: [], unavailable: [], unconfigured: [] };
+    if (!poolResult.ok) {
+        inventory.unconfigured.push(...providers);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.machine_failover_inventory_built",
+            message: "built machine provider failover inventory",
+            meta: { agentName, currentProvider, credentialPoolStatus: poolResult.reason, readyCount: 0, unavailableCount: 0, unconfiguredCount: inventory.unconfigured.length },
+        });
+        return inventory;
+    }
+    const results = await Promise.all(providers.map(async (provider) => {
+        const record = poolResult.pool.providers[provider];
+        if (!record)
+            return { provider, record: undefined, result: undefined };
+        const model = (0, provider_models_1.getDefaultModelForProvider)(provider);
+        const config = { ...record.credentials, ...record.config };
+        const result = await ping(provider, config, { model });
+        return { provider, record, model, result };
+    }));
+    for (const entry of results) {
+        if (!entry.record) {
+            inventory.unconfigured.push(entry.provider);
+        }
+        else if (entry.result.ok) {
+            inventory.ready.push({
+                ...candidateFromCredentialRecord(entry.record),
+                model: entry.model,
+                result: entry.result,
+            });
+        }
+        else {
+            inventory.unavailable.push({
+                ...candidateFromCredentialRecord(entry.record),
+                model: entry.model,
+                result: entry.result,
+            });
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.machine_failover_inventory_built",
+        message: "built machine provider failover inventory",
+        meta: {
+            agentName,
+            currentProvider,
+            credentialPoolStatus: "present",
+            readyCount: inventory.ready.length,
+            unavailableCount: inventory.unavailable.length,
+            unconfiguredCount: inventory.unconfigured.length,
+        },
+    });
+    return inventory;
+}

package/dist/heart/provider-visibility.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentProviderVisibility = buildAgentProviderVisibility;
+exports.formatProviderVisibilityLine = formatProviderVisibilityLine;
+exports.formatAgentProviderVisibilityForPrompt = formatAgentProviderVisibilityForPrompt;
+exports.formatAgentProviderVisibilityForStartOfTurn = formatAgentProviderVisibilityForStartOfTurn;
+exports.formatAgentProviderVisibilityForPulse = formatAgentProviderVisibilityForPulse;
+exports.providerVisibilityStatusRows = providerVisibilityStatusRows;
+exports.isAgentProviderVisibility = isAgentProviderVisibility;
+const runtime_1 = require("../nerves/runtime");
+const provider_binding_resolver_1 = require("./provider-binding-resolver");
+const LANES = ["outward", "inner"];
+function credentialVisibility(binding) {
+    const credential = binding.credential;
+    if (credential.status === "present") {
+        return {
+            status: "present",
+            source: credential.source,
+            contributedByAgent: credential.contributedByAgent,
+            revision: credential.revision,
+        };
+    }
+    return {
+        status: credential.status,
+        repairCommand: credential.repair.command,
+    };
+}
+function readinessVisibility(binding) {
+    return {
+        status: binding.readiness.status,
+        ...(binding.readiness.checkedAt ? { checkedAt: binding.readiness.checkedAt } : {}),
+        ...(binding.readiness.error ? { error: binding.readiness.error } : {}),
+        ...(binding.readiness.reason ? { reason: binding.readiness.reason } : {}),
+        ...(binding.readiness.attempts !== undefined ? { attempts: binding.readiness.attempts } : {}),
+    };
+}
+function visibilityForLane(input, lane) {
+    const resolved = (0, provider_binding_resolver_1.resolveEffectiveProviderBinding)({ ...input, lane });
+    if (!resolved.ok) {
+        return {
+            lane,
+            status: "unconfigured",
+            provider: "unconfigured",
+            model: "-",
+            source: "missing",
+            readiness: {
+                status: "unknown",
+                reason: resolved.reason,
+            },
+            credential: {
+                status: "missing",
+                repairCommand: resolved.repair.command,
+            },
+            repairCommand: resolved.repair.command,
+            reason: resolved.reason,
+            warnings: resolved.warnings.map((warning) => warning.message),
+        };
+    }
+    return {
+        lane,
+        status: "configured",
+        provider: resolved.binding.provider,
+        model: resolved.binding.model,
+        source: resolved.binding.source,
+        readiness: readinessVisibility(resolved.binding),
+        credential: credentialVisibility(resolved.binding),
+        warnings: resolved.binding.warnings.map((warning) => warning.message),
+    };
+}
+function buildAgentProviderVisibility(input) {
+    const visibility = {
+        agentName: input.agentName,
+        lanes: LANES.map((lane) => visibilityForLane(input, lane)),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.provider_visibility_built",
+        message: "built provider visibility summary",
+        meta: {
+            agentName: input.agentName,
+            laneStatuses: visibility.lanes.map((lane) => `${lane.lane}:${lane.status}`).join(","),
+        },
+    });
+    return visibility;
+}
+function credentialLabel(credential) {
+    if (credential.status === "present") {
+        const source = credential.source ?? "unknown";
+        return credential.contributedByAgent ? `${source} from ${credential.contributedByAgent}` : source;
+    }
+    if (credential.status === "invalid-pool")
+        return "invalid pool";
+    return "missing";
+}
+function readinessLabel(readiness) {
+    if (readiness.status === "failed") {
+        return readiness.error ? `failed: ${readiness.error}` : "failed";
+    }
+    if (readiness.status === "stale") {
+        return readiness.reason ? `stale: ${readiness.reason}` : "stale";
+    }
+    if (readiness.status === "unknown") {
+        return readiness.reason ? `unknown: ${readiness.reason}` : "unknown";
+    }
+    return readiness.status;
+}
+function formatProviderVisibilityLine(lane) {
+    if (lane.status === "unconfigured") {
+        return `${lane.lane}: unconfigured (${lane.reason}); repair: ${lane.repairCommand}`;
+    }
+    const parts = [
+        readinessLabel(lane.readiness),
+        `source: ${lane.source}`,
+        `credentials: ${credentialLabel(lane.credential)}`,
+    ];
+    if (lane.credential.revision)
+        parts.push(`revision: ${lane.credential.revision}`);
+    if (lane.credential.repairCommand)
+        parts.push(`repair: ${lane.credential.repairCommand}`);
+    if (lane.warnings.length > 0)
+        parts.push(`warnings: ${lane.warnings.join("; ")}`);
+    return `${lane.lane}: ${lane.provider} / ${lane.model} [${parts.join("; ")}]`;
+}
+function formatAgentProviderVisibilityForPrompt(visibility) {
+    if (visibility.lanes.every((lane) => lane.status === "unconfigured")) {
+        return [
+            "provider bindings are not configured on this machine.",
+            ...visibility.lanes.map((lane) => `- ${formatProviderVisibilityLine(lane)}`),
+        ].join("\n");
+    }
+    return [
+        "runtime uses local provider bindings for this machine:",
+        ...visibility.lanes.map((lane) => `- ${formatProviderVisibilityLine(lane)}`),
+    ].join("\n");
+}
+function formatAgentProviderVisibilityForStartOfTurn(visibility) {
+    return visibility.lanes.map((lane) => `- ${formatProviderVisibilityLine(lane)}`).join("\n");
+}
+function formatAgentProviderVisibilityForPulse(visibility) {
+    return visibility.lanes.map((lane) => formatProviderVisibilityLine(lane)).join("; ");
+}
+function providerVisibilityStatusRows(visibility) {
+    return visibility.lanes.map((lane) => {
+        if (lane.status === "unconfigured") {
+            return {
+                agent: visibility.agentName,
+                lane: lane.lane,
+                provider: "unconfigured",
+                model: "-",
+                source: "missing",
+                readiness: "unknown",
+                detail: lane.repairCommand,
+                credential: "missing",
+            };
+        }
+        return {
+            agent: visibility.agentName,
+            lane: lane.lane,
+            provider: lane.provider,
+            model: lane.model,
+            source: lane.source,
+            readiness: lane.readiness.status,
+            ...(lane.readiness.error ? { detail: lane.readiness.error } : {}),
+            credential: credentialLabel(lane.credential),
+        };
+    });
+}
+function isAgentProviderVisibility(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    if (typeof record.agentName !== "string")
+        return false;
+    if (!Array.isArray(record.lanes))
+        return false;
+    return record.lanes.every((lane) => {
+        if (!lane || typeof lane !== "object" || Array.isArray(lane))
+            return false;
+        const laneRecord = lane;
+        return (laneRecord.lane === "outward" || laneRecord.lane === "inner")
+            && (laneRecord.status === "configured" || laneRecord.status === "unconfigured");
+    });
+}

package/dist/heart/start-of-turn-packet.js

@@ -228,6 +228,7 @@ function renderStartOfTurnPacket(packet) {
         // are actionable "fix your git" signals. bundleState is preferred
         // because it's structured (array of enum values) while syncFailure is
         // a legacy free-form string; both render when populated.
+        { label: "provider", content: packet.providerState ?? "", priority: 8 },
         { label: "bundleState", content: (0, bundle_state_1.renderBundleStateHint)(packet.bundleState ?? []), priority: 7 },
         { label: "syncFailure", content: packet.syncFailure ?? "", priority: 7 },
         { label: "resume", content: packet.resumeHint, priority: 6 },
@@ -305,6 +306,9 @@ function formatSections(sections) {
             case "bundleState":
                 parts.push(`**Bundle:** ${section.content}`);
                 break;
+            case "provider":
+                parts.push(`**Provider:**\n${section.content}`);
+                break;
         }
     }
     return parts.join("\n\n");

package/dist/heart/turn-context.js

@@ -59,6 +59,7 @@ const cares_1 = require("../arc/cares");
 const config_1 = require("./config");
 const daemon_health_1 = require("./daemon/daemon-health");
 const prompt_1 = require("../mind/prompt");
+const provider_visibility_1 = require("./provider-visibility");
 // ── Helpers ─────────────────────────────────────────────────────────
 const DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
 function isLiveCodingSessionStatus(status) {
@@ -306,6 +307,7 @@ async function buildTurnContext(input) {
         /* v8 ignore stop */
     }
     const bundleMeta = readBundleMetaFile();
+    const providerVisibility = (0, provider_visibility_1.buildAgentProviderVisibility)({ agentName, agentRoot });
     let daemonHealth = null;
     try {
         daemonHealth = (0, daemon_health_1.readHealth)((0, daemon_health_1.getDefaultHealthPath)());
@@ -333,6 +335,7 @@ async function buildTurnContext(input) {
             bridgeCount: activeBridges.length,
             codingSessionCount: codingSessions.length,
             episodeCount: recentEpisodes.length,
+            providerLaneCount: providerVisibility.lanes.length,
         },
     });
     return {
@@ -349,6 +352,7 @@ async function buildTurnContext(input) {
         activeCares,
         syncConfig,
         syncFailure: undefined, // Set by pipeline after preTurnPull
+        providerVisibility,
         daemonRunning,
         senseStatusLines,
         bundleMeta,

package/dist/mind/prompt.js

@@ -78,6 +78,7 @@ const obligation_steering_1 = require("./obligation-steering");
 const daemon_health_1 = require("../heart/daemon/daemon-health");
 const scrutiny_1 = require("./scrutiny");
 const pulse_1 = require("../heart/daemon/pulse");
+const provider_visibility_1 = require("../heart/provider-visibility");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
 let _senseStatusLinesCache = null;
@@ -459,7 +460,10 @@ function senseRuntimeGuidance(channel, preReadStatusLines) {
     }
     return lines;
 }
-function providerSection(channel) {
+function providerSection(channel, options) {
+    if (options?.providerVisibility) {
+        return `## my provider\n${(0, provider_visibility_1.formatAgentProviderVisibilityForPrompt)(options.providerVisibility)}`;
+    }
     return `## my provider\n${(0, core_1.getProviderDisplayLabel)((0, channel_1.channelToFacing)(channel))}`;
 }
 function dateSection() {
@@ -727,6 +731,8 @@ function pulseSection(channel = "cli") {
             if (sib.fixHint)
                 lines.push(`  fix: ${sib.fixHint}`);
             lines.push(`  bundle: \`${sib.bundlePath}\``);
+            if (sib.providerVisibility)
+                lines.push(`  provider: ${(0, provider_visibility_1.formatAgentProviderVisibilityForPulse)(sib.providerVisibility)}`);
         }
         lines.push("");
     }
@@ -737,6 +743,8 @@ function pulseSection(channel = "cli") {
         for (const sib of healthy) {
             const activity = sib.currentActivity ? ` — ${sib.currentActivity}` : "";
             lines.push(`- **${sib.name}** is running${activity}. bundle: \`${sib.bundlePath}\``);
+            if (sib.providerVisibility)
+                lines.push(`  provider: ${(0, provider_visibility_1.formatAgentProviderVisibilityForPulse)(sib.providerVisibility)}`);
         }
         lines.push("");
     }
@@ -744,6 +752,8 @@ function pulseSection(channel = "cli") {
         lines.push("**idle siblings** — configured but not currently running:");
         for (const sib of idle) {
             lines.push(`- **${sib.name}** (status: ${sib.status}). bundle: \`${sib.bundlePath}\``);
+            if (sib.providerVisibility)
+                lines.push(`  provider: ${(0, provider_visibility_1.formatAgentProviderVisibilityForPulse)(sib.providerVisibility)}`);
         }
         lines.push("");
     }
@@ -1260,7 +1270,7 @@ async function buildSystem(channel = "cli", options, context) {
         runtimeInfoSection(channel, options),
         rhythmStatusSection(options?.daemonHealth),
         channelNatureSection((0, channel_1.getChannelCapabilities)(channel)),
-        providerSection(channel),
+        providerSection(channel, options),
         dateSection(),
         // Group 3: my tools & capabilities
         "# my tools & capabilities",

package/dist/senses/pipeline.js

@@ -52,9 +52,7 @@ const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
 const obligations_1 = require("../arc/obligations");
 const provider_failover_1 = require("../heart/provider-failover");
-const provider_ping_1 = require("../heart/provider-ping");
-const auth_flow_1 = require("../heart/auth/auth-flow");
-const provider_models_1 = require("../heart/provider-models");
+const provider_state_1 = require("../heart/provider-state");
 const tempo_1 = require("../heart/tempo");
 const temporal_view_1 = require("../heart/temporal-view");
 const start_of_turn_packet_1 = require("../heart/start-of-turn-packet");
@@ -65,6 +63,7 @@ const session_events_1 = require("../heart/session-events");
 const presence_1 = require("../arc/presence");
 const episodes_1 = require("../arc/episodes");
 const turn_context_1 = require("../heart/turn-context");
+const provider_visibility_1 = require("../heart/provider-visibility");
 /**
  * Emit episodes for obligation state transitions detected during a turn.
  * Exported for direct testability (avoids v8 coverage merge issues in multi-file test suites).
@@ -85,6 +84,52 @@ function emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postT
         }
     }
 }
+function providerLaneForChannel(channel) {
+    return channel === "inner" ? "inner" : "outward";
+}
+function resolveCurrentFailoverBinding(agentName, lane) {
+    const stateResult = (0, provider_state_1.readProviderState)((0, identity_1.getAgentRoot)(agentName));
+    if (stateResult.ok) {
+        const binding = stateResult.state.lanes[lane];
+        return { provider: binding.provider, model: binding.model };
+    }
+    const agentConfig = (0, identity_1.loadAgentConfig)();
+    const fallback = lane === "inner" ? agentConfig.agentFacing : agentConfig.humanFacing;
+    return { provider: fallback.provider, model: fallback.model };
+}
+function writeFailoverProviderStateSwitch(agentName, action) {
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const stateResult = (0, provider_state_1.readProviderState)(agentRoot);
+    if (!stateResult.ok) {
+        throw new Error(`Cannot switch ${action.lane} lane for ${agentName}: ${stateResult.error}`);
+    }
+    const updatedAt = new Date().toISOString();
+    const lanes = { ...stateResult.state.lanes };
+    lanes[action.lane] = {
+        provider: action.provider,
+        model: action.model,
+        source: "local",
+        updatedAt,
+    };
+    const readiness = { ...stateResult.state.readiness };
+    readiness[action.lane] = {
+        status: "ready",
+        provider: action.provider,
+        model: action.model,
+        checkedAt: updatedAt,
+        ...(action.credentialRevision ? { credentialRevision: action.credentialRevision } : {}),
+    };
+    (0, provider_state_1.writeProviderState)(agentRoot, {
+        ...stateResult.state,
+        updatedAt,
+        lanes,
+        readiness,
+    });
+}
+function formatFailoverSwitchLabel(action) {
+    const provenance = (0, provider_failover_1.formatCredentialProvenanceLabel)(action);
+    return `${action.provider} (${action.model}${provenance ? `; ${provenance}` : ""})`;
+}
 function prependTurnSections(message, sections) {
     /* v8 ignore next -- defensive: only user messages with non-empty sections reach here @preserve */
     if (message.role !== "user" || sections.length === 0)
@@ -133,8 +178,7 @@ async function handleInboundTurn(input) {
         if (failoverAction.action === "switch") {
             let switchSucceeded = false;
             try {
-                (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "human", failoverAction.provider);
-                (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "agent", failoverAction.provider);
+                writeFailoverProviderStateSwitch(failoverAgentName, failoverAction);
                 switchSucceeded = true;
                 /* v8 ignore start -- defensive: write failure during provider switch @preserve */
             }
@@ -143,8 +187,8 @@ async function handleInboundTurn(input) {
                     level: "error",
                     component: "senses",
                     event: "senses.failover_switch_error",
-                    message: `failed to switch provider to ${failoverAction.provider}`,
-                    meta: { agentName: failoverAgentName, provider: failoverAction.provider, error: switchError instanceof Error ? switchError.message : String(switchError) },
+                    message: `failed to switch ${failoverAction.lane} provider lane to ${failoverAction.provider}`,
+                    meta: { agentName: failoverAgentName, lane: failoverAction.lane, provider: failoverAction.provider, model: failoverAction.model, error: switchError instanceof Error ? switchError.message : String(switchError) },
                 });
             }
             /* v8 ignore stop */
@@ -153,28 +197,24 @@ async function handleInboundTurn(input) {
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.failover_switch",
-                    message: `switched provider to ${failoverAction.provider} via failover`,
-                    meta: { agentName: failoverAgentName, provider: failoverAction.provider },
+                    message: `switched ${failoverAction.lane} provider lane to ${failoverAction.provider} via failover`,
+                    meta: {
+                        agentName: failoverAgentName,
+                        lane: failoverAction.lane,
+                        provider: failoverAction.provider,
+                        model: failoverAction.model,
+                        credentialRevision: failoverAction.credentialRevision,
+                        source: failoverAction.source,
+                        contributedByAgent: failoverAction.contributedByAgent,
+                    },
                 });
                 // Replace "switch to <provider>" with a context message for the agent.
                 // The session already has the user's original question from the failed turn.
                 // The agent needs to know what happened so it can respond appropriately.
-                const newProviderSecrets = (() => {
-                    try {
-                        const { secrets } = (0, auth_flow_1.loadAgentSecrets)(failoverAgentName);
-                        const cfg = secrets.providers[failoverAction.provider];
-                        const hint = cfg?.model ?? cfg?.modelName;
-                        return (0, provider_models_1.resolveModelForProviderDisplay)(failoverAction.provider, typeof hint === "string" ? hint : "");
-                        /* v8 ignore next 2 -- defensive: secrets read failure @preserve */
-                    }
-                    catch {
-                        return (0, provider_models_1.resolveModelForProviderDisplay)(failoverAction.provider);
-                    }
-                })();
-                const newProviderLabel = `${failoverAction.provider} (${newProviderSecrets})`;
+                const newProviderLabel = formatFailoverSwitchLabel(failoverAction);
                 input.messages = [{
                         role: "user",
-                        content: `[provider switch: ${pendingContext.errorSummary}. switched to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,
+                        content: `[provider switch: ${pendingContext.errorSummary}. switched ${failoverAction.lane} lane to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,
                     }];
                 input.switchedProvider = failoverAction.provider;
             }
@@ -396,6 +436,9 @@ async function handleInboundTurn(input) {
             if (syncFailure) {
                 startOfTurnPacket.syncFailure = syncFailure;
             }
+            if (ctx.providerVisibility) {
+                startOfTurnPacket.providerState = (0, provider_visibility_1.formatAgentProviderVisibilityForStartOfTurn)(ctx.providerVisibility);
+            }
             // Structured bundle state detection — surfaces discrete issues the
             // agent can remediate via the bundle_* tools. Runs independently of
             // syncFailure so the two signals coexist during the transition away
@@ -450,6 +493,7 @@ async function handleInboundTurn(input) {
             bundleMeta: ctx.bundleMeta,
             daemonHealth: ctx.daemonHealth,
             journalFiles: ctx.journalFiles,
+            ...(ctx.providerVisibility ? { providerVisibility: ctx.providerVisibility } : {}),
             toolContext: {
                 /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
                 signin: async () => undefined,
@@ -465,23 +509,15 @@ async function handleInboundTurn(input) {
         if (result.outcome === "errored" && input.failoverState) {
             try {
                 const agentName = (0, identity_1.getAgentName)();
-                const agentConfig = (0, identity_1.loadAgentConfig)();
-                const currentProvider = agentConfig.humanFacing.provider;
+                const currentLane = providerLaneForChannel(input.channel);
+                const currentBinding = resolveCurrentFailoverBinding(agentName, currentLane);
+                const currentProvider = currentBinding.provider;
                 /* v8 ignore next -- defensive: errorClassification always set when errored @preserve */
                 const classification = result.errorClassification ?? "unknown";
-                const inventory = await (0, provider_ping_1.runHealthInventory)(agentName, currentProvider);
-                const { secrets } = (0, auth_flow_1.loadAgentSecrets)(agentName);
-                const providerModels = {};
-                for (const [p, cfg] of Object.entries(secrets.providers)) {
-                    const model = cfg.model ?? cfg.modelName;
-                    if (typeof model === "string" && model)
-                        providerModels[p] = model;
-                }
-                // Use agent.json model (source of truth), not secrets model (may be stale)
-                const currentModel = agentConfig.humanFacing.model;
+                const inventory = await (0, provider_failover_1.runMachineProviderFailoverInventory)(agentName, currentProvider);
                 const failoverContext = (0, provider_failover_1.buildFailoverContext)(
                 /* v8 ignore next -- defensive: error always set when errored @preserve */
-                result.error?.message ?? "unknown error", classification, currentProvider, currentModel, agentName, inventory, providerModels);
+                result.error?.message ?? "unknown error", classification, currentProvider, currentBinding.model, agentName, inventory, {}, { currentLane });
                 input.failoverState.pending = failoverContext;
                 input.postTurn(sessionMessages, session.sessionPath, result.usage);
                 return {

package/package.json

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