@ouro.bot/cli 0.1.0-alpha.53 → 0.1.0-alpha.54

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.54",
+      "changes": [
+        "Disk-backed runtime config now reloads from agent and secrets files instead of being held behind stale process-level caches, so config changes are picked up truthfully.",
+        "`ouro up` now treats runtime drift as a real restart trigger, including repo-root drift, config-fingerprint drift, and stale launchd boot persistence after branch/worktree changes.",
+        "BlueBubbles status now prefers fresh runtime health over stale managed-process crash snapshots, preventing false whole-sense `error` reports when the live channel is actually healthy."
+      ]
+    },
     {
       "version": "0.1.0-alpha.53",
       "changes": [

package/dist/heart/config.js

@@ -138,7 +138,7 @@ function defaultRuntimeConfig() {
         integrations: { ...DEFAULT_SECRETS_TEMPLATE.integrations },
     };
 }
-let _cachedConfig = null;
+let _runtimeConfigOverride = null;
 let _testContextOverride = null;
 function resolveConfigPath() {
     return (0, identity_1.getAgentSecretsPath)();
@@ -160,15 +160,6 @@ function deepMerge(defaults, partial) {
     return result;
 }
 function loadConfig() {
-    if (_cachedConfig) {
-        (0, runtime_1.emitNervesEvent)({
-            event: "config.load",
-            component: "config/identity",
-            message: "config loaded from cache",
-            meta: { source: "cache" },
-        });
-        return _cachedConfig;
-    }
     const configPath = resolveConfigPath();
     // Auto-create config directory if it doesn't exist
     const configDir = path.dirname(configPath);
@@ -229,7 +220,10 @@ function loadConfig() {
             },
         });
     }
-    _cachedConfig = deepMerge(defaultRuntimeConfig(), sanitizedFileData);
+    const mergedConfig = deepMerge(defaultRuntimeConfig(), sanitizedFileData);
+    const config = _runtimeConfigOverride
+        ? deepMerge(mergedConfig, _runtimeConfigOverride)
+        : mergedConfig;
     (0, runtime_1.emitNervesEvent)({
         event: "config.load",
         component: "config/identity",
@@ -237,22 +231,22 @@ function loadConfig() {
         meta: {
             source: "disk",
             used_defaults_only: Object.keys(fileData).length === 0,
+            override_applied: _runtimeConfigOverride !== null,
         },
     });
-    return _cachedConfig;
+    return config;
 }
 function resetConfigCache() {
-    _cachedConfig = null;
+    _runtimeConfigOverride = null;
     _testContextOverride = null;
 }
 function patchRuntimeConfig(partial) {
-    loadConfig(); // ensure _cachedConfig exists
     const contextPatch = partial.context;
     if (contextPatch) {
         const base = _testContextOverride ?? identity_1.DEFAULT_AGENT_CONTEXT;
         _testContextOverride = deepMerge(base, contextPatch);
     }
-    _cachedConfig = deepMerge(_cachedConfig, partial);
+    _runtimeConfigOverride = deepMerge((_runtimeConfigOverride ?? {}), partial);
 }
 function getAzureConfig() {
     const config = loadConfig();

package/dist/heart/core.js

@@ -25,6 +25,27 @@ const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
 let _providerRuntime = null;
+function getProviderRuntimeFingerprint() {
+    const provider = (0, identity_1.loadAgentConfig)().provider;
+    switch (provider) {
+        case "azure": {
+            const { apiKey, endpoint, deployment, modelName, apiVersion } = (0, config_1.getAzureConfig)();
+            return JSON.stringify({ provider, apiKey, endpoint, deployment, modelName, apiVersion });
+        }
+        case "anthropic": {
+            const { model, setupToken } = (0, config_1.getAnthropicConfig)();
+            return JSON.stringify({ provider, model, setupToken });
+        }
+        case "minimax": {
+            const { apiKey, model } = (0, config_1.getMinimaxConfig)();
+            return JSON.stringify({ provider, apiKey, model });
+        }
+        case "openai-codex": {
+            const { model, oauthAccessToken } = (0, config_1.getOpenAICodexConfig)();
+            return JSON.stringify({ provider, model, oauthAccessToken });
+        }
+    }
+}
 function createProviderRegistry() {
     const factories = {
         azure: azure_1.createAzureProviderRuntime,
@@ -40,42 +61,44 @@ function createProviderRegistry() {
     };
 }
 function getProviderRuntime() {
-    if (!_providerRuntime) {
-        try {
-            _providerRuntime = createProviderRegistry().resolve();
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: msg,
-                meta: {},
-            });
-            // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
-            console.error(`\n[fatal] ${msg}\n`);
-            process.exit(1);
-            throw new Error("unreachable");
-        }
-        if (!_providerRuntime) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                event: "engine.provider_init_error",
-                component: "engine",
-                message: "provider runtime could not be initialized.",
-                meta: {},
-            });
-            process.exit(1);
-            throw new Error("unreachable");
+    try {
+        const fingerprint = getProviderRuntimeFingerprint();
+        if (!_providerRuntime || _providerRuntime.fingerprint !== fingerprint) {
+            const runtime = createProviderRegistry().resolve();
+            _providerRuntime = runtime ? { fingerprint, runtime } : null;
         }
     }
