@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.200

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

@@ -0,0 +1,138 @@
+"use strict";
+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.registerUpdateHook = registerUpdateHook;
+exports.getRegisteredHooks = getRegisteredHooks;
+exports.clearRegisteredHooks = clearRegisteredHooks;
+exports.applyPendingUpdates = applyPendingUpdates;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+const runtime_1 = require("../../nerves/runtime");
+const _hooks = [];
+function registerUpdateHook(hook) {
+    _hooks.push(hook);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_hook_registered",
+        message: "registered update hook",
+        meta: {},
+    });
+}
+function getRegisteredHooks() {
+    return _hooks;
+}
+function clearRegisteredHooks() {
+    _hooks.length = 0;
+}
+async function applyPendingUpdates(bundlesRoot, currentVersion) {
+    const summary = { updated: [] };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.apply_pending_updates_start",
+        message: "applying pending updates",
+        meta: { bundlesRoot, currentVersion },
+    });
+    if (!fs.existsSync(bundlesRoot)) {
+        return summary;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return summary;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentRoot = path.join(bundlesRoot, entry.name);
+        let previousVersion;
+        const metaPath = path.join(agentRoot, "bundle-meta.json");
+        try {
+            if (fs.existsSync(metaPath)) {
+                const raw = fs.readFileSync(metaPath, "utf-8");
+                const meta = JSON.parse(raw);
+                previousVersion = meta.runtimeVersion;
+                if (previousVersion === currentVersion) {
+                    continue;
+                }
+                // Skip downgrades — only update forward
+                if (semver.valid(previousVersion) && semver.valid(currentVersion) && semver.gte(previousVersion, currentVersion)) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "daemon",
+                        event: "daemon.update_hook_skip_downgrade",
+                        message: "skipping downgrade",
+                        meta: { agentRoot, previousVersion, currentVersion },
+                    });
+                    continue;
+                }
+            }
+        }
+        catch {
+            // Malformed or unreadable bundle-meta.json -- treat as needing update
+            previousVersion = undefined;
+        }
+        const ctx = { agentRoot, currentVersion, previousVersion };
+        for (const hook of _hooks) {
+            try {
+                await hook(ctx);
+            }
+            catch (err) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.update_hook_error",
+                    message: "update hook threw",
+                    meta: {
+                        agentRoot,
+                        error: err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err),
+                    },
+                });
+            }
+        }
+        summary.updated.push({
+            agent: entry.name.replace(/\.ouro$/, ""),
+            from: previousVersion,
+            to: currentVersion,
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.apply_pending_updates_end",
+        message: "pending updates applied",
+        meta: { bundlesRoot },
+    });
+    return summary;
+}

