micro-models-agent 2.10.0 → 2.12.0

package/dist/modules/lsp/project-root.js

@@ -1,19 +1,7 @@
+// Корень LSP-workspace по маркерам и поиск локального tsc вверх по node_modules.
 import { existsSync } from "fs";
 import { dirname, join, relative, isAbsolute } from "path";
 import { platform } from "os";
-/**
- * Resolve the LSP workspace root for an edited file.
- *
- * The workspace root must be the nearest project of the *edited file*, not the
- * agent baseDir — tsserver resolves `typescript` relative to the workspace
- * root, so for a file in `bicycle-shop/src/x.ts` under baseDir `mma_tests` the
- * root must be `bicycle-shop` (observed: "Could not find a valid TypeScript
- * installation" on every write/edit because baseDir had no node_modules).
- *
- * Which files mark a project root is language-specific and is declared in the
- * LSP server config (`LspServerConfig.workspaceMarkers`) — this function takes
- * the markers as a parameter and performs no language detection itself.
- */
 /**
  * Находит локальный компилятор TypeScript, поднимаясь от `startDir` вверх по
  * `node_modules`. Возвращает готовую команду или null, если tsc не установлен.
@@ -47,16 +35,25 @@ export function resolveTscCommand(startDir, maxLevels = 8) {
     }
     return null;
 }
+/**
+ * Корень LSP-workspace для редактируемого файла.
+ * Корень — ближайший проект *редактируемого файла*, не baseDir агента:
+ * tsserver резолвит `typescript` от корня workspace (наблюдалось: "Could not
+ * find a valid TypeScript installation" на каждый write/edit, когда у baseDir
+ * не было node_modules). Какие файлы маркируют корень — языко-специфично
+ * (`LspServerConfig.workspaceMarkers`); функция маркеры принимает параметром
+ * и детектом языка не занимается.
+ */
 export function findProjectRoot(filePath, baseDir, markers) {
     if (!markers || markers.length === 0)
         return baseDir;
     let dir = dirname(filePath);
     const root = baseDir.replace(/[\\/]+$/, "");
-    // Clamp the walk to baseDir: callers that pass baseDir itself as filePath
-    // (probes) start at dirname(baseDir) — ABOVE the sandbox — and would pick up
-    // a marker directory from the parent (e.g. a package.json next to it).
+    // Обход клампим к baseDir: вызывающие с самим baseDir как filePath (пробы)
+    // стартуют от dirname(baseDir) — ВЫШЕ песочницы — и подобрали бы маркер
+    // родителя (напр. package.json рядом).
     const rel = relative(root, dir);
-    if ((rel && rel.startsWith("..")) || isAbsolute(rel))
+    if ((rel?.startsWith("..")) || isAbsolute(rel))
         dir = root;
     while (true) {
         if (markers.some((m) => existsSync(join(dir, m)))) {

package/dist/modules/lsp/startup-check.js

@@ -1,3 +1,4 @@
+// Стартовый health-check проекта: предсуществующие ошибки в промпт до начала работы.
 import { existsSync } from "fs";
 import { join } from "path";
 import { spawn } from "child_process";
@@ -8,27 +9,27 @@ import { getServerForFile } from "./config";
 import { findProjectRoot, resolveTscCommand } from "./project-root";
 import { estimateTokens } from "../../llm/token-counter";
 import { errMsg } from "../../utils";
-/** Startup check never examines more than this many files via LSP. */
+import { LSP_STARTUP_CHECK_TIMEOUT_MS as STARTUP_CHECK_TIMEOUT_MS } from "../../config/timeouts";
+/** Стартовый чек смотрит не больше этого числа файлов через LSP. */
 const STARTUP_CHECK_FILE_CAP = 5;
-/** Overall cap for the whole startup check — never block session start longer. */
-const STARTUP_CHECK_TIMEOUT_MS = 60_000;
-/** Cap of tsc error lines surfaced in the prompt block. */
+/** Кап строк ошибок tsc в промпт-блоке. */
 const STARTUP_CHECK_ERROR_CAP = 20;
 /**
- * Scan the project at session start for errors that already exist, so the
- * model knows the baseline BEFORE it starts working. Addresses interrupted
- * sessions: code left half-broken by a previous run is surfaced up front
- * instead of being discovered (or missed) reactively.
+ * Сканирует проект на старте сессии на уже существующие ошибки, чтобы модель
+ * знала baseline ДО начала работы. Закрывает прерванные сессии: недоломанный
+ * прошлым запуском код всплывает сразу, а не находится (или пропускается)
+ * реактивно.
  *
- * Strategy:
- * - If the project has a tsconfig.json → one `tsc --noEmit --skipLibCheck`
- *   invocation (single process, covers the whole project).
- * - Otherwise → bounded LSP diagnostics on up to STARTUP_CHECK_FILE_CAP files
- *   (handles CSS/JSON/plain-JS projects with no TS).
+ * Стратегия:
+ * - есть tsconfig.json → один `tsc --noEmit --skipLibCheck` (один процесс на
+ *   весь проект);
+ * - иначе → ограниченные LSP-диагностики до STARTUP_CHECK_FILE_CAP файлов
+ *   (CSS/JSON/чистый-JS проекты без TS).
  *
- * Always fail-open: on any error/timeout/clean result → returns null, so the
- * check can never slow down or break session startup.
+ * Всегда fail-open: любая ошибка/таймаут/чистый результат → null, чек не
+ * может замедлить или сломать старт сессии.
  */
+/** Запустить стартовый health-check; нечего показать — null. */
 export async function runStartupHealthCheck(config, baseDir, deps = {}) {
     if (!config.enabled)
         return null;
@@ -81,7 +82,7 @@ async function runCheck(config, baseDir, deps) {
             }
         }
         catch (e) {
-            // Per-file LSP failure → log and skip (fail-open).
+            // Упавший LSP на файле → лог и пропуск (fail-open).
             deps.logger?.debug(`Startup LSP check failed for ${file}: ${errMsg(e)}`);
         }
     }
@@ -124,6 +125,7 @@ async function runTscDefault(projectRoot, timeoutMs) {
         });
     });
 }
