dsh-skill-browser 1.9.11 → 2.0.1

package/lib/groups.js

@@ -27,6 +27,8 @@ import { categoriesMeta } from "./scan.js";
 // askModel() so a host without the package still loads this plugin (the AI
 // buttons then report "llm service unavailable" instead of breaking everything).
 var _llmMod = null;
+// 记录不支持 reasoningEffort 的 provider（如 magpie 聚合网关），后续直接不传该参数。
+var _noReasoning = Object.create(null);
 // llm is an OPTIONAL capability: read it through ctx.get() so the plugin still
 // loads on a host/profile that has no llm service (official rule: reserve
 // ctx.<name> for declared injections, use ctx.get() for optional services).
@@ -48,6 +50,48 @@ async function loadLlm() {
 }
 
 var STORE_FILE = join(homedir(), ".dsh", "data", "dsh-skill-browser", "groups.json");
+// AI 分组结果缓存（按技能目录集指纹，24h 有效）；只存分组结构，不含技能正文。
+var CLASSIFY_CACHE_FILE = join(homedir(), ".dsh", "data", "dsh-skill-browser", "ai-classify-cache.json");
+var CLASSIFY_CACHE_TTL = 24 * 3600 * 1000;
+function cacheHash(str) {
+  var h = 5381;
+  for (var i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) | 0;
+  return (h >>> 0).toString(36);
+}
+function loadClassifyCache() {
+  try {
+    if (!existsSync(CLASSIFY_CACHE_FILE)) return {};
+    return JSON.parse(String(readFileSync(CLASSIFY_CACHE_FILE, "utf8")).replace(/^\uFEFF/, "")) || {};
+  } catch (e) { return {}; }
+}
+function saveClassifyCache(map) {
+  try {
+    mkdirSync(dirname(CLASSIFY_CACHE_FILE), { recursive: true });
+    writeFileSync(CLASSIFY_CACHE_FILE, JSON.stringify(map), "utf8");
+  } catch (e) { /* best-effort */ }
+}
+// 清除 AI 分组结果缓存（只动缓存文件，绝不碰任何技能文件）。
+export function clearClassifyCache() {
+  try {
+    if (existsSync(CLASSIFY_CACHE_FILE)) writeFileSync(CLASSIFY_CACHE_FILE, "{}", "utf8");
+    return { ok: true };
+  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
+}
+// 并行分批分类总开关：设 false 即退回「串行单次」原方案（回退用，单点切换）。
+var PARALLEL_CLASSIFY = true;
+// 合并多批结果：按「规范化大类名」归并去重（同名大类的 subs 合并）。
+function mergeDomainsByName(list) {
+  var order = [], byKey = {};
+  for (var i = 0; i < list.length; i++) {
+    var d = list[i] || {};
+    var key = String(d.name || "").replace(/\s+/g, "").toLowerCase() || ("__" + i);
+    var t = byKey[key];
+    if (!t) { t = byKey[key] = { name: d.name, emoji: d.emoji, subs: [] }; order.push(key); }
+    var ss = Array.isArray(d.subs) ? d.subs : [];
+    for (var j = 0; j < ss.length; j++) t.subs.push(ss[j]);
+  }
+  return order.map(function (k) { return byKey[k]; });
+}
 // Two levels (domain -> sub-group) means a 109-skill library can legitimately
 // need 10 domains x 5 sub-groups, so the cap has to be generous.
 var MAX_GROUPS = 160;
@@ -448,12 +492,14 @@ export async function resolveModelRoute(ctx, cfg) {
     return route;
   }
   var tried = [];
-  var r2 = routeFromDefaultModel(ctx);
-  if (r2) return r2;
-  tried.push("agentDefaultModel");
+  // v2.0.9 用户要求：优先「当前对话模型」（live agent session selection），
+  // 其次才退 DSH 默认模型，最后目录兜底 —— 这样 AI 分组跟随你当前对话用的模型。
   var r3 = routeFromAgent(ctx);
   if (r3) return r3;
   tried.push("agent.session");
+  var r2 = routeFromDefaultModel(ctx);
+  if (r2) return r2;
+  tried.push("agentDefaultModel");
   var r4 = await routeFromLlmCatalog(ctx);
   if (r4) return r4;
   tried.push("llm.listProviders");
@@ -486,13 +532,14 @@ export async function describeModelRoute(ctx, cfg) {
 }
 
 
-async function askModel(ctx, cfg, system, userText, purpose, maxTokens) {
+export async function askModel(ctx, cfg, system, userText, purpose, maxTokens, opts) {
   // resolveModelRoute is async: stage 4 may query the host's provider catalog.
   var route = await resolveModelRoute(ctx, cfg);
   var llm = await loadLlm();
   var messages = [
     llm.createUserMessage({ content: [{ type: "text", text: userText }], source: { kind: "dsh-skill-browser" } })
   ];
+  var o2 = opts || {};
   var options = {
     provider: route.provider,
     model: route.model,
@@ -500,9 +547,11 @@ async function askModel(ctx, cfg, system, userText, purpose, maxTokens) {
     system: system,
     maxTokens: maxTokens || 2400,
     purpose: purpose,
-    signal: AbortSignal.timeout(120000)
+    signal: AbortSignal.timeout(o2.timeoutMs || 120000)
   };
-  if (route.reasoningEffort) options.reasoningEffort = route.reasoningEffort;
+  // AI 分组/封面属于结构化整理任务，不需要深度推理：显式压到 low 可明显缩短等待。
+  if (o2.reasoningEffort && !_noReasoning[String(route.provider)]) options.reasoningEffort = String(o2.reasoningEffort);
+  else if (route.reasoningEffort) options.reasoningEffort = route.reasoningEffort;
   try {
     var sid = ctx.agent && ctx.agent.session && ctx.agent.session.id;
     if (sid) options.sessionId = String(sid);
@@ -518,8 +567,39 @@ async function askModel(ctx, cfg, system, userText, purpose, maxTokens) {
 
   var llmSvc = getLlm(ctx);
   if (!llmSvc) throw new Error("宿主未提供 llm 服务，AI 功能不可用");
-  var assembler = new llm.BlockAssembler();
-  for await (var chunk of llmSvc.stream(options)) assembler.push(chunk);
+
+  // 一次完整尝试：跑流 + 检查 finish。finish 里的 failure 也是错误来源
+  // （UNSUPPORTED_REASONING_EFFORT 就是从 finish 抛出的，必须一起判）。
+  async function attemptOnce(opts2) {
+    var asm = new llm.BlockAssembler();
+    for await (var ch of llmSvc.stream(opts2)) asm.push(ch);
+    var fin = asm.finish;
+    if (fin && fin.kind && fin.kind !== "stop") {
+      var fl = fin.failure;
+      var dt = fl ? [fl.code ? "[" + String(fl.code) + "]" : "", String(fl.message || fl)].filter(Boolean).join(" ") : "(无 failure 详情)";
+      var e2 = new Error("模型流异常结束（" + String(fin.kind) + "）: " + dt);
+      e2.code = fl && fl.code ? String(fl.code) : "LLM_FINISH_" + String(fin.kind).toUpperCase();
+      throw e2;
+    }
+    return asm;
+  }
+
+  var assembler;
+  try {
+    assembler = await attemptOnce(options);
+  } catch (eTry) {
+    var sig = String((eTry && (eTry.code || eTry.message)) || eTry);
+    // 该 provider 不支持 reasoningEffort（实测 magpie 报 UNSUPPORTED_REASONING_EFFORT）：
+    // 去掉参数重试，并记住这个 provider，后续调用直接不传，避免每次都白跑一轮。
+    if (options.reasoningEffort && /REASONING_EFFORT|reasoning.?effort|unsupported/i.test(sig)) {
+      _noReasoning[String(route.provider)] = true;
+      delete options.reasoningEffort;
+      if (ctx.logger && ctx.logger.warn) ctx.logger.warn('dsh-skill-browser: provider "' + route.provider + '" 不支持 reasoningEffort，已自动去掉并重试');
+      assembler = await attemptOnce(options);
+    } else {
+      throw eTry;
+    }
+  }
   var finish = assembler.finish;
   if (finish && finish.kind && finish.kind !== "stop") {
     // finish shape is { kind, failure } — NOT { error }.
@@ -579,6 +659,10 @@ var CLASSIFY_SYSTEM =
 // to the user first, then calls applyPlan() with mode replace|merge - "如果对 AI
 // 分组满意就替换原来的组" must be an explicit user decision, never a side effect.
 export async function aiClassify(ctx, cfg, skills, opts) {
+  // 【铁律·用户强制】AI 分组是纯只读流程：只读取技能元数据（frontmatter），
+  // 绝不修改 / 移动 / 重命名 / 删除任何技能文件（SKILL.md 或技能目录）。
+  // 本流程只写 ① 结果缓存 ai-classify-cache.json；分组方案不落盘（落盘由用户确认后
+  // 的 applyPlan 单独写 groups.json，同样不碰任何技能文件）。
   if (!getLlm(ctx)) throw new Error("宿主未提供 llm 服务，AI 功能不可用");
   var o = opts || {};
   var mode = o.mode === "merge" ? "merge" : "replace";
@@ -602,16 +686,32 @@ export async function aiClassify(ctx, cfg, skills, opts) {
     }
   }
 
+  // ── AI 分组结果缓存（同一批技能 + 同 mode 24h 内直接复用，避免重复调模型）──
+  // 指纹只用技能目录名集合，不涉及任何技能内容，因此缓存同样不读取正文。
+  var cacheKey = mode + ":" + cacheHash(pool.map(function (x) { return x.dir; }).sort().join("|"));
+  var _classifyCache = loadClassifyCache();
+  var _cacheHit = _classifyCache[cacheKey];
+  if (_cacheHit && _cacheHit.plan && (Date.now() - Number(_cacheHit.ts || 0)) < CLASSIFY_CACHE_TTL) {
+    if (ctx.logger && ctx.logger.info) ctx.logger.info("dsh-skill-browser: ai-classify cache hit (" + pool.length + " skills)");
+    return { ok: true, plan: _cacheHit.plan, mode: mode, stats: _cacheHit.stats, model: _cacheHit.model || null, cached: true };
+  }
+
+  // 【硬约束·用户强制】AI 分组的模型输入只允许「元数据白名单」：
+  //   目录名 dir + 中文名 zh + frontmatter description（各截前 60 字）+ 现分类 cat。
+  // 严禁读取 / 拼入 SKILL.md 正文（body / content / fullText 等）。即使上游误传
+  // 了正文字段，这里也一律忽略；并用行长断言兜底，防止正文被拼进 prompt。
   function buildList(arr) {
     var out = [];
     for (var i = 0; i < arr.length; i++) {
       var s = arr[i];
-      var line = s.dir;
-      var zh = String(s.zh || "").trim();
-      var desc = String(s.desc || "").trim();
-      if (zh) line += " | " + zh.slice(0, 60);
-      else if (desc) line += " | " + desc.slice(0, 60);
+      var line = String(s.dir || "");
+      var zh = String(s.zh || "").trim().slice(0, 60);
+      var desc = String(s.desc || "").trim().slice(0, 60);
+      if (zh) line += " | " + zh;
+      else if (desc) line += " | " + desc;
       if (s.cat && s.cat !== "other") line += " | 现分类:" + (catLabelOf[s.cat] || s.cat);
+      // 兜底断言：单行只应是元数据（正常 < 160 字）；超长说明混入了正文，拒绝。
+      if (line.length > 200) throw new Error("AI 分组输入疑似包含技能正文，已拒绝（只允许元数据）");
       out.push(line);
     }
     return out;
@@ -632,7 +732,7 @@ export async function aiClassify(ctx, cfg, skills, opts) {
       list.join("\n");
     // A full 109-skill tree easily exceeds 4k tokens; truncation would parse-fail
     // and surface as "AI 分组坏了".
-    var res = await askModel(ctx, cfg, CLASSIFY_SYSTEM, userText, "skill-browser-classify", 8000);
+    var res = await askModel(ctx, cfg, CLASSIFY_SYSTEM, userText, "skill-browser-classify", 6000, { reasoningEffort: "low", timeoutMs: 150000 });
     var data = extractJson(res.text);
     var raw = data && Array.isArray(data.domains) ? data.domains : [];
     if (!raw.length && data && Array.isArray(data.groups)) raw = legacyToDomains(data.groups);
@@ -703,9 +803,50 @@ export async function aiClassify(ctx, cfg, skills, opts) {
     return out;
   }
 
-  // Pass 1: the whole (or unassigned) catalogue.
-  var p1 = await classifyOnce(pool, []);
-  routeUsed = p1.route;
+  // Pass 1: 分批并行分类（提速）。PARALLEL_CLASSIFY=false 即退回串行单次（回退开关）。
+  //  - pool ≥ 45 才分；每批 ~40、最多 4 批并行 Promise.all；
+  //  - 合并时按「同名大类」归并去重（mergeDomainsByName）；
+  //  - 任一批失败 → 自动回退串行单次，保证可用性（并行只是加速，不是唯一路径）。
+  var ranParallel = false, ranBatches = 1;
+  async function classifyWhole() {
+    if (!PARALLEL_CLASSIFY || pool.length < 45) {
+      ranParallel = false; ranBatches = 1;
+      var one = await classifyOnce(pool, []);
+      return { raw: one.raw, route: one.route };
+    }
+    var BATCH = 40, nB = Math.ceil(pool.length / BATCH);
+    if (nB > 4) { nB = 4; BATCH = Math.ceil(pool.length / nB); }
+    var batches = [];
+    for (var bi = 0; bi < nB; bi++) batches.push(pool.slice(bi * BATCH, bi * BATCH + BATCH));
+    var parts = await Promise.all(batches.map(function (bt) { return classifyOnce(bt, []); }));
+    var route0 = null, all = [];
+    for (var pi = 0; pi < parts.length; pi++) {
+      if (parts[pi].route) route0 = parts[pi].route;
+      var rr0 = parts[pi].raw || [];
+      for (var pj = 0; pj < rr0.length; pj++) all.push(rr0[pj]);
+    }
+    ranParallel = true; ranBatches = nB;
+    return { raw: mergeDomainsByName(all), route: route0 };
+  }
+
+  var p1;
+  try {
+    p1 = await classifyWhole();
+  } catch (eP1) {
+    ranParallel = false; ranBatches = 1;
+    var msg1 = String((eP1 && eP1.message) || eP1);
+    if (ctx.logger && ctx.logger.warn) ctx.logger.warn("dsh-skill-browser: classify batch failed, fallback serial: " + msg1);
+    try {
+      var fb = await classifyOnce(pool, []);
+      p1 = { raw: fb.raw, route: fb.route };
+    } catch (eP1b) {
+      if (/abort|timeout|中断/i.test(String((eP1b && eP1b.message) || eP1b))) {
+        var fb2 = await classifyOnce(pool, []);
+        p1 = { raw: fb2.raw, route: fb2.route };
+      } else { throw eP1b; }
+    }
+  }
+  routeUsed = p1.route || routeUsed;
   if (!p1.raw.length) throw new Error("模型没有给出任何分组");
   absorb(p1.raw);
 
@@ -713,7 +854,8 @@ export async function aiClassify(ctx, cfg, skills, opts) {
   // Re-ask only about the leftovers so they get real semantic groups instead of
   // one "其他" bin.
   var left = leftoversOf();
-  if (left.length && plan.domains.length) {
+  // 只有遗漏较多时才补第二次调用（每次调用几十秒，少一次就快一倍）。
+  if (left.length > 20 && plan.domains.length) {
     var names = [];
     for (var cn = 0; cn < plan.domains.length; cn++) names.push(plan.domains[cn].name);
     try {
@@ -753,13 +895,21 @@ export async function aiClassify(ctx, cfg, skills, opts) {
     subCount += plan.domains[a].subs.length;
     for (var b = 0; b < plan.domains[a].subs.length; b++) covered += plan.domains[a].subs[b].skills.length;
   }
-  return {
+  var _result = {
     ok: true,
     plan: plan,
     mode: mode,
     stats: { skills: pool.length, domains: plan.domains.length, subs: subCount, covered: covered },
-    model: routeUsed
+    model: routeUsed,
+    parallel: ranParallel,
+    batches: ranBatches
   };
+  // 写入缓存（best-effort；plan 只含分组结构，不含任何技能正文）。
+  try {
+    _classifyCache[cacheKey] = { ts: Date.now(), mode: mode, model: routeUsed, stats: _result.stats, plan: plan };
+    saveClassifyCache(_classifyCache);
+  } catch (eC) { /* ignore */ }
+  return _result;
 }
 
 // Turn a flat [{"name","skills":[...]}] reply into the two-level shape.
@@ -948,7 +1098,7 @@ export async function aiCover(ctx, cfg, group, sampleSkills) {
     "分组名称：" + group.name + "\n" +
     (sample ? "包含技能：" + sample + "\n" : "") +
     "请为这个分组生成一张 200x200 的 SVG 封面图。";
-  var res = await askModel(ctx, cfg, COVER_SYSTEM, userText, "skill-browser-cover", 2000);
+  var res = await askModel(ctx, cfg, COVER_SYSTEM, userText, "skill-browser-cover", 2000, { reasoningEffort: "low", timeoutMs: 60000 });
   var svg = cleanSvg(res.text);
   var saved = setGroupCover(group.id, svg);
   if (!saved.ok) throw new Error(saved.error || "封面保存失败");

package/lib/index.js

@@ -45,8 +45,17 @@ var listGroups = grMod.listGroups, createGroup = grMod.createGroup,
   describeModelRoute = grMod.describeModelRoute;
 var keywordClassify = kwMod.keywordClassify;
 
+// ── v2.0.0 MCP 管理子模块（同样走 RELOAD_V 热加载） ──
+var mcpMod = await import("./mcp.js" + RELOAD_V);
+var collectMcp = mcpMod.collectMcp, setMcpEnabled = mcpMod.setMcpEnabled,
+  reconnectMcp = mcpMod.reconnectMcp, recordMcpCall = mcpMod.recordMcpCall,
+  getMcpStats = mcpMod.getMcpStats, clearMcpStats = mcpMod.clearMcpStats,
+  exportMcp = mcpMod.exportMcp,
+  detectMcpResidue = mcpMod.detectMcpResidue, cleanMcpResidue = mcpMod.cleanMcpResidue,
+  scanLocalMcp = mcpMod.scanLocalMcp, mcpAiDiagnose = mcpMod.mcpAiDiagnose, mcpAiFixApply = mcpMod.mcpAiFixApply;
+
 var PREFIX = "/dsh-skill-browser";
-export var VERSION = "1.9.10";
+export var VERSION = "2.0.0";
 var CACHE_TTL_MS = 30 * 1000;
 var DIAG_FILE = join(homedir(), ".dsh", "data", "dsh-skill-browser", "diag.log");
 var CONFIG_FILE = join(homedir(), ".dsh", "data", "dsh-skill-browser", "config.json");
@@ -278,6 +287,34 @@ export function createApi(ctx, config) {
     ctx.logger.warn("dsh-skill-browser: tools/result listener failed: " + (e && e.message));
   }
 
+  // ── v2.0.0 MCP 调用统计：官方 tools/result 事件，按 mcp__<server>__ 前缀归类 ──
+  var offMcp = null;
+  try {
+    offMcp = ctx.on("tools/result", function (exec, result) {
+      try {
+        var nm = exec && exec.name;
+        if (typeof nm !== "string" || nm.indexOf("mcp__") !== 0) return;
+        var seg = nm.split("__");
+        var server = seg.length >= 3 && seg[1] ? seg[1] : "(unknown)";
+        var ok = !(result && result.isError);
+        var err = "";
+        if (!ok && result) {
+          if (result.error && typeof result.error === "string") err = result.error;
+          else if (Array.isArray(result.content)) {
+            for (var ii = 0; ii < result.content.length; ii++) {
+              var blk = result.content[ii];
+              if (blk && typeof blk.text === "string") { err = blk.text; break; }
+            }
+          }
+        }
+        recordMcpCall(server, nm, ok, err, 0);
+      } catch (e2) { /* 统计失败绝不影响工具调用本身 */ }
+    });
+    ctx.logger.info("dsh-skill-browser: mcp call recorder armed (tools/result)");
+  } catch (e) {
+    ctx.logger.warn("dsh-skill-browser: mcp stats listener failed: " + (e && e.message));
+  }
+
   function buildPayload() {
     var skills = scanSkills(root, ZH);
     // Per-category counts, emitted in CATS order so the client renders a
@@ -603,6 +640,11 @@ function getLedgerPayload(force) {
           }
           return;
         }
+        if (action === "clear-classify-cache") {
+          var ccRes = grMod.clearClassifyCache ? grMod.clearClassifyCache() : { ok: false, error: "groups 模块不支持清缓存" };
+          sendJson(res, ccRes.ok ? 200 : 500, ccRes);
+          return;
+        }
         if (action === "ai-classify") {
           var skills = scanSkills(root, ZH);
           if (!skills.length) { sendJson(res, 400, { ok: false, error: "技能库为空或未找到技能" }); return; }
@@ -900,11 +942,108 @@ function getLedgerPayload(force) {
         return;
       }
 
+      // ── v2.0.0 MCP 管理：列表 / 状态 / 工具清单 / 统计 / 启停 / 重连 / 导出 ──
+      function readMcpBody(cb) {
+        var chunks = [];
+        req.on("data", function (c) { chunks.push(c); });
+        req.on("end", function () {
+          var obj = {};
+          try { obj = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"); } catch (e) { obj = {}; }
+          cb(obj);
+        });
+      }
+      if (path === PREFIX + "/mcp/local-scan") {
+        try { sendJson(res, 200, scanLocalMcp(ctx)); }
+        catch (e) { sendJson(res, 500, { ok: false, error: String((e && e.message) || e) }); }
+        return;
+      }
+      if (path === PREFIX + "/mcp/ai-diagnose") {
+        mcpAiDiagnose(ctx).then(function (r) { sendJson(res, r && r.ok ? 200 : 500, r); })
+          .catch(function (e) { sendJson(res, 500, { ok: false, error: String((e && e.message) || e) }); });
+        return;
+      }
+      if (path === PREFIX + "/mcp/ai-fix/apply" && req.method === "POST") {
+        readBody(req, function (body) {
+          mcpAiFixApply(ctx, (body && body.actions) || []).then(function (r) { sendJson(res, 200, r); })
+            .catch(function (e) { sendJson(res, 500, { ok: false, error: String((e && e.message) || e) }); });
+        });
+        return;
+      }
+      if (path === PREFIX + "/mcp/servers") {
+        try { sendJson(res, 200, collectMcp(ctx, /(^|&)(refresh=1|t=)/.test(query))); }
+        catch (e) {
+          ctx.logger.warn("dsh-skill-browser: mcp list failed " + (e && e.message));
+          sendJson(res, 500, { ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+      if (path === PREFIX + "/mcp/stats") {
+        try { sendJson(res, 200, getMcpStats({ since: qp(query, "since") })); }
+        catch (e) {
+          ctx.logger.warn("dsh-skill-browser: mcp stats failed " + (e && e.message));
+          sendJson(res, 500, { ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+      if (path === PREFIX + "/mcp/stats/clear" && req.method === "POST") {
+        try { sendJson(res, 200, clearMcpStats()); }
+        catch (e) { sendJson(res, 500, { ok: false, error: String((e && e.message) || e) }); }
+        return;
+      }
+      if (path === PREFIX + "/mcp/export") {
+        try { sendJson(res, 200, exportMcp(ctx, { mask: /(^|&)mask=1(&|$)/.test(query) })); }
+        catch (e) {
+          ctx.logger.warn("dsh-skill-browser: mcp export failed " + (e && e.message));
+          sendJson(res, 500, { ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+      if (path === PREFIX + "/mcp/residue") {
+        try { sendJson(res, 200, detectMcpResidue(ctx)); }
+        catch (e) {
+          ctx.logger.warn("dsh-skill-browser: mcp residue detect failed " + (e && e.message));
+          sendJson(res, 500, { ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+      if (path === PREFIX + "/mcp/residue/clean" && req.method === "POST") {
+        try {
+          var cres = cleanMcpResidue(ctx);
+          ctx.logger.info("dsh-skill-browser: mcp residue cleaned=" + cres.cleaned);
+          sendJson(res, 200, cres);
+        } catch (e) {
+          ctx.logger.warn("dsh-skill-browser: mcp residue clean failed " + (e && e.message));
+          sendJson(res, 500, { ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+      if ((path === PREFIX + "/mcp/enable" || path === PREFIX + "/mcp/disable") && req.method === "POST") {
+        var wantEnable = path.indexOf("/mcp/enable") >= 0;
+        readMcpBody(function (body) {
+          var r;
+          try { r = setMcpEnabled(ctx, String(body.id || ""), wantEnable); }
+          catch (e) { r = { ok: false, error: String((e && e.message) || e) }; }
+          sendJson(res, r.ok ? 200 : 500, r);
+        });
+        return;
+      }
+      if (path === PREFIX + "/mcp/reconnect" && req.method === "POST") {
+        readMcpBody(function (body) {
+          Promise.resolve(reconnectMcp(ctx, String(body.id || ""))).then(function (r) {
+            sendJson(res, r && r.ok ? 200 : 500, r);
+          }).catch(function (e) { sendJson(res, 500, { ok: false, error: String((e && e.message) || e) }); });
+        });
+        return;
+      }
+
       sendJson(res, 404, { ok: false, error: "unknown path" });
     };
 
     return {
       handler: handler,
-      dispose: function () { try { if (offTools) offTools(); } catch (e) {} }
+      dispose: function () {
+        try { if (offTools) offTools(); } catch (e) {}
+        try { if (offMcp) offMcp(); } catch (e) {}
+      }
     };
   }