@yawlabs/mcph 0.47.0 → 0.47.2

package/dist/index.js

@@ -125,7 +125,8 @@ function stripJsoncComments(src) {
   return out;
 }
 function parseJsonc(src) {
-  const stripped = stripJsoncComments(src);
+  const debommed = src.charCodeAt(0) === 65279 ? src.slice(1) : src;
+  const stripped = stripJsoncComments(debommed);
   return JSON.parse(stripped);
 }
 
@@ -191,9 +192,9 @@ var LEGACY_PROJECT_FILENAME = ".mcph.json";
 var LEGACY_LOCAL_FILENAME = ".mcph.local.json";
 var NEW_CONFIG_FILENAME = "config.json";
 var NEW_LOCAL_FILENAME = "config.local.json";
-async function exists(path4) {
+async function exists(path5) {
   try {
-    await stat(path4);
+    await stat(path5);
     return true;
   } catch {
     return false;
@@ -244,7 +245,7 @@ async function migrateLegacyConfigPaths(opts) {
   }
 }
 async function findLegacyProjectRoot(cwd, home) {
-  const { resolve: resolve4, dirname: dirname3 } = await import("path");
+  const { resolve: resolve4, dirname: dirname2 } = await import("path");
   const homeResolved = resolve4(home);
   let dir = resolve4(cwd);
   let prev = "";
@@ -254,7 +255,7 @@ async function findLegacyProjectRoot(cwd, home) {
     const legacyLocal = join(dir, LEGACY_LOCAL_FILENAME);
     if (await exists(legacyProject) || await exists(legacyLocal)) return dir;
     prev = dir;
-    dir = dirname3(dir);
+    dir = dirname2(dir);
   }
   return null;
 }
@@ -264,10 +265,10 @@ var CONFIG_FILENAME = "config.json";
 var LOCAL_CONFIG_FILENAME = "config.local.json";
 var CURRENT_SCHEMA_VERSION = 1;
 var DEFAULT_API_BASE = "https://mcp.hosting";
-async function readConfigAt(path4, scope, warnings) {
+async function readConfigAt(path5, scope, warnings) {
   let raw;
   try {
-    raw = await readFile(path4, "utf8");
+    raw = await readFile(path5, "utf8");
   } catch {
     return null;
   }
@@ -276,19 +277,19 @@ async function readConfigAt(path4, scope, warnings) {
     parsed = parseJsonc(raw);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    warnings.push(`${path4}: invalid JSON (${msg}) \u2014 file ignored`);
-    log("warn", "Config file is not valid JSON; ignoring", { path: path4, error: msg });
+    warnings.push(`${path5}: invalid JSON (${msg}) \u2014 file ignored`);
+    log("warn", "Config file is not valid JSON; ignoring", { path: path5, error: msg });
     return null;
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    warnings.push(`${path4}: root must be a JSON object \u2014 file ignored`);
+    warnings.push(`${path5}: root must be a JSON object \u2014 file ignored`);
     return null;
   }
   const obj = parsed;
   const version = typeof obj.version === "number" ? obj.version : void 0;
   if (version !== void 0 && version > CURRENT_SCHEMA_VERSION) {
     warnings.push(
-      `${path4}: schema version ${version} is newer than this mcph (${CURRENT_SCHEMA_VERSION}); upgrade with \`npm i -g @yawlabs/mcph@latest\`. Loading best-effort.`
+      `${path5}: schema version ${version} is newer than this mcph (${CURRENT_SCHEMA_VERSION}); upgrade with \`npm i -g @yawlabs/mcph@latest\`. Loading best-effort.`
     );
   }
   const token6 = typeof obj.token === "string" && obj.token.length > 0 ? obj.token : void 0;
@@ -298,21 +299,21 @@ async function readConfigAt(path4, scope, warnings) {
   if (token6) {
     if (scope === "project") {
       warnings.push(
-        `${path4}: 'token' should not appear in a project-shared file. Move it to ${CONFIG_DIRNAME}/${LOCAL_CONFIG_FILENAME} (gitignored) or ~/${CONFIG_DIRNAME}/${CONFIG_FILENAME}.`
+        `${path5}: 'token' should not appear in a project-shared file. Move it to ${CONFIG_DIRNAME}/${LOCAL_CONFIG_FILENAME} (gitignored) or ~/${CONFIG_DIRNAME}/${CONFIG_FILENAME}.`
       );
     }
-    await checkPermissions(path4, warnings);
+    await checkPermissions(path5, warnings);
   }
-  return { path: path4, scope, version, token: token6, apiBase, servers, blocked };
+  return { path: path5, scope, version, token: token6, apiBase, servers, blocked };
 }
-async function checkPermissions(path4, warnings) {
+async function checkPermissions(path5, warnings) {
   if (process.platform === "win32") return;
   try {
-    const st = await stat2(path4);
+    const st = await stat2(path5);
     const mode = st.mode & 511;
     if ((mode & 63) !== 0) {
       warnings.push(
-        `${path4}: contains a token but is readable by group/other (mode ${mode.toString(8)}). Run \`chmod 600 ${path4}\` to restrict.`
+        `${path5}: contains a token but is readable by group/other (mode ${mode.toString(8)}). Run \`chmod 600 ${path5}\` to restrict.`
       );
     }
   } catch {
@@ -994,6 +995,124 @@ import { readFile as readFile3 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 
+// src/analytics.ts
+import { request as request3 } from "undici";
+var FLUSH_INTERVAL = 3e4;
+var FLUSH_SIZE = 50;
+var MAX_BUFFER = 5e3;
+var buffer = [];
+var dispatchBuffer = [];
+var flushTimer = null;
+var apiUrl = "";
+var token = "";
+var lastFailure = null;
+function getLastAnalyticsFailure() {
+  return lastFailure;
+}
+function recordConnectEvent(event) {
+  if (buffer.length >= MAX_BUFFER) return;
+  buffer.push({ ...event, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  if (buffer.length >= FLUSH_SIZE) {
+    flush().catch(() => {
+    });
+  }
+}
+function recordDispatchEvent(event) {
+  if (dispatchBuffer.length >= MAX_BUFFER) return;
+  dispatchBuffer.push(event);
+  if (dispatchBuffer.length >= FLUSH_SIZE) {
+    flushDispatch().catch(() => {
+    });
+  }
+}
+async function flush() {
+  if (buffer.length === 0 || !apiUrl || !token) return;
+  const events = buffer.splice(0, FLUSH_SIZE);
+  const url = `${apiUrl.replace(/\/$/, "")}/api/connect/analytics`;
+  try {
+    const res = await request3(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ events }),
+      headersTimeout: 1e4,
+      bodyTimeout: 1e4
+    });
+    if (res.statusCode >= 400) {
+      const room = MAX_BUFFER - buffer.length;
+      if (room > 0) buffer.push(...events.slice(0, room));
+      log("warn", "Analytics flush failed", { status: res.statusCode });
+      lastFailure = { statusCode: res.statusCode, url, at: Date.now() };
+    } else {
+      lastFailure = null;
+    }
+    await res.body.text().catch(() => {
+    });
+  } catch (err) {
+    const room = MAX_BUFFER - buffer.length;
+    if (room > 0) buffer.push(...events.slice(0, room));
+    log("warn", "Analytics flush error", { error: err.message });
+  }
+}
+async function flushDispatch() {
+  if (dispatchBuffer.length === 0 || !apiUrl || !token) return;
+  const events = dispatchBuffer.splice(0, FLUSH_SIZE);
+  const url = `${apiUrl.replace(/\/$/, "")}/api/connect/dispatch-events`;
+  try {
+    const res = await request3(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ events }),
+      headersTimeout: 1e4,
+      bodyTimeout: 1e4
+    });
+    if (res.statusCode >= 400 && res.statusCode !== 204) {
+      const room = MAX_BUFFER - dispatchBuffer.length;
+      if (room > 0) dispatchBuffer.push(...events.slice(0, room));
+      log("warn", "Dispatch-events flush failed", { status: res.statusCode });
+      lastFailure = { statusCode: res.statusCode, url, at: Date.now() };
+    } else if (res.statusCode < 400) {
+      lastFailure = null;
+    }
+    await res.body.text().catch(() => {
+    });
+  } catch (err) {
+    const room = MAX_BUFFER - dispatchBuffer.length;
+    if (room > 0) dispatchBuffer.push(...events.slice(0, room));
+    log("warn", "Dispatch-events flush error", { error: err.message });
+  }
+}
+function initAnalytics(url, tok) {
+  apiUrl = url;
+  token = tok;
+  flushTimer = setInterval(() => {
+    flush().catch(() => {
+    });
+    flushDispatch().catch(() => {
+    });
+  }, FLUSH_INTERVAL);
+  if (flushTimer.unref) flushTimer.unref();
+}
+async function shutdownAnalytics() {
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+  for (let i = 0; i < 3 && buffer.length > 0; i++) {
+    await flush();
+  }
+  for (let i = 0; i < 3 && dispatchBuffer.length > 0; i++) {
+    await flushDispatch();
+  }
+  buffer.length = 0;
+  dispatchBuffer.length = 0;
+}
+
 // src/cli-shadows.ts
 var EMPTY = [];
 var NAMESPACE_REGISTRY = {
@@ -1229,7 +1348,7 @@ var INSTALL_TARGETS = [
 function resolveInstallPath(opts) {
   const home = opts.home ?? homedir3();
   const appData = opts.appData ?? process.env.APPDATA ?? join3(home, "AppData", "Roaming");
-  const { clientId, scope, os, projectDir } = opts;
+  const { clientId, scope, os, projectDir, claudeConfigDir } = opts;
   const target = INSTALL_TARGETS.find((t) => t.clientId === clientId);
   if (!target) throw new Error(`Unknown client: ${clientId}`);
   const scopeSpec = target.scopes.find((s) => s.scope === scope);
@@ -1240,15 +1359,24 @@ function resolveInstallPath(opts) {
   if (scopeSpec.requiresProjectDir && !projectDir) {
     throw new Error(`Scope ${scope} for ${clientId} requires a project directory`);
   }
-  const p = pathFor(clientId, scope, os, { home, appData, projectDir: projectDir ?? "" });
+  const p = pathFor(clientId, scope, os, {
+    home,
+    appData,
+    projectDir: projectDir ?? "",
+    claudeConfigDir: claudeConfigDir && claudeConfigDir.length > 0 ? claudeConfigDir : void 0
+  });
   return p;
 }
 function pathFor(client, scope, os, base) {
-  const { home, appData, projectDir } = base;
+  const { home, appData, projectDir, claudeConfigDir } = base;
   const sep = os === "windows" ? "\\" : "/";
   const joinPath = (...parts) => parts.join(sep);
   if (client === "claude-code") {
     if (scope === "user") {
+      if (claudeConfigDir) {
+        const absolute = join3(claudeConfigDir, ".claude.json");
+        return { absolute, display: absolute, containerPath: ["mcpServers"] };
+      }
       const display = os === "windows" ? "%USERPROFILE%\\.claude.json" : "~/.claude.json";
       return { absolute: join3(home, ".claude.json"), display, containerPath: ["mcpServers"] };
     }
@@ -1259,6 +1387,10 @@ function pathFor(client, scope, os, base) {
         containerPath: ["mcpServers"]
       };
     }
+    if (claudeConfigDir) {
+      const absolute = join3(claudeConfigDir, ".claude.json");
+      return { absolute, display: absolute, containerPath: ["projects", projectDir, "mcpServers"] };
+    }
     return {
       absolute: join3(home, ".claude.json"),
       display: os === "windows" ? "%USERPROFILE%\\.claude.json" : "~/.claude.json",
@@ -1311,20 +1443,39 @@ function buildLaunchEntry(opts) {
 var ENTRY_NAME = "mcp.hosting";
 var CLAUDE_CODE_ALLOW_PATTERN = "mcp__mcp_hosting__*";
 function resolveClaudeCodeSettingsPath(scope, opts) {
-  const { home, projectDir } = opts;
-  if (scope === "user") return join3(home, ".claude", "settings.json");
+  const { home, projectDir, claudeConfigDir } = opts;
+  const cfgDir = claudeConfigDir && claudeConfigDir.length > 0 ? claudeConfigDir : null;
+  if (scope === "user") return cfgDir ? join3(cfgDir, "settings.json") : join3(home, ".claude", "settings.json");
   if (scope === "project" && projectDir) return join3(projectDir, ".claude", "settings.json");
   if (scope === "local" && projectDir) return join3(projectDir, ".claude", "settings.local.json");
   return null;
 }
 
 // src/persistence.ts
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/atomic-write.ts
+import { mkdir as mkdir2, rename as rename2, unlink, writeFile } from "fs/promises";
 import path2 from "path";
+async function atomicWriteFile(filePath, contents, encoding = "utf8") {
+  const dir = path2.dirname(filePath);
+  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await mkdir2(dir, { recursive: true });
+  try {
+    await writeFile(tmp, contents, encoding);
+    await rename2(tmp, filePath);
+  } catch (err) {
+    await unlink(tmp).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/persistence.ts
 var STATE_SCHEMA_VERSION = 1;
 var STATE_FILENAME = "state.json";
 function statePath(configDir = userConfigDir()) {
-  return path2.join(configDir, STATE_FILENAME);
+  return path3.join(configDir, STATE_FILENAME);
 }
 function emptyState() {
   return { version: STATE_SCHEMA_VERSION, savedAt: 0, learning: {}, packHistory: [] };
@@ -1348,19 +1499,21 @@ async function loadState(filePath = statePath()) {
     return emptyState();
   }
 }
-async function saveState(state, filePath = statePath()) {
+var saveChain = Promise.resolve();
+function saveState(state, filePath = statePath()) {
+  const next = saveChain.then(() => doSaveState(state, filePath));
+  saveChain = next.catch(() => void 0);
+  return next;
+}
+async function doSaveState(state, filePath) {
   const payload = {
     version: STATE_SCHEMA_VERSION,
     savedAt: Date.now(),
     learning: state.learning,
     packHistory: state.packHistory
   };
-  const dir = path2.dirname(filePath);
-  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   try {
-    await mkdir2(dir, { recursive: true });
-    await writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
-    await rename2(tmp, filePath);
+    await atomicWriteFile(filePath, JSON.stringify(payload, null, 2));
   } catch (err) {
     log("warn", "Failed to save mcph state", { error: errorMessage(err) });
   }
@@ -1399,6 +1552,45 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
+// src/tool-report.ts
+import { request as request4 } from "undici";
+var apiUrl2 = "";
+var token2 = "";
+var lastFailure2 = null;
+function getLastReportFailure() {
+  return lastFailure2;
+}
+function initToolReport(url, tok) {
+  apiUrl2 = url;
+  token2 = tok;
+}
+async function reportTools(serverId, tools) {
+  if (!apiUrl2 || !token2 || !serverId) return;
+  const url = `${apiUrl2.replace(/\/$/, "")}/api/connect/servers/${serverId}/tools`;
+  try {
+    const res = await request4(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token2}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ tools }),
+      headersTimeout: 1e4,
+      bodyTimeout: 1e4
+    });
+    await res.body.text().catch(() => {
+    });
+    if (res.statusCode >= 400 && res.statusCode !== 404) {
+      log("warn", "Tool report failed", { serverId, status: res.statusCode });
+      lastFailure2 = { statusCode: res.statusCode, url, at: Date.now() };
+    } else if (res.statusCode < 400) {
+      lastFailure2 = null;
+    }
+  } catch (err) {
+    log("warn", "Tool report error", { serverId, error: err?.message });
+  }
+}
+
 // src/usage-hints.ts
 var MAX_PEERS = 3;
 var MIN_SUCCESS_TO_SHOW = 1;
@@ -1458,7 +1650,7 @@ function selectFlakyNamespaces(entries, limit) {
 }
 
 // src/doctor-cmd.ts
-var VERSION = true ? "0.47.0" : "dev";
+var VERSION = true ? "0.47.2" : "dev";
 async function runDoctor(opts = {}) {
   if (opts.json) return runDoctorJson(opts);
   const lines = [];
@@ -1497,7 +1689,9 @@ async function runDoctor(opts = {}) {
   renderEnvSection({ env, print });
   await renderStateSection({ home, env, print });
   await renderReliabilitySection({ home, env, print });
-  const clients = probeClients({ home, os, cwd });
+  renderBackgroundPostersSection({ print });
+  const claudeConfigDir = env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.length > 0 ? env.CLAUDE_CONFIG_DIR : void 0;
+  const clients = probeClients({ home, os, cwd, claudeConfigDir });
   print("INSTALLED CLIENTS (probed config files)");
   for (const c of clients) {
     const status = c.unavailable ? "unavailable on this OS" : c.malformed ? "exists but JSON is malformed \u2014 fix or rerun `mcph install`" : c.hasMcphEntry ? `OK \u2014 has "${ENTRY_NAME}" entry` : c.exists ? `present, no "${ENTRY_NAME}" entry \u2014 run \`mcph install ${c.clientId}${c.scope === "user" ? "" : ` --scope ${c.scope}`}\`` : `not configured \u2014 run \`mcph install ${c.clientId}${c.scope === "user" ? "" : ` --scope ${c.scope}`}\``;
@@ -1557,7 +1751,8 @@ async function runDoctorJson(opts) {
   const env = opts.env ?? process.env;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const config = await loadMcphConfig({ cwd, home, env });
-  const clients = probeClients({ home, os, cwd });
+  const claudeConfigDir = env.CLAUDE_CONFIG_DIR && env.CLAUDE_CONFIG_DIR.length > 0 ? env.CLAUDE_CONFIG_DIR : void 0;
+  const clients = probeClients({ home, os, cwd, claudeConfigDir });
   const envVarNames = [
     "MCPH_POLL_INTERVAL",
     "MCPH_SERVER_CAP",
@@ -1675,6 +1870,25 @@ async function renderStateSection(opts) {
   }
   const filePath = join4(userConfigDir(home), STATE_FILENAME);
   print(`  path:   ${filePath}`);
+  const peek = await peekStateFile(filePath);
+  if (peek.kind === "malformed") {
+    print("  status: corrupt -- file exists but JSON is unparseable");
+    print(`  fix:    \`mcph reset-learning\` to clear, or open ${filePath} and fix by hand`);
+    print(`  detail: ${peek.message}`);
+    print("");
+    return;
+  }
+  if (peek.kind === "stale-version") {
+    print(`  status: schema mismatch (file is v${peek.version ?? "?"}, this mcph reads v${peek.expected})`);
+    print("  fix:    `mcph reset-learning` to drop the old file -- learning will rebuild on use");
+    print("");
+    return;
+  }
+  if (peek.kind === "unreadable") {
+    print(`  status: unreadable (${peek.message})`);
+    print("");
+    return;
+  }
   const persisted = await loadState(filePath);
   if (persisted.savedAt === 0) {
     print("  (no persisted state yet \u2014 will be created on the first tool call)");
@@ -1685,6 +1899,29 @@ async function renderStateSection(opts) {
   }
   print("");
 }
+async function peekStateFile(filePath) {
+  let raw;
+  try {
+    raw = await readFile3(filePath, "utf8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return { kind: "missing" };
+    }
+    return { kind: "unreadable", message: err instanceof Error ? err.message : String(err) };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { kind: "malformed", message: err instanceof Error ? err.message : String(err) };
+  }
+  if (!parsed || typeof parsed !== "object") return { kind: "malformed", message: "top-level value is not an object" };
+  const version = parsed.version;
+  if (version !== STATE_SCHEMA_VERSION) {
+    return { kind: "stale-version", version, expected: STATE_SCHEMA_VERSION };
+  }
+  return { kind: "ok" };
+}
 async function renderReliabilitySection(opts) {
   const { home, env, print } = opts;
   const raw = env.MCPH_DISABLE_PERSISTENCE;
@@ -1705,6 +1942,18 @@ async function renderReliabilitySection(opts) {
   }
   print("");
 }
+function renderBackgroundPostersSection(opts) {
+  const { print } = opts;
+  const analyticsFailure = getLastAnalyticsFailure();
+  const reportFailure = getLastReportFailure();
+  if (!analyticsFailure && !reportFailure) return;
+  const now = Date.now();
+  const fmt = (f) => `HTTP ${f.statusCode} from ${f.url}, ${formatRelativeAge(now - f.at)} ago`;
+  print("BACKGROUND POSTERS (recent failures)");
+  print(`  analytics:    ${analyticsFailure ? fmt(analyticsFailure) : "(no recent failure)"}`);
+  print(`  tool-report:  ${reportFailure ? fmt(reportFailure) : "(no recent failure)"}`);
+  print("");
+}
 function formatRelativeAge(ms) {
   const clamped = Math.max(0, ms);
   const s = Math.floor(clamped / 1e3);
@@ -1746,7 +1995,8 @@ function probeClients(opts) {
           scope: scope.scope,
           os: opts.os,
           home: opts.home,
-          projectDir: scope.requiresProjectDir ? opts.cwd : void 0
+          projectDir: scope.requiresProjectDir ? opts.cwd : void 0,
+          claudeConfigDir: opts.claudeConfigDir
         });
       } catch {
         continue;
@@ -1784,9 +2034,9 @@ function probeClients(opts) {
   }
   return out;
 }
-function walkContainer(root, path4) {
+function walkContainer(root, path5) {
   let cur = root;
-  for (const key of path4) {
+  for (const key of path5) {
     if (typeof cur !== "object" || cur === null || Array.isArray(cur)) return null;
     cur = cur[key];
   }
@@ -1815,7 +2065,8 @@ async function probeClientsAsync(opts) {
         scope: scope.scope,
         os: opts.os,
         home: opts.home,
-        projectDir: scope.requiresProjectDir ? opts.cwd : void 0
+        projectDir: scope.requiresProjectDir ? opts.cwd : void 0,
+        claudeConfigDir: opts.claudeConfigDir
       });
       const exists3 = existsSync(resolved.absolute);
       let hasMcphEntry = false;
@@ -1922,9 +2173,9 @@ function shellHistorySources(opts) {
   }
   return sources;
 }
-function readTailLines(path4, n) {
+function readTailLines(path5, n) {
   try {
-    const raw = readFileSync(path4, "utf8");
+    const raw = readFileSync(path5, "utf8");
     const all = raw.split(/\r?\n/);
     return all.length <= n ? all : all.slice(all.length - n);
   } catch {
@@ -2025,9 +2276,8 @@ function closestNames(query, candidates, limit) {
 
 // src/install-cmd.ts
 import { existsSync as existsSync2 } from "fs";
-import { chmod, mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { chmod, readFile as readFile4 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname2 } from "path";
 import { join as join5, resolve as resolve2 } from "path";
 import { createInterface } from "readline/promises";
 var USAGE = "Usage: mcph install <claude-code|claude-desktop|cursor|vscode> [--scope user|project|local]\n                       [--token <mcp_pat_\u2026>] [--project-dir <path>] [--os macos|linux|windows]\n                       [--force | --skip] [--dry-run] [--no-mcph-config]\n       mcph install --list                       (detect clients; no writes)\n       mcph install --all  [--token <mcp_pat_\u2026>] (install into every detected client)";
@@ -2089,7 +2339,8 @@ ${USAGE}`);
       scope,
       os,
       home: opts.home,
-      projectDir
+      projectDir,
+      claudeConfigDir: opts.claudeConfigDir
     });
   } catch (e) {
     err(`mcph install: ${e.message}`);
@@ -2172,40 +2423,39 @@ ${USAGE}`);
   const writeMcphConfig = !opts.skipMcphConfig;
   const home = opts.home ?? homedir5();
   const mcphConfigPath = join5(home, CONFIG_DIRNAME, CONFIG_FILENAME);
-  const mcphConfigJson = await composeMcphConfig(mcphConfigPath, token6);
+  const mcphConfigComposed = await composeMcphConfig(mcphConfigPath, token6);
+  if (mcphConfigComposed.backupPath) {
+    log2(
+      `mcph install: existing ${mcphConfigPath} was malformed; original bytes backed up to ${mcphConfigComposed.backupPath} before overwriting.`
+    );
+  }
+  const mcphConfigJson = mcphConfigComposed.json;
   const settingsPatch = opts.clientId === "claude-code" ? await prepareClaudeCodeSettingsPatch({
     scope,
     home,
     projectDir,
-    os
+    os,
+    claudeConfigDir: opts.claudeConfigDir
   }) : null;
   if (opts.dryRun) {
     log2("\n--- dry run: would write the following ---");
+    if (writeMcphConfig) log2(`# ${mcphConfigPath}
+${mcphConfigJson}`);
     log2(`
 # ${resolved.absolute}
 ${clientJson}`);
-    if (writeMcphConfig) log2(`# ${mcphConfigPath}
-${mcphConfigJson}`);
     if (settingsPatch?.changed) log2(`# ${settingsPatch.path}
 ${settingsPatch.nextJson}`);
-    const wouldWrite = [resolved.absolute];
+    const wouldWrite = [];
     if (writeMcphConfig) wouldWrite.push(mcphConfigPath);
+    wouldWrite.push(resolved.absolute);
     if (settingsPatch?.changed) wouldWrite.push(settingsPatch.path);
     return { written: [], wouldWrite, messages, exitCode: 0 };
   }
-  try {
-    await mkdir3(dirname2(resolved.absolute), { recursive: true });
-    await writeFile2(resolved.absolute, clientJson, "utf8");
-  } catch (e) {
-    err(`mcph install: failed to write ${resolved.absolute}: ${e.message}`);
-    return { written: [], wouldWrite: [], messages, exitCode: 1 };
-  }
-  log2(`Wrote ${resolved.absolute}`);
-  const written = [resolved.absolute];
+  const written = [];
   if (writeMcphConfig) {
     try {
-      await mkdir3(dirname2(mcphConfigPath), { recursive: true });
-      await writeFile2(mcphConfigPath, mcphConfigJson, "utf8");
+      await atomicWriteFile(mcphConfigPath, mcphConfigJson);
       if (process.platform !== "win32") {
         try {
           await chmod(mcphConfigPath, 384);
@@ -2214,15 +2464,22 @@ ${settingsPatch.nextJson}`);
       }
     } catch (e) {
       err(`mcph install: failed to write ${mcphConfigPath}: ${e.message}`);
-      return { written, wouldWrite: [], messages, exitCode: 1 };
+      return { written: [], wouldWrite: [], messages, exitCode: 1 };
     }
     log2(`Wrote ${mcphConfigPath}`);
     written.push(mcphConfigPath);
   }
+  try {
+    await atomicWriteFile(resolved.absolute, clientJson);
+  } catch (e) {
+    err(`mcph install: failed to write ${resolved.absolute}: ${e.message}`);
+    return { written, wouldWrite: [], messages, exitCode: 1 };
+  }
+  log2(`Wrote ${resolved.absolute}`);
+  written.push(resolved.absolute);
   if (settingsPatch?.changed) {
     try {
-      await mkdir3(dirname2(settingsPatch.path), { recursive: true });
-      await writeFile2(settingsPatch.path, settingsPatch.nextJson, "utf8");
+      await atomicWriteFile(settingsPatch.path, settingsPatch.nextJson);
       log2(`Wrote ${settingsPatch.path} (added ${CLAUDE_CODE_ALLOW_PATTERN} to permissions.allow)`);
       written.push(settingsPatch.path);
     } catch (e) {
@@ -2237,33 +2494,34 @@ ${settingsPatch.nextJson}`);
   return { written, wouldWrite: [], messages, exitCode: 0 };
 }
 async function prepareClaudeCodeSettingsPatch(opts) {
-  const path4 = resolveClaudeCodeSettingsPath(opts.scope, {
+  const path5 = resolveClaudeCodeSettingsPath(opts.scope, {
     home: opts.home,
     projectDir: opts.projectDir,
-    os: opts.os
+    os: opts.os,
+    claudeConfigDir: opts.claudeConfigDir
   });
-  if (!path4) return null;
+  if (!path5) return null;
   let existing = {};
-  if (existsSync2(path4)) {
+  if (existsSync2(path5)) {
     try {
-      const raw = await readFile4(path4, "utf8");
+      const raw = await readFile4(path5, "utf8");
       if (raw.trim().length > 0) {
         const parsed = parseJsonc(raw);
         if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
           existing = parsed;
         } else {
-          return { path: path4, nextJson: "", changed: false };
+          return { path: path5, nextJson: "", changed: false };
         }
       }
     } catch {
-      return { path: path4, nextJson: "", changed: false };
+      return { path: path5, nextJson: "", changed: false };
     }
   }
   const merged = mergePermissionsAllow(existing, [CLAUDE_CODE_ALLOW_PATTERN]);
   const before = JSON.stringify(existing);
   const after = JSON.stringify(merged);
-  if (before === after) return { path: path4, nextJson: "", changed: false };
-  return { path: path4, nextJson: `${JSON.stringify(merged, null, 2)}
+  if (before === after) return { path: path5, nextJson: "", changed: false };
+  return { path: path5, nextJson: `${JSON.stringify(merged, null, 2)}
 `, changed: true };
 }
 function mergePermissionsAllow(existing, patterns) {
@@ -2279,13 +2537,13 @@ function mergePermissionsAllow(existing, patterns) {
   out.permissions = perms;
   return out;
 }
-async function promptCollision(path4, io) {
+async function promptCollision(path5, io) {
   const stdin = io?.stdin ?? process.stdin;
   const stdout = io?.stdout ?? process.stdout;
   const rl = createInterface({ input: stdin, output: stdout });
   try {
     const answer = (await rl.question(
-      `${path4} already has an "${ENTRY_NAME}" entry.
+      `${path5} already has an "${ENTRY_NAME}" entry.
   [o]verwrite, [s]kip, or [a]bort? (default: skip) `
     )).trim().toLowerCase();
     if (answer.startsWith("o")) return "overwrite";
@@ -2321,23 +2579,37 @@ function mergeClientConfig(existing, containerPath, entry) {
   parent[leafKey] = container;
   return out;
 }
-async function composeMcphConfig(path4, token6) {
+async function composeMcphConfig(path5, token6) {
   let existing = {};
-  if (existsSync2(path4)) {
+  let backupPath;
+  if (existsSync2(path5)) {
+    let raw = "";
     try {
-      const raw = await readFile4(path4, "utf8");
-      const parsed = parseJsonc(raw);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-        existing = parsed;
-      }
+      raw = await readFile4(path5, "utf8");
     } catch {
+      raw = "";
+    }
+    if (raw) {
+      try {
+        const parsed = parseJsonc(raw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          existing = parsed;
+        }
+      } catch {
+        const candidate = `${path5}.bak-${Date.now()}`;
+        try {
+          await atomicWriteFile(candidate, raw);
+          backupPath = candidate;
+        } catch {
+        }
+      }
     }
   }
   const next = { version: CURRENT_SCHEMA_VERSION, ...existing };
   next.token = token6;
   if (typeof next.version !== "number") next.version = CURRENT_SCHEMA_VERSION;
-  return `${JSON.stringify(next, null, 2)}
-`;
+  return { json: `${JSON.stringify(next, null, 2)}
+`, backupPath };
 }
 function parseInstallArgs(argv) {
   if (argv.length === 0) return { ok: false, error: USAGE };
@@ -2427,7 +2699,7 @@ async function runInstallList(opts, log2) {
   const home = opts.home ?? homedir5();
   const cwd = opts.cwd ?? process.cwd();
   const os = opts.os ?? CURRENT_OS;
-  const probes = await probeClientsAsync({ home, os, cwd });
+  const probes = await probeClientsAsync({ home, os, cwd, claudeConfigDir: opts.claudeConfigDir });
   const rows = probes.map((p) => ({
     client: INSTALL_TARGETS.find((t) => t.clientId === p.clientId)?.label ?? p.clientId,
     scope: p.scope,
@@ -2546,9 +2818,29 @@ async function runInstallAll(opts, log2, err) {
 }
 
 // src/reset-learning-cmd.ts
-import { unlink } from "fs/promises";
+import { unlink as unlink2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join6 } from "path";
+var RESET_LEARNING_USAGE = `Usage: mcph reset-learning
+
+  Delete ~/.mcph/state.json so cross-session learning starts fresh.
+  Use this after fixing the root cause of a flaky upstream (token
+  rotated, account swapped, server replaced) so the routing penalty
+  doesn't keep suppressing it.
+
+  -h, --help  Show this help.`;
+function parseResetLearningArgs(argv) {
+  for (const arg of argv) {
+    if (arg === "-h" || arg === "--help") return { kind: "help" };
+    return {
+      kind: "error",
+      error: `mcph reset-learning: unknown argument "${arg}"
+
+${RESET_LEARNING_USAGE}`
+    };
+  }
+  return { kind: "ok", options: {} };
+}
 async function runResetLearning(opts = {}) {
   const home = opts.home ?? homedir6();
   const env = opts.env ?? process.env;
@@ -2576,7 +2868,7 @@ async function runResetLearning(opts = {}) {
   const learningCount = Object.keys(persisted.learning).length;
   const packCount = persisted.packHistory.length;
   try {
-    await unlink(filePath);
+    await unlink2(filePath);
   } catch (err) {
     if (isFileNotFound2(err)) {
       print("mcph reset-learning: no persisted state to reset.");
@@ -2613,112 +2905,6 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { request as request9 } from "undici";
 
-// src/analytics.ts
-import { request as request3 } from "undici";
-var FLUSH_INTERVAL = 3e4;
-var FLUSH_SIZE = 50;
-var MAX_BUFFER = 5e3;
-var buffer = [];
-var dispatchBuffer = [];
-var flushTimer = null;
-var apiUrl = "";
-var token = "";
-function recordConnectEvent(event) {
-  if (buffer.length >= MAX_BUFFER) return;
-  buffer.push({ ...event, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  if (buffer.length >= FLUSH_SIZE) {
-    flush().catch(() => {
-    });
-  }
-}
-function recordDispatchEvent(event) {
-  if (dispatchBuffer.length >= MAX_BUFFER) return;
-  dispatchBuffer.push(event);
-  if (dispatchBuffer.length >= FLUSH_SIZE) {
-    flushDispatch().catch(() => {
-    });
-  }
-}
-async function flush() {
-  if (buffer.length === 0 || !apiUrl || !token) return;
-  const events = buffer.splice(0, FLUSH_SIZE);
-  try {
-    const res = await request3(`${apiUrl.replace(/\/$/, "")}/api/connect/analytics`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ events }),
-      headersTimeout: 1e4,
-      bodyTimeout: 1e4
-    });
-    if (res.statusCode >= 400) {
-      const room = MAX_BUFFER - buffer.length;
-      if (room > 0) buffer.push(...events.slice(0, room));
-      log("warn", "Analytics flush failed", { status: res.statusCode });
-    }
-    await res.body.text().catch(() => {
-    });
-  } catch (err) {
-    const room = MAX_BUFFER - buffer.length;
-    if (room > 0) buffer.push(...events.slice(0, room));
-    log("warn", "Analytics flush error", { error: err.message });
-  }
-}
-async function flushDispatch() {
-  if (dispatchBuffer.length === 0 || !apiUrl || !token) return;
-  const events = dispatchBuffer.splice(0, FLUSH_SIZE);
-  try {
-    const res = await request3(`${apiUrl.replace(/\/$/, "")}/api/connect/dispatch-events`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ events }),
-      headersTimeout: 1e4,
-      bodyTimeout: 1e4
-    });
-    if (res.statusCode >= 400 && res.statusCode !== 204) {
-      const room = MAX_BUFFER - dispatchBuffer.length;
-      if (room > 0) dispatchBuffer.push(...events.slice(0, room));
-      log("warn", "Dispatch-events flush failed", { status: res.statusCode });
-    }
-    await res.body.text().catch(() => {
-    });
-  } catch (err) {
-    const room = MAX_BUFFER - dispatchBuffer.length;
-    if (room > 0) dispatchBuffer.push(...events.slice(0, room));
-    log("warn", "Dispatch-events flush error", { error: err.message });
-  }
-}
-function initAnalytics(url, tok) {
-  apiUrl = url;
-  token = tok;
-  flushTimer = setInterval(() => {
-    flush().catch(() => {
-    });
-    flushDispatch().catch(() => {
-    });
-  }, FLUSH_INTERVAL);
-  if (flushTimer.unref) flushTimer.unref();
-}
-async function shutdownAnalytics() {
-  if (flushTimer) {
-    clearInterval(flushTimer);
-    flushTimer = null;
-  }
-  for (let i = 0; i < 3 && buffer.length > 0; i++) {
-    await flush();
-  }
-  for (let i = 0; i < 3 && dispatchBuffer.length > 0; i++) {
-    await flushDispatch();
-  }
-  buffer.length = 0;
-  dispatchBuffer.length = 0;
-}
-
 // src/compliance.ts
 var GRADE_ORDER = {
   A: 4,
@@ -2727,13 +2913,20 @@ var GRADE_ORDER = {
   D: 1,
   F: 0
 };
+function classifyGrade(grade) {
+  if (grade === void 0 || grade === null) return { kind: "ungraded" };
+  const trimmed = grade.trim();
+  if (trimmed === "") return { kind: "ungraded" };
+  const up = trimmed.toUpperCase();
+  if (up in GRADE_ORDER) return { kind: "graded", rank: GRADE_ORDER[up] };
+  return { kind: "unrecognized", raw: grade };
+}
 function gradeRank(grade) {
-  if (!grade) return -1;
-  const up = grade.toUpperCase();
-  if (up in GRADE_ORDER) return GRADE_ORDER[up];
-  return -1;
+  const c = classifyGrade(grade);
+  return c.kind === "graded" ? c.rank : -1;
 }
 var invalidWarned = false;
+var unrecognizedServerWarned = /* @__PURE__ */ new Set();
 function parseMinCompliance(raw) {
   if (raw === void 0) return null;
   const trimmed = raw.trim();
@@ -2750,9 +2943,19 @@ function parseMinCompliance(raw) {
 }
 function passesMinCompliance(serverGrade, min) {
   if (min === null) return true;
-  const serverRank = gradeRank(serverGrade);
-  if (serverRank < 0) return true;
-  return serverRank >= gradeRank(min);
+  const c = classifyGrade(serverGrade);
+  if (c.kind === "ungraded") return true;
+  if (c.kind === "unrecognized") {
+    if (!unrecognizedServerWarned.has(c.raw)) {
+      unrecognizedServerWarned.add(c.raw);
+      log("warn", "Unrecognized server compliance grade; failing closed under MCPH_MIN_COMPLIANCE", {
+        grade: c.raw,
+        min
+      });
+    }
+    return false;
+  }
+  return c.rank >= gradeRank(min);
 }
 
 // src/cost-estimate.ts
@@ -3023,18 +3226,18 @@ function stepBindingKey(step, index) {
 // src/guide.ts
 import { readFile as readFile5 } from "fs/promises";
 var GUIDE_READ_TIMEOUT_MS = 1e3;
-async function readGuide(path4, scope) {
+async function readGuide(path5, scope) {
   let raw;
   try {
     raw = await Promise.race([
-      readFile5(path4, "utf8"),
+      readFile5(path5, "utf8"),
       new Promise(
         (_, reject) => setTimeout(() => reject(new Error("guide read timeout")), GUIDE_READ_TIMEOUT_MS)
       )
     ]);
   } catch (err) {
     if (err instanceof Error && err.message === "guide read timeout") {
-      log("warn", "Guide read timed out", { path: path4 });
+      log("warn", "Guide read timed out", { path: path5 });
     }
     return null;
   }
@@ -3042,7 +3245,7 @@ async function readGuide(path4, scope) {
   if (content.length === 0) {
     return null;
   }
-  return { scope, path: path4, content };
+  return { scope, path: path5, content };
 }
 async function loadUserGuide(home) {
   const p = guidePath(userConfigDir(home));
@@ -3822,6 +4025,14 @@ function buildToolRoutes(activeConnections, inactiveWithCache = []) {
   const routes = /* @__PURE__ */ new Map();
   for (const conn of activeConnections.values()) {
     for (const tool of conn.tools) {
+      const existing = routes.get(tool.namespacedName);
+      if (existing && existing.namespace !== conn.config.namespace) {
+        log("warn", "Tool route collision; later upstream shadows earlier", {
+          tool: tool.namespacedName,
+          shadowedNamespace: existing.namespace,
+          winningNamespace: conn.config.namespace
+        });
+      }
       routes.set(tool.namespacedName, {
         namespace: conn.config.namespace,
         originalName: tool.name
@@ -3969,9 +4180,12 @@ async function routeToolCall(toolName, args, toolRoutes, activeConnections) {
     });
     return result;
   } catch (err) {
-    log("error", "Tool call failed", { tool: toolName, namespace: route.namespace, error: err.message });
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err && typeof err === "object" && "code" in err && typeof err.code === "number" ? err.code : void 0;
+    log("error", "Tool call failed", { tool: toolName, namespace: route.namespace, error: message, code });
+    const codeTag = code !== void 0 ? ` [code=${code}]` : "";
     return {
-      content: [{ type: "text", text: `Error calling ${toolName}: ${err.message}` }],
+      content: [{ type: "text", text: `Error calling ${toolName}${codeTag}: ${message}` }],
       isError: true
     };
   }
@@ -4194,26 +4408,26 @@ function rankServers(context, servers) {
 }
 
 // src/rerank.ts
-import { request as request4 } from "undici";
-var apiUrl2 = "";
-var token2 = "";
+import { request as request5 } from "undici";
+var apiUrl3 = "";
+var token3 = "";
 var RERANK_TIMEOUT_MS = 2e3;
 function initRerank(url, tok) {
-  apiUrl2 = url;
-  token2 = tok;
+  apiUrl3 = url;
+  token3 = tok;
 }
 async function rerank(intent, candidateIds, limit) {
-  if (!apiUrl2 || !token2) return null;
+  if (!apiUrl3 || !token3) return null;
   if (!intent?.trim()) return null;
   if (candidateIds !== void 0 && candidateIds.length === 0) return null;
   const payload = { intent: intent.trim() };
   if (candidateIds && candidateIds.length > 0) payload.candidateIds = candidateIds;
   if (typeof limit === "number" && limit > 0) payload.limit = limit;
   try {
-    const res = await request4(`${apiUrl2.replace(/\/$/, "")}/api/connect/rerank`, {
+    const res = await request5(`${apiUrl3.replace(/\/$/, "")}/api/connect/rerank`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${token2}`,
+        Authorization: `Bearer ${token3}`,
         "Content-Type": "application/json"
       },
       body: JSON.stringify(payload),
@@ -4243,14 +4457,14 @@ async function rerank(intent, candidateIds, limit) {
 
 // src/runtime-detect.ts
 import { spawn as spawn2 } from "child_process";
-import { request as request5 } from "undici";
+import { request as request6 } from "undici";
 var PROBE_TIMEOUT_MS = 3e3;
 var RUNTIME_REPORT_PATH = "/api/connect/runtimes";
-var apiUrl3 = "";
-var token3 = "";
+var apiUrl4 = "";
+var token4 = "";
 function initRuntimeDetect(url, tok) {
-  apiUrl3 = url;
-  token3 = tok;
+  apiUrl4 = url;
+  token4 = tok;
 }
 var PROBES = {
   node: {
@@ -4362,7 +4576,7 @@ async function detectRuntimes() {
   return out;
 }
 async function reportRuntimes() {
-  if (!apiUrl3 || !token3) return;
+  if (!apiUrl4 || !token4) return;
   let runtimes;
   try {
     runtimes = await detectRuntimes();
@@ -4371,10 +4585,10 @@ async function reportRuntimes() {
     return;
   }
   try {
-    const res = await request5(`${apiUrl3.replace(/\/$/, "")}${RUNTIME_REPORT_PATH}`, {
+    const res = await request6(`${apiUrl4.replace(/\/$/, "")}${RUNTIME_REPORT_PATH}`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${token3}`,
+        Authorization: `Bearer ${token4}`,
         "Content-Type": "application/json"
       },
       body: JSON.stringify({ runtimes }),
@@ -4419,15 +4633,23 @@ function buildTiebreakPrompt(intent, candidates) {
   ].join("\n");
 }
 function parseTiebreakResponse(response, candidates) {
-  const namespaces = new Set(candidates.map((c) => c.namespace));
+  const namespaces = candidates.map((c) => c.namespace);
+  const namespaceSet = new Set(namespaces);
   for (const rawLine of response.split(/\r?\n/)) {
     const line = rawLine.trim().replace(/^[`"'*>\-\s]+|[`"'*\s]+$/g, "");
     if (!line) continue;
-    if (namespaces.has(line)) return line;
+    if (namespaceSet.has(line)) return line;
+    let bestNs = null;
+    let bestPos = Number.POSITIVE_INFINITY;
     for (const ns of namespaces) {
       const re = new RegExp(`\\b${escapeRegex(ns)}\\b`);
-      if (re.test(line)) return ns;
+      const match = re.exec(line);
+      if (match && match.index < bestPos) {
+        bestPos = match.index;
+        bestNs = ns;
+      }
     }
+    if (bestNs) return bestNs;
   }
   return null;
 }
@@ -4506,7 +4728,7 @@ function evaluateServerCap(namespace, loaded, cap) {
 }
 
 // src/test-runner.ts
-import { request as request7 } from "undici";
+import { request as request8 } from "undici";
 
 // src/upstream.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -4524,9 +4746,9 @@ import { spawn as spawn3 } from "child_process";
 import { createHash } from "crypto";
 import { createWriteStream } from "fs";
 import fs from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import { pipeline } from "stream/promises";
-import { request as request6 } from "undici";
+import { request as request7 } from "undici";
 var UV_VERSION = "0.11.7";
 var RELEASE_BASE = `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}`;
 function uvTarget() {
@@ -4603,7 +4825,7 @@ async function onPath(cmd) {
 async function fetchWithRedirects(url, maxHops = 5) {
   let current = url;
   for (let i = 0; i < maxHops; i++) {
-    const res = await request6(current, { method: "GET" });
+    const res = await request7(current, { method: "GET" });
     if (res.statusCode >= 300 && res.statusCode < 400) {
       const loc = res.headers.location;
       if (!loc) throw new Error(`Redirect without Location header from ${current}`);
@@ -4653,7 +4875,7 @@ function runCommand(cmd, args) {
 async function findBinary(root, name) {
   const entries = await fs.readdir(root, { withFileTypes: true });
   for (const e of entries) {
-    const full = path3.join(root, e.name);
+    const full = path4.join(root, e.name);
     if (e.isFile() && e.name === name) return full;
     if (e.isDirectory()) {
       const found = await findBinary(full, name);
@@ -4675,8 +4897,8 @@ async function resolveUv() {
       `No prebuilt uv binary for ${process.platform}/${process.arch}. Install uv manually: https://docs.astral.sh/uv/`
     );
   }
-  const installDir = path3.join(cacheDir(), "uv", UV_VERSION);
-  const finalBin = path3.join(installDir, binName());
+  const installDir = path4.join(cacheDir(), "uv", UV_VERSION);
+  const finalBin = path4.join(installDir, binName());
   if (await exists2(finalBin)) return finalBin;
   await fs.mkdir(installDir, { recursive: true });
   log("info", "Bootstrapping uv", { version: UV_VERSION, target, cache: installDir });
@@ -4689,11 +4911,11 @@ async function resolveUv() {
   if (!expected || expected.toLowerCase() !== actual.toLowerCase()) {
     throw new Error(`uv archive checksum mismatch (expected ${expected}, got ${actual})`);
   }
-  const archivePath = path3.join(installDir, archiveName);
+  const archivePath = path4.join(installDir, archiveName);
   await pipeline(async function* () {
     yield archiveBuf;
   }, createWriteStream(archivePath));
-  const extractDir = path3.join(installDir, "extract");
+  const extractDir = path4.join(installDir, "extract");
   await fs.rm(extractDir, { recursive: true, force: true });
   await extractArchive(archivePath, extractDir);
   const extracted = await findBinary(extractDir, binName());
@@ -4722,6 +4944,12 @@ var CONNECT_TIMEOUT = (() => {
   const n = Number.parseInt(env, 10);
   return Number.isFinite(n) && n > 0 ? n : 15e3;
 })();
+var LIST_TIMEOUT = (() => {
+  const env = process.env.MCP_LIST_TIMEOUT;
+  if (!env) return 15e3;
+  const n = Number.parseInt(env, 10);
+  return Number.isFinite(n) && n > 0 ? n : 15e3;
+})();
 var STDERR_RING_CAP = 8 * 1024;
 var MAX_TOOLS_PER_SERVER = 1e3;
 var MAX_RESOURCES_PER_SERVER = 1e3;
@@ -4746,7 +4974,7 @@ function categorizeSpawnError(err) {
 }
 async function connectToUpstream(config, onDisconnect, onListChanged) {
   const client = new Client(
-    { name: "mcph", version: true ? "0.47.0" : "dev" },
+    { name: "mcph", version: true ? "0.47.2" : "dev" },
     { capabilities: {} }
   );
   let transport;
@@ -4911,7 +5139,7 @@ async function disconnectFromUpstream(connection) {
 }
 async function fetchResourcesFromUpstream(client, namespace) {
   try {
-    const result = await client.listResources();
+    const result = await client.listResources({}, { timeout: LIST_TIMEOUT });
     const raw = result.resources ?? [];
     if (raw.length > MAX_RESOURCES_PER_SERVER) {
       log("warn", "Upstream returned more resources than cap; truncating", {
@@ -4933,7 +5161,7 @@ async function fetchResourcesFromUpstream(client, namespace) {
 }
 async function fetchPromptsFromUpstream(client, namespace) {
   try {
-    const result = await client.listPrompts();
+    const result = await client.listPrompts({}, { timeout: LIST_TIMEOUT });
     const raw = result.prompts ?? [];
     if (raw.length > MAX_PROMPTS_PER_SERVER) {
       log("warn", "Upstream returned more prompts than cap; truncating", {
@@ -4953,7 +5181,7 @@ async function fetchPromptsFromUpstream(client, namespace) {
   }
 }
 async function fetchToolsFromUpstream(client, namespace) {
-  const result = await client.listTools();
+  const result = await client.listTools({}, { timeout: LIST_TIMEOUT });
   const raw = result.tools ?? [];
   if (raw.length > MAX_TOOLS_PER_SERVER) {
     log("warn", "Upstream returned more tools than cap; truncating", {
@@ -4974,23 +5202,27 @@ async function fetchToolsFromUpstream(client, namespace) {
 // src/test-runner.ts
 var POLL_INTERVAL_MS = 3e4;
 var REQUEST_TIMEOUT_MS = 1e4;
-var apiUrl4 = "";
-var token4 = "";
+var CONSECUTIVE_404_LIMIT = 10;
+var apiUrl5 = "";
+var token5 = "";
 var pollTimer = null;
 var running = false;
+var consecutive404 = 0;
 var configRef = () => null;
 function initTestRunner(url, tok, getConfig) {
-  apiUrl4 = url;
-  token4 = tok;
+  apiUrl5 = url;
+  token5 = tok;
   configRef = getConfig;
 }
 function startTestRunner() {
   if (running) return;
   running = true;
+  consecutive404 = 0;
   schedule();
 }
 function stopTestRunner() {
   running = false;
+  consecutive404 = 0;
   if (pollTimer) {
     clearTimeout(pollTimer);
     pollTimer = null;
@@ -5008,7 +5240,7 @@ function schedule() {
   pollTimer.unref?.();
 }
 async function pollOnce() {
-  if (!apiUrl4 || !token4) return;
+  if (!apiUrl5 || !token5) return;
   const list = await fetchPending();
   if (list.length === 0) return;
   for (const pending2 of list) {
@@ -5020,23 +5252,34 @@ async function pollOnce() {
 }
 async function fetchPending() {
   try {
-    const res = await request7(`${apiUrl4.replace(/\/$/, "")}/api/connect/test-requests`, {
+    const res = await request8(`${apiUrl5.replace(/\/$/, "")}/api/connect/test-requests`, {
       method: "GET",
-      headers: { Authorization: `Bearer ${token4}` },
+      headers: { Authorization: `Bearer ${token5}` },
       headersTimeout: REQUEST_TIMEOUT_MS,
       bodyTimeout: REQUEST_TIMEOUT_MS
     });
     if (res.statusCode === 404) {
       await res.body.text().catch(() => {
       });
-      stopTestRunner();
+      consecutive404++;
+      if (consecutive404 === 1) {
+        log("warn", "Test runner endpoint returned 404; will retry", { url: `${apiUrl5}/api/connect/test-requests` });
+      }
+      if (consecutive404 >= CONSECUTIVE_404_LIMIT) {
+        log("warn", "Test runner endpoint persistently 404; stopping poller", {
+          consecutive: consecutive404
+        });
+        stopTestRunner();
+      }
       return [];
     }
     if (res.statusCode !== 200) {
       await res.body.text().catch(() => {
       });
+      consecutive404 = 0;
       return [];
     }
+    consecutive404 = 0;
     const body = await res.body.json();
     return Array.isArray(body?.requests) ? body.requests : [];
   } catch {
@@ -5093,12 +5336,12 @@ async function runOne(pending2) {
 }
 async function postResult(requestId, result) {
   try {
-    const res = await request7(
-      `${apiUrl4.replace(/\/$/, "")}/api/connect/test-requests/${encodeURIComponent(requestId)}/result`,
+    const res = await request8(
+      `${apiUrl5.replace(/\/$/, "")}/api/connect/test-requests/${encodeURIComponent(requestId)}/result`,
       {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${token4}`,
+          Authorization: `Bearer ${token5}`,
           "Content-Type": "application/json"
         },
         body: JSON.stringify(result),
@@ -5113,37 +5356,6 @@ async function postResult(requestId, result) {
   }
 }
 
-// src/tool-report.ts
-import { request as request8 } from "undici";
-var apiUrl5 = "";
-var token5 = "";
-function initToolReport(url, tok) {
-  apiUrl5 = url;
-  token5 = tok;
-}
-async function reportTools(serverId, tools) {
-  if (!apiUrl5 || !token5 || !serverId) return;
-  try {
-    const res = await request8(`${apiUrl5.replace(/\/$/, "")}/api/connect/servers/${serverId}/tools`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token5}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ tools }),
-      headersTimeout: 1e4,
-      bodyTimeout: 1e4
-    });
-    await res.body.text().catch(() => {
-    });
-    if (res.statusCode >= 400 && res.statusCode !== 404) {
-      log("warn", "Tool report failed", { serverId, status: res.statusCode });
-    }
-  } catch (err) {
-    log("warn", "Tool report error", { serverId, error: err?.message });
-  }
-}
-
 // src/server.ts
 var DEFAULT_POLL_INTERVAL_MS = 6e4;
 function resolvePollIntervalMs() {
@@ -5227,7 +5439,7 @@ var ConnectServer = class _ConnectServer {
     this.apiUrl = apiUrl6;
     this.token = token6;
     this.server = new Server(
-      { name: "mcph", version: true ? "0.47.0" : "dev" },
+      { name: "mcph", version: true ? "0.47.2" : "dev" },
       {
         capabilities: {
           tools: { listChanged: true },
@@ -5740,7 +5952,10 @@ var ConnectServer = class _ConnectServer {
         if (serverConfig) {
           let reconnected = false;
           let lastErr;
-          for (let attempt = 0; attempt < 2; attempt++) {
+          const RECONNECT_ATTEMPTS = 2;
+          const RECONNECT_DELAY_MS = 1e3;
+          for (let attempt = 0; attempt < RECONNECT_ATTEMPTS; attempt++) {
+            if (attempt > 0) await new Promise((r) => setTimeout(r, RECONNECT_DELAY_MS));
             try {
               await disconnectFromUpstream(conn);
               const newConn = await connectToUpstream(
@@ -5756,23 +5971,23 @@ var ConnectServer = class _ConnectServer {
               break;
             } catch (err) {
               lastErr = err;
-              if (attempt === 0) {
+              if (attempt < RECONNECT_ATTEMPTS - 1) {
                 log("warn", "Auto-reconnect attempt failed, retrying", {
                   namespace: route.namespace,
-                  error: err.message
+                  error: err instanceof Error ? err.message : String(err)
                 });
-                await new Promise((r) => setTimeout(r, 1e3 * 2 ** attempt));
               }
             }
           }
           if (!reconnected) {
             conn.status = "error";
-            log("error", "Auto-reconnect failed", { namespace: route.namespace, error: lastErr.message });
+            const lastErrMsg = lastErr instanceof Error ? lastErr.message : String(lastErr);
+            log("error", "Auto-reconnect failed", { namespace: route.namespace, error: lastErrMsg });
             return {
               content: [
                 {
                   type: "text",
-                  text: `Server "${route.namespace}" disconnected and auto-reconnect failed: ${lastErr.message}. Use mcp_connect_activate with server "${route.namespace}" to reload it manually.`
+                  text: `Server "${route.namespace}" disconnected and auto-reconnect failed: ${lastErrMsg}. Use mcp_connect_activate with server "${route.namespace}" to reload it manually.`
                 }
               ],
               isError: true
@@ -5800,8 +6015,7 @@ var ConnectServer = class _ConnectServer {
         toolName: route.originalName,
         action: "tool_call",
         latencyMs,
-        success: !result.isError,
-        error: result.isError ? result.content[0]?.text : void 0
+        success: !result.isError
       });
       if (!result.isError && Array.isArray(result.content)) {
         try {
@@ -5848,9 +6062,11 @@ var ConnectServer = class _ConnectServer {
         } catch {
         }
       }
+      this.learning.recordDispatch(route.namespace);
+      if (!result.isError) this.learning.recordSuccess(route.namespace);
+      this.scheduleStateSave();
       if (!result.isError) {
         this.packDetector.recordCall(route.namespace, route.originalName, Date.now());
-        this.scheduleStateSave();
       }
       await this.trackUsageAndAutoDeactivate(route.namespace);
     }
@@ -5909,9 +6125,9 @@ var ConnectServer = class _ConnectServer {
     const shortlist = bm25.slice(0, _ConnectServer.BM25_TOP_K);
     const idByNamespace = new Map(servers.map((s) => [s.namespace, s.id]));
     const candidateIds = shortlist.map((r) => idByNamespace.get(r.namespace)).filter((id) => typeof id === "string" && id.length > 0);
-    if (candidateIds.length === 0) return shortlist;
+    if (candidateIds.length === 0) return shortlist.map((r) => ({ ...r, hasRerank: false }));
     const rerankResults = await rerank(context, candidateIds);
-    if (!rerankResults) return shortlist;
+    if (!rerankResults) return shortlist.map((r) => ({ ...r, hasRerank: false }));
     const namespaceById = new Map(servers.map((s) => [s.id, s.namespace]));
     const rerankScoreByNamespace = /* @__PURE__ */ new Map();
     for (const r of rerankResults) {
@@ -5931,7 +6147,7 @@ var ConnectServer = class _ConnectServer {
       if (a.hasRerank !== b.hasRerank) return a.hasRerank ? -1 : 1;
       return b.score - a.score;
     });
-    return reordered.map((r) => ({ namespace: r.namespace, score: r.score }));
+    return reordered;
   }
   // Auto-warm confidence gate — applied to discover(context) so a single
   // clearly-winning server gets activated without the LLM needing to
@@ -5942,10 +6158,15 @@ var ConnectServer = class _ConnectServer {
     return raw === void 0 || raw === "" || raw === "1" || raw.toLowerCase() === "true";
   })();
   // Top score must clear this floor AND the gap over the runner-up must
-  // be convincing before we auto-activate. Values tuned by intuition;
-  // when we have real usage data we can re-pick them.
-  static AUTO_ACTIVATE_MIN_SCORE = 1;
-  static AUTO_ACTIVATE_MARGIN = 1.3;
+  // be convincing before we auto-activate. Values are scale-dependent --
+  // BM25 scores are unbounded positive numbers, rerank cosines are in
+  // [0, 1] -- so we keep separate thresholds and pick based on whether
+  // the top entry was reranked. Tuned by intuition; revisit when we
+  // have real usage data.
+  static AUTO_ACTIVATE_MIN_SCORE_BM25 = 1;
+  static AUTO_ACTIVATE_MARGIN_BM25 = 1.3;
+  static AUTO_ACTIVATE_MIN_SCORE_COSINE = 0.5;
+  static AUTO_ACTIVATE_MARGIN_COSINE = 1.25;
   // Below this installed-server count, discover() appends a one-line
   // marketplace pointer so sparse-config users see where to add more.
   // At or above the threshold we stay silent — power users already know
@@ -5966,7 +6187,9 @@ var ConnectServer = class _ConnectServer {
     if (ranked.length === 0) return this.handleDiscover(context);
     const top = ranked[0];
     const second = ranked[1];
-    const topWinsDecisively = top !== void 0 && top.score >= _ConnectServer.AUTO_ACTIVATE_MIN_SCORE && (second === void 0 || top.score / (second.score || 1e-6) >= _ConnectServer.AUTO_ACTIVATE_MARGIN);
+    const minScore = top?.hasRerank ? _ConnectServer.AUTO_ACTIVATE_MIN_SCORE_COSINE : _ConnectServer.AUTO_ACTIVATE_MIN_SCORE_BM25;
+    const margin = top?.hasRerank ? _ConnectServer.AUTO_ACTIVATE_MARGIN_COSINE : _ConnectServer.AUTO_ACTIVATE_MARGIN_BM25;
+    const topWinsDecisively = top !== void 0 && top.score >= minScore && (second === void 0 || top.score / (second.score || 1e-6) >= margin);
     if (!topWinsDecisively || !top) return this.handleDiscover(context);
     const existing = this.connections.get(top.namespace);
     if (existing && existing.status === "connected") return this.handleDiscover(context);
@@ -6487,9 +6710,6 @@ ${activeCount} loaded in this session, ${totalTools} tools in context${tokenSumm
       results.push(`${winner.namespace} (score ${winner.score.toFixed(2)}): ${r.message}`);
       if (r.isChanged) anyChanged = true;
       if (!r.ok) anyError = true;
-      this.learning.recordDispatch(winner.namespace);
-      if (r.ok) this.learning.recordSuccess(winner.namespace);
-      this.scheduleStateSave();
     }
     if (anyChanged) {
       this.rebuildRoutes();
@@ -7551,13 +7771,24 @@ async function runUpgrade(opts = {}) {
     print("No upgrade command available for this install method.");
     return { exitCode: 0, lines };
   }
+  const autoRunnable = method === "global-npm";
   if (!opts.run) {
-    print(`Run:
+    if (autoRunnable) {
+      print(`Run:
+  ${plan.command}
+
+Or re-run with --run to upgrade in place.`);
+    } else {
+      print(`Suggested command (run it yourself; --run only works for global-npm installs):
   ${plan.command}`);
+    }
     return { exitCode: 1, lines };
   }
-  if (method !== "global-npm") {
-    printErr(`mcph upgrade --run: refusing to auto-run upgrade for method "${method}". Run manually: ${plan.command}`);
+  if (!autoRunnable) {
+    printErr(
+      `mcph upgrade --run: install method "${method}" can't be upgraded automatically. Run manually:
+  ${plan.command}`
+    );
     return { exitCode: 2, lines };
   }
   const runner = opts.spawnImpl ?? defaultSpawn;
@@ -7572,7 +7803,7 @@ async function runUpgrade(opts = {}) {
   return { exitCode: 3, lines };
 }
 function readCurrentVersion() {
-  return true ? "0.47.0" : "dev";
+  return true ? "0.47.2" : "dev";
 }
 
 // src/index.ts
@@ -7601,7 +7832,8 @@ if (subcommand === "compliance") {
 `);
     process.exit(2);
   }
-  runInstall(parsed.options).then((r) => process.exit(r.exitCode));
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.length > 0 ? process.env.CLAUDE_CONFIG_DIR : void 0;
+  runInstall({ ...parsed.options, claudeConfigDir }).then((r) => process.exit(r.exitCode));
 } else if (subcommand === "doctor") {
   const doctorArgs = process.argv.slice(3);
   const doctorJson = doctorArgs.includes("--json");
@@ -7619,6 +7851,17 @@ if (subcommand === "compliance") {
   }
   runDoctor({ json: doctorJson }).then((r) => process.exit(r.exitCode));
 } else if (subcommand === "reset-learning") {
+  const parsed = parseResetLearningArgs(process.argv.slice(3));
+  if (parsed.kind === "help") {
+    process.stdout.write(`${RESET_LEARNING_USAGE}
+`);
+    process.exit(0);
+  }
+  if (parsed.kind === "error") {
+    process.stderr.write(`${parsed.error}
+`);
+    process.exit(2);
+  }
   runResetLearning().then((r) => process.exit(r.exitCode));
 } else if (subcommand === "servers") {
   const parsed = parseServersArgs(process.argv.slice(3));
@@ -7728,7 +7971,7 @@ if (subcommand === "compliance") {
 `);
   process.exit(0);
 } else if (subcommand === "--version" || subcommand === "-V") {
-  process.stdout.write(`mcph ${true ? "0.47.0" : "dev"}
+  process.stdout.write(`mcph ${true ? "0.47.2" : "dev"}
 `);
   process.exit(0);
 } else if (subcommand && !subcommand.startsWith("-")) {