@yawlabs/mcph 0.33.0 → 0.35.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to `@yawlabs/mcph` are documented here. This project uses [semantic versioning](https://semver.org) and a CI-gated release flow: pushing a `vX.Y.Z` tag triggers `.github/workflows/release.yml`, which publishes to npm.
 
+## 0.35.0 — 2026-04-18
+
+- **Inline reliability warning in `mcp_connect_discover`** — Discover now annotates dormant (not currently loaded) servers with `reliability: P% success across N past calls` when persisted learning shows ≥3 dispatches and <80% success. Renders under the server card right after the live health warning, so the LLM sees the flaky history *before* it picks a server to activate — not only after `handleHealth` surfaces it post-hoc. Thresholds match the cross-session reliability block from v0.34.0 so the two views stay consistent. Suppressed for loaded servers (the live per-call warning already covers them with fresher data).
+
+## 0.34.0 — 2026-04-18
+
+- **Cross-session reliability block in `mcp_connect_health`** — New section at the bottom of health output surfaces flaky *dormant* namespaces pulled from persisted learning: `<namespace> — N calls, P% success, last used <age> ago`. Threshold is deliberately high (≥3 dispatches, <80% success) so a one-off failure doesn't light up the panel; loaded namespaces are skipped (in-session block already covers them). Sorted worst-rate first, ties broken by most calls then alpha; capped at 5. Also fixes a gap where `handleHealth` returned early on an empty-connections session and never showed dormant history — now it falls through so operators can see which past servers were unreliable even before loading anything.
+
 ## 0.33.0 — 2026-04-18
 
 - **`mcph doctor` ENVIRONMENT section** — New block enumerating every behavior-modifier env var mcph actually reads (`MCPH_POLL_INTERVAL`, `MCPH_SERVER_CAP`, `MCPH_MIN_COMPLIANCE`, `MCPH_AUTO_LOAD`, `MCPH_PRUNE_RESPONSES`). Each shows its current value, or `(not set — <default>)` when unset. Closes a diagnostic gap where users reporting "my server cap isn't taking effect" or "compliance filter isn't blocking anything" had no doctor signal on whether the knob was even set. TOKEN / URL / DISABLE_PERSISTENCE still get their dedicated sections (richer context there).

package/dist/index.js

@@ -946,7 +946,7 @@ function errorMessage(err) {
 }
 
 // src/doctor-cmd.ts
-var VERSION = true ? "0.33.0" : "dev";
+var VERSION = true ? "0.35.0" : "dev";
 async function runDoctor(opts = {}) {
   const lines = [];
   const write = opts.out ?? ((s) => process.stdout.write(s));
@@ -2402,6 +2402,19 @@ var LearningStore = class {
     }
     return out;
   }
+  // Iterate the current store as { namespace, usage } pairs. Used by
+  // observability paths (e.g., mcp_connect_health's cross-session
+  // reliability block) that need to walk every recorded namespace.
+  entries() {
+    const out = [];
+    for (const [ns, u] of this.usage) {
+      out.push({
+        namespace: ns,
+        usage: { dispatched: u.dispatched, succeeded: u.succeeded, lastUsedAt: u.lastUsedAt }
+      });
+    }
+    return out;
+  }
   // Replace in-memory state with the given snapshot. Used on startup
   // to restore persisted signal; silently overwrites anything already
   // in the store, so callers should only invoke this before recording.
@@ -3909,7 +3922,7 @@ function categorizeSpawnError(err) {
 }
 async function connectToUpstream(config, onDisconnect, onListChanged) {
   const client = new Client(
-    { name: "mcph", version: true ? "0.33.0" : "dev" },
+    { name: "mcph", version: true ? "0.35.0" : "dev" },
     { capabilities: {} }
   );
   let transport;
@@ -4310,6 +4323,8 @@ async function reportTools(serverId, tools) {
 // src/usage-hints.ts
 var MAX_PEERS = 3;
 var MIN_SUCCESS_TO_SHOW = 1;
+var RELIABILITY_MIN_OBSERVATIONS = 3;
+var RELIABILITY_THRESHOLD = 0.8;
 function buildCoUsageMap(packs) {
   const result = /* @__PURE__ */ new Map();
   for (const pack of packs) {
@@ -4342,6 +4357,13 @@ function formatUsageHint(usage, coUsedWith) {
   if (parts.length === 0) return null;
   return `usage: ${parts.join("; ")}`;
 }
+function formatReliabilityWarning(usage) {
+  if (!usage || usage.dispatched < RELIABILITY_MIN_OBSERVATIONS) return null;
+  const rate = usage.succeeded / usage.dispatched;
+  if (rate >= RELIABILITY_THRESHOLD) return null;
+  const pct = Math.round(rate * 100);
+  return `reliability: ${pct}% success across ${usage.dispatched} past calls`;
+}
 
 // src/server.ts
 var DEFAULT_POLL_INTERVAL_MS = 6e4;
@@ -4426,7 +4448,7 @@ var ConnectServer = class _ConnectServer {
     this.apiUrl = apiUrl6;
     this.token = token6;
     this.server = new Server(
-      { name: "mcph", version: true ? "0.33.0" : "dev" },
+      { name: "mcph", version: true ? "0.35.0" : "dev" },
       {
         capabilities: {
           tools: { listChanged: true },
@@ -5301,6 +5323,10 @@ var ConnectServer = class _ConnectServer {
       if (shadow) lines.push(`    ${shadow}`);
       const warning = formatHealthWarning(connection?.health, this.activationFailures.get(server.namespace));
       if (warning) lines.push(`    ${warning}`);
+      if (!connection) {
+        const reliability = formatReliabilityWarning(this.learning.get(server.namespace));
+        if (reliability) lines.push(`    ${reliability}`);
+      }
       const usageHint = formatUsageHint(this.learning.get(server.namespace), coUsageMap.get(server.namespace) ?? []);
       if (usageHint) lines.push(`    ${usageHint}`);
       if (!connection) {
@@ -6161,23 +6187,43 @@ Use mcp_connect_discover to see imported servers.`
     }
     if (this.connections.size === 0) {
       lines.push("No servers loaded in this session yet.");
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-    lines.push("Session health:\n");
-    for (const [namespace, conn] of this.connections) {
-      const h = conn.health;
-      const avgLatency = h.totalCalls > 0 ? Math.round(h.totalLatencyMs / h.totalCalls) : 0;
-      const errorRate = h.totalCalls > 0 ? Math.round(h.errorCount / h.totalCalls * 100) : 0;
-      const idleCount = this.idleCallCounts.get(namespace) ?? 0;
-      const idleLimit = adaptiveThreshold(namespace, this.recentToolCalls, _ConnectServer.IDLE_CALL_THRESHOLD);
-      const toolNames = conn.tools.map((t) => t.name).join(", ");
-      lines.push(`  ${namespace} [${conn.status}] (${conn.config.type})`);
-      lines.push(`    tools: ${conn.tools.length} \u2014 ${toolNames}`);
-      lines.push(`    calls: ${h.totalCalls}, errors: ${h.errorCount} (${errorRate}%)`);
-      lines.push(`    avg latency: ${avgLatency}ms`);
-      lines.push(`    idle: ${idleCount}/${idleLimit} until auto-unload`);
-      if (h.lastErrorMessage) {
-        lines.push(`    last error: ${h.lastErrorMessage} at ${h.lastErrorAt}`);
+    } else {
+      lines.push("Session health:\n");
+      for (const [namespace, conn] of this.connections) {
+        const h = conn.health;
+        const avgLatency = h.totalCalls > 0 ? Math.round(h.totalLatencyMs / h.totalCalls) : 0;
+        const errorRate = h.totalCalls > 0 ? Math.round(h.errorCount / h.totalCalls * 100) : 0;
+        const idleCount = this.idleCallCounts.get(namespace) ?? 0;
+        const idleLimit = adaptiveThreshold(namespace, this.recentToolCalls, _ConnectServer.IDLE_CALL_THRESHOLD);
+        const toolNames = conn.tools.map((t) => t.name).join(", ");
+        lines.push(`  ${namespace} [${conn.status}] (${conn.config.type})`);
+        lines.push(`    tools: ${conn.tools.length} \u2014 ${toolNames}`);
+        lines.push(`    calls: ${h.totalCalls}, errors: ${h.errorCount} (${errorRate}%)`);
+        lines.push(`    avg latency: ${avgLatency}ms`);
+        lines.push(`    idle: ${idleCount}/${idleLimit} until auto-unload`);
+        if (h.lastErrorMessage) {
+          lines.push(`    last error: ${h.lastErrorMessage} at ${h.lastErrorAt}`);
+        }
+      }
+    }
+    const now = Date.now();
+    const flaky = this.learning.entries().filter(({ namespace, usage }) => {
+      if (this.connections.has(namespace)) return false;
+      if (usage.dispatched < 3) return false;
+      return usage.succeeded / usage.dispatched < 0.8;
+    }).sort((a, b) => {
+      const aRate = a.usage.succeeded / a.usage.dispatched;
+      const bRate = b.usage.succeeded / b.usage.dispatched;
+      if (aRate !== bRate) return aRate - bRate;
+      if (a.usage.dispatched !== b.usage.dispatched) return b.usage.dispatched - a.usage.dispatched;
+      return a.namespace.localeCompare(b.namespace);
+    }).slice(0, 5);
+    if (flaky.length > 0) {
+      lines.push("\nCross-session reliability (dormant, <80% success):");
+      for (const { namespace, usage } of flaky) {
+        const rate = Math.round(usage.succeeded / usage.dispatched * 100);
+        const age = formatRelativeAge(now - usage.lastUsedAt);
+        lines.push(`  ${namespace} \u2014 ${usage.dispatched} calls, ${rate}% success, last used ${age} ago`);
       }
     }
     return { content: [{ type: "text", text: lines.join("\n") }] };
@@ -6507,7 +6553,7 @@ ${installBlock}
   );
   process.exit(0);
 } else if (subcommand === "--version" || subcommand === "-V") {
-  process.stdout.write(`mcph ${true ? "0.33.0" : "dev"}
+  process.stdout.write(`mcph ${true ? "0.35.0" : "dev"}
 `);
   process.exit(0);
 } else if (subcommand && !subcommand.startsWith("-")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/mcph",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "mcp.hosting — one install, all your MCP servers, managed from the cloud",
   "license": "UNLICENSED",
   "author": "Yaw Labs <contact@yaw.sh> (https://yaw.sh)",