-    return _providerRuntime;
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: msg,
+            meta: {},
+        });
+        // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
+        console.error(`\n[fatal] ${msg}\n`);
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    if (!_providerRuntime) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.provider_init_error",
+            component: "engine",
+            message: "provider runtime could not be initialized.",
+            meta: {},
+        });
+        process.exit(1);
+        throw new Error("unreachable");
+    }
+    return _providerRuntime.runtime;
 }
 /**
- * Clear the cached provider runtime so the next call to getProviderRuntime()
- * re-creates it from current config. Used by the adoption specialist to
- * switch provider context without restarting the process.
+ * Clear the cached provider runtime so the next access re-creates it from
+ * current config. Runtime access also auto-refreshes when the selected
+ * provider fingerprint changes on disk.
  */
 function resetProviderRuntime() {
     _providerRuntime = null;
@@ -102,14 +125,17 @@ function createSummarize() {
     };
 }
 function getProviderDisplayLabel() {
-    const model = getModel();
+    const provider = (0, identity_1.loadAgentConfig)().provider;
     const providerLabelBuilders = {
-        azure: () => `azure openai (${(0, config_1.getAzureConfig)().deployment || "default"}, model: ${model})`,
-        anthropic: () => `anthropic (${model})`,
-        minimax: () => `minimax (${model})`,
-        "openai-codex": () => `openai codex (${model})`,
+        azure: () => {
+            const config = (0, config_1.getAzureConfig)();
+            return `azure openai (${config.deployment || "default"}, model: ${config.modelName || "unknown"})`;
+        },
+        anthropic: () => `anthropic (${(0, config_1.getAnthropicConfig)().model || "unknown"})`,
+        minimax: () => `minimax (${(0, config_1.getMinimaxConfig)().model || "unknown"})`,
+        "openai-codex": () => `openai codex (${(0, config_1.getOpenAICodexConfig)().model || "unknown"})`,
     };
-    return providerLabelBuilders[getProvider()]();
+    return providerLabelBuilders[provider]();
 }
 // Re-export tools, execTool, summarizeArgs from ./tools for backward compat
 var tools_2 = require("../repertoire/tools");

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

