@linghun/tui 0.1.0

package/dist/chunk-JQCRCDOC.js

@@ -0,0 +1,1195 @@
+import {
+  formatMcpTools
+} from "./chunk-W6NU7ZAV.js";
+import {
+  buildIndexStatusPanel,
+  buildMcpStatusPanel,
+  formatIndexRefreshSummary,
+  formatIndexStatus,
+  formatMcpStatus
+} from "./chunk-OF3K3CU5.js";
+import {
+  runMcpSseToolCall
+} from "./chunk-SRZIA6B4.js";
+import {
+  isPotentiallyMutatingMcpTool,
+  runMcpStdioToolCall,
+  runMcpStdioToolList
+} from "./chunk-OEYW3JE3.js";
+import {
+  createIndexTransientExcludes,
+  formatIndexAutoSkipDetails,
+  formatIndexAutoSkipNextAction,
+  formatIndexAutoSkipPrimary,
+  scanIndexSafety,
+  summarizeIndexResult
+} from "./chunk-W3KHJNSH.js";
+import {
+  showCommandPanel
+} from "./chunk-JO5ANTMR.js";
+import {
+  writeDiagnosticLine
+} from "./chunk-ECFLCY5V.js";
+import {
+  redactedPath,
+  runCommandCapture
+} from "./chunk-RVY34HK4.js";
+import {
+  findDeferredTool,
+  getCodebaseMemoryToolRisk,
+  isCodebaseMemoryToolName,
+  isLocalStdioMcpServer,
+  listDeferredTools,
+  parseMcpDeferredToolName,
+  searchDeferredTools,
+  summarizeDeferredToolMatch,
+  validateCodebaseMemoryToolExecution
+} from "./chunk-I3NTAIMF.js";
+import {
+  findCurrentIndexProject,
+  readLocalIndexArtifactState
+} from "./chunk-UT2TYK2A.js";
+import {
+  createMcpState,
+  createMcpToolPlaceholders,
+  pathExists
+} from "./chunk-QLRTQHTR.js";
+import {
+  diffFreshness
+} from "./chunk-4T5DJW54.js";
+import {
+  formatError,
+  sanitizeDiagnosticText,
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/mcp-index-runtime.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { delimiter, dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import {
+  removeMcpServerConfig,
+  resolveStoragePaths,
+  saveMcpServerConfig
+} from "@linghun/config";
+import { TOGGLE_DETAILS_KEYBIND } from "@linghun/shared";
+var CODEBASE_MEMORY_COMMAND = "codebase-memory-mcp";
+var CODEBASE_MEMORY_ENV = "LINGHUN_CODEBASE_MEMORY_MCP";
+var CLI_BUNDLED_ROOT_ENV = "LINGHUN_CLI_BUNDLED_ROOT";
+var CODEBASE_MEMORY_BUNDLED_ENV = "LINGHUN_CODEBASE_MEMORY_BUNDLED_DIR";
+var CODEBASE_MEMORY_BUNDLED_PLATFORM_ARCHES = /* @__PURE__ */ new Set([
+  "win32-x64",
+  "linux-x64",
+  "darwin-arm64",
+  "darwin-x64"
+]);
+var runtimeDeps;
+function configureMcpIndexRuntime(deps2) {
+  runtimeDeps = deps2;
+}
+function deps() {
+  if (!runtimeDeps) {
+    throw new Error("mcp-index-runtime deps not configured");
+  }
+  return runtimeDeps;
+}
+function refreshCacheFreshness(context) {
+  const freshness = deps().getCurrentFreshness(context);
+  context.cache.lastFreshness = {
+    ...freshness,
+    changedKeys: diffFreshness(context.cache.lastFreshness, freshness)
+  };
+}
+async function handleMcpCommand(args, context, output) {
+  const action = args[0] ?? "status";
+  if (action === "status") {
+    showCommandPanel(context, output, buildMcpStatusPanel(context));
+    return;
+  }
+  if (action === "tools") {
+    context.mcp.tools = stabilizeMcpToolList(context.mcp.tools);
+    refreshCacheFreshness(context);
+    writeDiagnosticLine(output, formatMcpTools(context.mcp));
+    return;
+  }
+  if (action === "doctor") {
+    await runMcpDoctor(context);
+    const isEn = context.language === "en-US";
+    showCommandPanel(context, output, {
+      title: "/mcp doctor",
+      tone: "neutral",
+      summary: [
+        isEn ? `MCP doctor \u2014 ${TOGGLE_DETAILS_KEYBIND} for full diagnostics.` : `MCP \u8BCA\u65AD \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u5B8C\u6574\u8BCA\u65AD\u3002`
+      ],
+      detailsText: formatMcpStatus(context)
+    });
+    return;
+  }
+  if (action === "validate") {
+    const isEn = context.language === "en-US";
+    showCommandPanel(context, output, {
+      title: "/mcp validate",
+      tone: "neutral",
+      summary: [
+        isEn ? `MCP validate \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `MCP \u6821\u9A8C \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: validateMcpServers(context, args[1])
+    });
+    return;
+  }
+  if (action === "add" || action === "install") {
+    const result = await addMcpServer(args.slice(1), context);
+    writeLine(output, result);
+    return;
+  }
+  if (action === "enable" || action === "disable") {
+    const id = args[1];
+    writeLine(
+      output,
+      id ? await setMcpServerEnabled(id, action === "enable", context) : `\u7528\u6CD5\uFF1A/mcp ${action} <server-id>`
+    );
+    return;
+  }
+  if (action === "remove") {
+    const id = args[1];
+    writeLine(output, id ? await removeMcpServer(id, context) : "\u7528\u6CD5\uFF1A/mcp remove <server-id>");
+    return;
+  }
+  if (action === "update") {
+    writeLine(output, await updateMcpServer(args.slice(1), context));
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/mcp | /mcp status | /mcp tools | /mcp doctor | /mcp validate [id] | /mcp add local <id> <command> [args...] | /mcp update <id> local <command> [args...] | /mcp enable|disable <id> | /mcp remove <id>"
+  );
+}
+async function handleIndexCommand(args, context, output) {
+  const action = args[0] ?? "status";
+  if (action === "status") {
+    await refreshIndexStatus(context, args.includes("--fresh"));
+    showCommandPanel(context, output, buildIndexStatusPanel(context));
+    if (!context.isInkSession) deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "doctor") {
+    await refreshIndexStatus(context, true);
+    showCommandPanel(context, output, buildIndexStatusPanel(context));
+    if (!context.isInkSession) deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "check") {
+    await refreshIndexStatus(context, true);
+    showCommandPanel(context, output, buildIndexStatusPanel(context));
+    if (!context.isInkSession) deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "init" && args[1] === "fast") {
+    const guard = deps().checkBackgroundStartGuard(context, "index", true);
+    if (guard) {
+      writeLine(output, guard);
+      return;
+    }
+    await runIndexRepository(context, "fast", "init fast", args.includes("--force"), output, {
+      guardAlreadyChecked: true
+    });
+    if (context.index.status === "ready") {
+      if (!context.index.safetyWarning) {
+        writeLine(output, formatIndexRefreshSummary(context, "init fast"));
+      }
+    }
+    if (!context.isInkSession) deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "refresh") {
+    const guard = deps().checkBackgroundStartGuard(context, "index", true);
+    if (guard) {
+      writeLine(output, guard);
+      return;
+    }
+    await runIndexRepository(
+      context,
+      context.config.index.mode,
+      "refresh",
+      args.includes("--force"),
+      output,
+      { guardAlreadyChecked: true }
+    );
+    if (context.index.status === "ready") {
+      if (!context.index.safetyWarning) {
+        writeLine(output, formatIndexRefreshSummary(context, "refresh"));
+      }
+    }
+    if (!context.isInkSession) deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "search") {
+    const query = args.slice(1).join(" ").trim();
+    if (!query) {
+      writeLine(output, "\u7528\u6CD5\uFF1A/index search <query>");
+      return;
+    }
+    const result = await runIndexQuery(context, "search_graph", { query, limit: 5 });
+    await recordIndexEvidence(context, `search ${query}`, result.summary);
+    showCommandPanel(context, output, {
+      title: "/index search",
+      tone: result.summary.includes("no matches") && context.index.nodes !== void 0 && context.index.nodes > 0 ? "warning" : "neutral",
+      summary: [
+        context.language === "en-US" ? `Index search result \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u7D22\u5F15\u641C\u7D22\u7ED3\u679C \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: result.summary
+    });
+    deps().writeStatus(output, context);
+    return;
+  }
+  if (action === "architecture") {
+    const result = await runIndexQuery(context, "get_architecture", {});
+    await recordIndexEvidence(context, "architecture", result.summary);
+    showCommandPanel(context, output, {
+      title: "/index architecture",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Index architecture summary \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u7D22\u5F15\u67B6\u6784\u6458\u8981 \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: result.summary
+    });
+    deps().writeStatus(output, context);
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/index status [--fresh] | /index doctor | /index check | /index search <query> | /index architecture\uFF08\u53EA\u8BFB\uFF09 | /index init fast | /index refresh\uFF08\u9700\u786E\u8BA4\uFF09"
+  );
+}
+async function resolveCodebaseMemoryBinary(context) {
+  const configured = context.config.mcp.servers["codebase-memory"];
+  const configuredCommand = configured?.command?.trim();
+  const configuredArgs = configured?.args ?? [];
+  const envCommand = process.env[CODEBASE_MEMORY_ENV]?.trim();
+  if (envCommand) {
+    const spec = await codebaseMemoryCommandSpec(envCommand, []);
+    return probeCodebaseMemoryBinary(spec.command, spec.args, "env", context, spec.detailPath);
+  }
+  if (configuredCommand && configuredCommand !== CODEBASE_MEMORY_COMMAND) {
+    const spec = await codebaseMemoryCommandSpec(configuredCommand, configuredArgs);
+    return probeCodebaseMemoryBinary(spec.command, spec.args, "env", context, spec.detailPath);
+  }
+  const bundled = await findBundledCodebaseMemoryBinary();
+  if (bundled) {
+    return probeCodebaseMemoryBinary(
+      bundled.command,
+      bundled.args,
+      "bundled",
+      context,
+      bundled.detailPath
+    );
+  }
+  const managed = await findManagedCodebaseMemoryBinary(context);
+  if (managed) {
+    return probeCodebaseMemoryBinary(
+      managed.command,
+      managed.args,
+      "managed",
+      context,
+      managed.detailPath
+    );
+  }
+  const pathBinary = await findPathCodebaseMemoryBinary();
+  if (pathBinary) {
+    return probeCodebaseMemoryBinary(
+      pathBinary.command,
+      pathBinary.args,
+      "path",
+      context,
+      pathBinary.detailPath
+    );
+  }
+  const pathProbe = await probeCodebaseMemoryBinary(CODEBASE_MEMORY_COMMAND, [], "path", context);
+  if (pathProbe.status === "missing") {
+    return { ...pathProbe, source: "missing" };
+  }
+  return pathProbe;
+}
+async function codebaseMemoryCommandSpec(command, args) {
+  const lowerCommand = command.toLowerCase();
+  if (lowerCommand.endsWith(".cjs")) {
+    return { command: process.execPath, args: [command, ...args], detailPath: command };
+  }
+  if (process.platform === "win32" && (lowerCommand.endsWith(".cmd") || lowerCommand.endsWith(".bat"))) {
+    const script = await resolveWindowsShimNodeScript(command);
+    if (script) {
+      return {
+        command: process.execPath,
+        args: [script, ...args],
+        detailPath: command
+      };
+    }
+    return {
+      command: "cmd.exe",
+      args: ["/d", "/c", "call", command, ...args],
+      detailPath: command
+    };
+  }
+  if (process.platform === "win32" && lowerCommand.endsWith(".ps1")) {
+    const script = await resolveWindowsShimNodeScript(command);
+    if (script) {
+      return {
+        command: process.execPath,
+        args: [script, ...args],
+        detailPath: command
+      };
+    }
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
+      detailPath: command
+    };
+  }
+  return { command, args, detailPath: command };
+}
+async function resolveWindowsShimNodeScript(command) {
+  let content;
+  try {
+    content = await readFile(command, "utf8");
+  } catch {
+    return void 0;
+  }
+  const dir = dirname(command);
+  const patterns = [
+    /(?:node\.exe|node)["']?\s+"([^"]+\.(?:cjs|mjs|js))"/iu,
+    /(?:node\.exe|node)["']?\s+'([^']+\.(?:cjs|mjs|js))'/iu,
+    /(?:node\.exe|node)["']?\s+([^\s"'`]+\.(?:cjs|mjs|js))/iu
+  ];
+  for (const pattern of patterns) {
+    const raw = pattern.exec(content)?.[1];
+    if (!raw) continue;
+    return resolveShimTarget(dir, raw);
+  }
+  const ps1Match = /(?:&\s*)?\$basedir[\\/ ]*["']?([^"'\r\n]+?\.(?:cjs|mjs|js))["']?/iu.exec(
+    content
+  )?.[1];
+  return ps1Match ? resolveShimTarget(dir, ps1Match) : void 0;
+}
+function resolveShimTarget(dir, rawTarget) {
+  const expanded = rawTarget.replace(/%~dp0/giu, dir.endsWith("\\") || dir.endsWith("/") ? dir : `${dir}\\`).replace(/\$basedir/giu, dir);
+  return resolve(dir, expanded.replace(/^["']|["']$/g, ""));
+}
+async function findManagedCodebaseMemoryBinary(context) {
+  const paths = resolveStoragePaths(context.config, context.projectPath);
+  const candidates = [
+    join(context.projectPath, ".linghun", "bin", CODEBASE_MEMORY_COMMAND),
+    join(paths.index, "bin", CODEBASE_MEMORY_COMMAND),
+    join(paths.userData, "bin", CODEBASE_MEMORY_COMMAND)
+  ];
+  return findCodebaseMemoryBinaryCandidate(candidates);
+}
+async function findBundledCodebaseMemoryBinary() {
+  const roots = getBundledCodebaseMemoryRoots();
+  const platformArch = getCodebaseMemoryPlatformArch();
+  if (!CODEBASE_MEMORY_BUNDLED_PLATFORM_ARCHES.has(platformArch)) {
+    return void 0;
+  }
+  const names = platformArch.startsWith("win32") ? [`${CODEBASE_MEMORY_COMMAND}.exe`, `${CODEBASE_MEMORY_COMMAND}.cjs`] : [CODEBASE_MEMORY_COMMAND, `${CODEBASE_MEMORY_COMMAND}.cjs`];
+  for (const root of roots) {
+    for (const name of names) {
+      const candidate = join(root, platformArch, name);
+      if (await pathExists(candidate)) {
+        return codebaseMemoryCommandSpec(candidate, []);
+      }
+    }
+  }
+  return void 0;
+}
+function getBundledCodebaseMemoryRoots() {
+  const roots = [];
+  if (process.env[CODEBASE_MEMORY_BUNDLED_ENV]) {
+    roots.push(process.env[CODEBASE_MEMORY_BUNDLED_ENV]);
+  }
+  if (process.env[CLI_BUNDLED_ROOT_ENV]) {
+    roots.push(join(process.env[CLI_BUNDLED_ROOT_ENV], "codebase-memory"));
+  }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  roots.push(join(moduleDir, "..", "bundled", "codebase-memory"));
+  roots.push(join(moduleDir, "bundled", "codebase-memory"));
+  return roots;
+}
+function getCodebaseMemoryPlatformArch() {
+  const override = process.env.LINGHUN_CODEBASE_MEMORY_PLATFORM_ARCH_TEST;
+  if (override && CODEBASE_MEMORY_BUNDLED_PLATFORM_ARCHES.has(override)) {
+    return override;
+  }
+  return `${process.platform}-${process.arch}`;
+}
+async function findPathCodebaseMemoryBinary() {
+  const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const candidates = pathDirs.map((dir) => join(dir, CODEBASE_MEMORY_COMMAND));
+  return findCodebaseMemoryBinaryCandidate(candidates);
+}
+async function findCodebaseMemoryBinaryCandidate(candidates) {
+  const suffixes = process.platform === "win32" ? [".cmd", ".exe", ".ps1", ".cjs", ""] : [".cjs", ""];
+  for (const candidate of candidates) {
+    for (const suffix of suffixes) {
+      const path = `${candidate}${suffix}`;
+      if (!await pathExists(path)) {
+        continue;
+      }
+      return await codebaseMemoryCommandSpec(path, []);
+    }
+  }
+  return void 0;
+}
+async function probeCodebaseMemoryBinary(command, args, source, context, detailPath = command) {
+  const result = await runCommandCapture(
+    command,
+    [...args, "--version"],
+    context.projectPath,
+    5e3
+  );
+  if (result.errorCode === "ENOENT") {
+    return {
+      command,
+      args,
+      source,
+      status: "missing",
+      detailPath,
+      summary: "codebase-memory binary not found"
+    };
+  }
+  if (result.exitCode !== 0) {
+    return {
+      command,
+      args,
+      source,
+      status: "corrupt",
+      detailPath,
+      summary: `codebase-memory --version failed: ${result.summary}`
+    };
+  }
+  const version = extractCodebaseMemoryVersion(result.stdout || result.stderr);
+  if (!version) {
+    return {
+      command,
+      args,
+      source,
+      status: "unsupported",
+      detailPath,
+      summary: "codebase-memory --version did not return a supported version string"
+    };
+  }
+  return {
+    command,
+    args,
+    source,
+    status: "ready",
+    version,
+    detailPath,
+    summary: "codebase-memory binary ready"
+  };
+}
+function extractCodebaseMemoryVersion(output) {
+  const compact = output.replace(/\s+/g, " ").trim();
+  const version = compact.match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/)?.[0];
+  if (!version) {
+    return void 0;
+  }
+  return version;
+}
+function rememberCodebaseMemoryResolution(context, resolution) {
+  context.index.binarySource = resolution.source;
+  context.index.binaryStatus = resolution.status;
+  context.index.binaryVersion = resolution.version;
+  context.index.binaryCommand = redactedPath(resolution.detailPath);
+  context.index.runtime = resolution.source === "bundled" ? "bundled codebase-memory" : resolution.source === "managed" ? "Linghun-managed codebase-memory" : resolution.source === "path" ? "external fallback from PATH" : resolution.source === "env" ? "explicit codebase-memory override" : "missing codebase-memory runtime";
+}
+async function getCodebaseMemoryResolution(context) {
+  const resolution = await resolveCodebaseMemoryBinary(context);
+  rememberCodebaseMemoryResolution(context, resolution);
+  return resolution;
+}
+async function runMcpDoctor(context) {
+  for (const server of context.mcp.servers) {
+    if (server.status === "disabled") {
+      continue;
+    }
+    if (server.name !== "codebase-memory") {
+      const result = await runCommandCapture(
+        server.command,
+        ["--version"],
+        context.projectPath,
+        5e3
+      );
+      if (result.exitCode === 0) {
+        server.status = "configured";
+        server.error = void 0;
+        continue;
+      }
+      server.status = result.errorCode === "ENOENT" ? "missing" : "error";
+      server.error = result.summary;
+      continue;
+    }
+    const resolution = await getCodebaseMemoryResolution(context);
+    server.command = redactedPath(resolution.detailPath);
+    server.status = resolution.status === "ready" ? "configured" : resolution.status === "missing" ? "missing" : "error";
+    server.error = resolution.status === "ready" ? void 0 : resolution.summary;
+  }
+  context.mcp.lastDoctor = (/* @__PURE__ */ new Date()).toISOString();
+  const discoveredTools = [];
+  for (const server of context.mcp.servers) {
+    if (server.status !== "configured") continue;
+    if (server.name === "codebase-memory") {
+      discoveredTools.push(...createMcpToolPlaceholders(server.name, "discovered"));
+      continue;
+    }
+    const serverConfig = context.config.mcp.servers[server.name];
+    if (!isLocalStdioMcpServer(serverConfig)) {
+      discoveredTools.push(...createMcpToolPlaceholders(server.name, "discovered"));
+      continue;
+    }
+    const listResult = await runMcpStdioToolList(
+      serverConfig,
+      context.projectPath
+    );
+    if (listResult.ok && listResult.toolNames.length > 0) {
+      for (const toolName of listResult.toolNames) {
+        discoveredTools.push({
+          server: server.name,
+          name: toolName,
+          description: `MCP tool ${server.name}:${toolName}`,
+          discovery: "discovered",
+          trusted: true,
+          schemaLoaded: true,
+          runtimeVersion: "compatible"
+        });
+      }
+    } else {
+      discoveredTools.push({
+        server: server.name,
+        name: `${server.name}.status`,
+        description: `MCP server tools/list failed: ${truncateDisplay(listResult.summary, 80)}`,
+        discovery: "placeholder",
+        trusted: false,
+        schemaLoaded: false,
+        runtimeVersion: "unknown"
+      });
+    }
+  }
+  context.mcp.tools = stabilizeMcpToolList(discoveredTools);
+  refreshCacheFreshness(context);
+}
+function validateMcpServers(context, id) {
+  const servers = id ? context.mcp.servers.filter((server) => server.name === id) : context.mcp.servers;
+  if (servers.length === 0) {
+    return id ? `\u672A\u627E\u5230 MCP server\uFF1A${id}` : "\u6CA1\u6709 MCP server \u914D\u7F6E\u3002";
+  }
+  return [
+    "MCP validate",
+    ...servers.map((server) => {
+      const config = context.config.mcp.servers[server.name];
+      const problems = [];
+      if (!config) problems.push("not registered");
+      if (server.status === "disabled") problems.push("disabled");
+      if (server.status === "missing") problems.push("missing binary");
+      if (server.status === "error") problems.push("doctor error");
+      if (config?.trustLevel === "untrusted") problems.push("untrusted");
+      return `- ${server.name}: ${problems.length === 0 ? "ok" : problems.join("; ")}; source ${config?.sourceUrl ? sanitizeDiagnosticText(config.sourceUrl) : redactedPath(config?.localPath ?? config?.command)}; ref ${config?.ref ?? "-"}; commit ${config?.commit ?? "-"}; permissions ${config?.permissionSummary ?? "tool-discovery"}; next ${problems.length === 0 ? "tools/status available" : "run /mcp doctor, then validate/enable after fixing"}`;
+    })
+  ].join("\n");
+}
+async function addMcpServer(args, context) {
+  const [source, id, command, ...commandArgs] = args;
+  if (source === "sse" && id && command) {
+    const server2 = {
+      command: "",
+      url: command,
+      transport: "sse",
+      sourceUrl: command,
+      scope: "project",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      disabled: true,
+      trustLevel: "untrusted",
+      permissionSummary: "tool-discovery"
+    };
+    context.config = await saveMcpServerConfig(id, server2, false, context.projectPath);
+    context.mcp = createMcpState(context.config);
+    refreshCacheFreshness(context);
+    return `\u5DF2\u6DFB\u52A0 MCP SSE server\uFF1A${id}\uFF1B\u9ED8\u8BA4 untrusted/disabled\uFF0C\u672A\u8FDE\u63A5\u8FDC\u7A0B endpoint\u3002\u4E0B\u4E00\u6B65\u8FD0\u884C /mcp validate ${id}\uFF1B\u786E\u8BA4\u4FE1\u4EFB\u540E\u518D\u8FD0\u884C /mcp enable ${id}\u3002`;
+  }
+  if (source !== "local" || !id || !command) {
+    return [
+      "MCP add\uFF08Connect Lite\uFF09",
+      "- usage: /mcp add local <server-id> <command> [args...]",
+      "- usage: /mcp add sse <server-id> <url>",
+      "- \u672C\u9636\u6BB5 MCP \u652F\u6301\u672C\u5730 command \u4E0E SSE endpoint metadata\uFF1BGit/GitHub install \u53EA\u7528\u4E8E skills/plugins\u3002",
+      "- add \u53EA\u5199\u6765\u6E90/\u6743\u9650\u8BB0\u5F55\uFF0C\u4E0D\u6267\u884C server\uFF1B\u8FD0\u884C /mcp doctor \u624D\u505A\u53D7\u63A7 --version \u8BCA\u65AD\u3002"
+    ].join("\n");
+  }
+  const server = {
+    command,
+    args: commandArgs,
+    localPath: command,
+    scope: "project",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    disabled: true,
+    trustLevel: "untrusted",
+    permissionSummary: "tool-discovery"
+  };
+  context.config = await saveMcpServerConfig(id, server, false, context.projectPath);
+  context.mcp = createMcpState(context.config);
+  refreshCacheFreshness(context);
+  return `\u5DF2\u6DFB\u52A0 MCP server\uFF1A${id}\uFF1B\u9ED8\u8BA4 untrusted/disabled\uFF0C\u672A\u6267\u884C server\u3002\u4E0B\u4E00\u6B65\u8FD0\u884C /mcp validate ${id} \u6216 /mcp doctor\uFF1B\u786E\u8BA4\u4FE1\u4EFB\u540E\u518D\u8FD0\u884C /mcp enable ${id}\u3002`;
+}
+async function setMcpServerEnabled(id, enabled, context) {
+  const current = context.config.mcp.servers[id];
+  if (!current) {
+    return `\u672A\u627E\u5230 MCP server\uFF1A${id}`;
+  }
+  const nextTrustLevel = enabled ? "trusted" : "disabled";
+  context.config = await saveMcpServerConfig(
+    id,
+    { ...current, disabled: !enabled, trustLevel: nextTrustLevel },
+    enabled,
+    context.projectPath
+  );
+  context.mcp = createMcpState(context.config);
+  refreshCacheFreshness(context);
+  const trustNotice = enabled ? "Trust notice\uFF1A\u5373\u5C06\u542F\u7528\u672C\u5730 MCP server\uFF1BLinghun \u4E0D\u4F1A\u5728 enable \u65F6\u6267\u884C server\uFF0C\u4F46\u540E\u7EED tools/call \u4ECD\u5FC5\u987B\u7ECF\u8FC7 discovery/schema/required-args \u548C\u6743\u9650\u7BA1\u9053\u3002" : "";
+  return [
+    trustNotice,
+    `${enabled ? "\u5DF2\u542F\u7528" : "\u5DF2\u7981\u7528"} MCP server\uFF1A${id}\uFF1B\u5931\u8D25\u53EF\u901A\u8FC7 /mcp doctor \u9694\u79BB\u8BCA\u65AD\u3002`
+  ].filter(Boolean).join("\n");
+}
+async function updateMcpServer(args, context) {
+  const [id, source, command, ...commandArgs] = args;
+  const current = id ? context.config.mcp.servers[id] : void 0;
+  if (!id || source !== "local" && source !== "sse" || !command) {
+    return "\u7528\u6CD5\uFF1A/mcp update <server-id> local <command> [args...] \u6216 /mcp update <server-id> sse <url>\uFF1BConnect Lite \u4E0D\u6267\u884C server\uFF0C\u53EA\u66F4\u65B0 metadata\u3002";
+  }
+  if (!current) {
+    return `\u672A\u627E\u5230 MCP server\uFF1A${id}`;
+  }
+  if (source === "sse") {
+    const server2 = {
+      ...current,
+      command: "",
+      args: [],
+      url: command,
+      transport: "sse",
+      sourceUrl: command,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      disabled: current.disabled ?? !context.config.mcp.enabledServers.includes(id),
+      trustLevel: current.trustLevel ?? (current.disabled ? "disabled" : "untrusted"),
+      permissionSummary: current.permissionSummary ?? "tool-discovery"
+    };
+    context.config = await saveMcpServerConfig(id, server2, !server2.disabled, context.projectPath);
+    context.mcp = createMcpState(context.config);
+    refreshCacheFreshness(context);
+    return `\u5DF2\u66F4\u65B0 MCP SSE server\uFF1A${id}\uFF1B\u53EA\u66F4\u65B0 endpoint metadata\uFF0C\u672A\u8FDE\u63A5\u8FDC\u7A0B server\u3002\u4E0B\u4E00\u6B65\u8FD0\u884C /mcp validate ${id} \u6216 /mcp doctor\u3002`;
+  }
+  const server = {
+    ...current,
+    command,
+    args: commandArgs,
+    localPath: command,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    disabled: current.disabled ?? !context.config.mcp.enabledServers.includes(id),
+    trustLevel: current.trustLevel ?? (current.disabled ? "disabled" : "untrusted"),
+    permissionSummary: current.permissionSummary ?? "tool-discovery"
+  };
+  context.config = await saveMcpServerConfig(id, server, !server.disabled, context.projectPath);
+  context.mcp = createMcpState(context.config);
+  refreshCacheFreshness(context);
+  return `\u5DF2\u66F4\u65B0 MCP server\uFF1A${id}\uFF1B\u53EA\u66F4\u65B0\u672C\u5730 command metadata\uFF0C\u672A\u6267\u884C server\u3002\u4E0B\u4E00\u6B65\u8FD0\u884C /mcp validate ${id} \u6216 /mcp doctor\u3002`;
+}
+async function removeMcpServer(id, context) {
+  if (!context.config.mcp.servers[id]) {
+    return `\u672A\u627E\u5230 MCP server\uFF1A${id}`;
+  }
+  context.config = await removeMcpServerConfig(id, context.projectPath);
+  context.mcp = createMcpState(context.config);
+  refreshCacheFreshness(context);
+  return `\u5DF2\u79FB\u9664 MCP server\uFF1A${id}\uFF1B\u5DF2\u6709\u666E\u901A\u804A\u5929\u548C\u672C\u5730\u5DE5\u5177\u4E0D\u53D7\u5F71\u54CD\u3002`;
+}
+async function refreshIndexStatus(context, fresh = false) {
+  if (!context.index.enabled) {
+    context.index.status = "disabled";
+    context.index.artifactStatus = "disabled";
+    context.index.error = "codebase index is disabled in settings.";
+    context.index.projectName = void 0;
+    context.index.projectSelectionSource = "missing";
+    context.index.safetyRiskyFiles = void 0;
+    context.index.safetyAction = void 0;
+    return;
+  }
+  await refreshLocalIndexArtifactState(context);
+  const resolution = await getCodebaseMemoryResolution(context);
+  if (resolution.status !== "ready") {
+    context.index.status = context.index.artifactStatus === "ready" ? "unknown-project" : context.index.artifactStatus === "corrupt" ? "error" : "missing";
+    const artifactError = context.index.error;
+    context.index.artifactStatus = context.index.artifactStatus ?? "unknown";
+    context.index.error = `${resolution.summary}\u3002\u666E\u901A\u804A\u5929\u4E0D\u53D7\u5F71\u54CD\uFF1B\u5982\u9700\u7D22\u5F15\uFF0C\u8BF7\u914D\u7F6E ${CODEBASE_MEMORY_ENV} \u6216\u5B89\u88C5 Linghun-managed codebase-memory\u3002`;
+    if (context.index.status === "error" && artifactError) {
+      context.index.error = artifactError;
+    }
+    if (context.index.status === "missing") context.index.projectName = void 0;
+    context.index.projectSelectionSource = "missing";
+    context.index.safetyRiskyFiles = void 0;
+    context.index.safetyAction = void 0;
+    return;
+  }
+  const projects = await runCodebaseMemoryCli(context, "list_projects", {}, context.projectPath);
+  if (!projects.ok) {
+    context.index.status = projects.errorCode === "ENOENT" ? "missing" : "error";
+    context.index.artifactStatus = projects.errorCode === "ENOENT" ? "missing" : "corrupt";
+    context.index.error = projects.summary;
+    context.index.projectName = void 0;
+    context.index.projectSelectionSource = "missing";
+    context.index.safetyRiskyFiles = void 0;
+    context.index.safetyAction = void 0;
+    return;
+  }
+  const project = findCurrentIndexProject(projects.data, context.projectPath);
+  if (!project) {
+    await refreshLocalIndexArtifactState(context);
+    context.index.status = context.index.artifactStatus === "ready" ? "unknown-project" : context.index.artifactStatus === "corrupt" ? "error" : "missing";
+    context.index.artifactStatus = context.index.artifactStatus === "ready" || context.index.artifactStatus === "corrupt" ? context.index.artifactStatus : "missing";
+    context.index.projectSelectionSource = "missing";
+    context.index.error = context.index.status === "error" ? context.index.error ?? "\u672C\u5730 codebase-memory artifact \u635F\u574F\u3002" : context.index.status === "unknown-project" ? "\u68C0\u6D4B\u5230\u672C\u5730 .codebase-memory/graph.db.zst\uFF0C\u4F46 codebase-memory list_projects \u672A\u80FD\u5339\u914D\u5F53\u524D\u9879\u76EE\u3002\u8BF7\u8FD0\u884C /index status --fresh \u6216 /index refresh \u91CD\u65B0\u7ED1\u5B9A\u9879\u76EE\u3002" : "\u672A\u627E\u5230\u5F53\u524D\u9879\u76EE\u7D22\u5F15\u3002\u8BF7\u8FD0\u884C /index init fast \u5EFA\u7ACB\u7D22\u5F15\u3002";
+    context.index.safetyRiskyFiles = void 0;
+    context.index.safetyAction = void 0;
+    return;
+  }
+  context.index.projectName = project.name;
+  context.index.artifactPath = project.rootPath;
+  context.index.projectSelectionSource = project.source;
+  const status = await runCodebaseMemoryCli(
+    context,
+    "index_status",
+    { project: project.name },
+    context.projectPath
+  );
+  if (!status.ok) {
+    context.index.status = "error";
+    context.index.artifactStatus = "corrupt";
+    context.index.error = status.summary;
+    context.index.safetyRiskyFiles = void 0;
+    context.index.safetyAction = void 0;
+    return;
+  }
+  const data = status.data;
+  context.index.status = data.status === "ready" ? "ready" : "stale";
+  context.index.artifactStatus = data.status === "ready" ? "ready" : "stale";
+  context.index.nodes = data.nodes;
+  context.index.edges = data.edges;
+  context.index.error = void 0;
+  context.index.changedFiles = void 0;
+  context.index.staleHint = fresh ? void 0 : "fast status\uFF1A\u672A\u8FD0\u884C detect_changes\uFF1B\u9700\u8981\u65B0\u9C9C\u5EA6\u68C0\u67E5\u8BF7\u7528 /index status --fresh \u6216 /index check\u3002";
+  context.index.safetyWarning = void 0;
+  context.index.safetyRiskyFiles = void 0;
+  context.index.safetyAction = void 0;
+  if (fresh) {
+    await refreshIndexStaleHint(context, project.name);
+  }
+}
+async function refreshLocalIndexArtifactState(context) {
+  const artifact = await readLocalIndexArtifactState(context.projectPath);
+  context.index.artifactStatus = artifact.status === "ready" ? "ready" : artifact.status;
+  context.index.artifactPath = artifact.artifactPath;
+  if (artifact.status === "ready") {
+    context.index.projectName = context.index.projectName ?? artifact.projectName;
+    context.index.nodes = context.index.nodes ?? artifact.nodes;
+    context.index.edges = context.index.edges ?? artifact.edges;
+    context.index.indexedAt = context.index.indexedAt ?? artifact.indexedAt;
+    return;
+  }
+  if (artifact.status === "corrupt") {
+    context.index.error = artifact.error;
+  }
+}
+async function refreshIndexStaleHint(context, projectName) {
+  const changes = await runCodebaseMemoryCli(
+    context,
+    "detect_changes",
+    { project: projectName },
+    context.projectPath,
+    15e3
+  );
+  if (!changes.ok) {
+    context.index.staleHint = `detect_changes \u4E0D\u53EF\u7528\uFF1A${changes.summary}\u3002/index status \u4ECD\u6309 index_status \u5C55\u793A\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u5237\u65B0\u3002`;
+    return;
+  }
+  const data = changes.data;
+  const changedCount = typeof data.changed_count === "number" ? data.changed_count : Array.isArray(data.changed_files) ? data.changed_files.length : 0;
+  context.index.changedFiles = changedCount;
+  if (changedCount > 0) {
+    context.index.status = "stale";
+    context.index.artifactStatus = "stale";
+    context.index.staleHint = `detect_changes \u53D1\u73B0 ${changedCount} \u4E2A\u53D8\u66F4\u6587\u4EF6\uFF0C\u5EFA\u8BAE\u8FD0\u884C /index refresh\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u5237\u65B0\u3002`;
+    return;
+  }
+  context.index.staleHint = "detect_changes \u672A\u53D1\u73B0\u53D8\u66F4\uFF1B/index refresh \u4ECD\u53EA\u5728\u7528\u6237\u663E\u5F0F\u6267\u884C\u65F6\u8FD0\u884C\u3002";
+}
+async function runIndexRepository(context, mode, actionLabel, force, output, options = {}) {
+  if (!options.guardAlreadyChecked) {
+    const guard = deps().checkBackgroundStartGuard(context, "index", true);
+    if (guard) {
+      context.index.status = "error";
+      context.index.error = guard;
+      writeLine(output, guard);
+      return;
+    }
+  }
+  const safety = await scanIndexSafety(context.projectPath);
+  const transientExcludes = !force && safety.riskyFiles.length > 0 ? createIndexTransientExcludes(safety) : [];
+  context.index.safetyWarning = void 0;
+  context.index.safetyRiskyFiles = safety.riskyFiles.length > 0 ? safety.riskyFiles : void 0;
+  context.index.safetyAction = safety.riskyFiles.length > 0 ? actionLabel : void 0;
+  context.index.error = void 0;
+  context.index.status = "indexing";
+  if (transientExcludes.length > 0) {
+    await recordIndexEvidence(
+      context,
+      `auto-skip:${actionLabel}`,
+      formatIndexAutoSkipDetails(safety, actionLabel, context.language),
+      transientExcludes.map((file) => `skipped_file:${file}`)
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const task = {
+    id: `index-${randomUUID().slice(0, 8)}`,
+    kind: "index",
+    title: `Index ${actionLabel}`,
+    status: "running",
+    currentStep: "index_repository",
+    progress: { completed: 0, total: 1, label: "index" },
+    startedAt: now,
+    updatedAt: now,
+    heartbeatIntervalMs: 3e4,
+    staleAfterMs: 12e4,
+    hasOutput: false,
+    userVisibleSummary: `\u7D22\u5F15${actionLabel === "refresh" ? "\u5237\u65B0" : "\u521D\u59CB\u5316"}\u6B63\u5728\u6267\u884C\u3002`,
+    nextAction: "\u7B49\u5F85\u5B8C\u6210\uFF0C\u6216\u7528 /interrupt \u6807\u8BB0\u53D6\u6D88\u540E\u68C0\u67E5 /index status\u3002"
+  };
+  const sessionId = await deps().ensureSession(context);
+  deps().rememberBackgroundTask(context, task);
+  await deps().appendBackgroundTaskEvent(context, sessionId, task);
+  const result = await runCodebaseMemoryCli(
+    context,
+    "index_repository",
+    {
+      repo_path: context.projectPath,
+      mode,
+      persistence: true,
+      ...transientExcludes.length > 0 ? {
+        transient_exclude_paths: transientExcludes,
+        skip_paths: transientExcludes
+      } : {}
+    },
+    context.projectPath,
+    12e4
+  );
+  const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  task.updatedAt = endedAt;
+  task.lastOutputAt = endedAt;
+  task.hasOutput = Boolean(result.ok || result.summary);
+  if (!result.ok) {
+    context.index.status = result.errorCode === "ENOENT" ? "missing" : "error";
+    context.index.error = `${result.summary}\u3002\u8BF7\u786E\u8BA4\u7D22\u5F15\u8FD0\u884C\u65F6\u53EF\u7528\uFF0C\u4FEE\u590D\u540E\u91CD\u8BD5\u3002`;
+    task.status = result.summary.includes("\u547D\u4EE4\u8D85\u65F6") ? "timeout" : "failed";
+    task.result = task.status === "timeout" ? "timeout" : "fail";
+    task.currentStep = task.status === "timeout" ? "timeout" : "index failed";
+    task.progress = { completed: 1, total: 1, label: "index" };
+    task.userVisibleSummary = `Index ${task.status}: ${context.index.error}`;
+    task.nextAction = "\u67E5\u770B /index status\uFF0C\u4FEE\u590D runtime/artifact \u540E\u91CD\u8BD5\uFF1B\u4E0D\u5F97\u58F0\u79F0\u7D22\u5F15\u5237\u65B0\u6210\u529F\u3002";
+    await deps().appendBackgroundTaskEvent(context, sessionId, task);
+    writeLine(output, `Index: ${context.index.status}. ${context.index.error}`);
+    return;
+  }
+  await refreshIndexStatus(context);
+  const statusAfterRefresh = context.index.status;
+  if (statusAfterRefresh === "missing" || statusAfterRefresh === "unknown" || statusAfterRefresh === "error") {
+    context.index.status = "refresh_completed_but_unverified";
+    context.index.artifactStatus = "stale";
+    context.index.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+    context.index.error = void 0;
+    context.index.staleHint = context.language === "en-US" ? "Index refresh command completed, but status read-back/freshness was not verified. Run /index status --fresh to confirm." : "\u7D22\u5F15\u5237\u65B0\u547D\u4EE4\u5DF2\u5B8C\u6210\uFF0C\u4F46\u72B6\u6001\u8BFB\u56DE/\u65B0\u9C9C\u5EA6\u5C1A\u672A\u9A8C\u8BC1\u3002\u8FD0\u884C /index status --fresh \u53EF\u786E\u8BA4\u3002";
+  } else {
+    context.index.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  task.status = "completed";
+  task.result = "pass";
+  task.currentStep = "index finished";
+  task.progress = { completed: 1, total: 1, label: "index" };
+  task.userVisibleSummary = `Index ${actionLabel} completed: ${context.index.status}`;
+  task.nextAction = "\u7528 /index status \u67E5\u770B\u8BE6\u60C5\uFF1B\u9700\u8981\u65B0\u9C9C\u5EA6\u68C0\u67E5\u65F6\u7528 /index status --fresh\u3002";
+  await deps().appendBackgroundTaskEvent(context, sessionId, task);
+  if (transientExcludes.length > 0) {
+    const detailsText = formatIndexAutoSkipDetails(safety, actionLabel, context.language);
+    context.index.safetyWarning = formatIndexAutoSkipPrimary(
+      safety,
+      context.index.status,
+      actionLabel,
+      context.language
+    );
+    context.index.safetyRiskyFiles = safety.riskyFiles;
+    context.index.safetyAction = actionLabel;
+    await recordIndexEvidence(
+      context,
+      `auto-skip-result:${actionLabel}`,
+      detailsText,
+      transientExcludes.map((file) => `skipped_file:${file}`)
+    );
+    context.lastFullOutput = detailsText;
+    writeLine(output, context.index.safetyWarning);
+    writeLine(output, formatIndexAutoSkipNextAction(context.language));
+  }
+}
+async function runIndexQuery(context, tool, input) {
+  await refreshIndexStatus(context);
+  if (context.index.status !== "ready" || !context.index.projectName) {
+    const summary2 = formatIndexStatus(context);
+    return { summary: summary2 };
+  }
+  const result = await runCodebaseMemoryCli(
+    context,
+    tool,
+    { project: context.index.projectName, ...input },
+    context.projectPath
+  );
+  if (!result.ok) {
+    context.index.status = result.errorCode === "ENOENT" ? "missing" : "error";
+    context.index.error = result.summary;
+    return { summary: formatIndexStatus(context) };
+  }
+  const summary = summarizeIndexResult(tool, result.data);
+  context.index.lastQuery = tool === "search_code" || tool === "search_graph" ? String(input.pattern ?? input.query ?? "") : "architecture";
+  context.index.lastSummary = summary;
+  return { summary };
+}
+async function recordIndexEvidence(context, query, summary, supportsClaims = []) {
+  const supportsIndexCodeFact = isSupportiveIndexEvidence(context, query, summary);
+  const isSupplementalEvidence = supportsClaims.length > 0;
+  if (!supportsIndexCodeFact && !isSupplementalEvidence) {
+    return;
+  }
+  const sessionId = await deps().ensureSession(context);
+  const evidence = {
+    id: randomUUID(),
+    kind: "index_query",
+    summary: truncateDisplay(summary.replace(/\s+/g, " "), 160),
+    source: `codebase-memory:${context.index.projectName ?? "unknown"}:${query}`,
+    supportsClaims: [
+      "index_query",
+      ...supportsIndexCodeFact ? ["index_code_fact"] : [],
+      query,
+      ...supportsClaims
+    ],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  deps().rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, { type: "evidence_record", ...evidence });
+}
+function isSupportiveIndexEvidence(context, query, summary) {
+  if (context.index.status !== "ready" || !context.index.projectName) {
+    return false;
+  }
+  const text = `${query}
+${summary}`;
+  if (/(?:missing|stale|error|not ready|no matches|status[:=\s]+(?:missing|stale|error))/iu.test(text)) {
+    return false;
+  }
+  return /(?:\bpath\s*(?:=|:|\s)\s*(?!unknown\b|-)(?:[^\s,;]+)|\bfile_path\s*[:=]\s*(?!unknown\b|-)(?:[^\s,;]+)|\bfile:\s*(?!unknown\b|-)(?:[^\s,;]+)|\bsymbol\s*(?:=|:|\s)\s*(?!unknown\b|-)(?:[^\s,;]+)|\bsnippet\s*=\s*(?!\s*$).+|\bmatch\s*=\s*(?!\s*$).+)/imu.test(
+    text
+  );
+}
+async function runCodebaseMemoryCli(context, tool, input, cwd, timeoutMs = 3e4) {
+  const guard = validateCodebaseMemoryToolExecution(tool, input);
+  if (!guard.ok) {
+    return { ok: false, summary: guard.summary };
+  }
+  const resolution = await getCodebaseMemoryResolution(context);
+  if (resolution.status !== "ready") {
+    return { ok: false, summary: resolution.summary, errorCode: resolution.status };
+  }
+  const result = await runCommandCapture(
+    resolution.command,
+    [...resolution.args, "cli", tool, JSON.stringify(input)],
+    cwd,
+    timeoutMs
+  );
+  if (result.exitCode !== 0) {
+    return { ok: false, summary: result.summary, errorCode: result.errorCode };
+  }
+  const jsonLine = [...result.stdout.trim().split(/\r?\n/)].reverse().find((line) => line.trim().startsWith("{"));
+  if (!jsonLine) {
+    return { ok: false, summary: "codebase-memory-mcp \u672A\u8FD4\u56DE JSON\u3002" };
+  }
+  try {
+    return { ok: true, data: JSON.parse(jsonLine) };
+  } catch (error) {
+    return { ok: false, summary: `\u65E0\u6CD5\u89E3\u6790 codebase-memory-mcp \u8F93\u51FA\uFF1A${formatError(error)}` };
+  }
+}
+function executeSearchExtraTools(query, context) {
+  const all = listDeferredTools(context);
+  const filtered = searchDeferredTools(query, all);
+  for (const tool of filtered) {
+    context.discoveredDeferredToolNames.add(tool.name);
+  }
+  return {
+    ok: true,
+    text: `SearchExtraTools matched ${filtered.length}/${all.length} deferred tools (query=${JSON.stringify(query)}).`,
+    data: { matches: filtered.map(summarizeDeferredToolMatch), total: filtered.length }
+  };
+}
+async function executeExtraTool(args, context) {
+  if (typeof args.tool_name !== "string" || args.tool_name.trim() === "") {
+    return {
+      ok: false,
+      text: "ExecuteExtraTool: tool_name \u7F3A\u5931\u6216\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u8FD0\u884C SearchExtraTools \u627E\u5230\u76EE\u6807\u5DE5\u5177\u3002"
+    };
+  }
+  if (!context.discoveredDeferredToolNames.has(args.tool_name)) {
+    return {
+      ok: false,
+      text: `ExecuteExtraTool: \u5DE5\u5177 ${args.tool_name} \u672A\u5728\u672C session \u901A\u8FC7 SearchExtraTools \u53D1\u73B0\u8FC7\u3002\u8BF7\u5148\u8FD0\u884C SearchExtraTools \u53D1\u73B0\u8BE5\u5DE5\u5177\u3002`
+    };
+  }
+  const all = listDeferredTools(context);
+  const target = findDeferredTool(args.tool_name, all);
+  if (!target) {
+    return {
+      ok: false,
+      text: `ExecuteExtraTool: \u5DE5\u5177 ${args.tool_name} \u5DF2\u88AB\u672C session \u8BB0\u4E3A\u53D1\u73B0\u8FC7\uFF0C\u4F46\u5DF2\u4E0D\u5728\u5F53\u524D\u53EF\u7528 deferred \u5DE5\u5177\u6E05\u5355\u4E2D\uFF08\u767D\u540D\u5355\u6216\u4F1A\u8BDD\u72B6\u6001\u53EF\u80FD\u5DF2\u53D8\u5316\uFF09\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C SearchExtraTools\u3002`
+    };
+  }
+  if (!target.executable) {
+    return {
+      ok: false,
+      text: `ExecuteExtraTool: \u5DE5\u5177 ${target.name} (${target.kind}) \u5DF2\u53D1\u73B0\u4F46\u5F53\u524D\u6CA1\u6709\u5B89\u5168\u6267\u884C\u9002\u914D\u5668\uFF1A${target.reason}`
+    };
+  }
+  const params = args.params && typeof args.params === "object" && !Array.isArray(args.params) ? args.params : {};
+  if (target.kind === "codebase-memory") {
+    if (!isCodebaseMemoryToolName(target.name)) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool: ${target.name} \u672A\u901A\u8FC7 codebase-memory \u767D\u540D\u5355\u3002`
+      };
+    }
+    const guard = validateCodebaseMemoryToolExecution(target.name, params);
+    if (!guard.ok) {
+      return { ok: false, text: guard.summary };
+    }
+    const risk = getCodebaseMemoryToolRisk(target.name);
+    if (risk === "mutating" && !context.codebaseMemoryMutatingGranted) {
+      return {
+        ok: false,
+        text: "\u8BE5\u7D22\u5F15\u5199\u5165\u52A8\u4F5C\u4E0D\u80FD\u901A\u8FC7\u901A\u7528\u5DE5\u5177\u5165\u53E3\u6267\u884C\u3002\u8BF7\u4F7F\u7528 /index refresh \u6216\u8BA9\u6A21\u578B\u53D1\u8D77\u7ED3\u6784\u5316\u7684\u4EE3\u7801\u7D22\u5F15\u5237\u65B0\u5DE5\u5177\uFF1B\u6267\u884C\u65F6\u4ECD\u4F1A\u8D70 Linghun \u6743\u9650\u8FB9\u754C\u3002"
+      };
+    }
+    const cliResult = await runCodebaseMemoryCli(context, target.name, params, context.projectPath);
+    if (!cliResult.ok) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool(codebase-memory:${target.name}) \u5931\u8D25\uFF1A${cliResult.summary}${cliResult.errorCode ? ` [${cliResult.errorCode}]` : ""}`
+      };
+    }
+    return {
+      ok: true,
+      text: `ExecuteExtraTool(codebase-memory:${target.name}) \u5B8C\u6210\u3002`,
+      data: cliResult.data
+    };
+  }
+  if (target.kind === "mcp") {
+    const parsed = parseMcpDeferredToolName(target.name);
+    if (!parsed) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool: \u65E0\u6CD5\u89E3\u6790 MCP \u5DE5\u5177\u540D ${target.name}\uFF0C\u671F\u671B\u683C\u5F0F mcp:<server>:<tool>\u3002`
+      };
+    }
+    const serverConfig = context.config.mcp.servers[parsed.server];
+    const isSse = serverConfig?.transport === "sse" && typeof serverConfig.url === "string";
+    if (!isLocalStdioMcpServer(serverConfig) && !isSse) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool: MCP server ${parsed.server} \u4E0D\u662F\u672C\u5730 stdio \u6216 SSE\uFF08\u7F3A\u5C11 command/url \u6216\u5DF2\u7981\u7528\uFF09\u3002`
+      };
+    }
+    if (!context.mcpStdioMutatingGranted && isPotentiallyMutatingMcpTool(parsed.tool)) {
+      return {
+        ok: false,
+        text: "\u8BE5 MCP \u5DE5\u5177\u770B\u8D77\u6765\u4F1A\u4FEE\u6539\u5DE5\u4F5C\u533A\uFF0C\u4E0D\u80FD\u901A\u8FC7\u901A\u7528\u5DE5\u5177\u5165\u53E3\u76F4\u63A5\u6267\u884C\u3002\u8BF7\u6539\u7528\u660E\u786E\u7684\u53D7\u63A7\u547D\u4EE4\u6216\u8BA9\u6A21\u578B\u53D1\u8D77\u5BF9\u5E94\u7ED3\u6784\u5316\u5DE5\u5177\uFF1B\u6267\u884C\u65F6\u4ECD\u4F1A\u8D70 Linghun \u6743\u9650\u8FB9\u754C\u3002"
+      };
+    }
+    const result = isSse ? await runMcpSseToolCall(serverConfig, parsed.tool, params) : await runMcpStdioToolCall(
+      serverConfig,
+      parsed.tool,
+      params,
+      context.projectPath
+    );
+    if (!result.ok) {
+      return {
+        ok: false,
+        text: `ExecuteExtraTool(${target.name}) \u5931\u8D25\uFF1A${result.summary}${result.errorCode ? ` [${result.errorCode}]` : ""}`
+      };
+    }
+    return {
+      ok: true,
+      text: `ExecuteExtraTool(${target.name}) \u5B8C\u6210\u3002`,
+      data: result.data
+    };
+  }
+  return {
+    ok: false,
+    text: `ExecuteExtraTool: \u5DE5\u5177 ${target.name} (${target.kind}) \u6CA1\u6709\u53EF\u7528\u7684\u5B89\u5168\u6267\u884C\u9002\u914D\u5668\u3002`
+  };
+}
+function stabilizeMcpToolList(tools) {
+  return tools.map((tool) => ({
+    server: tool.server,
+    name: tool.name,
+    description: truncateDisplay(tool.description.replace(/\s+/g, " "), 120),
+    discovery: tool.discovery ?? "placeholder",
+    trusted: tool.trusted ?? false,
+    schemaLoaded: tool.schemaLoaded ?? false,
+    runtimeVersion: tool.runtimeVersion ?? "unknown"
+  })).sort((a, b) => `${a.server}:${a.name}`.localeCompare(`${b.server}:${b.name}`));
+}
+
+export {
+  configureMcpIndexRuntime,
+  handleMcpCommand,
+  handleIndexCommand,
+  resolveCodebaseMemoryBinary,
+  codebaseMemoryCommandSpec,
+  findManagedCodebaseMemoryBinary,
+  findBundledCodebaseMemoryBinary,
+  getBundledCodebaseMemoryRoots,
+  getCodebaseMemoryPlatformArch,
+  findPathCodebaseMemoryBinary,
+  findCodebaseMemoryBinaryCandidate,
+  probeCodebaseMemoryBinary,
+  extractCodebaseMemoryVersion,
+  rememberCodebaseMemoryResolution,
+  getCodebaseMemoryResolution,
+  runMcpDoctor,
+  validateMcpServers,
+  addMcpServer,
+  setMcpServerEnabled,
+  updateMcpServer,
+  removeMcpServer,
+  refreshIndexStatus,
+  refreshLocalIndexArtifactState,
+  refreshIndexStaleHint,
+  runIndexRepository,
+  runIndexQuery,
+  recordIndexEvidence,
+  isSupportiveIndexEvidence,
+  runCodebaseMemoryCli,
+  executeSearchExtraTools,
+  executeExtraTool,
+  stabilizeMcpToolList
+};