jinzd-ai-cli 0.4.217 → 0.4.219

package/dist/electron-server.js

@@ -38,7 +38,7 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-QAYOI57M.js";
+} from "./chunk-EGMORH5W.js";
 import {
   hasSemanticIndex,
   semanticSearch
@@ -64,8 +64,8 @@ import {
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
-import { join as join22, dirname as dirname7, resolve as resolve10, relative as relative4, sep as sep3 } from "path";
-import { existsSync as existsSync27, readFileSync as readFileSync21, readdirSync as readdirSync13, statSync as statSync9, realpathSync } from "fs";
+import { join as join25, dirname as dirname8, resolve as resolve11, relative as relative4, sep as sep3 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync23, readdirSync as readdirSync15, statSync as statSync12, realpathSync } from "fs";
 import { networkInterfaces } from "os";
 
 // src/config/config-manager.ts
@@ -1847,12 +1847,12 @@ function findPhantomClaims(content, extraMessages) {
   const claimed = extractClaimedFilePaths(content);
   if (claimed.length === 0) return [];
   const normalize = (p) => p.replace(/\\/g, "/").toLowerCase().replace(/^\.\//, "");
-  const basename6 = (p) => {
+  const basename7 = (p) => {
     const parts = normalize(p).split("/");
     return parts[parts.length - 1] ?? "";
   };
   const written = extractWrittenFilePaths(extraMessages).map(normalize);
-  const writtenBases = new Set(written.map(basename6));
+  const writtenBases = new Set(written.map(basename7));
   const writtenFull = new Set(written);
   const bashText = extractBashCommands(extraMessages).map((c) => c.replace(/\\/g, "/").toLowerCase()).join("\n");
   return claimed.filter((raw) => {
@@ -1861,8 +1861,8 @@ function findPhantomClaims(content, extraMessages) {
     for (const w of writtenFull) {
       if (w.endsWith("/" + norm2) || norm2.endsWith("/" + w)) return false;
     }
-    if (writtenBases.has(basename6(norm2))) return false;
-    const base = basename6(norm2);
+    if (writtenBases.has(basename7(norm2))) return false;
+    const base = basename7(norm2);
     if (base && bashText.includes(base)) return false;
     return true;
   });
@@ -6629,6 +6629,21 @@ function flush() {
   } catch {
   }
 }
+function getStatsSnapshot() {
+  const s = ensureLoaded();
+  return Object.values(s.entries).map((e) => ({ ...e }));
+}
+function getTopFailingTools(limit = 5) {
+  return getStatsSnapshot().filter((e) => e.failures > 0).sort((a, b) => {
+    const rateA = a.failures / Math.max(1, a.calls);
+    const rateB = b.failures / Math.max(1, b.calls);
+    if (rateB !== rateA) return rateB - rateA;
+    return b.failures - a.failures;
+  }).slice(0, limit);
+}
+function getTopUsedTools(limit = 5) {
+  return getStatsSnapshot().sort((a, b) => b.calls - a.calls).slice(0, limit);
+}
 
 // src/tools/action-classifier.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
@@ -7182,7 +7197,7 @@ var ToolExecutor = class {
     rl.resume();
     process.stdout.write(prompt);
     this.confirming = true;
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       let completed = false;
       const cleanup = (result) => {
         if (completed) return;
@@ -7192,7 +7207,7 @@ var ToolExecutor = class {
         rl.pause();
         rlAny.output = savedOutput;
         this.confirming = false;
-        resolve11(result);
+        resolve12(result);
       };
       const onLine = (line) => {
         const trimmed = line.trim();
@@ -7366,7 +7381,7 @@ var ToolExecutor = class {
     rl.resume();
     process.stdout.write(color("Proceed? [y/N] (type y + Enter to confirm) "));
     this.confirming = true;
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       let completed = false;
       const cleanup = (answer) => {
         if (completed) return;
@@ -7376,7 +7391,7 @@ var ToolExecutor = class {
         rl.pause();
         rlAny.output = savedOutput;
         this.confirming = false;
-        resolve11(answer === "y");
+        resolve12(answer === "y");
       };
       const onLine = (line) => {
         const trimmed = line.trim();
@@ -8625,7 +8640,7 @@ var runInteractiveTool = {
       PYTHONDONTWRITEBYTECODE: "1"
     };
     const prefixWarnings = [argsTypeWarning, stdinTypeWarning].filter(Boolean).join("");
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const child = spawn2(executable, cmdArgs.map(String), {
         cwd: process.cwd(),
         env,
@@ -8658,22 +8673,22 @@ var runInteractiveTool = {
       setTimeout(writeNextLine, 400);
       const timer = setTimeout(() => {
         child.kill();
-        resolve11(`${prefixWarnings}[Timeout after ${timeout}ms]
+        resolve12(`${prefixWarnings}[Timeout after ${timeout}ms]
 ${buildOutput(stdout, stderr)}`);
       }, timeout);
       child.on("close", (code) => {
         clearTimeout(timer);
         const output = buildOutput(stdout, stderr);
         if (code !== 0 && code !== null) {
-          resolve11(`${prefixWarnings}Exit code ${code}:
+          resolve12(`${prefixWarnings}Exit code ${code}:
 ${output}`);
         } else {
-          resolve11(`${prefixWarnings}${output || "(no output)"}`);
+          resolve12(`${prefixWarnings}${output || "(no output)"}`);
         }
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        resolve11(
+        resolve12(
           `${prefixWarnings}Failed to start process "${executable}": ${err.message}
 Hint: On Windows, use the full path to the executable, e.g.:
   C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe`
@@ -9723,7 +9738,7 @@ function promptUser(rl, question) {
   console.log();
   console.log(chalk4.cyan("\u2753 ") + chalk4.bold(question));
   process.stdout.write(chalk4.cyan("> "));
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let completed = false;
     const cleanup = (answer) => {
       if (completed) return;
@@ -9733,7 +9748,7 @@ function promptUser(rl, question) {
       rl.pause();
       rlAny.output = savedOutput;
       askUserContext.prompting = false;
-      resolve11(answer);
+      resolve12(answer);
     };
     const onLine = (line) => {
       cleanup(line);
@@ -9965,9 +9980,292 @@ function formatResults2(query, data, _requested) {
 }
 
 // src/agents/agent-config.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync8, readFileSync as readFileSync13 } from "fs";
+import { join as join13 } from "path";
 import { homedir as homedir6 } from "os";
+
+// src/plugins/plugin-manager.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readdirSync as readdirSync7, readFileSync as readFileSync12, cpSync, rmSync, statSync as statSync6 } from "fs";
+import { basename as basename5, dirname as dirname6, join as join12, resolve as resolve7 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { z as z2 } from "zod";
+var MANIFEST_RELATIVE = ".aicli-plugin/plugin.json";
+var STATE_FILE = "plugin-state.json";
+var HookCommandSchema = z2.union([
+  z2.string(),
+  z2.object({
+    command: z2.string(),
+    source: z2.enum(["user", "project", "managed"]).optional(),
+    description: z2.string().optional(),
+    required: z2.boolean().optional(),
+    timeoutMs: z2.number().int().min(100).max(3e4).optional(),
+    disabled: z2.boolean().optional()
+  }),
+  z2.array(z2.union([
+    z2.string(),
+    z2.object({
+      command: z2.string(),
+      source: z2.enum(["user", "project", "managed"]).optional(),
+      description: z2.string().optional(),
+      required: z2.boolean().optional(),
+      timeoutMs: z2.number().int().min(100).max(3e4).optional(),
+      disabled: z2.boolean().optional()
+    })
+  ]))
+]);
+var HookEventNameSchema = z2.enum([
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PreCompact",
+  "PostCompact",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop"
+]);
+var McpServerSchema = z2.object({
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string()).optional(),
+  timeout: z2.number().default(3e4)
+});
+var PluginManifestSchema = z2.object({
+  name: z2.string().regex(/^[a-zA-Z0-9._-]{1,80}$/),
+  version: z2.string().min(1),
+  description: z2.string().optional(),
+  skills: z2.array(z2.string()).default([]),
+  hooks: z2.object({
+    enabled: z2.boolean().optional(),
+    events: z2.record(HookEventNameSchema, HookCommandSchema).default({})
+  }).default({ events: {} }),
+  commands: z2.array(z2.string()).default([]),
+  mcpServers: z2.record(McpServerSchema).default({}),
+  agents: z2.array(z2.string()).default([]),
+  permissionHints: z2.array(z2.string()).default([])
+}).strict();
+function pluginRoot(configDir) {
+  return join12(configDir, PLUGINS_DIR_NAME);
+}
+function pluginManifestPath(pluginDir) {
+  return join12(pluginDir, MANIFEST_RELATIVE);
+}
+function statePath(configDir) {
+  return join12(pluginRoot(configDir), STATE_FILE);
+}
+function loadState(configDir) {
+  const file = statePath(configDir);
+  if (!existsSync16(file)) return { version: 1, plugins: [] };
+  try {
+    const parsed = JSON.parse(readFileSync12(file, "utf-8"));
+    return { version: 1, plugins: Array.isArray(parsed.plugins) ? parsed.plugins : [] };
+  } catch {
+    return { version: 1, plugins: [] };
+  }
+}
+function saveState(configDir, state2) {
+  mkdirSync8(pluginRoot(configDir), { recursive: true });
+  atomicWriteFileSync(statePath(configDir), JSON.stringify(state2, null, 2));
+}
+function hashPluginManifest(manifestPath) {
+  return createHash3("sha256").update(readFileSync12(manifestPath)).digest("hex");
+}
+function readPluginManifest(manifestPath) {
+  return PluginManifestSchema.parse(JSON.parse(readFileSync12(manifestPath, "utf-8")));
+}
+function findPluginSourceDir(inputPath) {
+  const abs = resolve7(inputPath);
+  const direct = statSync6(abs).isDirectory() ? abs : dirname6(abs);
+  if (existsSync16(pluginManifestPath(direct))) return direct;
+  const nested = join12(direct, ".aicli-plugin");
+  if (existsSync16(join12(nested, "plugin.json"))) return direct;
+  throw new Error(`plugin manifest not found: ${MANIFEST_RELATIVE}`);
+}
+function installPlugin(configDir, inputPath) {
+  const sourceDir = findPluginSourceDir(inputPath);
+  const manifest = readPluginManifest(pluginManifestPath(sourceDir));
+  const targetDir = join12(pluginRoot(configDir), manifest.name);
+  mkdirSync8(pluginRoot(configDir), { recursive: true });
+  if (existsSync16(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+  cpSync(sourceDir, targetDir, { recursive: true });
+  const manifestPath = pluginManifestPath(targetDir);
+  const hash = hashPluginManifest(manifestPath);
+  const state2 = loadState(configDir);
+  const previous = state2.plugins.find((p) => p.name === manifest.name);
+  const next = {
+    name: manifest.name,
+    enabled: previous?.enabled ?? false,
+    trusted: false,
+    hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== manifest.name), next];
+  saveState(configDir, state2);
+  return { name: manifest.name, dir: targetDir, manifestPath, manifest, hash, enabled: next.enabled, trusted: false, valid: true };
+}
+function setPluginEnabled(configDir, name, enabled) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state2 = loadState(configDir);
+  const current = state2.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, enabled, hash: plugin.hash, enabledAt: enabled ? (/* @__PURE__ */ new Date()).toISOString() : current.enabledAt };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state2);
+  return next;
+}
+function trustPlugin(configDir, name) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state2 = loadState(configDir);
+  const current = state2.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, trusted: true, hash: plugin.hash, trustedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  state2.plugins = [...state2.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state2);
+  return next;
+}
+function getInstalledPlugin(configDir, name) {
+  const plugins = listInstalledPlugins(configDir);
+  const matches = plugins.filter((p) => p.name === name || p.name.startsWith(name));
+  if (matches.length === 0) throw new Error(`plugin not found: ${name}`);
+  if (matches.length > 1) throw new Error(`plugin name is ambiguous: ${name}`);
+  return matches[0];
+}
+function listInstalledPlugins(configDir) {
+  const root = pluginRoot(configDir);
+  if (!existsSync16(root)) return [];
+  const state2 = loadState(configDir);
+  const out = [];
+  for (const entry of readdirSync7(root)) {
+    const dir = join12(root, entry);
+    try {
+      if (!statSync6(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const manifestPath = pluginManifestPath(dir);
+    if (!existsSync16(manifestPath)) continue;
+    try {
+      const manifest = readPluginManifest(manifestPath);
+      const hash = hashPluginManifest(manifestPath);
+      const st = state2.plugins.find((p) => p.name === manifest.name);
+      const trusted = st?.trusted === true && st.hash === hash;
+      out.push({
+        name: manifest.name,
+        dir,
+        manifestPath,
+        manifest,
+        hash,
+        enabled: st?.enabled === true,
+        trusted,
+        valid: true
+      });
+    } catch (err) {
+      out.push({
+        name: entry,
+        dir,
+        manifestPath,
+        manifest: { name: entry, version: "invalid", skills: [], commands: [], agents: [], hooks: { events: {} }, mcpServers: {}, permissionHints: [] },
+        hash: "",
+        enabled: false,
+        trusted: false,
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function activePlugins(configDir) {
+  return listInstalledPlugins(configDir).filter((p) => p.valid && p.enabled && p.trusted);
+}
+function uniqueDirs(plugin, rels) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const rel of rels) {
+    const abs = resolve7(plugin.dir, rel);
+    if (!abs.startsWith(resolve7(plugin.dir))) continue;
+    if (existsSync16(abs)) dirs.add(statSync6(abs).isDirectory() ? abs : dirname6(abs));
+  }
+  return [...dirs];
+}
+function prefixCommand(plugin, command) {
+  return command.replaceAll("{pluginDir}", plugin.dir).replaceAll("$PLUGIN_DIR", plugin.dir);
+}
+function pluginHooks(plugin) {
+  const events = plugin.manifest.hooks?.events ?? {};
+  const out = {};
+  for (const [event, raw] of Object.entries(events)) {
+    const normalize = (item) => {
+      if (typeof item === "string") return { command: prefixCommand(plugin, item), source: "project", description: `plugin:${plugin.name}` };
+      if (item && typeof item === "object") {
+        const obj = item;
+        return { ...obj, command: prefixCommand(plugin, String(obj.command ?? "")), source: "project", description: obj.description ?? `plugin:${plugin.name}` };
+      }
+      return item;
+    };
+    out[event] = Array.isArray(raw) ? raw.map(normalize) : normalize(raw);
+  }
+  return Object.keys(out).length > 0 ? { enabled: plugin.manifest.hooks?.enabled ?? true, events: out } : void 0;
+}
+function mergePluginHooks(base, configDir) {
+  const plugins = activePlugins(configDir);
+  if (plugins.length === 0) return base;
+  const merged = { ...base ?? {}, enabled: base?.enabled ?? true, events: { ...base?.events ?? {} } };
+  for (const plugin of plugins) {
+    const hooks = pluginHooks(plugin);
+    if (!hooks?.events) continue;
+    for (const [event, entry] of Object.entries(hooks.events)) {
+      const key = event;
+      const existing = merged.events?.[key];
+      const existingItems = existing === void 0 ? [] : Array.isArray(existing) ? existing : [existing];
+      const newItems = Array.isArray(entry) ? entry : [entry];
+      merged.events[key] = [...existingItems, ...newItems];
+    }
+  }
+  return merged;
+}
+function getActivePluginAssets(configDir) {
+  const plugins = activePlugins(configDir);
+  const mcpServers = {};
+  const skillDirs = [];
+  const commandDirs = [];
+  const agentDirs = [];
+  for (const plugin of plugins) {
+    skillDirs.push(...uniqueDirs(plugin, plugin.manifest.skills));
+    commandDirs.push(...uniqueDirs(plugin, plugin.manifest.commands));
+    agentDirs.push(...uniqueDirs(plugin, plugin.manifest.agents));
+    for (const [serverName, server] of Object.entries(plugin.manifest.mcpServers)) {
+      mcpServers[`plugin_${plugin.name}_${serverName}`] = server;
+    }
+  }
+  return { plugins, skillDirs, commandDirs, agentDirs, hooks: mergePluginHooks(void 0, configDir), mcpServers };
+}
+function describePlugin(plugin) {
+  const m = plugin.manifest;
+  return [
+    `${plugin.name}@${m.version}`,
+    `  status: ${plugin.enabled ? "enabled" : "disabled"} \xB7 ${plugin.trusted ? "trusted" : "untrusted"}${plugin.valid ? "" : " \xB7 invalid"}`,
+    `  dir: ${plugin.dir}`,
+    m.description ? `  description: ${m.description}` : void 0,
+    `  assets: ${m.skills.length} skill(s), ${m.commands.length} command(s), ${m.agents.length} agent(s), ${Object.keys(m.mcpServers).length} MCP server(s), ${Object.keys(m.hooks?.events ?? {}).length} hook event(s)`,
+    m.permissionHints.length ? `  permission hints: ${m.permissionHints.join("; ")}` : void 0,
+    plugin.error ? `  error: ${plugin.error}` : void 0
+  ].filter((line) => Boolean(line));
+}
+
+// src/agents/agent-config.ts
 var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
   "read_file",
   "list_dir",
@@ -10061,13 +10359,13 @@ function parseAgentConfig(raw, source, path3) {
   return cfg;
 }
 function loadAgentDir(dir, source) {
-  if (!existsSync16(dir)) return [];
+  if (!existsSync17(dir)) return [];
   const out = [];
-  for (const file of readdirSync7(dir)) {
+  for (const file of readdirSync8(dir)) {
     if (!file.endsWith(".json")) continue;
-    const path3 = join12(dir, file);
+    const path3 = join13(dir, file);
     try {
-      const parsed = JSON.parse(readFileSync12(path3, "utf-8"));
+      const parsed = JSON.parse(readFileSync13(path3, "utf-8"));
       const cfg = parseAgentConfig(parsed, source, path3);
       if (cfg) out.push(cfg);
     } catch {
@@ -10077,8 +10375,8 @@ function loadAgentDir(dir, source) {
 }
 function getAgentDirs(configDir, cwd = process.cwd()) {
   return {
-    user: join12(configDir ?? join12(homedir6(), CONFIG_DIR_NAME), "agents"),
-    project: join12(cwd, CONFIG_DIR_NAME, "agents")
+    user: join13(configDir ?? join13(homedir6(), CONFIG_DIR_NAME), "agents"),
+    project: join13(cwd, CONFIG_DIR_NAME, "agents")
   };
 }
 function listAgentConfigs(configDir, cwd = process.cwd()) {
@@ -10086,6 +10384,11 @@ function listAgentConfigs(configDir, cwd = process.cwd()) {
   const byName = /* @__PURE__ */ new Map();
   for (const cfg of BUILTIN_AGENTS) byName.set(normalizeName(cfg.name), { ...cfg });
   for (const cfg of loadAgentDir(dirs.user, "user")) byName.set(normalizeName(cfg.name), cfg);
+  if (configDir) {
+    for (const dir of getActivePluginAssets(configDir).agentDirs) {
+      for (const cfg of loadAgentDir(dir, "plugin")) byName.set(normalizeName(cfg.name), cfg);
+    }
+  }
   for (const cfg of loadAgentDir(dirs.project, "project")) byName.set(normalizeName(cfg.name), cfg);
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -10788,14 +11091,14 @@ var taskStopTool = {
 
 // src/tools/builtin/git-tools.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync17 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join14 } from "path";
 function assertGitRepo(cwd) {
   let dir = cwd;
   const root = dir.split(/[\\/]/)[0] + (dir.includes("\\") ? "\\" : "/");
   while (dir && dir !== root) {
-    if (existsSync17(join13(dir, ".git"))) return;
-    const parent = join13(dir, "..");
+    if (existsSync18(join14(dir, ".git"))) return;
+    const parent = join14(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -11060,9 +11363,9 @@ ${commitOutput.trim()}`;
 };
 
 // src/tools/builtin/notebook-edit.ts
-import { readFileSync as readFileSync13, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync19 } from "fs";
 import { writeFile } from "fs/promises";
-import { resolve as resolve7, extname as extname2 } from "path";
+import { resolve as resolve8, extname as extname2 } from "path";
 var notebookEditTool = {
   definition: {
     name: "notebook_edit",
@@ -11111,14 +11414,14 @@ var notebookEditTool = {
     if (!Number.isInteger(cellIndexRaw) || cellIndexRaw < 1) {
       throw new ToolError("notebook_edit", "cell_index must be a positive integer (1-based)");
     }
-    const absPath = resolve7(filePath);
+    const absPath = resolve8(filePath);
     if (extname2(absPath).toLowerCase() !== ".ipynb") {
       throw new ToolError("notebook_edit", "path must point to a .ipynb file");
     }
-    if (!existsSync18(absPath)) {
+    if (!existsSync19(absPath)) {
       throw new ToolError("notebook_edit", `Notebook not found: ${filePath}`);
     }
-    const raw = readFileSync13(absPath, "utf-8");
+    const raw = readFileSync14(absPath, "utf-8");
     const nb = parseNotebook(raw);
     const cellIdx0 = cellIndexRaw - 1;
     undoStack.push(absPath, `notebook_edit (${action}): ${filePath}`);
@@ -11535,8 +11838,8 @@ function estimateToolDefinitionTokens(def) {
 
 // src/tools/registry.ts
 import { pathToFileURL } from "url";
-import { existsSync as existsSync19, mkdirSync as mkdirSync8, readdirSync as readdirSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "fs";
+import { join as join15 } from "path";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   pluginToolNames = /* @__PURE__ */ new Set();
@@ -11697,16 +12000,16 @@ var ToolRegistry = class {
    * Returns the number of successfully loaded plugins.
    */
   async loadPlugins(pluginsDir, allowPlugins = false) {
-    if (!existsSync19(pluginsDir)) {
+    if (!existsSync20(pluginsDir)) {
       try {
-        mkdirSync8(pluginsDir, { recursive: true });
+        mkdirSync9(pluginsDir, { recursive: true });
       } catch {
       }
       return 0;
     }
     let files;
     try {
-      files = readdirSync8(pluginsDir).filter((f) => f.endsWith(".js"));
+      files = readdirSync9(pluginsDir).filter((f) => f.endsWith(".js"));
     } catch {
       return 0;
     }
@@ -11723,12 +12026,12 @@ var ToolRegistry = class {
     process.stderr.write(
       `
 [plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
-` + files.map((f) => `  + ${join14(pluginsDir, f)}`).join("\n") + "\n\n"
+` + files.map((f) => `  + ${join15(pluginsDir, f)}`).join("\n") + "\n\n"
     );
     let loaded = 0;
     for (const file of files) {
       try {
-        const fileUrl = pathToFileURL(join14(pluginsDir, file)).href;
+        const fileUrl = pathToFileURL(join15(pluginsDir, file)).href;
         const mod = await import(fileUrl);
         const tool = mod.tool ?? mod.default?.tool ?? mod.default;
         if (!tool || typeof tool.execute !== "function" || !tool.definition?.name) {
@@ -11890,7 +12193,7 @@ var McpClient = class {
   // 内部方法：JSON-RPC 通信
   // ══════════════════════════════════════════════════════════════════
   sendRequest(method, params) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.process?.stdin?.writable) {
         return reject(new Error(`MCP server [${this.serverId}] stdin not writable`));
       }
@@ -11914,7 +12217,7 @@ var McpClient = class {
       this.pendingRequests.set(id, {
         resolve: (result) => {
           cleanup();
-          resolve11(result);
+          resolve12(result);
         },
         reject: (error) => {
           cleanup();
@@ -11991,13 +12294,13 @@ var McpClient = class {
   }
   /** Promise 超时包装 */
   withTimeout(promise, ms, label) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`MCP [${this.serverId}] ${label} timed out after ${ms}ms`));
       }, ms);
       promise.then((val) => {
         clearTimeout(timer);
-        resolve11(val);
+        resolve12(val);
       }).catch((err) => {
         clearTimeout(timer);
         reject(err);
@@ -12274,12 +12577,12 @@ var McpManager = class {
 };
 
 // src/skills/manager.ts
-import { existsSync as existsSync20, readdirSync as readdirSync9, mkdirSync as mkdirSync9, statSync as statSync6 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync10, mkdirSync as mkdirSync10, statSync as statSync7 } from "fs";
+import { join as join16 } from "path";
 
 // src/skills/types.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { basename as basename5 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { basename as basename6 } from "path";
 function parseSimpleYaml(yaml) {
   const result = {};
   for (const line of yaml.split("\n")) {
@@ -12300,7 +12603,7 @@ function parseYamlArray(value) {
 function parseSkillFile(filePath) {
   let raw;
   try {
-    raw = readFileSync14(filePath, "utf-8");
+    raw = readFileSync15(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -12308,7 +12611,7 @@ function parseSkillFile(filePath) {
   if (!frontmatterMatch) {
     return {
       meta: {
-        name: basename5(filePath, ".md"),
+        name: basename6(filePath, ".md"),
         description: ""
       },
       content: raw.trim(),
@@ -12319,7 +12622,7 @@ function parseSkillFile(filePath) {
   const parsed = parseSimpleYaml(yaml);
   return {
     meta: {
-      name: parsed["name"] ?? basename5(filePath, ".md"),
+      name: parsed["name"] ?? basename6(filePath, ".md"),
       description: parsed["description"] ?? "",
       tools: parsed["tools"] ? parseYamlArray(parsed["tools"]) : void 0
     },
@@ -12340,36 +12643,40 @@ var SkillManager = class {
     this.skillsDir = skillsDir;
     this.warnThreshold = warnThreshold ?? SKILL_CONTENT_WARN_CHARS_DEFAULT;
   }
-  /** 发现并加载 skillsDir 下所有 .md 文件，返回加载数量 */
-  loadSkills() {
+  /** 发现并加载 skillsDir 以及额外插件目录下的技能，返回加载数量 */
+  loadSkills(extraDirs = []) {
     this.skills.clear();
-    if (!existsSync20(this.skillsDir)) {
-      try {
-        mkdirSync9(this.skillsDir, { recursive: true });
-      } catch {
+    this.loadSkillDir(this.skillsDir, true);
+    for (const dir of extraDirs) this.loadSkillDir(dir, false);
+    return this.skills.size;
+  }
+  loadSkillDir(dir, createIfMissing) {
+    if (!existsSync21(dir)) {
+      if (createIfMissing) {
+        try {
+          mkdirSync10(dir, { recursive: true });
+        } catch {
+        }
       }
-      return 0;
+      return;
     }
     let entries;
     try {
-      entries = readdirSync9(this.skillsDir);
+      entries = readdirSync10(dir);
     } catch {
-      return 0;
+      return;
     }
     for (const entry of entries) {
       let filePath;
-      const fullPath = join15(this.skillsDir, entry);
+      const fullPath = join16(dir, entry);
       if (entry.endsWith(".md")) {
         filePath = fullPath;
       } else {
         try {
-          if (statSync6(fullPath).isDirectory()) {
-            const skillMd = join15(fullPath, "SKILL.md");
-            if (existsSync20(skillMd)) {
-              filePath = skillMd;
-            } else {
-              continue;
-            }
+          if (statSync7(fullPath).isDirectory()) {
+            const skillMd = join16(fullPath, "SKILL.md");
+            if (existsSync21(skillMd)) filePath = skillMd;
+            else continue;
           } else {
             continue;
           }
@@ -12379,13 +12686,10 @@ var SkillManager = class {
       }
       const skill = parseSkillFile(filePath);
       if (skill) {
-        if (skill.meta.name === "SKILL" && !entry.endsWith(".md")) {
-          skill.meta.name = entry;
-        }
-        this.skills.set(skill.meta.name, skill);
+        if (skill.meta.name === "SKILL" && !entry.endsWith(".md")) skill.meta.name = entry;
+        if (!this.skills.has(skill.meta.name)) this.skills.set(skill.meta.name, skill);
       }
     }
-    return this.skills.size;
   }
   /** 列出所有已加载的技能 */
   listSkills() {
@@ -12430,7 +12734,7 @@ var SkillManager = class {
 // src/web/tool-executor-web.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { tmpdir as tmpdir2 } from "os";
-import { existsSync as existsSync21, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
 var ToolExecutorWeb = class _ToolExecutorWeb {
   constructor(registry, ws) {
     this.registry = registry;
@@ -12500,33 +12804,33 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
   }
   /** Resolve a pending confirm from client response */
   resolveConfirm(requestId, approved) {
-    const resolve11 = this.pendingConfirms.get(requestId);
-    if (resolve11) {
+    const resolve12 = this.pendingConfirms.get(requestId);
+    if (resolve12) {
       this.clearPendingTimer(requestId);
       this.pendingConfirms.delete(requestId);
       this.confirming = false;
-      resolve11(approved);
+      resolve12(approved);
     }
   }
   /** Resolve a pending batch confirm from client response */
   resolveBatchConfirm(requestId, decision) {
-    const resolve11 = this.pendingBatchConfirms.get(requestId);
-    if (resolve11) {
+    const resolve12 = this.pendingBatchConfirms.get(requestId);
+    if (resolve12) {
       this.clearPendingTimer(requestId);
       this.pendingBatchConfirms.delete(requestId);
       this.confirming = false;
       if (decision === "all" || decision === "none") {
-        resolve11(decision);
+        resolve12(decision);
       } else {
-        resolve11(new Set(decision));
+        resolve12(new Set(decision));
       }
     }
   }
   /** Cancel all pending confirms (e.g., on disconnect) */
   cancelAll() {
-    for (const resolve11 of this.pendingConfirms.values()) resolve11(false);
+    for (const resolve12 of this.pendingConfirms.values()) resolve12(false);
     this.pendingConfirms.clear();
-    for (const resolve11 of this.pendingBatchConfirms.values()) resolve11("none");
+    for (const resolve12 of this.pendingBatchConfirms.values()) resolve12("none");
     this.pendingBatchConfirms.clear();
     this.confirming = false;
   }
@@ -12569,9 +12873,9 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
     if (call.name === "write_file") {
       const filePath = String(call.arguments["path"] ?? "");
       const newContent = String(call.arguments["content"] ?? "");
-      if (filePath && existsSync21(filePath)) {
+      if (filePath && existsSync22(filePath)) {
         try {
-          const old = readFileSync15(filePath, "utf-8");
+          const old = readFileSync16(filePath, "utf-8");
           return renderDiff(old, newContent, { filePath });
         } catch {
         }
@@ -12602,8 +12906,8 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
       diff: this.getDiffPreview(call)
     };
     this.send(msg);
-    return new Promise((resolve11) => {
-      this.pendingConfirms.set(requestId, resolve11);
+    return new Promise((resolve12) => {
+      this.pendingConfirms.set(requestId, resolve12);
       this.pendingTimers.set(requestId, setTimeout(() => {
         if (this.pendingConfirms.has(requestId)) {
           this.resolveConfirm(requestId, false);
@@ -12627,8 +12931,8 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
       files
     };
     this.send(msg);
-    return new Promise((resolve11) => {
-      this.pendingBatchConfirms.set(requestId, resolve11);
+    return new Promise((resolve12) => {
+      this.pendingBatchConfirms.set(requestId, resolve12);
       this.pendingTimers.set(requestId, setTimeout(() => {
         if (this.pendingBatchConfirms.has(requestId)) {
           this.resolveBatchConfirm(requestId, "none");
@@ -12874,16 +13178,16 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
 };
 
 // src/repl/dev-state.ts
-import { existsSync as existsSync22, readFileSync as readFileSync16, unlinkSync as unlinkSync4, mkdirSync as mkdirSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync17, unlinkSync as unlinkSync4, mkdirSync as mkdirSync11 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir7 } from "os";
 function getDevStatePath() {
-  return join16(homedir7(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
+  return join17(homedir7(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
 }
 function loadDevState() {
   const path3 = getDevStatePath();
-  if (!existsSync22(path3)) return null;
-  const content = readFileSync16(path3, "utf-8").trim();
+  if (!existsSync23(path3)) return null;
+  const content = readFileSync17(path3, "utf-8").trim();
   return content || null;
 }
 
@@ -13140,8 +13444,8 @@ function autoTrimSessionIfNeeded(session, sizeLimit = SESSION_SIZE_LIMIT) {
 }
 
 // src/core/context-files.ts
-import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
-import { join as join17, relative as relative3, resolve as resolve8 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync18 } from "fs";
+import { join as join18, relative as relative3, resolve as resolve9 } from "path";
 function uniqueNonEmpty(values) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -13164,14 +13468,14 @@ function displayPath(filePath, cwd) {
   return filePath;
 }
 function isInsideOrEqual(parent, child) {
-  const rel = relative3(resolve8(parent), resolve8(child));
+  const rel = relative3(resolve9(parent), resolve9(child));
   return rel === "" || !!rel && !rel.startsWith("..") && !rel.startsWith("/") && !rel.startsWith("\\");
 }
 function readContextFile(level, filePath, cwd, maxBytes) {
   const name = filePath.split(/[\\/]/).pop() ?? filePath;
   const shown = displayPath(filePath, cwd);
   try {
-    const raw = readFileSync17(filePath);
+    const raw = readFileSync18(filePath);
     const byteCount = raw.byteLength;
     if (byteCount === 0) {
       return {
@@ -13218,8 +13522,8 @@ function readContextFile(level, filePath, cwd, maxBytes) {
 function findFirstContextFile(level, dir, cwd, candidates, maxBytes) {
   const skipped = [];
   for (const candidate of candidates) {
-    const filePath = join17(dir, candidate);
-    if (!existsSync23(filePath)) continue;
+    const filePath = join18(dir, candidate);
+    if (!existsSync24(filePath)) continue;
     const result = readContextFile(level, filePath, cwd, maxBytes);
     if (result.skipped) skipped.push(result.skipped);
     if (result.layer) return { layer: result.layer, skipped };
@@ -13227,7 +13531,7 @@ function findFirstContextFile(level, dir, cwd, candidates, maxBytes) {
   return { layer: null, skipped };
 }
 function loadContextFiles(options) {
-  const cwd = resolve8(options.cwd);
+  const cwd = resolve9(options.cwd);
   const maxBytes = options.maxBytes ?? CONTEXT_FILE_MAX_BYTES;
   const candidates = options.candidates ?? buildContextFileCandidates(options.fallbackFilenames);
   const skipped = [];
@@ -13235,7 +13539,7 @@ function loadContextFiles(options) {
     return { layers: [], mergedContent: "", skipped, totalChars: 0, totalBytes: 0, maxBytes, candidates };
   }
   if (options.setting && options.setting !== "auto") {
-    const filePath = resolve8(cwd, String(options.setting));
+    const filePath = resolve9(cwd, String(options.setting));
     if (!isInsideOrEqual(cwd, filePath)) {
       skipped.push({
         level: "single",
@@ -13246,7 +13550,7 @@ function loadContextFiles(options) {
       });
       return { layers: [], mergedContent: "", skipped, totalChars: 0, totalBytes: 0, maxBytes, candidates };
     }
-    if (!existsSync23(filePath)) {
+    if (!existsSync24(filePath)) {
       skipped.push({
         level: "single",
         filePath,
@@ -13279,7 +13583,7 @@ function loadContextFiles(options) {
     skipped.push(...result.skipped);
     if (result.layer) layers.push(result.layer);
   }
-  if (resolve8(options.cwd) !== resolve8(options.projectRoot)) {
+  if (resolve9(options.cwd) !== resolve9(options.projectRoot)) {
     const result = findFirstContextFile("local", options.cwd, cwd, candidates, maxBytes);
     skipped.push(...result.skipped);
     if (result.layer) layers.push(result.layer);
@@ -13297,8 +13601,8 @@ function loadContextFiles(options) {
 }
 
 // src/web/session-handler.ts
-import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync2, mkdirSync as mkdirSync11, readdirSync as readdirSync11, statSync as statSync8, createWriteStream } from "fs";
-import { join as join20, resolve as resolve9, dirname as dirname6 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync3, mkdirSync as mkdirSync13, readdirSync as readdirSync13, statSync as statSync11, createWriteStream } from "fs";
+import { join as join23, resolve as resolve10, dirname as dirname7 } from "path";
 
 // src/cli/review-prompts.ts
 function buildReviewPrompt(diff, gitContextStr, detailed) {
@@ -13359,8 +13663,8 @@ If no security issues found, state "\u2705 No security vulnerabilities detected"
 }
 
 // src/repl/commands/project-init.ts
-import { existsSync as existsSync24, readFileSync as readFileSync18, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync19, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
+import { join as join19 } from "path";
 var SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -13396,7 +13700,7 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     if (depth > maxDepth || count >= maxEntries) return;
     let entries;
     try {
-      entries = readdirSync10(d);
+      entries = readdirSync11(d);
     } catch {
       return;
     }
@@ -13404,11 +13708,11 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     const sorted = filtered.sort((a, b) => {
       let aIsDir = false, bIsDir = false;
       try {
-        aIsDir = statSync7(join18(d, a)).isDirectory();
+        aIsDir = statSync8(join19(d, a)).isDirectory();
       } catch {
       }
       try {
-        bIsDir = statSync7(join18(d, b)).isDirectory();
+        bIsDir = statSync8(join19(d, b)).isDirectory();
       } catch {
       }
       if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
@@ -13416,12 +13720,12 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     });
     for (let i = 0; i < sorted.length && count < maxEntries; i++) {
       const name = sorted[i];
-      const fullPath = join18(d, name);
+      const fullPath = join19(d, name);
       const isLast = i === sorted.length - 1;
       const connector = isLast ? "+-- " : "|-- ";
       let isDir;
       try {
-        isDir = statSync7(fullPath).isDirectory();
+        isDir = statSync8(fullPath).isDirectory();
       } catch {
         continue;
       }
@@ -13443,7 +13747,7 @@ function scanProject(cwd) {
     configFiles: [],
     directoryStructure: ""
   };
-  const check = (file) => existsSync24(join18(cwd, file));
+  const check = (file) => existsSync25(join19(cwd, file));
   const configCandidates = [
     "package.json",
     "tsconfig.json",
@@ -13470,7 +13774,7 @@ function scanProject(cwd) {
     info.type = "node";
     info.language = check("tsconfig.json") ? "TypeScript" : "JavaScript";
     try {
-      const pkg = JSON.parse(readFileSync18(join18(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync19(join19(cwd, "package.json"), "utf-8"));
       const scripts = pkg.scripts ?? {};
       info.buildCommand = scripts.build ? "npm run build" : void 0;
       info.testCommand = scripts.test ? "npm test" : void 0;
@@ -13943,6 +14247,334 @@ var DiscussionOrchestrator = class {
   }
 };
 
+// src/diagnostics/doctor-report.ts
+import { existsSync as existsSync27, statSync as statSync10 } from "fs";
+import { join as join21 } from "path";
+import { arch as arch2, platform as platform6, release as release2 } from "os";
+
+// src/diagnostics/crash-log.ts
+import {
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync20,
+  statSync as statSync9,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir8, platform as platform5, release, arch } from "os";
+var LOGS_DIR_NAME = "logs";
+var CRASH_LOG_PREFIX = "crash-";
+function getLogsDir(configDir) {
+  const base = configDir ?? join20(homedir8(), CONFIG_DIR_NAME);
+  return join20(base, LOGS_DIR_NAME);
+}
+function truncate(s, n) {
+  return s.length <= n ? s : s.slice(0, n) + "\u2026";
+}
+function listRecentCrashes(limit = 10, configDir) {
+  const dir = getLogsDir(configDir);
+  if (!existsSync26(dir)) return [];
+  const files = [];
+  let names;
+  try {
+    names = readdirSync12(dir);
+  } catch {
+    return [];
+  }
+  for (const name of names) {
+    if (!name.startsWith(CRASH_LOG_PREFIX) || !name.endsWith(".log")) continue;
+    const full = join20(dir, name);
+    try {
+      const st = statSync9(full);
+      const head = readFileSync20(full, "utf-8").split("\n").slice(0, 20);
+      const tsLine = head.find((l) => l.startsWith("timestamp:"));
+      const kindLine = head.find((l) => l.startsWith("kind:"));
+      const msgIdx = head.findIndex((l) => l.trim() === "## message");
+      const message = msgIdx >= 0 && head[msgIdx + 1] ? head[msgIdx + 1] : "";
+      files.push({
+        file: full,
+        timestamp: tsLine ? tsLine.replace("timestamp:", "").trim() : st.mtime.toISOString(),
+        kind: kindLine ? kindLine.replace("kind:", "").trim() : "unknown",
+        message: truncate(message, 200),
+        sizeBytes: st.size
+      });
+    } catch {
+    }
+  }
+  files.sort((a, b) => a.timestamp < b.timestamp ? 1 : -1);
+  return files.slice(0, limit);
+}
+function getConfigDirUsage(configDir) {
+  const base = configDir ?? join20(homedir8(), CONFIG_DIR_NAME);
+  if (!existsSync26(base)) return { totalBytes: 0, entries: [] };
+  const entries = [];
+  let total = 0;
+  let names;
+  try {
+    names = readdirSync12(base);
+  } catch {
+    return { totalBytes: 0, entries: [] };
+  }
+  for (const name of names) {
+    const full = join20(base, name);
+    const bytes = dirSize(full);
+    entries.push({ name, bytes });
+    total += bytes;
+  }
+  entries.sort((a, b) => b.bytes - a.bytes);
+  return { totalBytes: total, entries };
+}
+function dirSize(path3) {
+  try {
+    const st = statSync9(path3);
+    if (st.isFile()) return st.size;
+    if (!st.isDirectory()) return 0;
+    let sum = 0;
+    for (const name of readdirSync12(path3)) {
+      sum += dirSize(join20(path3, name));
+    }
+    return sum;
+  } catch {
+    return 0;
+  }
+}
+
+// src/diagnostics/doctor-report.ts
+function checkFile(label, path3) {
+  const exists = existsSync27(path3);
+  let sizeBytes = null;
+  if (exists) {
+    try {
+      sizeBytes = statSync10(path3).size;
+    } catch {
+    }
+  }
+  return { label, path: path3, exists, sizeBytes };
+}
+function buildDoctorReport(options) {
+  const config = options.config;
+  const cwd = options.cwd ?? process.cwd();
+  const configDir = config.getConfigDir();
+  const projectRoot = getGitRoot(cwd) ?? cwd;
+  const contextCfg = config.get("context");
+  const contextSetting = config.get("contextFile");
+  const context = loadContextFiles({
+    cwd,
+    configDir,
+    projectRoot,
+    setting: contextSetting,
+    maxBytes: contextCfg.projectDocMaxBytes,
+    fallbackFilenames: contextCfg.projectDocFallbackFilenames
+  });
+  const hooksConfig = config.get("hooks");
+  const hooks = listHooks(hooksConfig, configDir);
+  const pendingHooks = getPendingHookTrust(hooksConfig, configDir);
+  const plugins = listInstalledPlugins(configDir);
+  const activeAssets = getActivePluginAssets(configDir);
+  const network = config.get("networkPolicy");
+  const mcpServers = config.get("mcpServers");
+  const allStats = getStatsSnapshot();
+  return {
+    version: VERSION,
+    npmCheck: options.npmCheck,
+    node: process.version,
+    platform: `${platform6()} ${release2()} (${arch2()})`,
+    cwd,
+    projectRoot,
+    configDir,
+    providers: options.providers.listAll().map((p) => ({ id: p.id, displayName: p.displayName, configured: p.configured })),
+    files: [
+      checkFile("config.json", join21(configDir, "config.json")),
+      checkFile("memory.md", join21(configDir, MEMORY_FILE_NAME)),
+      checkFile("memory.jsonl", join21(configDir, "memory.jsonl")),
+      checkFile("dev-state.md", join21(configDir, DEV_STATE_FILE_NAME)),
+      checkFile("hooks-trust.json", join21(configDir, "hooks-trust.json")),
+      checkFile("plugin-state.json", join21(configDir, "plugins", "plugin-state.json"))
+    ],
+    context: {
+      enabled: contextSetting !== false,
+      setting: contextSetting,
+      candidates: context.candidates,
+      maxBytes: context.maxBytes,
+      layers: context.layers.map((l) => ({ level: l.level, fileName: l.fileName, displayPath: l.displayPath, bytes: l.byteCount, chars: l.charCount, truncated: l.truncated })),
+      skipped: context.skipped.map((s) => ({ level: s.level, fileName: s.fileName, displayPath: s.displayPath, reason: s.reason, message: s.message }))
+    },
+    permissions: {
+      defaultProfile: config.get("defaultPermissionProfile"),
+      allowedProfiles: config.get("allowedPermissionProfiles"),
+      customProfileCount: Object.keys(config.get("permissionProfiles")).length,
+      legacyDefaultAction: config.get("defaultPermission"),
+      ruleCount: config.get("permissionRules").length
+    },
+    networkPolicy: {
+      enabled: network.enabled,
+      defaultAction: network.defaultAction,
+      allowDomains: network.allowDomains.length,
+      denyDomains: network.denyDomains.length,
+      allowPorts: network.allowPorts.length,
+      denyPorts: network.denyPorts.length,
+      allowPrivateNetwork: network.allowPrivateNetwork,
+      toolOverrides: Object.fromEntries(Object.entries(network.tools).filter(([, v]) => v !== void 0))
+    },
+    hooks: {
+      enabled: hooksConfig?.enabled !== false,
+      total: hooks.length,
+      project: hooks.filter((h) => h.source === "project").length,
+      pendingTrust: pendingHooks.length,
+      disabled: hooks.filter((h) => h.disabled).length
+    },
+    plugins: {
+      root: join21(configDir, "plugins"),
+      installed: plugins.length,
+      active: activeAssets.plugins.length,
+      invalid: plugins.filter((p) => !p.valid).length,
+      untrusted: plugins.filter((p) => p.valid && !p.trusted).length,
+      disabled: plugins.filter((p) => p.valid && !p.enabled).length,
+      mcpServers: Object.keys(activeAssets.mcpServers).length,
+      skillDirs: activeAssets.skillDirs.length,
+      commandDirs: activeAssets.commandDirs.length,
+      agentDirs: activeAssets.agentDirs.length,
+      entries: plugins.map((p) => ({ name: p.name, version: p.manifest.version, enabled: p.enabled, trusted: p.trusted, valid: p.valid, error: p.error }))
+    },
+    mcp: {
+      enabled: config.get("mcpEnabled"),
+      configured: Object.keys(mcpServers).length,
+      projectConfigExists: existsSync27(join21(projectRoot, MCP_PROJECT_CONFIG_NAME)),
+      statuses: options.mcpStatuses ?? []
+    },
+    recentCrashes: listRecentCrashes(5, configDir),
+    diskUsage: getConfigDirUsage(configDir),
+    toolStats: {
+      totalCalls: allStats.reduce((a, b) => a + b.calls, 0),
+      totalFailures: allStats.reduce((a, b) => a + b.failures, 0),
+      topUsed: getTopUsedTools(5),
+      topFailing: getTopFailingTools(5)
+    }
+  };
+}
+
+// src/diagnostics/doctor-cli.ts
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+function formatDoctorReport(report, ansi = true) {
+  const wrap = (code, s) => ansi ? `${code}${s}\x1B[0m` : s;
+  const B = (s) => wrap("\x1B[1m", s);
+  const D = (s) => wrap("\x1B[2m", s);
+  const G = (s) => wrap("\x1B[32m", s);
+  const Y = (s) => wrap("\x1B[33m", s);
+  const R = (s) => wrap("\x1B[31m", s);
+  const out = [];
+  out.push("");
+  out.push(B("\u{1FA7A} AI-CLI Health Check"));
+  out.push("");
+  const nc = report.npmCheck;
+  let versionLine = `  version:  ${report.version}`;
+  if (nc?.status === "up-to-date") versionLine += `  ${D("(latest on npm)")}`;
+  else if (nc?.status === "outdated" && nc.latest) versionLine += `  ${Y(`\u2192 ${nc.latest} available`)}  ${D("(npm i -g jinzd-ai-cli@latest)")}`;
+  else if (nc?.status === "skipped") versionLine += `  ${D(`(npm check skipped: ${nc.reason ?? "unknown"})`)}`;
+  out.push(versionLine);
+  out.push(`  node:     ${report.node}`);
+  out.push(`  platform: ${report.platform}`);
+  out.push(`  cwd:      ${report.cwd}`);
+  out.push(`  project:  ${report.projectRoot}`);
+  out.push(`  config:   ${report.configDir}`);
+  out.push("");
+  out.push(B("API Keys:"));
+  for (const p of report.providers) {
+    out.push(`  ${p.configured ? G("\u2713") : D("\u25CB")}  ${p.id.padEnd(14)} ${p.configured ? G("configured") : D("not configured")}`);
+  }
+  out.push("");
+  out.push(B("Context Files:"));
+  out.push(`  status: ${report.context.enabled ? G("enabled") : D("disabled")} \xB7 max ${formatBytes(report.context.maxBytes)}`);
+  if (report.context.layers.length === 0) out.push(`  ${D("(no context files loaded)")}`);
+  for (const l of report.context.layers) {
+    out.push(`  ${G("\u2713")}  ${l.level.padEnd(7)} ${l.displayPath} ${D(`(${formatBytes(l.bytes)}${l.truncated ? ", truncated" : ""})`)}`);
+  }
+  if (report.context.skipped.length > 0) {
+    out.push(`  ${D("skipped:")}`);
+    for (const s of report.context.skipped.slice(0, 5)) {
+      out.push(`    ${Y("!")} ${s.level}:${s.fileName} ${s.reason}${s.message ? ` \xB7 ${s.message}` : ""}`);
+    }
+  }
+  out.push("");
+  out.push(B("Permissions / Network:"));
+  out.push(`  profile: ${report.permissions.defaultProfile} \xB7 allowed ${report.permissions.allowedProfiles.join(", ")} \xB7 rules ${report.permissions.ruleCount} \xB7 custom profiles ${report.permissions.customProfileCount}`);
+  const np = report.networkPolicy;
+  out.push(`  networkPolicy: ${np.enabled ? G("enabled") : D("disabled")} \xB7 default ${np.defaultAction} \xB7 allow ${np.allowDomains} domain(s)/${np.allowPorts} port(s) \xB7 deny ${np.denyDomains} domain(s)/${np.denyPorts} port(s) \xB7 private ${np.allowPrivateNetwork ? "allow" : "block/confirm"}`);
+  const overrides = Object.entries(np.toolOverrides).map(([k, v]) => `${k}=${v}`).join(", ");
+  if (overrides) out.push(`  tool overrides: ${overrides}`);
+  out.push("");
+  out.push(B("Hooks / Plugins:"));
+  out.push(`  hooks: ${report.hooks.enabled ? G("enabled") : D("disabled")} \xB7 total ${report.hooks.total} \xB7 project ${report.hooks.project} \xB7 pending trust ${report.hooks.pendingTrust} \xB7 disabled ${report.hooks.disabled}`);
+  out.push(`  plugins: installed ${report.plugins.installed} \xB7 active ${report.plugins.active} \xB7 disabled ${report.plugins.disabled} \xB7 untrusted ${report.plugins.untrusted} \xB7 invalid ${report.plugins.invalid}`);
+  out.push(`  plugin assets: ${report.plugins.skillDirs} skill dir(s), ${report.plugins.commandDirs} command dir(s), ${report.plugins.agentDirs} agent dir(s), ${report.plugins.mcpServers} MCP server(s)`);
+  if (report.plugins.entries.length > 0) {
+    for (const p of report.plugins.entries.slice(0, 5)) {
+      const state2 = p.valid ? `${p.enabled ? "enabled" : "disabled"} \xB7 ${p.trusted ? "trusted" : "untrusted"}` : `invalid \xB7 ${p.error ?? ""}`;
+      out.push(`    ${p.valid ? G("\u2713") : R("\u2717")} ${p.name}@${p.version} ${D(state2)}`);
+    }
+  }
+  out.push("");
+  out.push(B("MCP Servers:"));
+  out.push(`  global configured: ${report.mcp.configured} \xB7 project .mcp.json: ${report.mcp.projectConfigExists ? "yes" : "no"} \xB7 mcpEnabled: ${report.mcp.enabled ? "true" : "false"}`);
+  if (report.mcp.statuses.length === 0) out.push(`  ${D("(no connected manager status in this mode)")}`);
+  for (const s of report.mcp.statuses) {
+    const state2 = s.connected ? `${G("connected")} \xB7 ${s.serverName} \xB7 ${s.toolCount} tools` : `${R("disconnected")}${s.error ? D(` \xB7 ${s.error}`) : ""}`;
+    out.push(`  ${s.connected ? G("\u2713") : R("\u2717")}  ${s.serverId.padEnd(16)} ${state2}`);
+  }
+  out.push("");
+  out.push(B("Config Files:"));
+  for (const f of report.files) {
+    const extra = f.exists && f.sizeBytes !== null ? ` ${D(`(${formatBytes(f.sizeBytes)})`)}` : "";
+    out.push(`  ${f.exists ? G("\u2713") : D("\u2013")}  ${f.label.padEnd(16)} ${f.exists ? f.path : D("(not found)")}${extra}`);
+  }
+  out.push("");
+  out.push(B("Recent Crashes (last 5):"));
+  if (report.recentCrashes.length === 0) out.push(`  ${D("(none - clean!)")}`);
+  for (const c of report.recentCrashes) {
+    out.push(`  ${R("\u2717")}  ${c.timestamp}  ${Y(c.kind)}`);
+    out.push(`     ${D(c.message)}`);
+    out.push(`     ${D(c.file)}`);
+  }
+  out.push("");
+  const ts = report.toolStats;
+  out.push(B("Tool Usage:"));
+  out.push(`  total: ${ts.totalCalls} calls \xB7 ${ts.totalFailures} failures (${ts.totalCalls ? (ts.totalFailures * 100 / ts.totalCalls).toFixed(1) : "0.0"}%)`);
+  if (ts.topUsed.length > 0) {
+    out.push(`  ${D("top used:")}`);
+    for (const t of ts.topUsed) out.push(`    ${t.name.padEnd(20)} ${String(t.calls).padStart(6)} calls \xB7 avg ${t.calls ? (t.totalDurationMs / t.calls).toFixed(0) : "0"}ms`);
+  }
+  if (ts.topFailing.length > 0) {
+    out.push(`  ${D("top failing:")}`);
+    for (const t of ts.topFailing) out.push(`    ${R(t.name.padEnd(20))} ${t.failures}/${t.calls} (${(t.failures * 100 / Math.max(1, t.calls)).toFixed(1)}%)  ${D(t.lastFailureMessage ?? "")}`.slice(0, 200));
+  }
+  out.push("");
+  const dirAnnotations = {
+    models: "semantic search model -> /index semantic-clear",
+    index: "symbol index -> /index clear",
+    history: "conversation history",
+    logs: "crash logs",
+    "memory-index": "chat memory index -> /memory index-clear",
+    plugins: "installed package plugins"
+  };
+  out.push(B("Disk Usage (~/.aicli):"));
+  out.push(`  total: ${formatBytes(report.diskUsage.totalBytes)}`);
+  for (const e of report.diskUsage.entries.slice(0, 10)) {
+    const note = dirAnnotations[e.name];
+    out.push(`    ${e.name.padEnd(18)} ${formatBytes(e.bytes)}${note ? `  ${D(`\xB7 ${note}`)}` : ""}`);
+  }
+  out.push("");
+  out.push(G("\u2713 Health check complete"));
+  out.push("");
+  return out.join("\n");
+}
+
 // src/hub/presets.ts
 var PRESETS = [
   {
@@ -14130,7 +14762,7 @@ function resolveRoleProviders(roles, lookup, defaultProvider, defaultModel, avai
 }
 
 // src/hub/persist.ts
-import { join as join19 } from "path";
+import { join as join22 } from "path";
 function discussionToMessages(state2) {
   const out = [];
   const t0 = state2.messages[0]?.timestamp ?? /* @__PURE__ */ new Date();
@@ -14168,7 +14800,7 @@ async function persistDiscussion(state2, config, defaultProvider, defaultModel)
   session.title = `[Hub] ${state2.topic.slice(0, 48)}`.replace(/\n/g, " ");
   session.titleAiGenerated = true;
   await sm.save();
-  return { id: session.id, path: join19(config.getHistoryDir(), `${session.id}.json`) };
+  return { id: session.id, path: join22(config.getHistoryDir(), `${session.id}.json`) };
 }
 
 // src/web/session-handler.ts
@@ -14264,7 +14896,7 @@ var SessionHandler = class {
     }
     this.updateContextWindow();
     this.activeSystemPrompt = this.loadContextFiles();
-    const hooks = this.config.get("hooks");
+    const hooks = mergePluginHooks(this.config.get("hooks") ?? void 0, this.config.getConfigDir());
     const permissionRules = this.config.get("permissionRules");
     const defaultPermission = this.config.get("defaultPermission");
     const permissionProfileName = this.config.get("defaultPermissionProfile") ?? "legacy";
@@ -14364,10 +14996,10 @@ var SessionHandler = class {
         return;
       }
       case "ask_user_response": {
-        const resolve11 = this.pendingAskUser.get(msg.requestId);
-        if (resolve11) {
+        const resolve12 = this.pendingAskUser.get(msg.requestId);
+        if (resolve12) {
           this.pendingAskUser.delete(msg.requestId);
-          resolve11(msg.answer);
+          resolve12(msg.answer);
         }
         return;
       }
@@ -14380,10 +15012,10 @@ var SessionHandler = class {
       case "memory_manage":
         return this.handleMemoryManage(msg.action, msg.id, msg.expiresAt);
       case "auto_pause_response": {
-        const resolve11 = this.pendingAutoPause.get(msg.requestId);
-        if (resolve11) {
+        const resolve12 = this.pendingAutoPause.get(msg.requestId);
+        if (resolve12) {
           this.pendingAutoPause.delete(msg.requestId);
-          resolve11({ action: msg.action, message: msg.message });
+          resolve12({ action: msg.action, message: msg.message });
         }
         return;
       }
@@ -14398,10 +15030,10 @@ var SessionHandler = class {
         this.hubOrchestrator?.abort();
         return;
       case "hub_steer": {
-        const resolve11 = this.pendingHubReview.get(msg.requestId);
-        if (resolve11) {
+        const resolve12 = this.pendingHubReview.get(msg.requestId);
+        if (resolve12) {
           this.pendingHubReview.delete(msg.requestId);
-          resolve11({ action: msg.action, message: msg.message });
+          resolve12({ action: msg.action, message: msg.message });
         }
         return;
       }
@@ -14411,12 +15043,12 @@ var SessionHandler = class {
     }
   }
   onDisconnect() {
-    runLifecycleHooks(this.config.get("hooks") ?? void 0, "Stop", { sessionId: this.sessions.current?.id }, { configDir: this.config.getConfigDir() });
+    runLifecycleHooks(mergePluginHooks(this.config.get("hooks") ?? void 0, this.config.getConfigDir()), "Stop", { sessionId: this.sessions.current?.id }, { configDir: this.config.getConfigDir() });
     this.toolExecutor.cancelAll();
     if (this.abortController) this.abortController.abort();
-    for (const resolve11 of this.pendingAskUser.values()) resolve11(null);
+    for (const resolve12 of this.pendingAskUser.values()) resolve12(null);
     this.pendingAskUser.clear();
-    for (const resolve11 of this.pendingAutoPause.values()) resolve11({ action: "stop" });
+    for (const resolve12 of this.pendingAutoPause.values()) resolve12({ action: "stop" });
     this.pendingAutoPause.clear();
     this.saveIfNeeded();
   }
@@ -14550,9 +15182,9 @@ var SessionHandler = class {
     this.hubOrchestrator = orchestrator;
     orchestrator.onEvent = (event) => this.send({ type: "hub_event", event });
     if (config.humanSteer) {
-      orchestrator.onRoundReview = ({ round, maxRounds }) => new Promise((resolve11) => {
+      orchestrator.onRoundReview = ({ round, maxRounds }) => new Promise((resolve12) => {
         const requestId = `hubrev_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        this.pendingHubReview.set(requestId, resolve11);
+        this.pendingHubReview.set(requestId, resolve12);
         this.send({ type: "hub_review", requestId, round, maxRounds });
       });
     }
@@ -14590,7 +15222,7 @@ var SessionHandler = class {
       this.ensureSession();
       const session = this.sessions.current;
       const promptDecisions = runLifecycleHooks(
-        this.config.get("hooks") ?? void 0,
+        mergePluginHooks(this.config.get("hooks") ?? void 0, this.config.getConfigDir()),
         "UserPromptSubmit",
         { sessionId: session.id, prompt: content },
         { configDir: this.config.getConfigDir(), onSummary: (message) => this.send({ type: "info", message: "[hook] " + message }) }
@@ -14885,7 +15517,7 @@ Try: /compact to reduce context, /clear to reset, or switch to a larger-context
           this.send({ type: "response_done", content, usage });
           if (pendingTeeSave && isCleanDocumentBody(content)) {
             try {
-              mkdirSync11(dirname6(pendingTeeSave), { recursive: true });
+              mkdirSync13(dirname7(pendingTeeSave), { recursive: true });
               const bodyToSave = stripOuterCodeFence(content);
               atomicWriteFileSync(pendingTeeSave, bodyToSave);
               undoStack.push(pendingTeeSave, `save_last_response (deferred): ${pendingTeeSave}`);
@@ -14910,8 +15542,8 @@ Try: /compact to reduce context, /clear to reset, or switch to a larger-context
         onMcpToolUsed: (name) => this.usedMcpToolNames.add(name),
         requestAutoPause: async ({ effectiveRound, maxToolRounds: totalRounds, toolSummary }) => {
           const requestId = `pause_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-          const pauseResp = await new Promise((resolve11) => {
-            this.pendingAutoPause.set(requestId, resolve11);
+          const pauseResp = await new Promise((resolve12) => {
+            this.pendingAutoPause.set(requestId, resolve12);
             this.send({
               type: "auto_pause_request",
               requestId,
@@ -15061,7 +15693,7 @@ ${summaryContent}`,
     let isError = false;
     let summary;
     try {
-      mkdirSync11(dirname6(saveToFile), { recursive: true });
+      mkdirSync13(dirname7(saveToFile), { recursive: true });
       fileStream = createWriteStream(saveToFile);
       const teeSystemPrompt = stripToolCallReminder(systemPrompt ?? "") + CONTENT_ONLY_STREAM_REMINDER;
       const teeExtraMessages = extraMessages.length > 0 ? [...extraMessages, { role: "user", content: TEE_FINAL_USER_NUDGE }] : [{ role: "user", content: TEE_FINAL_USER_NUDGE }];
@@ -15090,8 +15722,8 @@ ${summaryContent}`,
         }
         if (chunk.done) break;
       }
-      await new Promise((resolve11, reject) => {
-        fileStream.end((err) => err ? reject(err) : resolve11());
+      await new Promise((resolve12, reject) => {
+        fileStream.end((err) => err ? reject(err) : resolve12());
       });
       const verdict = evaluateTeeContent(fullContent, saveToFile, priorContent);
       if (verdict.kind === "reject") {
@@ -15117,7 +15749,7 @@ ${summaryContent}`,
     } catch (err) {
       if (fileStream) {
         try {
-          await new Promise((resolve11) => fileStream.end(() => resolve11()));
+          await new Promise((resolve12) => fileStream.end(() => resolve12()));
         } catch {
         }
       }
@@ -15432,6 +16064,7 @@ Tokens: in=${this.sessionTokenUsage.inputTokens} out=${this.sessionTokenUsage.ou
             "  /add-dir [path|remove] \u2014 Add/remove directory from AI context",
             "  /mcp [reconnect]     \u2014 Show/manage MCP servers",
             "  /plugins             \u2014 Show loaded plugins",
+            "  /plugin <cmd>        \u2014 Manage package plugins",
             "  /commands            \u2014 List custom commands",
             "  /doctor              \u2014 Health check (API keys, config, MCP)",
             "  /bug                 \u2014 Generate bug report template",
@@ -15530,7 +16163,7 @@ ${lines.join("\n")}` });
           this.sendToolsList();
           this.sendStatus();
         } else if (sub === "reload") {
-          this.skillManager.loadSkills();
+          this.skillManager.loadSkills(getActivePluginAssets(this.config.getConfigDir()).skillDirs);
           this.send({ type: "info", message: `\u{1F504} Reloaded ${this.skillManager.listSkills().length} skill(s).` });
           this.sendToolsList();
         } else {
@@ -15749,9 +16382,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
         let modifiedFiles = 0;
         const diffLines2 = [];
         for (const [filePath, { earliest }] of fileMap) {
-          const currentContent = existsSync25(filePath) ? (() => {
+          const currentContent = existsSync28(filePath) ? (() => {
             try {
-              return readFileSync19(filePath, "utf-8");
+              return readFileSync21(filePath, "utf-8");
             } catch {
               return null;
             }
@@ -15852,7 +16485,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
           break;
         }
         const sub = args[0]?.toLowerCase();
-        const resolve11 = (ref) => {
+        const resolve12 = (ref) => {
           const r = session.resolveBranchRef(ref);
           if (r.ok) return r.id;
           if (r.reason === "ambiguous") {
@@ -15906,7 +16539,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             this.send({ type: "error", message: "Usage: /branch switch <id|title>" });
             break;
           }
-          const id = resolve11(ref);
+          const id = resolve12(ref);
           if (!id) break;
           const ok = session.switchBranch(id);
           if (ok) {
@@ -15926,7 +16559,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             this.send({ type: "error", message: "Usage: /branch delete <id|title>" });
             break;
           }
-          const id = resolve11(ref);
+          const id = resolve12(ref);
           if (!id) break;
           const ok = session.deleteBranch(id);
           if (ok) {
@@ -15945,7 +16578,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             this.send({ type: "error", message: "Usage: /branch rename <id|title> <new title>" });
             break;
           }
-          const id = resolve11(ref);
+          const id = resolve12(ref);
           if (!id) break;
           const ok = session.renameBranch(id, title);
           if (ok) {
@@ -15963,7 +16596,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             this.send({ type: "error", message: "Usage: /branch diff <id|title>" });
             break;
           }
-          const id = resolve11(ref);
+          const id = resolve12(ref);
           if (!id) break;
           const d = session.diffBranches(id);
           if (!d) {
@@ -16005,7 +16638,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             this.send({ type: "error", message: "Usage: /branch cherry-pick <source-id|title> <msg-index>" });
             break;
           }
-          const id = resolve11(ref);
+          const id = resolve12(ref);
           if (!id) break;
           const idx = parseInt(idxStr, 10);
           if (Number.isNaN(idx)) {
@@ -16267,7 +16900,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-K7QR5QN4.js");
+          const { executeTests } = await import("./run-tests-O76JIBCW.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -16284,9 +16917,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       // ── /init ───────────────────────────────────────────────────────
       case "init": {
         const cwd = process.cwd();
-        const targetPath = join20(cwd, "AICLI.md");
+        const targetPath = join23(cwd, "AICLI.md");
         const force = args.includes("--force");
-        if (existsSync25(targetPath) && !force) {
+        if (existsSync28(targetPath) && !force) {
           this.send({ type: "info", message: `AICLI.md already exists at ${targetPath}
 Use /init --force to overwrite.` });
           break;
@@ -16296,7 +16929,7 @@ Use /init --force to overwrite.` });
           const projectInfo = scanProject(cwd);
           const prompt = buildInitPrompt(projectInfo, cwd);
           const content = await this.chatOnce(prompt, { temperature: 0.3, maxTokens: 4096 });
-          writeFileSync2(targetPath, content, "utf-8");
+          writeFileSync3(targetPath, content, "utf-8");
           this.send({ type: "info", message: `\u2713 Generated: ${targetPath} (${content.length} chars)
 Use /context reload to load it.` });
         } catch (err) {
@@ -16306,53 +16939,13 @@ Use /context reload to load it.` });
       }
       // ── /doctor ─────────────────────────────────────────────────────
       case "doctor": {
-        const lines = ["\u{1FA7A} **AI-CLI Health Check**", ""];
-        lines.push("**API Keys:**");
-        const providersList = this.providers.listAll();
-        for (const p of providersList) {
-          const icon = p.configured ? "\u2713" : "\u25CB";
-          const status = p.configured ? "configured" : "not configured";
-          lines.push(`  ${icon}  ${p.id.padEnd(14)} ${status}`);
-        }
-        lines.push("");
-        const configDir = this.config.getConfigDir();
-        lines.push("**Config Files:**");
-        lines.push(`  Dir: ${configDir}`);
-        const checkFile = (label, filePath) => {
-          const exists = existsSync25(filePath);
-          let extra = "";
-          if (exists) {
-            try {
-              extra = ` (${statSync8(filePath).size} bytes)`;
-            } catch {
-            }
-          }
-          lines.push(`  ${exists ? "\u2713" : "\u2013"}  ${label.padEnd(14)} ${exists ? filePath + extra : "(not found)"}`);
-        };
-        checkFile("config.json", join20(configDir, "config.json"));
-        checkFile("memory.md", join20(configDir, MEMORY_FILE_NAME));
-        checkFile("dev-state.md", join20(configDir, "dev-state.md"));
-        lines.push("");
-        if (this.mcpManager) {
-          lines.push("**MCP Servers:**");
-          const statuses = this.mcpManager.getStatus();
-          if (statuses.length === 0) {
-            lines.push("  (no servers configured)");
-          } else {
-            for (const s of statuses) {
-              const state2 = s.connected ? `connected \xB7 ${s.serverName} \xB7 ${s.toolCount} tools` : `disconnected${s.error ? ` \xB7 ${s.error}` : ""}`;
-              lines.push(`  ${s.connected ? "\u2713" : "\u2717"}  ${s.serverId.padEnd(16)} ${state2}`);
-            }
-          }
-          lines.push("");
-        }
-        lines.push("**Current Session:**");
-        lines.push(`  Provider: ${this.currentProvider}`);
-        lines.push(`  Model:    ${this.currentModel}`);
-        lines.push(`  Version:  ${VERSION}`);
-        lines.push("");
-        lines.push("\u2713 Health check complete");
-        this.send({ type: "info", message: lines.join("\n") });
+        const report = buildDoctorReport({
+          config: this.config,
+          providers: this.providers,
+          cwd: process.cwd(),
+          mcpStatuses: this.mcpManager?.getStatus() ?? []
+        });
+        this.send({ type: "info", message: formatDoctorReport(report, false) });
         break;
       }
       // ── /about ──────────────────────────────────────────────────────
@@ -16434,7 +17027,7 @@ ${this.config.toFormattedJSON()}
         const result = this.contextLoadResult;
         const layers = ["\u{1F4DA} **Context Layers:**", ""];
         if (result && result.layers.length > 0) {
-          const labels = { global: "Global ", project: "Project", local: "Local  " };
+          const labels = { global: "Global ", project: "Project", plugin: "Plugin ", local: "Local  " };
           for (const layer of result.layers) {
             layers.push(`  \u2713 ${labels[layer.level] ?? layer.level}: ${layer.displayPath} (${layer.charCount} chars${layer.truncated ? ", truncated" : ""})`);
           }
@@ -16518,12 +17111,12 @@ Use /add-dir remove to clear.` : "No directories added.\nUsage: /add-dir <path>
           this.send({ type: "info", message: "\u2713 All added directories removed from context." });
           break;
         }
-        const dirPath = resolve9(sub);
-        if (!existsSync25(dirPath)) {
+        const dirPath = resolve10(sub);
+        if (!existsSync28(dirPath)) {
           this.send({ type: "error", message: `Directory not found: ${dirPath}` });
           break;
         }
-        if (!statSync8(dirPath).isDirectory()) {
+        if (!statSync11(dirPath).isDirectory()) {
           this.send({ type: "error", message: `Not a directory: ${dirPath}` });
           break;
         }
@@ -16535,14 +17128,14 @@ It will be included in AI context for subsequent messages.` });
       // ── /commands ───────────────────────────────────────────────────
       case "commands": {
         const configDir = this.config.getConfigDir();
-        const commandsDir = join20(configDir, CUSTOM_COMMANDS_DIR_NAME);
-        if (!existsSync25(commandsDir)) {
+        const commandsDir = join23(configDir, CUSTOM_COMMANDS_DIR_NAME);
+        if (!existsSync28(commandsDir)) {
           this.send({ type: "info", message: `No custom commands directory.
 Create: ${commandsDir}/ with .md files.` });
           break;
         }
         try {
-          const files = readdirSync11(commandsDir).filter((f) => f.endsWith(".md"));
+          const files = readdirSync13(commandsDir).filter((f) => f.endsWith(".md"));
           if (files.length === 0) {
             this.send({ type: "info", message: `No custom commands found in ${commandsDir}
 Add .md files to create commands.` });
@@ -16559,23 +17152,75 @@ Add .md files to create commands.` });
         }
         break;
       }
-      // ── /plugins ────────────────────────────────────────────────────
+      // ── /plugins / /plugin ──────────────────────────────────────────
       case "plugins": {
         const configDir = this.config.getConfigDir();
-        const pluginsDir = join20(configDir, PLUGINS_DIR_NAME);
+        const pluginsDir = join23(configDir, PLUGINS_DIR_NAME);
         const pluginTools = this.toolRegistry.listPluginTools();
+        const pluginPackages = listInstalledPlugins(configDir);
         const lines = [`\u{1F50C} **Plugins:**`, `Dir: ${pluginsDir}`, ""];
-        if (pluginTools.length === 0) {
+        if (pluginTools.length === 0 && pluginPackages.length === 0) {
           lines.push("No plugins loaded.");
-          lines.push("Add .js files to the plugins directory and set allowPlugins:true in config.");
+          lines.push("Use /plugin install <path>, /plugin trust <name>, then /plugin enable <name>.");
         } else {
-          for (const t of pluginTools) {
-            lines.push(`  \u2022 ${t.definition.name} \u2014 ${t.definition.description}`);
+          if (pluginPackages.length > 0) {
+            lines.push(`Package plugins (${pluginPackages.length}):`);
+            for (const p of pluginPackages) lines.push(`  \u2022 ${p.name}@${p.manifest.version} \u2014 ${p.enabled ? "enabled" : "disabled"} / ${p.trusted ? "trusted" : "untrusted"}`);
+            lines.push("");
+          }
+          if (pluginTools.length > 0) {
+            lines.push(`Legacy JS plugin tools (${pluginTools.length}):`);
+            for (const t of pluginTools) lines.push(`  \u2022 ${t.definition.name} \u2014 ${t.definition.description}`);
           }
         }
         this.send({ type: "info", message: lines.join("\n") });
         break;
       }
+      case "plugin": {
+        const configDir = this.config.getConfigDir();
+        const sub = args[0] ?? "list";
+        try {
+          if (sub === "list") {
+            const plugins = listInstalledPlugins(configDir);
+            const lines = [`\u{1F50C} **Package Plugins**`, `Dir: ${pluginRoot(configDir)}`, ""];
+            if (plugins.length === 0) lines.push("No package plugins installed.");
+            for (const p of plugins) lines.push(`  \u2022 ${p.name}@${p.manifest.version} \u2014 ${p.enabled ? "enabled" : "disabled"} / ${p.trusted ? "trusted" : "untrusted"}`);
+            this.send({ type: "info", message: lines.join("\n") });
+            break;
+          }
+          if (sub === "install") {
+            const input = args[1];
+            if (!input) throw new Error("Usage: /plugin install <path>");
+            const plugin = installPlugin(configDir, input);
+            this.send({ type: "info", message: `Installed plugin ${plugin.name}@${plugin.manifest.version}. Run /plugin trust ${plugin.name}, then /plugin enable ${plugin.name}.` });
+            break;
+          }
+          if (sub === "trust") {
+            const name2 = args[1];
+            if (!name2) throw new Error("Usage: /plugin trust <name>");
+            const state2 = trustPlugin(configDir, name2);
+            this.send({ type: "info", message: `Trusted plugin ${state2.name}.` });
+            break;
+          }
+          if (sub === "enable" || sub === "disable") {
+            const name2 = args[1];
+            if (!name2) throw new Error(`Usage: /plugin ${sub} <name>`);
+            const state2 = setPluginEnabled(configDir, name2, sub === "enable");
+            this.send({ type: "info", message: `${sub === "enable" ? "Enabled" : "Disabled"} plugin ${state2.name}. Restart Web UI for changes to take effect.` });
+            break;
+          }
+          if (sub === "inspect") {
+            const name2 = args[1];
+            if (!name2) throw new Error("Usage: /plugin inspect <name>");
+            this.send({ type: "info", message: describePlugin(getInstalledPlugin(configDir, name2)).join("\n") });
+            break;
+          }
+          throw new Error("Usage: /plugin [list|install|enable|disable|inspect|trust]");
+        } catch (err) {
+          this.send({ type: "error", message: err instanceof Error ? err.message : String(err) });
+        }
+        break;
+      }
       // ── /bug ────────────────────────────────────────────────────────
       case "bug": {
         const session = this.sessions.current;
@@ -16618,7 +17263,7 @@ Add .md files to create commands.` });
       return;
     }
     const preDecisions = runLifecycleHooks(
-      this.config.get("hooks") ?? void 0,
+      mergePluginHooks(this.config.get("hooks") ?? void 0, this.config.getConfigDir()),
       "PreCompact",
       { sessionId: session.id, messageCount: session.messages.length, instruction },
       { configDir: this.config.getConfigDir(), onSummary: (message) => this.send({ type: "info", message: "[hook] " + message }) }
@@ -16655,7 +17300,7 @@ Add .md files to create commands.` });
       const removedCount = session.compact(summaryMsg, ackMsg, keepLast);
       const afterCount = session.messages.length;
       runLifecycleHooks(
-        this.config.get("hooks") ?? void 0,
+        mergePluginHooks(this.config.get("hooks") ?? void 0, this.config.getConfigDir()),
         "PostCompact",
         { sessionId: session.id, beforeCount, afterCount, removedCount, keepLast, instruction },
         { configDir: this.config.getConfigDir(), onSummary: (message) => this.send({ type: "info", message: "[hook] " + message }) }
@@ -16792,7 +17437,7 @@ ${entry.content}`;
     const configDir = this.config.getConfigDir();
     try {
       atomicWriteFileSync(memoryStorePath(configDir), "");
-      atomicWriteFileSync(join20(configDir, MEMORY_FILE_NAME), "");
+      atomicWriteFileSync(join23(configDir, MEMORY_FILE_NAME), "");
       this.send({ type: "info", message: "\u{1F5D1}\uFE0F Persistent memory cleared." });
       this.sendMemoryEntries();
     } catch (err) {
@@ -17074,8 +17719,8 @@ async function setupProxy(configProxy) {
 }
 
 // src/web/auth.ts
-import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync3, mkdirSync as mkdirSync12, readdirSync as readdirSync12, copyFileSync } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync22, writeFileSync as writeFileSync4, mkdirSync as mkdirSync14, readdirSync as readdirSync14, copyFileSync } from "fs";
+import { join as join24 } from "path";
 import { createHmac, randomBytes, timingSafeEqual, pbkdf2Sync } from "crypto";
 var USERS_FILE = "users.json";
 var TOKEN_EXPIRY_HOURS = 24;
@@ -17090,7 +17735,7 @@ var AuthManager = class {
   db;
   constructor(baseDir) {
     this.baseDir = baseDir;
-    this.usersFile = join21(baseDir, USERS_FILE);
+    this.usersFile = join24(baseDir, USERS_FILE);
     this.db = this.loadOrCreate();
   }
   // ── Public API ─────────────────────────────────────────────────
@@ -17119,9 +17764,9 @@ var AuthManager = class {
     }
     const salt = randomBytes(16).toString("hex");
     const passwordHash = this.hashPassword(password, salt);
-    const dataDir = join21(USERS_DIR, username);
-    const fullDataDir = join21(this.baseDir, dataDir);
-    mkdirSync12(join21(fullDataDir, "history"), { recursive: true });
+    const dataDir = join24(USERS_DIR, username);
+    const fullDataDir = join24(this.baseDir, dataDir);
+    mkdirSync14(join24(fullDataDir, "history"), { recursive: true });
     const user = {
       username,
       passwordHash,
@@ -17236,7 +17881,7 @@ var AuthManager = class {
   getUserDataDir(username) {
     const user = this.db.users.find((u) => u.username === username);
     if (!user) throw new Error(`User not found: ${username}`);
-    return join21(this.baseDir, user.dataDir);
+    return join24(this.baseDir, user.dataDir);
   }
   /** List all usernames */
   listUsers() {
@@ -17272,30 +17917,30 @@ var AuthManager = class {
     const err = this.register(username, password);
     if (err) return err;
     const userDir = this.getUserDataDir(username);
-    const globalConfig = join21(this.baseDir, "config.json");
-    if (existsSync26(globalConfig)) {
+    const globalConfig = join24(this.baseDir, "config.json");
+    if (existsSync29(globalConfig)) {
       try {
-        const content = readFileSync20(globalConfig, "utf-8");
-        writeFileSync3(join21(userDir, "config.json"), content, "utf-8");
+        const content = readFileSync22(globalConfig, "utf-8");
+        writeFileSync4(join24(userDir, "config.json"), content, "utf-8");
       } catch {
       }
     }
-    const globalMemory = join21(this.baseDir, "memory.md");
-    if (existsSync26(globalMemory)) {
+    const globalMemory = join24(this.baseDir, "memory.md");
+    if (existsSync29(globalMemory)) {
       try {
-        const content = readFileSync20(globalMemory, "utf-8");
-        writeFileSync3(join21(userDir, "memory.md"), content, "utf-8");
+        const content = readFileSync22(globalMemory, "utf-8");
+        writeFileSync4(join24(userDir, "memory.md"), content, "utf-8");
       } catch {
       }
     }
-    const globalHistory = join21(this.baseDir, "history");
-    if (existsSync26(globalHistory)) {
+    const globalHistory = join24(this.baseDir, "history");
+    if (existsSync29(globalHistory)) {
       try {
-        const files = readdirSync12(globalHistory).filter((f) => f.endsWith(".json"));
-        const userHistory = join21(userDir, "history");
+        const files = readdirSync14(globalHistory).filter((f) => f.endsWith(".json"));
+        const userHistory = join24(userDir, "history");
         for (const f of files) {
           try {
-            copyFileSync(join21(globalHistory, f), join21(userHistory, f));
+            copyFileSync(join24(globalHistory, f), join24(userHistory, f));
           } catch {
           }
         }
@@ -17306,9 +17951,9 @@ var AuthManager = class {
   }
   // ── Private methods ────────────────────────────────────────────
   loadOrCreate() {
-    if (existsSync26(this.usersFile)) {
+    if (existsSync29(this.usersFile)) {
       try {
-        return JSON.parse(readFileSync20(this.usersFile, "utf-8"));
+        return JSON.parse(readFileSync22(this.usersFile, "utf-8"));
       } catch {
       }
     }
@@ -17324,7 +17969,7 @@ var AuthManager = class {
     this.saveDB(this.db);
   }
   saveDB(db) {
-    mkdirSync12(this.baseDir, { recursive: true });
+    mkdirSync14(this.baseDir, { recursive: true });
     atomicWriteFileSync(this.usersFile, JSON.stringify(db, null, 2));
   }
   /** Legacy hash — kept only for migrating old users (v0.2.x) */
@@ -17356,11 +18001,11 @@ function getModuleDir() {
     if (typeof import.meta?.url === "string") {
       const url = new URL(import.meta.url);
       const filePath = url.pathname.replace(/^\/([A-Z]:)/i, "$1");
-      return dirname7(filePath);
+      return dirname8(filePath);
     }
   } catch {
   }
-  return resolve10(".");
+  return resolve11(".");
 }
 async function startWebServer(options = {}) {
   const port = options.port ?? 3e3;
@@ -17395,6 +18040,8 @@ async function startWebServer(options = {}) {
   let mcpManager = null;
   const mcpEnabled = config.get("mcpEnabled") !== false;
   const globalMcpServers = mcpEnabled ? config.get("mcpServers") ?? {} : {};
+  const pluginAssets = getActivePluginAssets(config.getConfigDir());
+  const pluginMcpServers = mcpEnabled ? pluginAssets.mcpServers : {};
   const projectMcpResolved = mcpEnabled ? resolveProjectMcpPath() : null;
   let projectMcpServers = {};
   if (projectMcpResolved) {
@@ -17407,7 +18054,7 @@ async function startWebServer(options = {}) {
       console.log(`     Skipped to prevent unintended RCE. Run "aicli" then "/mcp trust-project" to approve.`);
     }
   }
-  const mergedMcpServers = { ...globalMcpServers, ...projectMcpServers };
+  const mergedMcpServers = { ...globalMcpServers, ...pluginMcpServers, ...projectMcpServers };
   if (!mcpEnabled) {
     console.log("   \u{1F50C} MCP: disabled (config.mcpEnabled=false)");
   }
@@ -17425,10 +18072,10 @@ async function startWebServer(options = {}) {
     }
   }
   let skillManager = null;
-  const skillsDir = join22(config.getConfigDir(), SKILLS_DIR_NAME);
-  if (existsSync27(skillsDir)) {
+  const skillsDir = join25(config.getConfigDir(), SKILLS_DIR_NAME);
+  if (existsSync30(skillsDir)) {
     skillManager = new SkillManager(skillsDir, config.get("ui").skillSizeWarn);
-    skillManager.loadSkills();
+    skillManager.loadSkills(pluginAssets.skillDirs);
     const count = skillManager.listSkills().length;
     if (count > 0) {
       console.log(`   Skills: ${count} available`);
@@ -17497,18 +18144,18 @@ async function startWebServer(options = {}) {
     next();
   };
   const moduleDir = getModuleDir();
-  let clientDir = join22(moduleDir, "web", "client");
-  if (!existsSync27(clientDir)) {
-    clientDir = join22(moduleDir, "client");
+  let clientDir = join25(moduleDir, "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(moduleDir, "client");
   }
-  if (!existsSync27(clientDir)) {
-    clientDir = join22(moduleDir, "..", "..", "src", "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(moduleDir, "..", "..", "src", "web", "client");
   }
-  if (!existsSync27(clientDir)) {
-    clientDir = join22(process.cwd(), "src", "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(process.cwd(), "src", "web", "client");
   }
   console.log(`   Static files: ${clientDir}`);
-  app.use("/vendor", express.static(join22(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
+  app.use("/vendor", express.static(join25(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
   app.use(express.static(clientDir));
   app.get("/api/status", (_req, res) => {
     res.json({
@@ -17575,10 +18222,10 @@ async function startWebServer(options = {}) {
   app.get("/api/files", requireAuth, (req, res) => {
     const cwd = process.cwd();
     const prefix = req.query.prefix || "";
-    const targetDir = join22(cwd, prefix);
+    const targetDir = join25(cwd, prefix);
     try {
-      const canonicalTarget = realpathSync(resolve10(targetDir));
-      const canonicalCwd = realpathSync(resolve10(cwd));
+      const canonicalTarget = realpathSync(resolve11(targetDir));
+      const canonicalCwd = realpathSync(resolve11(cwd));
       if (!canonicalTarget.startsWith(canonicalCwd + sep3) && canonicalTarget !== canonicalCwd) {
         res.json({ files: [] });
         return;
@@ -17589,10 +18236,10 @@ async function startWebServer(options = {}) {
     }
     try {
       const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", "__pycache__", ".next", ".nuxt", "coverage", ".cache"]);
-      const entries = readdirSync13(targetDir, { withFileTypes: true });
+      const entries = readdirSync15(targetDir, { withFileTypes: true });
       const files = entries.filter((e) => !SKIP.has(e.name) && !e.name.startsWith(".")).slice(0, 50).map((e) => ({
         name: e.name,
-        path: relative4(cwd, join22(targetDir, e.name)).replace(/\\/g, "/"),
+        path: relative4(cwd, join25(targetDir, e.name)).replace(/\\/g, "/"),
         isDir: e.isDirectory()
       }));
       res.json({ files });
@@ -17628,8 +18275,8 @@ async function startWebServer(options = {}) {
     try {
       const authUser = req._authUser;
       const histDir = authUser ? getUserShared(authUser).config.getHistoryDir() : config.getHistoryDir();
-      const filePath = join22(histDir, `${id}.json`);
-      if (!existsSync27(filePath)) {
+      const filePath = join25(histDir, `${id}.json`);
+      if (!existsSync30(filePath)) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
@@ -17644,7 +18291,7 @@ async function startWebServer(options = {}) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      const data = JSON.parse(readFileSync21(filePath, "utf-8"));
+      const data = JSON.parse(readFileSync23(filePath, "utf-8"));
       res.json({ session: data });
     } catch (err) {
       res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
@@ -17657,10 +18304,10 @@ async function startWebServer(options = {}) {
       return;
     }
     const cwd = process.cwd();
-    const fullPath = resolve10(join22(cwd, filePath));
+    const fullPath = resolve11(join25(cwd, filePath));
     try {
       const canonicalFull = realpathSync(fullPath);
-      const canonicalCwd = realpathSync(resolve10(cwd));
+      const canonicalCwd = realpathSync(resolve11(cwd));
       if (!canonicalFull.startsWith(canonicalCwd + sep3) && canonicalFull !== canonicalCwd) {
         res.json({ error: "Access denied" });
         return;
@@ -17670,12 +18317,12 @@ async function startWebServer(options = {}) {
       return;
     }
     try {
-      const stat = statSync9(fullPath);
+      const stat = statSync12(fullPath);
       if (stat.size > 512 * 1024) {
         res.json({ error: `File too large (${(stat.size / 1024).toFixed(0)} KB, max 512 KB)` });
         return;
       }
-      const content = readFileSync21(fullPath, "utf-8");
+      const content = readFileSync23(fullPath, "utf-8");
       res.json({ content, size: stat.size });
     } catch {
       res.json({ error: "Cannot read file" });
@@ -17879,7 +18526,7 @@ async function startWebServer(options = {}) {
   });
   const MAX_PORT_ATTEMPTS = 10;
   let actualPort = port;
-  const result = await new Promise((resolve11, reject) => {
+  const result = await new Promise((resolve12, reject) => {
     const tryListen = (attempt) => {
       server.once("error", (err) => {
         if (err.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS) {
@@ -17910,7 +18557,7 @@ async function startWebServer(options = {}) {
         }
         console.log(`   Press Ctrl+C to stop
 `);
-        resolve11({ port: actualPort, host, url });
+        resolve12({ port: actualPort, host, url });
       });
     };
     tryListen(1);
@@ -17930,17 +18577,17 @@ function resolveProjectMcpPath() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join22(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  return existsSync27(configPath) ? configPath : null;
+  const configPath = join25(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  return existsSync30(configPath) ? configPath : null;
 }
 function loadProjectMcpConfig() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join22(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  if (!existsSync27(configPath)) return null;
+  const configPath = join25(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  if (!existsSync30(configPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync21(configPath, "utf-8"));
+    const raw = JSON.parse(readFileSync23(configPath, "utf-8"));
     return raw.mcpServers ?? raw;
   } catch {
     return null;