@itphx/synth-core 0.2.0 → 0.4.4

package/dist/engine/tools/task.js

@@ -1,13 +1,47 @@
 import { z } from 'zod';
-import { ToolCapability, MessageRole, nowISO, generateId, makeTextPart, TsmState } from '@itphx/synth-shared';
+import { ToolCapability, MessageRole, nowISO, generateId, makeTextPart } from '@itphx/synth-shared';
+import { normalizeAgentModes } from '../agents/normalize.js';
 import { EventBus } from '../../events/bus.js';
+import { classifyLlmError, isLlmErrorRecoverable, LLM_MAX_ATTEMPTS, LLM_RETRY_DELAYS_MS } from '../llm-error.js';
 import { deriveSubagentPermission } from '../permission/derive.js';
-import { PermissionEvaluator } from '../permission/evaluator.js';
+import { PermissionEvaluator, isPlanRestricted, isPlanBlockedTool, getMcpToolAvailability } from '../permission/evaluator.js';
 import { PermissionApprovalManager } from '../permission/approval.js';
 import { serializeSession, serializeMessage } from '../../server/serialize.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { t as sm, i18n as i18nMeta } from '../system-messages.js';
 const DEFAULT_SUBAGENT_MAX_STEPS = 15;
 const DEFAULT_LAST_N = 4;
