@ouro.bot/cli 0.1.0-alpha.531 → 0.1.0-alpha.533

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.533",
+      "changes": [
+        "Locks the `ouro.bot` bootstrap wrapper to install the matching `@ouro.bot/cli` package version from its own package metadata instead of resolving `@ouro.bot/cli@latest`, preventing stale npm dist-tags from downgrading or skipping a just-published alpha.",
+        "Adds wrapper bootstrap coverage that fails if the wrapper queries `npm view` for `latest` during install, closing the release-smoke gap that caught `ouro.bot@0.1.0-alpha.532` reporting the older CLI."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.532",
+      "changes": [
+        "MCP clients now classify dead transports, reconnect stale servers before tool calls, retry one transport-level failure, and expose live refresh canaries so closed MCP pipes recover instead of poisoning long-running sessions.",
+        "Adds `ouro mcp canary --agent <name>` plus daemon health-monitor wiring, surfacing fresh MCP status failures in `ouro status` and validating daemon/MCP version parity and required sense health.",
+        "Explicit `daemon.stop` now writes a last-known down health state instead of creating a misleading unexpected-clean-exit tombstone, daemon background update checks no longer self-restart the live runtime, and `ouro msg` wakes the target agent before IPC delivery.",
+        "Release publishing now tags prereleases with their prerelease channel and release smoke verifies exact wrapper versions, keeping npm dist-tags from driving surprise prerelease churn through the daemon updater."
+      ]
+    },
     {
       "version": "0.1.0-alpha.531",
       "changes": [

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

@@ -116,6 +116,7 @@ const boot_sync_probe_1 = require("./boot-sync-probe");
 const connect_bay_1 = require("./connect-bay");
 const runtime_capability_check_1 = require("../runtime-capability-check");
 const vault_items_1 = require("./vault-items");
+const mcp_canary_1 = require("./mcp-canary");
 // ── ensureDaemonRunning ──
 const DEFAULT_DAEMON_STARTUP_TIMEOUT_MS = 60_000;
 const DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS = 500;
@@ -6516,6 +6517,28 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             return message;
         }
     }
