micro-models-agent 0.63.3 → 1.1.0

package/dist/core/agent.js

@@ -1,84 +1,179 @@
 import { ProviderManager } from "../modules/providers/manager";
+import { buildActiveProvider } from "../modules/providers/factory";
 import { t } from "../i18n/index";
 import { pc } from "../ui/colors";
+import { join } from "path";
 import { PromptBuilder } from "./prompt-builder";
 import { processRegistry } from "../modules/processes";
 import { SessionLogger } from "./session-logger";
 import { runWithMoE } from "./agent-moe";
 import { CostTracker } from "../modules/pricing/index";
-const TOOL_RESULT_MAX_TOKENS_RATIO = 0.3;
-const TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
-const QUALITY_TRIGGER_THRESHOLD = 40;
-/** Minimum iterations between quality-triggered forced compactions. Without
- * this, a low-quality context re-triggers compaction on EVERY iteration
- * (observed: 56 compactions in ~28 min) and the compaction itself can't
- * restore quality, so the agent burns the whole budget compacting. */
-const FORCED_COMPACTION_COOLDOWN = 3;
-const MAX_LLM_ERROR_RETRIES = 2;
-/** True when the text looks like a raw JSON tool payload (garbage to display). */
-function isToolCallJson(text) {
-    const trimmed = text.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+import { createPolicyState } from "../modules/reasoning/policy";
+import { estimateTokens } from "../llm/token-counter";
+import { LlmError } from "../llm/llm-errors";
+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 { ReasoningEffortResolver } from "./agent/reasoning-resolver";
+import { ContextRenderer } from "./agent/context-renderer";
+import { ToolBatchExecutor } from "./agent/tool-batch";
+import { HallucinationGate } from "./agent/hallucination-gate";
+import { AuditGate } from "./agent/audit-gate";
+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.
+ */
+const LOOP_PRONE_STATUS_TOOLS = new Set([
+    "session_info",
+    "process_list",
+    "process_log",
+    "file_info",
+    "project_map",
+]);
+/**
+ * Ключ целевого объекта мутации для детекции «перфекционизм-цикла».
+ * edit_file/write_file → путь файла; bash → нормализованная команда.
+ * Остальные тула (read-only, bookkeeping) не считаются мутациями.
+ * Внимание: в цикле toolCall.arguments — сырая JSON-строка от провайдера.
+ */
+export function mutationTargetKey(name, rawArgs) {
+    let a = null;
+    if (typeof rawArgs === "string") {
         try {
-            JSON.parse(trimmed);
-            return true;
+            a = JSON.parse(rawArgs);
         }
         catch {
-            return false;
+            return null;
         }
     }
-    return false;
-}
-/**
- * Max chars a tool result may occupy, given remaining budget and whether
- * the tool bounds its own output. Tools that declare `boundedOutput` (e.g.
- * read_file with its line limit) are never truncated by the budget — a
- * near-full context used to cut them to ~2K chars, making the model believe
- * files were truncated and re-read them forever.
- */
-export function toolOutputCharLimit(remainingBudget, historyBudget, bounded) {
-    if (bounded)
-        return Number.MAX_SAFE_INTEGER;
-    const maxCharsByRatio = Math.floor(historyBudget * TOOL_RESULT_MAX_TOKENS_RATIO * 2);
-    return Math.min(remainingBudget, maxCharsByRatio, TOOL_RESULT_ABSOLUTE_MAX_CHARS);
+    else if (rawArgs && typeof rawArgs === "object") {
+        a = rawArgs;
+    }
+    if (!a)
+        return null;
+    if ((name === "edit_file" || name === "write_file") && typeof a.path === "string") {
+        return `write:${a.path.replace(/\\/g, "/").toLowerCase()}`;
+    }
+    if (name === "bash" && typeof a.command === "string") {
+        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).
+    if ((name === "plan" || name === "todo") && typeof a.action === "string") {
+        return `book:${name}:${a.action.toLowerCase()}`;
+    }
+    return null;
 }
 export class Agent {
     deps;
     systemPromptAdded = false;
     shutdownRequested = false;
     abortController = null;
-    lastCompactionShown = 0;
     costTracker;
+    /** Рендер UI-индикаторов контекста (stats-бар/компакция). Экземпляр
+     * переживает несколько запусков цикла — хранит lastCompactionShown. */
+    contextRenderer;
+    policyState;
+    /** Reasoning probe result (B2): starts from deps, refreshed lazily in run(). */
+    probePassed;
+    /** Shared mutable reasoning state (owned by agent, shared with set_thinking tool). */
+    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). */
+    promptOverrides = new Map();
+    /** Small always-included block explaining the compressed instructions. */
+    overflowHintBlock = null;
+    /** Guards the one-time async overflow resolution in run(). */
+    overflowResolved = false;
     constructor(deps) {
         this.deps = deps;
         this.costTracker = new CostTracker(deps.config.model, deps.config.pricing);
+        this.contextRenderer = new ContextRenderer();
+        this.policyState = createPolicyState();
+        this.probePassed = deps.reasoningProbePassed ?? false;
+        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. */
     get contextManager() {
         return this.deps.contextManager;
     }
+    /** Current effective reasoning level. */
+    get reasoningLevel() {
+        return this.reasoningState.level;
+    }
+    /** Set reasoning level (used by REPL and CLI). "auto" clears a manual override. */
+    setReasoningLevel(level) {
+        if (level === "auto") {
+            this.reasoningState.manual = false;
+            return;
+        }
+        this.reasoningState.level = level;
+        this.reasoningState.manual = true;
+    }
+    /** Current iteration number (for tool cooldown checks). */
+    get currentIteration() {
+        return this._currentIteration;
+    }
     callerProvenance() {
-        return {
-            provider: this.deps.config.provider?.type || "unknown",
-            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").
+        if (p?.entries && p.entries.length > 0) {
+            const entry = p.active
+                ? p.entries.find((e) => e.label === p.active || e.type === p.active)
+                : p.entries[0];
+            if (entry)
+                providerName = entry.label || entry.type || providerName;
+        }
+        return { provider: providerName, model: this.deps.config.model };
     }
     /** Typed module accessor for CLI/REPL commands (e.g. /lsp). */
     getModule(name) {
         return this.deps.moduleRegistry?.get(name);
     }
+    /**
+     * Запуск тула по имени из CLI/REPL (например, lsp_check). Обходит
+     * инкапсуляцию: команды не должны лезть в приватные `deps`.
+     */
+    runTool(name, args) {
+        return this.deps.toolExecutor.executeByName(name, args);
+    }
     setScope() {
         if (this.deps.scope) {
             this.deps.toolExecutor.setScope(this.deps.scope);
         }
     }
+    /**
+     * 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.
+     */
+    setPromptIO(io) {
+        this.deps.toolExecutor.setPromptIO(io);
+    }
     buildSystemPrompt() {
         const systemBudget = Math.floor(this.deps.config.contextWindow * this.deps.config.contextBudget.systemPrompt);
         const builder = new PromptBuilder(systemBudget);
-        builder.addBlocks(this.deps.promptBlocks);
+        // 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?.() ?? [];
         if (dynamic.length > 0) {
-            builder.addBlocks(dynamic);
+            builder.addBlocks(applyOverrides(dynamic));
         }
         const pluginBlocks = (this.deps.pluginManager.runOnBuildPrompt?.() ?? []).flatMap((content) => content && content.trim() !== ""
             ? [
@@ -93,10 +188,14 @@ export class Agent {
         if (pluginBlocks.length > 0) {
             builder.addBlocks(pluginBlocks);
         }
+        if (this.overflowHintBlock) {
+            builder.addBlock(this.overflowHintBlock);
+        }
         const result = builder.build();
         return {
             prompt: result.prompt,
             excluded: result.excluded,
+            excludedBlocks: result.excludedBlocks,
             blocks: result.blocks,
         };
     }
@@ -139,23 +238,46 @@ export class Agent {
         return { text: prompt, tokenCount, excluded };
     }
     /**
-     * Some OpenAI-compatible backends (llama.cpp) omit `usage` from responses,
-     * leaving apiPromptTokens/apiCompletionTokens at 0. Fall back to local
-     * estimates so JSON results still carry meaningful token metrics.
+     * 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.
      */
-    resolveUsageTokens(apiPromptTokens, apiCompletionTokens, estimatedPromptTokens, completionChars) {
-        if (apiPromptTokens > 0 || apiCompletionTokens > 0) {
-            return {
-                prompt: apiPromptTokens,
-                completion: apiCompletionTokens,
-                total: apiPromptTokens + apiCompletionTokens,
-            };
+    async resolvePromptOverflowOnce() {
+        const cfg = this.deps.config;
+        const dry = this.buildSystemPrompt();
+        const overflow = dry.excludedBlocks.filter((b) => Boolean(b.kind));
+        if (overflow.length === 0)
+            return;
+        const systemBudget = Math.floor(cfg.contextWindow * cfg.contextBudget.systemPrompt);
+        const res = await resolvePromptOverflow({
+            overflow,
+            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"),
+            logger: this.deps.logger,
+        });
+        for (const r of res.replacements) {
+            if (r.kind)
+                this.promptOverrides.set(r.kind, r);
+        }
+        this.overflowHintBlock = res.hintBlock;
+        const needed = dry.blocks.filter((b) => b.included).reduce((s, b) => s + b.tokens, 0) +
+            overflow.reduce((s, b) => s + b.estimatedTokens, 0) +
+            HINT_BLOCK_TOKENS;
+        const hint = overflowHint(cfg, this.deps.configDir, needed);
+        for (const w of res.warnings) {
+            this.deps.logger.warn(t("prompt.overflow.exceeded", {
+                label: w.label,
+                original: String(w.originalTokens),
+                needed: String(needed),
+                budget: String(systemBudget),
+                mode: w.mode === "summary" ? "summarized" : "truncated",
+                resolved: String(w.resolvedTokens),
+                hint,
+            }));
         }
-        // ~4 chars per token is a reasonable heuristic when the backend gives
-        // us nothing (matches the pre-tiktoken fallback elsewhere in the code).
-        const prompt = Math.max(1, estimatedPromptTokens);
-        const completion = Math.max(0, Math.ceil(completionChars / 4));
-        return { prompt, completion, total: prompt + completion };
     }
     refreshSystemPrompt() {
         const { prompt } = this.buildSystemPrompt();
@@ -164,15 +286,6 @@ export class Agent {
             this.deps.contextManager.updateSystemPrompt?.(prompt);
         }
     }
-    truncateToolOutput(output, budget, currentTokens, bounded) {
-        const remainingBudget = Math.max(0, budget.history - currentTokens);
-        const maxChars = toolOutputCharLimit(remainingBudget, budget.history, bounded);
-        if (output.length <= maxChars)
-            return output;
-        const truncated = output.slice(0, maxChars);
-        const removedChars = output.length - maxChars;
-        return truncated + `\n\n${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
-    }
     emitPhase(iteration, phase, onPhase) {
         this.deps.pluginManager.runOnPhase?.({
             iteration,
@@ -184,6 +297,9 @@ export class Agent {
     async run(input, onChunk, onMeta, onTool, onPhase) {
         // Reset shutdown flag from previous interrupt
         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).
+        this.abortController = new AbortController();
         this.setScope();
         const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, baseDir, } = this.deps;
         const slog = new SessionLogger(sessionManager, logger, () => this.callerProvenance());
@@ -205,6 +321,24 @@ 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.
+            if (!this.overflowResolved) {
+                this.overflowResolved = true;
+                try {
+                    await this.resolvePromptOverflowOnce();
+                }
+                catch (err) {
+                    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).
+            if (this.deps.reasoningProbe) {
+                this.probePassed = await this.deps.reasoningProbe();
+            }
             const { prompt: systemPrompt, excluded } = this.buildSystemPrompt();
             contextManager.addMessage({ role: "system", content: systemPrompt });
             this.systemPromptAdded = true;
@@ -251,15 +385,44 @@ export class Agent {
             });
         };
         try {
-            const result = config.moe?.enabled === true
-                ? await runWithMoE({
+            const moeEnabled = config.moe?.enabled === true;
+            const moeRunner = this.deps.runWithMoEOverride ?? runWithMoE;
+            const result = moeEnabled
+                ? await moeRunner({
                     config,
                     llmProvider,
                     toolExecutor,
                     logger,
                     baseDir: this.deps.baseDir,
-                }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase), { onMeta, onTool: countTool, onPhase })
-                : await this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase);
+                }, input, () => this.executeSingleAgentLoop(input, slog, onChunk, onMeta, countTool, onPhase), {
+                    onMeta,
+                    onTool: countTool,
+                    onPhase,
+                    signal: this.abortController.signal,
+                    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).
+            if (moeEnabled && result.moeHandled) {
+                if (result.text) {
+                    contextManager.addMessage({ role: "assistant", content: result.text });
+                    if (config.session.autoSave) {
+                        slog.saveAssistantMessage(result.text);
+                    }
+                    slog.logAssistant(result.text, "", undefined, 0);
+                }
+                if (!result.success && result.error) {
+                    slog.logError(result.error);
+                }
+            }
+            const provenance = this.callerProvenance();
+            result.provider = provenance.provider;
+            result.model = provenance.model;
+            result.durationMs = Date.now() - startedAt;
             emitTurnEnd(result);
             return result;
         }
@@ -268,44 +431,38 @@ export class Agent {
             throw err;
         }
     }
-    async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
-        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, baseDir, } = this.deps;
-        const slog = new SessionLogger(sessionManager, logger, () => this.callerProvenance());
+    async executeSingleAgentLoop(input, slog, onChunk, onMeta, onTool, onPhase) {
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, } = this.deps;
         this.abortController = new AbortController();
-        let iteration = 0;
-        let lastText = "";
-        // The actual most-recent model output (tool commentary, retried answers
-        // included). Repetition is compared against THIS, not the last *accepted*
-        // text — a frozen accepted answer made consecutive retries compare
-        // against a stale baseline and flag every re-answer as repetitive.
-        let lastModelText = "";
-        let lastForcedCompactionIteration = -FORCED_COMPACTION_COOLDOWN;
-        let hallucinationRetries = 0;
-        let lastToolSignature = "";
-        let apiPromptTokens = 0;
-        let apiCompletionTokens = 0;
-        let apiCompletionChars = 0;
-        const MAX_HALLUCINATION_RETRIES = 3;
-        let consecutiveToolFailures = 0;
-        const MAX_CONSECUTIVE_TOOL_FAILURES = 5;
-        // Per-tool failure counts and which tools already produced a memory rule.
-        const toolFailureCounts = new Map();
-        const memoryRuleRecorded = new Set();
-        const MIN_REPEATED_TOOL_FAILURES = 3;
-        let auditRetries = 0;
-        const MAX_AUDIT_RETRIES = 3;
-        let emptyResponseRetries = 0;
-        const MAX_EMPTY_RESPONSE_RETRIES = 2;
-        let emptyResponseExhausted = false;
-        let auditFailed = false;
-        let lastAuditSummary = "";
-        // Set when the audit gate rejects a final answer and re-prompts: the next
-        // non-tool response is then a re-answer of an already-completed task, so
-        // a repetition verdict is expected and must not burn a hallucination retry.
-        let suppressRepetitionRetry = false;
-        let repeatedToolCount = 0;
-        const MAX_REPEATED_TOOL_CALLS = 2;
-        let llmErrorRetries = 0;
+        // Единый контейнер состояния цикла — заменяет ~24 разрозненных `let`.
+        const state = createLoopState();
+        // Модули цикла: каждый инкапсулирует одну ответственность и получает
+        // зависимости через конструктор (никаких глобальных синглтонов).
+        const compactionService = new CompactionService({
+            contextManager,
+            logger,
+            slog,
+            hallucinationDetector,
+        });
+        const tokenTracker = new TokenTracker(this.costTracker, () => this.callerProvenance().provider);
+        const reasoningResolver = new ReasoningEffortResolver();
+        const toolBatch = new ToolBatchExecutor({
+            config,
+            toolExecutor,
+            pluginManager,
+            contextManager,
+            hallucinationDetector,
+            compactionService,
+            logger,
+            memoryStore: this.deps.memoryStore,
+            costTracker: this.costTracker,
+            planSummary: this.deps.planSummary,
+            getAbortSignal: () => this.abortController?.signal,
+            isShutdownRequested: () => this.shutdownRequested,
+            setScope: () => this.setScope(),
+        });
+        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
@@ -313,10 +470,11 @@ export class Agent {
         // estimate and boundedOutput set in sync with what is actually sent.
         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 + Math.ceil((t.description.length + JSON.stringify(t.parameters).length) / 4), 0);
+        let toolTokenEstimate = allToolsForBudget.reduce((sum, t) => sum + estimateTokens(t.description + JSON.stringify(t.parameters)), 0);
         contextManager.setToolTokens(toolTokenEstimate);
-        while (iteration < config.maxToolIterations && !this.shutdownRequested) {
-            iteration++;
+        while (state.iteration < config.maxToolIterations && !this.shutdownRequested) {
+            state.iteration++;
+            this._currentIteration = state.iteration;
             contextManager.noteIteration();
             // Re-read the mutable tag set in case enable_tools was called.
             allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
@@ -324,7 +482,7 @@ export class Agent {
             toolTokenEstimate = allToolsForBudget.reduce((sum, t) => sum + Math.ceil((t.description.length + JSON.stringify(t.parameters).length) / 4), 0);
             contextManager.setToolTokens(toolTokenEstimate);
             pluginManager.runOnBeforeThink({
-                iteration,
+                iteration: state.iteration,
                 logger,
                 lastUserMessage: input,
                 contextManager,
@@ -333,68 +491,65 @@ export class Agent {
                     plan: (event, detail, iter) => slog.logPlan(event, detail, iter),
                 },
             });
-            if (contextManager.needsCompaction()) {
-                const result = contextManager.compact();
-                if (result) {
-                    logger.debug("Context compacted");
-                    slog.logCompaction({ reason: "interval", iteration, ...result });
-                    // Seed hallucination checker with files from compaction summary
-                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
-                }
-            }
-            const currentTokens = contextManager.getEstimatedTokens();
-            const budget = contextManager.getBudget();
-            const quality = contextManager.getQuality();
-            if (quality < QUALITY_TRIGGER_THRESHOLD &&
-                contextManager.getCompactionCount() > 0 &&
-                iteration - lastForcedCompactionIteration >= FORCED_COMPACTION_COOLDOWN) {
-                lastForcedCompactionIteration = iteration;
-                const result = contextManager.compact();
-                logger.warn(`Low context quality (${quality}%) — forced compaction`);
-                if (result) {
-                    slog.logCompaction({
-                        reason: `quality-triggered (${quality}% < ${QUALITY_TRIGGER_THRESHOLD}%)`,
-                        iteration,
-                        ...result,
-                    });
-                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
-                }
-            }
-            if (currentTokens > budget.history) {
-                const result = contextManager.compact();
-                logger.warn(`Context overflow (${currentTokens} > ${budget.history}), forced compaction`);
-                if (result) {
-                    slog.logCompaction({
-                        reason: `overflow (${currentTokens} > ${budget.history})`,
-                        iteration,
-                        ...result,
-                    });
-                    hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
-                }
-            }
+            // Единая точка компакции: интервал → качество (с cooldown) → переполнение.
+            compactionService.compactIfNeeded(state);
             this.refreshSystemPrompt();
             const history = contextManager.getActiveHistory();
-            slog.logToolDefs(allToolsForBudget.length, allToolsForBudget.map((t) => t.name), iteration);
-            if (iteration === 1) {
+            // Монитор стабильности префикса: считаем до запроса, пишем в llm_usage
+            // после. Char-оценка (chars/4) достаточна — важна динамика ratio и
+            // причина расхождения, а не абсолютная точность токенов.
+            const promptSnapshot = buildPromptSnapshot(history, allToolsForBudget);
+            state.prefixDelta = diffPrompt(state.prevPrompt, promptSnapshot, estimateTokens);
+            state.prevPrompt = promptSnapshot;
+            if (state.prefixDelta.cause === "system" ||
+                state.prefixDelta.cause === "tools" ||
+                state.prefixDelta.cause === "history" ||
+                state.prefixDelta.cause === "volatile") {
+                state.lastPrefixBreak = state.prefixDelta;
+            }
+            slog.logToolDefs(allToolsForBudget.length, allToolsForBudget.map((t) => t.name), state.iteration);
+            if (state.iteration === 1) {
                 const { blocks } = this.buildSystemPrompt();
-                this.logContextStat("start", iteration, slog, blocks);
+                this.logContextStat("start", state.iteration, slog, blocks);
             }
             else {
-                this.logContextStat("iteration", iteration, slog);
+                this.logContextStat("iteration", state.iteration, slog);
             }
             let textContent = "";
             let reasoningContent = "";
             const toolCalls = [];
             let sawToolCall = false;
             let emittedReasoning = false;
-            const textChunks = [];
-            this.emitPhase(iteration, "thinking", onPhase);
+            this.emitPhase(state.iteration, "thinking", onPhase);
             const llmStart = Date.now();
-            const promptBefore = apiPromptTokens;
-            const completionBefore = apiCompletionTokens;
+            const baseline = tokenTracker.beginIteration(state, contextManager.getEstimatedTokens());
             logger.logLLMRequest(config.model, history.length, input, "agent");
+            // Оценка reasoning-effort на итерацию. Сигналы описывают события
+            // ПРЕДЫДУЩЕЙ итерации (выставляются на retry-путях перед continue),
+            // поэтому политика оценивается ДО очистки сигналов — иначе raise-ветка
+            // недостижима.
+            const reasoning = reasoningResolver.resolve({
+                state,
+                policyState: this.policyState,
+                reasoningConfig: config.reasoning,
+                probePassed: this.probePassed,
+                reasoningStrategy: this.deps.reasoningStrategy,
+                reasoningState: this.reasoningState,
+            });
+            // Очистка per-итерационных сигналов после потребления политикой.
+            clearIterationSignals(state);
+            if (reasoning.level) {
+                slog.logReasoningControl({
+                    iteration: state.iteration,
+                    level: reasoning.level,
+                    strategy: reasoning.strategy,
+                    probePassed: this.probePassed,
+                    source: reasoning.source,
+                });
+                contextManager.thinkingLevel = reasoning.level;
+            }
             try {
-                for await (const chunk of llmProvider.chat(history, allToolsForBudget, this.abortController?.signal)) {
+                for await (const chunk of llmProvider.chat(history, allToolsForBudget, this.abortController?.signal, reasoning.level ? { reasoningEffort: reasoning.level, reasoningStrategy: reasoning.strategy } : undefined)) {
                     if (this.shutdownRequested)
                         break;
                     if (chunk.type === "text" && chunk.content) {
@@ -402,12 +557,13 @@ export class Agent {
                             onMeta?.("\n\n");
                         }
                         textContent += chunk.content;
-                        textChunks.push(chunk.content);
+                        const textOut = pluginManager.runOnText({ iteration: state.iteration, logger, contextManager }, chunk.content);
+                        onChunk?.(textOut);
                     }
                     if (chunk.type === "reasoning" && chunk.content) {
                         reasoningContent += chunk.content;
                         if (config.showReasoning) {
-                            const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, chunk.content);
+                            const metaOut = pluginManager.runOnMeta({ iteration: state.iteration, logger, contextManager }, chunk.content);
                             if (metaOut) {
                                 onMeta?.(pc.dim(metaOut));
                             }
@@ -430,8 +586,19 @@ export class Agent {
                         });
                     }
                     if (chunk.type === "done" && chunk.usage) {
-                        apiPromptTokens += chunk.usage.promptTokens;
-                        apiCompletionTokens += chunk.usage.completionTokens;
+                        // chat() вызывается ОДИН раз за итерацию — каждый `done` здесь
+                        // относится к тому же логическому запросу (usage-only чанк +
+                        // non-streaming fallback дают два done). ЗАМЕНЯЕМ running-суммы
+                        // вместо аккумуляции, иначе один реальный запрос посчитается дважды.
+                        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}`);
+                        onChunk?.(`\n\n> ⚠️ ${chunk.content}\n`);
                     }
                 }
             }
@@ -440,15 +607,16 @@ export class Agent {
                     logger.info("LLM call aborted (interrupt)");
                     break;
                 }
-                // Recoverable LLM errors (e.g. the completion hit the token limit
-                // mid-tool_call): feed the localized reason back into context so the
-                // model can adapt (split the write into smaller chunks) instead of
-                // the whole session dying. Bounded to avoid infinite loops.
-                if (err?.recoverableLlm && llmErrorRetries < MAX_LLM_ERROR_RETRIES) {
-                    llmErrorRetries++;
-                    logger.warn(`Recoverable LLM error, feeding back (${llmErrorRetries}/${MAX_LLM_ERROR_RETRIES}): ${err.message}`);
+                // Восстановимые ошибки LLM (например, токен-лимит на середине
+                // tool_call): отдаём локализованную причину обратно в контекст, чтобы
+                // модель адаптировалась (разбить запись на куски) вместо смерти всей
+                // сессии. Ограничено во избежание бесконечного цикла.
+                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}`);
                     slog.logError(err.message);
-                    pluginManager.runOnError({ iteration, logger, contextManager }, err);
+                    pluginManager.runOnError({ iteration: state.iteration, logger, contextManager }, err);
                     contextManager.addMessage({
                         role: "user",
                         content: `<system-summary>${err.message}</system-summary>`,
@@ -458,58 +626,29 @@ export class Agent {
                 logger.logLLMResponse(config.model, textContent.length, Date.now() - llmStart, err.message, "agent");
                 logger.error(`LLM call failed: ${err.message}`);
                 slog.logError(err.message);
-                pluginManager.runOnError({ iteration, logger, contextManager }, err);
+                pluginManager.runOnError({ iteration: state.iteration, logger, contextManager }, err);
                 return {
                     success: false,
-                    text: lastText,
+                    text: state.lastText,
                     error: t("error.llm", { message: err.message }),
-                    iterationCount: iteration,
+                    iterationCount: state.iteration,
                 };
             }
             finally {
-                this.emitPhase(iteration, "done", onPhase);
+                this.emitPhase(state.iteration, "done", onPhase);
             }
-            // Track response length so token metrics stay meaningful even when
-            // the backend omits `usage` from the response.
-            apiCompletionChars += (textContent || reasoningContent).length;
+            // Совокупная длина ответа — метрики токенов остаются валидными, даже
+            // когда бэкенд опускает `usage`.
+            tokenTracker.addCompletionChars(state, (textContent || reasoningContent).length);
             logger.logLLMResponse(config.model, (textContent || reasoningContent).length, Date.now() - llmStart, undefined, "agent");
-            // Log per-call token usage. llama.cpp streaming often omits `usage`,
-            // so fall back to local estimates (context tokens + chars/4) and
-            // mark the source — the log must distinguish real API numbers from
-            // heuristics.
-            {
-                const usagePrompt = apiPromptTokens - promptBefore;
-                const usageCompletion = apiCompletionTokens - completionBefore;
-                const source = usagePrompt > 0 || usageCompletion > 0 ? "api" : "estimate";
-                const prompt = source === "api" ? usagePrompt : contextManager.getEstimatedTokens();
-                const completion = source === "api"
-                    ? usageCompletion
-                    : Math.ceil((textContent || reasoningContent).length / 4);
-                slog.logLlmUsage(iteration, {
-                    promptTokens: prompt,
-                    completionTokens: completion,
-                    totalTokens: prompt + completion,
-                    source,
-                    durationMs: Date.now() - llmStart,
-                });
-                this.costTracker.record(prompt, completion, this.callerProvenance().provider);
-            }
+            state.totalLlmDuration += Date.now() - llmStart;
+            // Per-call лог usage + стоимость. llama.cpp в стриминге часто опускает
+            // `usage` — фолбэк на локальные оценки (контекст + chars/4) с пометкой
+            // источника: лог должен отличать реальные API-цифры от эвристики.
+            tokenTracker.logUsage(state, baseline, textContent || reasoningContent, contextManager.getEstimatedTokens(), state.iteration, Date.now() - llmStart, slog);
             if (this.shutdownRequested) {
                 break;
             }
-            // Show the model's commentary text. When a tool call accompanies the
-            // response, keep the text too (opencode-like narration), unless it is
-            // a raw JSON payload that small models sometimes emit instead of
-            // describing the call. `toolComments: false` restores the old behavior
-            // of suppressing text next to a tool call.
-            const toolComments = this.deps.config.ui?.toolComments ?? true;
-            const showText = textChunks.length > 0 && (!sawToolCall || (toolComments && !isToolCallJson(textContent)));
-            if (showText) {
-                for (const chunk of textChunks) {
-                    const textOut = pluginManager.runOnText({ iteration, logger, contextManager }, chunk);
-                    onChunk?.(textOut);
-                }
-            }
             let llmResponse = null;
             if (sawToolCall) {
                 llmResponse = { type: "tool_call", calls: toolCalls };
@@ -520,305 +659,117 @@ export class Agent {
             else if (reasoningContent) {
                 llmResponse = { type: "reasoning", content: reasoningContent };
             }
-            pluginManager.runOnAfterThink({ iteration, logger, contextManager }, llmResponse);
-            if (this.deps.exitOnComplete && sawToolCall) {
+            pluginManager.runOnAfterThink({ iteration: state.iteration, logger, contextManager }, llmResponse);
+            // Детекция повторных одинаковых тулов (структурная, не по ключевым
+            // словам). Сигнал питает reasoning policy для понижения effort на рутине.
+            if (sawToolCall) {
                 const signature = toolCalls
                     .map((tc) => `${tc.name}:${JSON.stringify(tc.arguments)}`)
                     .join("|");
-                if (signature && signature === lastToolSignature) {
-                    // A repeated identical tool call is often the model re-running
-                    // a command after a confusing result. Give it one more chance
-                    // to produce a final text answer instead of stopping with
-                    // text: "" (observed on 08-r4: bash re-run → empty result).
-                    repeatedToolCount++;
-                    if (repeatedToolCount >= MAX_REPEATED_TOOL_CALLS) {
-                        logger.debug("Exit-on-complete: repeated identical tool call, stopping");
-                        break;
-                    }
+                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`);
                     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>`,
                     });
-                }
-                lastToolSignature = signature;
-            }
-            if (sawToolCall) {
-                slog.logAssistant(textContent || "", reasoningContent, toolCalls, iteration);
-            }
-            if (sawToolCall) {
-                contextManager.addMessage({
-                    role: "assistant",
-                    content: textContent || "",
-                    tool_calls: toolCalls.map((tc) => ({
-                        id: tc.id,
-                        type: "function",
-                        function: {
-                            name: tc.name,
-                            arguments: JSON.stringify(tc.arguments),
-                        },
-                    })),
-                });
-                const summaries = [];
-                let anyToolFailed = false;
-                // Informational read-only tools whose "failure" is expected behavior
-                // (e.g. file_info "Not found" after delete_file) — excluded from
-                // per-tool failure counting and consecutive failure tracking.
-                const infoTools = new Set(["file_info"]);
-                for (const call of toolCalls) {
-                    this.setScope();
-                    const startTime = Date.now();
-                    pluginManager.runOnToolCall({
-                        toolName: call.name,
-                        args: call.arguments,
-                    });
-                    pluginManager.runOnToolStart({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments });
-                    const toolIcon = this.deps.toolExecutor.getRegistry().get(call.name)?.icon;
-                    onTool?.({ type: "start", tool: call.name, args: call.arguments, icon: toolIcon });
-                    slog.logToolCall(call, iteration);
-                    const tokensBeforeTool = contextManager.getEstimatedTokens();
-                    const result = await toolExecutor.execute(call, this.abortController?.signal);
-                    // Interrupt during the tool call: the session is already shutting
-                    // down (Esc/Ctrl+C), so stop immediately — no rendering, no session
-                    // log writes, no context update for a result nobody will see. This
-                    // fixes the "Replaced in ..." lines appearing AFTER "Session ended".
-                    if (this.shutdownRequested)
-                        break;
-                    const duration = Date.now() - startTime;
-                    if (!result.success && !infoTools.has(call.name))
-                        anyToolFailed = true;
-                    if (result.success && call.arguments.path) {
-                        const filePath = String(call.arguments.path);
-                        if (call.name === "write_file" || call.name === "edit_file") {
-                            hallucinationDetector.getConsistencyCheck().trackCreatedFile(filePath);
-                        }
-                        else if (call.name === "delete_file") {
-                            hallucinationDetector.getConsistencyCheck().trackDeletedFile(filePath);
-                        }
-                    }
-                    pluginManager.runOnToolEnd({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
-                    // Presence check, not truthiness: read_file returns display ""
-                    // on a full read to suppress output entirely (the tool header
-                    // already shows the path) — falling back on empty string would
-                    // dump the whole file content into the REPL.
-                    if (result.display !== undefined) {
-                        if (result.display.length > 0) {
-                            onMeta?.("\n" + result.display + "\n");
+                    state.repeatedToolCount++;
+                    if (this.deps.exitOnComplete) {
+                        if (state.repeatedToolCount >= MAX_REPEATED_TOOL_CALLS) {
+                            logger.debug("Exit-on-complete: repeated identical tool call, stopping");
+                            break;
                         }
                     }
-                    else {
-                        const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
-                        onMeta?.("\n" + pc.dim(metaOut) + "\n");
-                    }
-                    if (result.diff) {
-                        onMeta?.("\n" + result.diff + "\n");
-                    }
-                    const currentTokens = contextManager.getEstimatedTokens();
-                    const budget = contextManager.getBudget();
-                    const truncatedOutput = this.truncateToolOutput(result.output, budget, currentTokens, boundedToolNames.has(call.name));
-                    contextManager.addMessage({
-                        role: "tool",
-                        content: truncatedOutput,
-                        name: call.name,
-                        tool_call_id: call.id,
-                        success: result.success,
-                        arguments: call.arguments,
-                    });
-                    const tokensAfterTool = contextManager.getEstimatedTokens();
-                    onTool?.({
-                        type: "end",
-                        tool: call.name,
-                        args: call.arguments,
-                        duration,
-                        error: !result.success,
-                        ctxDelta: tokensAfterTool - tokensBeforeTool,
-                        costUsd: this.costTracker.total,
-                    });
-                    summaries.push(`[Tool: ${call.name} (${JSON.stringify(call.arguments)}) → ${truncatedOutput.slice(0, 200)}]`);
-                    if (config.session.autoSave) {
-                        slog.logToolResult(call, result, duration, iteration);
-                    }
-                    if (contextManager.needsCompaction()) {
-                        const result = contextManager.compact();
-                        if (result) {
-                            logger.debug("Context compacted after tool result");
-                            slog.logCompaction({
-                                reason: "after_tool",
-                                iteration,
-                                ...result,
-                            });
-                            hallucinationDetector.addKnownFiles(contextManager.getKnownFiles());
-                        }
+                    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`);
+                        break;
                     }
-                    // Track per-tool failure counts (NOT just consecutive) so a tool
-                    // that keeps failing while other tools succeed between attempts
-                    // is still learned from (observed: LSP spawn npx ENOENT failed
-                    // 8x in one session, never consecutively, so it never reached
-                    // memory via the 5-consecutive-failures path).
-                    if (!result.success && !infoTools.has(call.name)) {
-                        const key = call.name;
-                        const prev = toolFailureCounts.get(key) ?? { count: 0, error: "" };
-                        prev.count++;
-                        prev.error = String(result.output ?? "").slice(0, 200);
-                        toolFailureCounts.set(key, prev);
-                        if (prev.count >= MIN_REPEATED_TOOL_FAILURES && !memoryRuleRecorded.has(key)) {
-                            memoryRuleRecorded.add(key);
-                            const memStore = this.deps.memoryStore;
-                            if (memStore) {
-                                memStore.appendRule("errors", `Tool ${key} failed ${prev.count}x (${prev.error})`, `Repeated ${key} failures suggest a systemic problem (config, environment, or a broken tool), not a one-off`, "Check the error message, verify the tool's dependencies are installed/configured, and consider a different tool");
-                                logger.warn(`Recorded repeated ${key} failures to memory (${prev.count}x)`);
-                            }
-                        }
+                }
+                else {
+                    state.repeatedToolCount = 0;
+                }
+                state.lastToolSignature = signature;
+            }
+            // Детекция «перфекционизм-цикла»: многократные правки ОДНОГО файла или
+            // запуски одной команды через не-подряд итерации (edit → build → read →
+            // edit…). Аргументы каждый раз новые, поэтому подряд-детекция дубликатов
+            // выше этот паттерн не видит. Nudge уходит ПОСЛЕ tool-результатов, чтобы
+            // не ломать парность assistant(tool_calls) → tool(results).
+            const cycleNudges = [];
+            if (sawToolCall) {
+                for (const tc of toolCalls) {
+                    const target = mutationTargetKey(tc.name, tc.arguments);
+                    if (!target)
+                        continue;
+                    const count = (state.toolTargetCounts.get(target) ?? 0) + 1;
+                    state.toolTargetCounts.set(target, count);
+                    if (count >= MUTATION_CYCLE_NUDGE_THRESHOLD &&
+                        !state.cycleNudgedKeys.has(target)) {
+                        state.cycleNudgedKeys.add(target);
+                        cycleNudges.push(target);
                     }
                 }
-                if (this.shutdownRequested)
+            }
+            if (sawToolCall) {
+                const batch = await toolBatch.execute(state, toolCalls, boundedToolNames, textContent, reasoningContent, input, onTool, onMeta, slog);
+                if (batch.interrupted) {
                     break;
-                if (anyToolFailed) {
-                    consecutiveToolFailures++;
-                }
-                else {
-                    consecutiveToolFailures = 0;
                 }
-                if (consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
-                    const recoveryMsg = t("exec.consecutive_failures_recovery", {
-                        count: consecutiveToolFailures,
-                    });
-                    logger.warn(`Consecutive tool failures: ${consecutiveToolFailures}`);
-                    const taskSnippet = input.length > 200 ? input.slice(0, 200) + "..." : input;
-                    const taskReminder = t("exec.task_reminder", { task: taskSnippet });
+                if (cycleNudges.length > 0) {
+                    logger.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>${recoveryMsg}\n${taskReminder}</system-summary>`,
+                        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>`,
                     });
-                    const memStore = this.deps.memoryStore;
-                    if (memStore) {
-                        memStore.appendRule("errors", `${consecutiveToolFailures} consecutive tool failures`, "Multiple tools failing suggests environment or configuration issue", "Check dependencies, verify file paths, try write_file directly instead of shell commands");
-                    }
                 }
-                contextManager.addMessage({
-                    role: "user",
-                    content: `<system-summary>${summaries.join("\n")}</system-summary>`,
-                });
-                const ui = this.deps.config.ui;
-                if (ui?.showContextStats) {
-                    const ctxTokens = contextManager.getEstimatedTokens();
-                    const ctxBudget = contextManager.getBudget();
-                    const ctxPct = Math.min(100, Math.round((ctxTokens / ctxBudget.history) * 100));
-                    const barLen = 10;
-                    const filled = Math.round((ctxPct / 100) * barLen);
-                    const ctxBar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
-                    const pctColor = ctxPct >= 75 ? pc.yellow : pc.dim;
-                    const compCount = contextManager.getCompactionCount();
-                    const quality = contextManager.getQuality();
-                    const qualityColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
-                    onMeta?.(`\n  ${ctxBar}  ${pctColor(`${ctxPct}%`)}  ${pc.dim(`ctx: ${ctxTokens}/${ctxBudget.history}`)}  ${pc.dim(`compactions: ${compCount}`)}  ${qualityColor(`quality: ${quality}%`)}\n`);
-                }
-                else if (ui?.showCompaction) {
-                    const compCount = contextManager.getCompactionCount();
-                    if (compCount > this.lastCompactionShown) {
-                        this.lastCompactionShown = compCount;
-                        onMeta?.(pc.dim(`\n  ⟳ Context compacted (${compCount})\n`));
-                    }
-                }
-                // A tool call means the model kept working instead of just
-                // re-answering — the audit-re-answer leniency no longer applies.
-                suppressRepetitionRetry = false;
+                this.contextRenderer.render(this.deps.config.ui, contextManager, onMeta);
+                // Тулы означают, что модель продолжила работать, а не переотвечает —
+                // послабление на повтор после аудита больше не действует.
+                state.suppressRepetitionRetry = false;
                 continue;
             }
-            hallucinationDetector.getConfidenceCheck().setPreviousResponse(lastModelText);
-            // Update AFTER setPreviousResponse so the comparison uses the
-            // previous iteration's output, not this one (which would otherwise
-            // always overlap with itself).
-            if (textContent)
-                lastModelText = textContent;
-            const hallucinationResult = await hallucinationDetector.validate(textContent);
-            if (hallucinationResult.status === "block") {
-                logger.warn(`Response blocked: ${hallucinationResult.reason}`);
+            const verdict = await hallucinationGate.evaluate({
+                state,
+                textContent,
+                input,
+                exitOnComplete: this.deps.exitOnComplete ?? false,
+                hasFinalAudit: !!this.deps.finalAudit,
+                logger,
+                contextManager,
+                onMeta,
+                onChunk,
+            });
+            if (verdict.action === "block") {
                 return {
                     success: false,
-                    text: lastText,
-                    error: t("error.response_blocked", {
-                        reason: hallucinationResult.reason || "",
-                    }),
-                    iterationCount: iteration,
+                    text: state.lastText,
+                    error: t("error.response_blocked", { reason: verdict.reason }),
+                    iterationCount: state.iteration,
                 };
             }
-            if (hallucinationResult.status === "warn") {
-                logger.warn(`Hallucination warning: ${hallucinationResult.reason}`);
-                const warnLine = `${t("hall.uncertainty_prefix").trim()} ${hallucinationResult.reason ?? ""}`;
-                if (onMeta) {
-                    onMeta(`\n${pc.yellow(warnLine)}\n`);
-                }
-                else if (onChunk) {
-                    onChunk(`\n${warnLine}\n`);
-                }
+            if (verdict.action === "retry") {
+                continue;
             }
-            if (hallucinationResult.status === "retry") {
-                if (this.deps.exitOnComplete && textContent?.trim()) {
-                    logger.debug("Exit-on-complete: stopping on first response");
-                    // Save the response BEFORE breaking — lastText is still the
-                    // previous (tool-only) iteration's text, so without this the
-                    // final answer is lost (reported text: "").
-                    lastText = textContent;
-                    break;
-                }
-                if (suppressRepetitionRetry && hallucinationResult.kind === "repetition") {
-                    // The audit gate rejected the previous final answer and
-                    // re-prompted the model. Its re-answer restating the completed
-                    // task is naturally "repetitive" — that is expected, not
-                    // degeneration. Downgrade to a warning and let the response
-                    // flow through to the final audit gate again (which is itself
-                    // bounded by MAX_AUDIT_RETRIES).
-                    suppressRepetitionRetry = false;
-                    logger.warn(`Audit-triggered re-answer repetition — not counted as hallucination retry`);
-                    const warnLine = `${t("hall.uncertainty_prefix").trim()} ${hallucinationResult.reason ?? ""}`;
-                    if (onMeta) {
-                        onMeta(`\n${pc.yellow(warnLine)}\n`);
-                    }
-                    else if (onChunk) {
-                        onChunk(`\n${warnLine}\n`);
-                    }
-                    // fall through to the acceptance path below (assistant message,
-                    // lastText, final audit gate).
-                }
-                else {
-                    // NOTE: with exitOnComplete and an EMPTY text we deliberately
-                    // do NOT break — the model produced no usable answer yet (same
-                    // case as the empty-response guard below). Falling through to
-                    // the retry path keeps us from finishing with text: "".
-                    if (hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
-                        logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
-                        return {
-                            success: false,
-                            text: lastText,
-                            error: t("error.response_blocked", {
-                                reason: t("hall.max_retries_exhausted"),
-                            }),
-                            iterationCount: iteration,
-                        };
-                    }
-                    hallucinationRetries++;
-                    logger.warn(`Hallucination retry (${hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${hallucinationResult.reason}`);
-                    if (textContent) {
-                        contextManager.addMessage({
-                            role: "assistant",
-                            content: textContent,
-                        });
-                    }
-                    contextManager.addMessage({
-                        role: "user",
-                        content: `<system-summary>[Retry context: ${hallucinationResult.reason}. Original task: "${input}". You must either call a needed tool or provide a substantive response. Empty replies are not allowed.]</system-summary>`,
-                    });
-                    continue;
-                }
+            if (verdict.action === "exit") {
+                // lastText/finalAnswerAccepted уже выставлены вентилем.
+                break;
             }
+            // warn/accept → принятие ответа
             if (textContent) {
                 contextManager.addMessage({ role: "assistant", content: textContent });
                 if (config.session.autoSave) {
                     slog.saveAssistantMessage(textContent);
                 }
-                slog.logAssistant(textContent, reasoningContent, undefined, iteration);
+                slog.logAssistant(textContent, reasoningContent, undefined, state.iteration);
             }
-            lastText = textContent;
+            state.lastText = textContent;
             {
                 const decisionPatterns = [
                     ...textContent.matchAll(/(?:plan|decided|decision|решено|план|решение):\s*(.+?)(?:\n|$)/gi),
@@ -829,63 +780,51 @@ export class Agent {
                         .trackDecision(match[1].trim(), "agent_response");
                 }
             }
-            if (!sawToolCall) {
-                // Guard: the model returned an EMPTY final response (no text, no
-                // tool calls — often just reasoning content after context
-                // compaction). Nudge it to produce a real answer instead of
-                // silently finishing with text: "".
-                if (!textContent?.trim()) {
-                    if (emptyResponseRetries < MAX_EMPTY_RESPONSE_RETRIES) {
-                        emptyResponseRetries++;
-                        logger.warn(`Empty response on iteration ${iteration} (retry ${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>`,
-                        });
-                        continue;
-                    }
-                    emptyResponseExhausted = true;
-                    logger.warn(`Empty response retries exhausted after ${MAX_EMPTY_RESPONSE_RETRIES} attempts`);
-                }
-                if (this.deps.finalAudit) {
-                    const audit = await this.deps.finalAudit();
-                    if (audit && !audit.passed) {
-                        logger.warn(`Final audit incomplete: ${audit.summary}`);
-                        const steps = audit.pendingSteps.slice(0, 5).join("; ") || "—";
-                        contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${t("exec.audit_incomplete", {
-                                summary: audit.summary,
-                                steps,
-                            })}</system-summary>`,
-                        });
-                        slog.logAudit(audit.summary, iteration);
-                        auditRetries++;
-                        lastAuditSummary = audit.summary;
-                        if (auditRetries >= MAX_AUDIT_RETRIES || iteration >= config.maxToolIterations - 1) {
-                            logger.warn(`Final audit still incomplete after ${auditRetries} retries — reporting failure`);
-                            auditFailed = true;
-                            break;
-                        }
-                        // The next non-tool response is a forced re-answer of an
-                        // already-completed task — allow one repetition without
-                        // burning the hallucination budget (see retry branch).
-                        suppressRepetitionRetry = true;
-                        continue;
-                    }
+            // Guard: пустой финальный ответ (текста нет, тулов нет — часто только
+            // reasoning после компакции). Подталкиваем к реальному ответу вместо
+            // молчаливого завершения с text: "".
+            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})`);
+                    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>`,
+                    });
+                    continue;
                 }
+                state.emptyResponseExhausted = true;
+                logger.warn(`Empty response retries exhausted after ${MAX_EMPTY_RESPONSE_RETRIES} attempts`);
+            }
+            const auditVerdict = await auditGate.evaluate({
+                state,
+                iteration: state.iteration,
+                maxIterations: config.maxToolIterations,
+                logger,
+                contextManager,
+                slog,
+            });
+            if (auditVerdict === null || auditVerdict.action === "pass") {
+                state.finalAnswerAccepted = true;
+                break;
+            }
+            if (auditVerdict.action === "exhausted") {
+                // auditFailed уже выставлен вентилем.
                 break;
             }
+            // reject → continue: аудит уже добавил контекст и взвёл suppressRepetitionRetry.
+            continue;
         }
         const tokensUsed = contextManager.getEstimatedTokens();
         const budget = contextManager.getBudget();
-        const usageTokens = this.resolveUsageTokens(apiPromptTokens, apiCompletionTokens, tokensUsed, apiCompletionChars);
-        if (iteration >= config.maxToolIterations) {
+        const usageTokens = tokenTracker.resolveFinal(state);
+        const cacheStats = this.buildCacheStats(state);
+        if (state.iteration >= config.maxToolIterations && !state.finalAnswerAccepted) {
             return {
                 success: false,
-                text: lastText,
+                text: state.lastText,
                 error: t("error.max_iters", { max: config.maxToolIterations }),
-                iterationCount: iteration,
+                iterationCount: state.iteration,
                 contextUsed: tokensUsed,
                 contextLimit: budget.history,
                 promptTokens: usageTokens.prompt,
@@ -893,19 +832,20 @@ export class Agent {
                 totalTokens: usageTokens.total,
                 totalCost: this.costTracker.total,
                 costBreakdown: this.costTracker.breakdown(),
+                cache: cacheStats,
                 compactionCount: contextManager.getCompactionCount(),
                 contextQuality: contextManager.getQuality(),
             };
         }
         return {
-            success: emptyResponseExhausted || auditFailed ? false : true,
-            text: lastText,
-            error: emptyResponseExhausted
+            success: state.emptyResponseExhausted || state.auditFailed ? false : true,
+            text: state.lastText,
+            error: state.emptyResponseExhausted
                 ? t("error.empty_response")
-                : auditFailed
-                    ? t("error.audit_failed", { summary: lastAuditSummary })
+                : state.auditFailed
+                    ? t("error.audit_failed", { summary: state.lastAuditSummary })
                     : undefined,
-            iterationCount: iteration,
+            iterationCount: state.iteration,
             contextUsed: tokensUsed,
             contextLimit: budget.history,
             promptTokens: usageTokens.prompt,
@@ -913,8 +853,34 @@ export class Agent {
             totalTokens: usageTokens.total,
             totalCost: this.costTracker.total,
             costBreakdown: this.costTracker.breakdown(),
+            cache: cacheStats,
             compactionCount: contextManager.getCompactionCount(),
             contextQuality: contextManager.getQuality(),
+            llmDurationMs: state.totalLlmDuration,
+        };
+    }
+    /**
+     * Собирает статистику кеша промпта за прогон: провайдерские токены (если
+     * были) плюс client-side стабильность префикса. Возвращает undefined, когда
+     * нет ни данных провайдера, ни префикс-монитора — чтобы не засорять вывод.
+     */
+    buildCacheStats(state) {
+        const hasTokens = state.cacheCachedTotal > 0 || state.cacheUncachedTotal > 0 || state.cacheWriteTotal > 0;
+        // Приоритет — последнему реальному разрыву, иначе состояние текущей
+        // итерации (нормальная дописка / первая итерация).
+        const prefix = state.lastPrefixBreak ?? state.prefixDelta;
+        if (!hasTokens && prefix?.stableRatio === undefined)
+            return undefined;
+        const denom = state.cacheCachedTotal + state.cacheUncachedTotal;
+        return {
+            cachedTokens: state.cacheCachedTotal,
+            uncachedTokens: state.cacheUncachedTotal,
+            cacheWriteTokens: state.cacheWriteTotal,
+            hitRate: denom > 0 ? state.cacheCachedTotal / denom : 0,
+            saved: this.costTracker.saved,
+            prefixStable: prefix?.stableRatio,
+            prefixCause: prefix?.cause,
+            source: state.cacheSource,
         };
     }
     clearContext() {
@@ -922,43 +888,35 @@ export class Agent {
         this.systemPromptAdded = false;
     }
     async reconfigure(config) {
-        const { OpenAICompatProvider } = await import("../llm/openai-compat");
         const { TokenCounter } = await import("../llm/token-counter");
-        const newProvider = new OpenAICompatProvider({
-            model: config.model,
-            baseUrl: config.provider.baseUrl,
-            apiKey: config.provider.apiKey,
-            contextWindow: config.contextWindow,
-            retry: config.retry,
-            rateLimits: config.security?.rateLimits,
-            maxCompletionTokens: config.provider.entries?.find((e) => e.label === config.provider.active)?.maxCompletionTokens ??
-                config.provider.maxCompletionTokens,
+        const { provider: newProvider } = buildActiveProvider(config, this.deps.logger, {
+            getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
         });
         this.deps.llmProvider = newProvider;
         this.deps.toolExecutor.updateProvider(newProvider);
         const newTokenCounter = new TokenCounter(config.model);
         this.deps.contextManager.resize(config.contextWindow, config.contextBudget, newTokenCounter);
         this.deps.config = config;
+        if (this.deps.configRef)
+            this.deps.configRef.current = config;
         this.costTracker.setModel(config.model);
     }
     setProvider(name, model) {
-        const manager = new ProviderManager(this.deps.config.provider, {
-            contextWindow: this.deps.config.contextWindow,
-            retry: this.deps.config.retry,
-            rateLimits: this.deps.config.security?.rateLimits,
+        const { manager, provider } = buildActiveProvider(this.deps.config, this.deps.logger, {
+            getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
         });
         manager.switch(name, model);
         const providerCfg = manager.toConfig();
         this.deps.config.provider = providerCfg;
-        this.deps.llmProvider = manager.active;
-        this.deps.toolExecutor.updateProvider(manager.active);
-        this.deps.toolExecutor.ctx.llmProvider = manager.active;
+        this.deps.llmProvider = provider;
+        this.deps.toolExecutor.updateProvider(provider);
     }
     listProviders() {
         const manager = new ProviderManager(this.deps.config.provider, {
             contextWindow: this.deps.config.contextWindow,
             retry: this.deps.config.retry,
             rateLimits: this.deps.config.security?.rateLimits,
+            getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
         });
         const activeName = this.deps.config.provider.active;
         return manager.list().map((e) => ({
@@ -973,6 +931,8 @@ export class Agent {
                 contextWindow: this.deps.config.contextWindow,
                 retry: this.deps.config.retry,
                 rateLimits: this.deps.config.security?.rateLimits,
+                getSessionId: () => this.deps.sessionManager?.getActiveMeta()?.id,
+                logger: this.deps.logger,
             });
             manager.setModel(this.deps.config.model);
             manager.switch(name);
@@ -1005,7 +965,7 @@ export class Agent {
         contextManager.onCompact = null;
         const killed = processRegistry.killAll();
         if (killed > 0) {
-            logger.info(`Killed ${killed} background process(es) on shutdown`);
+            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).