micro-models-agent 2.11.0 → 2.13.1

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

@@ -1,6 +1,9 @@
+/** Вентиль халлюцинаций: проверка финального ответа перед принятием. */
 import { pc } from "../../ui/colors";
 import { t } from "../../i18n/index";
-import { MAX_HALLUCINATION_RETRIES } from "./constants";
+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";
 /**
  * Вентиль проверки халлюцинаций финального текстового ответа.
  *
@@ -12,11 +15,38 @@ import { MAX_HALLUCINATION_RETRIES } from "./constants";
  * Возвращает структурированный вердикт; решение о `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-чек смотрит на
@@ -26,56 +56,136 @@ export class HallucinationGate {
             state.lastModelText = textContent;
         const result = await this.detector.validate(textContent);
         if (result.status === "block") {
-            logger.warn(`Response blocked: ${result.reason}`);
+            logger.diagnostic("warn", `Response blocked: ${result.reason}`);
             return { action: "block", reason: result.reason || "" };
         }
         if (result.status === "warn") {
-            logger.warn(`Hallucination warning: ${result.reason}`);
+            logger.diagnostic("warn", `Hallucination warning: ${result.reason}`);
             this.displayWarnLine(result.reason, deps);
             return { action: "warn" };
         }
         if (result.status === "retry") {
-            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.warn(`Audit-triggered re-answer repetition — not counted as hallucination retry`);
-                this.displayWarnLine(result.reason, deps);
-                return { action: "accept" };
+            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.hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
-                logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
-                return { action: "block", reason: t("hall.max_retries_exhausted") };
+        }
+        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}`);
             }
-            state.hallucinationRetries++;
-            logger.warn(`Hallucination retry (${state.hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${result.reason}`);
-            if (textContent) {
-                deps.contextManager.addMessage({ role: "assistant", content: textContent });
+        }
+        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}`);
             }
-            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" };
         }
-        return { action: "accept" };
+        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`);

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

@@ -1,4 +1,6 @@
+/** Состояние одного запуска агентного цикла: счётчики, бюджеты, сигналы. */
 import { FORCED_COMPACTION_COOLDOWN } from "./constants";