@@ -93,6 +93,8 @@ function parseStatusPayload(data) {
         socketPath: stringField(overview.socketPath) ?? "unknown",
         version: stringField(overview.version) ?? "unknown",
         lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
+        repoRoot: stringField(overview.repoRoot) ?? "unknown",
+        configFingerprint: stringField(overview.configFingerprint) ?? "unknown",
         workerCount: numberField(overview.workerCount) ?? 0,
         senseCount: numberField(overview.senseCount) ?? 0,
         entryPath: stringField(overview.entryPath) ?? "unknown",
@@ -212,14 +214,28 @@ async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
     if (alive) {
         const localRuntime = (0, runtime_metadata_1.getRuntimeMetadata)();
+        let runningRuntimePromise = null;
+        const fetchRunningRuntimeMetadata = async () => {
+            runningRuntimePromise ??= (async () => {
+                const status = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
+                const payload = parseStatusPayload(status.data);
+                return {
+                    version: payload?.overview.version ?? "unknown",
+                    lastUpdated: payload?.overview.lastUpdated ?? "unknown",
+                    repoRoot: payload?.overview.repoRoot ?? "unknown",
+                    configFingerprint: payload?.overview.configFingerprint ?? "unknown",
+                };
+            })();
+            return runningRuntimePromise;
+        };
         return (0, daemon_runtime_sync_1.ensureCurrentDaemonRuntime)({
             socketPath: deps.socketPath,
             localVersion: localRuntime.version,
-            fetchRunningVersion: async () => {
-                const status = await deps.sendCommand(deps.socketPath, { kind: "daemon.status" });
-                const payload = parseStatusPayload(status.data);
-                return payload?.overview.version ?? "unknown";
-            },
+            localLastUpdated: localRuntime.lastUpdated,
+            localRepoRoot: localRuntime.repoRoot,
+            localConfigFingerprint: localRuntime.configFingerprint,
+            fetchRunningVersion: async () => (await fetchRunningRuntimeMetadata()).version,
+            fetchRunningRuntimeMetadata,
             stopDaemon: async () => {
                 await deps.sendCommand(deps.socketPath, { kind: "daemon.stop" });
             },
@@ -285,6 +301,8 @@ function buildStoppedStatusPayload(socketPath) {
             socketPath,
             version: metadata.version,
             lastUpdated: metadata.lastUpdated,
+            repoRoot: metadata.repoRoot,
+            configFingerprint: metadata.configFingerprint,
             workerCount: 0,
             senseCount: 0,
             entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
@@ -732,9 +750,13 @@ function defaultEnsureDaemonBootPersistence(socketPath) {
     }
     const homeDir = os.homedir();
     const launchdDeps = {
+        exec: (cmd) => { (0, child_process_1.execSync)(cmd, { stdio: "ignore" }); },
         writeFile: (filePath, content) => fs.writeFileSync(filePath, content, "utf-8"),
+        removeFile: (filePath) => fs.rmSync(filePath, { force: true }),
+        existsFile: (filePath) => fs.existsSync(filePath),
         mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
         homeDir,
+        userUid: process.getuid?.() ?? 0,
     };
     const entryPath = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
     /* v8 ignore next -- covered via mock in daemon-cli-defaults.test.ts; v8 on CI attributes the real fs.existsSync branch to the non-mock load @preserve */
@@ -748,7 +770,7 @@ function defaultEnsureDaemonBootPersistence(socketPath) {
         });
     }
     const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
-    (0, launchd_1.writeLaunchAgentPlist)(launchdDeps, {
+    (0, launchd_1.installLaunchAgent)(launchdDeps, {
         nodePath: process.execPath,
         entryPath,
         socketPath,

package/dist/heart/daemon/daemon-runtime-sync.js

@@ -5,16 +5,82 @@ const runtime_1 = require("../../nerves/runtime");
 function isKnownVersion(version) {
     return version !== "unknown" && version.trim().length > 0;
 }
+function isKnownRuntimeValue(value) {
+    return typeof value === "string" && value.trim().length > 0 && value !== "unknown";
+}
 function formatErrorReason(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function normalizeRuntimeIdentity(value) {
+    return {
+        version: typeof value.version === "string" ? value.version : "unknown",
+        lastUpdated: typeof value.lastUpdated === "string" ? value.lastUpdated : "unknown",
+        repoRoot: typeof value.repoRoot === "string" ? value.repoRoot : "unknown",
+        configFingerprint: typeof value.configFingerprint === "string" ? value.configFingerprint : "unknown",
+    };
+}
+async function readRunningRuntimeIdentity(deps) {
+    if (!deps.fetchRunningRuntimeMetadata) {
+        return normalizeRuntimeIdentity({
+            version: await deps.fetchRunningVersion(),
+        });
+    }
+    const metadata = normalizeRuntimeIdentity(await deps.fetchRunningRuntimeMetadata());
+    if (isKnownVersion(metadata.version))
+        return metadata;
+    return normalizeRuntimeIdentity({
+        ...metadata,
+        version: await deps.fetchRunningVersion(),
+    });
+}
+function collectRuntimeDriftReasons(local, running) {
+    const reasons = [];
+    const comparableVersions = isKnownVersion(local.version) && isKnownVersion(running.version);
+    if (comparableVersions && local.version !== running.version) {
+        reasons.push({ key: "version", label: "version", local: local.version, running: running.version });
+    }
+    if (comparableVersions && isKnownRuntimeValue(local.lastUpdated) && isKnownRuntimeValue(running.lastUpdated) && local.lastUpdated !== running.lastUpdated) {
+        reasons.push({ key: "lastUpdated", label: "last updated", local: local.lastUpdated, running: running.lastUpdated });
+    }
+    if (isKnownRuntimeValue(local.repoRoot) && isKnownRuntimeValue(running.repoRoot) && local.repoRoot !== running.repoRoot) {
+        reasons.push({ key: "repoRoot", label: "code path", local: local.repoRoot, running: running.repoRoot });
+    }
+    if (isKnownRuntimeValue(local.configFingerprint)
+        && isKnownRuntimeValue(running.configFingerprint)
+        && local.configFingerprint !== running.configFingerprint) {
+        reasons.push({
+            key: "configFingerprint",
+            label: "config fingerprint",
+            local: local.configFingerprint,
+            running: running.configFingerprint,
+        });
+    }
+    return reasons;
+}
+function formatRuntimeValue(reason) {
+    if (reason.key === "configFingerprint") {
+        return `${reason.running.slice(0, 12)} -> ${reason.local.slice(0, 12)}`;
+    }
+    return `${reason.running} -> ${reason.local}`;
+}
+function formatRuntimeDriftSummary(reasons) {
+    return reasons.map((reason) => `${reason.label} ${formatRuntimeValue(reason)}`).join("; ");
+}
 async function ensureCurrentDaemonRuntime(deps) {
+    const localRuntime = normalizeRuntimeIdentity({
+        version: deps.localVersion,
+        lastUpdated: deps.localLastUpdated,
+        repoRoot: deps.localRepoRoot,
+        configFingerprint: deps.localConfigFingerprint,
+    });
     try {
-        const runningVersion = await deps.fetchRunningVersion();
+        const runningRuntime = await readRunningRuntimeIdentity(deps);
+        const runningVersion = runningRuntime.version;
+        const driftReasons = collectRuntimeDriftReasons(localRuntime, runningRuntime);
         let result;
-        if (isKnownVersion(deps.localVersion) &&
-            isKnownVersion(runningVersion) &&
-            runningVersion !== deps.localVersion) {
+        if (driftReasons.length > 0) {
+            const includesVersionDrift = driftReasons.some((entry) => entry.key === "version");
+            const driftSummary = formatRuntimeDriftSummary(driftReasons);
             try {
                 await deps.stopDaemon();
             }
@@ -22,14 +88,29 @@ async function ensureCurrentDaemonRuntime(deps) {
                 const reason = formatErrorReason(error);
                 result = {
                     alreadyRunning: true,
-                    message: `daemon already running (${deps.socketPath}; could not replace stale daemon ${runningVersion} -> ${deps.localVersion}: ${reason})`,
+                    message: includesVersionDrift
+                        ? `daemon already running (${deps.socketPath}; could not replace stale daemon ${runningVersion} -> ${deps.localVersion}: ${reason})`
+                        : `daemon already running (${deps.socketPath}; could not replace drifted daemon ${driftSummary}: ${reason})`,
                 };
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
                     component: "daemon",
                     event: "daemon.runtime_sync_decision",
                     message: "evaluated daemon runtime sync outcome",
-                    meta: { socketPath: deps.socketPath, localVersion: deps.localVersion, runningVersion, action: "stale_replace_failed", reason },
+                    meta: {
+                        socketPath: deps.socketPath,
+                        localVersion: deps.localVersion,
+                        localLastUpdated: localRuntime.lastUpdated,
+                        localRepoRoot: localRuntime.repoRoot,
+                        localConfigFingerprint: localRuntime.configFingerprint,
+                        runningVersion,
+                        runningLastUpdated: runningRuntime.lastUpdated,
+                        runningRepoRoot: runningRuntime.repoRoot,
+                        runningConfigFingerprint: runningRuntime.configFingerprint,
+                        action: "stale_replace_failed",
+                        driftKeys: driftReasons.map((entry) => entry.key),
+                        reason,
+                    },
                 });
                 return result;
             }
@@ -37,17 +118,32 @@ async function ensureCurrentDaemonRuntime(deps) {
             const started = await deps.startDaemonProcess(deps.socketPath);
             result = {
                 alreadyRunning: false,
-                message: `restarted stale daemon from ${runningVersion} to ${deps.localVersion} (pid ${started.pid ?? "unknown"})`,
+                message: includesVersionDrift
+                    ? `restarted stale daemon from ${runningVersion} to ${deps.localVersion} (pid ${started.pid ?? "unknown"})`
+                    : `restarted drifted daemon (${driftSummary}) (pid ${started.pid ?? "unknown"})`,
             };
             (0, runtime_1.emitNervesEvent)({
                 component: "daemon",
                 event: "daemon.runtime_sync_decision",
                 message: "evaluated daemon runtime sync outcome",
-                meta: { socketPath: deps.socketPath, localVersion: deps.localVersion, runningVersion, action: "stale_restarted", pid: started.pid ?? null },
+                meta: {
+                    socketPath: deps.socketPath,
+                    localVersion: deps.localVersion,
+                    localLastUpdated: localRuntime.lastUpdated,
+                    localRepoRoot: localRuntime.repoRoot,
+                    localConfigFingerprint: localRuntime.configFingerprint,
+                    runningVersion,
+                    runningLastUpdated: runningRuntime.lastUpdated,
+                    runningRepoRoot: runningRuntime.repoRoot,
+                    runningConfigFingerprint: runningRuntime.configFingerprint,
+                    action: "stale_restarted",
+                    driftKeys: driftReasons.map((entry) => entry.key),
+                    pid: started.pid ?? null,
+                },
             });
             return result;
         }
-        if (!isKnownVersion(deps.localVersion) || !isKnownVersion(runningVersion)) {
+        if (!isKnownVersion(localRuntime.version) || !isKnownVersion(runningVersion)) {
             result = {
                 alreadyRunning: true,
                 message: `daemon already running (${deps.socketPath}; unable to verify version)`,
@@ -56,7 +152,18 @@ async function ensureCurrentDaemonRuntime(deps) {
                 component: "daemon",
                 event: "daemon.runtime_sync_decision",
                 message: "evaluated daemon runtime sync outcome",
-                meta: { socketPath: deps.socketPath, localVersion: deps.localVersion, runningVersion, action: "unknown_version" },
+                meta: {
+                    socketPath: deps.socketPath,
+                    localVersion: deps.localVersion,
+                    localLastUpdated: localRuntime.lastUpdated,
+                    localRepoRoot: localRuntime.repoRoot,
+                    localConfigFingerprint: localRuntime.configFingerprint,
+                    runningVersion,
+                    runningLastUpdated: runningRuntime.lastUpdated,
+                    runningRepoRoot: runningRuntime.repoRoot,
+                    runningConfigFingerprint: runningRuntime.configFingerprint,
+                    action: "unknown_version",
+                },
             });
             return result;
         }
@@ -72,7 +179,15 @@ async function ensureCurrentDaemonRuntime(deps) {
             component: "daemon",
             event: "daemon.runtime_sync_decision",
             message: "evaluated daemon runtime sync outcome",
-            meta: { socketPath: deps.socketPath, localVersion: deps.localVersion, action: "status_lookup_failed", reason },
+            meta: {
+                socketPath: deps.socketPath,
+                localVersion: deps.localVersion,
+                localLastUpdated: localRuntime.lastUpdated,
+                localRepoRoot: localRuntime.repoRoot,
+                localConfigFingerprint: localRuntime.configFingerprint,
+                action: "status_lookup_failed",
+                reason,
+            },
         });
         return result;
     }
@@ -84,7 +199,14 @@ async function ensureCurrentDaemonRuntime(deps) {
         component: "daemon",
         event: "daemon.runtime_sync_decision",
         message: "evaluated daemon runtime sync outcome",
-        meta: { socketPath: deps.socketPath, localVersion: deps.localVersion, action: "already_current" },
+        meta: {
+            socketPath: deps.socketPath,
+            localVersion: deps.localVersion,
+            localLastUpdated: localRuntime.lastUpdated,
+            localRepoRoot: localRuntime.repoRoot,
+            localConfigFingerprint: localRuntime.configFingerprint,
+            action: "already_current",
+        },
     });
     return result;
 }

package/dist/heart/daemon/launchd.js

@@ -45,6 +45,9 @@ exports.DAEMON_PLIST_LABEL = "bot.ouro.daemon";
 function plistFilePath(homeDir) {
     return path.join(homeDir, "Library", "LaunchAgents", `${exports.DAEMON_PLIST_LABEL}.plist`);
 }
+function userLaunchDomain(userUid) {
+    return `gui/${userUid}`;
+}
 function generateDaemonPlist(options) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -105,15 +108,16 @@ function installLaunchAgent(deps, options) {
         meta: { entryPath: options.entryPath, socketPath: options.socketPath },
     });
     const fullPath = plistFilePath(deps.homeDir);
+    const domain = userLaunchDomain(deps.userUid);
     // Unload existing (best effort) for idempotent re-install
     if (deps.existsFile(fullPath)) {
         try {
-            deps.exec(`launchctl unload "${fullPath}"`);
+            deps.exec(`launchctl bootout ${domain} "${fullPath}"`);
         }
         catch { /* best effort */ }
     }
     writeLaunchAgentPlist(deps, options);
-    deps.exec(`launchctl load "${fullPath}"`);
+    deps.exec(`launchctl bootstrap ${domain} "${fullPath}"`);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.launchd_installed",
@@ -129,9 +133,10 @@ function uninstallLaunchAgent(deps) {
         meta: {},
     });
     const fullPath = plistFilePath(deps.homeDir);
+    const domain = userLaunchDomain(deps.userUid);
     if (deps.existsFile(fullPath)) {
         try {
-            deps.exec(`launchctl unload "${fullPath}"`);
+            deps.exec(`launchctl bootout ${domain} "${fullPath}"`);
         }
         catch { /* best effort */ }
         deps.removeFile(fullPath);

package/dist/heart/daemon/runtime-metadata.js

@@ -34,7 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeMetadata = getRuntimeMetadata;
+const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const childProcess = __importStar(require("child_process"));
 const identity_1 = require("../identity");
@@ -85,10 +87,98 @@ function readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncIm
         return { value: UNKNOWN_METADATA, source: "unknown" };
     }
 }
+function readHomeDir() {
+    const homedirImpl = optionalFunction(os, "homedir");
+    if (!homedirImpl) {
+        return null;
+    }
+    try {
+        return homedirImpl.call(os);
+    }
+    catch {
+        return null;
+    }
+}
+function listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl) {
+    if (!readdirSyncImpl)
+        return [];
+    const targets = new Set();
+    if (daemonLoggingPath) {
+        targets.add(daemonLoggingPath);
+    }
+    try {
+        const bundleEntries = readdirSyncImpl(bundlesRoot, { withFileTypes: true });
+        for (const entry of bundleEntries) {
+            if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+                continue;
+            targets.add(path.join(bundlesRoot, entry.name, "agent.json"));
+        }
+    }
+    catch {
+        // ignore unreadable bundle roots
+    }
+    if (secretsRoot) {
+        try {
+            const secretEntries = readdirSyncImpl(secretsRoot, { withFileTypes: true });
+            for (const entry of secretEntries) {
+                if (!entry.isDirectory())
+                    continue;
+                targets.add(path.join(secretsRoot, entry.name, "secrets.json"));
+            }
+        }
+        catch {
+            // ignore unreadable secrets roots
+        }
+    }
+    return [...targets].sort();
+}
+function readConfigFingerprint(targets, readFileSyncImpl, existsSyncImpl) {
+    if (!readFileSyncImpl || !existsSyncImpl) {
+        return {
+            value: UNKNOWN_METADATA,
+            source: "unknown",
+            trackedFiles: targets.length,
+            presentFiles: 0,
+        };
+    }
+    const hash = (0, crypto_1.createHash)("sha256");
+    let presentFiles = 0;
+    for (const target of targets) {
+        hash.update(target);
+        hash.update("\0");
+        if (!existsSyncImpl(target)) {
+            hash.update("missing");
+            hash.update("\0");
+            continue;
+        }
+        presentFiles += 1;
+        hash.update("present");
+        hash.update("\0");
+        try {
+            hash.update(readFileSyncImpl(target, "utf-8"));
+        }
+        catch {
+            hash.update("unreadable");
+        }
+        hash.update("\0");
+    }
+    return {
+        value: hash.digest("hex"),
+        source: "content-hash",
+        trackedFiles: targets.length,
+        presentFiles,
+    };
+}
 function getRuntimeMetadata(deps = {}) {
     const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const homeDir = readHomeDir();
+    const secretsRoot = deps.secretsRoot ?? (homeDir ? path.join(homeDir, ".agentsecrets") : null);
+    const daemonLoggingPath = deps.daemonLoggingPath ?? (homeDir ? path.join(homeDir, ".agentstate", "daemon", "logging.json") : null);
     const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
     const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
+    const readdirSyncImpl = deps.readdirSync ?? optionalFunction(fs, "readdirSync")?.bind(fs) ?? null;
+    const existsSyncImpl = deps.existsSync ?? optionalFunction(fs, "existsSync")?.bind(fs) ?? null;
     const execFileSyncImpl = deps.execFileSync
         ?? optionalFunction(childProcess, "execFileSync")?.bind(childProcess)
         ?? null;
@@ -101,6 +191,8 @@ function getRuntimeMetadata(deps = {}) {
             throw new Error("git unavailable");
         }))
         : { value: UNKNOWN_METADATA, source: "unknown" };
+    const configTargets = listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl);
+    const configFingerprint = readConfigFingerprint(configTargets, readFileSyncImpl, existsSyncImpl);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.runtime_metadata_read",
@@ -109,10 +201,19 @@ function getRuntimeMetadata(deps = {}) {
             version,
             lastUpdated: lastUpdated.value,
             lastUpdatedSource: lastUpdated.source,
+            repoRoot,
+            configFingerprint: configFingerprint.value === UNKNOWN_METADATA
+                ? UNKNOWN_METADATA
+                : configFingerprint.value.slice(0, 12),
+            configFingerprintSource: configFingerprint.source,
+            configTrackedFiles: configFingerprint.trackedFiles,
+            configPresentFiles: configFingerprint.presentFiles,
         },
     });
     return {
         version,
         lastUpdated: lastUpdated.value,
+        repoRoot,
+        configFingerprint: configFingerprint.value,
     };
 }

