micro-models-agent 2.16.1 → 2.17.2

package/dist/core/agent/critic-gate.js

@@ -1,132 +0,0 @@
-/** Вентиль контр-агента (критика): проверка мутаций перед финалом. */
-import { t } from "../../i18n/index";
-const MUTATIONS_BEFORE_CHECK = 3;
-/** Хвост вывода тула в evidence-событии (ограничен — у критика свой бюджет). */
-const MAX_EVENT_OUTPUT_CHARS = 600;
-function issueSignature(issue) {
-    return `${issue.severity}:${issue.claim}`.toLowerCase().replace(/\s+/g, " ").slice(0, 120);
-}
-function renderIssues(issues) {
-    return issues
-        .slice(0, 5)
-        .map((i) => `- [${i.severity}] ${i.problem || i.claim}${i.suggestion ? ` → ${i.suggestion}` : ""}`)
-        .join("\n");
-}
-/**
- * Вентиль критика: триггерит проверку по мутациям, инжектит вердикт в контекст.
- * Fail-open: сломанный/перебюджетный критик никогда не блокирует агента.
- */
-export class CriticGate {
-    opts;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /**
-     * Оценивает ход через критика.
-     * @param deps состояние цикла и события тулов; @returns "pass" или "retry".
-     */
-    async evaluate(deps) {
-        if (!this.shouldRun(deps))
-            return "pass";
-        this.logCheck(deps);
-        deps.state.criticCalls++;
-        deps.state.mutationsSinceCritic = 0;
-        const verdict = await this.verifySafely(deps);
-        if (!verdict || verdict.status === "ok")
-            return "pass";
-        const fresh = this.takeFreshIssues(deps.state, verdict.issues);
-        if (fresh.length === 0)
-            return "pass";
-        this.logVerdict(deps, verdict, fresh.length);
-        const canRepair = verdict.status === "critical" &&
-            deps.beforeFinish &&
-            deps.state.criticRepairCycles < this.opts.maxRepairCycles;
-        this.inject(deps, verdict, fresh, canRepair);
-        return "retry";
-    }
-    /** Fail-open: битый/перебюджетный критик не блокирует агента. */
-    async verifySafely(deps) {
-        try {
-            return await this.opts.verify(this.opts.buildPack(deps), this.opts.signal);
-        }
-        catch {
-            return null;
-        }
-    }
-    shouldRun(deps) {
-        if (!this.opts.enabled)
-            return false;
-        if (deps.state.criticCalls >= this.opts.maxCalls)
-            return false;
-        if (!deps.beforeFinish && deps.state.mutationsSinceCritic < MUTATIONS_BEFORE_CHECK) {
-            return false;
-        }
-        return deps.toolEvents.length !== 0;
-    }
-    takeFreshIssues(state, issues) {
-        const fresh = [];
-        for (const issue of issues) {
-            const sig = issueSignature(issue);
-            if (state.seenCriticIssues.has(sig))
-                continue;
-            state.seenCriticIssues.add(sig);
-            fresh.push(issue);
-        }
-        return fresh;
-    }
-    logCheck(deps) {
-        deps.slog.logCritic("critic_check", {
-            iteration: deps.iteration,
-            beforeFinish: deps.beforeFinish,
-            mutations: deps.state.mutationsSinceCritic,
-            tools: deps.toolEvents.map((e) => e.tool).slice(0, 8),
-        });
-    }
-    logVerdict(deps, verdict, count) {
-        deps.slog.logCritic("critic_verdict", {
-            status: verdict.status,
-            summary: verdict.summary,
-            issueCount: count,
-        });
-        deps.logger.diagnostic("info", `Critic ${verdict.status}: ${verdict.summary} (${count} issue(s))`);
-    }
-    inject(deps, verdict, fresh, canRepair) {
-        if (!canRepair) {
-            deps.contextManager.addMessage({
-                role: "user",
-                content: `<system-summary>${t("critic.advice", { issues: renderIssues(fresh) })}</system-summary>`,
-            });
-            return;
-        }
-        deps.state.criticRepairCycles++;
-        deps.slog.logCritic("critic_escalation", {
-            summary: verdict.summary,
-            cycle: deps.state.criticRepairCycles,
-        });
-        deps.contextManager.addMessage({
-            role: "user",
-            content: `<system-summary>${t("critic.repair", {
-                summary: verdict.summary,
-                issues: renderIssues(fresh),
-            })}</system-summary>`,
-        });
-    }
-}
-/**
- * Собирает события тулов хода из активной истории (для evidence-пакета критика).
- * @param contextManager менеджер с getActiveHistory; @returns события role:"tool".
- */
-export function gatherTurnToolEvents(contextManager) {
-    const events = [];
-    for (const m of contextManager.getActiveHistory()) {
-        if (m.role !== "tool" || !m.name)
-            continue;
-        // Сообщения role:"tool" уже несут аргументы (tool-batch) и обрезанный
-        // вывод — пробрасываем оба, чтобы критик видел ЧТО тронуто и ЧТО вернулось.
-        // Без аргументов пакет слеп (changedFiles/commands пусты) и критик
-        // вынужден вернуть "ok" за отсутствием улик.
-        const output = typeof m.content === "string" ? m.content.slice(-MAX_EVENT_OUTPUT_CHARS) : undefined;
-        events.push({ tool: m.name, args: m.arguments, ok: m.success, output });
-    }
-    return events;
-}

