@yawlabs/mcph 0.35.0 → 0.37.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.37.0 — 2026-04-18
+
+- **`mcph doctor` RELIABILITY section** — New block surfaces flaky dormant namespaces pulled directly from `~/.mcph/state.json`, using the same ≥3-dispatches / <80%-success definition as `mcp_connect_health`'s cross-session reliability block — so the CLI diagnostic and the LLM-facing health tool agree on what "flaky" means. Sorted worst-rate first, capped at 5. Silently omitted when no namespace qualifies, state.json doesn't exist yet, or `MCPH_DISABLE_PERSISTENCE` is set. Threshold constants + sort logic extracted into `selectFlakyNamespaces` so handleHealth and doctor can't drift apart.
+
+## 0.36.0 — 2026-04-18
+
+- **Negative signal in dispatch ranking (`boostFactor` penalty branch)** — The learning store's `boostFactor` now drops *below* 1.0 for namespaces with flaky history, mirroring the existing upward boost. Threshold is the same ≥3 dispatches / <80% success gate used by discover's inline reliability warning (v0.35.0) and health's cross-session block (v0.34.0) — so a server flagged flaky in those views also loses rank points at dispatch time rather than quietly continuing to win routing. Floor is `-10%` (`LEARNING_MIN_BOOST = 0.9`), symmetric with the existing `+10%` ceiling. Rate-based signal trumps count-based: a namespace with 10 successes but a 50% overall rate is flaky, not useful, and the penalty branch beats the positive branch in that case.
+
 ## 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).

package/dist/index.js

