@itphx/synth-core 0.2.0 → 0.3.0

package/dist/engine/orchestrator.js

@@ -1,8 +1,11 @@
-import { MessageRole, nowISO, ToolCapability, generateId, makeTextPart } from '@itphx/synth-shared';
+import { MessageRole, nowISO, ToolCapability, generateId, makeTextPart, lookupContextWindow, generateStreamId } from '@itphx/synth-shared';
 import { join, isAbsolute, normalize, resolve } from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import { DebugCollector } from '../debug.js';
 import { ProviderFactory } from '../providers/base.js';
+import { ContextLengthExceededError } from '../providers/exceptions.js';
+import { renderPlanMarkdown } from './tools/plan.js';
+import { renderTodosMarkdown } from './tools/todo.js';
 import { info, warning } from '../logger.js';
 import { autoTitleSession } from '../sessions/auto-title.js';
 import { ModelRouter } from './router/router.js';
@@ -13,15 +16,21 @@ import { DictionaryStore } from './router/dictionary-store.js';
 import { MicroPipeline } from './router/micro/index.js';
 import { TaskClassifier } from './router/micro/task-classifier.js';
 import { RulesModel, EmbeddingModel, MicroLlmModel } from './router/micro/models/index.js';
-import { PermissionEvaluator } from './permission/evaluator.js';
+import { PermissionEvaluator, isPlanRestricted, isPlanBlockedTool, getMcpToolAvailability, extractPaths } from './permission/evaluator.js';
 import { PermissionApprovalManager } from './permission/approval.js';
 import { emptyPermissionConfig } from './permission/derive.js';
+import { classifyLlmError, isLlmErrorRecoverable } from './llm-error.js';
+import { runSubagentResume, validateSubagentResume, SubagentResumeError } from './tools/task-resume.js';
 import { getToolTrust } from './security/trust.js';
 import { detectPromptInjection, applyPolicy, wrapContent, buildWarnLine } from './security/prompt-injection.js';
+import { loadProtectedPaths } from './security/protected-paths.js';
 import { GatewayProvider, AuditLogger, RateLimiter, ObfuscationMapStore, obfuscateSecrets, maskSecret, PLACEHOLDER_PATTERN } from './gateway/index.js';
+import { t as sm, i18n as i18nMeta } from './system-messages.js';
 const MAX_DOOM_LOOP_COUNT = 3;
 const DEFAULT_MAX_ITERATIONS = Number.POSITIVE_INFINITY;