-function messageToLLMMessage(msg) {
+/** Retry саб-агента: максимум попыток LLM-вызова (единая политика — LLM_MAX_ATTEMPTS). */
+export const SUBAGENT_MAX_ATTEMPTS = LLM_MAX_ATTEMPTS;
+/** Backoff между попытками (единая политика — LLM_RETRY_DELAYS_MS). */
+export const SUBAGENT_RETRY_DELAYS_MS = LLM_RETRY_DELAYS_MS;
+/**
+ * Промпт саб-агента по языку сессии: prompts/subagents/{type}.{lang}.md →
+ * {type}.md → agentDef.subagentPrompt (definitions JSON, легаси).
+ * Каталог промптов — systemPromptsDir из ContextConfig (резолв prompts/ или dist/prompts).
+ */
+export function resolveSubagentPrompt(agentDef, subagentType, language, systemPromptsDir) {
+    if (systemPromptsDir) {
+        const lang = language === 'en' ? 'en' : 'ru';
+        const localizedPath = join(systemPromptsDir, 'subagents', `${subagentType}.${lang}.md`);
+        if (existsSync(localizedPath)) {
+            try {
+                return readFileSync(localizedPath, 'utf-8');
+            }
+            catch { /* fallback ниже */ }
+        }
+        const basePath = join(systemPromptsDir, 'subagents', `${subagentType}.md`);
+        if (existsSync(basePath)) {
+            try {
+                return readFileSync(basePath, 'utf-8');
+            }
+            catch { /* fallback ниже */ }
+        }
+    }
+    return agentDef.subagentPrompt || '';
+}
+export function messageToLLMMessage(msg) {
     const roleMap = {
         [MessageRole.USER]: 'user',
         [MessageRole.ASSISTANT]: 'assistant',
@@ -27,9 +61,10 @@ function messageToLLMMessage(msg) {
         pinned: false,
         branchId: '',
         toolCallId: msg.toolCallId,
+        toolUse: msg.toolCalls,
     };
 }
-async function publishMessageAdded(eventBus, parentSessionId, childSessionId, msg, index, childSession) {
+export async function publishMessageAdded(eventBus, parentSessionId, childSessionId, msg, index, childSession) {
     const serialized = serializeMessage(msg, index);
     const payload = {
         session_id: childSessionId,
@@ -73,44 +108,42 @@ export const taskTool = {
     async execute(args, ctx) {
         const parsed = this.parameters.safeParse(args);
         if (!parsed.success) {
-            return { content: `Ошибка аргументов инструмента "${this.name}": ${parsed.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ')}`, isError: true };
+            return { content: sm('tool.args_error', { tool: this.name, issues: parsed.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ') }), isError: true, metadata: { i18n: i18nMeta('tool.args_error', { tool: this.name }) } };
         }
         const params = parsed.data;
         const extra = ctx.extra;
         if (!extra?.provider || !extra?.agentRegistry) {
             return {
-                content: 'Ошибка: провайдер или реестр агентов недоступны для запуска сабагента',
+                content: sm('task.deps_unavailable'),
                 isError: true,
             };
         }
         const agentDef = extra.agentRegistry.get(params.subagent_type);
         if (!agentDef) {
             return {
-                content: `Сабагент "${params.subagent_type}" не найден. Доступные типы: ${extra.agentRegistry.getSubagents().map((a) => a.id).join(', ')}`,
+                content: sm('task.subagent_not_found', { type: params.subagent_type, types: extra.agentRegistry.getSubagents().map((a) => a.id).join(', ') }),
                 isError: true,
             };
         }
-        if (agentDef.agentMode !== 'subagent' && agentDef.agentMode !== 'all') {
+        if (!normalizeAgentModes(agentDef.agentMode).includes('subagent')) {
             return {
-                content: `Агент "${params.subagent_type}" не может использоваться как сабагент (agentMode: ${agentDef.agentMode ?? 'primary'})`,
+                content: sm('task.subagent_not_allowed', { type: params.subagent_type, modes: String(agentDef.agentMode) }),
                 isError: true,
             };
         }
         const contextMode = params.context_mode || 'none';
         const contextCount = params.context_count || DEFAULT_LAST_N;
-        const systemPrompt = agentDef.subagentPrompt || '';
+        const systemPrompt = resolveSubagentPrompt(agentDef, params.subagent_type, extra.parentSessionSettings?.language, extra.contextConfig?.systemPromptsDir);
         const tools = extra.agentRegistry.getToolsForAgent(agentDef.id);
         const maxSteps = agentDef.maxSteps ?? DEFAULT_SUBAGENT_MAX_STEPS;
-        const effectiveMaxSteps = (maxSteps === 0)
-            ? Number.POSITIVE_INFINITY
-            : maxSteps;
-        const publish = extra.publish;
         // ─── Настройки роутинга для дочерней сессии (AD-034 Фаза 4) ──
         const childRoutingOverrides = {};
         if (params.model)
             childRoutingOverrides.model = params.model;
         if (params.provider)
             childRoutingOverrides.provider = params.provider;
+        if (agentDef?.reasoningLevel)
+            childRoutingOverrides.reasoningLevel = agentDef.reasoningLevel;
         if (params.routing_strategy) {
             if (params.routing_strategy === 'none') {
                 childRoutingOverrides.routingEnabled = false;
@@ -149,7 +182,7 @@ export const taskTool = {
                     const effectiveMode = contextMode === 'summary' && !extra.contextOptimizer ? 'none' : contextMode;
                     if (effectiveMode === 'inherit') {
                         const fork = await extra.sessionManager.forkSession(extra.sessionId, {
-                            title: `Подзадача: ${params.description}`,
+                            title: sm('session.subtask_title', { description: params.description }),
                         });
                         fork.sessionOrigin = 'subagent';
                         fork.userId = parentSession.userId;
@@ -164,7 +197,7 @@ export const taskTool = {
                         const startIdx = Math.max(0, parentSession.messages.length - contextCount);
                         const fork = await extra.sessionManager.forkSession(extra.sessionId, {
                             messageIndex: startIdx,
-                            title: `Подзадача: ${params.description}`,
+                            title: sm('session.subtask_title', { description: params.description }),
                         });
                         fork.sessionOrigin = 'subagent';
                         fork.userId = parentSession.userId;
@@ -177,7 +210,7 @@ export const taskTool = {
                     }
                     else if (effectiveMode === 'summary') {
                         const fork = await extra.sessionManager.forkSession(extra.sessionId, {
-                            title: `Подзадача: ${params.description}`,
+                            title: sm('session.subtask_title', { description: params.description }),
                         });
                         fork.sessionOrigin = 'subagent';
                         fork.userId = parentSession.userId;
@@ -223,7 +256,7 @@ export const taskTool = {
                     else {
                         // none mode (default)
                         const child = await extra.sessionManager.createSession({
-                            title: `Подзадача: ${params.description}`,
+                            title: sm('session.subtask_title', { description: params.description }),
                             projectId: parentSession.projectId,
                             engine: parentSession.engine,
                             parentId: extra.sessionId,
@@ -382,49 +415,275 @@ export const taskTool = {
                 // не фатально
             }
         }
-        const cancelToken = { cancelled: false, cancel: () => { cancelToken.cancelled = true; } };
-        // ─── Permissions саб-агента (AD-029): проверка перед каждым tool_call ──
-        // Дочерняя сессия наследует permissions родителя (deriveSubagentPermission).
-        // ask-запросы публикуются в EventBus РОДИТЕЛЬСКОЙ сессии — подтверждение
-        // видит пользователь основной сессии, approval_id связывает ответ.
-        const childEvaluator = new PermissionEvaluator(derivedPermission);
-        const childApprovalManager = new PermissionApprovalManager(extra.eventBus ?? new EventBus());
-        let childSessionMode = 'act';
-        let childPlanApproved = false;
-        let childPlanMode = 'auto';
-        let childMcpToolSettings;
-        if (childSessionId && extra.sessionManager) {
-            try {
-                const child = await extra.sessionManager.getSession(childSessionId);
-                if (child) {
-                    childSessionMode = child.mode ?? 'act';
-                    childPlanApproved = Boolean(child.planContent);
-                    childPlanMode = child.settings.planMode ?? 'auto';
-                    childMcpToolSettings = child.settings.mcpToolSettings;
-                }
+        // ─── Запуск цикла саб-агента: общий код для task и resume (ниже) ──
+        return runSubagent({
+            subagentType: params.subagent_type,
+            description: params.description,
+            contextMode,
+            maxSteps,
+            systemPrompt,
+            llmSystemPrompt,
+            initialMessages: messages.slice(1),
+            provider: effectiveProvider,
+            tools,
+            childSessionId,
+            parentSessionId: extra.sessionId,
+            routingDecisionInfo,
+            extra,
+            ctx,
+            retry: extra.retry,
+        });
+    },
+};
+/** Пауза backoff порциями с проверкой отмены. Возвращает true, если отмена. */
+async function sleepAbortable(ms, isAborted) {
+    const SLICE_MS = 200;
+    let waited = 0;
+    while (waited < ms) {
+        if (isAborted())
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, Math.min(SLICE_MS, ms - waited)));
+        waited += SLICE_MS;
+    }
+    return isAborted();
+}
+export async function runSubagent(config) {
+    const { subagentType, description, contextMode, maxSteps, systemPrompt, llmSystemPrompt, initialMessages, provider: effectiveProvider, tools: toolsInput, childSessionId, parentSessionId, extra, ctx, } = config;
+    let tools = toolsInput;
+    let routingDecisionInfo = config.routingDecisionInfo;
+    const publish = extra.publish;
+    const effectiveMaxSteps = (!maxSteps || maxSteps === 0)
+        ? Number.POSITIVE_INFINITY
+        : maxSteps;
+    // ─── Retry-параметры (аналог QueueProcessor: 3 попытки, backoff 5/15/30с) ──
+    const retryCfg = config.retry ?? extra.retry
+        ?? { maxRetries: LLM_MAX_ATTEMPTS, delaysMs: LLM_RETRY_DELAYS_MS };
+    const retryMaxAttempts = Math.max(1, retryCfg.maxRetries);
+    const retryDelaysMs = retryCfg.delaysMs.length > 0 ? retryCfg.delaysMs : LLM_RETRY_DELAYS_MS;
+    // ─── Permissions дочерней сессии (AD-029): родитель + deny-дополнения ──
+    const derivedPermission = deriveSubagentPermission(extra.permissionConfig);
+    // ─── LLM-сообщения: system + начальные (история/промпт) ─────────
+    const messages = [
+        {
+            id: '',
+            role: 'system',
+            content: llmSystemPrompt,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            disabled: false,
+            pinned: false,
+            branchId: '',
+        },
+        ...initialMessages,
+    ];
+    const cancelToken = { cancelled: false, cancel: () => { cancelToken.cancelled = true; } };
+    // Связка локального cancel-токена саб-агента с родительским сигналом отмены:
+    // «Стоп» в родительской сессии (POST /sessions/:id/abort → orchestrator.cancel
+    // → внутренний toolAbortController.abort → ctx.abortSignal) должен немедленно
+    // прерывать LLM-стрим саб-агента и его цикл, а не ждать завершения всех шагов.
+    const isAborted = () => cancelToken.cancelled || ctx.abortSignal?.aborted === true;
+    if (ctx.abortSignal?.aborted) {
+        cancelToken.cancel();
+    }
+    else {
+        ctx.abortSignal?.addEventListener('abort', () => cancelToken.cancel(), { once: true });
+    }
+    // ─── Permissions саб-агента (AD-029): проверка перед каждым tool_call ──
+    // Дочерняя сессия наследует permissions родителя (deriveSubagentPermission).
+    // ask-запросы публикуются в EventBus РОДИТЕЛЬСКОЙ сессии — подтверждение
+    // видит пользователь основной сессии, approval_id связывает ответ.
+    const childEvaluator = new PermissionEvaluator(derivedPermission);
+    const childApprovalManager = new PermissionApprovalManager(extra.eventBus ?? new EventBus());
+    let childSessionMode = 'act';
+    let childPlanApproved = false;
+    let childPlanMode = 'auto';
+    let childMcpToolSettings;
+    if (childSessionId && extra.sessionManager) {
+        try {
+            const child = await extra.sessionManager.getSession(childSessionId);
+            if (child) {
+                childSessionMode = child.mode ?? 'act';
+                childPlanApproved = Boolean(child.planApproved);
+                childPlanMode = child.settings.planMode ?? 'auto';
+                childMcpToolSettings = child.settings.mcpToolSettings;
             }
-            catch {
-                // не фатально — остаёмся в act/auto
+        }
+        catch {
+            // не фатально — остаёмся в act/auto
+        }
+    }
+    // B5: режимная фильтрация списка тулов саб-агента (аналог
+    // orchestrator._filterToolsByMode). В plan-режиме (или strict без
+    // утверждённого плана) скрываем write/edit-тулы и git-запись — модель не
+    // видит инструменты, которые всё равно будут отклонены evaluator'ом.
+    if (isPlanRestricted(childSessionMode, childPlanMode, childPlanApproved) && tools) {
+        const filtered = [];
+        for (const tool of tools) {
+            const toolName = tool.function.name;
+            const toolDef = extra.toolRegistry?.get(toolName);
+            const capabilities = toolDef?.capabilities;
+            if (isPlanBlockedTool(toolName, capabilities))
+                continue;
+            // MCP-инструменты: в plan-режиме недоступный по настройкам тул убираем.
+            if (capabilities?.includes(ToolCapability.MCP) && childMcpToolSettings) {
+                const availability = getMcpToolAvailability(childMcpToolSettings, toolName);
+                if (availability && !availability.plan)
+                    continue;
             }
+            filtered.push(tool);
         }
+        tools = filtered;
+    }
+    // Финализация дочерней сессии: обновление updatedAt + события для UI.
+    // Отдельного статусного поля «завершена/прервана» у сессии нет
+    // (SessionStatus — только процессная блокировка blocked/blockedAt),
+    // поэтому факт прерывания/ошибки фиксируется metadata-маркерами
+    // в сообщениях истории дочерней сессии.
+    const finalizeChildSession = async () => {
+        if (!childSessionId || !extra.sessionManager)
+            return;
         try {
-            let finalContent = '';
-            let iteration = 0;
-            const doomTracker = new Map();
-            let subagentReasoning = '';
-            let subagentDenied = false;
-            const allSubagentReasoning = [];
-            const allSubagentIntermediateTexts = [];
-            const allSubagentToolCalls = [];
-            while (iteration < effectiveMaxSteps) {
-                if (cancelToken.cancelled)
+            const childSession = await extra.sessionManager.getSession(childSessionId);
+            if (childSession) {
+                childSession.updatedAt = nowISO();
+                await extra.sessionManager.updateSession(childSession);
+                if (extra.eventBus) {
+                    extra.eventBus.publish(childSessionId, 'session.updated', {
+                        session_id: childSessionId,
+                    });
+                    extra.eventBus.publish(parentSessionId, 'child.session.updated', {
+                        session: serializeSession(childSession),
+                    });
+                }
+            }
+        }
+        catch {
+            // не фатально
+        }
+    };
+    /** Добавить сообщение в дочернюю сессию + опубликовать события. */
+    const addChildMessage = async (msg) => {
+        if (!childSessionId || !extra.sessionManager)
+            return;
+        try {
+            const updated = await extra.sessionManager.addMessage(childSessionId, msg);
+            if (updated && extra.eventBus) {
+                const idx = updated.messages.length - 1;
+                await publishMessageAdded(extra.eventBus, parentSessionId, childSessionId, updated.messages[idx], idx, updated);
+            }
+        }
+        catch {
+            // не фатально
+        }
+    };
+    try {
+        let finalContent = '';
+        let iteration = 0;
+        const doomTracker = new Map();
+        let subagentReasoning = '';
+        let subagentDenied = false;
+        const allSubagentReasoning = [];
+        const allSubagentIntermediateTexts = [];
+        const allSubagentToolCalls = [];
+        // Завершение по отмене (Стоп в родительской сессии): сохранить частичный
+        // текст (если есть), поставить маркер прерывания в историю дочерней
+        // сессии, финализировать её (без статуса completed) и вернуть родителю
+        // tool_result с маркером остановки, частичным ответом и списком шагов.
+        const finishAborted = async (partialContent, partialReasoning) => {
+            // 1. Частичный стрим оборванной итерации — в историю дочерней сессии
+            if (partialContent) {
+                await addChildMessage({
+                    id: generateId(),
+                    role: MessageRole.ASSISTANT,
+                    seq: 0,
+                    origin: 'local',
+                    parts: [makeTextPart(partialContent)],
+                    content: partialContent,
+                    createdAt: nowISO(),
+                    disabled: false,
+                    pinned: false,
+                    hidden: false,
+                    agentRole: subagentType,
+                    ...(partialReasoning ? { reasoning: partialReasoning } : {}),
+                    metadata: {
+                        stream_id: extra.streamId,
+                        partial: true,
+                        interrupted: true,
+                    },
+                });
+            }
+            // 2. Маркер прерывания в историю дочерней сессии
+            const stopMarkerText = sm('task.stopped_by_user');
+            await addChildMessage({
+                id: generateId(),
+                role: MessageRole.INFO,
+                seq: 0,
+                origin: 'local',
+                parts: [makeTextPart(stopMarkerText)],
+                content: stopMarkerText,
+                createdAt: nowISO(),
+                disabled: false,
+                pinned: false,
+                hidden: false,
+                agentRole: subagentType,
+                metadata: {
+                    stream_id: extra.streamId,
+                    stopped_by: 'user',
+                    interrupted: true,
+                    i18n: i18nMeta('task.stopped_by_user'),
+                },
+            });
+            // 3. Финализация дочерней сессии
+            await finalizeChildSession();
+            // 4. tool_result родителю: маркер отмены + частичный текст + шаги + id сессии
+            const stepsCompleted = allSubagentToolCalls.length > 0
+                ? allSubagentToolCalls.map((t) => t.name).join(', ')
+                : 'none';
+            return {
+                content: [
+                    '<task_result>',
+                    `<summary>${description}</summary>`,
+                    '<status>stopped_by_user</status>',
+                    ...(childSessionId ? [`<child_session_id>${childSessionId}</child_session_id>`] : []),
+                    ...(partialContent ? [`<partial_output>\n${partialContent}\n</partial_output>`] : []),
+                    `<steps_completed>${stepsCompleted}</steps_completed>`,
+                    sm('task.stopped_before_completion'),
+                    '</task_result>',
+                ].join('\n'),
+                metadata: {
+                    subagent_type: subagentType,
+                    description: description,
+                    context_mode: contextMode,
+                    steps: iteration,
+                    child_session_id: childSessionId,
+                    stopped_by: 'user',
+                    interrupted: true,
+                    tool_calls: allSubagentToolCalls.length > 0 ? allSubagentToolCalls : undefined,
+                    partial_output: partialContent || undefined,
+                },
+            };
+        };
+        while (iteration < effectiveMaxSteps) {
+            if (isAborted())
+                break;
+            let accumulatedContent = '';
+            let toolCalls = [];
+            let reasoning = '';
+            let lastPublishedReasoning = '';
+            let lastPublishedContentLen = 0;
+            // ─── LLM-вызов с retry (B1, аналог QueueProcessor) ──────────────
+            // Recoverable-ошибки (network/timeout/rate_limit/server_error) ретраятся
+            // до retryMaxAttempts попыток с backoff; unrecoverable (auth/
+            // model_not_found/context_length) — сразу финальная ошибка. Backoff-пауза
+            // спит порциями с проверкой отмены: «Стоп» прерывает ожидание мгновенно.
+            // Событие subagent.retry и паузы НЕ пишут ничего в историю дочерней
+            // сессии — мусорные сообщения не создаются (только финальный ERROR).
+            let llmFailure = null;
+            for (let attempt = 1; attempt <= retryMaxAttempts; attempt++) {
+                if (isAborted())
                     break;
-                let accumulatedContent = '';
-                let toolCalls = [];
-                let reasoning = '';
                 try {
                     for await (const chunk of effectiveProvider.chatAsync(messages, systemPrompt || undefined, tools, undefined, cancelToken)) {
-                        if (cancelToken.cancelled)
+                        if (isAborted())
                             break;
                         if (chunk.isFinal) {
                             accumulatedContent = chunk.content;
@@ -432,62 +691,148 @@ export const taskTool = {
                         }
                         else {
                             accumulatedContent += chunk.content;
+                            const chunkReasoning = chunk.reasoning;
+                            if (chunkReasoning)
+                                reasoning = chunkReasoning;
                         }
                         if (chunk.toolCalls && chunk.toolCalls.length > 0) {
                             toolCalls = chunk.toolCalls;
                         }
-                    }
-                }
-                catch (err) {
-                    return {
-                        content: `Ошибка выполнения сабагента "${params.subagent_type}": ${String(err)}`,
-                        isError: true,
-                        metadata: { subagent_type: params.subagent_type },
-                    };
-                }
-                if (cancelToken.cancelled)
-                    break;
-                if (reasoning) {
-                    allSubagentReasoning.push({ text: reasoning, iteration });
-                }
-                if (!toolCalls || toolCalls.length === 0) {
-                    finalContent = accumulatedContent;
-                    if (reasoning)
-                        subagentReasoning = reasoning;
-                    // Сохранить финальный ответ ассистента в дочернюю сессию
-                    if (childSessionId && extra.sessionManager) {
-                        try {
-                            const assistantMsg = {
-                                id: generateId(),
-                                role: MessageRole.ASSISTANT,
-                                seq: 0,
-                                origin: 'local',
-                                parts: [makeTextPart(accumulatedContent)],
-                                content: accumulatedContent,
-                                createdAt: nowISO(),
-                                disabled: false,
-                                pinned: false,
-                                hidden: false,
-                                agentRole: params.subagent_type,
-                                reasoning: reasoning || undefined,
-                            };
-                            const updated = await extra.sessionManager.addMessage(childSessionId, assistantMsg);
-                            if (updated && extra.eventBus) {
-                                const idx = updated.messages.length - 1;
-                                await publishMessageAdded(extra.eventBus, extra.sessionId, childSessionId, updated.messages[idx], idx, updated);
+                        // Стримим размышления/промежуточный текст саб-агента РОДИТЕЛЮ,
+                        // чтобы в блоке `task` (по parent_call_id) они были видны во время работы.
+                        if (publish) {
+                            const liveReasoning = reasoning || '';
+                            const liveContent = accumulatedContent || '';
+                            if (liveReasoning !== lastPublishedReasoning || liveContent.length !== lastPublishedContentLen) {
+                                publish('subagent.progress', {
+                                    stream_id: extra.streamId,
+                                    session_id: extra.sessionId,
+                                    parent_call_id: extra.callId,
+                                    reasoning: liveReasoning,
+                                    content: liveContent,
+                                    iteration,
+                                });
+                                lastPublishedReasoning = liveReasoning;
+                                lastPublishedContentLen = liveContent.length;
                             }
                         }
-                        catch {
-                            // не фатально
-                        }
                     }
+                    llmFailure = null;
                     break;
                 }
-                if (accumulatedContent) {
-                    allSubagentIntermediateTexts.push({ text: accumulatedContent, iteration });
+                catch (err) {
+                    // Прерывание пользователем во время стрима (провайдер бросил
+                    // AbortError) — не ошибка, обработается через finishAborted ниже.
+                    if (isAborted())
+                        break;
+                    const rawError = err instanceof Error ? err.message : String(err);
+                    const errorType = classifyLlmError(rawError);
+                    if (!isLlmErrorRecoverable(err, rawError) || attempt >= retryMaxAttempts) {
+                        // Unrecoverable или попытки исчерпаны — финальная ошибка
+                        llmFailure = { error: err, errorType, attempts: attempt };
+                        break;
+                    }
+                    const delay = retryDelaysMs[Math.min(attempt - 1, retryDelaysMs.length - 1)] ?? 0;
+                    publish?.('subagent.retry', {
+                        stream_id: extra.streamId,
+                        session_id: extra.sessionId,
+                        child_session_id: childSessionId,
+                        parent_call_id: extra.callId,
+                        attempt,
+                        max_retries: retryMaxAttempts,
+                        retry_in: delay,
+                        error_type: errorType,
+                        error: rawError,
+                    });
+                    if (await sleepAbortable(delay, isAborted))
+                        break;
+                    // Сброс частичного контекста неудавшейся попытки
+                    accumulatedContent = '';
+                    reasoning = '';
+                    toolCalls = [];
+                    lastPublishedReasoning = '';
+                    lastPublishedContentLen = 0;
                 }
-                iteration++;
-                // Сохранить ответ ассистента с tool calls в дочернюю сессию
+            }
+            if (llmFailure) {
+                // Ошибка провайдера внутри саб-агента (после retry-цикла): фиксируем
+                // в истории дочерней сессии, финализируем её и возвращаем родителю
+                // tool_result с описанием ошибки, счётчиком попыток и child_session_id.
+                const attempts = llmFailure.attempts;
+                const errParams = { type: subagentType, error: String(llmFailure.error) };
+                const errKey = attempts > 1
+                    ? 'task.subagent_exec_error_after_retries'
+                    : 'task.subagent_exec_error';
+                const errText = attempts > 1
+                    ? sm(errKey, { ...errParams, attempts: String(attempts) })
+                    : sm(errKey, errParams);
+                await addChildMessage({
+                    id: generateId(),
+                    role: MessageRole.ERROR,
+                    seq: 0,
+                    origin: 'local',
+                    parts: [makeTextPart(errText)],
+                    content: errText,
+                    createdAt: nowISO(),
+                    disabled: false,
+                    pinned: false,
+                    hidden: false,
+                    agentRole: subagentType,
+                    metadata: {
+                        stream_id: extra.streamId,
+                        error: true,
+                        attempts,
+                        max_retries: retryMaxAttempts,
+                        error_type: llmFailure.errorType,
+                        i18n: i18nMeta(errKey, attempts > 1 ? { ...errParams, attempts: String(attempts) } : errParams),
+                    },
+                });
+                await finalizeChildSession();
+                return {
+                    content: [
+                        '<task_result>',
+                        `<summary>${description}</summary>`,
+                        '<status>error</status>',
+                        ...(childSessionId ? [`<child_session_id>${childSessionId}</child_session_id>`] : []),
+                        `<attempts>${attempts}</attempts>`,
+                        errText,
+                        '</task_result>',
+                    ].join('\n'),
+                    isError: true,
+                    metadata: {
+                        subagent_type: subagentType,
+                        description: description,
+                        context_mode: contextMode,
+                        steps: iteration,
+                        child_session_id: childSessionId,
+                        error: true,
+                        attempts,
+                        max_retries: retryMaxAttempts,
+                        error_type: llmFailure.errorType,
+                        tool_calls: allSubagentToolCalls.length > 0 ? allSubagentToolCalls : undefined,
+                    },
+                };
+            }
+            // Отмена (Стоп в родительской сессии): сохраняем частичный текст
+            // ТЕКУЩЕЙ итерации, ставим маркер прерывания в историю дочерней
+            // сессии, финализируем её (без статуса completed) и возвращаем
+            // родителю tool_result с маркером остановки, частичным ответом и
+            // списком выполненных шагов.
+            if (isAborted()) {
+                return await finishAborted(accumulatedContent, reasoning);
+            }
+            // Единая итерация для размышлений, промежуточного текста и вызовов
+            // инструментов этого шага — иначе в UI (и в дочерней сессии) ломается
+            // порядок: размышления идут на step N, а вызовы — на N+1.
+            const stepIteration = iteration;
+            if (reasoning) {
+                allSubagentReasoning.push({ text: reasoning, iteration: stepIteration });
+            }
+            if (!toolCalls || toolCalls.length === 0) {
+                finalContent = accumulatedContent;
+                if (reasoning)
+                    subagentReasoning = reasoning;
+                // Сохранить финальный ответ ассистента в дочернюю сессию
                 if (childSessionId && extra.sessionManager) {
                     try {
                         const assistantMsg = {
@@ -495,215 +840,237 @@ export const taskTool = {
                             role: MessageRole.ASSISTANT,
                             seq: 0,
                             origin: 'local',
-                            parts: [makeTextPart(accumulatedContent || '')],
-                            content: accumulatedContent || '',
+                            parts: [makeTextPart(accumulatedContent)],
+                            content: accumulatedContent,
                             createdAt: nowISO(),
                             disabled: false,
                             pinned: false,
                             hidden: false,
-                            agentRole: params.subagent_type,
-                            reasoning: reasoning || undefined,
+                            agentRole: subagentType,
+                            // Все размышления сабагента (по итерациям), склеенные в поле
+                            // reasoning — UI дочерней сессии показывает их блоками
+                            // (ReasoningBlock разбивает по «\n\n---\n\n»). Без этого размышления
+                            // остаются только в скрытых tool_chain-сообщениях и теряются.
+                            reasoning: allSubagentReasoning.length > 0
+                                ? allSubagentReasoning.map((r) => r.text).join('\n\n---\n\n')
+                                : undefined,
+                            // Как в _persistToolChain родителя: финальное сообщение несёт
+                            // свёрнутую цепочку тулов, чтобы UI дочерней сессии отрисовал её
+                            // так же аккуратно, как финал родительской.
+                            metadata: {
+                                stream_id: extra.streamId,
+                                ...(allSubagentToolCalls.length > 0 ? { tool_results: allSubagentToolCalls } : {}),
+                                ...(allSubagentIntermediateTexts.length > 0 ? { intermediate_text_blocks: allSubagentIntermediateTexts } : {}),
+                            },
                         };
                         const updated = await extra.sessionManager.addMessage(childSessionId, assistantMsg);
                         if (updated && extra.eventBus) {
                             const idx = updated.messages.length - 1;
-                            await publishMessageAdded(extra.eventBus, extra.sessionId, childSessionId, updated.messages[idx], idx, updated);
+                            await publishMessageAdded(extra.eventBus, parentSessionId, childSessionId, updated.messages[idx], idx, updated);
                         }
                     }
                     catch {
                         // не фатально
                     }
                 }
-                messages.push({
-                    id: '',
-                    role: 'assistant',
-                    content: accumulatedContent || '',
-                    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                    disabled: false,
-                    pinned: false,
-                    branchId: '',
-                    toolUse: toolCalls,
-                });
-                for (const tc of toolCalls) {
-                    const tcId = tc.id || `subcall_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-                    const func = tc.function;
-                    if (!func?.name)
-                        continue;
-                    const toolName = func.name;
-                    let toolArgs;
-                    if (typeof func.arguments === 'string') {
-                        try {
-                            toolArgs = JSON.parse(func.arguments);
-                        }
-                        catch {
-                            toolArgs = {};
-                        }
+                break;
+            }
+            if (accumulatedContent) {
+                allSubagentIntermediateTexts.push({ text: accumulatedContent, iteration });
+            }
+            iteration++;
+            // Сохранить ответ ассистента с tool calls в дочернюю сессию
+            if (childSessionId && extra.sessionManager) {
+                try {
+                    const assistantMsg = {
+                        id: generateId(),
+                        role: MessageRole.ASSISTANT,
+                        seq: 0,
+                        origin: 'local',
+                        parts: [makeTextPart(accumulatedContent || '')],
+                        content: accumulatedContent || '',
+                        createdAt: nowISO(),
+                        disabled: false,
+                        pinned: false,
+                        hidden: false,
+                        agentRole: subagentType,
+                        reasoning: reasoning || undefined,
+                        // OpenAI-совместимая цепочка: assistant(toolCalls) → tool.
+                        // tool_chain=true — UI дочерней сессии скрывает промежуточные
+                        // сообщения (визуализация уже в финальном с tool_results).
+                        toolCalls,
+                        metadata: { stream_id: extra.streamId, tool_chain: true },
+                    };
+                    const updated = await extra.sessionManager.addMessage(childSessionId, assistantMsg);
+                    if (updated && extra.eventBus) {
+                        const idx = updated.messages.length - 1;
+                        await publishMessageAdded(extra.eventBus, parentSessionId, childSessionId, updated.messages[idx], idx, updated);
                     }
-                    else {
-                        toolArgs = func.arguments || {};
+                }
+                catch {
+                    // не фатально
+                }
+            }
+            messages.push({
+                id: '',
+                role: 'assistant',
+                content: accumulatedContent || '',
+                usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                disabled: false,
+                pinned: false,
+                branchId: '',
+                toolUse: toolCalls,
+            });
+            for (const tc of toolCalls) {
+                const tcId = tc.id || `subcall_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                const func = tc.function;
+                if (!func?.name)
+                    continue;
+                const toolName = func.name;
+                let toolArgs;
+                if (typeof func.arguments === 'string') {
+                    try {
+                        toolArgs = JSON.parse(func.arguments);
                     }
-                    const tcStartedAt = new Date().toISOString();
-                    const doomKey = `${toolName}:${JSON.stringify(toolArgs)}`;
-                    const doomCount = (doomTracker.get(doomKey) || 0) + 1;
-                    doomTracker.set(doomKey, doomCount);
-                    if (doomCount >= 3) {
-                        const doomMsg = {
-                            id: '', role: 'tool',
-                            content: `Ошибка: инструмент "${toolName}" вызван ${doomCount} раз(а) с одинаковыми аргументами. Цикл прерван.`,
-                            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                            disabled: false, pinned: false, branchId: '',
-                            toolCallId: tcId,
-                        };
-                        messages.push(doomMsg);
-                        if (childSessionId && extra.sessionManager) {
-                            try {
-                                const toolResultMsg = {
-                                    id: generateId(),
-                                    role: MessageRole.TOOL,
-                                    seq: 0,
-                                    origin: 'local',
-                                    parts: [makeTextPart(doomMsg.content)],
-                                    content: doomMsg.content,
-                                    createdAt: nowISO(),
-                                    disabled: false,
-                                    pinned: false,
-                                    hidden: false,
-                                    toolCallId: tcId,
-                                };
-                                const updated = await extra.sessionManager.addMessage(childSessionId, toolResultMsg);
-                                if (updated && extra.eventBus) {
-                                    const idx = updated.messages.length - 1;
-                                    await publishMessageAdded(extra.eventBus, extra.sessionId, childSessionId, updated.messages[idx], idx, updated);
-                                }
-                            }
-                            catch {
-                                // не фатально
+                    catch {
+                        toolArgs = {};
+                    }
+                }
+                else {
+                    toolArgs = func.arguments || {};
+                }
+                const tcStartedAt = new Date().toISOString();
+                const doomKey = `${toolName}:${JSON.stringify(toolArgs)}`;
+                const doomCount = (doomTracker.get(doomKey) || 0) + 1;
+                doomTracker.set(doomKey, doomCount);
+                if (doomCount >= 3) {
+                    const doomMsg = {
+                        id: '', role: 'tool',
+                        content: sm('tool.doom_loop', { tool: toolName, count: String(doomCount) }),
+                        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                        disabled: false, pinned: false, branchId: '',
+                        toolCallId: tcId,
+                    };
+                    messages.push(doomMsg);
+                    if (childSessionId && extra.sessionManager) {
+                        try {
+                            const toolResultMsg = {
+                                id: generateId(),
+                                role: MessageRole.TOOL,
+                                seq: 0,
+                                origin: 'local',
+                                parts: [makeTextPart(doomMsg.content)],
+                                content: doomMsg.content,
+                                createdAt: nowISO(),
+                                disabled: false,
+                                pinned: false,
+                                hidden: false,
+                                toolCallId: tcId,
+                                metadata: {
+                                    stream_id: extra.streamId,
+                                    tool_chain: true,
+                                    tool_name: toolName,
+                                    args: toolArgs,
+                                },
+                            };
+                            const updated = await extra.sessionManager.addMessage(childSessionId, toolResultMsg);
+                            if (updated && extra.eventBus) {
+                                const idx = updated.messages.length - 1;
+                                await publishMessageAdded(extra.eventBus, parentSessionId, childSessionId, updated.messages[idx], idx, updated);
                             }
                         }
-                        continue;
+                        catch {
+                            // не фатально
+                        }
                     }
-                    publish?.('tool_call.started', {
-                        stream_id: extra.streamId,
-                        session_id: extra.sessionId,
-                        call_id: tcId,
-                        name: toolName,
-                        arguments: toolArgs,
-                        iteration,
-                    });
-                    const toolDef = extra.toolRegistry?.get(toolName);
-                    let toolResult;
-                    let subagentUserDenied = false;
-                    // AD-029: permission-check саб-агента — permissions дочерней сессии
-                    // (родитель + deny-дополнения) применяются к каждому tool_call.
-                    const permissionDecision = childEvaluator.check({
-                        toolName,
-                        params: toolArgs,
-                        workingDir: ctx.workingDir,
-                        capabilities: toolDef?.capabilities,
-                        sessionMode: childSessionMode,
-                        planMode: childPlanMode,
-                        planApproved: childPlanApproved,
-                        mcpToolSettings: childMcpToolSettings,
-                    });
-                    if (permissionDecision.action === 'deny') {
-                        toolResult = {
-                            content: `Permission denied: ${permissionDecision.reason}`,
-                            isError: true,
-                            metadata: {
-                                permission: {
-                                    action: 'deny',
-                                    reason: permissionDecision.reason,
-                                    matched_rule: permissionDecision.matchedRule,
-                                },
+                    continue;
+                }
+                publish?.('tool_call.started', {
+                    stream_id: extra.streamId,
+                    session_id: extra.sessionId,
+                    call_id: tcId,
+                    name: toolName,
+                    arguments: toolArgs,
+                    iteration: stepIteration,
+                    // Вложенность внутренних вызовов саб-агента под блоком `task`
+                    // в родительском стриме (UI строит дерево по parent_call_id).
+                    parent_call_id: extra.callId,
+                });
+                const toolDef = extra.toolRegistry?.get(toolName);
+                let toolResult;
+                let subagentUserDenied = false;
+                // AD-029: permission-check саб-агента — permissions дочерней сессии
+                // (родитель + deny-дополнения) применяются к каждому tool_call.
+                const permissionDecision = childEvaluator.check({
+                    toolName,
+                    params: toolArgs,
+                    workingDir: ctx.workingDir,
+                    capabilities: toolDef?.capabilities,
+                    sessionMode: childSessionMode,
+                    planMode: childPlanMode,
+                    planApproved: childPlanApproved,
+                    mcpToolSettings: childMcpToolSettings,
+                    shellPolicy: extra.shellPolicy ?? undefined,
+                    protectedPaths: extra.protectedPaths ?? undefined,
+                    protectedPathsEnabled: extra.protectedPathsEnabled,
+                });
+                if (permissionDecision.action === 'deny') {
+                    toolResult = {
+                        content: extra.contextConfig && permissionDecision.messageId
+                            ? (extra.contextConfig.getSecurityMessage(permissionDecision.messageId, 'en', permissionDecision.params)
+                                ?? `Permission denied: ${permissionDecision.reason}`)
+                            : `Permission denied: ${permissionDecision.reason}`,
+                        isError: true,
+                        metadata: {
+                            ...(permissionDecision.messageId
+                                ? { i18n: i18nMeta(`security.${permissionDecision.messageId.replaceAll('-', '_')}`, permissionDecision.params) }
+                                : { i18n: i18nMeta('tool.permission_denied_default') }),
+                            permission: {
+                                action: 'deny',
+                                reason: permissionDecision.reason,
+                                matched_rule: permissionDecision.matchedRule,
                             },
-                        };
-                    }
-                    else if (permissionDecision.action === 'ask') {
-                        // ask публикуется в родительскую сессию (extra.sessionId) —
-                        // пользователь основной сессии видит запрос и отвечает.
-                        const approval = await childApprovalManager.waitForDecision(extra.sessionId, {
-                            approvalId: `approval_${tcId}`,
-                            callId: tcId,
-                            toolName,
-                            arguments: toolArgs,
-                            reason: permissionDecision.reason,
-                        }, derivedPermission.askTimeoutMs);
-                        if (approval.approved) {
-                            if (approval.once === false) {
-                                // «Разрешить в сессии» — allow-правило в permissions дочерней сессии
-                                derivedPermission.rules[toolName] = 'allow';
-                                if (childSessionId && extra.sessionManager) {
-                                    try {
-                                        const child = await extra.sessionManager.getSession(childSessionId);
-                                        if (child) {
-                                            child.settings.permission = { ...derivedPermission };
-                                            await extra.sessionManager.updateSession(child);
-                                        }
-                                    }
-                                    catch {
-                                        // не фатально
+                        },
+                    };
+                }
+                else if (permissionDecision.action === 'ask') {
+                    // ask публикуется в родительскую сессию (extra.sessionId) —
+                    // пользователь основной сессии видит запрос и отвечает.
+                    const approvalAskReason = extra.contextConfig && permissionDecision.messageId
+                        ? (extra.contextConfig.getSecurityMessage(permissionDecision.messageId, 'en', permissionDecision.params)
+                            ?? permissionDecision.reason)
+                        : permissionDecision.reason;
+                    const approval = await childApprovalManager.waitForDecision(extra.sessionId, {
+                        approvalId: `approval_${tcId}`,
+                        callId: tcId,
+                        toolName,
+                        arguments: toolArgs,
+                        reason: approvalAskReason,
+                    }, derivedPermission.askTimeoutMs);
+                    if (approval.approved) {
+                        if (approval.once === false) {
+                            // «Разрешить в сессии» — allow-правило в permissions дочерней сессии
+                            derivedPermission.rules[toolName] = 'allow';
+                            if (childSessionId && extra.sessionManager) {
+                                try {
+                                    const child = await extra.sessionManager.getSession(childSessionId);
+                                    if (child) {
+                                        child.settings.permission = { ...derivedPermission };
+                                        await extra.sessionManager.updateSession(child);
                                     }
                                 }
-                            }
-                            if (toolDef) {
-                                const parsed2 = toolDef.parameters.safeParse(toolArgs);
-                                if (!parsed2.success) {
-                                    toolResult = {
-                                        content: `Ошибка аргументов инструмента "${toolName}": ${parsed2.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ')}`,
-                                        isError: true,
-                                    };
-                                }
-                                else {
-                                    try {
-                                        toolResult = await toolDef.execute(parsed2.data, {
-                                            ...ctx,
-                                            abortSignal: ctx.abortSignal,
-                                            extra: extra,
-                                        });
-                                    }
-                                    catch (execError) {
-                                        toolResult = {
-                                            content: `Ошибка исполнения инструмента "${toolName}": ${String(execError)}`,
-                                            isError: true,
-                                        };
-                                    }
+                                catch {
+                                    // не фатально
                                 }
                             }
-                            else {
-                                toolResult = {
-                                    content: `Инструмент "${toolName}" не найден`,
-                                    isError: true,
-                                };
-                            }
                         }
-                        else {
-                            const why = approval.timeout
-                                ? 'истекло время ожидания подтверждения'
-                                : approval.noSubscribers
-                                    ? 'нет подключённого пользователя для подтверждения'
-                                    : 'отклонено пользователем';
-                            toolResult = {
-                                content: `Permission denied: ${permissionDecision.reason} (${why})`,
-                                isError: true,
-                                metadata: {
-                                    permission: {
-                                        action: 'deny',
-                                        reason: permissionDecision.reason,
-                                        matched_rule: permissionDecision.matchedRule,
-                                    },
-                                },
-                            };
-                            subagentUserDenied = !approval.timeout && !approval.noSubscribers;
-                        }
-                    }
-                    else {
-                        // allow — обычное выполнение
                         if (toolDef) {
                             const parsed2 = toolDef.parameters.safeParse(toolArgs);
                             if (!parsed2.success) {
                                 toolResult = {
-                                    content: `Ошибка аргументов инструмента "${toolName}": ${parsed2.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ')}`,
+                                    content: sm('tool.args_error', { tool: toolName, issues: parsed2.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ') }),
                                     isError: true,
+                                    metadata: { i18n: i18nMeta('tool.args_error', { tool: toolName }) },
                                 };
                             }
                             else {
@@ -716,229 +1083,289 @@ export const taskTool = {
                                 }
                                 catch (execError) {
                                     toolResult = {
-                                        content: `Ошибка исполнения инструмента "${toolName}": ${String(execError)}`,
+                                        content: sm('tool.exec_error', { tool: toolName, error: String(execError) }),
                                         isError: true,
+                                        metadata: { i18n: i18nMeta('tool.exec_error', { tool: toolName }) },
                                     };
                                 }
                             }
                         }
                         else {
                             toolResult = {
-                                content: `Инструмент "${toolName}" не найден`,
+                                content: sm('tool.not_found', { tool: toolName }),
                                 isError: true,
+                                metadata: { i18n: i18nMeta('tool.not_found', { tool: toolName }) },
                             };
                         }
                     }
-                    publish?.('tool_call.result', {
-                        stream_id: extra.streamId,
-                        session_id: extra.sessionId,
-                        call_id: tcId,
-                        name: toolName,
-                        result: toolResult,
-                        iteration,
-                    });
-                    allSubagentToolCalls.push({
-                        name: toolName,
-                        args: toolArgs,
-                        id: tcId,
-                        result: { content: toolResult.content, isError: toolResult.isError },
-                        started_at: tcStartedAt,
-                        completed_at: new Date().toISOString(),
-                        iteration,
-                    });
-                    const toolResultLLMMsg = {
-                        id: '', role: 'tool',
-                        content: toolResult.content,
-                        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                        disabled: false, pinned: false, branchId: '',
-                        toolCallId: tcId,
-                    };
-                    messages.push(toolResultLLMMsg);
-                    // Сохранить tool_result в дочернюю сессию
-                    if (childSessionId && extra.sessionManager) {
-                        try {
-                            const toolResultMsg = {
-                                id: generateId(),
-                                role: MessageRole.TOOL,
-                                seq: 0,
-                                origin: 'local',
-                                parts: [makeTextPart(toolResult.content)],
-                                content: toolResult.content,
-                                createdAt: nowISO(),
-                                disabled: false,
-                                pinned: false,
-                                hidden: false,
-                                toolCallId: tcId,
+                    else {
+                        const why = approval.timeout
+                            ? sm('permission.ask_timeout')
+                            : approval.noSubscribers
+                                ? sm('permission.ask_no_subscribers')
+                                : sm('permission.ask_denied');
+                        const baseDeny = extra.contextConfig && permissionDecision.messageId
+                            ? (extra.contextConfig.getSecurityMessage(permissionDecision.messageId, 'en', permissionDecision.params)
+                                ?? `Permission denied: ${permissionDecision.reason}`)
+                            : `Permission denied: ${permissionDecision.reason}`;
+                        toolResult = {
+                            content: `${baseDeny} (${why})`,
+                            isError: true,
+                            metadata: {
+                                ...(permissionDecision.messageId
+                                    ? { i18n: i18nMeta(`security.${permissionDecision.messageId.replaceAll('-', '_')}`, permissionDecision.params) }
+                                    : {}),
+                                permission: {
+                                    action: 'deny',
+                                    reason: permissionDecision.reason,
+                                    matched_rule: permissionDecision.matchedRule,
+                                },
+                            },
+                        };
+                        subagentUserDenied = !approval.timeout && !approval.noSubscribers;
+                    }
+                }
+                else {
+                    // allow — обычное выполнение
+                    if (toolDef) {
+                        const parsed2 = toolDef.parameters.safeParse(toolArgs);
+                        if (!parsed2.success) {
+                            toolResult = {
+                                content: sm('tool.args_error', { tool: toolName, issues: parsed2.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ') }),
+                                isError: true,
                             };
-                            const updated = await extra.sessionManager.addMessage(childSessionId, toolResultMsg);
-                            if (updated && extra.eventBus) {
-                                const idx = updated.messages.length - 1;
-                                await publishMessageAdded(extra.eventBus, extra.sessionId, childSessionId, updated.messages[idx], idx, updated);
-                            }
                         }
-                        catch {
-                            // не фатально
+                        else {
+                            try {
+                                toolResult = await toolDef.execute(parsed2.data, {
+                                    ...ctx,
+                                    abortSignal: ctx.abortSignal,
+                                    extra: extra,
+                                });
+                            }
+                            catch (execError) {
+                                toolResult = {
+                                    content: sm('tool.exec_error', { tool: toolName, error: String(execError) }),
+                                    isError: true,
+                                    metadata: { i18n: i18nMeta('tool.exec_error', { tool: toolName }) },
+                                };
+                            }
                         }
                     }
-                    // AD-029: пользователь отклонил ask саб-агента — прекращаем выполнение.
-                    if (subagentUserDenied) {
-                        subagentDenied = true;
-                        break;
+                    else {
+                        toolResult = {
+                            content: sm('tool.not_found', { tool: toolName }),
+                            isError: true,
+                            metadata: { i18n: i18nMeta('tool.not_found', { tool: toolName }) },
+                        };
                     }
                 }
-                publish?.('tool_call.loop', {
+                publish?.('tool_call.result', {
                     stream_id: extra.streamId,
                     session_id: extra.sessionId,
-                    iteration,
-                    total_tool_calls: toolCalls.length,
+                    call_id: tcId,
+                    name: toolName,
+                    result: toolResult,
+                    iteration: stepIteration,
+                    parent_call_id: extra.callId,
+                });
+                allSubagentToolCalls.push({
+                    name: toolName,
+                    args: toolArgs,
+                    id: tcId,
+                    result: { content: toolResult.content, isError: toolResult.isError },
+                    started_at: tcStartedAt,
+                    completed_at: new Date().toISOString(),
+                    iteration: stepIteration,
                 });
-                if (subagentDenied)
+                const toolResultLLMMsg = {
+                    id: '', role: 'tool',
+                    content: toolResult.content,
+                    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                    disabled: false, pinned: false, branchId: '',
+                    toolCallId: tcId,
+                };
+                messages.push(toolResultLLMMsg);
+                // Сохранить tool_result в дочернюю сессию
+                if (childSessionId && extra.sessionManager) {
+                    try {
+                        const toolResultMsg = {
+                            id: generateId(),
+                            role: MessageRole.TOOL,
+                            seq: 0,
+                            origin: 'local',
+                            parts: [makeTextPart(toolResult.content)],
+                            content: toolResult.content,
+                            createdAt: nowISO(),
+                            disabled: false,
+                            pinned: false,
+                            hidden: false,
+                            toolCallId: tcId,
+                            metadata: {
+                                stream_id: extra.streamId,
+                                tool_chain: true,
+                                tool_name: toolName,
+                                args: toolArgs,
+                            },
+                        };
+                        const updated = await extra.sessionManager.addMessage(childSessionId, toolResultMsg);
+                        if (updated && extra.eventBus) {
+                            const idx = updated.messages.length - 1;
+                            await publishMessageAdded(extra.eventBus, parentSessionId, childSessionId, updated.messages[idx], idx, updated);
+                        }
+                    }
+                    catch {
+                        // не фатально
+                    }
+                }
+                // AD-029: пользователь отклонил ask саб-агента — прекращаем выполнение.
+                if (subagentUserDenied) {
+                    subagentDenied = true;
                     break;
+                }
             }
-            if (subagentDenied && !finalContent) {
-                finalContent = 'Обработка остановлена: пользователь отклонил запрос на выполнение инструмента';
-            }
-            const output = finalContent || '(пустой ответ сабагента)';
-            // ─── Quality check результата саб-агента (AD-034 Фаза 4) ─────
-            let qaPass;
-            let qaReason;
-            let qualityOutput = output;
-            const escalationCfg = extra.routerConfig?.escalation;
-            const sessionEscalation = extra.parentSessionSettings?.routingEscalation;
-            const escalationEnabled = sessionEscalation?.enabled ?? escalationCfg?.enabled ?? false;
-            if (extra.modelRouter && escalationEnabled && finalContent && routingDecisionInfo) {
-                try {
-                    const qaResult = await extra.modelRouter.checkQuality(finalContent, {
-                        providerName: routingDecisionInfo.providerName,
-                        modelName: routingDecisionInfo.modelName,
-                        reason: routingDecisionInfo.strategy,
-                        strategy: routingDecisionInfo.strategy,
-                    }, extra.parentSessionSettings);
-                    qaPass = qaResult.pass;
-                    qaReason = qaResult.reason;
-                    // Пометить QA-информацию в дочерней сессии
-                    if (childSessionId && extra.sessionManager) {
-                        try {
-                            const childSession = await extra.sessionManager.getSession(childSessionId);
-                            if (childSession) {
-                                const lastAssistantMsg = [...childSession.messages].reverse()
-                                    .find(m => m.role === MessageRole.ASSISTANT);
-                                if (lastAssistantMsg) {
-                                    lastAssistantMsg.qa_pass = qaResult.pass;
-                                    lastAssistantMsg.qa_reason = qaResult.reason;
-                                    await extra.sessionManager.updateSession(childSession);
-                                }
+            publish?.('tool_call.loop', {
+                stream_id: extra.streamId,
+                session_id: extra.sessionId,
+                iteration: stepIteration,
+                total_tool_calls: toolCalls.length,
+            });
+            if (subagentDenied)
+                break;
+        }
+        // Отмена до/после цикла (например сигнал уже абортирован на входе или
+        // пришёл во время исполнения тулов саб-агента) — тот же протокол
+        // прерывания, что и при отмене во время стрима.
+        if (isAborted()) {
+            return await finishAborted('', '');
+        }
+        if (subagentDenied && !finalContent) {
+            finalContent = sm('task.stopped_by_deny');
+        }
+        const output = finalContent || sm('task.empty_response');
+        // ─── Quality check результата саб-агента (AD-034 Фаза 4) ─────
+        let qaPass;
+        let qaReason;
+        let qualityOutput = output;
+        const escalationCfg = extra.routerConfig?.escalation;
+        const sessionEscalation = extra.parentSessionSettings?.routingEscalation;
+        const escalationEnabled = sessionEscalation?.enabled ?? escalationCfg?.enabled ?? false;
+        if (extra.modelRouter && escalationEnabled && finalContent && routingDecisionInfo) {
+            try {
+                const qaResult = await extra.modelRouter.checkQuality(finalContent, {
+                    providerName: routingDecisionInfo.providerName,
+                    modelName: routingDecisionInfo.modelName,
+                    reason: routingDecisionInfo.strategy,
+                    strategy: routingDecisionInfo.strategy,
+                }, extra.parentSessionSettings);
+                qaPass = qaResult.pass;
+                qaReason = qaResult.reason;
+                // Пометить QA-информацию в дочерней сессии
+                if (childSessionId && extra.sessionManager) {
+                    try {
+                        const childSession = await extra.sessionManager.getSession(childSessionId);
+                        if (childSession) {
+                            const lastAssistantMsg = [...childSession.messages].reverse()
+                                .find(m => m.role === MessageRole.ASSISTANT);
+                            if (lastAssistantMsg) {
+                                lastAssistantMsg.qa_pass = qaResult.pass;
+                                lastAssistantMsg.qa_reason = qaResult.reason;
+                                await extra.sessionManager.updateSession(childSession);
                             }
                         }
-                        catch {
-                            // не фатально
-                        }
                     }
-                    // Эскалация на fallback-модель при FAIL
-                    if (!qaResult.pass) {
-                        const fallbackProvider = sessionEscalation?.fallbackProvider || escalationCfg?.fallbackProvider;
-                        const fallbackModel = sessionEscalation?.fallbackModel || escalationCfg?.fallbackModel;
-                        if (fallbackProvider && fallbackModel && extra.modelRouter) {
-                            const fbDecision = {
-                                providerName: fallbackProvider,
-                                modelName: fallbackModel,
-                                reason: 'escalation_fallback',
-                                strategy: 'default',
-                            };
-                            const fbEffectiveProvider = extra.modelRouter.getProvider(fbDecision);
-                            if (fbEffectiveProvider) {
-                                try {
-                                    // Перевызываем с fallback-моделью (только последний user-запрос)
-                                    const fbMessages = [messages[0]];
-                                    // Добавляем только user-сообщение без tool-результатов
-                                    const userMsg = messages.find(m => m.role === 'user');
-                                    if (userMsg)
-                                        fbMessages.push(userMsg);
-                                    const fbResponse = await fbEffectiveProvider.chat(fbMessages, systemPrompt || undefined, undefined, false);
-                                    if (fbResponse.content) {
-                                        finalContent = fbResponse.content;
-                                        qualityOutput = fbResponse.content;
-                                        qaPass = true;
-                                        qaReason = `Эскалация на ${fallbackProvider}/${fallbackModel}: ${qaResult.reason}`;
-                                        routingDecisionInfo = {
-                                            providerName: fallbackProvider,
-                                            modelName: fallbackModel,
-                                            strategy: 'escalation_fallback',
-                                        };
-                                    }
-                                }
-                                catch {
-                                    // fallback не удался, оставляем оригинальный ответ
+                    catch {
+                        // не фатально
+                    }
+                }
+                // Эскалация на fallback-модель при FAIL
+                if (!qaResult.pass) {
+                    const fallbackProvider = sessionEscalation?.fallbackProvider || escalationCfg?.fallbackProvider;
+                    const fallbackModel = sessionEscalation?.fallbackModel || escalationCfg?.fallbackModel;
+                    if (fallbackProvider && fallbackModel && extra.modelRouter) {
+                        const fbDecision = {
+                            providerName: fallbackProvider,
+                            modelName: fallbackModel,
+                            reason: 'escalation_fallback',
+                            strategy: 'default',
+                        };
+                        const fbEffectiveProvider = extra.modelRouter.getProvider(fbDecision);
+                        if (fbEffectiveProvider) {
+                            try {
+                                // Перевызываем с fallback-моделью (только последний user-запрос)
+                                const fbMessages = [messages[0]];
+                                // Добавляем только user-сообщение без tool-результатов
+                                const userMsg = messages.find(m => m.role === 'user');
+                                if (userMsg)
+                                    fbMessages.push(userMsg);
+                                const fbResponse = await fbEffectiveProvider.chat(fbMessages, systemPrompt || undefined, undefined, false);
+                                if (fbResponse.content) {
+                                    finalContent = fbResponse.content;
+                                    qualityOutput = fbResponse.content;
+                                    qaPass = true;
+                                    qaReason = sm('router.escalation', { provider: fallbackProvider, model: fallbackModel, reason: qaResult.reason });
+                                    routingDecisionInfo = {
+                                        providerName: fallbackProvider,
+                                        modelName: fallbackModel,
+                                        strategy: 'escalation_fallback',
+                                    };
                                 }
                             }
+                            catch {
+                                // fallback не удался, оставляем оригинальный ответ
+                            }
                         }
                     }
                 }
-                catch {
-                    // QA не удался, не блокируем
-                }
             }
-            // Финализировать дочернюю сессию — обновить TSM
-            if (childSessionId && extra.sessionManager) {
-                try {
-                    const childSession = await extra.sessionManager.getSession(childSessionId);
-                    if (childSession) {
-                        childSession.status.state = TsmState.DONE;
-                        childSession.updatedAt = nowISO();
-                        await extra.sessionManager.updateSession(childSession);
-                        if (extra.eventBus) {
-                            extra.eventBus.publish(childSessionId, 'session.updated', {
-                                session_id: childSessionId,
-                                status: { state: TsmState.DONE },
-                            });
-                            extra.eventBus.publish(extra.sessionId, 'child.session.updated', {
-                                session: serializeSession(childSession),
-                            });
-                        }
-                    }
-                }
-                catch {
-                    // не фатально
-                }
+            catch {
+                // QA не удался, не блокируем
             }
-            // ─── Формирование результата tool_result ──────────────────────
-            const qualityBlock = qaPass !== undefined
-                ? `<quality pass="${qaPass}" reason="${qaReason || ''}"/>\n`
-                : '';
-            const routedByBlock = routingDecisionInfo && routingDecisionInfo.strategy !== 'default'
-                ? `<routed_by strategy="${routingDecisionInfo.strategy}" provider="${routingDecisionInfo.providerName}" model="${routingDecisionInfo.modelName}"/>\n`
-                : '';
-            const qaWarningText = qaPass === false
-                ? `\n\n⚠️ Ответ не прошёл контроль качества: ${qaReason || 'неизвестная причина'}`
-                : '';
-            return {
-                content: `<task_result>\n<summary>${params.description}</summary>\n${qualityBlock}${routedByBlock}\n${qualityOutput}${qaWarningText}\n</task_result>`,
-                metadata: {
-                    subagent_type: params.subagent_type,
-                    description: params.description,
-                    context_mode: contextMode,
-                    steps: iteration,
-                    child_session_id: childSessionId,
-                    reasoning: subagentReasoning || undefined,
-                    reasoning_blocks: allSubagentReasoning.length > 0 ? allSubagentReasoning : undefined,
-                    intermediate_text_blocks: allSubagentIntermediateTexts.length > 0 ? allSubagentIntermediateTexts : undefined,
-                    tool_calls: allSubagentToolCalls.length > 0 ? allSubagentToolCalls : undefined,
-                    final_content: finalContent || undefined,
-                    qa_pass: qaPass,
-                    qa_reason: qaReason || undefined,
-                    routing_strategy: routingDecisionInfo?.strategy,
-                    routing_provider: routingDecisionInfo?.providerName,
-                    routing_model: routingDecisionInfo?.modelName,
-                },
-            };
         }
-        catch (err) {
-            return {
-                content: `Ошибка выполнения сабагента "${params.subagent_type}": ${String(err)}`,
-                isError: true,
-                metadata: { subagent_type: params.subagent_type },
-            };
-        }
-    },
-};
+        // Финализировать дочернюю сессию
+        await finalizeChildSession();
+        // ─── Формирование результата tool_result ──────────────────────
+        const qualityBlock = qaPass !== undefined
+            ? `<quality pass="${qaPass}" reason="${qaReason || ''}"/>\n`
+            : '';
+        const routedByBlock = routingDecisionInfo && routingDecisionInfo.strategy !== 'default'
+            ? `<routed_by strategy="${routingDecisionInfo.strategy}" provider="${routingDecisionInfo.providerName}" model="${routingDecisionInfo.modelName}"/>\n`
+            : '';
+        const qaWarningText = qaPass === false
+            ? `\n\n⚠️ Response failed the quality check: ${qaReason || 'unknown reason'}`
+            : '';
+        // ID дочерней сессии в content — родительская модель может прочитать
+        // историю саб-агента тулом read_session_reference.
+        const childSessionBlock = childSessionId
+            ? `<child_session_id>${childSessionId}</child_session_id>\n`
+            : '';
+        return {
+            content: `<task_result>\n<summary>${description}</summary>\n${qualityBlock}${routedByBlock}${childSessionBlock}\n${qualityOutput}${qaWarningText}\n</task_result>`,
+            metadata: {
+                subagent_type: subagentType,
+                description: description,
+                context_mode: contextMode,
+                steps: iteration,
+                child_session_id: childSessionId,
+                reasoning: subagentReasoning || undefined,
+                reasoning_blocks: allSubagentReasoning.length > 0 ? allSubagentReasoning : undefined,
+                intermediate_text_blocks: allSubagentIntermediateTexts.length > 0 ? allSubagentIntermediateTexts : undefined,
+                tool_calls: allSubagentToolCalls.length > 0 ? allSubagentToolCalls : undefined,
+                final_content: finalContent || undefined,
+                qa_pass: qaPass,
+                qa_reason: qaReason || undefined,
+                routing_strategy: routingDecisionInfo?.strategy,
+                routing_provider: routingDecisionInfo?.providerName,
+                routing_model: routingDecisionInfo?.modelName,
+            },
+        };
+    }
+    catch (err) {
+        return {
+            content: sm('task.subagent_exec_error', { type: subagentType, error: String(err) }),
+            isError: true,
+            metadata: { subagent_type: subagentType },
+        };
+    }
+}
 //# sourceMappingURL=task.js.map