@ouro.bot/cli 0.1.0-alpha.157 → 0.1.0-alpha.159

package/dist/heart/daemon/hatch-flow.js

@@ -134,6 +134,8 @@ function writeDiaryScaffold(bundleRoot) {
 function writeHatchlingAgentConfig(bundleRoot, input) {
     const template = (0, identity_1.buildDefaultAgentTemplate)(input.agentName);
     template.provider = input.provider;
+    template.humanFacing = { provider: input.provider, model: template.humanFacing.model };
+    template.agentFacing = { provider: input.provider, model: template.agentFacing.model };
     template.enabled = true;
     fs.writeFileSync(path.join(bundleRoot, "agent.json"), `${JSON.stringify(template, null, 2)}\n`, "utf-8");
 }

package/dist/heart/daemon/hooks/agent-config-v2.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentConfigV2Hook = agentConfigV2Hook;
+const runtime_1 = require("../../../nerves/runtime");
+const migrate_config_1 = require("../../migrate-config");
+async function agentConfigV2Hook(ctx) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_config_v2_hook_start",
+        message: "running agent-config-v2 update hook",
+        meta: { agentRoot: ctx.agentRoot, currentVersion: ctx.currentVersion },
+    });
+    try {
+        (0, migrate_config_1.migrateAgentConfigV1ToV2)(ctx.agentRoot);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_config_v2_hook_error",
+            message: "agent-config-v2 hook migration failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_config_v2_hook_end",
+        message: "agent-config-v2 hook completed",
+        meta: { agentRoot: ctx.agentRoot },
+    });
+    return { ok: true };
+}

package/dist/heart/daemon/run-hooks.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runHooks = runHooks;
 const runtime_1 = require("../../nerves/runtime");
 const bundle_meta_1 = require("./hooks/bundle-meta");
+const agent_config_v2_1 = require("./hooks/agent-config-v2");
 async function runHooks(deps) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -12,6 +13,7 @@ async function runHooks(deps) {
     });
     try {
         deps.registerUpdateHook(bundle_meta_1.bundleMetaHook);
+        deps.registerUpdateHook(agent_config_v2_1.agentConfigV2Hook);
         const currentVersion = deps.getPackageVersion();
         await deps.applyPendingUpdates(deps.bundlesRoot, currentVersion);
         (0, runtime_1.emitNervesEvent)({

package/dist/heart/daemon/specialist-prompt.js

@@ -59,8 +59,10 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "It also needs an **agent.json** with at minimum:",
         '```json',
         '{',
+        '  "version": 2,',
         '  "name": "AgentName",',
-        `  "provider": "${context.provider}",`,
+        `  "humanFacing": { "provider": "${context.provider}", "model": "${context.model}" },`,
+        `  "agentFacing": { "provider": "${context.provider}", "model": "${context.model}" },`,
         '  "enabled": true',
         '}',
         '```',

package/dist/heart/identity.js

@@ -56,6 +56,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
+const migrate_config_1 = require("./migrate-config");
 exports.DEFAULT_AGENT_CONTEXT = {
     maxTokens: 80000,
     contextMargin: 20,
@@ -123,9 +124,10 @@ function normalizeSenses(value, configFile) {
 }
 function buildDefaultAgentTemplate(_agentName) {
     return {
-        version: 1,
+        version: 2,
         enabled: true,
-        provider: "anthropic",
+        humanFacing: { provider: "anthropic", model: "claude-opus-4-6" },
+        agentFacing: { provider: "anthropic", model: "claude-opus-4-6" },
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
         senses: {
             cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
@@ -231,17 +233,11 @@ function getAgentToolsRoot(agentName) {
 function getAgentSecretsPath(agentName = getAgentName()) {
     return path.join(os.homedir(), ".agentsecrets", agentName, "secrets.json");
 }
-/**
- * Load and parse `<agentRoot>/agent.json`.
- * Reads the file fresh on each call unless an override is set.
- * Throws descriptive error if file is missing or contains invalid JSON.
- */
-function loadAgentConfig() {
-    if (_agentConfigOverride) {
-        return _agentConfigOverride;
-    }
-    const agentRoot = getAgentRoot();
-    const configFile = path.join(agentRoot, "agent.json");
+const VALID_PROVIDERS = ["azure", "minimax", "anthropic", "openai-codex", "github-copilot"];
+function isValidProvider(value) {
+    return typeof value === "string" && VALID_PROVIDERS.includes(value);
+}
+function readAndParseAgentJson(configFile) {
     let raw;
     try {
         raw = fs.readFileSync(configFile, "utf-8");
@@ -259,9 +255,8 @@ function loadAgentConfig() {
         });
         throw new Error(`Cannot read agent.json at ${configFile}. Does the agent directory exist?`);
     }
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        return JSON.parse(raw);
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -276,6 +271,62 @@ function loadAgentConfig() {
         });
         throw new Error(`Invalid JSON in agent.json at ${configFile}. Check syntax.`);
     }
+}
+function validateFacingConfig(parsed, facingName, configFile) {
+    const raw = parsed[facingName];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config missing or invalid ${facingName}`,
+            meta: { path: configFile, [facingName]: raw ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} must include ${facingName} as { provider, model }.`);
+    }
+    const facing = raw;
+    if (!isValidProvider(facing.provider)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config has invalid provider in ${facingName}`,
+            meta: { path: configFile, provider: facing.provider ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} ${facingName}.provider must be one of: ${VALID_PROVIDERS.join(", ")}.`);
+    }
+    if (typeof facing.model !== "string") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: `agent config has invalid model in ${facingName}`,
+            meta: { path: configFile, model: facing.model ?? null },
+        });
+        throw new Error(`agent.json at ${configFile} ${facingName}.model must be a string.`);
+    }
+    return { provider: facing.provider, model: facing.model };
+}
+/**
+ * Load and parse `<agentRoot>/agent.json`.
+ * Reads the file fresh on each call unless an override is set.
+ * If the config is v1, auto-migrates to v2 via migrateAgentConfigV1ToV2 and re-reads.
+ * Throws descriptive error if file is missing or contains invalid JSON.
+ */
+function loadAgentConfig() {
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
+    }
+    const agentRoot = getAgentRoot();
+    const configFile = path.join(agentRoot, "agent.json");
+    let parsed = readAndParseAgentJson(configFile);
+    // Inline migration: v1 -> v2
+    const rawVersion = parsed.version;
+    const initialVersion = typeof rawVersion === "number" ? rawVersion : 1;
+    if (initialVersion < 2) {
+        (0, migrate_config_1.migrateAgentConfigV1ToV2)(agentRoot);
+        parsed = readAndParseAgentJson(configFile);
+    }
     const existingPhrases = parsed.phrases;
     const needsFill = !existingPhrases ||
         !existingPhrases.thinking ||
@@ -297,29 +348,11 @@ function loadAgentConfig() {
         });
         fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
     }
-    const rawProvider = parsed.provider;
-    if (rawProvider !== "azure" &&
-        rawProvider !== "minimax" &&
-        rawProvider !== "anthropic" &&
-        rawProvider !== "openai-codex" &&
-        rawProvider !== "github-copilot") {
-        (0, runtime_1.emitNervesEvent)({
-            level: "error",
-            event: "config_identity.error",
-            component: "config/identity",
-            message: "agent config missing or invalid provider",
-            meta: {
-                path: configFile,
-                provider: rawProvider,
-            },
-        });
-        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", "openai-codex", or "github-copilot".`);
-    }
-    const provider = rawProvider;
-    const rawVersion = parsed.version;
-    const version = rawVersion === undefined ? 1 : rawVersion;
-    if (typeof version !== "number" ||
-        !Number.isInteger(version) ||
+    // Validate v2 facing configs
+    const humanFacing = validateFacingConfig(parsed, "humanFacing", configFile);
+    const agentFacing = validateFacingConfig(parsed, "agentFacing", configFile);
+    const version = typeof parsed.version === "number" ? parsed.version : 1;
+    if (!Number.isInteger(version) ||
         version < 1) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -328,7 +361,7 @@ function loadAgentConfig() {
             message: "agent config missing or invalid version",
             meta: {
                 path: configFile,
-                version: rawVersion,
+                version: parsed.version,
             },
         });
         throw new Error(`agent.json at ${configFile} must include version as integer >= 1.`);
