micro-models-agent 2.16.1 → 2.17.2

package/dist/tools/remember.js

@@ -1,72 +0,0 @@
-/** Тул записи в межсессионную память (preferences, факты, решения, ошибки). */
-import { t } from "../i18n/index";
-import { MemoryStore } from "../modules/memory/store";
-import { globalMemoryDir } from "../config/paths";
-/** Категории памяти. */
-const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
-/** Пишет факт/преференс в глобальную память. Параметры: category, key/value или entry. */
-export const rememberTool = {
-    name: "remember",
-    icon: "🧠",
-    description: "Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.",
-    tags: ["memory"],
-    parameters: {
-        type: "object",
-        properties: {
-            category: {
-                type: "string",
-                description: "Memory category: preferences, conventions, decisions, errors, facts",
-                enum: CATEGORIES,
-            },
-            key: {
-                type: "string",
-                description: 'Key name (required for preferences, e.g. "color", "language")',
-            },
-            value: {
-                type: "string",
-                description: "Value to store (required for preferences)",
-            },
-            entry: {
-                type: "string",
-                description: "Text entry to append (for conventions, decisions, errors, facts)",
-            },
-        },
-        required: ["category"],
-    },
-    handler: async (_ctx, args) => {
-        const category = String(args.category || "");
-        if (!CATEGORIES.includes(category)) {
-            return { success: false, output: t("tool.invalid_params") };
-        }
-        const memoryDir = globalMemoryDir();
-        const store = new MemoryStore(memoryDir);
-        try {
-            if (category === "preferences") {
-                const key = String(args.key || "");
-                const value = String(args.value || "");
-                if (!key) {
-                    return { success: false, output: t("tool.remember.key_required") };
-                }
-                store.setPreference(key, value);
-                return {
-                    success: true,
-                    output: t("tool.remember.preference", { key, value }),
-                };
-            }
-            const entry = String(args.entry || "");
-            if (!entry) {
-                return { success: false, output: t("tool.remember.entry_required") };
-            }
-            store.append(category, entry);
-            return {
-                success: true,
-                output: t("tool.remember.entry", { category, entry }),
-            };
-        }
-        catch (err) {
-            // Упавшая запись — провал: отчёт об успехе заставлял агента (и учёт
-            // падений) верить, что память сохранена.
-            return { success: false, output: t("tool.memory_error", { error: String(err) }) };
-        }
-    },
-};

package/dist/tools/scope-check.js

