micro-models-agent 2.10.0 → 2.12.0

package/dist/core/agent.js

@@ -1,8 +1,10 @@
-import { ProviderManager } from "../modules/providers/manager";
+import { ProviderManager, activeProviderEndpoint, reasoningStrategyForProvider } from "../modules/providers/manager";
 import { buildActiveProvider } from "../modules/providers/factory";
 import { t } from "../i18n/index";
-import { pc } from "../ui/colors";
+import { errMsg } from "../utils";
+import { resolveVerbosity } from "../ui/theme";
 import { join } from "path";
+import { projectMmaDir } from "../config/paths";
 import { PromptBuilder } from "./prompt-builder";
 import { processRegistry } from "../modules/processes";
 import { SessionLogger } from "./session-logger";
@@ -15,20 +17,29 @@ import { createLoopState, clearIterationSignals } from "./agent/loop-state";
 import { CompactionService } from "./agent/compaction";
 import { TokenTracker } from "./agent/token-tracker";
 import { buildPromptSnapshot, diffPrompt } from "./agent/prefix-monitor";
+import { recordArtifactWrite, testChurnFile } from "./agent/artifact-progress";
 import { ReasoningEffortResolver } from "./agent/reasoning-resolver";
+import { repairToolCallPairing } from "./agent/tool-pairing";
 import { ContextRenderer } from "./agent/context-renderer";
 import { ToolBatchExecutor } from "./agent/tool-batch";
 import { HallucinationGate } from "./agent/hallucination-gate";
+import { resolveArtifactStates } from "./agent/artifact-resolve";
 import { AuditGate } from "./agent/audit-gate";
