@ouro.bot/cli 0.1.0-alpha.351 → 0.1.0-alpha.353

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.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": [
+        "Settle tool description now communicates turn-ending semantics: 'deliver your response and end your turn' with explicit guidance against settling with status updates mid-task.",
+        "Observe tool now available in all outward channels including 1:1 chats, not just groups and reactions — agents can absorb messages without responding when the moment doesn't call for words.",
+        "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": [

package/dist/heart/core.js

@@ -556,8 +556,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     while (!done) {
         // Channel-based tool filtering:
         // - Inner dialog: exclude send_message (delivery via surface), observe (no one to observe)
-        // - 1:1 sessions: exclude observe (can't ignore someone talking directly to you)
-        // - Group chats: observe available
+        // - All outward channels (1:1, group, reaction): observe available
         //
         // ponder, settle/rest, surface, and observe are always assembled based on channel context.
         // ponder is available in ALL channels (outer: think privately, inner: keep turning).
@@ -571,7 +570,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ...filteredBaseTools,
             tools_1.ponderTool,
             ...(isInnerDialog ? [tools_2.surfaceToolDef, tools_1.restTool] : []),
-            ...((currentContext?.isGroupChat || options?.isReactionSignal) && !isInnerDialog ? [tools_1.observeTool] : []),
+            ...(!isInnerDialog ? [tools_1.observeTool] : []),
             ...(!isInnerDialog ? [tools_1.settleTool] : []),
         ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];

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/mind/prompt.js

@@ -609,6 +609,8 @@ function toolContractsSection(channel, options) {
             lines.push(`- When I am ready to respond to the user, I call \`settle\`.`);
             lines.push(`- \`settle\` must be the only tool call in that turn.`);
             lines.push(`- I do not call no-op tools before \`settle\`.`);
+            lines.push(`- when told to work autonomously, I use ponder to absorb new messages and continue using tools. I settle only with the final result.`);
+            lines.push(`- if nothing calls for words, I observe.`);
         }
     }
     return lines.join("\n");

package/dist/repertoire/tools-flow.js

@@ -72,7 +72,7 @@ exports.settleTool = {
     type: "function",
     function: {
         name: "settle",
-        description: "respond to the user with your message. call this tool when you are ready to deliver your response. Only call when you have a substantive response. If you're settling with 'I'll look into that,' you probably should be using a tool instead.",
+        description: "deliver your response and end your turn — this hands control back to the user. only settle when your work is complete, you're genuinely blocked, or the user asked a direct question that needs an answer now. do not settle with status updates mid-task. if you're settling with 'I'll look into that,' you probably should be using a tool instead.",
         parameters: {
             type: "object",
             properties: {

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");
@@ -85,6 +83,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 +177,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 +186,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 +196,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;
             }
@@ -465,23 +504,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.351",
+  "version": "0.1.0-alpha.353",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",