package/dist/core/agent/hallucination-gate.js

@@ -1,197 +0,0 @@
-/** Вентиль халлюцинаций: проверка финального ответа перед принятием. */
-import { pc } from "../../ui/colors";
-import { t } from "../../i18n/index";
-import { checkSuccessClaim } from "../../modules/hallucination/success-claim";
-import { checkArtifactClaims, checkUnverifiedOutput, } from "../../modules/hallucination/artifact-claim";
-import { MAX_CLAIM_CHECK_RETRIES, MAX_HALLUCINATION_RETRIES } from "./constants";
-/**
- * Вентиль проверки халлюцинаций финального текстового ответа.
- *
- * Объединяет весь граф вердиктов validate() (block/warn/retry) и их
- * под-пути: exit-on-complete fast-exit, подавление повтора после отказа
- * аудита (suppressRepetitionRetry), исчерпание повторов, добавление
- * retry-контекста в сообщения.
- *
- * Возвращает структурированный вердикт; решение о `break`/`continue`/`return`
- * принимает цикл. Вся мутация состояния живёт здесь — цикл остаётся тонким.
- */
-/**
- * Свежие выводы тулов для проверки заявлений: последние 10 сообщений
- * role:"tool" (текст урезан; чекер режет повторно). Тот же источник
- * getActiveHistory, что у вентиля критика.
- */
-function lastToolEvidence(deps) {
-    let history;
-    try {
-        history = deps.contextManager.getActiveHistory() ?? [];
-    }
-    catch {
-        return [];
-    }
-    return history
-        .filter((m) => m.role === "tool")
-        .slice(-10)
-        .map((m) => ({
-        name: m.name,
-        ok: m.success,
-        text: typeof m.content === "string" ? m.content : JSON.stringify(m.content) ?? "",
-    }))
-        .filter((m) => m.text.trim().length > 0);
-}
-export class HallucinationGate {
-    detector;
-    constructor(detector) {
-        this.detector = detector;
-    }
-    /**
-     * Проверяет финальный текст ответа (детектор + заявления об успехе).
-     * @param deps состояние, текст, контекст; @returns структурированный вердикт.
-     */
-    async evaluate(deps) {
-        const { state, textContent, logger } = deps;
-        // Обновляем базу сравнения ДО validate: confidence-чек смотрит на
-        // ПРЕДЫДУЩУЮ итерацию, иначе текст пересекался бы сам с собой.
-        this.detector.getConfidenceCheck().setPreviousResponse(state.lastModelText);
-        if (textContent)
-            state.lastModelText = textContent;
-        const result = await this.detector.validate(textContent);
-        if (result.status === "block") {
-            logger.diagnostic("warn", `Response blocked: ${result.reason}`);
-            return { action: "block", reason: result.reason || "" };
-        }
-        if (result.status === "warn") {
-            logger.diagnostic("warn", `Hallucination warning: ${result.reason}`);
-            this.displayWarnLine(result.reason, deps);
-            return { action: "warn" };
-        }
-        if (result.status === "retry") {
-            return this.applyRetry(deps, textContent, result);
-        }
-        // Проверка заявлений (ses_muih0ah5): сильное заявление о готовности
-        // («done», «published», «готово»), когда свежие результаты тулов — с ошибками.
-        // Одна ограниченная перепроверка — затем fail-open (принять как есть), не блок.
-        const claimRetry = this.checkSuccessClaim(deps, textContent);
-        if (claimRetry)
-            return claimRetry;
-        return { action: "accept" };
-    }
-    /**
-     * Общий инжект повтора: фиксирует отклонённый ответ, дописывает причину
-     * как `<system-summary>` и просит цикл о следующем ходе.
-     */
-    applyRetry(deps, textContent, result) {
-        const { state, logger } = deps;
-        state.iterHallucinationRetry = true;
-        // Exit-on-complete fast-exit НЕ должен обходить финальный аудит: при
-        // активном плане модель может ответить "done" с невыполненными шагами
-        // (регрессия сертификации: модель ответила, не запустив свой скрипт).
-        // Короткое замыкание — только когда аудитить нечего.
-        if (deps.exitOnComplete && textContent?.trim() && !deps.hasFinalAudit) {
-            logger.debug("Exit-on-complete: stopping on first response");
-            // Сохраняем ДО break — lastText всё ещё текст предыдущей (туловой)
-            // итерации, и без этого итоговый ответ теряется (reported text: "").
-            state.lastText = textContent;
-            state.finalAnswerAccepted = true;
-            return { action: "exit" };
-        }
-        if (state.suppressRepetitionRetry && result.kind === "repetition") {
-            // Аудит отклонил предыдущий ответ и переспросил; его переформулировка
-            // выполненной задачи естественно "повторяющаяся" — это ожидаемо, а не
-            // деградация. Снижаем до предупреждения и пропускаем в acceptance path
-            // (сам аудит ограничен MAX_AUDIT_RETRIES).
-            state.suppressRepetitionRetry = false;
-            logger.diagnostic("warn", `Audit-triggered re-answer repetition — not counted as hallucination retry`);
-            this.displayWarnLine(result.reason, deps);
-            return { action: "accept" };
-        }
-        if (state.hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
-            logger.diagnostic("warn", `Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
-            return { action: "block", reason: t("hall.max_retries_exhausted") };
-        }
-        state.hallucinationRetries++;
-        logger.diagnostic("warn", `Hallucination retry (${state.hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${result.reason}`);
-        if (textContent) {
-            deps.contextManager.addMessage({ role: "assistant", content: textContent });
-        }
-        deps.contextManager.addMessage({
-            role: "user",
-            content: `<system-summary>[Retry context: ${result.reason}. Original task: "${deps.input}". You must either call a needed tool or provide a substantive response. Empty replies are not allowed.]</system-summary>`,
-        });
-        return { action: "retry" };
-    }
-    /**
-     * Детерминированные проверки заявлений против улик (без LLM): исходная
-     * проверка success-claim плюс заземление артефактов (файл отсутствует/
-     * не парсится) и провенанс вывода (вывод подан как исполненный без
-     * исполняющего тула). У каждого класса свой ограниченный бюджет перепроверок
-     * (fail-open): съеденный бюджет одной проверки не должен экранировать другую
-     * ложь в том же ответе (наблюдалось: retry success-claim съел единый бюджет,
-     * и «output written to fizzbuzz_output.txt» прошёл при отсутствующем файле).
-     */
-    checkSuccessClaim(deps, textContent) {
-        const { state } = deps;
-        const text = textContent ?? "";
-        const evidence = lastToolEvidence(deps);
-        if (state.claimCheckRetries < MAX_CLAIM_CHECK_RETRIES) {
-            const contradiction = checkSuccessClaim(text, evidence);
-            if (contradiction) {
-                state.claimCheckRetries++;
-                return this.retryClaim(deps, textContent, t("hall.claim_contradiction", {
-                    tool: contradiction.tool,
-                    snippet: contradiction.snippet,
-                }), `Success-claim contradiction: ${contradiction.tool}: ${contradiction.snippet}`);
-            }
-        }
-        if (state.artifactClaimRetries < MAX_CLAIM_CHECK_RETRIES &&
-            deps.artifacts &&
-            deps.artifacts.length > 0) {
-            const artifact = checkArtifactClaims(text, deps.artifacts);
-            if (artifact) {
-                state.artifactClaimRetries++;
-                return this.retryClaim(deps, textContent, t("hall.claim_artifact", { path: artifact.path, detail: artifact.snippet }), `Artifact-claim contradiction: ${artifact.snippet}`);
-            }
-        }
-        if (state.outputClaimRetries < MAX_CLAIM_CHECK_RETRIES) {
-            const unverified = checkUnverifiedOutput(text, evidence);
-            if (unverified) {
-                state.outputClaimRetries++;
-                return this.retryClaim(deps, textContent, t("hall.claim_output_unverified", { detail: unverified.snippet }), `Unverified output: ${unverified.snippet}`);
-            }
-        }
-        return null;
-    }
-    /**
-     * Общий инжект claim-повтора: фиксирует отклонённый ответ, дописывает
-     * причину как `<system-summary>` и просит цикл о следующем ходе.
-     */
-    retryClaim(deps, textContent, reason, logLine) {
-        const { state, logger } = deps;
-        state.iterHallucinationRetry = true;
-        // Переответ пересказывает выполненную задачу и естественно повторяется —
-        // бюджет халлюцинаций на его форму не жжём (та же логика, что даунгрейд
-        // в applyRetry после отклонения аудита).
-        state.suppressRepetitionRetry = true;
-        logger.diagnostic("warn", logLine);
-        if (textContent) {
-            deps.contextManager.addMessage({ role: "assistant", content: textContent });
-        }
-        deps.contextManager.addMessage({
-            role: "user",
-            content: `<system-summary>${reason} Original task: "${deps.input}".</system-summary>`,
-        });
-        return { action: "retry" };
-    }
-    displayWarnLine(reason, deps) {
-        // Диагностика: в чате только пользовательские уведомления; модель всё равно
-        // получает retry-контекст, вердикт остаётся в логах сессии/приложения.
-        if (!deps.verbose)
-            return;
-        const warnLine = `${t("hall.uncertainty_prefix").trim()} ${reason ?? ""}`;
-        if (deps.onMeta) {
-            deps.onMeta(`\n${pc.yellow(warnLine)}\n`);
-        }
-        else if (deps.onChunk) {
-            deps.onChunk(`\n${warnLine}\n`);
-        }
-    }
-}

package/dist/core/agent/loop-state.js

@@ -1,68 +0,0 @@
-/** Состояние одного запуска агентного цикла: счётчики, бюджеты, сигналы. */
-import { FORCED_COMPACTION_COOLDOWN } from "./constants";
-import { createArtifactChurnState } from "./artifact-progress";
-/** Фабрика начального состояния цикла. */
-export function createLoopState() {
-    return {
-        iteration: 0,
-        lastText: "",
-        lastModelText: "",
-        lastForcedCompactionIteration: -FORCED_COMPACTION_COOLDOWN,
-        hallucinationRetries: 0,
-        claimCheckRetries: 0,
-        artifactClaimRetries: 0,
-        outputClaimRetries: 0,
-        lastToolSignature: "",
-        consecutiveToolFailures: 0,
-        consecutiveFailedBatches: 0,
-        honestStopNudged: false,
-        consecutiveToolSuccesses: 0,
-        repeatedToolCount: 0,
-        toolFailureCounts: new Map(),
-        memoryRuleRecorded: new Set(),
-        toolTargetCounts: new Map(),
-        cycleNudgedKeys: new Set(),
-        artifactChurn: createArtifactChurnState(),
-        sawSecurityBlock: false,
-        scriptWorkaroundNudged: false,
-        apiPromptTokens: 0,
-        apiCompletionTokens: 0,
-        apiCompletionChars: 0,
-        estimatedPromptTokensTotal: 0,
-        totalLlmDuration: 0,
-        cacheCachedTotal: 0,
-        cacheUncachedTotal: 0,
-        cacheWriteTotal: 0,
-        cacheSource: "none",
-        auditRetries: 0,
-        lastAuditSummary: "",
-        criticCalls: 0,
-        criticRepairCycles: 0,
-        mutationsSinceCritic: 0,
-        seenCriticIssues: new Set(),
-        emptyResponseRetries: 0,
-        emptyResponseExhausted: false,
-        retryLoopStopped: false,
-        auditFailed: false,
-        finalAnswerAccepted: false,
-        suppressRepetitionRetry: false,
-        llmErrorRetries: 0,
-        iterHallucinationRetry: false,
-        iterAuditRejection: false,
-        iterRecoverableLlmError: false,
-        iterPlanCreated: false,
-        iterRepetitive: false,
-    };
-}
-/**
- * Сброс per-итерационных сигналов reasoning policy. Вызывается в цикле
- * ПОСЛЕ оценки политики (политика читает сигналы предыдущей итерации),
- * перед тем как новые сигналы будут выставлены на текущем ходу.
- */
-export function clearIterationSignals(state) {
-    state.iterHallucinationRetry = false;
-    state.iterAuditRejection = false;
-    state.iterRecoverableLlmError = false;
-    state.iterPlanCreated = false;
-    state.iterRepetitive = false;
-}

package/dist/core/agent/prefix-monitor.js

@@ -1,101 +0,0 @@
-/** Монитор стабильности префикса промпта (клиентская оценка кеша). */
-/**
- * Клиентский монитор стабильности префикса промпта.
- *
- * Провайдеры кешируют только совпавший префикс промпта. Даже когда провайдер
- * не сообщает cache-метрики (Ollama, экзотические прокси), агент может сам
- * посчитать, насколько текущий промпт продолжает предыдущий, и — что важнее —
- * ЧТО именно сломало префикс. Это не заменяет провайдерский `cached_tokens`,
- * но работает всегда и не даёт спутать отсутствие данных с промахом кеша.
- */
-/** Разделитель сегментов при склейке (провайдер склеивает поля сам). */
-const SEP = "\n";
-/**
- * Маркеры «волатильного» содержимого. Если расхождение префикса попадает на
- * дату/время/UUID/временный путь — это почти наверняка клиентская ошибка
- * стабильности промпта, а не действие модели.
- */
-const VOLATILE_RE = /(\d{4}-\d{2}-\d{2}|\d{2}:\d{2}:\d{2}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}|[A-Za-z]:\\|\\AppData\\|\\Temp\\|\/tmp\/)/;
-/** Детерминированная сериализация определений тулов для сравнения префикса. */
-export function serializeTools(tools) {
-    return tools
-        .map((t) => `${t.name}\u0001${t.description}\u0001${JSON.stringify(t.parameters)}`)
-        .join("\u0002");
-}
-/** Детерминированная сериализация истории сообщений для сравнения префикса. */
-export function serializeMessages(messages) {
-    return messages
-        .map((m) => `${m.role}\u0001${typeof m.content === "string" ? m.content : JSON.stringify(m.content)}`)
-        .join("\u0002");
-}
-/**
- * Собирает снимок промпта из истории сообщений и определений тулов.
- * Системные сообщения выделяются в отдельный сегмент — они стабильны и
- * ломаются по другим причинам, чем история.
- */
-export function buildPromptSnapshot(messages, tools) {
-    const system = [];
-    const rest = [];
-    for (const m of messages) {
-        if (m.role === "system")
-            system.push(m);
-        else
-            rest.push(m);
-    }
-    return {
-        system: serializeMessages(system),
-        tools: serializeTools(tools),
-        history: serializeMessages(rest),
-    };
-}
-/** Склейка сегментов в единую строку с запоминанием границ. */
-function frame(s) {
-    const full = s.system + SEP + s.tools + SEP + s.history;
-    const toolsStart = s.system.length + SEP.length;
-    const historyStart = toolsStart + s.tools.length + SEP.length;
-    return { full, toolsStart, historyStart };
-}
-/**
- * Считает общий префикс текущего и предыдущего промпта и классифицирует
- * причину расхождения. `countTokens` передаётся вызывающим, чтобы функция
- * оставалась чистой и не тянула токенизатор в горячий путь.
- */
-export function diffPrompt(prev, curr, countTokens) {
-    const c = frame(curr);
-    const currTokens = countTokens(c.full);
-    if (!prev) {
-        return {
-            prevTokens: 0,
-            currTokens,
-            commonPrefixTokens: 0,
-            stableRatio: 0,
-            cause: "unknown",
-        };
-    }
-    const p = frame(prev);
-    const prevTokens = countTokens(p.full);
-    // Общий префикс — посимвольно (нижняя граница токенного префикса).
-    const maxCp = Math.min(p.full.length, c.full.length);
-    let cp = 0;
-    while (cp < maxCp && p.full[cp] === c.full[cp])
-        cp++;
-    const commonPrefixTokens = countTokens(c.full.slice(0, cp));
-    const stableRatio = currTokens === 0 ? 0 : Math.min(1, commonPrefixTokens / currTokens);
-    // Префикс не сломан: идентично, дописано в хвост или усечено.
-    if (cp === maxCp) {
-        return { prevTokens, currTokens, commonPrefixTokens, stableRatio, cause: "none" };
-    }
-    let cause;
-    if (cp >= c.historyStart)
-        cause = "history";
-    else if (cp >= c.toolsStart)
-        cause = "tools";
-    else
-        cause = "system";
-    // Волатильное содержимое у точки расхождения перекрывает сегментную причину.
-    const window = (c.full.slice(Math.max(0, cp - 40), cp + 160) +
-        p.full.slice(Math.max(0, cp - 40), cp + 160));
-    if (VOLATILE_RE.test(window))
-        cause = "volatile";
-    return { prevTokens, currTokens, commonPrefixTokens, stableRatio, cause };
-}

package/dist/core/agent/reasoning-resolver.js

@@ -1,65 +0,0 @@
-/** Резолвер уровня reasoning на итерацию: override → политика → фикс. */
-import { evaluateReasoningPolicy } from "../../modules/reasoning/policy";
-/**
- * Резолвер уровня reasoning на итерацию.
- *
- * Приоритет (сохранён из agent.ts):
- * 1. Активный override от set_thinking (в окне overrideCooldown) — побеждает
- *    и auto-режим, и фиксированный.
- * 2. auto-режим + пройденный probe — политика (повышение на халлюцинации/
- *    отказе аудита/ошибке LLM, понижение на рутине и повторах, затухание).
- * 3. Фиксированный режим.
- *
- * ВАЖНО: сигналы политики (iter*) описывают события ПРЕДЫДУЩЕЙ итерации —
- * они выставляются на retry-путях перед `continue`, поэтому политика должна
- * оцениваться ДО их очистки (это делает вызывающий код через
- * clearIterationSignals сразу после resolve).
- */
-export class ReasoningEffortResolver {
-    /**
-     * Вычисляет уровень reasoning на итерацию (override → политика → фикс).
-     * @param deps состояние цикла, политика, конфиг, probe, стратегия.
-     * @returns уровень, стратегия и источник решения.
-     */
-    resolve(deps) {
-        const { state, reasoningConfig, reasoningState } = deps;
-        let level;
-        const strategy = deps.reasoningStrategy;
-        let source = "policy";
-        const overrideCooldown = reasoningConfig?.overrideCooldown ?? 0;
-        const overrideAge = state.iteration - reasoningState.overrideIteration;
-        const overrideActive = overrideCooldown > 0 &&
-            reasoningState.overrideIteration >= 0 &&
-            overrideAge > 0 &&
-            overrideAge <= overrideCooldown;
-        if (reasoningState.manual) {
-            level = reasoningState.level;
-            source = "agent_override";
-        }
-        else if (overrideActive) {
-            level = reasoningState.level;
-            source = "agent_override";
-        }
-        else if (reasoningConfig && reasoningConfig.mode === "auto" && deps.probePassed) {
-            const policyResult = evaluateReasoningPolicy({
-                hallucinationRetry: state.iterHallucinationRetry,
-                auditRejection: state.iterAuditRejection,
-                recoverableLlmError: state.iterRecoverableLlmError,
-                planCreated: state.iterPlanCreated,
-                consecutiveSuccesses: state.consecutiveToolSuccesses,
-                isRepetitive: state.iterRepetitive,
-                // Baseline — настроенный минимум (`min`, по умолчанию "low"),
-                // чтобы конфиг без явного baseline не жёг "medium" на пустяках.
-                // Политика всё равно повышает уровень по сигналам.
-                baseline: reasoningConfig.baseline ?? reasoningConfig.min,
-            }, deps.policyState);
-            level = policyResult.level;
-            source = "policy";
-        }
-        else if (reasoningConfig && reasoningConfig.mode !== "auto") {
-            level = reasoningConfig.mode;
-            source = "fixed";
-        }
-        return { level, strategy, source };
-    }
-}

package/dist/core/agent/token-tracker.js

@@ -1,99 +0,0 @@
-import { estimateTokens } from "../../llm/token-counter";
-/**
- * Учёт токенов и стоимости за один запуск цикла.
- *
- * Отвечает за три вещи, которые в agent.ts были размазаны по циклу:
- * 1) замену (НЕ аккумуляцию) running-сумм prompt/completion-токенов из
- *    done-чанка стрима — `chat()` вызывается один раз за итерацию, поэтому
- *    суммировать нельзя (иначе один реальный запрос посчитается дважды);
- * 2) per-call лог usage + запись стоимости в CostTracker, с честным
- *    разделением источника ("api" против локальной оценки, т.к. llama.cpp
- *    часто опускает `usage` в стриминге);
- * 3) финальные метрики результата: API-токены, если бэкенд их отдал,
- *    иначе fallback-оценка (~4 символа на токен).
- */
-export class TokenTracker {
-    costTracker;
-    getProvenance;
-    constructor(costTracker, getProvenance) {
-        this.costTracker = costTracker;
-        this.getProvenance = getProvenance;
-    }
-    /**
-     * Начало итерации: фиксирует baseline API-токенов и аккумулирует оценку
-     * prompt-токенов. Возвращает baseline для последующих вызовов.
-     */
-    beginIteration(state, estimatedPromptTokens) {
-        state.estimatedPromptTokensTotal += estimatedPromptTokens;
-        // Кеш-данные относятся к одной итерации; сбрасываем, чтобы отсутствие
-        // usage в следующем ходе не приписало старые цифры.
-        state.cacheUsage = undefined;
-        return {
-            promptBefore: state.apiPromptTokens,
-            completionBefore: state.apiCompletionTokens,
-        };
-    }
-    /**
-     * done-чанк стрима: ЗАМЕНЯЕТ running-суммы (promptBefore + usage), не
-     * аккумулирует — один логический запрос = один `done`.
-     */
-    recordApiUsage(state, baseline, usage) {
-        state.apiPromptTokens = baseline.promptBefore + usage.promptTokens;
-        state.apiCompletionTokens = baseline.completionBefore + usage.completionTokens;
-        state.cacheUsage = usage.cache;
-    }
-    /** Аккумулирует символы ответа — fallback-оценка completion-токенов. */
-    addCompletionChars(state, chars) {
-        state.apiCompletionChars += chars;
-    }
-    /**
-     * Per-call лог usage + запись стоимости. Источник "api", когда бэкенд
-     * отдал цифры; иначе локальная оценка (контекст для prompt, chars/4 для
-     * completion) — лог должен отличать реальные числа от эвристики.
-     */
-    logUsage(state, baseline, textContent, contextTokens, iteration, durationMs, slog) {
-        const usagePrompt = state.apiPromptTokens - baseline.promptBefore;
-        const usageCompletion = state.apiCompletionTokens - baseline.completionBefore;
-        const source = usagePrompt > 0 || usageCompletion > 0 ? "api" : "estimate";
-        const prompt = source === "api" ? usagePrompt : contextTokens;
-        const completion = source === "api" ? usageCompletion : estimateTokens(textContent);
-        // Накопление кеш-токенов за прогон (для AgentResult.cache).
-        if (state.cacheUsage) {
-            state.cacheCachedTotal += state.cacheUsage.cachedTokens;
-            state.cacheUncachedTotal += state.cacheUsage.uncachedTokens;
-            state.cacheWriteTotal += state.cacheUsage.cacheWriteTokens;
-            state.cacheSource = state.cacheUsage.source;
-        }
-        const prov = this.getProvenance();
-        slog.logLlmUsage(iteration, {
-            provider: prov.provider,
-            model: prov.model,
-            promptTokens: prompt,
-            completionTokens: completion,
-            totalTokens: prompt + completion,
-            source,
-            durationMs,
-            prefix: state.prefixDelta,
-            cache: state.cacheUsage,
-        });
-        // Кеш учитываем только когда цифры пришли от API: оценка chars/4 о кеше
-        // ничего не знает и не должна менять тарификацию.
-        this.costTracker.record(prompt, completion, prov.provider, source === "api" ? state.cacheUsage : undefined);
-    }
-    /**
-     * Финальные метрики результата. API-токены в приоритете; иначе — сумма
-     * оценок prompt по итерациям и символы completion (~4 символа/токен).
-     */
-    resolveFinal(state) {
-        if (state.apiPromptTokens > 0 || state.apiCompletionTokens > 0) {
-            return {
-                prompt: state.apiPromptTokens,
-                completion: state.apiCompletionTokens,
-                total: state.apiPromptTokens + state.apiCompletionTokens,
-            };
-        }
-        const prompt = Math.max(1, state.estimatedPromptTokensTotal);
-        const completion = Math.max(0, Math.ceil(state.apiCompletionChars / 4));
-        return { prompt, completion, total: prompt + completion };
-    }
-}