+import { CriticGate, gatherTurnToolEvents } from "./agent/critic-gate";
+import { seedToolTags } from "../tools/auto-tags";
+import { CriticClient } from "../modules/critic/client";
+import { buildCriticProvider } from "../modules/critic/provider";
+import { CRITIC_READONLY_TOOLS } from "../modules/critic/tools";
+import { buildEvidencePack, isWorkMutation } from "../modules/critic/evidence";
+import { deriveSessionName, generateSessionTitle, } from "../modules/session/auto-name";
 import { resolvePromptOverflow, overflowHint, HINT_BLOCK_TOKENS, } from "./prompt-overflow";
 import { MAX_EMPTY_RESPONSE_RETRIES, MAX_LLM_ERROR_RETRIES, MAX_REPEATED_TOOL_CALLS, MAX_REPEATED_TOOL_CALLS_INTERACTIVE, MUTATION_CYCLE_NUDGE_THRESHOLD, } from "./agent/constants";
 export { toolOutputCharLimit, compactToolError } from "./agent/tool-output";
 /**
- * Read-only introspection tools. Repeating one with identical arguments can
- * never make progress, so the interactive loop hard-stops after a few repeats
- * (observed: `session_info` called in a tight loop after the task was already
- * complete). Mutating tools stay nudge-only so a legitimate edit/build/read
- * cycle is never cut short.
+ * Read-only тулты-интроспекции. Повтор одного с теми же аргументами прогресса
+ * не даст никогда, поэтому интерактивный цикл жёстко стопает после нескольких
+ * повторов (наблюдалось: `session_info` в тугом цикле после готовой задачи).
+ * Мутирующие — только nudge, чтобы легитимный edit/build/read-цикл не резать.
  */
 const LOOP_PRONE_STATUS_TOOLS = new Set([
     "session_info",
@@ -37,6 +48,13 @@ const LOOP_PRONE_STATUS_TOOLS = new Set([
     "file_info",
     "project_map",
 ]);
+function probeIdentityOf(config) {
+    return {
+        model: config.model,
+        baseUrl: activeProviderEndpoint(config.provider).baseUrl,
+        active: config.provider?.active,
+    };
+}
 /**
  * Ключ целевого объекта мутации для детекции «перфекционизм-цикла».
  * edit_file/write_file → путь файла; bash → нормализованная команда.
@@ -65,14 +83,23 @@ export function mutationTargetKey(name, rawArgs) {
         const cmd = a.command.replace(/\s+/g, " ").trim().slice(0, 80).toLowerCase();
         return cmd ? `bash:${cmd}` : null;
     }
-    // Bookkeeping churn: plan/todo repeated over the same action with slightly
-    // different args burned 10+ iterations in ses_mthn3c2a after an audit
-    // rejection (the model "fixed" the plan instead of the work).
+    // Bookkeeping-churn: повторы plan/todo над тем же действием с чуть разными
+    // аргументами сожгли 10+ итераций в ses_mthn3c2a после отклонения аудита
+    // (модель «чинила» план вместо работы).
     if ((name === "plan" || name === "todo") && typeof a.action === "string") {
         return `book:${name}:${a.action.toLowerCase()}`;
     }
+    // У plan_step нет action — ключ по status, чтобы повторные апдейты
+    // били в тот же гард подряд-дубликатов.
+    if (name === "plan_step" && typeof a.status === "string") {
+        return `book:${name}:${a.status.toLowerCase()}`;
+    }
     return null;
 }
+/**
+ * Агент: владеет циклом, конфигом, стоимостью, гейтами. Состояние хода —
+ * в LoopState, шаги — в extracted-модулях.
+ */
 export class Agent {
     deps;
     systemPromptAdded = false;
@@ -83,18 +110,22 @@ export class Agent {
      * переживает несколько запусков цикла — хранит lastCompactionShown. */
     contextRenderer;
     policyState;
-    /** Reasoning probe result (B2): starts from deps, refreshed lazily in run(). */
+    /** Итог reasoning-пробы (B2): старт из deps, лениво обновляется в run(). */
     probePassed;
-    /** Shared mutable reasoning state (owned by agent, shared with set_thinking tool). */
+    /** Общее мутабельное reasoning-состояние (владелец — агент, делит с set_thinking). */
     reasoningState;
-    /** Current iteration counter (exposed for tool cooldown checks). */
+    /** Счётчик текущей итерации (для кулдаунов тулов). */
     _currentIteration = 0;
-    /** Kind → replacement block for instructions/project-map blocks that
-     *  exceeded the system budget (resolved once before the first LLM call). */
+    /** Kind → блок-замена для instructions/project-map сверх бюджета (резолв раз до первого LLM-вызова). */
     promptOverrides = new Map();
-    /** Small always-included block explaining the compressed instructions. */
+    /** Идентичность, против которой гонялась проба. Сравнение ПО ЗНАЧЕНИЮ: все
+     *  write-пути мутят живой конфиг in place и передают ТОТ ЖЕ объект в
+     *  `reconfigure` — сравнение объектов изменения бы не увидело. Сидируется
+     *  в конструкторе (строки до мутаций). */
+    lastProbeIdentity;
+    /** Малый всегда-включённый блок про сжатые инструкции. */
     overflowHintBlock = null;
-    /** Guards the one-time async overflow resolution in run(). */
+    /** Гард одноразового асинхронного резолва переполнения в run(). */
     overflowResolved = false;
     constructor(deps) {
         this.deps = deps;
@@ -102,18 +133,19 @@ export class Agent {
         this.contextRenderer = new ContextRenderer();
         this.policyState = createPolicyState();
         this.probePassed = deps.reasoningProbePassed ?? false;
+        this.lastProbeIdentity = probeIdentityOf(deps.config);
         const initialLevel = (deps.config.reasoning?.mode !== "auto" ? deps.config.reasoning?.mode : undefined) ?? "medium";
         this.reasoningState = { level: initialLevel, overrideIteration: -100 };
     }
-    /** Expose context manager for REPL image attachment and other direct access. */
+    /** Менеджер контекста наружу (аттач картинок в REPL и др. прямой доступ). */
     get contextManager() {
         return this.deps.contextManager;
     }
-    /** Current effective reasoning level. */
+    /** Текущий эффективный уровень reasoning. */
     get reasoningLevel() {
         return this.reasoningState.level;
     }
-    /** Set reasoning level (used by REPL and CLI). "auto" clears a manual override. */
+    /** Ставит уровень reasoning (REPL/CLI). "auto" снимает ручной override. */
     setReasoningLevel(level) {
         if (level === "auto") {
             this.reasoningState.manual = false;
@@ -122,15 +154,24 @@ export class Agent {
         this.reasoningState.level = level;
         this.reasoningState.manual = true;
     }
-    /** Current iteration number (for tool cooldown checks). */
+    /** Номер текущей итерации (для кулдаунов тулов). */
     get currentIteration() {
         return this._currentIteration;
     }
+    /**
+     * Провенанс вызывающего: живой провайдер и модель (для стоимости/логов).
+     * @returns {provider, model} реально обслужившие вызов.
+     */
     callerProvenance() {
+        // Сначала живое имя: sticky failover переключает активную запись
+        // менеджера, не трогая config.provider.active.
+        const live = this.deps.getProviderName?.();
+        if (live)
+            return { provider: live, model: this.deps.config.model };
         const p = this.deps.config.provider;
         let providerName = p?.type || "unknown";
-        // When provider.entries exist, use the active entry's label for
-        // distinguishable cost provenance (e.g. "lmstudio" vs "ollama").
+        // При записях провайдера — метка активной, чтобы провенанс стоимости
+        // различался (напр. "lmstudio" vs "ollama").
         if (p?.entries && p.entries.length > 0) {
             const entry = p.active
                 ? p.entries.find((e) => e.label === p.active || e.type === p.active)
@@ -140,7 +181,7 @@ export class Agent {
         }
         return { provider: providerName, model: this.deps.config.model };
     }
-    /** Typed module accessor for CLI/REPL commands (e.g. /lsp). */
+    /** Типизированный доступ к модулям для CLI/REPL (напр. /lsp). */
     getModule(name) {
         return this.deps.moduleRegistry?.get(name);
     }
@@ -157,18 +198,46 @@ export class Agent {
         }
     }
     /**
-     * Install (or clear) the terminal-aware prompt surface used by interactive
-     * tools. Delegates to the tool executor so the shared ToolContext — the one
-     * tools actually receive — carries the same instance.
+     * Ставит (или снимает) терминальную prompt-поверхность для интерактивных
+     * тулов. Делегирует исполнителю, чтобы общий ToolContext — тот, что реально
+     * получают тулы — нёс тот же инстанс.
      */
     setPromptIO(io) {
         this.deps.toolExecutor.setPromptIO(io);
     }
+    /**
+     * Дописывает системный блок на текущий прогон (гайд онбординга).
+     * Удаление по идентичности через `removePromptBlock`. Блоки читаются при
+     * каждой `buildSystemPrompt`, эффект — со следующего хода.
+     */
+    pushPromptBlock(block) {
+        this.deps.promptBlocks.push(block);
+    }
+    /** Убирает ранее запушенный блок (по ссылке). */
+    removePromptBlock(block) {
+        const i = this.deps.promptBlocks.indexOf(block);
+        if (i >= 0)
+            this.deps.promptBlocks.splice(i, 1);
+    }
+    /** Тестовый вид текущих блоков промпта. */
+    getPromptBlocksForTest() {
+        return this.deps.promptBlocks;
+    }
+    /** Общий ToolContext (бросает, если bootstrap его не дал). */
+    get toolContext() {
+        if (!this.deps.toolCtx)
+            throw new Error("toolCtx not provided to Agent");
+        return this.deps.toolCtx;
+    }
+    /** Небросающийся вариант `toolContext` для опциональных/lifecycle-проверок. */
+    tryToolContext() {
+        return this.deps.toolCtx;
+    }
     buildSystemPrompt() {
         const systemBudget = Math.floor(this.deps.config.contextWindow * this.deps.config.contextBudget.systemPrompt);
         const builder = new PromptBuilder(systemBudget);
-        // Overflow replacements (compressed instructions / project map) take
-        // precedence over the original oversized blocks.
+        // Замены переполнения (сжатые инструкции/карта) приоритетнее исходных
+        // негабаритных блоков.
         const applyOverrides = (blocks) => blocks.map((b) => (b.kind && this.promptOverrides.has(b.kind) ? this.promptOverrides.get(b.kind) : b));
         builder.addBlocks(applyOverrides(this.deps.promptBlocks));
         const dynamic = this.deps.getDynamicPromptBlocks?.() ?? [];
@@ -200,11 +269,9 @@ export class Agent {
         };
     }
     /**
-     * Log the current context state to the session log. Called every iteration
-     * so the session.jsonl shows a full timeline of how the context grows,
-     * compacts, and what it consists of. The `start` snapshot additionally
-     * carries the system-prompt block breakdown (which blocks, priorities,
-     * token estimates, what was excluded by the budget).
+     * Пишет состояние контекста в лог сессии. Каждую итерацию — полный таймлайн
+     * роста/компакции/состава; `start`-снимок дополнительно несёт разбивку
+     * системных блоков (что, приоритеты, оценки, что срезал бюджет).
      */
     logContextStat(kind, iteration, slog, blocks) {
         const cm = this.deps.contextManager;
@@ -232,16 +299,19 @@ export class Agent {
             blocks,
         });
     }
+    /**
+     * Текущий системный промпт с подсчётом токенов (для /sysprompt, диагностики).
+     * @returns текст, число токенов, исключённые блоки.
+     */
     getSystemPromptInfo() {
         const { prompt, excluded } = this.buildSystemPrompt();
         const tokenCount = this.deps.llmProvider.countTokens(prompt);
         return { text: prompt, tokenCount, excluded };
     }
     /**
-     * One-time (first run) handling of instructions/project-map blocks that did
-     * not fit the system-prompt budget: they are summarized by the LLM into the
-     * remaining budget (disk-cached) or truncated, and a small hint block tells
-     * the model what happened and how to read the full source.
+     * Одноразовая (первый прогон) обработка instructions/project-map сверх
+     * бюджета: LLM суммаризирует в остаток (диск-кэш) или усекает, а малый
+     * hint-блок говорит модели что случилось и как читать полный источник.
      */
     async resolvePromptOverflowOnce() {
         const cfg = this.deps.config;
@@ -255,7 +325,7 @@ export class Agent {
             includedTokens: dry.blocks.filter((b) => b.included).reduce((s, b) => s + b.tokens, 0),
             systemBudget,
             provider: cfg.instructions?.summarize === false ? null : this.deps.llmProvider,
-            cacheDir: join(this.deps.baseDir, ".mma", "cache", "prompt-summaries"),
+            cacheDir: join(projectMmaDir(this.deps.baseDir), "cache", "prompt-summaries"),
             logger: this.deps.logger,
         });
         for (const r of res.replacements) {
@@ -294,26 +364,42 @@ export class Agent {
         }, phase);
         onPhase?.(phase);
     }
-    async run(input, onChunk, onMeta, onTool, onPhase) {
-        // Reset shutdown flag from previous interrupt
+    /**
+     * Прогоняет ход агента: MoE-путь или одиночный цикл, с автонеймингом сессии.
+     * @param input сообщение пользователя; @param onChunk/onMeta/onTool/onPhase/onReasoning колбэки вывода;
+     * @returns итог прогона.
+     */
+    async run(input, onChunk, onMeta, onTool, onPhase, onReasoning) {
+        // Сброс флага shutdown от прошлого прерывания
         this.shutdownRequested = false;
-        // Fresh controller per turn — the MoE path relies on it for Esc handling
-        // (executeSingleAgentLoop re-creates it again for the single-agent path).
+        // Свежий контроллер на ход — MoE-путь полагается на него для Esc
+        // (executeSingleAgentLoop пересоздаёт его же для одиночного пути).
         this.abortController = new AbortController();
         this.setScope();
-        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, baseDir, } = this.deps;
+        // P5 автосужение: детерминированно пред-посеваем теги тулов из сырого
+        // сообщения ДО первого LLM-вызова (системный промпт + схемы тулов).
+        // Только добавление — mid-session гранты enable_tools не снимаются.
+        // Пропуск при выключенном сужении (enableOnDemand: false → все тулы).
+        if (this.deps.config.tools?.enableOnDemand !== false && this.deps.toolTags) {
+            const added = seedToolTags(this.deps.toolTags, input);
+            if (added.length > 0) {
+                this.deps.logger.debug(`Auto-narrowing: pre-seeded tool tags [${added.join(", ")}]`);
+            }
+        }
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, } = this.deps;
         const slog = new SessionLogger(sessionManager, logger, () => this.callerProvenance());
         if (sessionManager && !sessionManager.getActive()) {
             sessionManager.create();
             logger.debug(`Session started: ${sessionManager.getActive()}`);
         }
+        const activeMeta = sessionManager?.getActiveMeta();
+        const isFirstMessage = !!activeMeta && activeMeta.messageCount === 0;
         if (!this.systemPromptAdded &&
             !contextManager.getActiveHistory().some((m) => m.role === "system")) {
-            // Log session startup diagnostics (environment, plugins, skills) as the
-            // first entry in session.jsonl so the file is self-describing for
-            // post-mortem analysis. LSP probe is logged separately from repl.ts
-            // since it may complete after this point. Dedup: logSessionStart
-            // checks for existing session_start entry to avoid double-logging.
+            // Стартовую диагностику сессии (окружение, плагины, скиллы) — первой
+            // записью в session.jsonl, чтобы файл был самоописываем для пост-анализа.
+            // LSP-проба логируется отдельно из repl.ts (может завершиться позже).
+            // Дедуп: logSessionStart проверяет существующий session_start от дублей.
             slog.logSessionStart({
                 environment: this.deps.envReport,
             });
@@ -321,9 +407,8 @@ export class Agent {
             if (lazy.length > 0) {
                 this.deps.promptBlocks.push(...lazy);
             }
-            // One-time resolution of instructions/project-map blocks that exceed
-            // the system-prompt budget: summarize (cached) or truncate them BEFORE
-            // the first real build so the model still receives the instructions.
+            // Одноразовый резолв instructions/project-map сверх бюджета: суммаризация
+            // (кэш) или усечение ДО первой сборки, чтобы модель инструкции получила.
             if (!this.overflowResolved) {
                 this.overflowResolved = true;
                 try {
@@ -333,9 +418,8 @@ export class Agent {
                     this.deps.logger.warn(t("prompt.overflow.failed", { error: String(err?.message ?? err) }));
                 }
             }
-            // B2: await the background reasoning probe next to the lazy prompt
-            // blocks so the FIRST LLM call already knows whether the backend
-            // respects the reasoning mechanism (bootstrap no longer blocks on it).
+            // B2: ждём фоновую reasoning-пробу рядом с ленивыми блоками, чтобы ПЕРВЫЙ
+            // LLM-вызов уже знал, держит ли бэкенд механизм (bootstrap больше не ждёт).
             if (this.deps.reasoningProbe) {
                 this.probePassed = await this.deps.reasoningProbe();
             }
@@ -352,17 +436,42 @@ export class Agent {
                 contextManager,
             });
         }
-        // A new user message starts a fresh compaction interval — iterations
-        // from the previous turn must not trigger a compaction on iteration 1
-        // of this one (observed: turn 2 compacted at iteration 8, deleting the
-        // just-sent task along with 40+ old turns).
+        // Новое сообщение — новый интервал компакции: итерации прошлого хода не
+        // должны триггерить компакцию на итерации 1 этого (наблюдалось: ход 2
+        // скомпактился на итерации 8, снеся только что присланную задачу с 40+ ходами).
         if (typeof contextManager.resetUserTurn === "function") {
             contextManager.resetUserTurn();
         }
         contextManager.addMessage({ role: "user", content: input });
         slog.logUser(input);
-        // Turn lifecycle for plugins: count tool events without touching the loop,
-        // and dispatch onTurnEnd exactly once — success, error or interrupt.
+        if (isFirstMessage && activeMeta && sessionManager) {
+            const meta = sessionManager.getActiveMeta();
+            if (meta && (meta.nameSource ?? "default") !== "manual") {
+                sessionManager.rename(meta.id, deriveSessionName(input), "auto");
+                if (config.session.autoName !== false) {
+                    const chat = async (prompt, signal) => {
+                        let text = "";
+                        for await (const chunk of llmProvider.chat([{ role: "user", content: prompt }], undefined, signal, { maxTokens: 48, reasoningEffort: "none" })) {
+                            if (chunk.type === "text" && chunk.content)
+                                text += chunk.content;
+                        }
+                        return text;
+                    };
+                    void generateSessionTitle(input, chat)
+                        .then((title) => {
+                        if (!title)
+                            return;
+                        const cur = sessionManager.getActiveMeta();
+                        if (cur && cur.id === meta.id && (cur.nameSource ?? "default") === "auto") {
+                            sessionManager.rename(meta.id, title, "auto");
+                        }
+                    })
+                        .catch(() => { });
+                }
+            }
+        }
+        // Жизненный цикл хода для плагинов: считаем тул-события вне цикла,
+        // onTurnEnd — ровно один раз (успех, ошибка или прерывание).
         const startedAt = Date.now();
         let toolCalls = 0;
         const countTool = (ev) => {
@@ -394,7 +503,7 @@ export class Agent {
                     toolExecutor,
                     logger,
                     baseDir: this.deps.baseDir,
-                }, input, () => this.executeSingleAgentLoop(input, slog, onChunk, onMeta, countTool, onPhase), {
+                }, input, () => this.executeSingleAgentLoop(input, slog, onChunk, onMeta, countTool, onPhase, onReasoning), {
                     onMeta,
                     onTool: countTool,
                     onPhase,
@@ -402,11 +511,11 @@ export class Agent {
                     onEvent: (event) => slog.logMoE(event.type, event.data),
                     sessionId: this.deps.sessionManager?.getActiveMeta()?.id,
                 })
-                : await this.executeSingleAgentLoop(input, slog, onChunk, onMeta, countTool, onPhase);
-            // In MoE mode the single-agent loop (the only writer of assistant turns)
-            // never runs — without this the history ends user→user across turns and
-            // session.jsonl is missing the assistant answer. Write the result once,
-            // only when MoE actually handled the turn (a fallback already wrote it).
+                : await this.executeSingleAgentLoop(input, slog, onChunk, onMeta, countTool, onPhase, onReasoning);
+            // В MoE-режиме одиночный цикл (единственный писатель ходов ассистента)
+            // не бежит — без этого история схлопнется user→user между ходами, а в
+            // session.jsonl не будет ответа. Пишем итог один раз и только когда MoE
+            // реально вёл ход (фолбэк уже записал сам).
             if (moeEnabled && result.moeHandled) {
                 if (result.text) {
                     contextManager.addMessage({ role: "assistant", content: result.text });
@@ -431,7 +540,7 @@ export class Agent {
             throw err;
         }
     }
-    async executeSingleAgentLoop(input, slog, onChunk, onMeta, onTool, onPhase) {
+    async executeSingleAgentLoop(input, slog, onChunk, onMeta, onTool, onPhase, onReasoning) {
         const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, } = this.deps;
         this.abortController = new AbortController();
         // Единый контейнер состояния цикла — заменяет ~24 разрозненных `let`.
@@ -444,7 +553,7 @@ export class Agent {
             slog,
             hallucinationDetector,
         });
-        const tokenTracker = new TokenTracker(this.costTracker, () => this.callerProvenance().provider);
+        const tokenTracker = new TokenTracker(this.costTracker, () => this.callerProvenance());
         const reasoningResolver = new ReasoningEffortResolver();
         const toolBatch = new ToolBatchExecutor({
             config,
@@ -463,11 +572,56 @@ export class Agent {
         });
         const hallucinationGate = new HallucinationGate(hallucinationDetector);
         const auditGate = new AuditGate(this.deps.finalAudit);
-        // Account for tool definitions in context budget (they're sent via body.tools, not messages)
-        // Tool definitions are recomputed each iteration so `enable_tools`
-        // (which mutates the shared activeToolTags array) can grow the
-        // LLM-visible tool set mid-run. Bound per-iteration to keep the budget
-        // estimate and boundedOutput set in sync with what is actually sent.
+        // Защита: частичные/легаси конфиги (тесты, старый config.json) могут не иметь
+        // домена `critic` — считаем выключенным, а не роняем цикл.
+        const criticConfig = {
+            enabled: config.critic?.enabled ?? false,
+            tools: config.critic?.tools ?? true,
+            maxCalls: config.critic?.maxCalls ?? 4,
+            maxRepairCycles: config.critic?.maxRepairCycles ?? 1,
+            timeoutMs: config.critic?.timeoutMs ?? 15000,
+        };
+        // Phase 2: выделенные провайдер/модель, если настроены, иначе активный
+        // провайдер (v1). Битый оверрайд — warn + фолбэк, никогда не молча.
+        const criticProvider = buildCriticProvider(config.critic, config, this.deps.llmProvider, {
+            logger,
+            getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
+        });
+        const criticClient = new CriticClient({
+            provider: criticProvider,
+            timeoutMs: criticConfig.timeoutMs,
+        });
+        const criticGate = new CriticGate({
+            enabled: criticConfig.enabled,
+            maxCalls: criticConfig.maxCalls,
+            maxRepairCycles: criticConfig.maxRepairCycles,
+            verify: this.deps.criticOverride?.verify ?? ((pack, signal) => criticClient.verify(pack, signal, {
+                // Phase 2 read-only цикл: проверки бегут последовательно здесь (гейт
+                // await'ится между пакетами тулов), через общий executor с read-only
+                // allowlist — записи/shell недостижимы.
+                runCheck: criticConfig.tools && this.deps.toolCtx
+                    ? async (tool, args) => {
+                        const res = await toolExecutor.executeByName(tool, args, {
+                            ...this.deps.toolCtx,
+                            toolAllowlist: [...CRITIC_READONLY_TOOLS],
+                        });
+                        return { ok: res.success, output: res.output ?? "" };
+                    }
+                    : undefined,
+            })),
+            buildPack: (d) => buildEvidencePack({
+                task: d.task,
+                planSummary: d.planSummary,
+                toolEvents: d.toolEvents,
+                baseDir: this.deps.baseDir,
+            }),
+            signal: this.abortController?.signal,
+        });
+        // Определения тулов учитываем в бюджете контекста (идут через body.tools, не messages).
+        // Пересчитываем каждую итерацию, чтобы `enable_tools` (мутит общий
+        // activeToolTags) мог растить видимый модели набор прямо в прогоне.
+        // Привязка к итерации держит оценку бюджета и boundedOutput в синхроне
+        // с реально отправляемым.
         let allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
         let boundedToolNames = new Set(allToolsForBudget.filter((t) => t.boundedOutput).map((t) => t.name));
         let toolTokenEstimate = allToolsForBudget.reduce((sum, t) => sum + estimateTokens(t.description + JSON.stringify(t.parameters)), 0);
@@ -476,7 +630,7 @@ export class Agent {
             state.iteration++;
             this._currentIteration = state.iteration;
             contextManager.noteIteration();
-            // Re-read the mutable tag set in case enable_tools was called.
+            // Перечитываем мутабельный набор тегов — вдруг вызывали enable_tools.
             allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
             boundedToolNames = new Set(allToolsForBudget.filter((t) => t.boundedOutput).map((t) => t.name));
             toolTokenEstimate = allToolsForBudget.reduce((sum, t) => sum + Math.ceil((t.description.length + JSON.stringify(t.parameters).length) / 4), 0);
@@ -494,13 +648,34 @@ export class Agent {
             // Единая точка компакции: интервал → качество (с cooldown) → переполнение.
             compactionService.compactIfNeeded(state);
             this.refreshSystemPrompt();
-            const history = contextManager.getActiveHistory();
+            // Позиционная нормализация истории перед отправкой: вклинившийся user
+            // (step-gate/auto-advance плана) или осиротевший tool ломает контракт
+            // OpenAI и даёт 400 у строгих провайдеров. Новые прогоны порядок не
+            // портят (pendingMessages), проход лечит уже испорченные resume-истории.
+            const history = repairToolCallPairing(contextManager.getActiveHistory());
             // Монитор стабильности префикса: считаем до запроса, пишем в llm_usage
             // после. Char-оценка (chars/4) достаточна — важна динамика ratio и
             // причина расхождения, а не абсолютная точность токенов.
             const promptSnapshot = buildPromptSnapshot(history, allToolsForBudget);
             state.prefixDelta = diffPrompt(state.prevPrompt, promptSnapshot, estimateTokens);
             state.prevPrompt = promptSnapshot;
+            // Opt-in git-style context log: snapshot отправляемого контекста.
+            if (this.deps.contextLogger) {
+                try {
+                    this.deps.contextLogger.record(history, allToolsForBudget, {
+                        iteration: state.iteration,
+                        ts: new Date().toISOString(),
+                        systemTokens: estimateTokens(promptSnapshot.system),
+                        toolTokens: estimateTokens(promptSnapshot.tools),
+                        historyTokens: estimateTokens(promptSnapshot.history),
+                        totalTokens: contextManager.getEstimatedTokens(),
+                        contextWindow: config.contextWindow,
+                    });
+                }
+                catch {
+                    // Логирование контекста не должно ронять агент.
+                }
+            }
             if (state.prefixDelta.cause === "system" ||
                 state.prefixDelta.cause === "tools" ||
                 state.prefixDelta.cause === "history" ||
@@ -520,6 +695,7 @@ export class Agent {
             const toolCalls = [];
             let sawToolCall = false;
             let emittedReasoning = false;
+            let malformedToolArgs = 0;
             this.emitPhase(state.iteration, "thinking", onPhase);
             const llmStart = Date.now();
             const baseline = tokenTracker.beginIteration(state, contextManager.getEstimatedTokens());
@@ -554,7 +730,7 @@ export class Agent {
                         break;
                     if (chunk.type === "text" && chunk.content) {
                         if (emittedReasoning && !textContent) {
-                            onMeta?.("\n\n");
+                            onReasoning?.("\n\n");
                         }
                         textContent += chunk.content;
                         const textOut = pluginManager.runOnText({ iteration: state.iteration, logger, contextManager }, chunk.content);
@@ -565,7 +741,7 @@ export class Agent {
                         if (config.showReasoning) {
                             const metaOut = pluginManager.runOnMeta({ iteration: state.iteration, logger, contextManager }, chunk.content);
                             if (metaOut) {
-                                onMeta?.(pc.dim(metaOut));
+                                onReasoning?.(metaOut);
                             }
                             emittedReasoning = true;
                         }
@@ -577,7 +753,13 @@ export class Agent {
                             parsedArgs = JSON.parse(chunk.toolCall.arguments);
                         }
                         catch {
+                            // Битый JSON аргументов раньше молча превращался в `{}` —
+                            // модель звала тул с пустыми параметрами и не понимала причины.
+                            // Логируем и сообщаем модели, чтобы она повторила вызов.
                             parsedArgs = {};
+                            malformedToolArgs++;
+                            logger.diagnostic("warn", `Invalid JSON in tool_call arguments for "${chunk.toolCall.name}" (${chunk.toolCall.arguments.length} chars) — passing {}`);
+                            slog.logError(`tool_args_parse_error: tool="${chunk.toolCall.name}" tool_call_id="${chunk.toolCall.id}" chars=${chunk.toolCall.arguments.length}`);
                         }
                         toolCalls.push({
                             id: chunk.toolCall.id,
@@ -593,18 +775,17 @@ export class Agent {
                         tokenTracker.recordApiUsage(state, baseline, chunk.usage);
                     }
                     if (chunk.type === "warning" && chunk.content) {
-                        // Non-fatal provider notice (e.g. answer cut by the completion
-                        // cap). Rendered through the text stream so it lands after the
-                        // partial line without disturbing markdown formatting; it is NOT
-                        // added to the assistant context/history.
-                        logger.warn(`LLM warning: ${chunk.content}`);
+                        // Нефатальное уведомление провайдера (напр., ответ срезан cap'ом).
+                        // Рендерим через текстовый стрим, чтобы легло после частичной строки,
+                        // не ломая markdown; в контекст/историю ассистента НЕ добавляем.
+                        logger.diagnostic("warn", `LLM warning: ${chunk.content}`);
                         onChunk?.(`\n\n> ⚠️ ${chunk.content}\n`);
                     }
                 }
             }
             catch (err) {
                 if (this.shutdownRequested || err?.name === "AbortError") {
-                    logger.info("LLM call aborted (interrupt)");
+                    logger.diagnostic("info", "LLM call aborted (interrupt)");
                     break;
                 }
                 // Восстановимые ошибки LLM (например, токен-лимит на середине
@@ -614,7 +795,7 @@ export class Agent {
                 if (err instanceof LlmError && err.recoverable && state.llmErrorRetries < MAX_LLM_ERROR_RETRIES) {
                     state.iterRecoverableLlmError = true;
                     state.llmErrorRetries++;
-                    logger.warn(`Recoverable LLM error, feeding back (${state.llmErrorRetries}/${MAX_LLM_ERROR_RETRIES}): ${err.message}`);
+                    logger.diagnostic("warn", `Recoverable LLM error, feeding back (${state.llmErrorRetries}/${MAX_LLM_ERROR_RETRIES}): ${err.message}`);
                     slog.logError(err.message);
                     pluginManager.runOnError({ iteration: state.iteration, logger, contextManager }, err);
                     contextManager.addMessage({
@@ -649,6 +830,14 @@ export class Agent {
             if (this.shutdownRequested) {
                 break;
             }
+            // Сообщаем модели, что её аргументы тула были невалидным JSON: иначе она
+            // видит лишь «пустой» вызов и не знает, что нужно повторить корректно.
+            if (malformedToolArgs > 0) {
+                contextManager.addMessage({
+                    role: "user",
+                    content: `<system-summary>${malformedToolArgs} tool call(s) in your last response had invalid JSON arguments and were executed with empty parameters. Re-issue them with valid JSON.</system-summary>`,
+                });
+            }
             let llmResponse = null;
             if (sawToolCall) {
                 llmResponse = { type: "tool_call", calls: toolCalls };
@@ -660,6 +849,22 @@ export class Agent {
                 llmResponse = { type: "reasoning", content: reasoningContent };
             }
             pluginManager.runOnAfterThink({ iteration: state.iteration, logger, contextManager }, llmResponse);
+            // Аннотация вывода модели в context-log (reasoning/текст/tool_calls).
+            // НЕ входит в отправляемый контекст — пишется отдельным [OUTPUT]-блоком.
+            if (this.deps.contextLogger && (reasoningContent || textContent || toolCalls.length > 0)) {
+                try {
+                    this.deps.contextLogger.recordOutput({
+                        iteration: state.iteration,
+                        ts: new Date().toISOString(),
+                        reasoning: reasoningContent || undefined,
+                        text: textContent || undefined,
+                        toolCalls: toolCalls.map((tc) => ({ name: tc.name, arguments: tc.arguments })),
+                    });
+                }
+                catch {
+                    // Логирование контекста не должно ронять агент.
+                }
+            }
             // Детекция повторных одинаковых тулов (структурная, не по ключевым
             // словам). Сигнал питает reasoning policy для понижения effort на рутине.
             if (sawToolCall) {
@@ -668,27 +873,31 @@ export class Agent {
                     .join("|");
                 if (signature && signature === state.lastToolSignature) {
                     state.iterRepetitive = true;
-                    // Nudge fires in ALL modes: an identical (tool,args) repeat is a
-                    // wasted iteration — observed with qwen3.5-9b re-running the same
-                    // verification command back-to-back after the answer was already
-                    // in the result. Mutating tools stay nudge-only in interactive
-                    // sessions (the user keeps control); status tools, which can never
-                    // make progress by repeating, hard-stop after a few identical calls.
-                    logger.info(`Repeated identical tool call detected (iteration ${state.iteration}) — nudging model to finish or change approach`);
+                    // Nudge во ВСЕХ режимах: идентичный (тул,аргументы) повтор — пустая
+                    // итерация (наблюдалось: qwen3.5-9b гонял ту же verify-команду подряд,
+                    // когда ответ уже был в результате). Мутирующие в интерактиве —
+                    // только nudge (контроль у пользователя); status-тулы, которым повтор
+                    // прогресса не даст никогда, — жёсткий стоп после нескольких повторов.
+                    logger.diagnostic("info", `Repeated identical tool call detected (iteration ${state.iteration}) — nudging model to finish or change approach`);
                     contextManager.addMessage({
                         role: "user",
                         content: `<system-summary>You just called the same tool with identical arguments. If the task is done, answer with a final text response NOW. If the command failed, try a different approach.</system-summary>`,
                     });
                     state.repeatedToolCount++;
+                    // Жёсткий стоп — только для status-тулов, которые не могут
+                    // прогрессировать от повтора. Мутирующие/побочные тулы (например,
+                    // bash) остаются nudge-only: пользователь мог явно попросить
+                    // выполнить команду несколько раз, и обрыв дал бы пустой ответ.
+                    const allStatusTools = toolCalls.every((tc) => LOOP_PRONE_STATUS_TOOLS.has(tc.name));
                     if (this.deps.exitOnComplete) {
-                        if (state.repeatedToolCount >= MAX_REPEATED_TOOL_CALLS) {
-                            logger.debug("Exit-on-complete: repeated identical tool call, stopping");
+                        if (state.repeatedToolCount >= MAX_REPEATED_TOOL_CALLS && allStatusTools) {
+                            logger.debug("Exit-on-complete: repeated identical status tool call, stopping");
                             break;
                         }
                     }
                     else if (state.repeatedToolCount >= MAX_REPEATED_TOOL_CALLS_INTERACTIVE &&
-                        toolCalls.every((tc) => LOOP_PRONE_STATUS_TOOLS.has(tc.name))) {
-                        logger.warn(`Repeated identical status tool ${state.repeatedToolCount}× (iteration ${state.iteration}) — stopping to avoid an infinite loop`);
+                        allStatusTools) {
+                        logger.diagnostic("warn", `Repeated identical status tool ${state.repeatedToolCount}× (iteration ${state.iteration}) — stopping to avoid an infinite loop`);
                         break;
                     }
                 }
@@ -705,6 +914,11 @@ export class Agent {
             const cycleNudges = [];
             if (sawToolCall) {
                 for (const tc of toolCalls) {
+                    // Прогресс тест/спек-артефактов (обобщённо, по пути файла).
+                    if ((tc.name === "write_file" || tc.name === "edit_file") &&
+                        typeof tc.arguments.path === "string") {
+                        recordArtifactWrite(state.artifactChurn, tc.arguments.path);
+                    }
                     const target = mutationTargetKey(tc.name, tc.arguments);
                     if (!target)
                         continue;
@@ -716,6 +930,10 @@ export class Agent {
                         cycleNudges.push(target);
                     }
                 }
+                for (const tc of toolCalls) {
+                    if (isWorkMutation(tc.name))
+                        state.mutationsSinceCritic++;
+                }
             }
             if (sawToolCall) {
                 const batch = await toolBatch.execute(state, toolCalls, boundedToolNames, textContent, reasoningContent, input, onTool, onMeta, slog);
@@ -723,12 +941,23 @@ export class Agent {
                     break;
                 }
                 if (cycleNudges.length > 0) {
-                    logger.info(`Perfectionism cycle detected (${cycleNudges.length} target(s) at ${MUTATION_CYCLE_NUDGE_THRESHOLD}+ mutations) — nudging model to finalize`);
+                    logger.diagnostic("info", `Perfectionism cycle detected (${cycleNudges.length} target(s) at ${MUTATION_CYCLE_NUDGE_THRESHOLD}+ mutations) — nudging model to finalize`);
                     contextManager.addMessage({
                         role: "user",
                         content: `<system-summary>You have already modified or re-run the same target many times (e.g. ${cycleNudges[0]}). If the latest output is correct, STOP polishing and answer with a final text response. More identical edits will not change the result.</system-summary>`,
                     });
                 }
+                // Тест/спек-churn: серия правок тестов без единой production-правки
+                // (обобщённо — см. artifact-progress.ts).
+                const churnFile = testChurnFile(state.artifactChurn);
+                if (churnFile) {
+                    state.artifactChurn.nudged = true;
+                    logger.diagnostic("info", `Test/spec artifact churn: "${churnFile}" repeatedly edited with no production changes — nudging to implement or change approach`);
+                    contextManager.addMessage({
+                        role: "user",
+                        content: `<system-summary>${t("exec.test_churn_nudge", { file: churnFile })}</system-summary>`,
+                    });
+                }
                 this.contextRenderer.render(this.deps.config.ui, contextManager, onMeta);
                 // Тулы означают, что модель продолжила работать, а не переотвечает —
                 // послабление на повтор после аудита больше не действует.
@@ -745,6 +974,11 @@ export class Agent {
                 contextManager,
                 onMeta,
                 onChunk,
+                // Строка о неуверенности — диагностика: только verbose-режим.
+                verbose: resolveVerbosity(this.deps.config.ui) === "verbose",
+                // Заземление заявлений на диск (отсутствующие/непарсящиеся файлы,
+                // поданные как созданные/валидные). Резолвится здесь — у гейта нет fs.
+                artifacts: resolveArtifactStates(this.deps.baseDir, textContent),
             });
             if (verdict.action === "block") {
                 return {
@@ -786,7 +1020,7 @@ export class Agent {
             if (!textContent?.trim()) {
                 if (state.emptyResponseRetries < MAX_EMPTY_RESPONSE_RETRIES) {
                     state.emptyResponseRetries++;
-                    logger.warn(`Empty response on iteration ${state.iteration} (retry ${state.emptyResponseRetries}/${MAX_EMPTY_RESPONSE_RETRIES})`);
+                    logger.diagnostic("warn", `Empty response on iteration ${state.iteration} (retry ${state.emptyResponseRetries}/${MAX_EMPTY_RESPONSE_RETRIES})`);
                     contextManager.addMessage({
                         role: "user",
                         content: `<system-summary>Your previous response was empty. Answer the user's task now with a final text response or call a tool. Do not reply with reasoning only.</system-summary>`,
@@ -794,7 +1028,22 @@ export class Agent {
                     continue;
                 }
                 state.emptyResponseExhausted = true;
-                logger.warn(`Empty response retries exhausted after ${MAX_EMPTY_RESPONSE_RETRIES} attempts`);
+                logger.diagnostic("warn", `Empty response retries exhausted after ${MAX_EMPTY_RESPONSE_RETRIES} attempts`);
+            }
+            const criticAction = await criticGate.evaluate({
+                state,
+                iteration: state.iteration,
+                logger,
+                contextManager,
+                slog,
+                task: input,
+                planSummary: this.deps.planSummary?.() ?? undefined,
+                toolEvents: gatherTurnToolEvents(contextManager),
+                beforeFinish: true,
+            });
+            if (criticAction === "retry") {
+                state.suppressRepetitionRetry = true;
+                continue;
             }
             const auditVerdict = await auditGate.evaluate({
                 state,
@@ -812,8 +1061,6 @@ export class Agent {
                 // auditFailed уже выставлен вентилем.
                 break;
             }
-            // reject → continue: аудит уже добавил контекст и взвёл suppressRepetitionRetry.
-            continue;
         }
         const tokensUsed = contextManager.getEstimatedTokens();
         const budget = contextManager.getBudget();
@@ -838,13 +1085,15 @@ export class Agent {
             };
         }
         return {
-            success: state.emptyResponseExhausted || state.auditFailed ? false : true,
+            success: !(state.emptyResponseExhausted || state.auditFailed || state.retryLoopStopped),
             text: state.lastText,
             error: state.emptyResponseExhausted
                 ? t("error.empty_response")
                 : state.auditFailed
                     ? t("error.audit_failed", { summary: state.lastAuditSummary })
-                    : undefined,
+                    : state.retryLoopStopped
+                        ? t("error.retry_loop_stopped", { count: state.consecutiveFailedBatches })
+                        : undefined,
             iterationCount: state.iteration,
             contextUsed: tokensUsed,
             contextLimit: budget.history,
@@ -883,16 +1132,54 @@ export class Agent {
             source: state.cacheSource,
         };
     }
+    /** Сбрасывает контекст (следующий прогон пересоберёт системный промпт). */
     clearContext() {
         this.deps.contextManager.clear();
         this.systemPromptAdded = false;
     }
+    /**
+     * Применяет новый конфиг живьём: provider-first проба контекста, пересборка
+     * провайдера, ресайз бюджетов, обновление стоимости.
+     * @param config новый конфиг приложения.
+     */
     async reconfigure(config) {
         const { TokenCounter } = await import("../llm/token-counter");
-        const { provider: newProvider } = buildActiveProvider(config, this.deps.logger, {
+        // Provider-first контекст: при смене модели/бэкенда спрашиваем новый
+        // провайдер о реально отдаваемом окне ДО пересборки бюджетов вокруг
+        // (возможно протухшего) настроенного значения. Ручные правки
+        // `contextWindow` без смены идентичности уважаются как есть.
+        // Fail-open: ошибки пробы хранят настроенное значение.
+        try {
+            const nextId = probeIdentityOf(config);
+            const prevId = this.lastProbeIdentity;
+            const identityChanged = prevId.model !== nextId.model ||
+                prevId.baseUrl !== nextId.baseUrl ||
+                prevId.active !== nextId.active;
+            if (identityChanged) {
+                const nextEndpoint = activeProviderEndpoint(config.provider);
+                const { probeModel, probeProviderContext } = await import("../llm/model-loader");
+                const lmProbe = await probeModel(nextEndpoint.baseUrl, config.model);
+                const detected = (lmProbe ? { model: lmProbe.model, actual: lmProbe.contextLength } : null) ??
+                    (await probeProviderContext(nextEndpoint.baseUrl, config.model, {
+                        apiKey: nextEndpoint.apiKey,
+                        providerType: nextEndpoint.type,
+                    }));
+                if (detected && detected.actual !== config.contextWindow) {
+                    this.deps.logger?.info(`Context probe: auto-set contextWindow from provider — model "${detected.model}" serves ${detected.actual} tokens (configured was ${config.contextWindow}).`);
+                    config.contextWindow = detected.actual;
+                }
+                this.lastProbeIdentity = nextId;
+            }
+        }
+        catch {
+            // Проба — best-effort, переключение модели/провайдера не блокируем никогда.
+        }
+        const built = buildActiveProvider(config, this.deps.logger, {
             getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
         });
+        const newProvider = built.provider;
         this.deps.llmProvider = newProvider;
+        this.deps.getProviderName = () => built.manager.activeName;
         this.deps.toolExecutor.updateProvider(newProvider);
         const newTokenCounter = new TokenCounter(config.model);
         this.deps.contextManager.resize(config.contextWindow, config.contextBudget, newTokenCounter);
@@ -900,7 +1187,25 @@ export class Agent {
         if (this.deps.configRef)
             this.deps.configRef.current = config;
         this.costTracker.setModel(config.model);
+        this.applyReasoningStrategy(config.provider);
+    }
+    /**
+     * Пересчитывает стратегию reasoning из АКТИВНОЙ записи провайдера. Без этого
+     * `/provider use` и смена модели оставляли старую стратегию (prompt-tag против
+     * openai-effort) на весь сеанс. При "none" гасит probe-флаг, чтобы auto-режим
+     * не полагался на устаревшую пробу.
+     * @param provider конфиг провайдера (entries/active).
+     */
+    applyReasoningStrategy(provider) {
+        const strategy = reasoningStrategyForProvider(provider);
+        this.deps.reasoningStrategy = strategy;
+        if (strategy === "none")
+            this.probePassed = false;
     }
+    /**
+     * Переключает активного провайдера (и модель опционально).
+     * @param name имя записи провайдера; @param model новая модель.
+     */
     setProvider(name, model) {
         const { manager, provider } = buildActiveProvider(this.deps.config, this.deps.logger, {
             getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
@@ -908,9 +1213,15 @@ export class Agent {
         manager.switch(name, model);
         const providerCfg = manager.toConfig();
         this.deps.config.provider = providerCfg;
+        this.applyReasoningStrategy(providerCfg);
         this.deps.llmProvider = provider;
+        this.deps.getProviderName = () => manager.activeName;
         this.deps.toolExecutor.updateProvider(provider);
     }
+    /**
+     * Список записей провайдеров с флагом активности.
+     * @returns записи с label и active.
+     */
     listProviders() {
         const manager = new ProviderManager(this.deps.config.provider, {
             contextWindow: this.deps.config.contextWindow,
@@ -924,7 +1235,7 @@ export class Agent {
             active: e.label === activeName || e.type === activeName,
         }));
     }
-    /** Build (or get cached) the provider for a named entry — health checks, routing. */
+    /** Строит (или берёт кэшированный) провайдер именованной записи — health-чеки, роутинг. */
     getProviderFor(name) {
         try {
             const manager = new ProviderManager(this.deps.config.provider, {
@@ -938,10 +1249,15 @@ export class Agent {
             manager.switch(name);
             return manager.active;
         }
-        catch {
+        catch (err) {
+            this.deps.logger.warn(t("error.provider_build", { name, error: errMsg(err) }));
             return undefined;
         }
     }
+    /**
+     * Заменяет контекст историей (resume): системный промпт + сообщения без дубля system.
+     * @param messages сообщения для восстановления.
+     */
     setContext(messages) {
         const { contextManager } = this.deps;
         contextManager.clear();
@@ -958,6 +1274,11 @@ export class Agent {
             });
         }
     }
+    /**
+     * Останавливает прогон: abort, kill фоновых процессов, onSessionEnd.
+     * Лог сессии НЕ закрываем — сессия ещё активна (закрытие только на
+     * реальном конце: exit, delete).
+     */
     shutdown() {
         this.shutdownRequested = true;
         this.abortController?.abort();
@@ -967,8 +1288,8 @@ export class Agent {
         if (killed > 0) {
             logger.info(t("env.killed_processes", { count: String(killed) }));
         }
-        // Note: do NOT close session log here — the session is still active.
-        // Session log is closed only when the session actually ends (exit, session delete).
+        // Сессионный лог тут НЕ закрываем — сессия ещё активна.
+        // Закрытие только на реальном конце (exit, удаление сессии).
         pluginManager.runOnSessionEnd({
             logger,
             sessionManager: sessionManager?.getActiveMeta(),