-function toCoreProviderConfig(shared, model) {
+/** Порог заполненности контекстного окна (%), после которого публикуем context.limit_warning. */
+const CONTEXT_LIMIT_WARNING_PERCENT = 90;
+function toCoreProviderConfig(shared, model, reasoningLevel) {
     return {
         name: shared.name,
         type: shared.type,
@@ -29,6 +38,7 @@ function toCoreProviderConfig(shared, model) {
         apiKey: shared.apiKey || '',
         model,
         timeout: shared.timeout,
+        reasoningLevel,
     };
 }
 /**
@@ -70,10 +80,44 @@ export class ChatOrchestrator {
     /** Внешний audit-logger (backend/runner) — переиспользуется при live-включении gateway. */
     _gatewayAuditExternal;
     _providerPool;
+    /** Политика защищённых путей (СКВОЗНАЯ проверка файловых тулов + shell) — ленивая загрузка с кэшем. */
+    _protectedPaths = null;
+    _protectedPathsLoaded = false;
     /** Публичный доступ к реестру агентов (для сериализации modeApplicable). */
     get agentRegistry() {
         return this._agentRegistry;
     }
+    /**
+     * Политика защищённых путей: системный дефолт definitions/protected-paths.json
+     * + override {dataDir}/security/protected-paths.json (каскад add/remove).
+     * Ленивая загрузка с кэшем; при недоступности dataDir/файлов — системный дефолт.
+     */
+    _getProtectedPaths() {
+        if (this._protectedPathsLoaded)
+            return this._protectedPaths;
+        this._protectedPathsLoaded = true;
+        try {
+            this._protectedPaths = loadProtectedPaths({ overridePath: join(this._dataDir, 'security', 'protected-paths.json') });
+        }
+        catch {
+            this._protectedPaths = null;
+        }
+        return this._protectedPaths;
+    }
+    /** Включена ли защита защищённых путей (тумблер полного отключения). */
+    _getProtectedPathsEnabled() {
+        return this._securityConfig.protectedPaths?.enabled ?? true;
+    }
+    /**
+     * Локализованный текст сообщения безопасности для model/UI. Для решений с
+     * messageId (защищённые пути, запрещённые команды) берётся из промпт-файла;
+     * иначе — обычный reason. Текст включает префикс "Permission denied/required".
+     */
+    _securityMessage(decision, lang) {
+        if (!decision.messageId)
+            return undefined;
+        return this._contextConfig?.getSecurityMessage(decision.messageId, lang, decision.params) ?? undefined;
+    }
     constructor(options) {
         this._sessionManager = options.sessionManager;
         this._eventBus = options.eventBus;
@@ -93,7 +137,7 @@ export class ChatOrchestrator {
         this._approvalManager = new PermissionApprovalManager(this._eventBus);
         this._defaultPlanMode = options.defaultPlanMode ?? 'auto';
         this._securityConfig = options.securityConfig
-            ?? { promptInjection: { enabled: true, wrapContent: true, mode: 'flag' } };
+            ?? { promptInjection: { enabled: true, wrapContent: true, mode: 'flag' }, protectedPaths: { enabled: true } };
         this._dataDir = options.dataDir || '/var/synth/data';
         this._gatewayPayloadLogPath = options.gatewayPayloadLogPath
             ?? join(options.dataDir || '/var/synth/data', 'audit', 'llm-payloads.jsonl');
@@ -210,6 +254,22 @@ export class ChatOrchestrator {
     isGatewayEnabled() {
         return !!this._gatewayConfig;
     }
+    /**
+     * Live-переключение секции «Безопасность» (runtime-настройка из UI).
+     * Обновляет тумблер защищённых путей без рестарта сервера.
+     */
+    setSecurityConfig(config) {
+        this._securityConfig = config
+            ?? { promptInjection: { enabled: true, wrapContent: true, mode: 'flag' }, protectedPaths: { enabled: true } };
+    }
+    /**
+     * AD-029: live-применение глобального таймаута подтверждения (runtime-настройка
+     * из UI, раздел «Безопасность»). Обновляет дефолтный permission-конфиг, который
+     * наследуют сессии без собственного пер-сессионного permission-конфига.
+     */
+    setDefaultPermissionTimeout(askTimeoutMs) {
+        this._permissionConfig = { ...this._permissionConfig, askTimeoutMs };
+    }
     /**
      * AD-036: обфусцирует user-сообщение при сохранении в историю (до отправки в LLM).
      * Карта обфускации сессии обновляется и сохраняется; в message.metadata.secrets
@@ -278,49 +338,159 @@ export class ChatOrchestrator {
         return dir;
     }
     /**
-     * AD-025/AD-027: добавляет в system prompt блоки режима Plan/Act и
-     * утверждённого плана. Вызывается при старте обработки и пересобирается
-     * после plan_enter/plan_exit в текущей итерации.
+     * AD-025/AD-039: добавляет в system prompt блоки режима Plan/Act и
+     * утверждённого плана проекта. Вызывается при старте обработки и
+     * пересобирается после plan_enter/plan_exit в текущей итерации.
      */
-    _buildPlanSystemPrompt(base, session, planMode, sessionMode, planApproved, planContent) {
+    async _buildPlanSystemPrompt(base, session, planMode, sessionMode, planApproved) {
         const parts = [];
-        // AD-025: промпт текущего режима загружается из контекстных файлов
-        // (prompts/modes/{mode}.md, переопределяемые через dataDir/context/modes).
-        // Если файл не найден — fallback на встроенный текст ниже.
+        // AD-025: промпт текущего режима загружается из contextConfig.getModePrompt
+        // (prompts/system/MODE_{PLAN,ACT,YOLO}.{lang}.md, переопределяемые через dataDir/context/user/system).
+        // Если getModePrompt вернул null (нет contextConfig или файла) — блок режима
+        // не добавляется ни для одного режима.
         const language = session.settings.language || 'ru';
         const modePrompt = this._contextConfig?.getModePrompt(sessionMode, language) ?? null;
         if (modePrompt) {
             parts.push(modePrompt);
         }
-        else if (sessionMode === 'plan') {
-            parts.push('[MODE: PLAN]\n'
-                + 'Ты в режиме планирования: чтение и исследование разрешены, но запись/изменение файлов '
-                + 'заблокированы (единственное исключение — .synth/plans/*.md). Изучи задачу, составь план '
-                + 'и утверди его через plan_exit(plan="..."), чтобы перейти в режим act.');
+        // AD-028/AD-039: промпт строгости цикла Plan→Build загружается из contextConfig
+        // (prompts/system/PLAN_MODE_{AUTO,STRICT_APPROVED,STRICT_NOT_APPROVED}.{lang}.md,
+        // переопределяемые через dataDir/context/user/system). planMode 'off' → null —
+        // блок не добавляется.
+        const planModePrompt = this._contextConfig?.getPlanModePrompt(planMode, planApproved, language) ?? null;
+        if (planModePrompt) {
+            parts.push(planModePrompt);
+        }
+        // AD-039: блок [APPROVED PLAN] собирается из плана проекта (project.plan).
+        const approvedPlan = await this._renderProjectPlan(session);
+        if (approvedPlan) {
+            parts.push(`[APPROVED PLAN]\n${approvedPlan}`);
+        }
+        // AD-039: блок [TODO] собирается из session.todos.
+        const todosMarkdown = renderTodosMarkdown(session.todos ?? []);
+        if (todosMarkdown) {
+            parts.push(`[TODO]\n${todosMarkdown}`);
+        }
+        // AD-039: инструкция по ведению плана и todo (PLAN_GUIDE) встраивается
+        // всегда, когда доступен контекст (contextConfig), независимо от наличия
+        // плана или todo — модель должна знать разницу между ними с первого запроса.
+        const guide = this._contextConfig?.getPlanGuide(language) ?? null;
+        if (guide) {
+            parts.push(guide);
+        }
+        if (parts.length === 0)
+            return base;
+        return `${base}\n\n${parts.join('\n\n')}`;
+    }
+    /**
+     * AD-025: фильтрует список тулов, передаваемых LLM, по текущему режиму сессии.
+     * В plan-режиме (или strict без утверждённого плана) из списка убираются
+     * write/edit-тулы и git-запись (группы edit/git_write) — модель не видит
+     * инструментов, которые всё равно будут отклонены PermissionEvaluator'ом.
+     * MCP-инструменты фильтруются по настройкам доступности (plan/act).
+     * Режимы act/yolo — полный список без изменений.
+     */
+    _filterToolsByMode(tools, session, sessionMode, planMode, planApproved) {
+        if (!tools || tools.length === 0)
+            return tools;
+        // Рестрикция не активна (act/yolo/off) — полный список тулов.
+        if (!isPlanRestricted(sessionMode, planMode, planApproved))
+            return tools;
+        const mcpToolSettings = session.settings.mcpToolSettings;
+        const result = [];
+        for (const tool of tools) {
+            const toolName = tool.function.name;
+            const toolDef = this._toolRegistry?.get(toolName);
+            const capabilities = toolDef?.capabilities;
+            // Edit-группа (write/edit/delete) и git-запись блокируются в plan-режиме —
+            // скрываем их от модели, чтобы она не пыталась их вызывать.
+            if (isPlanBlockedTool(toolName, capabilities))
+                continue;
+            // MCP-инструменты: в plan-режиме недоступный по настройкам тул убираем из
+            // списка (консистентно с PermissionEvaluator: modeKey = 'plan').
+            if (capabilities?.includes(ToolCapability.MCP) && mcpToolSettings) {
+                const availability = getMcpToolAvailability(mcpToolSettings, toolName);
+                if (availability && !availability.plan)
+                    continue;
+            }
+            result.push(tool);
+        }
+        return result;
+    }
+    /**
+     * AD-039: markdown-рендер плана проекта. Null — если проекта нет, нет plan
+     * или план пуст (нет пунктов).
+     */
+    async _renderProjectPlan(session) {
+        if (!session.projectId || !this._projectStore)
+            return null;
+        try {
+            const project = await this._projectStore.load(session.projectId);
+            const plan = project?.plan;
+            if (!plan || plan.items.length === 0)
+                return null;
+            return renderPlanMarkdown(plan);
         }
-        if (planMode === 'auto') {
-            parts.push('[PLAN MODE: AUTO]\n'
-                + 'Если задача сложная, затрагивает несколько файлов или требует архитектурных решений — '
-                + 'вызови plan_enter перед изменениями. Для простых фиксов — делай сразу.');
+        catch {
+            return null;
         }
-        else if (planMode === 'strict') {
-            if (planApproved) {
-                parts.push('[PLAN MODE: STRICT]\n'
-                    + 'План утверждён — ты можешь вносить изменения в соответствии с ним.');
+    }
+    /**
+     * AD-040: добавляет в system prompt контекстный блок сессии — наличие/отсутствие
+     * проекта, рабочий каталог и ограничения. Вызывается после резолва workingDir.
+     */
+    async _buildSessionContextPrompt(base, session, workingDir) {
+        const lang = session.settings.language || 'ru';
+        const lines = [];
+        if (session.projectId) {
+            let project = null;
+            if (this._projectStore) {
+                try {
+                    project = await this._projectStore.load(session.projectId);
+                }
+                catch {
+                    project = null;
+                }
+            }
+            if (project) {
+                lines.push('[КОНТЕКСТ СЕССИИ]');
+                lines.push(`Проект: ${project.name}`);
+                lines.push(`ID проекта: ${session.projectId}`);
+                lines.push(`Рабочий каталог: ${project.workspace || workingDir}`);
+                const invariants = project.invariants?.trim();
+                if (invariants) {
+                    lines.push('');
+                    lines.push(lang === 'en' ? '[PROJECT INVARIANTS]' : '[ИНВАРИАНТЫ ПРОЕКТА]');
+                    lines.push(project.invariants);
+                }
             }
             else {
-                parts.push('[PLAN MODE: STRICT]\n'
-                    + 'Перед любым изменением файлов план обязателен: вызови plan_enter, составь план и утверди '
-                    + 'его через plan_exit. До утверждения плана запись файлов заблокирована (чтение разрешено).');
+                lines.push('[КОНТЕКСТ СЕССИИ]');
+                lines.push(`Проект: не найден (id: ${session.projectId})`);
+                lines.push(`Рабочий каталог: ${workingDir}`);
             }
         }
-        const approvedPlan = planContent ?? session.planContent;
-        if (approvedPlan) {
-            parts.push(`[APPROVED PLAN]\n${approvedPlan}`);
+        else if (lang === 'en') {
+            lines.push('[SESSION CONTEXT]');
+            lines.push('Project: none');
+            lines.push(`Working directory: ${workingDir}`);
+            lines.push('Limitations: a plan is unavailable (the plan is bound to a project). '
+                + 'File and git tools operate within the working directory. Todo is available.');
+            lines.push('If the task requires long-term work with files, git, or a plan — suggest that the user '
+                + 'create a project and move the session into it.');
         }
-        if (parts.length === 0)
+        else {
+            lines.push('[КОНТЕКСТ СЕССИИ]');
+            lines.push('Проект: отсутствует');
+            lines.push(`Рабочий каталог: ${workingDir}`);
+            lines.push('Ограничения: план недоступен (план привязан к проекту). '
+                + 'Файловые и git-инструменты работают в рамках рабочего каталога. Todo доступен.');
+            lines.push('Если задача требует длительной работы с файлами, git или планом — предложи пользователю '
+                + 'создать проект и перенести сессию в него.');
+        }
+        if (lines.length === 0)
             return base;
-        return `${base}\n\n${parts.join('\n\n')}`;
+        return `${base}\n\n${lines.join('\n')}`;
     }
     /**
      * processMessage callback для QueueProcessor.
@@ -332,13 +502,13 @@ export class ChatOrchestrator {
     }
     async _processMessage(session, message, signal, publishChunk) {
         const streamId = message.metadata?.stream_id || 'unknown';
-        const effectiveAgentRole = message.agentRole || session.settings.agentRole || 'assistant';
+        const effectiveAgentRole = message.agentRole || session.settings.agentRole;
         const author = message.author || 'unknown';
         const workingDir = await this._resolveWorkingDir(session);
         // AD-025: режим Plan/Act — runtime-состояние сессии + строгость из настроек
         const planMode = session.settings.planMode ?? this._defaultPlanMode ?? 'auto';
         let sessionMode = session.mode ?? 'act';
-        let planApproved = Boolean(session.planContent);
+        let planApproved = Boolean(session.planApproved);
         // AD-029: permissions — сессионный override приоритетнее глобального конфига.
         // Конфиг может быть расширен «разрешить в сессии» (once:false) в процессе
         // обработки, поэтому ссылка и эвалуатор пересоздаются.
@@ -349,13 +519,15 @@ export class ChatOrchestrator {
         const maxIterations = (agentMaxSteps !== undefined && agentMaxSteps > 0)
             ? agentMaxSteps
             : DEFAULT_MAX_ITERATIONS;
+        // Уровень размышлений агента: если агент не задал — берём настройку сессии
+        const effectiveReasoningLevel = agentDef?.reasoningLevel ?? session.settings.reasoningLevel;
         const debugCollector = new DebugCollector(session.settings.debugEnabled);
         // --- Обработка системных сообщений (суммаризация, шедулер, etc.) ---
         if (message.role === MessageRole.SYSTEM && message.metadata?.type === 'summarization_request') {
             return this._handleSummarization(session, message, signal, publishChunk, debugCollector, streamId);
         }
         if (message.role === MessageRole.SYSTEM && message.metadata?.type === 'debug_system_message') {
-            return this._handleDebugSystemMessage(session, message, signal, publishChunk, debugCollector, streamId);
+            return this._handleDebugSystemMessage(session, message, signal, publishChunk, debugCollector, streamId, effectiveReasoningLevel);
         }
         // --- AD-035: Micro-first — пробуем ответить без LLM ---
         if (this._microPipeline && session.settings.microFirst) {
@@ -380,6 +552,9 @@ export class ChatOrchestrator {
                 // Сохраняем сообщение ассистента
                 const microMetadata = {
                     stream_id: streamId,
+                    ...(microResult.microResult.i18nKey
+                        ? { i18n: i18nMeta(microResult.microResult.i18nKey) }
+                        : {}),
                     micro_first: {
                         label: microResult.microResult.label,
                         confidence: microResult.microResult.confidence,
@@ -413,7 +588,7 @@ export class ChatOrchestrator {
                 // Авто-тайтл если это первое сообщение
                 if (session.messages.filter((m) => m.role === MessageRole.USER).length <= 1) {
                     try {
-                        session.title = `Диалог — ${session.id.slice(0, 8)}`;
+                        session.title = sm('session.dialog_title', { id: session.id.slice(0, 8) });
                         await this._sessionManager.saveSession(session);
                     }
                     catch {
@@ -434,11 +609,11 @@ export class ChatOrchestrator {
         }
         try {
             // 1. Get provider (через роутер если доступен, иначе напрямую)
-            const routeResult = this._routeProvider(session, message);
+            const routeResult = this._routeProvider(session, message, effectiveReasoningLevel);
             if (!routeResult) {
                 const providerName = message.provider || session.settings.provider || '';
                 return {
-                    error: `Провайдер ${providerName || 'не указан'} не найден или не настроен`,
+                    error: sm('router.provider_not_found', { provider: providerName || sm('router.provider_unspecified') }),
                     errorType: 'provider_not_found',
                     canRetry: false,
                 };
@@ -487,8 +662,10 @@ export class ChatOrchestrator {
                     finalSystemPrompt = `${finalSystemPrompt}\n\n${gatewayInstructions}`;
                 }
             }
-            // AD-025/AD-027: блоки режима Plan/Act + утверждённый план
-            finalSystemPrompt = this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved);
+            // AD-025/AD-039: блоки режима Plan/Act + утверждённый план проекта
+            finalSystemPrompt = await this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved);
+            // AD-040: контекстный блок сессии (проект/рабочий каталог/ограничения)
+            finalSystemPrompt = await this._buildSessionContextPrompt(finalSystemPrompt, session, workingDir);
             // 3. Convert messages for LLM (без summary — они уже в system prompt)
             const messagesForLlm = optimizedMessages.filter((m) => m.role !== MessageRole.SUMMARY);
             const baseLlmMessages = ChatOrchestrator._sessionMessagesToLlm(messagesForLlm, effectiveAgentRole, author);
@@ -518,32 +695,45 @@ export class ChatOrchestrator {
                     }
                 }
             }
-            // 4. Get tools from registry, filtered by agent capabilities
-            let tools;
+            // 4. Get tools from registry, filtered by agent capabilities.
+            // baseTools — полный набор по агентам; tools — с учётом режима сессии
+            // (AD-025): пересобирается из baseTools после plan_enter/plan_exit.
+            let baseTools;
             if (this._toolRegistry) {
-                if (this._agentRegistry && effectiveAgentRole) {
-                    tools = this._agentRegistry.getToolsForAgent(effectiveAgentRole);
+                // agentRole всегда определён при нормальной работе (пользователь, @-mention,
+                // сабагент). Если агент НЕ найден в реестре или role undefined — модель получает
+                // НИКАКИХ инструментов. Никакого молчаливого fallback на «все non-MCP», иначе
+                // агент без shell видит execute_shell и «гадает по именам» вместо честного ответа.
+                const agentDef = effectiveAgentRole ? this._agentRegistry?.get(effectiveAgentRole) : undefined;
+                if (agentDef && effectiveAgentRole) {
+                    baseTools = this._agentRegistry.getToolsForAgent(effectiveAgentRole);
                 }
-                if (tools === undefined) {
-                    // Агент не найден в реестре — отдаём только встроенные инструменты (без MCP)
-                    const allNonMcp = Object.values(ToolCapability).filter((c) => c !== ToolCapability.MCP);
-                    tools = this._toolRegistry.filterByCapabilities(allNonMcp);
-                }
-                else if (tools.length === 0) {
-                    tools = [];
+                else {
+                    baseTools = [];
                 }
             }
+            let tools = this._filterToolsByMode(baseTools, session, sessionMode, planMode, planApproved);
             // 5. Create cancellation token
+            // Внутренний AbortController: абортится и по cancelToken.cancel()
+            // (POST /sessions/:id/abort → orchestrator.cancel), и по внешнему signal
+            // (cancelRetry в QueueProcessor). Его signal передаётся в тулы
+            // (ctx.abortSignal) — долгие тулы (например task/сабагент) подписываются
+            // на него и прерываются сразу, не дожидаясь завершения.
+            const toolAbortController = new AbortController();
             const cancelToken = {
                 cancelled: false,
                 cancel: () => {
                     cancelToken.cancelled = true;
+                    toolAbortController.abort();
                 },
             };
             this._cancellationTokens.set(streamId, cancelToken);
             signal.addEventListener('abort', () => {
                 cancelToken.cancel();
             }, { once: true });
+            // signal мог быть уже абортирован до входа (гонка с отменой из очереди)
+            if (signal.aborted)
+                cancelToken.cancel();
             // 6. Tool loop — stream LLM, execute tools, continue until no tool calls
             let toolIteration = 0;
             const currentMessages = [...baseLlmMessages];
@@ -554,8 +744,17 @@ export class ChatOrchestrator {
             let finalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
             let finalModel;
             const allToolCalls = [];
+            const allRawToolCalls = [];
             let stopAfterDeny = false;
             let denyStopReason;
+            /** metadata.i18n подставленного финального фоллбека (лимит итераций / deny / пустой ответ). */
+            let fallbackI18n;
+            /** Были ли deny-отказы за цикл (для осмысленного fallback пустого ответа). */
+            let hadDeny = false;
+            /** Отмена пришла во время исполнения тула — завершать обработку как отмену. */
+            let cancelledDuringTool = false;
+            // Предупреждение о заполненности контекстного окна (fire-and-forget, не блокирует вызов)
+            this._publishContextLimitWarning(session.id, routeResult.modelName, messagesForLlm);
             while (toolIteration < maxIterations) {
                 if (cancelToken.cancelled)
                     break;
@@ -611,23 +810,28 @@ export class ChatOrchestrator {
                 catch (e) {
                     const errMsg = String(e);
                     warning('ORCHESTRATOR', `LLM stream error: ${errMsg}`);
-                    if (accumulatedContent || accumulatedReasoning) {
-                        await this._saveAssistantMessage(session.id, accumulatedContent, streamId, effectiveAgentRole, finalUsage, chunkModel, accumulatedReasoning, debugCollector, true, providerName);
-                    }
                     this._cancellationTokens.delete(streamId);
-                    return {
-                        error: errMsg,
-                        errorType: this._classifyError(errMsg),
-                        canRetry: this._isRecoverable(errMsg),
-                    };
+                    return this._handleLlmFailure(session.id, streamId, e, publishChunk);
                 }
                 if (cancelToken.cancelled) {
-                    if (accumulatedContent || accumulatedReasoning) {
-                        await this._saveAssistantMessage(session.id, accumulatedContent, streamId, effectiveAgentRole, finalUsage, chunkModel, accumulatedReasoning, debugCollector, true, providerName);
+                    // Отмена: сохраняем уже выполненные tool-вызовы (персистентность
+                    // tool-chain) — иначе timeline вызовов пропадает из истории.
+                    await this._persistToolChain(session.id, streamId, providerName, effectiveAgentRole, chunkModel ?? finalModel, allRawToolCalls, allToolCalls, allIntermediateTexts, allReasoning);
+                    // Баг: накопленный текст ВСЕХ итераций (завершённые + текущая
+                    // незавершённая), а не только последней. Иначе при стопе в истории
+                    // остаётся обрывок на случайном месте, хотя пользователь видел весь
+                    // текст в UI до стопа (тексты завершённых итераций лежат в
+                    // allIntermediateTexts и раньше не попадали в content).
+                    const partialContent = this._joinAccumulatedTexts(allIntermediateTexts, accumulatedContent);
+                    // При отмене НЕ кладём allIntermediateTexts в metadata
+                    // (intermediate_text_blocks): они уже вошли в partialContent, иначе
+                    // UI (режим 'bottom') склеит их с content повторно — дубль.
+                    if (partialContent || accumulatedReasoning || allToolCalls.length > 0) {
+                        await this._saveAssistantMessage(session.id, partialContent, streamId, effectiveAgentRole, finalUsage, chunkModel, accumulatedReasoning, debugCollector, true, providerName, MessageRole.ASSISTANT, undefined, false, allToolCalls, undefined);
                     }
                     publishChunk('stream.cancelled', {
                         stream_id: streamId,
-                        content: accumulatedContent,
+                        content: partialContent,
                     });
                     this._cancellationTokens.delete(streamId);
                     return {};
@@ -644,6 +848,7 @@ export class ChatOrchestrator {
                 if (accumulatedContent) {
                     allIntermediateTexts.push({ text: accumulatedContent, iteration: toolIteration });
                 }
+                allRawToolCalls.push({ iteration: toolIteration, calls: toolCalls });
                 // Tool calls detected — execute them
                 debugCollector.captureRawModelResponse(`[tool_calls iteration ${toolIteration}]: ${JSON.stringify(toolCalls)}`);
                 // Add assistant message with tool calls to currentMessages
@@ -677,36 +882,11 @@ export class ChatOrchestrator {
                     else {
                         toolArgs = func.arguments || {};
                     }
-                    // Doom loop detection
-                    const doomKey = `${toolName}:${JSON.stringify(toolArgs)}`;
-                    const doomCount = (doomLoopTracker.get(doomKey) || 0) + 1;
-                    doomLoopTracker.set(doomKey, doomCount);
-                    if (doomCount >= MAX_DOOM_LOOP_COUNT) {
-                        warning('ORCHESTRATOR', `Doom loop detected: ${toolName} called ${doomCount} times with same args`);
-                        currentMessages.push({
-                            id: '',
-                            role: 'tool',
-                            content: `Ошибка: инструмент "${toolName}" вызван ${doomCount} раз(а) с одинаковыми аргументами. Цикл прерван.`,
-                            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                            disabled: false,
-                            pinned: false,
-                            branchId: '',
-                            toolCallId: tcId,
-                        });
-                        continue;
-                    }
-                    const tcStartedAt = new Date().toISOString();
-                    publishChunk('tool_call.started', {
-                        stream_id: streamId,
-                        session_id: session.id,
-                        call_id: tcId,
-                        name: toolName,
-                        arguments: toolArgs,
-                        iteration: toolIteration,
-                    });
                     const toolDef = this._toolRegistry?.get(toolName);
                     let toolResult;
-                    // AD-029: гранулярные permissions — проверяем перед выполнением тула.
+                    // AD-029: гранулярные permissions — проверяем ДО doom loop, чтобы
+                    // deny-повторы не блокировались безликим «Цикл прерван», а получали
+                    // полноценный feedback (tool_call.result) с объяснением политики.
                     // AD-025: учитываем текущий режим Plan/Act и строгость плана.
                     const permissionDecision = permissionEvaluator.check({
                         toolName,
@@ -717,12 +897,48 @@ export class ChatOrchestrator {
                         planMode,
                         planApproved,
                         mcpToolSettings: session.settings.mcpToolSettings,
+                        shellPolicy: this._getProtectedPaths() ?? undefined,
+                        protectedPaths: this._getProtectedPaths() ?? undefined,
+                        protectedPathsEnabled: this._getProtectedPathsEnabled(),
+                    });
+                    // Doom loop detection — только для вызовов, НЕ заблокированных
+                    // политикой. Deny-вызовы исключены: каждая попытка должна получать
+                    // понятный feedback с объяснением причины запрета, а не «Цикл
+                    // прерван». Механика для повторяющихся легальных вызовов сохраняется.
+                    if (permissionDecision.action !== 'deny') {
+                        const doomKey = `${toolName}:${JSON.stringify(toolArgs)}`;
+                        const doomCount = (doomLoopTracker.get(doomKey) || 0) + 1;
+                        doomLoopTracker.set(doomKey, doomCount);
+                        if (doomCount >= MAX_DOOM_LOOP_COUNT) {
+                            warning('ORCHESTRATOR', `Doom loop detected: ${toolName} called ${doomCount} times with same args`);
+                            currentMessages.push({
+                                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,
+                            });
+                            continue;
+                        }
+                    }
+                    const tcStartedAt = new Date().toISOString();
+                    publishChunk('tool_call.started', {
+                        stream_id: streamId,
+                        session_id: session.id,
+                        call_id: tcId,
+                        name: toolName,
+                        arguments: toolArgs,
+                        iteration: toolIteration,
                     });
                     let executeTool = permissionDecision.action === 'allow';
                     let deniedReason;
                     let userDenied = false;
                     if (permissionDecision.action === 'deny') {
-                        deniedReason = permissionDecision.reason;
+                        deniedReason = this._securityMessage(permissionDecision, 'en')
+                            ?? `Permission denied: ${permissionDecision.reason}`;
                     }
                     else if (permissionDecision.action === 'ask') {
                         const approval = await this._approvalManager.waitForDecision(session.id, {
@@ -730,24 +946,27 @@ export class ChatOrchestrator {
                             callId: tcId,
                             toolName,
                             arguments: toolArgs,
-                            reason: permissionDecision.reason,
+                            reason: this._securityMessage(permissionDecision, 'en')
+                                ?? permissionDecision.reason,
                         }, effectivePermissionConfig.askTimeoutMs);
                         if (approval.approved) {
                             executeTool = true;
                             // «Разрешить в сессии» (once:false) — добавляем allow-правило для
                             // тула в permission-конфиг сессии, чтобы не спрашивать повторно.
                             if (approval.once === false) {
-                                effectivePermissionConfig = await this._grantSessionToolAllow(session, toolName);
+                                effectivePermissionConfig = await this._grantSessionToolAllow(session, toolName, toolArgs, workingDir);
                                 permissionEvaluator = new PermissionEvaluator(effectivePermissionConfig);
                             }
                         }
                         else {
                             const why = approval.timeout
-                                ? 'истекло время ожидания подтверждения'
+                                ? sm('permission.ask_timeout')
                                 : approval.noSubscribers
-                                    ? 'нет подключённого пользователя для подтверждения'
-                                    : 'отклонено пользователем';
-                            deniedReason = `${permissionDecision.reason} (${why})`;
+                                    ? sm('permission.ask_no_subscribers')
+                                    : sm('permission.ask_denied');
+                            const baseDeny = this._securityMessage(permissionDecision, 'en')
+                                ?? `Permission denied: ${permissionDecision.reason}`;
+                            deniedReason = `${baseDeny} (${why})`;
                             userDenied = !approval.timeout && !approval.noSubscribers;
                         }
                     }
@@ -761,24 +980,29 @@ export class ChatOrchestrator {
                             matched_rule: permissionDecision.matchedRule,
                         });
                         toolResult = {
-                            content: `Permission denied: ${deniedReason}`,
+                            content: deniedReason ?? sm('tool.permission_denied_default'),
                             isError: true,
                             metadata: {
+                                ...(permissionDecision.messageId
+                                    ? { i18n: i18nMeta(`security.${permissionDecision.messageId.replaceAll('-', '_')}`, permissionDecision.params) }
+                                    : { i18n: i18nMeta('tool.permission_denied_default') }),
                                 permission: {
                                     action: 'deny',
-                                    reason: deniedReason,
+                                    reason: deniedReason ?? '',
                                     matched_rule: permissionDecision.matchedRule,
                                 },
                             },
                         };
+                        hadDeny = true;
                     }
                     else {
                         if (toolDef) {
                             const parsed = toolDef.parameters.safeParse(toolArgs);
                             if (!parsed.success) {
                                 toolResult = {
-                                    content: `Ошибка аргументов инструмента "${toolName}": ${parsed.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ')}`,
+                                    content: sm('tool.args_error', { tool: toolName, issues: parsed.error.issues.map(i => `${i.path.join('.') || 'root'}: ${i.message}`).join('; ') }),
                                     isError: true,
+                                    metadata: { i18n: i18nMeta('tool.args_error', { tool: toolName }) },
                                 };
                             }
                             else {
@@ -786,7 +1010,10 @@ export class ChatOrchestrator {
                                     toolResult = await toolDef.execute(parsed.data, {
                                         sessionId: session.id,
                                         messageId: message.metadata?.stream_id || streamId,
-                                        abortSignal: signal,
+                                        // Живой сигнал отмены: абортится как по /abort (cancel()),
+                                        // так и по cancelRetry (внешний signal). Без этого тулы
+                                        // (task/сабагент) не узнают о «Стоп» до своего завершения.
+                                        abortSignal: toolAbortController.signal,
                                         agentRole: effectiveAgentRole,
                                         workingDir,
                                         dataDir: this._modelPriceLoader ? undefined : undefined,
@@ -808,37 +1035,64 @@ export class ChatOrchestrator {
                                             routerConfig: this._routerConfig ?? undefined,
                                             contextConfig: this._contextConfig ?? undefined,
                                             securityConfig: this._securityConfig,
+                                            language: session.settings.language || 'ru',
                                             publish: (type, data) => publishChunk(type, data),
                                             streamId,
                                             sessionId: session.id,
+                                            // ID собственного tool-вызова — для вложенности вызовов
+                                            // саб-агента под блоком `task` в родительском стриме.
+                                            callId: tcId,
                                             toolRegistry: this._toolRegistry,
                                             permissionConfig: effectivePermissionConfig,
+                                            shellPolicy: this._getProtectedPaths() ?? undefined,
+                                            protectedPaths: this._getProtectedPaths() ?? undefined,
+                                            protectedPathsEnabled: this._getProtectedPathsEnabled(),
                                         },
                                     });
                                 }
                                 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 }) },
                             };
                         }
                     }
-                    publishChunk('tool_call.result', {
-                        stream_id: streamId,
-                        session_id: session.id,
-                        call_id: tcId,
-                        name: toolName,
-                        result: toolResult,
-                        iteration: toolIteration,
-                    });
+                    // Отмена пришла ВО ВРЕМЯ исполнения тула (например task/сабагент).
+                    // Фиксируем результат (цепочка тулов сохранится в истории), публикуем
+                    // tool_call.result (UI видит, чем тул завершился) и прекращаем
+                    // дальнейшие тулы/итерации — обработка завершится как отмена (ниже),
+                    // а не как обычное завершение с «ответ модели пуст».
+                    if (cancelToken.cancelled || toolAbortController.signal.aborted) {
+                        allToolCalls.push({
+                            name: toolName,
+                            args: toolArgs,
+                            id: tcId,
+                            result: toolResult,
+                            started_at: tcStartedAt,
+                            completed_at: new Date().toISOString(),
+                            iteration: toolIteration,
+                        });
+                        publishChunk('tool_call.result', {
+                            stream_id: streamId,
+                            session_id: session.id,
+                            call_id: tcId,
+                            name: toolName,
+                            result: toolResult,
+                            iteration: toolIteration,
+                        });
+                        cancelledDuringTool = true;
+                        break;
+                    }
                     // IPI-защита: оборачиваем tool-контент по матрице доверия + детектируем
                     // подозрительные паттерны (флаг/sanitize/block по конфигу).
                     if (this._securityConfig.promptInjection.enabled && !toolResult.isError) {
@@ -858,10 +1112,11 @@ export class ChatOrchestrator {
                             const applied = applyPolicy(toolResult.content, piConfig.mode, detection);
                             if (applied.blocked) {
                                 toolResult = {
-                                    content: `[BLOCKED] Результат инструмента "${toolName}" заблокирован: обнаружены признаки prompt injection (${detection.matches.slice(0, 5).join(', ')})`,
+                                    content: sm('security.injection_blocked', { tool: toolName, matches: detection.matches.slice(0, 5).join(', ') }),
                                     isError: true,
                                     metadata: {
                                         ...toolResult.metadata,
+                                        i18n: i18nMeta('security.injection_blocked', { tool: toolName }),
                                         injection_suspicious: true,
                                         injection_matches: detection.matches,
                                     },
@@ -888,6 +1143,18 @@ export class ChatOrchestrator {
                             }
                         }
                     }
+                    // Публикуем результат ПОСЛЕ IPI-обёртки: живой UI (tool_call.result)
+                    // должен получать тот же контент, что сохраняется в историю
+                    // (metadata.tool_results и tool-chain tool-сообщения), иначе при
+                    // перезагрузке вид результата меняется.
+                    publishChunk('tool_call.result', {
+                        stream_id: streamId,
+                        session_id: session.id,
+                        call_id: tcId,
+                        name: toolName,
+                        result: toolResult,
+                        iteration: toolIteration,
+                    });
                     // classify_conversation: сохраняем категорию в настройках сессии (AD-034)
                     if (toolName === 'classify_conversation' && !toolResult.isError) {
                         const cat = toolResult.metadata?.routingCategory || undefined;
@@ -902,20 +1169,19 @@ export class ChatOrchestrator {
                             });
                         }
                     }
-                    // AD-025/AD-027: обновляем локальный режим после plan_enter/plan_exit,
-                    // чтобы ограничения и system prompt применились к следующим тулам/итерациям.
+                    // AD-025/AD-039: обновляем локальный режим после plan_enter/plan_exit,
+                    // чтобы ограничения, system prompt и список тулов применились к
+                    // следующим тулам/итерациям.
                     if (!toolResult.isError && toolName === 'plan_enter') {
                         sessionMode = 'plan';
-                        finalSystemPrompt = this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved);
+                        finalSystemPrompt = await this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved);
+                        tools = this._filterToolsByMode(baseTools, session, sessionMode, planMode, planApproved);
                     }
                     else if (!toolResult.isError && toolName === 'plan_exit') {
-                        const meta = (toolResult.metadata ?? {});
-                        const planContent = typeof meta.plan_content === 'string' ? meta.plan_content : undefined;
-                        if (planContent) {
-                            planApproved = true;
-                            sessionMode = 'act';
-                        }
-                        finalSystemPrompt = this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved, planContent);
+                        planApproved = true;
+                        sessionMode = 'act';
+                        finalSystemPrompt = await this._buildPlanSystemPrompt(finalSystemPrompt, session, planMode, sessionMode, planApproved);
+                        tools = this._filterToolsByMode(baseTools, session, sessionMode, planMode, planApproved);
                     }
                     allToolCalls.push({
                         name: toolName,
@@ -946,6 +1212,12 @@ export class ChatOrchestrator {
                         break;
                     }
                 }
+                // Отмена между тулами итерации (например во время IPI-обработки) —
+                // тоже завершаем как отмену, а не идём на следующую LLM-итерацию.
+                if (!stopAfterDeny && (cancelToken.cancelled || toolAbortController.signal.aborted)) {
+                    cancelledDuringTool = true;
+                    break;
+                }
                 publishChunk('tool_call.loop', {
                     stream_id: streamId,
                     session_id: session.id,
@@ -956,14 +1228,45 @@ export class ChatOrchestrator {
                 if (stopAfterDeny)
                     break;
             }
+            // Отмена во время исполнения тула: завершаем ровно как ветку отмены
+            // (persist tool-chain + stream.cancelled), а не как обычное завершение
+            // с подставленным «Не удалось выполнить запрос: ответ модели пуст».
+            if (cancelledDuringTool) {
+                await this._persistToolChain(session.id, streamId, providerName, effectiveAgentRole, finalModel, allRawToolCalls, allToolCalls, allIntermediateTexts, allReasoning);
+                const partialContent = this._joinAccumulatedTexts(allIntermediateTexts, '');
+                // Промежуточные тексты уже вошли в partialContent — как в ветке отмены
+                // выше, НЕ дублируем их в metadata.intermediate_text_blocks.
+                if (partialContent || allToolCalls.length > 0) {
+                    await this._saveAssistantMessage(session.id, partialContent, streamId, effectiveAgentRole, finalUsage, finalModel, allReasoning.map((r) => r.text).join('\n\n---\n\n'), debugCollector, true, providerName, MessageRole.ASSISTANT, undefined, false, allToolCalls, undefined);
+                }
+                publishChunk('stream.cancelled', {
+                    stream_id: streamId,
+                    content: partialContent,
+                });
+                this._cancellationTokens.delete(streamId);
+                return {};
+            }
             // 7. Handle max iterations exceeded
             if (toolIteration >= maxIterations && !finalContent) {
-                finalContent = '(достигнут лимит итераций инструментов)';
+                finalContent = sm('session.max_iterations');
+                fallbackI18n = i18nMeta('session.max_iterations');
             }
             // AD-029: пользователь отклонил ask — обработка завершена. Фиксируем
             // причину в финальном сообщении (история tool_result уже собрана).
             if (stopAfterDeny && !finalContent) {
-                finalContent = `Обработка остановлена: ${denyStopReason ?? 'пользователь отклонил запрос'}`;
+                const reason = denyStopReason ?? sm('session.stopped_reason_denied');
+                finalContent = sm('session.stopped', { reason });
+                fallbackI18n = i18nMeta('session.stopped', { reason });
+            }
+            // Защита от пустого финального ответа: если цикл завершился (в т.ч.
+            // через doom loop / лимит итераций / модель вернула пустой контент)
+            // с пустым finalContent — подставляем осмысленное сообщение, чтобы
+            // в истории не оставалось пустого assistant-сообщения.
+            if (!finalContent) {
+                finalContent = hadDeny
+                    ? sm('session.denied_blocked')
+                    : sm('session.empty_response');
+                fallbackI18n = i18nMeta(hadDeny ? 'session.denied_blocked' : 'session.empty_response');
             }
             // 7.5. Quality check + escalation (AD-034)
             let qaPass;
@@ -985,7 +1288,7 @@ export class ChatOrchestrator {
                             reason: 'escalation_fallback',
                             strategy: 'default',
                         };
-                        const fbProvider = this._router.getProvider(fbDecision);
+                        const fbProvider = this._router.getProvider(fbDecision, undefined, effectiveReasoningLevel);
                         if (fbProvider) {
                             // Перевызываем LLM с fallback-моделью (без стриминга в UI)
                             try {
@@ -996,7 +1299,7 @@ export class ChatOrchestrator {
                                 if (fbResponse.content) {
                                     finalContent = fbResponse.content;
                                     qaPass = true;
-                                    qaReason = `Эскалация на ${fallbackProvider}/${fallbackModel}: ${qaResult.reason}`;
+                                    qaReason = sm('router.escalation', { provider: fallbackProvider, model: fallbackModel, reason: qaResult.reason });
                                     if (fbResponse.usage)
                                         finalUsage = fbResponse.usage;
                                     if (fbResponse.model)
@@ -1029,9 +1332,15 @@ export class ChatOrchestrator {
                     });
                 }
             }
+            // 7.8. Персистентность tool-chain (Вариант B): настоящие пары
+            // «assistant с toolCalls + tool-результаты» в session.messages, чтобы
+            // _sessionMessagesToLlm на следующем запросе выдавал OpenAI-совместимый
+            // диалог. Промежуточные сообщения помечаются metadata.tool_chain=true —
+            // UI их скрывает (визуализация уже есть в финальном сообщении).
+            await this._persistToolChain(session.id, streamId, providerName, effectiveAgentRole, finalModel, allRawToolCalls, allToolCalls, allIntermediateTexts, allReasoning);
             // 8. Save final assistant message
             const reasoningJoined = allReasoning.map((r) => r.text).join('\n\n---\n\n');
-            const savedContent = await this._saveAssistantMessage(session.id, finalContent, streamId, effectiveAgentRole, finalUsage, finalModel, reasoningJoined, debugCollector, false, providerName, MessageRole.ASSISTANT, undefined, false, allToolCalls, allIntermediateTexts, qaPass, qaReason);
+            const savedContent = await this._saveAssistantMessage(session.id, finalContent, streamId, effectiveAgentRole, finalUsage, finalModel, reasoningJoined, debugCollector, false, providerName, MessageRole.ASSISTANT, undefined, false, allToolCalls, allIntermediateTexts, qaPass, qaReason, fallbackI18n ? { i18n: fallbackI18n } : undefined);
             // Получаем актуальную сессию после сохранения
             const updatedSession = await this._sessionManager.getSession(session.id);
             const doneData = {
@@ -1066,7 +1375,23 @@ export class ChatOrchestrator {
             if (updatedSession) {
                 const userMsgCount = updatedSession.messages.filter((m) => m.role === MessageRole.USER && !m.metadata?.synthetic).length;
                 if (userMsgCount === 1) {
-                    autoTitleSession(updatedSession, this._sessionManager, provider).catch(() => { });
+                    const titleAgentDef = this._agentRegistry?.get('title');
+                    let titleProvider = provider;
+                    if (titleAgentDef?.reasoningLevel && providerName) {
+                        const tp = this._getProvider(providerName, updatedSession, titleAgentDef.reasoningLevel);
+                        if (tp)
+                            titleProvider = tp;
+                    }
+                    autoTitleSession(updatedSession, this._sessionManager, titleProvider)
+                        .then((title) => {
+                        if (title) {
+                            this._eventBus.publish(updatedSession.id, 'session.updated', {
+                                session_id: updatedSession.id,
+                                name: title,
+                            });
+                        }
+                    })
+                        .catch(() => { });
                 }
             }
             // 9. Check context optimization triggers
@@ -1135,11 +1460,8 @@ export class ChatOrchestrator {
         catch (e) {
             const errMsg = String(e);
             warning('ORCHESTRATOR', `Unexpected error: ${errMsg}`);
-            return {
-                error: errMsg,
-                errorType: 'internal',
-                canRetry: false,
-            };
+            this._cancellationTokens.delete(streamId);
+            return this._handleLlmFailure(session.id, streamId, e, publishChunk);
         }
     }
     cancel(streamId) {
@@ -1147,12 +1469,118 @@ export class ChatOrchestrator {
         if (token)
             token.cancel();
     }
-    async _handleDebugSystemMessage(session, message, signal, publishChunk, debugCollector, streamId) {
+    /**
+     * Регистрация внешнего cancel-токена (resume саб-агента): позволяет отменить
+     * фоновый прогон обычным путём — orchestrator.cancel(streamId) из
+     * POST /sessions/:id/abort (токен ищется в общей карте по streamId).
+     */
+    registerCancelToken(streamId, token) {
+        this._cancellationTokens.set(streamId, token);
+    }
+    unregisterCancelToken(streamId) {
+        this._cancellationTokens.delete(streamId);
+    }
+    /**
+     * B2: возобновление прерванной/ошибочной дочерней сессии саб-агента.
+     * Валидация и захват блокировки — синхронно (ошибки маппятся route-ом в
+     * 400/404/409), выполнение — фоновое (mimo очереди: у дочерней сессии нет
+     * своего QueueProcessor). Защита от двойного resume — acquireLock +
+     * currentStream (последний также делает сессию abort-совместимой).
+     */
+    async startSubagentResume(childSessionId) {
+        const deps = this._subagentResumeDeps();
+        const { child, parent } = await validateSubagentResume(deps, childSessionId);
+        const streamId = generateStreamId();
+        const processId = `resume:${streamId}`;
+        // Атомарный захват — защита от гонки параллельных resume-запросов
+        const acquired = await this._sessionManager.acquireLock(childSessionId, processId);
+        if (!acquired) {
+            throw new SubagentResumeError('LOCKED', sm('task.resume_locked', { id: childSessionId }));
+        }
+        // currentStream — маркер активности для UI и abort-механики
+        await this._sessionManager.withLock(childSessionId, async (s) => {
+            s.currentStream = {
+                streamId,
+                message: sm('task.resume_marker'),
+                agentRole: s.settings.agentRole,
+                startedAt: nowISO(),
+                cancelled: false,
+            };
+            await this._sessionManager.saveSession(s);
+        });
+        // Отмена: orchestrator.cancel(streamId) → resumeAbort.abort() →
+        // runSubagent видит отмену (стрим + backoff-пауза) → finishAborted.
+        const resumeAbort = new AbortController();
+        const cancelToken = {
+            cancelled: false,
+            cancel: () => {
+                cancelToken.cancelled = true;
+                resumeAbort.abort();
+            },
+        };
+        this.registerCancelToken(streamId, cancelToken);
+        const freshChild = (await this._sessionManager.getSession(childSessionId)) ?? child;
+        void runSubagentResume(deps, {
+            child: freshChild,
+            parent,
+            streamId,
+            abortSignal: resumeAbort.signal,
+        })
+            .catch((err) => {
+            warning('ORCHESTRATOR', `subagent resume failed: ${err instanceof Error ? err.message : String(err)}`);
+            this._eventBus.publish(childSessionId, 'stream.error', {
+                stream_id: streamId,
+                error: String(err),
+                error_type: 'resume_failed',
+                can_retry: false,
+            });
+        })
+            .finally(async () => {
+            this.unregisterCancelToken(streamId);
+            try {
+                await this._sessionManager.withLock(childSessionId, async (s) => {
+                    s.currentStream = undefined;
+                    await this._sessionManager.saveSession(s);
+                });
+            }
+            catch { /* сессия могла быть удалена */ }
+            try {
+                await this._sessionManager.releaseLock(childSessionId, processId);
+            }
+            catch { /* ignore */ }
+        });
+        return {
+            status: 'started',
+            child_session_id: childSessionId,
+            parent_session_id: parent.id,
+            stream_id: streamId,
+        };
+    }
+    /** Зависимости resume из приватных резолверов оркестратора. */
+    _subagentResumeDeps() {
+        return {
+            sessionManager: this._sessionManager,
+            eventBus: this._eventBus,
+            agentRegistry: this._agentRegistry ?? { get: () => undefined },
+            toolRegistry: this._toolRegistry ?? undefined,
+            contextConfig: this._contextConfig ?? undefined,
+            contextOptimizer: this._optimizer ?? undefined,
+            routerConfig: this._routerConfig ?? undefined,
+            securityConfig: this._securityConfig,
+            permissionConfig: this._permissionConfig,
+            shellPolicy: this._getProtectedPaths() ?? undefined,
+            protectedPaths: this._getProtectedPaths() ?? undefined,
+            protectedPathsEnabled: this._getProtectedPathsEnabled(),
+            getProvider: (child) => this._getProvider(child.settings.provider || '', child, child.settings.reasoningLevel),
+            getWorkingDir: (child) => this._resolveWorkingDir(child),
+        };
+    }
+    async _handleDebugSystemMessage(session, message, signal, publishChunk, debugCollector, streamId, reasoningLevel) {
         const providerName = message.provider || session.settings.provider || '';
-        const provider = this._getProvider(providerName, session);
+        const provider = this._getProvider(providerName, session, reasoningLevel);
         if (!provider) {
             return {
-                error: `Провайдер ${providerName || 'не указан'} не найден или не настроен`,
+                error: sm('router.provider_not_found', { provider: providerName || sm('router.provider_unspecified') }),
                 errorType: 'provider_not_found',
                 canRetry: false,
             };
@@ -1207,7 +1635,8 @@ export class ChatOrchestrator {
         }
         catch (e) {
             warning('ORCHESTRATOR', `Debug system message stream error: ${e}`);
-            return { error: String(e), errorType: this._classifyError(String(e)), canRetry: this._isRecoverable(String(e)) };
+            this._cancellationTokens.delete(streamId);
+            return this._handleLlmFailure(session.id, streamId, e, publishChunk);
         }
         if (cancelToken.cancelled) {
             publishChunk('stream.cancelled', { stream_id: streamId, content: accumulatedContent });
@@ -1287,7 +1716,8 @@ export class ChatOrchestrator {
         }
         catch (e) {
             warning('ORCHESTRATOR', `Summarization stream error: ${e}`);
-            return { error: String(e), errorType: this._classifyError(String(e)), canRetry: this._isRecoverable(String(e)) };
+            this._cancellationTokens.delete(streamId);
+            return this._handleLlmFailure(session.id, streamId, e, publishChunk);
         }
         if (cancelToken.cancelled) {
             publishChunk('stream.cancelled', { stream_id: streamId, content: accumulatedContent });
@@ -1343,13 +1773,19 @@ export class ChatOrchestrator {
         this._cancellationTokens.delete(streamId);
         return {};
     }
-    _getProvider(providerName, session) {
+    _getProvider(providerName, session, reasoningLevel) {
         const modelName = session.settings.model || '';
         const sharedConfig = this._providerLoader(providerName);
         if (!sharedConfig)
             return null;
         try {
-            const provider = ProviderFactory.create(providerName, toCoreProviderConfig(sharedConfig, modelName || sharedConfig.defaultModel || ''), session.settings.temperature);
+            const effectiveModel = modelName || sharedConfig.defaultModel || '';
+            const contextWindow = this._resolveModelContextWindow(effectiveModel);
+            const provider = ProviderFactory.create(providerName, {
+                ...toCoreProviderConfig(sharedConfig, effectiveModel, reasoningLevel ?? session.settings.reasoningLevel),
+                maxTokens: session.settings.maxTokens,
+                numCtx: contextWindow > 0 ? contextWindow : undefined,
+            }, session.settings.temperature);
             return this._wrapWithGateway(provider, session);
         }
         catch (e) {
@@ -1357,6 +1793,39 @@ export class ChatOrchestrator {
             return null;
         }
     }
+    /**
+     * Размер контекстного окна модели: приоритет у сохранённого значения
+     * (ModelConfig.contextWindow через оптимизатор), иначе справочник.
+     */
+    _resolveModelContextWindow(modelName) {
+        const window = this._optimizer?.getContextWindow(modelName);
+        if (window && window > 0)
+            return window;
+        return lookupContextWindow(modelName).window;
+    }
+    /**
+     * Публикует context.limit_warning, когда оценка токенов контекста достигла
+     * порога (CONTEXT_LIMIT_WARNING_PERCENT) от окна модели. Уведомление не
+     * блокирует вызов LLM — это fire-and-forget сигнал для UI.
+     */
+    _publishContextLimitWarning(sessionId, modelName, messages) {
+        if (!this._optimizer)
+            return;
+        const contextWindow = this._resolveModelContextWindow(modelName);
+        if (!(contextWindow > 0))
+            return;
+        const estimatedTokens = this._optimizer.estimateTokens(messages);
+        if (estimatedTokens <= 0)
+            return;
+        const percent = Math.round((estimatedTokens / contextWindow) * 100);
+        if (percent >= CONTEXT_LIMIT_WARNING_PERCENT) {
+            this._eventBus.publish(sessionId, 'context.limit_warning', {
+                percent,
+                context_window: contextWindow,
+                estimated_tokens: estimatedTokens,
+            });
+        }
+    }
     /**
      * AD-036: оборачивает провайдер в GatewayProvider с привязкой к сессии.
      * Если gateway выключен — возвращает провайдер как есть (обратная совместимость).
@@ -1383,7 +1852,7 @@ export class ChatOrchestrator {
      * Выбор провайдера и модели через роутер (AD-034).
      * Если роутер недоступен — fallback на _getProvider().
      */
-    _routeProvider(session, message) {
+    _routeProvider(session, message, reasoningLevel) {
         if (this._router && session.settings.routingEnabled !== false) {
             const toolCallNames = message.toolCalls?.map((tc) => {
                 const func = tc.function;
@@ -1394,7 +1863,8 @@ export class ChatOrchestrator {
                 userMessage: message.content,
                 toolCalls: toolCallNames,
             });
-            let provider = this._router.getProvider(decision);
+            const routedWindow = this._resolveModelContextWindow(decision.modelName);
+            let provider = this._router.getProvider(decision, undefined, reasoningLevel ?? session.settings.reasoningLevel, session.settings.maxTokens, routedWindow > 0 ? routedWindow : undefined);
             if (provider) {
                 provider = this._wrapWithGateway(provider, session);
                 return {
@@ -1408,7 +1878,7 @@ export class ChatOrchestrator {
             // (например, категория не имеет маппинга в routingContent),
             // используем стандартный _getProvider() для провайдера сессии
             const fallbackName = session.settings.provider || '';
-            provider = this._getProvider(fallbackName, session);
+            provider = this._getProvider(fallbackName, session, reasoningLevel);
             if (provider) {
                 return {
                     provider,
@@ -1420,7 +1890,7 @@ export class ChatOrchestrator {
         }
         // Fallback: старый метод (если роутер недоступен или все пути выше не сработали)
         const providerName = message.provider || session.settings.provider || '';
-        const provider = this._getProvider(providerName, session);
+        const provider = this._getProvider(providerName, session, reasoningLevel);
         if (!provider)
             return null;
         return {
@@ -1468,6 +1938,7 @@ export class ChatOrchestrator {
                 branchId: '',
                 toolUse: isOwnMessage ? msg.toolCalls : undefined,
                 toolCallId: isOwnMessage ? msg.toolCallId : undefined,
+                reasoning: isOwnMessage && llmRole === MessageRole.ASSISTANT ? msg.reasoning : undefined,
                 agentRole: msg.agentRole,
             });
         }
@@ -1503,7 +1974,86 @@ export class ChatOrchestrator {
             return {};
         }
     }
-    async _saveAssistantMessage(sessionId, content, streamId, agentRole, usage, model, reasoning, debugCollector, isCancelled, provider, role = MessageRole.ASSISTANT, summaryOf, skipEvent = false, toolResults, intermediateTextBlocks, qaPass, qaReason) {
+    /**
+     * Персистентность tool-chain (Вариант B): настоящие пары
+     * «assistant с toolCalls + tool-результаты» в session.messages, чтобы
+     * _sessionMessagesToLlm на следующем запросе выдавал OpenAI-совместимый
+     * диалог. Промежуточные сообщения помечаются metadata.tool_chain=true —
+     * UI их скрывает (визуализация уже есть в финальном сообщении).
+     * Вызывается и в успешном пути, и при отмене (уже выполненные итерации).
+     */
+    async _persistToolChain(sessionId, streamId, providerName, agentRole, finalModel, allRawToolCalls, allToolCalls, allIntermediateTexts, allReasoning) {
+        for (const raw of allRawToolCalls) {
+            const iteration = raw.iteration;
+            const iterText = allIntermediateTexts.find((t) => t.iteration === iteration)?.text ?? '';
+            const iterReasoning = allReasoning.find((r) => r.iteration === iteration)?.text;
+            const assistantMsg = {
+                id: generateId(),
+                role: MessageRole.ASSISTANT,
+                seq: 0,
+                origin: 'local',
+                parts: [makeTextPart(iterText)],
+                content: iterText,
+                toolCalls: raw.calls,
+                createdAt: nowISO(),
+                disabled: false,
+                pinned: false,
+                hidden: false,
+                model: finalModel,
+                provider: providerName,
+                usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                agentRole,
+                metadata: { stream_id: streamId, tool_chain: true },
+                ...(iterReasoning ? { reasoning: iterReasoning } : {}),
+            };
+            await this._sessionManager.addMessage(sessionId, assistantMsg);
+            for (const tc of allToolCalls.filter((t) => t.iteration === iteration)) {
+                const toolContent = String(tc.result?.content ?? '');
+                // metadata ToolResult (в т.ч. i18n) пробрасывается в metadata сообщения —
+                // иначе локализационные ключи не доходят до истории и UI.
+                const toolResultMeta = tc.result?.metadata;
+                const toolMsg = {
+                    id: generateId(),
+                    role: MessageRole.TOOL,
+                    seq: 0,
+                    origin: 'local',
+                    parts: [makeTextPart(toolContent)],
+                    content: toolContent,
+                    toolCallId: tc.id,
+                    createdAt: nowISO(),
+                    disabled: false,
+                    pinned: false,
+                    hidden: false,
+                    model: finalModel,
+                    provider: providerName,
+                    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                    agentRole,
+                    metadata: {
+                        ...(toolResultMeta ?? {}),
+                        stream_id: streamId,
+                        tool_chain: true,
+                        tool_name: tc.name,
+                        args: tc.args,
+                    },
+                };
+                await this._sessionManager.addMessage(sessionId, toolMsg);
+            }
+        }
+    }
+    /**
+     * Склейка накопленного текста: все завершённые итерации (allIntermediateTexts)
+     * + текст текущей (незавершённой) итерации. Пустые фрагменты пропускаются.
+     * Используется при отмене (abort), чтобы в истории сохранялся полный
+     * частичный ответ, а не только обрывок последней итерации.
+     */
+    _joinAccumulatedTexts(intermediateTexts, current) {
+        const parts = [...intermediateTexts.map((t) => t.text), current]
+            .filter((t) => t && t.trim().length > 0);
+        return parts.join('\n\n');
+    }
+    async _saveAssistantMessage(sessionId, content, streamId, agentRole, usage, model, reasoning, debugCollector, isCancelled, provider, role = MessageRole.ASSISTANT, summaryOf, skipEvent = false, toolResults, intermediateTextBlocks, qaPass, qaReason, 
+    /** Дополнительные поля metadata (например metadata.i18n фоллбек-статусов). */
+    metadataExtra) {
         const finalContent = content;
         if (!isCancelled && content) {
             debugCollector.captureRawModelResponse(content);
@@ -1512,7 +2062,7 @@ export class ChatOrchestrator {
             debugCollector.captureReasoning(reasoning);
         }
         const debugInfo = debugCollector.getDebugInfo();
-        const metadata = { stream_id: streamId };
+        const metadata = { stream_id: streamId, ...metadataExtra };
         if (toolResults && toolResults.length > 0) {
             metadata.tool_results = toolResults;
         }
@@ -1600,51 +2150,111 @@ export class ChatOrchestrator {
         return finalContent;
     }
     _classifyError(errMsg) {
-        const lower = errMsg.toLowerCase();
-        if (lower.includes('rate') || lower.includes('limit') || lower.includes('429'))
-            return 'rate_limit';
-        if (lower.includes('timeout') || lower.includes('timed out'))
-            return 'timeout';
-        if (lower.includes('502') || lower.includes('503') || lower.includes('bad gateway'))
-            return 'server_error';
-        if (lower.includes('context length') || lower.includes('too long'))
-            return 'context_length';
-        if (lower.includes('401') || lower.includes('403') || lower.includes('auth'))
-            return 'auth_error';
-        if (lower.includes('model') && (lower.includes('not found') || lower.includes('invalid')))
-            return 'model_not_found';
-        return 'unknown';
+        // Общий хелпер (используется также retry-циклом саб-агента) — таксономия единая
+        return classifyLlmError(errMsg);
     }
-    _isRecoverable(errMsg) {
-        const lower = errMsg.toLowerCase();
-        const unrecoverable = [
-            'model not found', 'model_not_found', 'does not exist',
-            'invalid model', 'unknown model', 'invalid api key',
-            'incorrect api key', '401', 'authentication', 'unauthorized',
-        ];
-        return !unrecoverable.some((p) => lower.includes(p));
+    /**
+     * Человекочитаемое описание ошибки LLM (таймаут/обрыв соединения, сетевая
+     * ошибка). Для остальных ошибок — исходный текст.
+     */
+    _formatLlmError(error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        const lower = raw.toLowerCase();
+        if (lower.includes('abort') || lower.includes('operation was aborted') || lower.includes('timed out') || lower.includes('timeout')) {
+            return sm('router.timeout');
+        }
+        if (lower.includes('fetch failed') || lower.includes('network') || lower.includes('econnrefused') || lower.includes('enotfound') || lower.includes('eai_again')) {
+            return sm('router.network_error');
+        }
+        return raw;
     }
     /**
-     * AD-029: «Разрешить в сессии» (once:false). Добавляет allow-правило для тула
-     * в permission-конфиг сессии и сохраняет его. Если у сессии не было своего
-     * конфига — наследует глобальные правила, чтобы не потерять их при оверрайде.
+     * Единая обработка ошибки LLM-стрима: пишет last_error в user-сообщение
+     * сессии (по stream_id) и возвращает ProcessMessageResult. Публикация
+     * финального исхода (stream.retry для recoverable / stream.error для
+     * non-recoverable) — зона ответственности QueueProcessor, чтобы не было
+     * двойной публикации stream.error. Если ошибка recoverable — session
+     * разблокируется на уровне QueueProcessor после исчерпания попыток; сессия
+     * не остаётся заблокированной навсегда.
      */
-    async _grantSessionToolAllow(session, toolName) {
-        let cfg = session.settings.permission;
-        if (!cfg) {
-            cfg = {
-                rules: { ...this._permissionConfig.rules },
-                askTimeoutMs: this._permissionConfig.askTimeoutMs,
-            };
+    async _handleLlmFailure(sessionId, streamId, error, _publishChunk) {
+        const rawError = error instanceof Error ? error.message : String(error);
+        const humanError = this._formatLlmError(error);
+        // ContextLengthExceededError несёт русское сообщение («Контекстное окно
+        // превышено») — текстовый классификатор его не распознаёт, поэтому тип
+        // определяем по классу ошибки, чтобы UI показал дружелюбное сообщение.
+        const errorType = error instanceof ContextLengthExceededError
+            ? 'context_length'
+            : this._classifyError(rawError);
+        const canRetry = isLlmErrorRecoverable(error, rawError, errorType);
+        try {
+            await this._sessionManager.withLock(sessionId, async (s) => {
+                const userMsg = s.messages.find((m) => m.role === MessageRole.USER && m.metadata?.stream_id === streamId);
+                if (userMsg) {
+                    userMsg.metadata = { ...userMsg.metadata, last_error: humanError };
+                    await this._sessionManager.saveSession(s);
+                }
+            });
+        }
+        catch (err) {
+            warning('ORCHESTRATOR', `Не удалось записать last_error: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const next = {
-            ...cfg,
-            rules: { ...cfg.rules, [toolName]: 'allow' },
+        return { error: humanError, errorType, canRetry };
+    }
+    /** Строит permission-конфиг с добавленным грантом для заданной базы правил. */
+    _applyToolAllow(cfg, toolName, paths) {
+        const base = cfg ?? {
+            rules: { ...this._permissionConfig.rules },
+            askTimeoutMs: this._permissionConfig.askTimeoutMs,
         };
+        const rules = { ...base.rules };
+        if (paths.length > 0) {
+            if (rules[toolName] !== 'allow') {
+                const existing = (typeof rules[toolName] === 'object' && rules[toolName])
+                    ? { ...rules[toolName] }
+                    : {};
+                for (const p of paths)
+                    existing[p] = 'allow';
+                rules[toolName] = existing;
+            }
+        }
+        else {
+            rules[toolName] = 'allow';
+        }
+        return { ...base, rules };
+    }
+    /**
+     * AD-029: «Разрешить в сессии» (once:false). Если у вызова есть файловые
+     * параметры — одобряет КОНКРЕТНЫЕ абсолютные пути (правило-объект
+     * `rules[tool] = { path: 'allow' }`), иначе (shell/task/mcp) — весь тул.
+     * Если тул уже разрешён полностью ('allow') — не понижает до пути.
+     */
+    async _grantSessionToolAllow(session, toolName, toolArgs, workingDir) {
+        const paths = extractPaths(toolName, toolArgs, workingDir);
+        const next = this._applyToolAllow(session.settings.permission, toolName, paths);
         await this._sessionManager.withLock(session.id, async (s) => {
             s.settings.permission = next;
             await this._sessionManager.saveSession(s);
+            this._eventBus.publish(session.id, 'session.updated', {
+                session_id: session.id,
+                settings: s.settings,
+            });
         });
+        // AD-029: «Разрешить в сессии» для сабагентской (дочерней) сессии
+        // распространяется и на родителя (parentId): путь в правиле — абсолютный
+        // канонический, поэтому грант совпадёт при чтении того же файла и родителем,
+        // и ребёнком. Родительский грант обновляет и effectivePermissionConfig, и
+        // PermissionEvaluator при следующей обработке (сессия сохраняется в store).
+        if (session.parentId) {
+            await this._sessionManager.withLock(session.parentId, async (parent) => {
+                parent.settings.permission = this._applyToolAllow(parent.settings.permission, toolName, paths);
+                await this._sessionManager.saveSession(parent);
+                this._eventBus.publish(parent.id, 'session.updated', {
+                    session_id: parent.id,
+                    settings: parent.settings,
+                });
+            });
+        }
         return next;
     }
 }