@@ -945,8 +945,66 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
+// 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) {
+    for (const ns of pack.namespaces) {
+      const bucket = result.get(ns) ?? /* @__PURE__ */ new Set();
+      for (const peer of pack.namespaces) {
+        if (peer !== ns) bucket.add(peer);
+      }
+      result.set(ns, bucket);
+    }
+  }
+  const sorted = /* @__PURE__ */ new Map();
+  for (const [ns, peers] of result) {
+    sorted.set(ns, Array.from(peers).sort());
+  }
+  return sorted;
+}
+function formatUsageHint(usage, coUsedWith) {
+  const parts = [];
+  if (usage && usage.succeeded >= MIN_SUCCESS_TO_SHOW) {
+    parts.push(`used ${usage.succeeded}x`);
+  }
+  if (coUsedWith.length > 0) {
+    const shown = coUsedWith.slice(0, MAX_PEERS);
+    const more = coUsedWith.length - shown.length;
+    const names = shown.map((n) => `"${n}"`).join(", ");
+    const tail = more > 0 ? ` +${more} more` : "";
+    parts.push(`often loaded with ${names}${tail}`);
+  }
+  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`;
+}
+function selectFlakyNamespaces(entries, limit) {
+  if (limit <= 0) return [];
+  return Array.from(entries).filter(({ usage }) => {
+    if (usage.dispatched < RELIABILITY_MIN_OBSERVATIONS) return false;
+    return usage.succeeded / usage.dispatched < RELIABILITY_THRESHOLD;
+  }).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, limit);
+}
+
 // src/doctor-cmd.ts
-var VERSION = true ? "0.35.0" : "dev";
+var VERSION = true ? "0.37.0" : "dev";
 async function runDoctor(opts = {}) {
   const lines = [];
   const write = opts.out ?? ((s) => process.stdout.write(s));
@@ -983,6 +1041,7 @@ async function runDoctor(opts = {}) {
   print("");
   renderEnvSection({ env, print });
   await renderStateSection({ home, env, print });
+  await renderReliabilitySection({ home, env, print });
   const clients = probeClients({ home, os, cwd });
   print("INSTALLED CLIENTS (probed config files)");
   for (const c of clients) {
@@ -1075,6 +1134,26 @@ async function renderStateSection(opts) {
   }
   print("");
 }
+async function renderReliabilitySection(opts) {
+  const { home, env, print } = opts;
+  const raw = env.MCPH_DISABLE_PERSISTENCE;
+  const disabled = raw !== void 0 && raw !== "" && (raw === "1" || raw.toLowerCase() === "true");
+  if (disabled) return;
+  const filePath = join4(userConfigDir(home), STATE_FILENAME);
+  const persisted = await loadState(filePath);
+  if (persisted.savedAt === 0) return;
+  const entries = Object.entries(persisted.learning).map(([namespace, usage]) => ({ namespace, usage }));
+  const flaky = selectFlakyNamespaces(entries, 5);
+  if (flaky.length === 0) return;
+  print("RELIABILITY (dormant, <80% success)");
+  const now = Date.now();
+  for (const { namespace, usage } of flaky) {
+    const rate = Math.round(usage.succeeded / usage.dispatched * 100);
+    const age = formatRelativeAge(now - usage.lastUsedAt);
+    print(`  ${namespace} \u2014 ${usage.dispatched} calls, ${rate}% success, last used ${age} ago`);
+  }
+  print("");
+}
 function formatRelativeAge(ms) {
   const clamped = Math.max(0, ms);
   const s = Math.floor(clamped / 1e3);
@@ -2355,6 +2434,8 @@ function pushToolCall(history, record, limit = HISTORY_LIMIT) {
 // src/learning.ts
 var LEARNING_MIN_OBSERVATIONS = 3;
 var LEARNING_MAX_BOOST = 1.1;
+var LEARNING_MIN_BOOST = 0.9;
+var PENALTY_RATE_THRESHOLD = 0.8;
 var SATURATION_AT = 10;
 var LearningStore = class {
   usage = /* @__PURE__ */ new Map();
@@ -2377,13 +2458,23 @@ var LearningStore = class {
   get(namespace) {
     return this.usage.get(namespace);
   }
-  // Boost factor in [1.0, LEARNING_MAX_BOOST]. Grows with successful
-  // observation count, saturating at SATURATION_AT successes so a
-  // heavily-used server can't runaway-win against legitimately better
-  // matches.
+  // Boost factor in [LEARNING_MIN_BOOST, LEARNING_MAX_BOOST]. Penalty
+  // branch wins when a namespace has been dispatched enough times and
+  // its success rate has fallen below 80%; otherwise the positive
+  // branch grows the factor with successful observation count, saturating
+  // at SATURATION_AT successes so a heavily-used server can't runaway-win
+  // against legitimately better matches.
   boostFactor(namespace) {
     const u = this.usage.get(namespace);
-    if (!u || u.succeeded < LEARNING_MIN_OBSERVATIONS) return 1;
+    if (!u) return 1;
+    if (u.dispatched >= LEARNING_MIN_OBSERVATIONS) {
+      const rate = u.succeeded / u.dispatched;
+      if (rate < PENALTY_RATE_THRESHOLD) {
+        const distance = Math.min(1, (PENALTY_RATE_THRESHOLD - rate) / PENALTY_RATE_THRESHOLD);
+        return 1 - distance * (1 - LEARNING_MIN_BOOST);
+      }
+    }
+    if (u.succeeded < LEARNING_MIN_OBSERVATIONS) return 1;
     const progress = Math.min(1, u.succeeded / SATURATION_AT);
     return 1 + progress * (LEARNING_MAX_BOOST - 1);
   }
@@ -3922,7 +4013,7 @@ function categorizeSpawnError(err) {
 }
 async function connectToUpstream(config, onDisconnect, onListChanged) {
   const client = new Client(
-    { name: "mcph", version: true ? "0.35.0" : "dev" },
+    { name: "mcph", version: true ? "0.37.0" : "dev" },
     { capabilities: {} }
   );
   let transport;
@@ -4320,51 +4411,6 @@ 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) {
-    for (const ns of pack.namespaces) {
-      const bucket = result.get(ns) ?? /* @__PURE__ */ new Set();
-      for (const peer of pack.namespaces) {
-        if (peer !== ns) bucket.add(peer);
-      }
-      result.set(ns, bucket);
-    }
-  }
-  const sorted = /* @__PURE__ */ new Map();
-  for (const [ns, peers] of result) {
-    sorted.set(ns, Array.from(peers).sort());
-  }
-  return sorted;
-}
-function formatUsageHint(usage, coUsedWith) {
-  const parts = [];
-  if (usage && usage.succeeded >= MIN_SUCCESS_TO_SHOW) {
-    parts.push(`used ${usage.succeeded}x`);
-  }
-  if (coUsedWith.length > 0) {
-    const shown = coUsedWith.slice(0, MAX_PEERS);
-    const more = coUsedWith.length - shown.length;
-    const names = shown.map((n) => `"${n}"`).join(", ");
-    const tail = more > 0 ? ` +${more} more` : "";
-    parts.push(`often loaded with ${names}${tail}`);
-  }
-  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;
 function resolvePollIntervalMs() {
@@ -4448,7 +4494,7 @@ var ConnectServer = class _ConnectServer {
     this.apiUrl = apiUrl6;
     this.token = token6;
     this.server = new Server(
-      { name: "mcph", version: true ? "0.35.0" : "dev" },
+      { name: "mcph", version: true ? "0.37.0" : "dev" },
       {
         capabilities: {
           tools: { listChanged: true },
@@ -6207,17 +6253,10 @@ Use mcp_connect_discover to see imported servers.`
       }
     }
     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);
+    const flaky = selectFlakyNamespaces(
+      this.learning.entries().filter(({ namespace }) => !this.connections.has(namespace)),
+      5
+    );
     if (flaky.length > 0) {
       lines.push("\nCross-session reliability (dormant, <80% success):");
       for (const { namespace, usage } of flaky) {
@@ -6553,7 +6592,7 @@ ${installBlock}
   );
   process.exit(0);
 } else if (subcommand === "--version" || subcommand === "-V") {
-  process.stdout.write(`mcph ${true ? "0.35.0" : "dev"}
+  process.stdout.write(`mcph ${true ? "0.37.0" : "dev"}
 `);
   process.exit(0);
 } else if (subcommand && !subcommand.startsWith("-")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/mcph",
-  "version": "0.35.0",
+  "version": "0.37.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)",