+import { createArtifactChurnState } from "./artifact-progress";
 /** Фабрика начального состояния цикла. */
 export function createLoopState() {
     return {
@@ -7,14 +9,22 @@ export function createLoopState() {
         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,
@@ -26,8 +36,13 @@ export function createLoopState() {
         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,

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

@@ -1,4 +1,4 @@
-// src/core/agent/prefix-monitor
+/** Монитор стабильности префикса промпта (клиентская оценка кеша). */
 /**
  * Клиентский монитор стабильности префикса промпта.
  *

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

@@ -1,3 +1,4 @@
+/** Резолвер уровня reasoning на итерацию: override → политика → фикс. */
 import { evaluateReasoningPolicy } from "../../modules/reasoning/policy";
 /**
  * Резолвер уровня reasoning на итерацию.
@@ -15,6 +16,11 @@ import { evaluateReasoningPolicy } from "../../modules/reasoning/policy";
  * clearIterationSignals сразу после resolve).
  */
 export class ReasoningEffortResolver {
+    /**
+     * Вычисляет уровень reasoning на итерацию (override → политика → фикс).
+     * @param deps состояние цикла, политика, конфиг, probe, стратегия.
+     * @returns уровень, стратегия и источник решения.
+     */
     resolve(deps) {
         const { state, reasoningConfig, reasoningState } = deps;
         let level;
@@ -42,7 +48,10 @@ export class ReasoningEffortResolver {
                 planCreated: state.iterPlanCreated,
                 consecutiveSuccesses: state.consecutiveToolSuccesses,
                 isRepetitive: state.iterRepetitive,
-                baseline: reasoningConfig?.baseline ?? "medium",
+                // Baseline — настроенный минимум (`min`, по умолчанию "low"),
+                // чтобы конфиг без явного baseline не жёг "medium" на пустяках.
+                // Политика всё равно повышает уровень по сигналам.
+                baseline: reasoningConfig.baseline ?? reasoningConfig.min,
             }, deps.policyState);
             level = policyResult.level;
             source = "policy";

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

@@ -14,10 +14,10 @@ import { estimateTokens } from "../../llm/token-counter";
  */
 export class TokenTracker {
     costTracker;
-    getProviderName;
-    constructor(costTracker, getProviderName) {
+    getProvenance;
+    constructor(costTracker, getProvenance) {
         this.costTracker = costTracker;
-        this.getProviderName = getProviderName;
+        this.getProvenance = getProvenance;
     }
     /**
      * Начало итерации: фиксирует baseline API-токенов и аккумулирует оценку
@@ -64,7 +64,10 @@ export class TokenTracker {
             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,
@@ -75,7 +78,7 @@ export class TokenTracker {
         });
         // Кеш учитываем только когда цифры пришли от API: оценка chars/4 о кеше
         // ничего не знает и не должна менять тарификацию.
-        this.costTracker.record(prompt, completion, this.getProviderName(), source === "api" ? state.cacheUsage : undefined);
+        this.costTracker.record(prompt, completion, prov.provider, source === "api" ? state.cacheUsage : undefined);
     }
     /**
      * Финальные метрики результата. API-токены в приоритете; иначе — сумма

package/dist/core/agent/tool-batch.js

@@ -1,8 +1,10 @@
+/** Исполнитель пакета тулов: жизненный цикл вызовов за итерацию. */
 import { pc } from "../../ui/colors";
 import { t } from "../../i18n/index";
-import { summarizeToolArgs, truncateToolOutput, compactToolError } from "./tool-output";
+import { summarizeToolArgs, truncateToolOutput, toolFailureSummary, isExecutableScriptPath, } from "./tool-output";
+import { queueToolImages } from "./tool-images";
 import { errMsg } from "../../utils";
-import { MAX_CONSECUTIVE_TOOL_FAILURES, MIN_REPEATED_TOOL_FAILURES, } from "./constants";
+import { MAX_CONSECUTIVE_TOOL_FAILURES, MIN_REPEATED_TOOL_FAILURES, MAX_CONSECUTIVE_FAILED_BATCHES, HARD_STOP_FAILED_BATCHES } from "./constants";
 /**
  * Выполнение пакета тулов, полученных от модели за одну итерацию.
  *
@@ -24,6 +26,13 @@ export class ToolBatchExecutor {
     constructor(deps) {
         this.deps = deps;
     }
+    /**
+     * Выполняет пакет tool_calls одной итерации (контекст, UI, учёт неудач).
+     * @param state состояние цикла; @param toolCalls вызовы от модели;
+     * @param boundedToolNames тулы с собственным лимитом вывода;
+     * @param textContent/reasoningContent/input тексты хода;
+     * @returns флаг прерывания по shutdown.
+     */
     async execute(state, toolCalls, boundedToolNames, textContent, reasoningContent, input, onTool, onMeta, slog) {
         const { config, pluginManager, contextManager, logger } = this.deps;
         const iteration = state.iteration;
@@ -62,9 +71,13 @@ export class ToolBatchExecutor {
         };
         const summaries = [];
         let anyToolFailed = false;
+        let batchHasSuccess = false;
         // Информационные read-only тулы, чей "фейл" — ожидаемое поведение
         // (file_info "Not found" после delete_file) — исключены из учёта неудач.
         const infoTools = new Set(["file_info"]);
+        // Флаг блока безопасности действует в пределах текущего пакета вызовов:
+        // иначе старый блок влиял бы на nudge через десятки итераций.
+        state.sawSecurityBlock = false;
         for (const call of toolCalls) {
             this.deps.setScope();
             const startTime = Date.now();
@@ -77,6 +90,9 @@ export class ToolBatchExecutor {
             onTool?.({ type: "start", tool: call.name, args: call.arguments, icon: toolIcon });
             slog?.logToolCall(call, iteration);
             const tokensBeforeTool = contextManager.getEstimatedTokens();
+            // Снимок стоимости ДО тула: рендеру нужна стоимость именно этого вызова
+            // (subagent/mcp/pipeline тратят токены), а не накопленная за сессию.
+            const costBeforeTool = this.deps.costTracker.total;
             let result;
             try {
                 result = await this.deps.toolExecutor.execute(call, this.deps.getAbortSignal());
@@ -89,7 +105,7 @@ export class ToolBatchExecutor {
                     synthesizePendingToolResults();
                     throw err;
                 }
-                logger.warn(`Tool ${call.name} threw: ${errMsg(err)}`);
+                logger.diagnostic("warn", `Tool ${call.name} threw: ${errMsg(err)}`);
                 result = {
                     success: false,
                     output: `${t("error.prefix")}${errMsg(err)}`,
@@ -104,6 +120,8 @@ export class ToolBatchExecutor {
             const duration = Date.now() - startTime;
             if (!result.success && !result.blocked && !infoTools.has(call.name))
                 anyToolFailed = true;
+            if (result.success)
+                batchHasSuccess = true;
             if (result.success && call.name === "plan") {
                 const action = String(call.arguments.action ?? "");
                 if (action === "create" || action === "re-plan")
@@ -122,28 +140,34 @@ export class ToolBatchExecutor {
             // Проверка наличия, а не истинности: read_file возвращает display ""
             // на полном чтении (заголовок уже показывает путь) — фолбэк на пустую
             // строку вывалил бы всё содержимое файла в REPL.
+            // kind="tool": тела тулов model-facing, в quiet-чатах скрываются
+            // (статусы контекста/компакции идут с kind по умолчанию и всегда видны).
+            const TOOL_META = "tool";
             if (result.display !== undefined) {
                 if (result.display.length > 0) {
-                    onMeta?.("\n" + result.display + "\n");
+                    onMeta?.(`\n${result.display}\n`, TOOL_META);
                 }
             }
             else if (result.success) {
                 const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
-                onMeta?.("\n" + pc.dim(metaOut) + "\n");
+                onMeta?.(`\n${pc.dim(metaOut)}\n`, TOOL_META);
             }
             else {
-                // Failed tool: its `output` is model-facing (Hints, recovery
-                // directives, "Do NOT …"). The user only needs the gist — the first
-                // line — not the instructions written for the agent.
-                const line = compactToolError(result.output);
-                const metaOut = line
-                    ? pluginManager.runOnMeta({ iteration, logger, contextManager }, line)
+                // Упавший тул: `output` — model-facing (хинты, recovery-директивы,
+                // «Do NOT …»). Пользователю нужна спокойная суть — первая строка,
+                // а не инструкции для агента. Мягкие гарды — варнинги, не ошибки.
+                const failure = toolFailureSummary(result.output);
+                const metaOut = failure.text
+                    ? pluginManager.runOnMeta({ iteration, logger, contextManager }, failure.text)
                     : "";
-                if (metaOut)
-                    onMeta?.("\n" + pc.red(metaOut) + "\n");
+                if (metaOut) {
+                    const color = failure.severity === "warn" ? pc.yellow : pc.red;
+                    const glyph = failure.severity === "warn" ? "⚠" : "✗";
+                    onMeta?.(`\n${color(`${glyph} ${metaOut}`)}\n`, TOOL_META);
+                }
             }
             if (result.diff) {
-                onMeta?.("\n" + result.diff + "\n");
+                onMeta?.(`\n${result.diff}\n`, TOOL_META);
             }
             const currentTokens = contextManager.getEstimatedTokens();
             const budget = contextManager.getBudget();
@@ -158,17 +182,40 @@ export class ToolBatchExecutor {
                 arguments: call.arguments,
             });
             answeredToolCallIds.add(call.id);
+            // Изображения тула (browser screenshot и т.п.) встают в очередь и
+            // прицепятся к следующему user-сообщению — обычно к <system-summary>
+            // в конце этого же batch'а. В role:"tool" строку base64 не пишем.
+            queueToolImages(contextManager, result.images);
             const tokensAfterTool = contextManager.getEstimatedTokens();
+            const costAfterTool = this.deps.costTracker.total;
             onTool?.({
                 type: "end",
                 tool: call.name,
                 args: call.arguments,
                 duration,
                 error: !result.success,
+                output: typeof result.output === "string" ? result.output : undefined,
                 ctxDelta: tokensAfterTool - tokensBeforeTool,
-                costUsd: this.deps.costTracker.total,
+                costUsd: costBeforeTool !== undefined && costAfterTool !== undefined
+                    ? costAfterTool - costBeforeTool
+                    : undefined,
             });
             summaries.push(`[Tool: ${call.name}${summarizeToolArgs(call.arguments)} → ${truncatedOutput.slice(0, 200)}]`);
+            // Видели блок безопасности? Запоминаем для эвристики скрипта-обёртки.
+            if (typeof result.output === "string" && result.output.includes("[SECURITY BLOCKED]")) {
+                state.sawSecurityBlock = true;
+            }
+            // Скрипт-обход: после блока безопасности запись shell-скрипта
+            // (.bat/.cmd/.sh/.ps1) почти всегда — попытка обойти заблокированный
+            // оператор; nudge один раз, обобщённо (без привязки к тулу/языку).
+            if (state.sawSecurityBlock &&
+                !state.scriptWorkaroundNudged &&
+                call.name === "write_file" &&
+                typeof call.arguments.path === "string" &&
+                isExecutableScriptPath(call.arguments.path)) {
+                state.scriptWorkaroundNudged = true;
+                summaries.push(t("exec.script_workaround_nudge"));
+            }
             if (config.session.autoSave) {
                 slog?.logToolResult(call, result, duration, iteration);
             }
@@ -188,7 +235,7 @@ export class ToolBatchExecutor {
                     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)`);
+                        logger.diagnostic("warn", `Recorded repeated ${key} failures to memory (${prev.count}x)`);
                     }
                 }
             }
@@ -210,8 +257,8 @@ export class ToolBatchExecutor {
             const recoveryMsg = t("exec.consecutive_failures_recovery", {
                 count: state.consecutiveToolFailures,
             });
-            logger.warn(`Consecutive tool failures: ${state.consecutiveToolFailures}`);
-            const taskSnippet = input.length > 200 ? input.slice(0, 200) + "..." : input;
+            logger.diagnostic("warn", `Consecutive tool failures: ${state.consecutiveToolFailures}`);
+            const taskSnippet = input.length > 200 ? `${input.slice(0, 200)}...` : input;
             const taskReminder = t("exec.task_reminder", { task: taskSnippet });
             contextManager.addMessage({
                 role: "user",
@@ -222,6 +269,34 @@ export class ToolBatchExecutor {
                 memStore.appendRule("errors", `${state.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");
             }
         }
+        // Honest-stop полностью провальных пакетов: каждый вызов пакета — неудача
+        // или tool-level блок (в отличие от consecutiveToolFailures выше, блоки
+        // ВХОДЯТ в учёт — перебор вариантов заблокированной команды это та же
+        // петля). Смешанные пакеты и успехи сбрасывают стрик: связка
+        // «упал → поправил → упал» (дебаг) под него не попадает.
+        // Plugin-level блоки (result.blocked, guard-rails) нейтральны по контракту
+        // ToolResult.blocked — не успех и не неудача.
+        if (anyToolFailed && !batchHasSuccess) {
+            state.consecutiveFailedBatches++;
+        }
+        else if (batchHasSuccess) {
+            state.consecutiveFailedBatches = 0;
+            state.honestStopNudged = false;
+        }
+        if (state.consecutiveFailedBatches >= MAX_CONSECUTIVE_FAILED_BATCHES &&
+            !state.honestStopNudged) {
+            state.honestStopNudged = true;
+            logger.diagnostic("warn", `Consecutive failed tool batches: ${state.consecutiveFailedBatches} — honest-stop directive`);
+            contextManager.addMessage({
+                role: "user",
+                content: `<system-summary>${t("exec.honest_stop", { count: state.consecutiveFailedBatches })}</system-summary>`,
+            });
+        }
+        if (state.consecutiveFailedBatches >= HARD_STOP_FAILED_BATCHES) {
+            state.retryLoopStopped = true;
+            logger.diagnostic("warn", `Retry loop hard-stopped after ${state.consecutiveFailedBatches} consecutive failed batches`);
+            return { interrupted: true };
+        }
         // Статусная строка плана после каждого пакета тулов. Заменяет динамический
         // plan-блок, который жил в system prompt (удалён ради KV-cache — план
         // меняется каждую итерацию).

package/dist/core/agent/tool-images.js

@@ -0,0 +1,18 @@
+/**
+ * Ставит изображения, произведённые тулом, в очередь pending-изображений
+ * контекста. Они прикрепятся к следующему user-сообщению (обычно это
+ * `<system-summary>` с итогами пакета тулов в конце batch'а) — так картинка
+ * доходит до модели как валидный image-part, а не как base64-текст в
+ * `role:"tool"` (который и не портируем, и усекается бюджетом).
+ *
+ * Намеренно не складывает изображения в промежуточные tool-сообщения:
+ * вставка user-сообщения между результатами одного assistant(tool_calls)
+ * нарушает порядок, требуемый Jinja-шаблонами (см. architecture.md).
+ */
+export function queueToolImages(sink, images) {
+    if (!sink || !images || images.length === 0)
+        return;
+    for (const image of images) {
+        sink.addPendingImage(image);
+    }
+}