+/** Распарсить "error TS" строки из вывода tsc (дедуп). */
 export function parseTscErrors(output) {
     const lines = [];
     for (const raw of output.split("\n")) {

package/dist/modules/mcp/client.js

@@ -1,27 +1,32 @@
+// MCP-клиент: JSON-RPC поверх stdio/sse/http, listTools/callTool, таймауты.
 import { spawn } from "child_process";
 import { defaultOutputBus } from "../../output";
-/** Default timeout for MCP HTTP requests (connect + tool calls). */
-const HTTP_TIMEOUT_MS = 10_000;
+import { MCP_HTTP_TIMEOUT_MS as HTTP_TIMEOUT_MS } from "../../config/timeouts";
 /**
- * Accept header required by the MCP Streamable HTTP transport — the server
- * responds with 406 if the client doesn't accept both media types.
+ * Accept-заголовок для MCP Streamable HTTP: сервер отвечает 406, если клиент
+ * не принимает оба media type.
  */
 const MCP_ACCEPT_HEADER = "application/json, text/event-stream";
+/** MCP-клиент: коннект по транспорту, listTools, callTool. */
 export class MCPClient {
     serverName;
     config;
     process = null;
     _connected = false;
     abortController = null;
-    pendingResolve = null;
-    pendingReject = null;
+    /** In-flight SSE-вызовы по JSON-RPC id (один слот мешал конкурентные
+     *  вызовы и матчил ответы по любому id — теперь слот на вызов). */
+    ssePending = new Map();
+    sseSeq = 0;
     constructor(config) {
         this.config = config;
         this.serverName = config.name;
     }
+    /** Подключён ли клиент. */
     isConnected() {
         return this._connected;
     }
+    /** Подключиться по транспорту из конфига (http/sse/stdio). */
     async connect() {
         if (this._connected)
             return;
@@ -56,7 +61,7 @@ export class MCPClient {
             this._connected = true;
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
-            let buffer = "";
+            const buffer = "";
             this.readSSE(reader, decoder, buffer);
         }
         catch (err) {
@@ -102,31 +107,30 @@ export class MCPClient {
     handleSSEMessage(data) {
         try {
             const msg = JSON.parse(data);
-            if (this.pendingResolve && msg.id) {
-                this.clearSseTimer();
-                if (msg.error) {
-                    this.pendingReject?.(new Error(msg.error.message));
+            if (msg.id !== undefined) {
+                const pending = this.ssePending.get(msg.id);
+                if (pending) {
+                    this.ssePending.delete(msg.id);
+                    clearTimeout(pending.timer);
+                    if (msg.error)
+                        pending.reject(new Error(msg.error.message));
+                    else
+                        pending.resolve(msg.result);
                 }
-                else {
-                    this.pendingResolve(msg.result);
-                }
-                this.pendingResolve = null;
-                this.pendingReject = null;
             }
         }
         catch (e) {
-            // Heartbeats/comments are not JSON — expected noise, but still logged
-            // so a genuinely broken stream is visible in diagnostics.
+            // Хартбиты/комменты — не JSON: ожидаемый шум, но логируем, чтобы
+            // реально битый стрим был виден в диагностике.
             defaultOutputBus.log("error", "mcp", `[MCPClient] Unparseable SSE message: ${String(data).slice(0, 120)} ${e instanceof Error ? e.message : String(e)}`, { persist: true });
         }
     }
     handleSSEError(err) {
-        if (this.pendingReject) {
-            this.clearSseTimer();
-            this.pendingReject(err);
-            this.pendingResolve = null;
-            this.pendingReject = null;
+        for (const [, pending] of this.ssePending) {
+            clearTimeout(pending.timer);
+            pending.reject(err);
         }
+        this.ssePending.clear();
     }
     connectStdio() {
         return new Promise((resolve, reject) => {
@@ -152,15 +156,15 @@ export class MCPClient {
             child.on("spawn", () => {
                 this._connected = true;
                 this.process = child;
-                // MCP handshake: real servers require `initialize` before any
-                // tools/list or tools/call request.
+                // MCP-handshake: настоящие серверы требуют `initialize` перед
+                // tools/list и tools/call.
                 this.stdioRequest("initialize", {
                     protocolVersion: "2024-11-05",
                     capabilities: {},
                     clientInfo: { name: "mma", version: "1.0.0" },
                 }, 10000)
                     .then(() => {
-                    child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+                    child.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}\n`);
                 })
                     .then(() => {
                     _resolved = true;
@@ -176,16 +180,18 @@ export class MCPClient {
             });
         });
     }
-    /** Unparsed trailing bytes from stdio responses (partial line). */
+    /** Неразобранный хвост stdio-ответов (частичная строка). */
     stdioBuffer = "";
+    /** Монотонный id stdio-запросов (Date.now() коллизил на вызовах в одну мс). */
+    stdioRequestSeq = 0;
     /**
-     * JSON-RPC request over stdio with timeout, exit handling and
-     * buffer-aware line parsing (notifications and stale responses between
-     * our request and its response no longer break matching).
+     * JSON-RPC запрос поверх stdio: таймаут, обработка exit и построчный парсинг
+     * с учётом буфера (нотификации и чужие ответы между запросом и ответом
+     * матчинг больше не ломают).
      */
     stdioRequest(method, params, timeoutMs) {
         const proc = this.process;
-        if (!proc || !proc.stdout || !proc.stdin) {
+        if (!proc?.stdout || !proc.stdin) {
             return Promise.reject(new Error("Not connected to MCP server"));
         }
         const stdout = proc.stdout;
@@ -193,7 +199,7 @@ export class MCPClient {
         return new Promise((resolve, reject) => {
             const request = {
                 jsonrpc: "2.0",
-                id: Date.now(),
+                id: ++this.stdioRequestSeq,
                 method,
                 ...(params !== undefined ? { params } : {}),
             };
@@ -225,7 +231,7 @@ export class MCPClient {
                         continue;
                     }
                     if (msg.id !== request.id)
-                        continue; // notification or foreign response
+                        continue; // нотификация или чужой ответ
                     finish(() => {
                         if (msg.error) {
                             reject(new Error(msg.error.message));
@@ -245,9 +251,10 @@ export class MCPClient {
             timer = setTimeout(() => {
                 finish(() => reject(new Error(`MCP ${method} timeout`)));
             }, timeout);
-            proc.stdin.write(JSON.stringify(request) + "\n");
+            proc.stdin.write(`${JSON.stringify(request)}\n`);
         });
     }
+    /** Список тулов сервера (автоконнект; транспорт выбирается из конфига). */
     async listTools() {
         if (!this._connected) {
             await this.connect();
@@ -319,6 +326,7 @@ export class MCPClient {
         const result = await this.stdioRequest("tools/list");
         return result?.tools || [];
     }
+    /** Отключиться: http — флаг, sse — abort, stdio — kill процесса. */
     async disconnect() {
         if (this.config.transport === "http") {
             this._connected = false;
@@ -334,6 +342,7 @@ export class MCPClient {
         }
         this._connected = false;
     }
+    /** Вызвать тул (без коннекта — ошибка; транспорт из конфига). */
     async callTool(toolName, args) {
         if (!this._connected) {
             throw new Error("Not connected to MCP server");
@@ -376,12 +385,11 @@ export class MCPClient {
         }
         return result.result || result;
     }
-    /** Timer of the in-flight SSE request — cleared when the reply arrives via the stream. */
-    sseTimer;
     async callToolSSE(toolName, args) {
+        const id = ++this.sseSeq;
         const request = {
             jsonrpc: "2.0",
-            id: Date.now(),
+            id,
             method: "tools/call",
             params: {
                 name: toolName,
@@ -389,14 +397,17 @@ export class MCPClient {
             },
         };
         return new Promise((resolve, reject) => {
-            this.pendingResolve = resolve;
-            this.pendingReject = reject;
+            const settle = (fn) => {
+                const pending = this.ssePending.get(id);
+                if (!pending)
+                    return;
+                this.ssePending.delete(id);
+                clearTimeout(pending.timer);
+                fn();
+            };
             const timeout = this.config.timeout || 30000;
-            this.sseTimer = setTimeout(() => {
-                this.pendingResolve = null;
-                this.pendingReject = null;
-                reject(new Error("MCP call timeout"));
-            }, timeout);
+            const timer = setTimeout(() => settle(() => reject(new Error("MCP call timeout"))), timeout);
+            this.ssePending.set(id, { resolve, reject, timer });
             fetch(this.config.url, {
                 method: "POST",
                 headers: {
@@ -408,34 +419,20 @@ export class MCPClient {
                 signal: this.abortController?.signal,
             })
                 .then(async (response) => {
-                this.clearSseTimer();
                 if (!response.ok) {
                     const text = await response.text().catch(() => "");
-                    reject(new Error(`MCP POST failed: ${response.status} ${text}`));
+                    settle(() => reject(new Error(`MCP POST failed: ${response.status} ${text}`)));
                     return;
                 }
                 const result = await response.json();
-                if (result.error) {
-                    reject(new Error(result.error.message));
-                }
-                else {
-                    resolve(result.result || result);
-                }
+                settle(() => result.error ? reject(new Error(result.error.message)) : resolve(result.result || result));
             })
                 .catch((err) => {
-                this.clearSseTimer();
-                if (err.name !== "AbortError") {
-                    reject(err);
-                }
+                if (err.name !== "AbortError")
+                    settle(() => reject(err));
             });
         });
     }
-    clearSseTimer() {
-        if (this.sseTimer !== undefined) {
-            clearTimeout(this.sseTimer);
-            this.sseTimer = undefined;
-        }
-    }
     callToolStdio(toolName, args) {
         if (!this.process) {
             throw new Error("Not connected to MCP server");

package/dist/modules/mcp/index.js

@@ -1,3 +1,4 @@
+// Публичный фасад модуля MCP: клиент, реестр, модуль.
 export { MCPClient } from "./client";
 export { MCPRegistry } from "./registry";
 export { MCPModule } from "./module";

package/dist/modules/mcp/module.js

@@ -1,12 +1,15 @@
 import { MCPClient } from "./client";
 import { MCPRegistry } from "./registry";
 import { Logger } from "../../logger/app-logger";
+import { MCP_DISCOVERY_TIMEOUT_MS as DISCOVERY_TIMEOUT_MS } from "../../config/timeouts";
 const logger = new Logger("warn", "mcp");
+/** Безопасное имя тула: mcp__server__tool. */
 function sanitizeToolName(server, tool) {
     const safeServer = server.replace(/[^a-zA-Z0-9_-]/g, "_");
     const safeTool = tool.replace(/[^a-zA-Z0-9_-]/g, "_");
     return `mcp__${safeServer}__${safeTool}`;
 }
+/** Привести input-схему MCP к форме дефиниций тулов. */
 function convertInputSchema(schema) {
     if (schema && typeof schema === "object" && "properties" in schema) {
         const required = Array.isArray(schema.required) ? schema.required : [];
@@ -18,26 +21,23 @@ function convertInputSchema(schema) {
     }
     return { type: "object", properties: {} };
 }
-/** Timeout for the initial tool discovery call (avoids hanging startup). */
-const DISCOVERY_TIMEOUT_MS = 5_000;
+/** Модуль MCP: конфиги при init, коннект лениво, тул-дефиниции из найденного. */
 export class MCPModule {
     config;
     name = "mcp";
     connections = new Map();
-    /** Server configs registered at init, not yet connected. */
+    /** Конфиги серверов с init, ещё без коннекта. */
     serverConfigs = new Map();
     discovered = [];
     initialized = false;
-    initError = null;
-    /** Servers that failed initial discovery — will not be retried. */
+    /** Серверы с упавшим первичным discovery — не ретраятся. */
     failedServers = new Set();
     constructor(config) {
         this.config = config;
     }
     /**
-     * Register MCP server configs WITHOUT connecting. Actual connection and tool
-     * discovery happens lazily on first tool call — keeps startup fast and
-     * offline-safe.
+     * Зарегистрировать конфиги MCP-серверов БЕЗ коннекта. Коннект и discovery
+     * тулов — лениво, на первом вызове: старт быстрый и офлайн-безопасный.
      */
     async initialize() {
         if (this.initialized)
@@ -61,30 +61,36 @@ export class MCPModule {
             };
             registry.register(serverConfig);
         }
-        // Store configs for lazy connection — no network calls here.
+        // Конфиги — для ленивого коннекта, сетевых вызовов тут нет.
         for (const serverName of registry.list()) {
             this.serverConfigs.set(serverName, registry.get(serverName));
         }
-        // Attempt fast discovery in background (best-effort, timeout-bounded).
-        // If it fails, tools are still registered — they'll connect on first call.
-        this.discoverAllTools();
+        // Discovery ДО снапшота тул-дефиниций вызывающим. Раньше был
+        // fire-and-forget, и `collectToolDefinitions()` при bootstrap отрабатывал
+        // раньше, чем серверы успевали подключиться, — настоящие MCP-тулы не
+        // регистрировались. Discovery ограничен (таймаут на сервер, серверы
+        // параллельно) и best-effort: падения оставляют ленивый плейсхолдер "connect".
+        await this.discoverAllTools();
     }
     /**
-     * Try to connect and discover tools for all registered servers.
-     * Runs in background, never blocks the caller. Failures are silent —
-     * tools still get registered and will retry connection on first call.
+     * Подключиться и найти тулы всех зарегистрированных серверов параллельно,
+     * каждый ограничен DISCOVERY_TIMEOUT_MS. Отменённая по таймауту попытка:
+     * её позднее завершение не должно регистрировать сервер, уже помеченный упавшим.
      */
     async discoverAllTools() {
-        for (const [serverName, serverConfig] of this.serverConfigs) {
+        await Promise.all([...this.serverConfigs].map(async ([serverName, serverConfig]) => {
             if (this.failedServers.has(serverName))
-                continue;
+                return;
             const client = new MCPClient(serverConfig);
+            let timedOut = false;
+            let timer;
             try {
-                // Race discovery against timeout — never let a dead server block startup.
                 await Promise.race([
                     (async () => {
                         await client.connect();
                         const tools = await client.listTools();
+                        if (timedOut)
+                            return; // проиграл гонку — состояние не мутировать
                         this.connections.set(serverName, client);
                         for (const tool of tools) {
                             this.discovered.push({
@@ -95,28 +101,35 @@ export class MCPModule {
                             });
                         }
                     })(),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("discovery timeout")), DISCOVERY_TIMEOUT_MS)),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error("discovery timeout")), DISCOVERY_TIMEOUT_MS);
+                    }),
                 ]);
             }
             catch (e) {
+                timedOut = true;
                 this.failedServers.add(serverName);
-                this.initError = `MCP server "${serverName}" init failed: ${e.message}`;
+                logger.warn(`MCP server "${serverName}" init failed: ${e.message}`);
                 await client.disconnect().catch((err) => {
                     logger.warn(`cleanup disconnect for "${serverName}" failed`, { error: String(err) });
                 });
             }
-        }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }));
     }
     /**
-     * Ensure a specific server is connected and its tools are discovered.
-     * Called lazily on first tool invocation for that server.
+     * Гарантировать коннект конкретного сервера и discovery его тулов.
+     * Лениво вызывается на первом обращении к тулу сервера.
      */
     async ensureConnected(serverName) {
-        // Already connected?
+        // Уже подключён?
         const existing = this.connections.get(serverName);
         if (existing?.isConnected())
             return existing;
-        // Failed during init — don't retry.
+        // Упал при init — не ретраить.
         if (this.failedServers.has(serverName))
             return null;
         const serverConfig = this.serverConfigs.get(serverName);
@@ -127,7 +140,7 @@ export class MCPModule {
             await client.connect();
             const tools = await client.listTools();
             this.connections.set(serverName, client);
-            // Add newly discovered tools (if not already present).
+            // Добавить новонайденные тулы (если ещё нет).
             for (const tool of tools) {
                 const alreadyDiscovered = this.discovered.some((d) => d.serverName === serverName && d.toolName === tool.name);
                 if (!alreadyDiscovered) {
@@ -169,7 +182,7 @@ export class MCPModule {
                 }
             }
             else {
-                lines.push(`    (not yet connected — use mcp__${serverName}__connect to discover tools)`);
+                lines.push(`    (not yet connected — use ${sanitizeToolName(serverName, "connect")} to discover tools)`);
             }
         }
         lines.push("---");
@@ -181,13 +194,30 @@ export class MCPModule {
         };
     }
     getToolDefinitions() {
-        // Build definitions from discovered tools AND from registered-but-not-yet-discovered
-        // servers (so the LLM sees all configured MCP tools even if discovery failed at startup).
+        // Дефиниции из найденных тулов И из зарегистрированных, но ещё не
+        // найденных серверов (модель видит все настроенные MCP-тулы, даже если
+        // discovery при старте упал).
         const defs = [];
-        // Tools already discovered (connected at startup).
+        // Санитизация может схлопнуть разные имена в один id (`a.b`/`a-b`,
+        // `x.y`/`x-y`); реестр на дубле бросал, что роняло bootstrap.
+        // Разруливаем числовым суффиксом до регистрации.
+        const usedNames = new Set();
+        const uniqueName = (base) => {
+            if (!usedNames.has(base)) {
+                usedNames.add(base);
+                return base;
+            }
+            let i = 2;
+            while (usedNames.has(`${base}_${i}`))
+                i++;
+            const name = `${base}_${i}`;
+            usedNames.add(name);
+            return name;
+        };
+        // Уже найденные тулы (подключены при старте).
         for (const d of this.discovered) {
             defs.push({
-                name: sanitizeToolName(d.serverName, d.toolName),
+                name: uniqueName(sanitizeToolName(d.serverName, d.toolName)),
                 description: `${d.description} [MCP server: ${d.serverName}]`,
                 parameters: convertInputSchema(d.inputSchema),
                 tags: ["code", "research"],
@@ -212,17 +242,16 @@ export class MCPModule {
                 },
             });
         }
-        // Servers that haven't been discovered yet — register placeholder tools
-        // that will connect lazily on first call.
+        // Ещё не найденные серверы — плейсхолдеры, коннект лениво на первом вызове.
         for (const [serverName] of this.serverConfigs) {
             if (this.failedServers.has(serverName))
                 continue;
             const alreadyDiscovered = this.discovered.some((d) => d.serverName === serverName);
             if (alreadyDiscovered)
                 continue;
-            // Register a single "connect" tool so the LLM can trigger discovery.
+            // Один тул "connect", чтобы модель могла триггернуть discovery.
             defs.push({
-                name: sanitizeToolName(serverName, "connect"),
+                name: uniqueName(sanitizeToolName(serverName, "connect")),
                 description: `Connect to MCP server "${serverName}" and discover its tools`,
                 parameters: { type: "object", properties: {} },
                 tags: ["code", "research"],
@@ -255,8 +284,8 @@ export class MCPModule {
                         await client.disconnect();
                     }
                     catch (e) {
-                        // Best-effort cleanup at session end — a failed disconnect must
-                        // not crash the shutdown path, but must stay diagnosable.
+                        // Best-effort cleanup на конце сессии: упавший disconnect не
+                        // должен ронять shutdown, но обязан остаться в диагностике.
                         logger.warn(`disconnect from "${serverName}" failed`, { error: String(e?.message ?? e) });
                     }
                 }

package/dist/modules/mcp/registry.js

@@ -1,14 +1,19 @@
+/** Реестр конфигов MCP-серверов по именам. */
 export class MCPRegistry {
     servers = new Map();
+    /** Зарегистрировать конфиг сервера. */
     register(config) {
         this.servers.set(config.name, config);
     }
+    /** Конфиг по имени (undefined — нет). */
     get(name) {
         return this.servers.get(name);
     }
+    /** Имена серверов по алфавиту. */
     list() {
         return Array.from(this.servers.keys()).sort();
     }
+    /** Удалить сервер. */
     remove(name) {
         this.servers.delete(name);
     }

package/dist/modules/memory/index.js

@@ -1 +1,2 @@
+// Публичная поверхность модуля памяти: хранилище категорий и преференсов.
 export { MemoryStore } from "./store";