package/dist/heart/daemon/sense-manager.js

@@ -45,6 +45,7 @@ const process_manager_1 = require("./process-manager");
 const DEFAULT_TEAMS_PORT = 3978;
 const DEFAULT_BLUEBUBBLES_PORT = 18790;
 const DEFAULT_BLUEBUBBLES_WEBHOOK_PATH = "/bluebubbles-webhook";
+const BLUEBUBBLES_RUNTIME_FRESHNESS_WINDOW_MS = 90_000;
 function defaultSenses() {
     return {
         cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
@@ -176,20 +177,36 @@ function runtimeInfoFor(status) {
         return { runtime: "running" };
     return { runtime: "error" };
 }
+function blueBubblesRuntimeStateIsFresh(lastCheckedAt, now = Date.now()) {
+    if (!lastCheckedAt) {
+        return false;
+    }
+    const checkedAt = Date.parse(lastCheckedAt);
+    if (!Number.isFinite(checkedAt)) {
+        return false;
+    }
+    return checkedAt >= now - BLUEBUBBLES_RUNTIME_FRESHNESS_WINDOW_MS;
+}
 function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
     const agentRoot = path.join(bundlesRoot, `${agent}.ouro`);
     const runtimePath = path.join(agentRoot, "state", "senses", "bluebubbles", "runtime.json");
-    if (snapshot?.runtime !== "running" || !fs.existsSync(runtimePath)) {
+    if (!fs.existsSync(runtimePath)) {
         return { runtime: snapshot?.runtime };
     }
     const state = (0, bluebubbles_runtime_state_1.readBlueBubblesRuntimeState)(agent, agentRoot);
+    if (!blueBubblesRuntimeStateIsFresh(state.lastCheckedAt)) {
+        return { runtime: snapshot?.runtime };
+    }
     if (state.upstreamStatus === "error") {
         return {
             runtime: "error",
             detail: state.detail,
         };
     }
-    return { runtime: snapshot.runtime };
+    if (state.upstreamStatus === "ok") {
+        return { runtime: "running" };
+    }
+    return { runtime: snapshot?.runtime };
 }
 class DaemonSenseManager {
     processManager;

package/dist/heart/identity.js

@@ -134,7 +134,6 @@ function buildDefaultAgentTemplate(_agentName) {
     };
 }
 let _cachedAgentName = null;
-let _cachedAgentConfig = null;
 let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
@@ -199,22 +198,13 @@ function getAgentSecretsPath(agentName = getAgentName()) {
 }
 /**
  * Load and parse `<agentRoot>/agent.json`.
- * Caches the result after first load.
+ * 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;
     }
-    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");
     let raw;
@@ -289,6 +279,7 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", or "openai-codex".`);
     }
+    const provider = rawProvider;
     const rawVersion = parsed.version;
     const version = rawVersion === undefined ? 1 : rawVersion;
     if (typeof version !== "number" ||
@@ -321,10 +312,10 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
     }
-    _cachedAgentConfig = {
+    const config = {
         version,
         enabled,
-        provider: rawProvider,
+        provider,
         context: parsed.context,
         logging: parsed.logging,
         senses: normalizeSenses(parsed.senses, configFile),
@@ -336,7 +327,7 @@ function loadAgentConfig() {
         message: "loaded agent config from disk",
         meta: { source: "disk" },
     });
-    return _cachedAgentConfig;
+    return config;
 }
 /**
  * Prime the agent name cache explicitly.
@@ -356,11 +347,11 @@ function setAgentConfigOverride(config) {
     _agentConfigOverride = config;
 }
 /**
- * Clear only the cached agent config while preserving the resolved agent identity.
- * Used when a running agent should pick up updated disk-backed config on the next turn.
+ * 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() {
-    _cachedAgentConfig = null;
+    // No-op: disk-backed agent config is no longer memoized in-process.
 }
 /**
  * Clear all cached identity state.
@@ -368,6 +359,5 @@ function resetAgentConfigCache() {
  */
 function resetIdentity() {
     _cachedAgentName = null;
-    _cachedAgentConfig = null;
     _agentConfigOverride = null;
 }

package/package.json

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