@@ -348,10 +381,15 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
     }
+    // Tolerate deprecated provider field for backward compatibility
+    const rawProvider = parsed.provider;
+    const provider = isValidProvider(rawProvider) ? rawProvider : undefined;
     const config = {
         version,
         enabled,
-        provider,
+        ...(provider !== undefined ? { provider } : {}),
+        humanFacing,
+        agentFacing,
         context: parsed.context,
         logging: parsed.logging,
         senses: normalizeSenses(parsed.senses, configFile),

package/dist/heart/migrate-config.js

@@ -0,0 +1,127 @@
+"use strict";
+// v1 → v2 agent.json migration.
+// Moves model from secrets.json into agent.json under humanFacing/agentFacing.
+// Uses raw fs — NO import from config.ts (avoids circular dependency).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateAgentConfigV1ToV2 = migrateAgentConfigV1ToV2;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const MODEL_FIELD = {
+    azure: "modelName",
+    minimax: "model",
+    anthropic: "model",
+    "openai-codex": "model",
+    "github-copilot": "model",
+};
+function resolveSecretsPath(agentRoot, deps) {
+    const agentName = path.basename(agentRoot).replace(/\.ouro$/, "");
+    const secretsBase = deps?.secretsRoot ?? path.join(require("os").homedir(), ".agentsecrets");
+    return path.join(secretsBase, agentName, "secrets.json");
+}
+function migrateAgentConfigV1ToV2(agentRoot, deps) {
+    const configPath = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return; // No agent.json — nothing to migrate
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Cannot parse agent.json at ${configPath} — invalid JSON`);
+    }
+    const version = typeof config.version === "number" ? config.version : 1;
+    if (version >= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config_identity.migrate_skip",
+            message: "agent config already v2, skipping migration",
+            meta: { agentRoot },
+        });
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_start",
+        message: "migrating agent config v1 → v2",
+        meta: { agentRoot },
+    });
+    const provider = config.provider;
+    let model = "";
+    if (provider) {
+        const secretsPath = resolveSecretsPath(agentRoot, deps);
+        try {
+            const secretsRaw = fs.readFileSync(secretsPath, "utf-8");
+            const secrets = JSON.parse(secretsRaw);
+            const providers = secrets.providers;
+            if (providers) {
+                const providerSecrets = providers[provider];
+                if (providerSecrets) {
+                    /* v8 ignore next -- fallback: all known providers are in MODEL_FIELD @preserve */
+                    const fieldName = MODEL_FIELD[provider] ?? "model";
+                    const rawModel = providerSecrets[fieldName];
+                    model = typeof rawModel === "string" ? rawModel : "";
+                    // Strip model from secrets
+                    delete providerSecrets[fieldName];
+                    fs.writeFileSync(secretsPath, JSON.stringify(secrets, null, 2) + "\n", "utf-8");
+                }
+            }
+        }
+        catch {
+            // Missing or malformed secrets.json — leave model as empty string
+        }
+    }
+    // Write v2 config
+    const { provider: _removed, ...rest } = config;
+    const v2Config = {
+        ...rest,
+        version: 2,
+        humanFacing: { provider: provider ?? "anthropic", model },
+        agentFacing: { provider: provider ?? "anthropic", model },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(v2Config, null, 2) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_end",
+        message: "agent config migration complete",
+        meta: { agentRoot, provider: provider ?? "unknown", model },
+    });
+}

package/dist/heart/provider-ping.js

@@ -62,18 +62,31 @@ function hasEmptyCredentials(provider, config) {
             return true;
     }
 }
-function createRuntimeForPing(provider, config) {
+function createRuntimeForPing(provider, _config) {
+    // The provider constructors read credentials from the active config via getXxxConfig().
+    // For ping, this is acceptable because verifyProviderCredentials patches the runtime
+    // config before calling ping. The model string is a default — for anthropic the ping
+    // overrides it with haiku anyway, and for others it's used in a minimal API call.
+    const DEFAULT_MODELS = {
+        anthropic: "claude-haiku-4-5-20251001",
+        azure: "gpt-4o",
+        minimax: "minimax-text-01",
+        "openai-codex": "codex-mini-latest",
+        "github-copilot": "gpt-4o",
+    };
+    /* v8 ignore next -- fallback: all known providers are in DEFAULT_MODELS @preserve */
+    const model = DEFAULT_MODELS[provider] ?? "unknown";
     switch (provider) {
         case "anthropic":
-            return (0, anthropic_1.createAnthropicProviderRuntime)(config);
+            return (0, anthropic_1.createAnthropicProviderRuntime)(model);
         case "azure":
-            return (0, azure_1.createAzureProviderRuntime)(config);
+            return (0, azure_1.createAzureProviderRuntime)(model);
         case "minimax":
-            return (0, minimax_1.createMinimaxProviderRuntime)(config);
+            return (0, minimax_1.createMinimaxProviderRuntime)(model);
         case "openai-codex":
-            return (0, openai_codex_1.createOpenAICodexProviderRuntime)(config);
+            return (0, openai_codex_1.createOpenAICodexProviderRuntime)(model);
         case "github-copilot":
-            return (0, github_copilot_1.createGithubCopilotProviderRuntime)(config);
+            return (0, github_copilot_1.createGithubCopilotProviderRuntime)(model);
         /* v8 ignore next 2 -- exhaustive: all providers handled above @preserve */
         default:
             throw new Error(`unsupported provider for ping: ${provider}`);

package/dist/heart/providers/anthropic.js

@@ -417,25 +417,24 @@ async function streamAnthropicMessages(client, model, request) {
         settleStreamed: answerStreamer.streamed,
     };
 }
-function createAnthropicProviderRuntime(config) {
+function createAnthropicProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "anthropic provider init",
         meta: { provider: "anthropic" },
     });
-    const anthropicConfig = config ?? (0, config_1.getAnthropicConfig)();
-    if (!(anthropicConfig.model && anthropicConfig.setupToken)) {
-        throw new Error(getAnthropicReauthGuidance("provider 'anthropic' is selected in agent.json but providers.anthropic.model/setupToken is incomplete in secrets.json."));
+    const anthropicConfig = (0, config_1.getAnthropicConfig)();
+    if (!anthropicConfig.setupToken) {
+        throw new Error(getAnthropicReauthGuidance("provider 'anthropic' is selected in agent.json but providers.anthropic.setupToken is missing in secrets.json."));
     }
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(anthropicConfig.model);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const capabilities = new Set();
     if (modelCaps.reasoningEffort)
         capabilities.add("reasoning-effort");
     const credential = resolveAnthropicSetupTokenCredential();
-    const fullConfig = config ?? (0, config_1.getAnthropicConfig)();
-    const refreshToken = fullConfig.refreshToken;
-    const expiresAt = fullConfig.expiresAt;
+    const refreshToken = anthropicConfig.refreshToken;
+    const expiresAt = anthropicConfig.expiresAt;
     function createClient(token) {
         return new sdk_1.default({
             authToken: token,
@@ -470,7 +469,7 @@ function createAnthropicProviderRuntime(config) {
     /* v8 ignore stop */
     return {
         id: "anthropic",
-        model: anthropicConfig.model,
+        model,
         /* v8 ignore next -- getter: returns mutable client ref @preserve */
         get client() { return client; },
         capabilities,
@@ -483,7 +482,7 @@ function createAnthropicProviderRuntime(config) {
         },
         async streamTurn(request) {
             const freshClient = await ensureClient();
-            return streamAnthropicMessages(freshClient, anthropicConfig.model, request);
+            return streamAnthropicMessages(freshClient, model, request);
         },
         /* v8 ignore next 3 -- delegation: classification logic tested via classifyAnthropicError @preserve */
         classifyError(error) {

package/dist/heart/providers/azure.js

@@ -92,8 +92,8 @@ function createAzureTokenProvider(managedIdentityClientId) {
         }
     };
 }
-function createAzureProviderRuntime(config) {
-    const azureConfig = config ?? (0, config_1.getAzureConfig)();
+function createAzureProviderRuntime(model) {
+    const azureConfig = (0, config_1.getAzureConfig)();
     const useApiKey = !!azureConfig.apiKey;
     const authMethod = useApiKey ? "key" : "managed-identity";
     (0, runtime_1.emitNervesEvent)({
@@ -102,10 +102,10 @@ function createAzureProviderRuntime(config) {
         message: "azure provider init",
         meta: { provider: "azure", authMethod },
     });
-    if (!(azureConfig.endpoint && azureConfig.deployment && azureConfig.modelName)) {
+    if (!(azureConfig.endpoint && azureConfig.deployment)) {
         throw new Error("provider 'azure' is selected in agent.json but providers.azure is incomplete in secrets.json.");
     }
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(azureConfig.modelName);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const capabilities = new Set();
     if (modelCaps.reasoningEffort)
         capabilities.add("reasoning-effort");
@@ -128,7 +128,7 @@ function createAzureProviderRuntime(config) {
     let nativeInstructions = "";
     return {
         id: "azure",
-        model: azureConfig.modelName,
+        model,
         client,
         capabilities,
         supportedReasoningEfforts: modelCaps.reasoningEffort,

package/dist/heart/providers/github-copilot.js

@@ -34,22 +34,22 @@ function classifyGithubCopilotError(error) {
     return "unknown";
 }
 /* v8 ignore stop */
-function createGithubCopilotProviderRuntime(injectedConfig) {
+function createGithubCopilotProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "github-copilot provider init",
         meta: { provider: "github-copilot" },
     });
-    const config = injectedConfig ?? (0, config_1.getGithubCopilotConfig)();
+    const config = (0, config_1.getGithubCopilotConfig)();
     if (!config.githubToken) {
         throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.githubToken is missing in secrets.json.");
     }
     if (!config.baseUrl) {
         throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.baseUrl is missing in secrets.json.");
     }
-    const isCompletionsModel = config.model.startsWith("claude");
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(config.model);
+    const isCompletionsModel = model.startsWith("claude");
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const capabilities = new Set();
     /* v8 ignore next -- branch: capability detection tested via unit test @preserve */
     if (modelCaps.reasoningEffort)
@@ -64,7 +64,7 @@ function createGithubCopilotProviderRuntime(injectedConfig) {
         // Chat completions path (Claude models via Copilot)
         return {
             id: "github-copilot",
-            model: config.model,
+            model,
             client,
             capabilities,
             supportedReasoningEfforts: modelCaps.reasoningEffort,
@@ -106,7 +106,7 @@ function createGithubCopilotProviderRuntime(injectedConfig) {
     let nativeInstructions = "";
     return {
         id: "github-copilot",
-        model: config.model,
+        model,
         client,
         capabilities,
         supportedReasoningEfforts: modelCaps.reasoningEffort,

package/dist/heart/providers/minimax.js

@@ -32,19 +32,19 @@ function classifyMinimaxError(error) {
 }
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
-function createMinimaxProviderRuntime(config) {
+function createMinimaxProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "minimax provider init",
         meta: { provider: "minimax" },
     });
-    const minimaxConfig = config ?? (0, config_1.getMinimaxConfig)();
+    const minimaxConfig = (0, config_1.getMinimaxConfig)();
     if (!minimaxConfig.apiKey) {
         throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
     }
     // Registry consulted; MiniMax models return empty defaults (no capabilities to derive)
-    (0, model_capabilities_1.getModelCapabilities)(minimaxConfig.model);
+    (0, model_capabilities_1.getModelCapabilities)(model);
     const client = new openai_1.default({
         apiKey: minimaxConfig.apiKey,
         baseURL: "https://api.minimaxi.chat/v1",
@@ -53,7 +53,7 @@ function createMinimaxProviderRuntime(config) {
     });
     return {
         id: "minimax",
-        model: minimaxConfig.model,
+        model,
         client,
         capabilities: new Set(),
         resetTurnState(_messages) {

package/dist/heart/providers/openai-codex.js

@@ -110,16 +110,16 @@ function getChatGPTAccountIdFromToken(token) {
         return "";
     return accountId.trim();
 }
-function createOpenAICodexProviderRuntime(config) {
+function createOpenAICodexProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "openai-codex provider init",
         meta: { provider: "openai-codex" },
     });
-    const codexConfig = config ?? (0, config_1.getOpenAICodexConfig)();
-    if (!(codexConfig.model && codexConfig.oauthAccessToken)) {
-        throw new Error(getOpenAICodexReauthGuidance("provider 'openai-codex' is selected in agent.json but providers.openai-codex.model/oauthAccessToken is incomplete in secrets.json."));
+    const codexConfig = (0, config_1.getOpenAICodexConfig)();
+    if (!codexConfig.oauthAccessToken) {
+        throw new Error(getOpenAICodexReauthGuidance("provider 'openai-codex' is selected in agent.json but providers.openai-codex.oauthAccessToken is missing in secrets.json."));
     }
     const token = codexConfig.oauthAccessToken.trim();
     if (!token) {
@@ -129,7 +129,7 @@ function createOpenAICodexProviderRuntime(config) {
     if (!chatgptAccountId) {
         throw new Error(getOpenAICodexReauthGuidance("OpenAI Codex OAuth access token is missing a chatgpt_account_id claim required for chatgpt.com/backend-api/codex."));
     }
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(codexConfig.model);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const capabilities = new Set();
     if (modelCaps.reasoningEffort)
         capabilities.add("reasoning-effort");
@@ -150,7 +150,7 @@ function createOpenAICodexProviderRuntime(config) {
     let nativeInstructions = "";
     return {
         id: "openai-codex",
-        model: codexConfig.model,
+        model,
         client,
         capabilities,
         supportedReasoningEfforts: modelCaps.reasoningEffort,

package/dist/mind/friends/channel.js

@@ -2,10 +2,22 @@
 // Channel capabilities -- hardcoded const map keyed by channel identifier.
 // Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelToFacing = channelToFacing;
 exports.getChannelCapabilities = getChannelCapabilities;
 exports.isRemoteChannel = isRemoteChannel;
 exports.getAlwaysOnSenseNames = getAlwaysOnSenseNames;
 const runtime_1 = require("../../nerves/runtime");
+const AGENT_FACING_CHANNELS = new Set(["inner", "mcp"]);
+function channelToFacing(channel) {
+    const facing = channel && AGENT_FACING_CHANNELS.has(channel) ? "agent" : "human";
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.facing_lookup",
+        message: "channel facing lookup",
+        meta: { channel: channel ?? "undefined", facing },
+    });
+    return facing;
+}
 const CHANNEL_CAPABILITIES = {
     cli: {
         channel: "cli",

package/dist/mind/prompt.js

@@ -368,8 +368,8 @@ function senseRuntimeGuidance(channel) {
     }
     return lines;
 }
-function providerSection() {
-    return `## my provider\n${(0, core_1.getProviderDisplayLabel)()}`;
+function providerSection(channel) {
+    return `## my provider\n${(0, core_1.getProviderDisplayLabel)((0, channel_1.channelToFacing)(channel))}`;
 }
 function dateSection() {
     const today = new Date().toISOString().slice(0, 10);
@@ -943,7 +943,7 @@ async function buildSystem(channel = "cli", options, context) {
         runtimeInfoSection(channel),
         rhythmStatusSection(),
         channelNatureSection((0, channel_1.getChannelCapabilities)(channel)),
-        providerSection(),
+        providerSection(channel),
         dateSection(),
         toolsSection(channel, options, context),
         mcpToolsSection(options?.mcpManager),