@@ -1,32 +0,0 @@
-import { resolve, normalize } from "path";
-import { isInsideDir, matchesScopeEntry } from "./path-utils";
-export function isPathInScope(baseDir, targetPath, scope) {
-    const baseResolved = resolve(baseDir);
-    const targetResolved = resolve(baseDir, normalize(targetPath));
-    // Separator- and case-safe containment (sibling prefixes cannot pass).
-    if (!isInsideDir(targetResolved, baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
-    }
-    if (!scope)
-        return { allowed: true };
-    const isRead = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    if (isWrite)
-        return { allowed: true };
-    if (isRead)
-        return { allowed: true, reason: "Read-only file" };
-    return { allowed: false, reason: "Path is not within the allowed scope for this sub-agent" };
-}
-export function isPathWritable(baseDir, targetPath, scope) {
-    const baseResolved = resolve(baseDir);
-    const targetResolved = resolve(baseDir, normalize(targetPath));
-    if (!isInsideDir(targetResolved, baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
-    }
-    if (!scope)
-        return { allowed: true };
-    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    if (isWrite)
-        return { allowed: true };
-    return { allowed: false, reason: "Path is not within the writable scope for this sub-agent" };
-}

package/dist/tools/scope-request.js

@@ -1,96 +0,0 @@
-/** Тулы записи (для классификации отказа как write). */
-const WRITE_TOOLS = new Set([
-    "write_file",
-    "edit_file",
-    "delete_file",
-    "create_dir",
-    "move_file",
-    "download_file",
-]);
-/**
- * Отказы скоупа идут через i18n-ключи file.path_not_allowed(_short)
- * ("Path not allowed" / "Путь недопустим") и "[SCOPE]"-префикс chunk-query.
- */
-export function isPathDenialOutput(output) {
-    if (!output)
-        return false;
-    return (output.includes("Path not allowed") ||
-        output.includes("Путь недопустим") ||
-        output.startsWith("[SCOPE]"));
-}
-/** Извлекает путь из аргументов tool call (по именам ключей, иначе по виду). */
-function pathArgOf(args) {
-    if (!args)
-        return "";
-    for (const key of ["path", "file", "input_path", "target", "source", "destination", "dir"]) {
-        const v = args[key];
-        if (typeof v === "string" && v.trim())
-            return v.trim();
-    }
-    for (const v of Object.values(args)) {
-        if (typeof v === "string" && /\.[\w-]+$/.test(v))
-            return v.trim();
-    }
-    return "";
-}
-/** Наблюдает результаты тулов субагента, копит scope-отказы по путям. */
-export class ScopeDenialCollector {
-    denied = new Map();
-    plugin = {
-        name: "scope-denial-collector",
-        isBuiltin: true,
-        onAfterTool: (_ctx, call, result) => {
-            const name = call.name;
-            if (!name || !result || result.success)
-                return;
-            if (!isPathDenialOutput(typeof result.output === "string" ? result.output : undefined)) {
-                return;
-            }
-            const path = pathArgOf(call.arguments);
-            if (!path)
-                return;
-            const write = WRITE_TOOLS.has(name);
-            this.denied.set(path, { path, write });
-        },
-    };
-    /** Все отказы дедуплицированно. */
-    getDenied() {
-        return Array.from(this.denied.values());
-    }
-    /** read_only=true — только если все отказы были чисто read. */
-    toScopeRequest(reason = "sub-agent was denied access to files needed for the task") {
-        const all = this.getDenied();
-        if (all.length === 0)
-            return null;
-        return {
-            files: all.map((d) => d.path),
-            read_only: !all.some((d) => d.write),
-            reason,
-        };
-    }
-}
-/** Сериализует запрос в `<scope-request>`-блок результата. */
-export function formatScopeRequest(req) {
-    return `<scope-request>${JSON.stringify(req)}</scope-request>`;
-}
-/** Парсит `<scope-request>`-блок из текста. Битый/пустой — null. */
-export function parseScopeRequest(text) {
-    if (!text)
-        return null;
-    const match = text.match(/<scope-request>([\s\S]*?)<\/scope-request>/);
-    if (!match)
-        return null;
-    try {
-        const parsed = JSON.parse(match[1]);
-        if (!Array.isArray(parsed.files) || parsed.files.length === 0)
-            return null;
-        return {
-            files: parsed.files.map(String),
-            read_only: !!parsed.read_only,
-            reason: String(parsed.reason || "access denied"),
-        };
-    }
-    catch {
-        return null;
-    }
-}

package/dist/tools/search-history.js

@@ -1,88 +0,0 @@
-/** Тул поиска по истории сессий (JSONL всех сессий, cap результатов). */
-import * as fs from "fs";
-import { join } from "path";
-import { t } from "../i18n/index";
-import { globalSessionsDir } from "../config/paths";
-/** Ищет запрос в одном history.jsonl, складывает ужатые JSON-записи. */
-function searchFile(filePath, query, maxResults, results) {
-    if (!fs.existsSync(filePath))
-        return;
-    const content = fs.readFileSync(filePath, "utf-8");
-    for (const line of content.split("\n").filter(Boolean)) {
-        if (line.toLowerCase().includes(query)) {
-            try {
-                const entry = JSON.parse(line);
-                results.push(`[${filePath}] ${JSON.stringify(entry).slice(0, 200)}`);
-            }
-            catch {
-                /* skip */
-            }
-        }
-        if (results.length >= maxResults)
-            break;
-    }
-}
-/** Ищет по прошлым взаимодействиям всех сессий. Параметры: query, maxResults, sessionId. */
-export const searchHistoryTool = {
-    name: "search_history",
-    icon: "🕵️",
-    description: "Search through session history for past interactions across all sessions.",
-    tags: ["research"],
-    parameters: {
-        type: "object",
-        properties: {
-            query: { type: "string", description: "Search query" },
-            maxResults: {
-                type: "number",
-                description: "Maximum results (default 5)",
-            },
-            sessionId: {
-                type: "string",
-                description: "Optional: limit search to a specific session",
-            },
-        },
-        required: ["query"],
-    },
-    handler: async (_ctx, args) => {
-        const query = String(args.query || "").toLowerCase();
-        const maxResults = Number(args.maxResults) || 5;
-        const sessionId = args.sessionId ? String(args.sessionId) : null;
-        const sessionDir = globalSessionsDir();
-        const results = [];
-        try {
-            if (!fs.existsSync(sessionDir)) {
-                return {
-                    success: true,
-                    output: t("tool.no_sessions_dir", { dir: sessionDir }),
-                };
-            }
-            const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                if (sessionId && entry.name !== sessionId)
-                    continue;
-                const historyFile = join(sessionDir, entry.name, "history.jsonl");
-                searchFile(historyFile, query, maxResults, results);
-                if (results.length >= maxResults)
-                    break;
-            }
-            if (results.length === 0) {
-                return { success: true, output: t("tool.no_history", { query }) };
-            }
-            return {
-                success: true,
-                output: t("tool.history_results", {
-                    query,
-                    results: results.join("\n"),
-                }),
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                output: t("tool.history_error", { error: String(err) }),
-            };
-        }
-    },
-};

package/dist/tools/session-info.js

@@ -1,46 +0,0 @@
-/** Тул метаданных текущей сессии (id, модель, бюджет контекста; alwaysOn). */
-import { t } from "../i18n/index";
-/** Показывает сессию и загрузку контекстного бюджета. Без активной — пометка. */
-export const sessionInfoTool = {
-    name: "session_info",
-    icon: "ℹ️",
-    description: "Show metadata about the current session: id, name, model, provider, context window, message count, and how much of the context budget is used. Use when the user asks which session this is or how much context is left.",
-    alwaysOn: true,
-    boundedOutput: true,
-    parameters: {
-        type: "object",
-        properties: {},
-    },
-    handler: async (ctx) => {
-        const meta = ctx.sessionManager?.getActiveMeta();
-        if (!meta) {
-            return { success: true, output: t("tool.session_info.no_active") };
-        }
-        const provider = ctx.config.provider;
-        const providerName = provider.active ?? provider.type ?? "unknown";
-        const lines = [
-            t("tool.session_info.result", {
-                id: meta.id,
-                name: meta.name,
-                model: meta.model ?? ctx.config.model ?? "unknown",
-                provider: providerName,
-                contextWindow: String(meta.contextWindow ?? ctx.config.contextWindow),
-                messages: String(meta.messageCount),
-                createdAt: meta.createdAt,
-                updatedAt: meta.updatedAt,
-            }),
-        ];
-        const snapshot = ctx.contextManager?.getSnapshot();
-        if (snapshot) {
-            const used = snapshot.tokens;
-            const budget = snapshot.budget.history;
-            const percent = budget > 0 ? Math.round((used / budget) * 100) : 0;
-            lines.push(t("tool.session_info.context", {
-                used: String(used),
-                budget: String(budget),
-                percent: String(percent),
-            }));
-        }
-        return { success: true, output: lines.join("\n") };
-    },
-};

package/dist/tools/set-thinking.js

@@ -1,75 +0,0 @@
-/** Тул ручной установки reasoning-уровня (транзиентный, с кулдауном). */
-import { t } from "../i18n/index";
-/** Допустимые уровни reasoning. */
-const VALID_LEVELS = ["default", "none", "low", "medium", "high", "max"];
-/**
- * Фабрика тула set_thinking (уровень на следующий LLM-вызов; штатно рулит
- * харнесс). Возврат: определение тула.
- */
-export function createSetThinkingTool(state, config, getCurrentIteration) {
-    return {
-        name: "set_thinking",
-        description: "Set reasoning effort level for the next LLM call. Normally managed automatically by the harness. Use only to force deeper thinking for genuinely hard subproblems or shallower for mechanical batches.",
-        icon: "🧠",
-        tags: [],
-        alwaysOn: true,
-        parameters: {
-            type: "object",
-            properties: {
-                level: {
-                    type: "string",
-                    enum: ["none", "low", "high", "max"],
-                    description: "Reasoning effort level to set",
-                },
-                reason: {
-                    type: "string",
-                    description: "Why changing the level",
-                },
-            },
-            required: ["level"],
-        },
-        handler: async (_ctx, args) => {
-            const requested = args.level;
-            const reason = args.reason || "agent override";
-            if (!VALID_LEVELS.includes(requested) && requested !== "auto") {
-                return {
-                    success: false,
-                    output: t("tool.thinking_invalid_level", { level: requested }),
-                };
-            }
-            // Проверка кулдауна.
-            const currentIter = getCurrentIteration();
-            const elapsed = currentIter - state.overrideIteration;
-            if (elapsed > 0 && elapsed < config.overrideCooldown) {
-                return {
-                    success: true,
-                    output: t("tool.thinking_cooldown", {
-                        remaining: config.overrideCooldown - elapsed,
-                        current: state.level,
-                    }),
-                };
-            }
-            // Кламп в настроенные границы.
-            let level = requested;
-            const levelOrder = ["none", "low", "medium", "high", "max"];
-            const minIdx = levelOrder.indexOf(config.min);
-            const maxIdx = levelOrder.indexOf(config.max);
-            const reqIdx = levelOrder.indexOf(level);
-            let clamped = false;
-            if (reqIdx >= 0 && reqIdx < minIdx) {
-                level = config.min;
-                clamped = true;
-            }
-            else if (reqIdx > maxIdx) {
-                level = config.max;
-                clamped = true;
-            }
-            state.level = level;
-            state.overrideIteration = currentIter;
-            const msg = clamped
-                ? t("tool.thinking_set_clamped", { level, reason })
-                : t("tool.thinking_set", { level, reason });
-            return { success: true, output: msg };
-        },
-    };
-}

package/dist/tools/subagent.js

@@ -1,257 +0,0 @@
-/** Тул изолированного субагента (свой контекст, скоуп, теги тулов, MoE-off). */
-import { t } from "../i18n/index";
-import { Agent } from "../core/agent";
-import { ContextManager } from "../modules/context/manager";
-import { HallucinationDetector } from "../modules/hallucination/detector";
-import { PluginManager } from "../modules/plugins/manager";
-import { logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { ArtifactStore } from "../modules/artifacts/store";
-import { ScopeDenialCollector, formatScopeRequest } from "./scope-request";
-/** Фиксированный системный промпт (KV-cache дружит при stableSystemPrompt). */
-export const SUBAGENT_SYSTEM_PROMPT_TEMPLATE = `You are a sub-agent working on a specific task. You have your own context window and tool set.
-
-Workflow rules:
-- Prefer small, focused steps. Verify your own work (typecheck/tests) before finishing.
-- For large outputs, write the result to a file with write_file instead of reproducing it in your answer.
-- If the task is big and decomposable, delegate parts to the subagent tool instead of doing everything in one context.
-- When you finish, return a concise final answer; do not repeat file contents verbatim if you already wrote them to disk.`;
-/** Собирает системный промпт субагента (стабильный или с контекстом). */
-function buildSubagentSystemPrompt(context, stable) {
-    if (stable)
-        return SUBAGENT_SYSTEM_PROMPT_TEMPLATE;
-    return `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`;
-}
-/** Спавнит изолированного субагента. Параметры: task, scope-файлы, tool_tags, result_mode. */
-export const subagentTool = {
-    name: "subagent",
-    icon: "🤖",
-    description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
-    tags: ["code"],
-    timeoutMs: 180000,
-    parameters: {
-        type: "object",
-        properties: {
-            task: {
-                type: "string",
-                description: "Task description for the sub-agent",
-            },
-            context: {
-                type: "string",
-                description: "Optional context or constraints",
-            },
-            expert_tag: {
-                type: "string",
-                description: "Expert tag for tool filtering and model selection",
-            },
-            allowed_files: {
-                type: "array",
-                items: { type: "string" },
-                description: "Files/directories the sub-agent can read and write",
-            },
-            read_only_files: {
-                type: "array",
-                items: { type: "string" },
-                description: "Files/directories the sub-agent can read but not write",
-            },
-            shared_context: {
-                type: "string",
-                description: "Shared context/rules passed to the sub-agent",
-            },
-            max_tokens: {
-                type: "number",
-                description: "Maximum tokens for the sub-agent response",
-            },
-            tool_tags: {
-                type: "array",
-                items: { type: "string" },
-                description: "Tool tags to expose to the sub-agent",
-            },
-            result_mode: {
-                type: "string",
-                enum: ["text", "file"],
-                description: '"file": persist the full result to an artifact and return a path + summary (pass-by-reference). "text" (default): return the full text into context.',
-            },
-            artifact_name: {
-                type: "string",
-                description: "Artifact file name (sanitized). Default: subagent-<timestamp>.",
-            },
-        },
-        required: ["task"],
-    },
-    handler: async (ctx, args) => {
-        const task = String(args.task || "");
-        const context = String(args.context || "");
-        if (!task) {
-            return { success: false, output: t("tool.name_or_task") };
-        }
-        // Сессионный security-конфиг.
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
-            : ctx.config.security;
-        // Лимит глубины рекурсии. Глубину читаем из SHARED-контекста исполнителя
-        // (его видят вложенные субагенты) — `ctx.recursionDepth` снапшотился раз при
-        // bootstrap и не инкрементился, поэтому гард не срабатывал и субагент мог
-        // спавнить субагентов безгранично.
-        const executor = ctx.toolExecutor;
-        const parentDepth = executor?.getRecursionDepth?.() ?? (ctx.recursionDepth ?? 0);
-        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
-        const currentDepth = parentDepth;
-        if (currentDepth >= maxDepth) {
-            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, task);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum sub-agent recursion depth (${maxDepth}) exceeded`,
-            };
-        }
-        const scope = args.allowed_files || args.read_only_files
-            ? {
-                allowed_files: args.allowed_files || [],
-                read_only_files: args.read_only_files || [],
-            }
-            : ctx.scope;
-        const toolTags = args.tool_tags ? args.tool_tags : undefined;
-        if (!ctx.llmProvider || !ctx.toolExecutor) {
-            return {
-                success: false,
-                output: t("tool.subagent_cannot_run"),
-            };
-        }
-        // Оборонительный гард: запрошенные tool_tags ни с чем не мэтчатся — у
-        // субагента ноль тулов, и он галлюцинирует вместо действий. Предупредить
-        // вызывающего для коррекции тегов. Проверка через getByTags (не
-        // getAllForLLM): alwaysOn мэтчатся всегда — гард меряет реальное покрытие,
-        // а не присутствие в схеме.
-        if (toolTags && toolTags.length > 0) {
-            const matched = ctx.toolExecutor.getRegistry().getByTags(toolTags);
-            if (matched.length === 0) {
-                return {
-                    success: false,
-                    output: `[SECURITY BLOCKED] No tools match the requested tool_tags: [${toolTags.join(", ")}]. Check the subagent tool_tags parameter and retry with valid tags (e.g. "file", "code", "shell", "research").`,
-                };
-            }
-        }
-        // Сейв/рестор shared-скоупа исполнителя, чтобы субагент не мутировал скоуп
-        // родителя навсегда. Текущий скоуп — из shared-исполнителя, не `ctx.scope`:
-        // MoE зовёт тул с ad-hoc контекстом без scope — снапшот `ctx.scope` ресторил
-        // бы "unrestricted" и сносил изоляцию всей волне.
-        const parentScope = executor?.getScope?.() ?? ctx.scope;
-        const appliedScope = scope || { allowed_files: [], read_only_files: [] };
-        // Compare-and-restore: параллельная MoE-волна могла тем временем поставить
-        // свой скоуп — чужого свежего владельца не затирать.
-        const restoreScope = () => {
-            if (ctx.toolExecutor?.getScope?.() === appliedScope) {
-                ctx.toolExecutor.setScope(parentScope);
-            }
-        };
-        try {
-            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
-            const subPluginManager = new PluginManager();
-            // Детерминированный трекинг scope-отказов: блокировки файловых тулов
-            // ребёнка скоуп-гардом всплывают машиночитаемым блоком <scope-request>
-            // в результате (см. MoE executor / Router).
-            const scopeCollector = new ScopeDenialCollector();
-            subPluginManager.register(scopeCollector.plugin, "builtin");
-            const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
-            ctx.toolExecutor.setScope(appliedScope);
-            // Cleanup на исполнителе — рестор скоупа при таймауте/аборте, даже если
-            // `finally` агента не отработал (брошенный промис).
-            ctx.cleanup = restoreScope;
-            // Глубину — на shared-контекст исполнителя, чтобы ВЛОЖЕННЫЕ субагенты
-            // видели уровень глубже (и гард выше мог сработать).
-            ctx.recursionDepth = currentDepth + 1;
-            executor?.setRecursionDepth?.(currentDepth + 1);
-            const systemPrompt = {
-                content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
-                priority: "critical",
-                essential: true,
-                estimatedTokens: 150,
-            };
-            // MoE — TOP-LEVEL режим оркестрации: субагент от тула subagent всегда идёт
-            // plain single-agent циклом. Шаринг родительского конфига заставлял каждого
-            // MoE-субагента реентерить runWithMoE — планировать свои сабтаски и рекурсивно
-            // спавнить вложенных субагентов (лимит — лишь maxRecursionDepth), что вешало
-            // исполнение на минуты без прогресс-событий.
-            const subConfig = { ...ctx.config, moe: { ...ctx.config.moe, enabled: false } };
-            const subDeps = {
-                config: subConfig,
-                llmProvider: ctx.llmProvider,
-                toolExecutor: ctx.toolExecutor,
-                pluginManager: subPluginManager,
-                contextManager: subContextManager,
-                hallucinationDetector,
-                logger: ctx.logger,
-                baseDir: ctx.baseDir,
-                scope,
-                toolTags,
-                promptBlocks: [systemPrompt],
-            };
-            const subAgent = (ctx.agentFactory ?? ((d) => new Agent(d)))(subDeps);
-            const fullTask = context ? `${task}\n\nContext: ${context}` : task;
-            try {
-                const result = await subAgent.run(fullTask);
-                const pickUsage = () => result.promptTokens !== undefined || result.totalTokens !== undefined
-                    ? {
-                        promptTokens: result.promptTokens ?? 0,
-                        completionTokens: result.completionTokens ?? 0,
-                        totalTokens: result.totalTokens ?? 0,
-                    }
-                    : undefined;
-                if (!result.success) {
-                    let output = t("tool.subagent_failed", {
-                        error: String(result.error),
-                        text: result.text,
-                    });
-                    const scopeReq = scopeCollector.toScopeRequest();
-                    if (scopeReq)
-                        output += `\n${formatScopeRequest(scopeReq)}`;
-                    return { success: false, output };
-                }
-                const resultMode = args.result_mode || ctx.config.subagent?.resultMode || "text";
-                if (resultMode === "file") {
-                    const store = new ArtifactStore({
-                        baseDir: ctx.baseDir,
-                        sessionId: ctx.sessionId || "default",
-                        artifactsDir: ctx.config.subagent?.artifactsDir,
-                    });
-                    const abs = store.save(args.artifact_name || `subagent-${Date.now()}`, result.text, "md");
-                    const summary = store.summary(result.text, ctx.config.subagent?.maxSummaryChars ?? 2000);
-                    ctx.logger.debug(`subagent result persisted to artifact ${abs} (${result.text.length} chars, ${result.iterationCount} iterations)`);
-                    return {
-                        success: true,
-                        output: t("tool.subagent_artifact", {
-                            path: abs,
-                            iterations: String(result.iterationCount),
-                            summary,
-                        }),
-                        // Структурированный путь, чтобы вызывающие (MoE executor) не парсили
-                        // локализованную строку `output`.
-                        artifactPath: abs,
-                        usage: pickUsage(),
-                    };
-                }
-                return {
-                    success: true,
-                    output: t("tool.subagent_completed", {
-                        text: result.text,
-                        iterations: String(result.iterationCount),
-                    }),
-                    usage: pickUsage(),
-                };
-            }
-            finally {
-                // Рестор точного скоупа родителя (compare-and-restore — свежий скоуп
-                // параллельного сиблинга не затирать). undefined — "без ограничений",
-                // пустым скоупом (запрет всего) становиться не должен.
-                restoreScope();
-                if (ctx.cleanup === restoreScope)
-                    ctx.cleanup = undefined;
-                ctx.recursionDepth = currentDepth;
-                executor?.setRecursionDepth?.(currentDepth);
-            }
-        }
-        catch (e) {
-            return { success: false, output: t("tool.subagent_error", { error: e.message }) };
-        }
-    },
-};