package/dist/heart/daemon/wrapper-publish-guard.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessWrapperPublishSync = assessWrapperPublishSync;
+const runtime_1 = require("../../nerves/runtime");
+function wrapperPackageChanged(changedFiles) {
+    return changedFiles.some((file) => file.startsWith("packages/ouro.bot/"));
+}
+function assessWrapperPublishSync(input) {
+    let result;
+    if (input.localVersion !== input.cliVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper version ${input.localVersion} must match @ouro.bot/cli version ${input.cliVersion}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: wrapperPackageChanged(input.changedFiles),
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (!wrapperPackageChanged(input.changedFiles)) {
+        result = {
+            ok: true,
+            message: "wrapper package unchanged",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: false,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (input.publishedVersion === input.localVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper changed but ouro.bot@${input.localVersion} is already published; bump packages/ouro.bot/package.json before merging`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: true,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    result = {
+        ok: true,
+        message: "wrapper package changed and local wrapper version is unpublished",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.wrapper_publish_guard_checked",
+        message: "evaluated wrapper publish sync",
+        meta: {
+            changed: true,
+            localVersion: input.localVersion,
+            cliVersion: input.cliVersion,
+            publishedVersion: input.publishedVersion,
+            ok: result.ok,
+        },
+    });
+    return result;
+}

package/dist/heart/delegation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideDelegation = decideDelegation;
+const runtime_1 = require("../nerves/runtime");
+const CROSS_SESSION_TOOLS = new Set(["query_session", "send_message", "bridge_manage"]);
+const FAST_PATH_TOOLS = new Set(["settle"]);
+const REFLECTION_PATTERN = /\b(think|reflect|ponder|surface|surfaces|surfaced|sit with|metaboli[sz]e)\b/i;
+const CROSS_SESSION_PATTERN = /\b(other chat|other session|across chats?|across sessions?|keep .* aligned|relay|carry .* across)\b/i;
+function hasExplicitReflection(ingressTexts) {
+    return ingressTexts.some((text) => REFLECTION_PATTERN.test(text));
+}
+function hasCrossSessionPressure(ingressTexts, requestedToolNames) {
+    if (requestedToolNames.some((name) => CROSS_SESSION_TOOLS.has(name))) {
+        return true;
+    }
+    return ingressTexts.some((text) => CROSS_SESSION_PATTERN.test(text));
+}
+function hasNonFastPathToolRequest(requestedToolNames) {
+    return requestedToolNames.some((name) => !FAST_PATH_TOOLS.has(name));
+}
+function decideDelegation(input) {
+    const requestedToolNames = (input.requestedToolNames ?? [])
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+    const reasons = [];
+    if (hasExplicitReflection(input.ingressTexts)) {
+        reasons.push("explicit_reflection");
+    }
+    if (hasCrossSessionPressure(input.ingressTexts, requestedToolNames)) {
+        reasons.push("cross_session");
+    }
+    if (input.activeWork.centerOfGravity === "shared-work" || input.activeWork.bridges.some((bridge) => bridge.lifecycle === "active")) {
+        reasons.push("bridge_state");
+    }
+    if (input.activeWork.taskPressure.liveTaskNames.length > 0) {
+        reasons.push("task_state");
+    }
+    if (hasNonFastPathToolRequest(requestedToolNames)) {
+        reasons.push("non_fast_path_tool");
+    }
+    if (input.mustResolveBeforeHandoff || input.activeWork.mustResolveBeforeHandoff) {
+        reasons.push("unresolved_obligation");
+    }
+    const target = reasons.length === 0 ? "fast-path" : "delegate-inward";
+    const decision = {
+        target,
+        reasons,
+        outwardClosureRequired: target === "delegate-inward" && input.channel !== "inner",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.delegation_decide",
+        message: "computed delegation hint",
+        meta: {
+            channel: input.channel,
+            target: decision.target,
+            reasons: decision.reasons,
+            outwardClosureRequired: decision.outwardClosureRequired,
+        },
+    });
+    return decision;
+}

package/dist/heart/identity.js

@@ -33,20 +33,30 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.HARNESS_CANONICAL_REPO_URL = exports.PROVIDER_CREDENTIALS = exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
 exports.getAgentBundlesRoot = getAgentBundlesRoot;
 exports.getAgentRoot = getAgentRoot;
+exports.getAgentStateRoot = getAgentStateRoot;
+exports.getAgentRepoWorkspacesRoot = getAgentRepoWorkspacesRoot;
+exports.getAgentDaemonStateRoot = getAgentDaemonStateRoot;
+exports.getAgentDaemonLogsDir = getAgentDaemonLogsDir;
+exports.getAgentDaemonLoggingConfigPath = getAgentDaemonLoggingConfigPath;
+exports.getAgentMessagesRoot = getAgentMessagesRoot;
+exports.getAgentToolsRoot = getAgentToolsRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
+exports.resetAgentConfigCache = resetAgentConfigCache;
 exports.resetIdentity = resetIdentity;
 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,
@@ -56,12 +66,74 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_AGENT_SENSES = {
+    cli: { enabled: true },
+    teams: { enabled: false },
+    bluebubbles: { enabled: false },
+};
+function normalizeSenses(value, configFile) {
+    const defaults = {
+        cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+    if (value === undefined) {
+        return defaults;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid senses block",
+            meta: { path: configFile },
+        });
+        throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
+    }
+    const raw = value;
+    const senseNames = ["cli", "teams", "bluebubbles"];
+    for (const senseName of senseNames) {
+        const rawSense = raw[senseName];
+        if (rawSense === undefined) {
+            continue;
+        }
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense config",
+                meta: { path: configFile, sense: senseName },
+            });
+            throw new Error(`agent.json at ${configFile} has invalid senses.${senseName} config.`);
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled !== "boolean") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense enabled flag",
+                meta: { path: configFile, sense: senseName, enabled: enabled ?? null },
+            });
+            throw new Error(`agent.json at ${configFile} must include senses.${senseName}.enabled as boolean.`);
+        }
+        defaults[senseName] = { enabled };
+    }
+    return defaults;
+}
 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 },
+            teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+            bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
             tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
@@ -70,7 +142,7 @@ function buildDefaultAgentTemplate(_agentName) {
     };
 }
 let _cachedAgentName = null;
-let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -111,13 +183,60 @@ function getRepoRoot() {
  * Returns the shared bundle root directory: `~/AgentBundles/`
  */
 function getAgentBundlesRoot() {
-    return path.join(os.homedir(), "AgentBundles");
+    const homeBase = process.env.WEBSITE_SITE_NAME ? "/home" : os.homedir();
+    return path.join(homeBase, "AgentBundles");
 }
 /**
  * Returns the agent-specific bundle directory: `~/AgentBundles/<agentName>.ouro/`
  */
-function getAgentRoot() {
-    return path.join(getAgentBundlesRoot(), `${getAgentName()}.ouro`);
+function getAgentRoot(agentName = getAgentName()) {
+    return path.join(getAgentBundlesRoot(), `${agentName}.ouro`);
+}
+function resolveOptionalAgentName(agentName) {
+    if (agentName && agentName.trim().length > 0)
+        return agentName.trim();
+    try {
+        return getAgentName();
+    }
+    catch {
+        return "slugger";
+    }
+}
+/**
+ * Returns the bundle-local runtime state directory: `~/AgentBundles/<agentName>.ouro/state/`
+ */
+function getAgentStateRoot(agentName) {
+    return path.join(getAgentRoot(resolveOptionalAgentName(agentName)), "state");
+}
+/**
+ * Required credential fields per provider.
+ * Used by daemon config-check to validate secrets before spawning an agent.
+ */
+exports.PROVIDER_CREDENTIALS = {
+    azure: ["apiKey", "endpoint", "deployment"],
+    minimax: ["apiKey"],
+    anthropic: ["setupToken"],
+    "openai-codex": ["oauthAccessToken"],
+    "github-copilot": ["githubToken", "baseUrl"],
+};
+exports.HARNESS_CANONICAL_REPO_URL = "https://github.com/ouroborosbot/ouroboros.git";
+function getAgentRepoWorkspacesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "workspaces");
+}
+function getAgentDaemonStateRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "daemon");
+}
+function getAgentDaemonLogsDir(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logs");
+}
+function getAgentDaemonLoggingConfigPath(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logging.json");
+}
+function getAgentMessagesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "messages");
+}
+function getAgentToolsRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "tools");
 }
 /**
  * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`
@@ -125,23 +244,11 @@ function getAgentRoot() {
 function getAgentSecretsPath(agentName = getAgentName()) {
     return path.join(os.homedir(), ".agentsecrets", agentName, "secrets.json");
 }
-/**
- * Load and parse `<agentRoot>/agent.json`.
- * Caches the result after first load.
- * Throws descriptive error if file is missing or contains invalid JSON.
- */
-function loadAgentConfig() {
-    if (_cachedAgentConfig) {
-        (0, runtime_1.emitNervesEvent)({
-            event: "identity.resolve",
-            component: "config/identity",
-            message: "loaded agent config from cache",
-            meta: { source: "cache" },
-        });
-        return _cachedAgentConfig;
-    }
-    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");
@@ -159,9 +266,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)({
@@ -176,6 +282,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 ||
@@ -197,27 +359,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") {
-        (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", or "openai-codex".`);
-    }
-    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",
@@ -226,7 +372,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.`);
@@ -246,12 +392,19 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
     }
-    _cachedAgentConfig = {
+    // Tolerate deprecated provider field for backward compatibility
+    const rawProvider = parsed.provider;
+    const provider = isValidProvider(rawProvider) ? rawProvider : undefined;
+    const config = {
         version,
         enabled,
-        provider: rawProvider,
+        ...(provider !== undefined ? { provider } : {}),
+        humanFacing,
+        agentFacing,
         context: parsed.context,
         logging: parsed.logging,
+        senses: normalizeSenses(parsed.senses, configFile),
+        mcpServers: parsed.mcpServers,
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({
@@ -260,7 +413,7 @@ function loadAgentConfig() {
         message: "loaded agent config from disk",
         meta: { source: "disk" },
     });
-    return _cachedAgentConfig;
+    return config;
 }
 /**
  * Prime the agent name cache explicitly.
@@ -271,11 +424,26 @@ function loadAgentConfig() {
 function setAgentName(name) {
     _cachedAgentName = name;
 }
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
+/**
+ * Preserve the compatibility hook for callers that previously cleared cached
+ * disk-backed agent config. Agent config is now read fresh on every call.
+ */
+function resetAgentConfigCache() {
+    // No-op: disk-backed agent config is no longer memoized in-process.
+}
 /**
  * Clear all cached identity state.
  * Used in tests and when switching agent context.
  */
 function resetIdentity() {
     _cachedAgentName = null;
-    _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }