micro-models-agent 2.11.0 → 2.12.0

package/dist/modules/context/manager.js

@@ -17,12 +17,12 @@ function summarizeArgs(args) {
     }
 }
 function looksLikeErrorPaste(text) {
-    // Error markers.
+    // Маркеры ошибок.
     if (/(?:^|\s)ERROR|Error:|error TS\d+|Transform failed|\[plugin:|SyntaxError|Cannot find|Uncaught|exception/i.test(text)) {
         return true;
     }
-    // Structural signals of pasted compiler/runtime output: source frames
-    // ("270|  }_s(...)"), path:line:col references, and stack-trace lines.
+    // Структурные сигналы вставленного вывода компилятора/рантайма: фреймы
+    // исходников ("270|  }_s(...)"), ссылки path:line:col и строки стектрейсов.
     if (/(?:^|\n)\s*\d+\s*\|/.test(text))
         return true;
     if (/[\w./\\-]+\.[a-z]{1,6}:\d+:\d+/.test(text))
@@ -31,14 +31,15 @@ function looksLikeErrorPaste(text) {
         return true;
     return false;
 }
+/** Извлекает повторы "пробовали и не вышло" (≥2 фейлов одного тула+args). */
 export function extractTriedAndFailed(messages) {
     const failures = new Map();
     for (const msg of messages) {
         if (msg.role === "tool" && msg.name && msg.success === false) {
-            // Plugin-blocked calls are guard decisions, not failed attempts: a
-            // transient guard (or a guard bug) must never be remembered as
-            // "tried & failed — do NOT repeat" (observed: a false plan-alignment
-            // block made the model refuse to rewrite its own step's file).
+            // Заблокированные плагином вызовы — решения гардов, не попытки: транзиентный
+            // гард (или его баг) нельзя запоминать как "пробовали и не вышло — НЕ повторять"
+            // (было: ложный plan-alignment блок заставил модель отказываться переписывать
+            // файл собственного шага).
             if (msg.blocked)
                 continue;
             const key = `${msg.name}:${summarizeArgs(msg.arguments)}`;
@@ -59,6 +60,7 @@ export function extractTriedAndFailed(messages) {
     }
     return Array.from(failures.values()).filter((f) => f.count >= 2);
 }
+/** Менеджер контекста: история, бюджеты, компакция, трекинг задачи/миссии сессии. */
 export class ContextManager {
     contextWindow;
     messages = [];
@@ -68,36 +70,44 @@ export class ContextManager {
     peakTokens = 0;
     budget;
     compactionThreshold;
+    /**
+     * Минимальная загрузка истории (доля бюджета), нужная интервалу итераций для
+     * срабатывания компакции. Интервал — защита от частоты, не триггер: слабо
+     * загруженный контекст нельзя уплотнять лишь потому, что прошло N итераций
+     * (было: компакция на ~40% бюджета стирала 33-44 полезных хода посреди задачи).
+     */
+    compactionMinLoad;
     facts = new FactExtractor();
-    /** Latest real user instruction (skips <system-summary> blocks). */
+    /** Последняя реальная инструкция юзера (мимо <system-summary>). */
     lastUserTask = "";
-    /** First real user instruction of the session — survives resetUserTurn(). */
+    /** Первая реальная инструкция сессии — переживает resetUserTurn(). */
     sessionMission = "";
-    /** Latest user message that looks like a pasted error/log (never a task). */
+    /** Последнее сообщение юзера, похожее на вставленную ошибку/лог (не задача). */
     lastUserFeedback = "";
     tokenCounter;
     pendingImageParts = [];
     toolTokens = 0;
-    /** Current reasoning level (set by agent loop, included in compaction summary). */
+    /** Текущий reasoning-уровень (ставит цикл агента, входит в сводку компакции). */
     thinkingLevel = null;
     onCompact = null;
     /**
-     * Optional short line appended to the compaction summary so the model knows
-     * an active plan exists with progress. Wired from bootstrap to the execution
-     * module — without it, a 9B model re-creates a plan from scratch right after
-     * compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) was discarded for a
-     * fresh plan_xzq9xe the same iteration the old plan was still visible).
+     * Опциональная короткая строка в сводку компакции, чтобы модель знала про
+     * активный план с прогрессом. Прокидывается из bootstrap в execution-модуль —
+     * без неё 9B-модель пересоздаёт план с нуля сразу после компакции (было:
+     * ses_msvuao0h — plan_e07pb2 (1/6) выброшен ради свежего plan_xzq9xe в ту же
+     * итерацию, когда старый план ещё был виден).
      */
     planSummaryProvider = null;
     constructor(contextWindow, contextBudget, tokenCounter) {
         this.contextWindow = contextWindow;
         this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
+        this.compactionMinLoad = contextBudget?.compactionMinLoad ?? 0.5;
         this.budget = this.calculateBudget(contextWindow, contextBudget);
         this.tokenCounter = tokenCounter ?? null;
     }
     /**
-     * Provide a short "current plan" line for the compaction summary, or null
-     * when no plan is active. Injected once at bootstrap (not per-turn state).
+     * Задаёт короткую строку "текущий план" для сводки компакции, или null если
+     * плана нет. Инжектится один раз на bootstrap (не per-turn состояние).
      */
     setPlanSummaryProvider(fn) {
         this.planSummaryProvider = fn;
@@ -109,57 +119,61 @@ export class ContextManager {
             const history = Math.max(0, window - systemPrompt - responseReserve);
             return { systemPrompt, responseReserve, history };
         }
-        // Fallback for backwards compatibility (tests, subagents without explicit budget)
+        // Фолбэк для обратной совместимости (тесты, сабагенты без явного бюджета)
         return {
             systemPrompt: Math.floor(window * 0.25),
             responseReserve: Math.floor(window * 0.12),
             history: Math.floor(window * 0.63),
         };
     }
+    /** Копия текущего бюджета. */
     getBudget() {
         return { ...this.budget };
     }
+    /** Число выполненных компакций. */
     getCompactionCount() {
         return this.compactionCount;
     }
+    /** Итераций с последней компакции. */
     getIterationsSinceCompaction() {
         return this.iterationsSinceCompaction;
     }
-    /** Files known from compaction summaries — for seeding the hallucination
-     *  checker's known-files set so bare filenames survive context resets. */
+    /** Файлы, известные из сводок компакции — сидируют known-files проверки
+     *  галлюцинаций, чтобы голые имена переживали сбросы контекста. */
     getKnownFiles() {
         return this.facts.getKnownFiles();
     }
+    /** Отмечает прошедшую итерацию (счётчик для интервала компакции). */
     noteIteration() {
         this.iterationsSinceCompaction++;
     }
     /**
-     * Start a fresh user turn. The 15-iteration compaction interval must not
-     * leak across user messages — otherwise a turn that ends at iteration 14
-     * forces a compaction on the very first iteration of the next user message
-     * (observed: compaction fired on iteration 8 of a new turn, deleting the
-     * user's freshly-sent task alongside 40+ old turns). Facts are kept.
+     * Начинает свежий ход юзера. 15-итерационный интервал компакции не должен
+     * течь через сообщения юзера — иначе ход, кончившийся на итерации 14,
+     * форсит компакцию на первой же итерации следующего сообщения (было:
+     * компакция на итерации 8 нового хода снесла свежеприсланную задачу юзера
+     * вместе с 40+ старыми ходами). Факты сохраняются.
      */
     resetUserTurn() {
         this.iterationsSinceCompaction = 0;
-        // A new user message begins a new turn — drop the previous turn's task
-        // so the fresh instruction becomes the one preserved at compaction. The
-        // session mission survives: an error/log paste in the new turn must not
-        // erase the original goal.
+        // Новое сообщение юзера начинает новый ход — сбрасываем задачу прошлого хода,
+        // чтобы сводка сохранила свежую инструкцию. Миссия сессии выживает: вставка
+        // ошибки/лога в новом ходе не должна стирать исходную цель.
         this.lastUserTask = "";
         this.lastUserFeedback = "";
     }
+    /** Оценка качества контекста 0–100 (нагрузка, компакции, ошибки, свежесть). */
     getQuality() {
         const usedTokens = this.getEstimatedTokens();
         const tokenLoad = this.budget.history > 0
             ? Math.max(0, 1 - usedTokens / this.budget.history)
             : 0;
-        // Recoverable penalty: each compaction loses some information, but the
-        // penalty is CAPPED so cumulative compactions can never permanently pin
-        // quality below the forced-compaction trigger (40%). Before this cap, a
-        // session with ~7+ compactions clamped the term to 0 forever; combined
-        // with heavy token load + error density, quality stuck below 40 and a
-        // compaction fired on EVERY iteration (observed: 56 compactions in 28 min).
+        // Восстанавливаемый штраф: каждая компакция теряет часть информации, но штраф
+        // ОГРАНИЧЕН СВЕРХУ, чтобы кумулятивные компакции не прикалывали качество ниже
+        // триггера форсированной компакции (40%). До капа сессия с ~7+ компакциями
+        // клампила слагаемое в 0 навсегда; вместе с тяжёлой токенной нагрузкой и
+        // плотностью ошибок качество застревало ниже 40 и компакция срабатывала на
+        // КАЖДОЙ итерации (было: 56 компакций за 28 минут).
         const COMPACTION_PENALTY_FLOOR = 0.5;
         const compactionLoss = Math.max(COMPACTION_PENALTY_FLOOR, 1 - this.compactionCount * 0.15);
         const msgCount = this.messages.length || 1;
@@ -168,13 +182,13 @@ export class ContextManager {
         const score = tokenLoad * 0.4 + compactionLoss * 0.25 + errorDensity * 0.2 + freshness * 0.15;
         return Math.round(Math.min(100, Math.max(0, score * 100)));
     }
+    /** Добавляет сообщение в историю (трекает задачу, аттачит pending-картинки, пик токенов). */
     addMessage(msg) {
-        // Track the task the agent is working on so it survives compaction. The
-        // user's real instruction is the FIRST non-system-summary user message of
-        // the turn; everything after it (tool results, retry nudges) are injected
-        // `user` envelopes that must not overwrite it (observed: after compaction
-        // the model had forgotten "удали /bicycles, почини стили" and re-read
-        // files aimlessly for 40+ iterations).
+        // Трекаем задачу, над которой работает агент, чтобы пережила компакцию.
+        // Реальная инструкция юзера — ПЕРВОЕ не-system-summary user-сообщение хода;
+        // всё после (результаты тулов, retry-nudge'и) — инжектированные `user`-
+        // конверты, которые не должны её затирать (было: после компакции модель
+        // забывала "удали /bicycles, почини стили" и 40+ итераций бесцельно читала файлы).
         if (msg.role === "user") {
             const text = typeof msg.content === "string" ? msg.content : getMessageText(msg.content);
             if (text.trim() && !text.startsWith("<system-summary>") && !text.includes("[Compressed:")) {
@@ -182,16 +196,16 @@ export class ContextManager {
                     this.lastUserFeedback = text.trim().slice(0, 400);
                 }
                 else if (!this.lastUserTask && !this.lastUserFeedback) {
-                    // No new task inside a turn that already captured an error/log paste:
-                    // the paste's follow-up messages are tool-result continuations, not a
-                    // fresh instruction, so the session mission must win at compaction.
+                    // Нет новой задачи внутри хода, где уже поймана вставка ошибки/лога:
+                    // последующие сообщения — продолжения результатов тулов, не свежая
+                    // инструкция, поэтому на компакции побеждает миссия сессии.
                     this.lastUserTask = text.trim();
                     if (!this.sessionMission)
                         this.sessionMission = text.trim();
                 }
             }
         }
-        // Auto-attach pending images to the next user message
+        // Авто-аттач pending-картинок к следующему user-сообщению
         if (msg.role === "user" && this.pendingImageParts.length > 0) {
             const textPart = {
                 type: "text",
@@ -209,35 +223,36 @@ export class ContextManager {
             this.peakTokens = tokens;
     }
     /**
-     * Queue an image part to be attached to the next user message.
+     * Кладёт картинку в очередь на аттач к следующему user-сообщению.
      */
     addPendingImage(part) {
         this.pendingImageParts.push(part);
     }
     /**
-     * Check if there are pending images waiting to be attached.
+     * True, если есть картинки, ждущие аттача.
      */
     hasPendingImages() {
         return this.pendingImageParts.length > 0;
     }
     /**
-     * Get pending image parts without clearing them.
+     * Возвращает pending-картинки, не очищая очередь.
      */
     getPendingImages() {
         return [...this.pendingImageParts];
     }
     /**
-     * Clear pending images (e.g., if user sends a text-only message).
+     * Очищает pending-картинки (напр., юзер шлёт чисто текстовое сообщение).
      */
     clearPendingImages() {
         this.pendingImageParts = [];
     }
+    /** Число сообщений в истории. */
     getMessageCount() {
         return this.messages.length;
     }
-    // Per-message token cache: messages are treated as immutable once added
-    // (compaction/updateSystemPrompt create new objects), so a WeakMap is safe
-    // and turns repeated full-history estimation from O(n) encodes into O(1).
+    // Токенный кэш на сообщение: сообщения считаются иммутабельными после добавления
+    // (компакция/updateSystemPrompt создают новые объекты), поэтому WeakMap безопасен
+    // и превращает повторную оценку всей истории из O(n) кодирований в O(1).
     tokenCache = new WeakMap();
     estimateMessageTokensCached(m) {
         let t = this.tokenCache.get(m);
@@ -251,14 +266,14 @@ export class ContextManager {
         const text = getMessageText(m.content);
         if (this.tokenCounter) {
             let t = this.tokenCounter.count(text);
-            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
+            // Токены картинок: base64 ~130 токенов на тайл 512x512; грубая оценка
             if (Array.isArray(m.content)) {
                 for (const part of m.content) {
                     if (part.type === "image_url" && part.image_url?.url) {
                         const b64Len = part.image_url.url.includes(",")
                             ? (part.image_url.url.split(",")[1]?.length ?? 0)
                             : part.image_url.url.length;
-                        // ~130 tokens per 512 bytes of base64
+                        // ~130 токенов на 512 байт base64
                         t += Math.ceil(b64Len / 512) * 130;
                     }
                 }
@@ -294,29 +309,36 @@ export class ContextManager {
         }
         return t;
     }
+    /** True, если истории нужна компакция (бюджет превышен или интервал + загрузка). */
     needsCompaction() {
-        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
-            return true;
         const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0);
-        return totalTokens > this.budget.history * this.compactionThreshold;
+        if (totalTokens > this.budget.history * this.compactionThreshold)
+            return true;
+        // Интервал итераций уплотняет только значимо загруженную историю.
+        // Уплотнять слабозагруженный контекст — терять рабочее состояние без
+        // бюджетной причины (см. `compactionMinLoad`).
+        if (this.iterationsSinceCompaction < COMPACTION_INTERVAL)
+            return false;
+        const load = this.budget.history > 0 ? totalTokens / this.budget.history : 0;
+        return load >= this.compactionMinLoad;
     }
+    /** Уплотняет историю: старые ходы → сводка фактов, свежие — дословно. Null, если уплотнять нечего. */
     compact() {
-        // Capture the pre-compaction state BEFORE any counters reset or rise —
-        // qualityBefore must reflect the context the model actually saw.
+        // Снимаем состояние ДО компакции ПЕРЕД сбросом/ростом счётчиков —
+        // qualityBefore обязан отражать контекст, который реально видела модель.
         const tokensBefore = this.getEstimatedTokens();
         const qualityBefore = this.getQuality();
         const messagesBefore = this.messages.length;
-        // Reset the counter even when nothing to compact — otherwise
-        // needsCompaction() returns true forever after 15 iterations with few messages.
+        // Сбрасываем счётчик, даже если уплотнять нечего — иначе
+        // needsCompaction() вечно true после 15 итераций с малым числом сообщений.
         this.iterationsSinceCompaction = 0;
         if (this.messages.length <= KEEP_LAST_N * 2)
             return null;
         this.compactionCount++;
         let cutoff = this.messages.length - KEEP_LAST_N * 2;
-        // Never split an assistant(tool_calls) group across the cutoff: the kept
-        // history must not start with orphaned role:"tool" messages, and the
-        // assistant half must not stay in the compacted part (OpenAI-compatible
-        // backends reject such histories).
+        // Не режем группу assistant(tool_calls) по cutoff: сохранённая история не
+        // должна начинаться с сиротских role:"tool", а assistant-половина — остаться
+        // в уплотняемой части (OpenAI-совместимые бэкенды такие истории отвергают).
         while (cutoff > 0 &&
             (this.messages[cutoff]?.role === "tool" || this.messages[cutoff - 1]?.tool_calls?.length)) {
             cutoff--;
@@ -326,18 +348,18 @@ export class ContextManager {
         this.facts.extract(oldTurns);
         const parts = [];
         parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        // Carry the user's actual instruction forward — the model must never lose
-        // the task it is working on just because 40 turns got compacted away. The
-        // per-turn task falls back to the session mission (first real instruction)
-        // so a pasted error/log in the current turn cannot erase the goal.
+        // Проносим реальную инструкцию юзера — модель не должна терять задачу,
+        // над которой работает, лишь потому что уплотнилось 40 ходов. Задача хода
+        // фолбэчится на миссию сессии (первую реальную инструкцию), чтобы вставка
+        // ошибки/лога в текущем ходе не стирала цель.
         const task = (this.lastUserTask || this.sessionMission).slice(0, 400);
         if (task)
             parts.push(`[Task: ${task}]`);
         if (this.lastUserFeedback && !task.startsWith(this.lastUserFeedback)) {
             parts.push(`[User feedback: ${this.lastUserFeedback}]`);
         }
-        // Orient the model after compaction: an active plan must not be re-created
-        // from scratch (see planSummaryProvider doc).
+        // Ориентируем модель после компакции: активный план нельзя пересоздавать
+        // с нуля (см. доку planSummaryProvider).
         const planLine = this.planSummaryProvider?.();
         if (planLine)
             parts.push(`[Plan: ${planLine}]`);
@@ -369,7 +391,7 @@ export class ContextManager {
             content: `<system-summary>${this.compactedBlock}</system-summary>`,
         };
         const firstSystem = this.messages.find((m) => m.role === "system");
-        // Filter out stale system-summary messages from recent turns to prevent nesting
+        // Чистим протухшие system-summary из свежих ходов против вложенности
         const freshRecent = recentTurns.filter((m) => {
             if (m.role !== "user")
                 return true;
@@ -394,8 +416,8 @@ export class ContextManager {
         };
     }
     /**
-     * Snapshot of the current context state — used to log the initial context
-     * structure at session start and per-iteration context stats.
+     * Снапшот текущего состояния контекста — для лога начальной структуры
+     * контекста на старте сессии и per-iteration статистики.
      */
     getSnapshot() {
         return {
@@ -410,8 +432,8 @@ export class ContextManager {
         };
     }
     /**
-     * Replace the system prompt in place (keeps it first) or prepend a new one.
-     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
+     * Заменяет системный промпт на месте (остаётся первым) или пренпендит новый.
+     * Обновляет динамические блоки промпта (напр. чеклист плана) посреди прогона.
      */
     updateSystemPrompt(content) {
         const idx = this.messages.findIndex((m) => m.role === "system");
@@ -422,13 +444,14 @@ export class ContextManager {
             this.messages.unshift({ role: "system", content });
         }
     }
+    /** Копия активной истории сообщений. */
     getActiveHistory() {
         return [...this.messages];
     }
     /**
-     * Reset everything that belongs to the current conversation turn.
-     * Fact lists (FactExtractor) intentionally survive clear() — they are
-     * session-scoped compaction state, not per-turn.
+     * Сбрасывает всё, что принадлежит текущему ходу диалога.
+     * Списки фактов (FactExtractor) осознанно переживают clear() — это
+     * session-scoped состояние компакции, не per-turn.
      */
     clear() {
         this.messages = [];
@@ -440,12 +463,15 @@ export class ContextManager {
         this.lastUserFeedback = "";
         this.sessionMission = "";
     }
+    /** Оценка токенов истории (сообщения + токены тулов). */
     getEstimatedTokens() {
         return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0) + this.toolTokens);
     }
+    /** Задаёт токены определений тулов (прибавляются к оценке). */
     setToolTokens(tokens) {
         this.toolTokens = tokens;
     }
+    /** Пересчитывает бюджеты под новое окно контекста (и опционально счётчик). */
     resize(contextWindow, contextBudget, tokenCounter) {
         this.contextWindow = contextWindow;
         this.budget = this.calculateBudget(contextWindow, contextBudget);

package/dist/modules/critic/client.js

@@ -0,0 +1,176 @@
+// Клиент контр-агента: верификация пакета доказательств с опциональным read-only контуром.
+import { jsonrepair } from "jsonrepair";
+import { parseChecks, runCriticChecks, renderCheckResults, CRITIC_READONLY_TOOLS } from "./tools";
+export const CRITIC_SYSTEM_PROMPT = `You are a strict but fair verifier ("counter-agent") reviewing an AI agent's in-progress work.
+Rules:
+- Flag ONLY issues that can be verified from the evidence provided. Do not speculate or invent.
+- Do not nitpick style, wording, or preferences unless the user's task demanded it.
+- If the evidence is insufficient to judge, return status "ok" (prefer silence over noise).
+- "critical" = the task's stated result is demonstrably not delivered. "concern" = a concrete, checkable gap. "info" = minor.
+- Every issue must reference concrete evidence (file, command, output).
+Reply with JSON ONLY:
+{"status":"ok|concern|critical","summary":"one line","issues":[{"severity":"info|concern|critical","claim":"...","problem":"...","suggestion":"...","evidence":"..."}]}`;
+const CHECK_REQUEST_INSTRUCTION = `If your verdict is concern/critical and a read-only file check could confirm or refute an issue, request up to 3 checks by adding "checks":[{"tool":"...","args":{...}}] to your JSON. Available tools ONLY: ${CRITIC_READONLY_TOOLS.join(", ")} (read-only; no writes, shell, web, or memory exist — do not request anything else). Checks run locally and their outputs return to you for a FINAL verdict. If no check would help, omit "checks".`;
+const FINAL_VERDICT_INSTRUCTION = `Check outputs above are ground truth from the workspace. Reply with your FINAL verdict as JSON (same shape, no more "checks"): confirm each issue the checks support, drop the ones they refute, and set status accordingly.`;
+/** Клиент критика: судит пакет доказательств, при concern/critical — до 3 read-only проверок. */
+export class CriticClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    isEnabled() {
+        return true;
+    }
+    /**
+     * Верифицирует пакет доказательств (Phase 2: опциональный ограниченный тул-контур).
+     *
+     * Проход 1 судит пакет как есть (поведение v1). При concern/critical с
+     * раннером `runCheck` проход 2 даёт критику до 3 read-only проверок,
+     * проход 3 выносит финальный вердикт по их выводам. Вся цепочка делит
+     * один таймаут-бюджет и откатывается к вердикту прохода 1
+     * (или null, если упал сам проход 1) — глубина верификации best-effort,
+     * никогда не блокирует.
+     */
+    async verify(pack, signal, opts) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs ?? 15000);
+        const onAbort = () => controller.abort();
+        signal?.addEventListener("abort", onAbort);
+        try {
+            const messages = [
+                { role: "system", content: CRITIC_SYSTEM_PROMPT },
+                { role: "user", content: renderPack(pack) },
+            ];
+            const firstRaw = await this.chat(messages, controller.signal);
+            const first = parseVerdict(firstRaw);
+            if (!first || first.status === "ok" || !opts?.runCheck)
+                return first;
+            return await this.verifyWithChecks(messages, firstRaw, first, controller.signal, opts.runCheck);
+        }
+        catch {
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    /**
+     * Проходы 2–3: запрашиваем ограниченные read-only проверки (доп. LLM-вызовы
+     * только если первый вердикт actionable), выполняем их и заземляем финальный
+     * вердикт на выводах. История сохраняется, чтобы "твой вердикт" резолвился в проход 1.
+     * Любой сбой — откат к вердикту прохода 1.
+     */
+    async verifyWithChecks(messages, firstRaw, first, signal, runCheck) {
+        try {
+            messages.push({ role: "assistant", content: firstRaw });
+            messages.push({ role: "user", content: CHECK_REQUEST_INSTRUCTION });
+            const checksRaw = await this.chat(messages, signal);
+            const checks = parseChecks(parseVerdict(checksRaw));
+            if (checks.length === 0)
+                return first;
+            const results = await runCriticChecks(checks, runCheck);
+            if (results.length === 0)
+                return first;
+            messages.push({ role: "assistant", content: checksRaw });
+            messages.push({
+                role: "user",
+                content: `CHECK RESULTS (ground truth):\n${renderCheckResults(results)}\n\n${FINAL_VERDICT_INSTRUCTION}`,
+            });
+            return parseVerdict(await this.chat(messages, signal)) ?? first;
+        }
+        catch {
+            return first;
+        }
+    }
+    async chat(messages, signal) {
+        let text = "";
+        for await (const chunk of this.opts.provider.chat(messages, undefined, signal, {
+            maxTokens: this.opts.maxTokens ?? 512,
+            reasoningEffort: "none",
+        })) {
+            if (chunk.type === "text" && chunk.content)
+                text += chunk.content;
+        }
+        return text;
+    }
+}
+function renderPack(pack) {
+    const cmdLines = pack.commands.map((c) => {
+        const base = `${c.command} (exit ${c.exitCode ?? "?"})`;
+        return c.output ? `${base}\n  output: ${c.output}` : base;
+    });
+    const files = (pack.fileExcerpts ?? []).map((f) => `--- ${f.path} ---\n${f.excerpt}`);
+    return [
+        `TASK: ${pack.task}`,
+        pack.planSummary ? `PLAN: ${pack.planSummary}` : "",
+        `CHANGED FILES: ${pack.changedFiles.join(", ") || "(none)"}`,
+        `COMMANDS: ${cmdLines.join("; ") || "(none)"}`,
+        "TOOL TRAIL:",
+        pack.toolDigest || "(empty)",
+        files.length > 0 ? `FILE CONTENTS:\n${files.join("\n")}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+const SEVERITIES = new Set(["info", "concern", "critical"]);
+/** Парсит вердикт критика из сырого текста (строгий JSON → jsonrepair → вырезание блока). Null, если не вердикт. */
+export function parseVerdict(text) {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        try {
+            parsed = JSON.parse(jsonrepair(text));
+        }
+        catch {
+            const match = text.match(/\{[\s\S]*\}/);
+            if (!match)
+                return null;
+            try {
+                parsed = JSON.parse(jsonrepair(match[0]));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const obj = parsed;
+    const status = obj.status;
+    if (status !== "ok" && status !== "concern" && status !== "critical")
+        return null;
+    const issues = parseIssuesList(obj.issues);
+    // Запрошенные проверки верификации (Phase 2): несём сырыми, кап здесь;
+    // форма + allowlist enforced в parseChecks, вслепую не доверяем.
+    const checks = parseRawChecks(obj.checks);
+    return { status, summary: String(obj.summary ?? ""), issues, ...(checks ? { checks } : {}) };
+}
+/** Проблемы вердикта с санитизированными severity; записи без claim+problem дропаются. */
+function parseIssuesList(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((i) => !!i && typeof i === "object")
+        .map((i) => ({
+        severity: (SEVERITIES.has(String(i.severity)) ? String(i.severity) : "concern"),
+        claim: String(i.claim ?? ""),
+        problem: String(i.problem ?? ""),
+        suggestion: i.suggestion ? String(i.suggestion) : undefined,
+        evidence: i.evidence ? String(i.evidence) : undefined,
+    }))
+        .filter((i) => i.claim || i.problem);
+}
+/** Сырые запрошенные проверки (с капом); форма + allowlist enforced в parseChecks. */
+function parseRawChecks(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = raw
+        .filter((c) => !!c &&
+        typeof c === "object" &&
+        typeof c.tool === "string")
+        .map((c) => ({ tool: c.tool, args: c.args }));
+    return out.length > 0 ? out : undefined;
+}