micro-models-agent 2.11.0 → 2.12.0

package/dist/tools/executor.js

@@ -1,25 +1,44 @@
 import { killByCallId } from "../modules/processes/runner";
 import { t } from "../i18n/index";
-const TOOL_EXECUTION_TIMEOUT_MS = 60000;
+import { TOOL_EXECUTION_TIMEOUT_MS, TOOL_MEMO_TTL_MS as MEMO_TTL_MS, } from "../config/timeouts";
+const MEMO_MAX_ENTRIES = 100;
+/** Стабильная сериализация: сортировка ключей, порядок аргументов на ключ не влияет. */
+function stableArgsKey(value) {
+    if (Array.isArray(value))
+        return value.map(stableArgsKey);
+    if (value && typeof value === "object") {
+        const entries = Object.keys(value)
+            .sort()
+            .map((k) => [k, stableArgsKey(value[k])]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+/** Исполнитель: реестр, контекст, плагины, сессионное мемо. */
 export class ToolExecutor {
     registry;
     ctx;
     pluginManager;
+    /**
+     * Сессионное мемо детерминированных read-only результатов
+     * (`ToolDefinition.cacheable` + ручные записи `manualMemo`-тулов вроде bash).
+     * Ключ: `sessionId::name::stableArgs`.
+     */
+    memo = new Map();
     constructor(registry, ctx, pluginManager) {
         this.registry = registry;
         this.ctx = ctx;
         this.pluginManager = pluginManager;
     }
     /**
-     * Execute a tool by name with plain arguments (no call id, no timeout
-     * wiring). Used internally — e.g. bash redirects a mistaken tool-call-as-
-     * command into the real tool. Runs through the same registry and plugin
-     * hooks as a normal call.
+     * Запуск тула по имени с plain-аргументами (без call id и таймаут-обвязки).
+     * Для внутреннего использования — напр. bash перенаправляет ошибочный
+     * tool-call-как-команду в настоящий тул. Идёт через те же реестр и хуки.
      *
-     * **Reentrancy warning:** swaps `this.ctx` temporarily (line 30-39). Safe
-     * for sequential callers but NOT for concurrent calls on the same executor
-     * instance — they would race on the ctx swap. Today all callers are
-     * sequential (bash redirect, single subagent tool); keep it that way.
+     * Внимание по реентрантности: временно подменяет `this.ctx`. Безопасно для
+     * последовательных вызовов, но НЕ для конкурентных на одном инстансе —
+     * будет гонка на подмене. Сейчас все вызовы последовательны (bash-редирект,
+     * один subagent-тул); так и держать.
      */
     async executeByName(name, args, ctx) {
         const prevCtx = this.ctx;
@@ -36,11 +55,59 @@ export class ToolExecutor {
             this.ctx = prevCtx;
         }
     }
-    /** Whether a tool with this name is registered (used before redirects). */
+    /** Есть ли тул с таким именем (проверка перед редиректами). */
     hasTool(name) {
         return this.registry.has(name);
     }
+    memoKey(name, args) {
+        return `${this.ctx.sessionId ?? ""}::${name}::${JSON.stringify(stableArgsKey(args))}`;
+    }
+    /**
+     * Чтение мемо для `manualMemo`-тулов (bash). Возвращает откреплённую копию —
+     * `toolCallId` вызывающий ставит сам.
+     */
+    memoGet(name, args) {
+        const hit = this.memo.get(this.memoKey(name, args));
+        if (!hit)
+            return undefined;
+        if (Date.now() - hit.at > MEMO_TTL_MS) {
+            this.memo.delete(this.memoKey(name, args));
+            return undefined;
+        }
+        return { ...hit.result };
+    }
+    /** Запись в мемо для `manualMemo`-тулов. Хранит откреплённую копию. */
+    memoSet(name, args, result) {
+        const key = this.memoKey(name, args);
+        if (!this.memo.has(key) && this.memo.size >= MEMO_MAX_ENTRIES) {
+            const oldest = this.memo.keys().next();
+            if (!oldest.done)
+                this.memo.delete(oldest.value);
+        }
+        this.memo.set(key, { result: { ...result }, at: Date.now() });
+    }
+    /** Сброс мемо — после всего, что могло мутировать состояние. */
+    memoInvalidate() {
+        this.memo.clear();
+    }
+    /**
+     * Имена разрешённых тулов множеством, `null` — без ограничений.
+     * `undefined` — без ограничений; `[]` — запрещено всё.
+     */
+    allowedNames() {
+        const allow = this.ctx.toolAllowlist;
+        return allow ? new Set(allow) : null;
+    }
+    /** Выполнить tool call: allowlist → плагины → хендлер → post-хуки. */
     async execute(call, signal) {
+        const allow = this.allowedNames();
+        if (allow && !allow.has(call.name)) {
+            return {
+                success: false,
+                output: t("tool.not_allowed", { name: call.name }),
+                toolCallId: call.id,
+            };
+        }
         const tool = this.registry.get(call.name);
         if (!tool) {
             return {
@@ -72,23 +139,27 @@ export class ToolExecutor {
             }
         }
         let result;
+        // Мемоизированный повтор детерминированного чтения (cacheable): хендлер
+        // пропускается, но общий хвост (post-плагины, логирование) идёт как обычно,
+        // чтобы мемо-хит был неотличим от свежего прогона.
+        const memoHit = tool.cacheable ? this.memoGet(call.name, call.arguments) : undefined;
         try {
             this.ctx.activeCallId = call.id;
             if (tool.interactive) {
-                // Interactive tools wait for user input — no timeout.
-                result = await tool.handler(this.ctx, call.arguments);
+                // Интерактивные тулы ждут ввода — без таймаута.
+                result = memoHit ?? (await tool.handler(this.ctx, call.arguments));
             }
             else {
                 const timeoutMs = tool.timeoutMs ?? TOOL_EXECUTION_TIMEOUT_MS;
                 const failFast = (message) => {
-                    // Kill any long-running child process registered for this call.
+                    // Убить долгоживущий дочерний процесс этого вызова.
                     killByCallId(call.id);
-                    // Run tool-specific cleanup (e.g. subagent scope restore) before
-                    // rejecting so shared state is restored even on abandonment.
+                    // Тул-специфичный cleanup (напр. восстановление скоупа subagent) —
+                    // до reject, чтобы общее состояние восстановилось и при abandonment.
                     const cleanup = this.ctx.cleanup;
                     if (cleanup) {
                         cleanup();
-                        // Clear only if no newer call has replaced it meanwhile.
+                        // Сбрасывать, только если более новый вызов не подменил тем временем.
                         if (this.ctx.cleanup === cleanup)
                             this.ctx.cleanup = undefined;
                     }
@@ -105,7 +176,7 @@ export class ToolExecutor {
                     }, timeoutMs);
                 });
                 const racePromises = [
-                    tool.handler(this.ctx, call.arguments),
+                    memoHit ? Promise.resolve(memoHit) : tool.handler(this.ctx, call.arguments),
                     timeoutPromise,
                 ];
                 if (signal) {
@@ -124,16 +195,15 @@ export class ToolExecutor {
                     result = await Promise.race(racePromises);
                 }
                 finally {
-                    // Stop the timer and detach the abort listener once settled so they
-                    // never fire against a DIFFERENT call's context/cleanup later.
+                    // Остановить таймер и снять abort-слушатель, чтобы они не сработали
+                    // против контекста/cleanup УЖЕ ДРУГОГО вызова.
                     if (timer !== undefined)
                         clearTimeout(timer);
                     if (onAbort && signal)
                         signal.removeEventListener("abort", onAbort);
-                    // Losing promises have no consumer after Promise.race settled
-                    // (their kill/cleanup effects were already applied in failFast).
-                    // Log the rejection, then detach it so it never surfaces as an
-                    // unhandled rejection.
+                    // У проигравших промисов потребителя после settled race нет (их
+                    // kill/cleanup-эффекты уже применены в failFast). Залогировать
+                    // reject и отцепить, чтобы не всплыл как unhandled rejection.
                     for (const p of racePromises.slice(1)) {
                         p.catch((e) => {
                             this.ctx.logger.debug(`Tool ${call.name}: discarded race loser: ${e.message}`);
@@ -150,10 +220,22 @@ export class ToolExecutor {
                 toolCallId: call.id,
             };
         }
-        // After an abort the tool's work is discarded (the agent loop breaks
-        // without rendering or logging it), so skip the slow post-tool plugins
-        // (LSP checks, lint, tsc) entirely. When the abort lands mid-plugin the
-        // signal in the hook context lets the plugin kill its child processes.
+        if (!memoHit) {
+            // Успешные детерминированные чтения мемоизируются; всё остальное, что
+            // реально выполнялось, могло мутировать состояние (даже упавшая команда
+            // применяется наполовину) — мемо сбрасывается. `manualMemo` (bash) ведут
+            // свои записи сами.
+            if (tool.cacheable && result.success) {
+                this.memoSet(call.name, call.arguments, result);
+            }
+            else if (!tool.cacheable && !tool.manualMemo) {
+                this.memoInvalidate();
+            }
+        }
+        // После аборта работа тула отбрасывается (цикл агента завершается без
+        // рендера/логирования), поэтому медленные post-плагины (LSP, lint, tsc)
+        // пропускаются целиком. Аборт посреди плагина виден ему через signal
+        // в контексте хука — плагин убьёт свои дочерние процессы.
         if (signal?.aborted) {
             this.ctx.logger.debug(`Tool ${call.name}: abort, skipping onAfterTool plugins`);
         }
@@ -175,24 +257,47 @@ export class ToolExecutor {
         this.ctx.logger.debug(`Tool ${call.name}: ${result.success ? "OK" : "FAIL"}`);
         return result;
     }
+    /** Определения тулов с учётом allowlist (для схемы LLM). */
     getToolDefinitions(tags) {
+        const allow = this.allowedNames();
+        if (allow) {
+            return this.registry
+                .getAll()
+                .filter((t) => allow.has(t.name))
+                .map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+                boundedOutput: t.boundedOutput,
+            }));
+        }
         return this.registry.getAllForLLM(tags);
     }
+    /** Доступ к реестру. */
     getRegistry() {
         return this.registry;
     }
+    /** Установить скоуп shared-исполнителя. */
     setScope(scope) {
         this.ctx.scope = scope;
     }
+    /** Текущий скоуп shared-исполнителя (для compare-and-restore субагентов). */
+    getScope() {
+        return this.ctx.scope;
+    }
+    /** Установить prompt-поверхность для интерактивных тулов. */
     setPromptIO(io) {
         this.ctx.promptIO = io;
     }
+    /** Текущая глубина рекурсии субагентов. */
     getRecursionDepth() {
         return this.ctx.recursionDepth ?? 0;
     }
+    /** Установить глубину рекурсии. */
     setRecursionDepth(depth) {
         this.ctx.recursionDepth = depth;
     }
+    /** Подменить LLM-провайдер в контексте. */
     updateProvider(provider) {
         this.ctx.llmProvider = provider;
     }

package/dist/tools/file-info.js

@@ -1,13 +1,16 @@
+/** Тул метаданных файла/каталога (размер, даты; кешируемый). */
 import { statSync, existsSync } from "fs";
 import { t } from "../i18n/index";
 import { isPathInScope } from "../modules/security/path-validator";
 import { safeResolvePath } from "./path-utils";
+/** Возвращает JSON с размером, типом, датами создания/изменения. */
 export const fileInfoTool = {
     name: "file_info",
     icon: "ℹ️",
     description: "Get metadata about a file or directory (size, creation date, modification date).",
     tags: ["file"],
     boundedOutput: true,
+    cacheable: true,
     parameters: {
         type: "object",
         properties: {
@@ -18,7 +21,6 @@ export const fileInfoTool = {
     handler: async (ctx, args) => {
         const path = String(args.path);
         const resolved = safeResolvePath(ctx.baseDir, path);
-        // Check path permissions
         const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
         if (!scopeCheck.allowed) {
             return {

package/dist/tools/filter-tools.js

@@ -1,7 +1,7 @@
 /**
- * Filter tools by a tag set, always keeping `alwaysOn` tools. Used by MoE
- * expert routing and subagent tool_tags so structural tools (plan/todo/verify,
- * project_map, lsp_check, enable_tools) survive narrowing.
+ * Фильтрует тулы по набору тегов, всегда оставляя `alwaysOn`. Для MoE-роутинга
+ * экспертов и subagent tool_tags — структурные тулы (plan/todo/verify,
+ * project_map, lsp_check, enable_tools) переживают сужение.
  */
 export function filterToolsByTags(tools, toolTags) {
     if (!toolTags || toolTags.length === 0)

package/dist/tools/glob-tool.js

@@ -1,11 +1,14 @@
+/** Тул поиска файлов по glob-паттерну (кешируемый, jail в baseDir). */
 import { globSync } from "fs";
 import { t } from "../i18n/index";
 import { MAX_PREVIEW_LINES } from "./preview";
+/** Ищет файлы по glob; выдача обрезана MAX_PREVIEW_LINES. */
 export const globTool = {
     name: "glob",
     icon: "🔎",
     description: `Search for files matching a glob pattern. Shows up to ${MAX_PREVIEW_LINES} results by default. Uses standard glob syntax (e.g., **/*.ts, src/**/*.test.ts).`,
     tags: ["file", "code", "research"],
+    cacheable: true,
     parameters: {
         type: "object",
         properties: {
@@ -15,7 +18,7 @@ export const globTool = {
     },
     handler: async (ctx, args) => {
         const pattern = String(args.pattern);
-        // Security: absolute patterns (/etc/*) and ".." segments escape baseDir.
+        // Абсолютные паттерны (/etc/*) и ".." выводят за baseDir — запретить.
         if (/^([a-zA-Z]:)?[\\/]/.test(pattern) || pattern.split(/[\\/]/).includes("..")) {
             return {
                 success: false,

package/dist/tools/grep-tool.js

@@ -1,10 +1,12 @@
-import { spawn } from "child_process";
+/** Тул поиска по содержимому (rg с fallback на grep -r). */
+import { spawn, } from "child_process";
 import { resolve } from "path";
 import { t } from "../i18n/index";
 import { logBashCommand, logSecurityBlock } from "../modules/security/audit-log";
 import { isPathInScope } from "../modules/security/path-validator";
 import { DEFAULT_SECURITY_CONFIG } from "../config/security";
 import { MAX_PREVIEW_LINES } from "./preview";
+/** Обрезает вывод до MAX_PREVIEW_LINES строк. */
 function truncateLines(output) {
     const lines = output.split("\n");
     if (lines.length <= MAX_PREVIEW_LINES)
@@ -13,8 +15,8 @@ function truncateLines(output) {
         `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`);
 }
 /**
- * Run a search command asynchronously with kill-on-timeout.
- * Exit code 1 (no matches) resolves to an empty string, like execFileSync semantics.
+ * Поисковая команда асинхронно, с kill по таймауту. Exit code 1 (нет совпадений)
+ * резолвится в пустую строку. Возврат: stdout поиска.
  */
 export function runSearch(bin, args, cwd, timeoutMs = 30000) {
     return new Promise((resolvePromise, reject) => {
@@ -53,11 +55,13 @@ export function runSearch(bin, args, cwd, timeoutMs = 30000) {
         });
     });
 }
+/** Ищет по содержимому через regex (rg, иначе grep -r); кешируемый. */
 export const grepTool = {
     name: "grep",
     icon: "🔍",
     description: `Search file contents using a regular expression. Shows up to ${MAX_PREVIEW_LINES} matching lines by default. Uses ripgrep (rg) if available, otherwise falls back to grep -r.`,
     tags: ["file", "code", "research"],
+    cacheable: true,
     parameters: {
         type: "object",
         properties: {
@@ -76,8 +80,8 @@ export const grepTool = {
     handler: async (ctx, args) => {
         const pattern = String(args.pattern);
         const searchPath = args.path ? resolve(ctx.baseDir, String(args.path)) : ctx.baseDir;
-        // Security: the search directory must stay inside baseDir / scope /
-        // allowed paths — `path: "../../.."` must not read outside the sandbox.
+        // Каталог поиска обязан оставаться внутри baseDir/скоупа: `path: "../../.."`
+        // не должен читать вне песочницы.
         const scopeCheck = isPathInScope(ctx.baseDir, searchPath, ctx.scope, ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths);
         if (!scopeCheck.allowed) {
             logSecurityBlock(ctx.sessionId || undefined, "file_read", scopeCheck.reason || "grep path not allowed", String(args.path ?? ctx.baseDir));
@@ -88,13 +92,12 @@ export const grepTool = {
                 }),
             };
         }
-        // Build rg arguments as an array to avoid shell interpretation of regex
-        // metacharacters like |, (, ) — these are regex patterns, not shell operators.
+        // Аргументы rg массивом, чтобы шелл не трактовал метасимволы regex
+        // (|, (, )) как операторы — это паттерны, не команды шелла.
         const rgArgs = ["-n", "--with-filename", pattern, searchPath];
         if (args.include) {
             rgArgs.push("-g", String(args.include));
         }
-        // Log the search (sanitized) for audit purposes
         logBashCommand(ctx.sessionId, `rg ${rgArgs.join(" ")}`, false, "grep-tool");
         try {
             const output = await runSearch("rg", rgArgs, ctx.baseDir);
@@ -113,8 +116,8 @@ export const grepTool = {
             else if (e.status === 1) {
                 return { success: true, output: t("file.no_matches") };
             }
-            // Fall back to plain grep -r when rg is not available or fails.
-            // Using array args avoids shell injection.
+            // Fallback на plain grep -r, когда rg нет или упал. Массив аргументов —
+            // защита от shell injection.
             try {
                 const grepArgs = ["-rn", pattern, searchPath];
                 if (args.include) {

package/dist/tools/hidden-tools-block.js

@@ -1,9 +1,9 @@
+/** Блок системного промпта о скрытых tag-фильтром тулах. */
 import { t } from "../i18n/index";
 /**
- * Build a compact system-prompt block listing the tools hidden by the current
- * tag filter. The model must know these tools exist (and how to reach them)
- * even though they are absent from the LLM tool schema. Grouped by tag with
- * short purposes; capped to keep the block small.
+ * Компактный блок системного промпта со скрытыми тулами. Модель должна знать
+ * об их существовании (и пути доступа), хотя их нет в tool-схеме LLM.
+ * Группировка по тегам, размер ограничен.
  */
 export function buildHiddenToolsBlock(allTools, activeTags) {
     if (!allTools.length)
@@ -11,14 +11,14 @@ export function buildHiddenToolsBlock(allTools, activeTags) {
     const activeSet = new Set(activeTags);
     const visible = new Set();
     for (const tool of allTools) {
-        if (tool.alwaysOn || (tool.tags && tool.tags.some((tag) => activeSet.has(tag)))) {
+        if (tool.alwaysOn || (tool.tags?.some((tag) => activeSet.has(tag)))) {
             visible.add(tool.name);
         }
     }
     const hidden = allTools.filter((tool) => !visible.has(tool.name));
     if (hidden.length === 0)
         return "";
-    // Group by tag → tools, then by tool name alphabetically within a tag.
+    // Группировка по тегам, внутри тега — по имени тула.
     const byTag = new Map();
     for (const tool of hidden) {
         const tags = tool.tags && tool.tags.length > 0 ? tool.tags : ["other"];

package/dist/tools/index.js

@@ -1,3 +1,4 @@
+/** Точка сборки каталога тулов: импорты, реэкспорты, регистрация. */
 import { ToolRegistry } from "./registry";
 import { ToolExecutor } from "./executor";
 import { readFileTool } from "./read-file";
@@ -14,29 +15,33 @@ import { bashTool } from "./bash";
 import { processListTool } from "./process-list";
 import { processLogTool } from "./process-log";
 import { processKillTool } from "./process-kill";
+import { processWaitTool } from "./process-wait";
 import { subagentTool } from "./subagent";
 import { chunkQueryTool } from "./chunk-query";
 import { webSearchTool } from "./web-search";
 import { webFetchTool } from "./web-fetch";
 import { webBrowseTool } from "./web-browse";
 import { downloadFileTool } from "./download-file";
-// questionTool and approveTool removed — interactive menus are too disruptive for small models.
-// The model should ask questions as plain text in its response instead.
-// import { questionTool } from './question'
-// import { approveTool } from './approve'
+// question/approve — основной набор: question покрывает выбор + свободный
+// текст (с pre-check памяти), approve — явное Yes/No (reject даёт success:false,
+// и цикл трактует это как сигнал сбоя, а не текст ответа).
+import { questionTool } from "./question";
+import { approveTool } from "./approve";
 import { createLoadSkillTool } from "./load-skill";
 import { pipelineRunTool } from "./pipeline-run";
 import { mcpCallTool } from "./mcp-call";
 import { searchHistoryTool } from "./search-history";
 import { rememberTool } from "./remember";
 import { recallTool } from "./recall";
+import { meetDoneTool } from "./meet-done";
 import { createBrowserTool } from "./browser";
 import { attachImageTool } from "./attach-image";
 import { enableToolsTool } from "./enable-tools";
 import { sessionInfoTool } from "./session-info";
 export { ToolRegistry, ToolExecutor };
 export { filterToolsByTags } from "./filter-tools";
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, chunkQueryTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, downloadFileTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, enableToolsTool, sessionInfoTool, };
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, chunkQueryTool, processListTool, processLogTool, processKillTool, processWaitTool, webSearchTool, webFetchTool, webBrowseTool, downloadFileTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, meetDoneTool, createBrowserTool, attachImageTool, enableToolsTool, sessionInfoTool, questionTool, approveTool, };
+/** Регистрирует все тулы; опционально — on-demand тул и скиллы. */
 export function registerAllTools(registry, skillsModule, opts) {
     const tools = [
         readFileTool,
@@ -55,6 +60,7 @@ export function registerAllTools(registry, skillsModule, opts) {
         processListTool,
         processLogTool,
         processKillTool,
+        processWaitTool,
         webSearchTool,
         webFetchTool,
         webBrowseTool,
@@ -64,10 +70,12 @@ export function registerAllTools(registry, skillsModule, opts) {
         searchHistoryTool,
         attachImageTool,
         sessionInfoTool,
+        meetDoneTool,
+        questionTool,
+        approveTool,
     ];
-    // On-demand tool activation is the default. When explicitly disabled
-    // (enableOnDemand: false), the tool is not registered at all — combined
-    // with an empty defaultTags this restores the legacy all-tools behavior.
+    // On-demand активация — дефолт. При явном enableOnDemand:false тул не
+    // регистрируется вовсе — с пустым defaultTags это legacy-режим «все тулы».
     if (opts?.enableOnDemand !== false) {
         tools.push(enableToolsTool);
     }

package/dist/tools/list-dir.js

@@ -1,17 +1,20 @@
+/** Тул листинга каталога (игнор мусора, cap вывода, кешируемый). */
 import { readdirSync, statSync, existsSync } from "fs";
 import { resolve } from "path";
 import { t } from "../i18n/index";
 import { isPathInScope } from "../modules/security/path-validator";
 import { safeResolvePath } from "./path-utils";
 import { MAX_PREVIEW_LINES } from "./preview";
-/** Directories hidden from list_dir output (consistent with indexer walker). */
+/** Каталоги вне выдачи list_dir (едино с walker'ом индексёра). */
 const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage", ".mma"]);
+/** Показывает файлы/подкаталоги (каталоги с `/`); мусор скрыт. */
 export const listDirTool = {
     name: "list_dir",
     icon: "📂",
     description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
     tags: ["file"],
     boundedOutput: true,
+    cacheable: true,
     parameters: {
         type: "object",
         properties: {
@@ -22,7 +25,6 @@ export const listDirTool = {
     handler: async (ctx, args) => {
         const path = String(args.path);
         const resolved = safeResolvePath(ctx.baseDir, path);
-        // Check path permissions
         const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
         if (!scopeCheck.allowed) {
             return {

package/dist/tools/load-skill.js

@@ -1,10 +1,17 @@
+/** Фабрика тула загрузки скилла (инжект в системный промпт). */
 import { t } from "../i18n/index";
 import { estimateTokens } from "../llm/token-counter";
+/**
+ * Фабрика тула load_skill. Контент скилла инжектится в системный промпт
+ * (не в историю) — переживает компакцию. Возврат: определение тула.
+ */
 export function createLoadSkillTool(skillsModule) {
     return {
         name: "load_skill",
         icon: "🎯",
         tags: ["core"],
+        // Роутинг скиллов — вне сужения (P5): модель использует только видимый скилл.
+        alwaysOn: true,
         description: "Load a skill by name. Skills provide specialized instructions and workflows. When loaded, the skill content is injected into the system prompt (not conversation history) so it persists through context compaction. Only use when the task clearly requires domain-specific knowledge.",
         parameters: {
             type: "object",

package/dist/tools/mcp-call.js

@@ -1,7 +1,10 @@
+/** Тул вызова тула на MCP-сервере (ленивая регистрация из конфига). */
+import { t } from "../i18n/index";
 import { MCPClient } from "../modules/mcp/client";
 import { MCPRegistry } from "../modules/mcp/registry";
 const registry = new MCPRegistry();
 let initialized = false;
+/** Ленивая регистрация MCP-серверов из конфига (один раз на процесс). */
 function ensureInitialized(ctx) {
     if (initialized)
         return;
@@ -22,6 +25,7 @@ function ensureInitialized(ctx) {
         }
     }
 }
+/** Вызывает тул на MCP-сервере. Параметры: server, tool, args. */
 export const mcpCallTool = {
     name: "mcp_call",
     icon: "🔗",
@@ -49,21 +53,28 @@ export const mcpCallTool = {
             const available = registry.list();
             return {
                 success: false,
-                output: `MCP server "${serverName}" not found. Available: ${available.join(", ") || "(none)"}`,
+                output: t("tool.mcp_server_not_found", {
+                    server: serverName,
+                    available: available.join(", ") || "(none)",
+                }),
             };
         }
+        const client = new MCPClient(serverConfig);
         try {
-            const client = new MCPClient(serverConfig);
             await client.connect();
             const result = await client.callTool(toolName, toolArgs);
-            await client.disconnect();
             return {
                 success: true,
                 output: `MCP call result:\n${JSON.stringify(result, null, 2)}`,
             };
         }
         catch (e) {
-            return { success: false, output: `MCP call failed: ${e.message}` };
+            return { success: false, output: t("tool.mcp_call_failed", { error: e.message }) };
+        }
+        finally {
+            // Клиент закрывать всегда: раньше ошибка/таймаут в callTool пропускала
+            // disconnect и сиротила stdio-дочерний процесс на сессию.
+            await client.disconnect().catch(() => { });
         }
     },
 };

package/dist/tools/meet-done.js

@@ -0,0 +1,14 @@
+/** Сентинел завершения meet-интервью: ставит флаг, REPL выходит из режима. */
+import { t } from "../i18n/index";
+/** Модель зовёт по финальному саммари; вне онбординга — no-op по флагу. */
+export const meetDoneTool = {
+    name: "meet_done",
+    description: "Signal that the get-acquainted interview is complete. Call only after the final summary.",
+    tags: ["memory"],
+    parameters: { type: "object", properties: {} },
+    handler: async (ctx) => {
+        if (ctx.onboarding)
+            ctx.onboarding.done = true;
+        return { success: true, output: t("tool.meet_done") };
+    },
+};