@ouro.bot/cli 0.1.0-alpha.528 → 0.1.0-alpha.529

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.529",
+      "changes": [
+        "MCP agent status now asks the daemon for proof-bearing runtime health, including per-agent worker rows and enabled sense rows with proof method, proof age, failure layer, and recovery counters.",
+        "MCP status reports daemon/socket unreachability as an explicit status line instead of hiding it behind otherwise successful diary/session facts.",
+        "MCP status now includes its own package version and flags MCP-vs-daemon version mismatches so stale long-lived MCP servers are visible during reliability checks."
+      ]
+    },
     {
       "version": "0.1.0-alpha.528",
       "changes": [

package/dist/heart/daemon/agent-service.js

@@ -58,6 +58,7 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const diary_1 = require("../../mind/diary");
 const runtime_1 = require("../../nerves/runtime");
+const socket_client_1 = require("./socket-client");
 /** Format diary hits the same way the search_notes tool does. */
 function formatDiaryHits(hits) {
     return hits.map((f) => `[diary] ${f.text} (source=${f.source}, createdAt=${f.createdAt})`);
@@ -149,6 +150,152 @@ function listTaskFiles(agent) {
 function emit(event, message, meta) {
     (0, runtime_1.emitNervesEvent)({ component: "daemon", event, message, meta });
 }
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : null;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readMcpRuntimeVersion() {
+    const packagePath = path.resolve(__dirname, "..", "..", "..", "package.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        return stringValue(parsed.version);
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeRuntimeStatus(data, agent) {
+    const payload = objectRecord(data);
+    if (!payload)
+        return null;
+    const overview = objectRecord(payload.overview);
+    const workers = Array.isArray(payload.workers) ? payload.workers : [];
+    const senses = Array.isArray(payload.senses) ? payload.senses : [];
+    return {
+        daemonReachable: true,
+        overview: overview
+            ? {
+                daemon: stringValue(overview.daemon) ?? "unknown",
+                health: stringValue(overview.health) ?? "unknown",
+                version: stringValue(overview.version),
+                mode: stringValue(overview.mode),
+            }
+            : undefined,
+        workers: workers.flatMap((row) => {
+            const record = objectRecord(row);
+            if (!record || stringValue(record.agent) !== agent)
+                return [];
+            const worker = stringValue(record.worker);
+            const status = stringValue(record.status);
+            return worker && status ? [{ worker, status }] : [];
+        }),
+        senses: senses.flatMap((row) => {
+            const record = objectRecord(row);
+            if (!record || stringValue(record.agent) !== agent)
+                return [];
+            const sense = stringValue(record.sense);
+            const status = stringValue(record.status);
+            const enabled = booleanValue(record.enabled);
+            if (!sense || !status || enabled === null)
+                return [];
+            return [{
+                    sense,
+                    status,
+                    enabled,
+                    detail: stringValue(record.detail),
+                    proofMethod: stringValue(record.proofMethod),
+                    lastProofAt: stringValue(record.lastProofAt),
+                    proofAgeMs: numberValue(record.proofAgeMs),
+                    pendingRecoveryCount: numberValue(record.pendingRecoveryCount),
+                    failedRecoveryCount: numberValue(record.failedRecoveryCount),
+                    failureLayer: stringValue(record.failureLayer),
+                    lastFailure: stringValue(record.lastFailure),
+                    recoveryAction: stringValue(record.recoveryAction),
+                }];
+        }),
+    };
+}
+async function readRuntimeStatus(socketPath, agent) {
+    if (!socketPath)
+        return null;
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socketPath, { kind: "daemon.status" });
+        if (!response.ok) {
+            return {
+                daemonReachable: false,
+                workers: [],
+                senses: [],
+                error: response.error ?? response.message ?? "daemon status did not answer cleanly",
+            };
+        }
+        return summarizeRuntimeStatus(response.data, agent);
+    }
+    catch (error) {
+        return {
+            daemonReachable: false,
+            workers: [],
+            senses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function formatRuntimeStatusLines(runtime, mcpVersion) {
+    if (!runtime)
+        return mcpVersion ? [`mcpVersion=${mcpVersion}`] : [];
+    if (!runtime.daemonReachable) {
+        return [
+            `daemon=unreachable${runtime.error ? `\terror=${runtime.error}` : ""}`,
+            ...(mcpVersion ? [`mcpVersion=${mcpVersion}`] : []),
+        ];
+    }
+    const lines = [];
+    if (runtime.overview) {
+        const versionPart = runtime.overview.version ? `\tdaemonVersion=${runtime.overview.version}` : "";
+        const modePart = runtime.overview.mode ? `\tmode=${runtime.overview.mode}` : "";
+        const mcpVersionPart = mcpVersion ? `\tmcpVersion=${mcpVersion}` : "";
+        const mismatchPart = mcpVersion && runtime.overview.version && mcpVersion !== runtime.overview.version
+            ? `\tversionMismatch=mcp:${mcpVersion},daemon:${runtime.overview.version}`
+            : "";
+        lines.push(`daemon=${runtime.overview.daemon}\thealth=${runtime.overview.health}${versionPart}${modePart}${mcpVersionPart}${mismatchPart}`);
+    }
+    for (const worker of runtime.workers) {
+        lines.push(`worker=${worker.worker}:${worker.status}`);
+    }
+    for (const sense of runtime.senses) {
+        const detailPart = sense.detail ? `\tdetail=${sense.detail}` : "";
+        const proofPart = sense.proofMethod ? `\tproof=${sense.proofMethod}` : "";
+        const lastProofPart = sense.lastProofAt ? `\tlastProofAt=${sense.lastProofAt}` : "";
+        const proofAgePart = sense.proofAgeMs !== null ? `\tproofAgeMs=${sense.proofAgeMs}` : "";
+        const pendingPart = sense.pendingRecoveryCount !== null ? `\tpendingRecovery=${sense.pendingRecoveryCount}` : "";
+        const failedPart = sense.failedRecoveryCount !== null ? `\tfailedRecovery=${sense.failedRecoveryCount}` : "";
+        const failureLayerPart = sense.failureLayer ? `\tfailureLayer=${sense.failureLayer}` : "";
+        const failurePart = sense.lastFailure ? `\tlastFailure=${sense.lastFailure}` : "";
+        const recoveryPart = sense.recoveryAction ? `\trecovery=${sense.recoveryAction}` : "";
+        lines.push(`sense=${sense.sense}:${sense.enabled ? sense.status : "disabled"}`
+            + detailPart
+            + proofPart
+            + lastProofPart
+            + proofAgePart
+            + pendingPart
+            + failedPart
+            + failureLayerPart
+            + failurePart
+            + recoveryPart);
+    }
+    if (lines.length === 0 && mcpVersion)
+        lines.push(`mcpVersion=${mcpVersion}`);
+    return lines;
+}
 // ─── Handlers ────────────────────────────────────────────────────────────────
 async function handleAgentStatus(params) {
     (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.agent_service_start", message: "handling agent.status", meta: { agent: params.agent } });
@@ -156,16 +303,20 @@ async function handleAgentStatus(params) {
     const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
     const innerStatus = readInnerDialogStatus(params.agent);
     const sessions = enumerateSessions(params.agent);
+    const mcpVersion = readMcpRuntimeVersion();
+    const runtime = await readRuntimeStatus(params.socketPath ?? socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, params.agent);
     emit("daemon.agent_service_end", "completed agent.status", { agent: params.agent });
     const innerStatusValue = innerStatus?.status ?? "unknown";
     const lastThoughtAt = innerStatus?.lastCompletedAt ?? null;
-    const message = [
+    const agentLine = [
         `agent=${params.agent}`,
         `innerStatus=${innerStatusValue}`,
         `lastThoughtAt=${lastThoughtAt ?? "never"}`,
         `sessionCount=${sessions.length}`,
         `diaryEntries=${facts.length}`,
     ].join("\t");
+    const runtimeLines = formatRuntimeStatusLines(runtime, mcpVersion);
+    const message = [agentLine, ...runtimeLines].join("\n");
     return {
         ok: true,
         message,
@@ -176,6 +327,8 @@ async function handleAgentStatus(params) {
             sessionCount: sessions.length,
             hasDiaryEntries: facts.length > 0,
             factCount: facts.length,
+            runtime,
+            mcpVersion,
         },
     };
 }

package/dist/heart/mcp/mcp-server.js

@@ -425,7 +425,7 @@ function createMcpServer(options) {
         if (serviceHandler && typeof agentService[serviceHandler] === "function") {
             const handlerFn = agentService[serviceHandler];
             try {
-                response = await handlerFn({ agent, friendId, ...toolArgs });
+                response = await handlerFn({ agent, friendId, socketPath, ...toolArgs });
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);

package/package.json

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