+    if (command.kind === "mcp.canary") {
+        const canarySocketPath = command.socketOverride ?? deps.socketPath;
+        const result = await (0, mcp_canary_1.runMcpStatusCanary)({
+            agent: command.agent,
+            socketPath: canarySocketPath,
+            command: process.execPath,
+            commandArgs: [
+                path.join(__dirname, "ouro-bot-entry.js"),
+                "mcp-serve",
+                "--agent",
+                command.agent,
+                "--socket",
+                canarySocketPath,
+            ],
+            requiredSenses: command.requiredSenses ?? [],
+        });
+        if (!result.ok)
+            deps.setExitCode?.(1);
+        const message = command.json ? JSON.stringify(result, null, 2) : (0, mcp_canary_1.formatMcpStatusCanaryResult)(result);
+        deps.writeStdout(message);
+        return message;
+    }
     /* v8 ignore start — mcp-serve block binds to process.stdin/stdout; tested via mcp-server unit tests */
     // ── mcp-serve: start MCP server in-process on stdin/stdout ──
     if (command.kind === "mcp-serve") {

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

@@ -253,8 +253,8 @@ exports.COMMAND_REGISTRY = {
         category: "System",
         description: "Interact with MCP servers",
         usage: "ouro mcp <subcommand>",
-        example: "ouro mcp list",
-        subcommands: ["list", "call"],
+        example: "ouro mcp canary --agent ouroboros",
+        subcommands: ["list", "call", "canary"],
     },
     "mcp-serve": {
         category: "System",

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

@@ -1223,7 +1223,8 @@ function parseConfigCommand(args) {
     throw new Error(`Usage\n${usage()}`);
 }
 function parseMcpCommand(args) {
-    const [sub, ...rest] = args;
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    const [sub, ...rest] = cleaned;
     if (!sub)
         throw new Error(`Usage\n${usage()}`);
     if (sub === "list")
@@ -1237,6 +1238,34 @@ function parseMcpCommand(args) {
         const mcpArgs = argsIdx !== -1 && rest[argsIdx + 1] ? rest[argsIdx + 1] : undefined;
         return { kind: "mcp.call", server, tool, ...(mcpArgs ? { args: mcpArgs } : {}) };
     }
+    if (sub === "canary") {
+        let socketOverride;
+        let json = false;
+        const requiredSenses = [];
+        for (let i = 0; i < rest.length; i++) {
+            if (rest[i] === "--socket" && rest[i + 1]) {
+                socketOverride = rest[++i];
+                continue;
+            }
+            if (rest[i] === "--require-sense" && rest[i + 1]) {
+                requiredSenses.push(rest[++i]);
+                continue;
+            }
+            if (rest[i] === "--json") {
+                json = true;
+                continue;
+            }
+        }
+        if (!agent)
+            throw new Error("mcp canary requires --agent <name>");
+        return {
+            kind: "mcp.canary",
+            agent,
+            ...(socketOverride ? { socketOverride } : {}),
+            ...(requiredSenses.length > 0 ? { requiredSenses } : {}),
+            ...(json ? { json: true } : {}),
+        };
+    }
     throw new Error(`Usage\n${usage()}`);
 }
 function inferAgentNameFromRemote(remote) {

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

@@ -121,6 +121,7 @@ function parseStatusPayload(data) {
     const sync = raw.sync;
     const agents = raw.agents;
     const providers = raw.providers;
+    const healthChecks = raw.healthChecks;
     if (!overview || typeof overview !== "object" || Array.isArray(overview))
         return null;
     if (!Array.isArray(senses) || !Array.isArray(workers))
@@ -132,6 +133,8 @@ function parseStatusPayload(data) {
         return null;
     if (providers !== undefined && !Array.isArray(providers))
         return null;
+    if (healthChecks !== undefined && !Array.isArray(healthChecks))
+        return null;
     const parsedOverview = {
         daemon: stringField(overview.daemon) ?? "unknown",
         health: stringField(overview.health) ?? "unknown",
@@ -281,16 +284,29 @@ function parseStatusPayload(data) {
             parsed.detail = detail;
         return parsed;
     });
+    const parsedHealthChecks = (healthChecks ?? []).map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const name = stringField(row.name);
+        const status = stringField(row.status);
+        const message = stringField(row.message);
+        if (!name || !status || !message)
+            return null;
+        return { name, status, message };
+    });
     if (parsedSenses.some((row) => row === null) ||
         parsedWorkers.some((row) => row === null) ||
         parsedSync.some((row) => row === null) ||
         parsedAgents.some((row) => row === null) ||
-        parsedProviders.some((row) => row === null))
+        parsedProviders.some((row) => row === null) ||
+        parsedHealthChecks.some((row) => row === null))
         return null;
     return {
         overview: parsedOverview,
         senses: parsedSenses,
         workers: parsedWorkers,
+        healthChecks: parsedHealthChecks,
         sync: parsedSync,
         agents: parsedAgents,
         providers: parsedProviders,
@@ -482,6 +498,16 @@ function formatDaemonStatusOutput(response, fallback) {
         }
         lines.push("");
     }
+    // ── Health Checks ──
+    if (payload.healthChecks.length > 0) {
+        lines.push(`  ${teal("──")} ${bold("Health Checks")} ${teal("─".repeat(29))}`);
+        const nameWidth = Math.max(16, ...payload.healthChecks.map((r) => r.name.length));
+        const statusWidth = Math.max(8, ...payload.healthChecks.map((r) => r.status.length));
+        for (const row of payload.healthChecks) {
+            lines.push(`    ${row.name.padEnd(nameWidth)} ${statusDot(row.status)} ${row.status.padEnd(statusWidth)}  ${dim(row.message)}`);
+        }
+        lines.push("");
+    }
     // ── Git Sync (per agent) ──
     if (payload.sync.length > 0) {
         lines.push(`  ${teal("──")} ${bold("Git Sync")} ${teal("─".repeat(35))}`);
@@ -547,6 +573,7 @@ function buildStoppedStatusPayload(socketPath, syncRows = [], agentRows = []) {
         },
         senses: [],
         workers: [],
+        healthChecks: [],
         sync: syncRows,
         agents: agentRows,
         providers: [],

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

@@ -60,6 +60,7 @@ const drift_detection_1 = require("./drift-detection");
 const pulse_1 = require("./pulse");
 const socket_client_1 = require("./socket-client");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const mcp_canary_1 = require("./mcp-canary");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -131,7 +132,22 @@ const senseManager = new sense_manager_1.DaemonSenseManager({
 const healthMonitor = new health_monitor_1.HealthMonitor({
     processManager,
     scheduler,
-    senseProbeProvider: () => senseManager.listHealthProbes(),
+    senseProbeProvider: () => [
+        ...senseManager.listHealthProbes(),
+        ...managedAgents.map((agent) => (0, mcp_canary_1.createMcpStatusCanaryProbe)({
+            agent,
+            socketPath,
+            command: process.execPath,
+            commandArgs: [
+                path.join(__dirname, "ouro-bot-entry.js"),
+                "mcp-serve",
+                "--agent",
+                agent,
+                "--socket",
+                socketPath,
+            ],
+        })),
+    ],
     alertSink: (message) => {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -173,6 +189,10 @@ function scheduleCleanProcessExitAfterStopCommand() {
     if (stopCommandExitScheduled)
         return;
     stopCommandExitScheduled = true;
+    // Account for the explicit daemon.stop path so the process exit catch-all
+    // does not mislabel an operator-requested stop as an unexpected clean exit.
+    _tombstoneWritten = true;
+    writeStopCommandHealthState();
     setTimeout(() => process.exit(0), 100);
 }
 const daemon = new daemon_1.OuroDaemon({
@@ -328,6 +348,18 @@ const healthWriter = new daemon_health_1.DaemonHealthWriter((0, daemon_health_1.
 const healthSink = (0, daemon_health_1.createHealthNervesSink)(healthWriter, buildDaemonHealthState);
 (0, index_1.registerGlobalLogSink)(healthSink);
 /* v8 ignore stop */
+function writeStopCommandHealthState() {
+    try {
+        healthWriter.writeHealth({
+            ...buildDaemonHealthState(),
+            status: "down",
+            uptimeSeconds: Math.floor(process.uptime()),
+        });
+    }
+    catch {
+        // Health writes are best-effort during shutdown.
+    }
+}
 /* v8 ignore start -- habit wiring: lambdas delegate to processManager/fs; tested via HabitScheduler unit tests @preserve */
 void daemon.start().then(() => {
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();

package/dist/heart/daemon/daemon.js

@@ -54,8 +54,6 @@ const bundle_meta_1 = require("./hooks/bundle-meta");
 const agent_config_v2_1 = require("./hooks/agent-config-v2");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const update_checker_1 = require("../versioning/update-checker");
-const staged_restart_1 = require("../versioning/staged-restart");
-const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
 const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
 const agent_service_1 = require("./agent-service");
@@ -356,15 +354,20 @@ function unhealthySenseRows(senses) {
         return true;
     });
 }
-function overviewHealth(workers, senses) {
+function unhealthyHealthChecks(healthChecks) {
+    return healthChecks.filter((row) => row.status !== "ok");
+}
+function overviewHealth(workers, senses, healthChecks = []) {
     if (!workers.every((worker) => worker.status === "running"))
         return "warn";
     if (unhealthySenseRows(senses).length > 0)
         return "warn";
+    if (unhealthyHealthChecks(healthChecks).length > 0)
+        return "warn";
     return "ok";
 }
 function formatStatusSummary(payload) {
-    if (payload.overview.workerCount === 0 && payload.overview.senseCount === 0) {
+    if (payload.overview.workerCount === 0 && payload.overview.senseCount === 0 && (payload.healthChecks ?? []).length === 0) {
         return "no managed agents";
     }
     const degraded = [
@@ -373,6 +376,9 @@ function formatStatusSummary(payload) {
             .map((row) => `worker:${row.agent}/${row.worker}:${row.status}`),
         ...unhealthySenseRows(payload.senses)
             .map((row) => `sense:${row.agent}/${row.sense}:${row.status}`),
+        ...(payload.healthChecks ?? [])
+            .filter((row) => row.status !== "ok")
+            .map((row) => `health-check:${row.name}:${row.status}`),
     ];
     const detail = degraded.length > 0 ? `\tdegraded=${degraded.join(",")}` : "";
     if (!detail) {
@@ -498,6 +504,7 @@ class OuroDaemon {
         const snapshots = this.processManager.listAgentSnapshots();
         const workers = buildWorkerRows(snapshots);
         const senses = this.senseManager?.listSenseRows() ?? [];
+        const healthChecks = this.healthMonitor.getLastResults?.() ?? [];
         const repoRoot = (0, identity_1.getRepoRoot)();
         const sync = (0, agent_discovery_1.listBundleSyncRows)({ bundlesRoot: this.bundlesRoot });
         const agents = (0, agent_discovery_1.listAllBundleAgents)({ bundlesRoot: this.bundlesRoot });
@@ -509,7 +516,7 @@ class OuroDaemon {
         return {
             overview: {
                 daemon: "running",
-                health: overviewHealth(workers, senses),
+                health: overviewHealth(workers, senses, healthChecks),
                 socketPath: this.socketPath,
                 mailboxUrl,
                 outlookUrl: mailboxUrl,
@@ -521,6 +528,7 @@ class OuroDaemon {
             },
             workers,
             senses,
+            ...(healthChecks.length > 0 ? { healthChecks } : {}),
             sync,
             agents,
             ...(providers.length > 0 ? { providers } : {}),
@@ -562,8 +570,6 @@ class OuroDaemon {
         await (0, update_hooks_1.applyPendingUpdates)(this.bundlesRoot, currentVersion);
         // Start periodic update checker (polls npm registry every 30 minutes)
         // Skip in dev mode — dev builds should not auto-update from npm
-        const bundlesRoot = this.bundlesRoot;
-        const daemonSocketPath = this.socketPath;
         if (this.mode === "dev") {
             (0, runtime_1.emitNervesEvent)({
                 component: "daemon",
@@ -573,7 +579,6 @@ class OuroDaemon {
             });
         }
         else {
-            const daemon = this;
             (0, update_checker_1.startUpdateChecker)({
                 currentVersion,
                 deps: {
@@ -583,55 +588,6 @@ class OuroDaemon {
                         return res.json();
                     },
                 },
-                onUpdate: /* v8 ignore start -- integration: real npm install + process spawn @preserve */ async (result) => {
-                    if (!result.latestVersion)
-                        return;
-                    // Install via the version manager (NOT `npm install -g`). The
-                    // global install path doesn't end up on the daemon process's
-                    // NODE_PATH, so the previous `require.resolve('@ouro.bot/cli')`
-                    // -based path lookup always returned null and the staged restart
-                    // never actually completed. Verified live on 2026-04-08:
-                    // alpha.268 daemon detected alpha.270 was available, ran the
-                    // staged restart, and bailed at `staged_restart_path_failed` —
-                    // meaning the daemon could never auto-update itself and required
-                    // manual `ouro up` to pick up new versions.
-                    //
-                    // Switch to the version-managed layout the CLI itself uses:
-                    // installVersion(version) puts files at
-                    //   ~/.ouro-cli/versions/{version}/node_modules/@ouro.bot/cli
-                    // which is a known path we can compute deterministically.
-                    // Then activateVersion(version) flips the CurrentVersion symlink
-                    // so the next `ouro up` from the user sees the same version
-                    // the daemon is running.
-                    const cliHome = (0, ouro_version_manager_1.getOuroCliHome)();
-                    await (0, staged_restart_1.performStagedRestart)(result.latestVersion, {
-                        execSync: (cmd) => (0, child_process_1.execSync)(cmd, { stdio: "inherit" }),
-                        spawnSync: child_process_1.spawnSync,
-                        installNewVersion: (version) => {
-                            (0, ouro_version_manager_1.installVersion)(version, {});
-                            (0, ouro_version_manager_1.activateVersion)(version, {});
-                        },
-                        resolveNewCodePath: (version) => {
-                            const versionPath = path.join(cliHome, "versions", version, "node_modules", "@ouro.bot", "cli");
-                            return fs.existsSync(versionPath) ? versionPath : null;
-                        },
-                        gracefulShutdown: () => daemon.stop(),
-                        spawnNewDaemon: (entryPath, sock) => {
-                            const outFd = fs.openSync(os.devNull, "w");
-                            const errFd = fs.openSync(os.devNull, "w");
-                            const child = (0, child_process_1.spawn)(process.execPath, [entryPath, "--socket", sock], {
-                                detached: true,
-                                stdio: ["ignore", outFd, errFd],
-                            });
-                            child.unref();
-                            return { pid: child.pid ?? null };
-                        },
-                        nodePath: process.execPath,
-                        bundlesRoot,
-                        socketPath: daemonSocketPath,
-                    });
-                },
-                /* v8 ignore stop */
             });
         }
         // MCP connections are lazily initialized per-agent during senseTurn
@@ -1136,6 +1092,7 @@ class OuroDaemon {
                     sessionId: command.sessionId,
                     taskRef: command.taskRef,
                 });
+                await this.processManager.startAgent(command.to);
                 this.processManager.sendToAgent?.(command.to, { type: "message" });
                 return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
             }

package/dist/heart/daemon/health-monitor.js

@@ -12,6 +12,7 @@ class HealthMonitor {
     senseProbes;
     senseProbeProvider;
     intervalHandle = null;
+    lastResults = [];
     constructor(options) {
         this.processManager = options.processManager;
         this.scheduler = options.scheduler;
@@ -177,6 +178,7 @@ class HealthMonitor {
                 });
             }
         }
+        this.lastResults = results.map((result) => ({ ...result }));
         for (const result of results) {
             (0, runtime_1.emitNervesEvent)({
                 level: result.status === "critical" ? "error" : result.status === "warn" ? "warn" : "info",
@@ -191,5 +193,8 @@ class HealthMonitor {
         }
         return results;
     }
+    getLastResults() {
+        return this.lastResults.map((result) => ({ ...result }));
+    }
 }
 exports.HealthMonitor = HealthMonitor;

package/dist/heart/daemon/mcp-canary.js

@@ -0,0 +1,288 @@
+"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.parseMcpStatusText = parseMcpStatusText;
+exports.runMcpStatusCanary = runMcpStatusCanary;
+exports.formatMcpStatusCanaryResult = formatMcpStatusCanaryResult;
+exports.createMcpStatusCanaryProbe = createMcpStatusCanaryProbe;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_CANARY_TIMEOUT_MS = 10_000;
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+function defaultCommandArgs(agent, socketPath) {
+    const entryPath = path.join(__dirname, "ouro-bot-entry.js");
+    return [
+        entryPath,
+        "mcp-serve",
+        "--agent",
+        agent,
+        ...(socketPath ? ["--socket", socketPath] : []),
+    ];
+}
+function responseText(response) {
+    const result = response.result;
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        return JSON.stringify(response);
+    const content = result.content;
+    if (!Array.isArray(content))
+        return JSON.stringify(response);
+    const first = content[0];
+    if (!first || typeof first !== "object" || Array.isArray(first))
+        return JSON.stringify(response);
+    const text = first.text;
+    return typeof text === "string" ? text : JSON.stringify(response);
+}
+function parseFields(line) {
+    const parsed = {};
+    for (const segment of line.split("\t")) {
+        const idx = segment.indexOf("=");
+        if (idx <= 0)
+            continue;
+        parsed[segment.slice(0, idx)] = segment.slice(idx + 1);
+    }
+    return parsed;
+}
+function parseMcpStatusText(text) {
+    const daemon = {};
+    const senses = {};
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("daemon=")) {
+            Object.assign(daemon, parseFields(trimmed));
+            continue;
+        }
+        if (!trimmed.startsWith("sense="))
+            continue;
+        const fields = parseFields(trimmed);
+        const sense = fields.sense;
+        if (!sense)
+            continue;
+        const [name, status = "unknown"] = sense.split(":");
+        senses[name] = { ...fields, name, status };
+    }
+    return { daemon, senses, raw: text };
+}
+function validateMcpStatus(parsed, requiredSenses) {
+    const failures = [];
+    if (parsed.daemon.daemon !== "running") {
+        failures.push(`daemon=${parsed.daemon.daemon ?? "missing"}`);
+    }
+    if (parsed.daemon.health !== "ok") {
+        failures.push(`health=${parsed.daemon.health ?? "missing"}`);
+    }
+    if (parsed.daemon.daemonVersion &&
+        parsed.daemon.mcpVersion &&
+        parsed.daemon.daemonVersion !== parsed.daemon.mcpVersion) {
+        failures.push(`version mismatch daemon=${parsed.daemon.daemonVersion} mcp=${parsed.daemon.mcpVersion}`);
+    }
+    for (const [sense, row] of Object.entries(parsed.senses)) {
+        if (row.status === "disabled")
+            continue;
+        if (row.status === "running" || row.status === "interactive")
+            continue;
+        failures.push(`sense=${sense}:${row.status}`);
+    }
+    for (const sense of requiredSenses) {
+        const row = parsed.senses[sense];
+        if (!row) {
+            failures.push(`required sense missing: ${sense}`);
+            continue;
+        }
+        if (row.status !== "running" && row.status !== "interactive") {
+            failures.push(`required sense unhealthy: ${sense}:${row.status}`);
+        }
+    }
+    const senseSummary = Object.values(parsed.senses)
+        .map((row) => `${row.name}:${row.status}`)
+        .join(",");
+    const summary = failures.length === 0
+        ? `mcp canary ok: daemon=${parsed.daemon.daemon} health=${parsed.daemon.health} senses=${senseSummary}`
+        : `mcp canary failed: ${failures.join("; ")}`;
+    return {
+        ok: failures.length === 0,
+        summary,
+        details: failures.length === 0 ? [parsed.raw] : [...failures, parsed.raw],
+        parsed,
+    };
+}
+async function runMcpStatusCanary(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CANARY_TIMEOUT_MS;
+    /* v8 ignore next -- default spawn is exercised by live canaries, while unit tests inject a fake child @preserve */
+    const spawnImpl = options.spawnImpl ?? child_process_1.spawn;
+    const command = options.command ?? process.execPath;
+    const commandArgs = options.commandArgs ?? defaultCommandArgs(options.agent, options.socketPath);
+    const requiredSenses = options.requiredSenses ?? [];
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.mcp_canary_start",
+        message: "starting MCP status canary",
+        meta: { agent: options.agent, command, commandArgs, timeoutMs, requiredSenses },
+    });
+    const child = spawnImpl(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
+    let buffer = "";
+    let stderr = "";
+    const pending = new Map();
+    function cleanup() {
+        for (const [, request] of pending) {
+            clearTimeout(request.timer);
+        }
+        pending.clear();
+        if (!child.killed)
+            child.kill();
+    }
+    function failAll(error) {
+        for (const [, request] of pending) {
+            clearTimeout(request.timer);
+            request.reject(error);
+        }
+        pending.clear();
+    }
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        buffer += chunk.toString();
+        for (;;) {
+            const idx = buffer.indexOf("\n");
+            if (idx === -1)
+                break;
+            const line = buffer.slice(0, idx).trim();
+            buffer = buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            let response;
+            try {
+                response = JSON.parse(line);
+            }
+            catch {
+                failAll(new Error(`MCP canary received malformed JSON: ${line}`));
+                return;
+            }
+            const id = typeof response.id === "number" ? response.id : null;
+            if (id === null)
+                continue;
+            const request = pending.get(id);
+            if (!request)
+                continue;
+            pending.delete(id);
+            clearTimeout(request.timer);
+            request.resolve(response);
+        }
+    });
+    child.on("error", (error) => failAll(error));
+    child.on("close", (code, signal) => {
+        if (pending.size === 0)
+            return;
+        failAll(new Error(`MCP canary process closed before response code=${code} signal=${signal ?? "none"} stderr=${stderr.trim()}`));
+    });
+    let nextId = 1;
+    function request(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!child.stdin?.writable) {
+                reject(new Error("MCP canary stdin is not writable"));
+                return;
+            }
+            const id = nextId++;
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`MCP canary timed out waiting for ${method}; stderr=${stderr.trim()}`));
+            }, timeoutMs);
+            pending.set(id, { resolve, reject, timer });
+            child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+        });
+    }
+    try {
+        await request("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: "ouro-mcp-canary", version: "1.0" },
+        });
+        child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method: "initialized" }) + "\n");
+        const statusResponse = await request("tools/call", {
+            name: "status",
+            arguments: {},
+        });
+        const result = statusResponse.result;
+        if (result && typeof result === "object" && !Array.isArray(result) && result.isError === true) {
+            throw new Error(responseText(statusResponse));
+        }
+        const parsed = parseMcpStatusText(responseText(statusResponse));
+        const canary = validateMcpStatus(parsed, requiredSenses);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: canary.ok ? "daemon.mcp_canary_end" : "daemon.mcp_canary_error",
+            level: canary.ok ? "info" : "error",
+            message: canary.summary,
+            meta: { agent: options.agent, ok: canary.ok },
+        });
+        return canary;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_canary_error",
+            level: "error",
+            message: "MCP status canary failed",
+            meta: { agent: options.agent, reason },
+        });
+        return { ok: false, summary: `mcp canary failed: ${reason}`, details: [reason] };
+    }
+    finally {
+        child.stdin?.end();
+        cleanup();
+    }
+}
+function formatMcpStatusCanaryResult(result) {
+    return [
+        result.ok ? "mcp canary: ok" : "mcp canary: failed",
+        result.summary,
+        ...result.details.map((line) => `  ${line}`),
+    ].join("\n");
+}
+function createMcpStatusCanaryProbe(options) {
+    return {
+        name: `mcp-canary:${options.agent}`,
+        check: async () => {
+            const result = await runMcpStatusCanary(options);
+            return { ok: result.ok, detail: result.summary };
+        },
+    };
+}

package/dist/repertoire/mcp-client.js

@@ -1,11 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpClient = void 0;
+exports.isMcpTransportError = isMcpTransportError;
 const child_process_1 = require("child_process");
 const readline_1 = require("readline");
 const runtime_1 = require("../nerves/runtime");
 const MCP_PROTOCOL_VERSION = "2024-11-05";
+const DEFAULT_REQUEST_TIMEOUT = 10_000;
 const DEFAULT_TOOL_CALL_TIMEOUT = 30_000;
+function isMcpTransportError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes("disconnected")
+        || normalized.includes("transport")
+        || normalized.includes("closed")
+        || normalized.includes("econnreset")
+        || normalized.includes("econnrefused")
+        || normalized.includes("enoent")
+        || normalized.includes("epipe")
+        || normalized.includes("broken pipe")
+        || normalized.includes("not writable");
+}
 class McpClient {
     config;
     process = null;
@@ -18,6 +33,9 @@ class McpClient {
         this.config = config;
     }
     async connect() {
+        if (this.connected)
+            return;
+        this.shutdownProcessOnly();
         (0, runtime_1.emitNervesEvent)({
             event: "mcp.connect_start",
             component: "repertoire",
@@ -44,6 +62,7 @@ class McpClient {
         }
         catch (error) {
             this.connected = false;
+            this.shutdownProcessOnly();
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
                 event: "mcp.connect_error",
@@ -76,6 +95,10 @@ class McpClient {
         this.cachedTools = allTools;
         return allTools;
     }
+    async refreshTools() {
+        this.cachedTools = null;
+        return this.listTools();
+    }
     async callTool(name, args, timeout = DEFAULT_TOOL_CALL_TIMEOUT) {
         (0, runtime_1.emitNervesEvent)({
             event: "mcp.tool_call_start",
@@ -139,7 +162,7 @@ class McpClient {
         });
         return result;
     }
-    sendRequest(method, params, timeout) {
+    sendRequest(method, params, timeout = DEFAULT_REQUEST_TIMEOUT) {
         return new Promise((resolve, reject) => {
             if (!this.process || !this.connected && method !== "initialize") {
                 reject(new Error("MCP client is disconnected"));
@@ -160,14 +183,21 @@ class McpClient {
                 method,
                 params,
             };
-            this.writeMessage(request);
+            if (!this.writeMessage(request)) {
+                this.pending.delete(id);
+                if (pending.timer) {
+                    clearTimeout(pending.timer);
+                }
+                reject(new Error(`MCP transport is not writable for request: ${method}`));
+            }
         });
     }
     writeMessage(message) {
-        /* v8 ignore next -- defensive: stdin always writable during active connection @preserve */
         if (this.process?.stdin?.writable) {
             this.process.stdin.write(JSON.stringify(message) + "\n");
+            return true;
         }
+        return false;
     }
     setupLineReader() {
         /* v8 ignore next -- defensive: stdout always exists after spawn @preserve */
@@ -251,5 +281,13 @@ class McpClient {
             this.pending.delete(id);
         }
     }
+    shutdownProcessOnly() {
+        this.rejectAllPending(new Error("MCP transport closed during reconnect"));
+        /* v8 ignore next -- defensive: process may already be absent @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
 }
 exports.McpClient = McpClient;

package/dist/repertoire/mcp-manager.js

@@ -33,14 +33,59 @@ class McpManager {
         return result;
     }
     async callTool(server, tool, args) {
-        const entry = this.servers.get(server);
+        let entry = this.servers.get(server);
         if (!entry) {
             throw new Error(`Unknown server: ${server}`);
         }
         if (!entry.client.isConnected()) {
-            throw new Error(`Server "${server}" is disconnected`);
+            await this.recoverStaleTransport(server, "pre-call disconnected");
+            entry = this.servers.get(server);
+            if (!entry?.client.isConnected()) {
+                throw new Error(`Server "${server}" is disconnected`);
+            }
+        }
+        try {
+            return await entry.client.callTool(tool, args);
+        }
+        catch (error) {
+            if (!(0, mcp_client_1.isMcpTransportError)(error)) {
+                throw error;
+            }
+            const reason = error instanceof Error ? error.message : String(error);
+            await this.recoverStaleTransport(server, reason);
+            const recovered = this.servers.get(server);
+            if (!recovered?.client.isConnected()) {
+                throw new Error(`Server "${server}" is disconnected after recovery: ${reason}`);
+            }
+            return recovered.client.callTool(tool, args);
+        }
+    }
+    async runCanaries() {
+        const results = [];
+        for (const [server, entry] of [...this.servers]) {
+            try {
+                if (!entry.client.isConnected()) {
+                    await this.recoverStaleTransport(server, "canary disconnected");
+                }
+                const current = this.servers.get(server);
+                if (!current?.client.isConnected()) {
+                    results.push({ server, ok: false, detail: "disconnected after recovery attempt" });
+                    continue;
+                }
+                const tools = await current.client.refreshTools();
+                current.cachedTools = tools;
+                current.consecutiveFailures = 0;
+                results.push({ server, ok: true, detail: `${tools.length} tools listed` });
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                if ((0, mcp_client_1.isMcpTransportError)(error)) {
+                    await this.recoverStaleTransport(server, reason);
+                }
+                results.push({ server, ok: false, detail: reason });
+            }
         }
-        return entry.client.callTool(tool, args);
+        return results;
     }
     /* v8 ignore start — reconcile: dynamic MCP server management, tested via integration @preserve */
     /** Re-read agent config and connect new servers / disconnect removed ones. */
@@ -232,6 +277,7 @@ class McpManager {
             return;
         // Remove old entry and reconnect
         this.servers.delete(name);
+        entry.client.shutdown();
         await this.connectServer(name, entry.config);
         // Preserve failure count
         const newEntry = this.servers.get(name);
@@ -239,6 +285,17 @@ class McpManager {
             newEntry.consecutiveFailures = entry.consecutiveFailures;
         }
     }
+    /* v8 ignore stop */
+    async recoverStaleTransport(name, reason) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mcp.transport_recovery",
+            component: "repertoire",
+            message: `recovering stale MCP transport: ${name}`,
+            meta: { server: name, reason },
+        });
+        await this.restartServer(name);
+    }
 }
 exports.McpManager = McpManager;
 let _sharedManager = null;

package/package.json

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