micro-models-agent 0.6.4 → 0.7.0

package/dist/agent/loop.js

@@ -1,1043 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join, isAbsolute, relative } from "node:path";
-import { parseToolCalls } from "../tools/parse-tool-call.js";
-import { AdapterPipeline, } from "../tools/adapters/index.js";
-import { parseFileRefs } from "../file-loader.js";
-import { ContextManager } from "./context.js";
-import { ModeRegistry } from "./modes/registry.js";
-import { applyMode } from "./modes/applier.js";
-import { loadSkill, loadSkillsFromRefs, enforceSkillBudget, preloadSkillsByKeywords, isSkillRequest, listInstalledSkills, } from "../skills/loader.js";
-import { runPreToolUseHooks, runPostToolUseHooks } from "../tools/hooks.js";
-import { isMCPCommand, parseMCPCommand, callMCPTool } from "../tools/mcp.js";
-import { showPlan, getPlanPendingCount, clearPlan, getNextPendingStep, updatePlanStep, extractDirFromStepTitle, } from "../tools/plan.js";
-import { generateToolCallId } from "../tools/id-gen.js";
-import { checkFileSyntax } from "../tools/syntax-check.js";
-import { loadConfig, getLLMConfig, getGroundingConfig, } from "../config/config.js";
-import { buildSystemPrompt } from "./system-prompt.js";
-import { logInfo, logWarn, logError, logDebug, logToolCall, logToolOutput, setStatusWriter, writeStatus, } from "../logger.js";
-import { runIsolatedLoop } from "../tools/subagent.js";
-import { buildSubagentContext } from "../subagent/context.js";
-import { doChat } from "../subagent/chat.js";
-import { SubagentRenderer } from "../ui/subagent-renderer.js";
-import { ToolExecutor } from "./tool-executor.js";
-import { ErrorEscalator } from "./error-escalation.js";
-import { WriteEnforcer } from "./write-enforcer.js";
-import { sendNotification } from "../tools/hooks.js";
-import { planHandler } from "../tools/native/plan.js";
-import { todoHandler } from "../tools/native/todo.js";
-import { questionHandler } from "../tools/native/question.js";
-import { approveHandler } from "../tools/native/approve.js";
-import { userProfileHandler } from "../tools/native/user-profile.js";
-import { themeHandler } from "../tools/native/theme.js";
-import { scaffoldHandler } from "../tools/native/scaffold.js";
-import { projectMapHandler } from "../tools/native/project-map.js";
-import { bashHandler } from "../tools/bash.js";
-import { readFileHandler } from "../tools/fs/read-file.js";
-import { writeFileHandler } from "../tools/fs/write-file.js";
-import { editFileHandler } from "../tools/fs/edit-file.js";
-import { listDirHandler } from "../tools/fs/list-dir.js";
-import { createDirHandler } from "../tools/fs/create-dir.js";
-import { deleteFileHandler } from "../tools/fs/delete-file.js";
-import { copyFileHandler } from "../tools/fs/copy-file.js";
-import { moveFileHandler } from "../tools/fs/move-file.js";
-import { fileInfoHandler } from "../tools/fs/file-info.js";
-import { globSearchHandler } from "../tools/fs/glob-search.js";
-import { grepSearchHandler } from "../tools/fs/grep-search.js";
-import { treeHandler } from "../tools/fs/tree.js";
-import { webSearchHandler } from "../tools/web-search.js";
-import { webFetchHandler } from "../tools/web-fetch.js";
-import { webBrowseHandler } from "../tools/web-browse.js";
-import { truncateOutput } from "./tool-executor.js";
-/**
- * Основной цикл ReAct-агента.
- *
- * Архитектура цикла:
- * 1. Сборка system prompt (кэшируется на время сессии)
- * 2. Отправка запроса к LLM с историей сообщений
- * 3. Парсинг tool calls из ответа модели (формат <tool_call>)
- * 4. Валидация и исполнение каждого tool call
- * 5. Добавление результата в историю
- * 6. Повтор до завершения (нет tool calls) или лимита ходов
- *
- * Особенности:
- * - Fallback-парсинг при невалидном JSON от маленьких моделей
- * - Автоматическое компактирование контекста при приближении к лимиту
- * - Retry с увеличением temperature при пустых ответах
- * - Автодобавление скилов при обнаружении релевантных паттернов
- *
- * @module agent/loop
- */
-/**
- * Fallback-извлечение bash-команды из ответа модели.
- * Используется когда основной парсинг tool calls не сработал
- * (маленькие модели часто генерируют невалидный JSON).
- * Применяет три regex-паттерна для поиска команды bash.
- */
-function extractToolCallFallback(response) {
-    const patterns = [
-        /"name"\s*:\s*"bash"\s*,\s*"arguments"\s*:\s*\{\s*"cmd"\s*:\s*"((?:[^"\\]|\\.)*)"/,
-        /"cmd"\s*:\s*"((?:[^"\\]|\\.)*)"/,
-        /name['"]\s*:\s*['"]bash['"]\s*,.*?cmd['"]\s*:\s*['"]((?:[^'\\]|\\.)*)['"]/,
-    ];
-    for (const re of patterns) {
-        const m = response.match(re);
-        if (m) {
-            let cmd = m[1];
-            cmd = cmd
-                .replace(/\\n/g, "\n")
-                .replace(/\\t/g, "\t")
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, "\\");
-            return { name: "bash", cmd };
-        }
-    }
-    return null;
-}
-/**
- * Запускает основной цикл ReAct-агента.
- *
- * Цикл работает до тех пор, пока:
- * - Агент не перестанет вызывать инструменты (финальный текстовый ответ)
- * - Не будет достигнут лимит ходов (maxSteps из конфига)
- * - Пользователь не прервёт выполнение (abort signal)
- *
- * Стратегия обработки ошибок:
- * - Пустые ответы: retry до 3 раз с подсказкой "Continue."
- * - Невалидные tool calls: отправка обратной связи модели
- * - Пустые ответы подряд >3: остановка цикла
- *
- * @param provider - провайдер LLM (OpenAI-совместимый)
- * @param registry - реестр доступных инструментов
- * @param prompt - начальный промпт пользователя
- * @param contextManager - менеджер контекста (опциональный, создаётся новый если не передан)
- * @param previousMessages - предыдущие сообщения для восстановления сессии
- * @param renderer - рендерер вывода (Ink или readline)
- * @param providerName - имя провайдера для отображения
- * @param options - дополнительные опции (quiet, showThinking, mode)
- */
-export async function runAgentLoop(provider, registry, prompt, contextManager, previousMessages, renderer, providerName, options) {
-    logInfo("LOOP", `runAgentLoop started: "${prompt.slice(0, 50)}"`);
-    renderer?.resetAbort?.();
-    // Парсинг ссылок на файлы в промпте (формат @path/to/file)
-    const { prompt: enrichedPrompt, files } = await parseFileRefs(prompt);
-    logDebug("LOOP", `parseFileRefs: ${files.length} files, prompt len: ${enrichedPrompt.length}`);
-    const quiet = options?.quiet ?? false;
-    // ─── ModeRegistry: конфигурация режима ──
-    const modeRegistry = new ModeRegistry();
-    const modeConfig = modeRegistry.getOrFallback(options?.mode || "base");
-    const applied = applyMode(modeConfig, {
-        quiet,
-        showThinking: options?.showThinking,
-    });
-    // ─── Behaviors из ModeConfig ──────────────────────────
-    const behaviors = modeConfig.behaviors;
-    const continuationNudgeMax = typeof behaviors.continuationNudgeLimit === "number"
-        ? behaviors.continuationNudgeLimit
-        : behaviors.continuationNudge !== false
-            ? 2
-            : 0;
-    const readConsolidation = behaviors.readConsolidation !== false;
-    // Автозагрузка скилов из промпта (если пользователь указал @skill-name)
-    const loadedSkills = loadSkillsFromRefs(prompt, process.cwd());
-    const loadedSkillNames = new Set(loadedSkills.map((s) => s.name));
-    if (loadedSkills.length > 0) {
-        logInfo("LOOP", `loaded ${loadedSkills.length} skills: ${loadedSkills.map((s) => s.name).join(", ")}`);
-        renderer?.writeInfo(`  Loaded ${loadedSkills.length} skill(s): ${loadedSkills.map((s) => s.name).join(", ")}`);
-    }
-    // Принудительная загрузка скилов из ModeConfig
-    for (const skillName of applied.forcedSkills) {
-        if (!loadedSkillNames.has(skillName)) {
-            const skill = loadSkill(skillName, process.cwd());
-            if (skill) {
-                loadedSkills.push(skill);
-                loadedSkillNames.add(skillName);
-                logInfo("LOOP", `auto-loaded ${skillName} skill for ${modeConfig.id} mode`);
-                renderer?.writeInfo(`  Auto-loaded @${skillName} skill for ${modeConfig.id} mode`);
-            }
-            else {
-                logWarn("LOOP", `${skillName} skill not found for ${modeConfig.id} mode`);
-                renderer?.writeWarning(`  Warning: @${skillName} skill not found (required for ${modeConfig.id} mode)`);
-            }
-        }
-    }
-    // Ограничение количества скилов из ModeConfig (не deprecated config)
-    const config = loadConfig();
-    const maxSkills = modeConfig.constraints.maxSkills;
-    if (maxSkills > 0 && loadedSkills.length > maxSkills) {
-        const budget = applied.skillTokenBudget;
-        const { allowed, dropped } = enforceSkillBudget(loadedSkills, budget);
-        if (dropped.length > 0) {
-            renderer?.writeWarning(`  Skill limit (${maxSkills} max in ${modeConfig.id} mode): dropped ${dropped.join(", ")}`);
-            logInfo("LOOP", `skill limit: dropped ${dropped.join(", ")} (budget: ${budget} tokens)`);
-            loadedSkills.length = 0;
-            loadedSkills.push(...allowed);
-            for (const s of dropped)
-                loadedSkillNames.delete(s);
-        }
-    }
-    // Pre-load скиллов по ключевым словам (без language-specific хардкода)
-    if (loadedSkills.length === 0 && options?.mode !== "fast") {
-        const keywordSkills = preloadSkillsByKeywords(prompt, process.cwd());
-        for (const skill of keywordSkills) {
-            if (!loadedSkillNames.has(skill.name)) {
-                loadedSkills.push(skill);
-                loadedSkillNames.add(skill.name);
-                logInfo("LOOP", `keyword preloaded skill: ${skill.name}`);
-                renderer?.writeInfo(`  Auto-loaded @${skill.name} (keyword match)`);
-            }
-        }
-        // Если пользователь явно просит "используй скилл", но ничего не нашлось — подсказываем
-        if (keywordSkills.length === 0 && isSkillRequest(prompt)) {
-            const allSkills = listInstalledSkills(process.cwd());
-            renderer?.writeWarning(`  You asked for a skill but none matched. Use @skill-name in your prompt to load one. Installed: ${allSkills
-                .slice(0, 10)
-                .map((s) => "@" + s)
-                .join(", ")}... (${allSkills.length} total)`);
-        }
-    }
-    if (files.length > 0) {
-        const totalTokens = files.reduce((sum, f) => sum + f.tokens, 0);
-        const totalLines = files.reduce((sum, f) => sum + f.content.split("\n").length, 0);
-        logInfo("LOOP", `loaded ${files.length} files (${totalLines} lines, ~${totalTokens} tokens)`);
-        renderer?.writeInfo(`  Loaded ${files.length} files (${totalLines} lines, ~${totalTokens} tokens)`);
-    }
-    setStatusWriter(renderer ? (msg) => renderer.writeDim(`  ${msg}`) : null);
-    writeStatus("Initializing...");
-    // Сборка system prompt (включает инструкции, информацию о проекте, скилы, память)
-    const sysStart = performance.now();
-    const systemPrompt = buildSystemPrompt(loadedSkills.length > 0 ? loadedSkills : undefined, options?.mode, options?.flags);
-    const sysElapsed = ((performance.now() - sysStart) / 1000).toFixed(1);
-    writeStatus(`Done (${sysElapsed}s)`);
-    setStatusWriter(null);
-    // Начальное состояние истории: system prompt + предыдущие сообщения + текущий промпт
-    const messages = [
-        { role: "system", content: systemPrompt },
-        ...(previousMessages || []),
-        { role: "user", content: enrichedPrompt },
-    ];
-    const ctx = contextManager ?? new ContextManager(provider.contextWindow);
-    const maxSteps = config.agent.maxSteps ?? 100;
-    let consecutiveEmpty = 0; // счётчик пустых ответов подряд
-    let pendingSyntaxError = "";
-    let aborted = false;
-    let continuationNudges = 0; // счётчик подсказок "продолжай работать"
-    let consecutiveMissingGrounding = 0; // счётчик пропущенных grounding-маркеров подряд
-    let groundingRetryCount = 0; // сколько раз был CRITICAL retry подряд
-    let consecutiveInvalidCalls = 0; // счётчик невалидных tool call подряд
-    /** Счётчик бесполезных действий (list_dir, glob_search, todo list без результата) */
-    let uselessActionCount = 0;
-    /** Сколько шагов подряд модель не вызывает инструменты */
-    let consecutiveNoToolSteps = 0;
-    /** История последних чтений файлов для.detect повторных чтений */
-    const recentReadFiles = [];
-    /** История последних grep-запросов для detect повторных поисков */
-    const recentGrepPatterns = [];
-    /** История последних вопросов для detect повторных вопросов */
-    const recentQuestions = [];
-    /** История последних bash-команд для detect циклических вызовов */
-    const recentBashCommands = [];
-    // ─── ToolExecutor: единый диспетчер инструментов ──
-    const toolExecutor = new ToolExecutor();
-    toolExecutor.registerAll([
-        planHandler,
-        todoHandler,
-        questionHandler,
-        approveHandler,
-        userProfileHandler,
-        themeHandler,
-        scaffoldHandler,
-        projectMapHandler,
-        bashHandler,
-        readFileHandler,
-        writeFileHandler,
-        editFileHandler,
-        listDirHandler,
-        createDirHandler,
-        deleteFileHandler,
-        copyFileHandler,
-        moveFileHandler,
-        fileInfoHandler,
-        globSearchHandler,
-        grepSearchHandler,
-        treeHandler,
-        webSearchHandler,
-        webFetchHandler,
-        webBrowseHandler,
-    ]);
-    const errorEscalator = new ErrorEscalator();
-    const writeEnforcer = new WriteEnforcer();
-    const adapterPipeline = new AdapterPipeline();
-    /** Отслеживание созданных/изменённых файлов за всю сессию */
-    const createdFiles = [];
-    // Reset abort signal for this run
-    if (renderer?.abortSignal === undefined) {
-        // Renderer doesn't support abort — fine
-    }
-    renderer?.updateStatus({
-        provider: providerName,
-        model: provider.model,
-        contextWindow: provider.contextWindow,
-        step: 0,
-        maxSteps,
-    });
-    // ─── Основной цикл ReAct ────────────────────────────────
-    for (let step = 0; step < maxSteps; step++) {
-        if (renderer?.abortSignal?.aborted) {
-            aborted = true;
-            break;
-        }
-        let skillsAutoLoaded = false;
-        logDebug("LOOP", `step ${step + 1}/${maxSteps} starting, ${messages.length} messages`);
-        // Инкрементальный подсчёт — считаем только новые сообщения (быстрее в ~100x на больших историях)
-        if (step === 0) {
-            await ctx.updateTokens(messages);
-        }
-        else {
-            await ctx.updateTokensIncremental(messages);
-        }
-        const skillNames = loadedSkills.map((s) => s.name).join(", ");
-        const usageText = ctx.formatUsage() + (skillNames ? ` │ skills: ${skillNames}` : "");
-        renderer?.updateContextUsage(usageText);
-        renderer?.updateStatus({
-            provider: providerName,
-            model: provider.model,
-            tokens: ctx.totalTokens,
-            contextWindow: provider.contextWindow,
-            step: step + 1,
-            maxSteps,
-        });
-        // ─── Compaction контекста ─────────────────────────────
-        // Если использование контекста превышает порог (70%), компактируем историю
-        if (ctx.needsCompact && messages.length > 6) {
-            const before = messages.length;
-            messages.splice(0, messages.length, ...ctx.compact(messages));
-            if (!quiet) {
-                renderer?.writeBracketTag("compact", `${before} → ${messages.length} messages`);
-            }
-            await ctx.updateTokens(messages);
-        }
-        // ─── Emergency compact при переполнении контекста ─────
-        if (ctx.isOverflow) {
-            const before = messages.length;
-            messages.splice(0, messages.length, ...ctx.emergencyCompact(messages));
-            if (!quiet) {
-                renderer?.writeBracketTag("compact", `EMERGENCY: ${before} → ${messages.length}`);
-            }
-            await ctx.updateTokens(messages);
-        }
-        // ─── Запрос к LLM ────────────────────────────────────
-        const llmCfg = getLLMConfig(config);
-        logInfo("LOOP", `calling doChat, messages: ${messages.length}, options.showThinking: ${options?.showThinking}, retries: ${llmCfg.retries}`);
-        const { response } = await doChat(provider, messages, renderer, renderer?.abortSignal, llmCfg.retries, options?.showThinking);
-        // Проверка прерывания во время генерации
-        if (renderer?.abortSignal?.aborted) {
-            aborted = true;
-            break;
-        }
-        // ─── Автозагрузка скилов по @упоминаниям ─────────────
-        // Если ответ содержит @skill-name, загружаем скил и пересобираем system prompt
-        if (options?.mode !== "fast" && !skillsAutoLoaded) {
-            const suggestedSkillRefs = response.matchAll(/@(\w[\w-]*)/g);
-            const newSkillNames = [];
-            for (const match of suggestedSkillRefs) {
-                const name = match[1];
-                if ([
-                    "email",
-                    "api",
-                    "id",
-                    "json",
-                    "url",
-                    "http",
-                    "https",
-                    "localhost",
-                ].includes(name))
-                    continue;
-                if (!loadedSkillNames.has(name)) {
-                    const skill = loadSkill(name, process.cwd());
-                    if (skill) {
-                        newSkillNames.push(name);
-                        loadedSkills.push(skill);
-                        loadedSkillNames.add(name);
-                    }
-                }
-            }
-            if (newSkillNames.length > 0) {
-                skillsAutoLoaded = true;
-                // Применяем бюджет скилов после автозагрузки (Баг 1 fix)
-                const autoBudget = applied.skillTokenBudget;
-                if (autoBudget > 0 && loadedSkills.length > 0) {
-                    const { allowed, dropped } = enforceSkillBudget(loadedSkills, autoBudget);
-                    if (dropped.length > 0) {
-                        renderer?.writeWarning(`  Auto-load budget: dropped ${dropped.join(", ")} (budget: ${autoBudget} tokens)`);
-                        logInfo("LOOP", `auto-load budget: dropped ${dropped.join(", ")} (budget: ${autoBudget} tokens)`);
-                        loadedSkills.length = 0;
-                        loadedSkills.push(...allowed);
-                        for (const s of dropped)
-                            loadedSkillNames.delete(s);
-                    }
-                }
-                renderer?.writeInfo(`  Auto-loaded ${loadedSkills.filter((s) => newSkillNames.includes(s.name)).length} skill(s): ${newSkillNames.join(", ")}`);
-                messages[0] = {
-                    role: "system",
-                    content: buildSystemPrompt(loadedSkills, options?.mode, options?.flags),
-                };
-                // Не удаляем ответ ассистента — skills загружаются для следующих шагов цикла.
-                // Модель увидит обновлённый system prompt на следующей итерации и сможет
-                // использовать загруженные скилы без retry (экономит ~один LLM-запрос).
-            }
-        } // end fast-mode skill block
-        // ─── Обработка пустых ответов ────────────────────────
-        // Маленькие модели иногда возвращают пустой ответ — повторяем с подсказкой
-        if (!response.trim()) {
-            logWarn("LOOP", `empty response #${consecutiveEmpty + 1}`);
-            consecutiveEmpty++;
-            // После компактинга — более информативное сообщение о пустом ответе
-            if (ctx.compactCount > 0 && consecutiveEmpty <= 3) {
-                let lastUserMsg;
-                for (let i = messages.length - 1; i >= 0; i--) {
-                    if (messages[i].role === "user") {
-                        lastUserMsg = messages[i];
-                        break;
-                    }
-                }
-                const contextHint = lastUserMsg
-                    ? `[System: You returned an empty response. The conversation was compressed. Continue working on: "${(lastUserMsg.content || "").slice(0, 150)}..."]`
-                    : "[System: You returned an empty response. Continue with the task.]";
-                messages.push({ role: "user", content: contextHint });
-                if (!quiet) {
-                    renderer?.writeDim(`  [empty response, retrying with context hint]`);
-                }
-                continue;
-            }
-            const lastMsg = messages[messages.length - 1];
-            if ((lastMsg?.role === "user" || lastMsg?.role === "system") &&
-                consecutiveEmpty <= 2) {
-                // После system-сообщений (например "Skills loaded") — более конкретная подсказка
-                const isAfterSystem = lastMsg?.role === "system";
-                const hint = isAfterSystem
-                    ? "[System: You returned an empty response. The skills are loaded. Now create a plan and start working on the task. Do NOT wait for further instructions.]"
-                    : "Continue.";
-                messages.push({ role: "user", content: hint });
-                if (!quiet) {
-                    renderer?.writeDim(`  [empty response, retrying${isAfterSystem ? " with skills hint" : ""}]`);
-                }
-                continue;
-            }
-            renderer?.writeError(consecutiveEmpty > 3
-                ? `[model returned empty response ${consecutiveEmpty} times in a row — stopping]`
-                : "[model returned empty response]");
-            return { messages };
-        }
-        consecutiveEmpty = 0;
-        messages.push({ role: "assistant", content: response });
-        const { validCalls, invalidCalls } = parseToolCalls(response);
-        // ─── Adapter pipeline: чиним кривые вызовы маленьких моделей ──
-        const adapterLogs = [];
-        const adaptedCalls = [];
-        const adapterCtx = {
-            cwd: process.cwd(),
-            config,
-            responseText: response,
-            existingFiles: createdFiles,
-        };
-        for (const call of validCalls) {
-            const result = await adapterPipeline.process(call, adapterCtx);
-            if ("blocked" in result) {
-                invalidCalls.push(result.blocked);
-                if (!quiet)
-                    renderer?.writeError(`  [adapter blocked: ${result.blocked}]`);
-            }
-            else {
-                adaptedCalls.push(result.call);
-                adapterLogs.push(...result.logs);
-            }
-        }
-        // Заменяем validCalls на адаптированные
-        validCalls.length = 0;
-        validCalls.push(...adaptedCalls);
-        // Показываем логи адаптеров
-        if (adapterLogs.length > 0 && !quiet) {
-            for (const log of adapterLogs) {
-                renderer?.writeDim(`  ${log}`);
-            }
-        }
-        if (validCalls.length === 0) {
-            if (invalidCalls.length > 0) {
-                // If the response has substantial text outside tool_call tags,
-                // it's a description with examples — not a failed tool call attempt.
-                const textOutside = response
-                    .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "")
-                    .trim();
-                if (textOutside.length < 100) {
-                    consecutiveInvalidCalls++;
-                    const feedback = `[Tool call error(s)]\n${invalidCalls.join("\n")}\n\nFix the tool call format and try again. Use ONLY valid tool names: bash, read_file, write_file, edit_file, list_dir, create_dir, delete_file, copy_file, move_file, file_info, glob_search, grep_search, tree, web_search, web_fetch, web_browse, plan, todo, question, approve, subagent, scaffold.`;
-                    if (!quiet) {
-                        renderer?.writeError(`  [invalid tool call: ${invalidCalls[0]}]`);
-                    }
-                    messages.push({
-                        role: "tool",
-                        content: feedback,
-                        tool_call_id: `invalid-${Date.now()}`,
-                    });
-                    continue;
-                }
-                // Text response with example tool calls — just log and proceed
-                logWarn("LOOP", `ignored ${invalidCalls.length} invalid tool call(s) in descriptive text`);
-            }
-            // Nudge model to continue working after a tool result — but only if
-            // the agent didn't already write a meaningful text response.
-            if (continuationNudgeMax > 0 &&
-                continuationNudges < continuationNudgeMax) {
-                const lastThree = messages.slice(-3);
-                const hasRecentToolResult = lastThree.some((m) => m.role === "tool");
-                const alreadyResponded = response.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim()
-                    .length > 20;
-                if (hasRecentToolResult && !alreadyResponded) {
-                    continuationNudges++;
-                    if (!quiet) {
-                        renderer?.writeDim(`  [nudge ${continuationNudges}/${continuationNudgeMax}: continue working]`);
-                    }
-                    messages.push({
-                        role: "user",
-                        content: "[Tool result received. Write a response to the user. Do NOT call additional tools unless there is actual work to do.]",
-                    });
-                    continue;
-                }
-            }
-            // ─── Определение завершения: только по поведению, не по тексту ──────
-            // Смотрим: были ли хоть какие-то вызовы инструментов за сессию.
-            // Сообщения с role:tool — это результаты выполненных инструментов
-            // (кроме invalid — они с tool_call_id вида "invalid-...").
-            const hasDoneAnyWork = messages.some((m) => m.role === "tool" &&
-                m.tool_call_id &&
-                !m.tool_call_id.startsWith("invalid-"));
-            const planStatus = showPlan();
-            const hasActivePlan = !planStatus.startsWith("No active plan");
-            const pendingSteps = getPlanPendingCount();
-            // === 1. Незавершённый план ===
-            if (hasActivePlan && pendingSteps > 0) {
-                const planText = planStatus;
-                const pendingLines = planText
-                    .split("\n")
-                    .filter((l) => l.includes("○") || l.includes("►"));
-                const nextStep = pendingLines[0] || "";
-                const nextStepMatch = nextStep.match(/\d+\.\s*(.+)/);
-                const nextStepTitle = nextStepMatch ? nextStepMatch[1].trim() : "";
-                if (!quiet) {
-                    renderer?.writeWarning(`  [plan has ${pendingSteps} incomplete steps — pushing agent to continue]`);
-                }
-                const nudge = nextStepTitle
-                    ? `Plan is NOT complete! ${pendingSteps} step(s) remaining.\nNext step: ${nextStepTitle}\nUse subagent to execute this step, then mark done: plan({action:"done", step:N})`
-                    : `Plan is NOT complete! ${pendingSteps} step(s) remaining:\n${pendingLines.join("\n")}\n\nContinue with the next step using subagent.`;
-                messages.push({ role: "user", content: nudge });
-                continuationNudges = 0;
-                continue;
-            }
-            // === 2. План завершён — аудит файлов ===
-            // Проверка по createdFiles: если план выполнен, но ни одного файла
-            // не создано — скорее всего модель галлюцинирует выполнение шагов.
-            if (hasActivePlan && pendingSteps === 0) {
-                if (createdFiles.length === 0) {
-                    if (!quiet) {
-                        renderer?.writeWarning(`  [plan complete but no files created]`);
-                    }
-                    messages.push({
-                        role: "user",
-                        content: `Plan claims all steps done, but no files were created via write_file or subagent. Either execute the steps properly or explain why files aren't needed.`,
-                    });
-                    continuationNudges = 0;
-                    continue;
-                }
-                // Файлы созданы — выходим
-                return { messages };
-            }
-            // === 3. Нет активного плана ===
-            // Stuck detection (без изменений)
-            const isUselessAction = validCalls.some((c) => c.parsed.name === "list_dir" ||
-                c.parsed.name === "tree" ||
-                (c.parsed.name === "todo" && c.parsed.arguments?.action === "list") ||
-                (c.parsed.name === "question" && !c.parsed.arguments?.question));
-            let isRepeatedRead = false;
-            let isRepeatedSearch = false;
-            let isRepeatedQuestion = false;
-            let isRepeatedBash = false;
-            for (const c of validCalls) {
-                if (c.parsed.name === "read_file") {
-                    const filePath = String(c.parsed.arguments?.path || "");
-                    if (recentReadFiles.includes(filePath))
-                        isRepeatedRead = true;
-                    recentReadFiles.push(filePath);
-                    if (recentReadFiles.length > 5)
-                        recentReadFiles.shift();
-                }
-                if (c.parsed.name === "grep_search") {
-                    const pattern = String(c.parsed.arguments?.pattern || "");
-                    if (recentGrepPatterns.includes(pattern))
-                        isRepeatedSearch = true;
-                    recentGrepPatterns.push(pattern);
-                    if (recentGrepPatterns.length > 5)
-                        recentGrepPatterns.shift();
-                }
-                if (c.parsed.name === "question") {
-                    const questionText = String(c.parsed.arguments?.question || "");
-                    if (recentQuestions.includes(questionText))
-                        isRepeatedQuestion = true;
-                    recentQuestions.push(questionText);
-                    if (recentQuestions.length > 3)
-                        recentQuestions.shift();
-                }
-                if (c.parsed.name === "bash") {
-                    const cmdText = String(c.parsed.arguments?.cmd || "");
-                    const normalized = cmdText.trim().replace(/\s+/g, " ");
-                    if (recentBashCommands.includes(normalized))
-                        isRepeatedBash = true;
-                    recentBashCommands.push(normalized);
-                    if (recentBashCommands.length > 5)
-                        recentBashCommands.shift();
-                }
-            }
-            const isStuckAction = isUselessAction ||
-                isRepeatedRead ||
-                isRepeatedSearch ||
-                isRepeatedQuestion ||
-                isRepeatedBash;
-            if (isStuckAction) {
-                uselessActionCount++;
-                if (uselessActionCount >= 3) {
-                    if (!quiet) {
-                        renderer?.writeWarning(`  [agent stuck: ${uselessActionCount} useless actions]`);
-                    }
-                    clearPlan();
-                    messages.push({
-                        role: "user",
-                        content: `[System: You are stuck in a loop. STOP calling the same tool. The user already answered your question — use their answer and proceed with the task. Do NOT ask the same question again.]`,
-                    });
-                    uselessActionCount = 0;
-                    continuationNudges = 0;
-                    continue;
-                }
-            }
-            else {
-                consecutiveNoToolSteps = 0;
-                if (validCalls.some((c) => c.parsed.name === "subagent" ||
-                    c.parsed.name === "write_file" ||
-                    c.parsed.name === "bash")) {
-                    uselessActionCount = 0;
-                    recentReadFiles.length = 0;
-                    recentGrepPatterns.length = 0;
-                    recentQuestions.length = 0;
-                    recentBashCommands.length = 0;
-                }
-            }
-            // === 4. Выход: решение по поведению, а не по тексту ===
-            // 4a. Модель ничего не делала — поведенческий контроль
-            if (!hasDoneAnyWork) {
-                if (step > 0)
-                    consecutiveNoToolSteps++;
-                if (consecutiveNoToolSteps >= 2) {
-                    if (!quiet) {
-                        renderer?.writeWarning(`  [idle: ${consecutiveNoToolSteps} steps without any tool calls]`);
-                    }
-                    const idleSteps = consecutiveNoToolSteps;
-                    consecutiveNoToolSteps = 0;
-                    messages.push({
-                        role: "user",
-                        content: `[System: ты уже ${idleSteps} шага подряд не вызываешь инструменты. Если задача требует создания/изменения файлов — вызови write_file или edit_file. Если задача уже выполнена — напиши результат пользователю.]`,
-                    });
-                    continuationNudges = 0;
-                    continue;
-                }
-                // Первый ответ (step === 0) без инструментов — обычный диалог
-                return { messages };
-            }
-            // 4b. Модель что-то делала — проверяем созданные файлы перед выходом
-            if (createdFiles.length > 0) {
-                messages.push({
-                    role: "user",
-                    content: `Files created: ${createdFiles.join(", ")}. Before finishing — verify all files are complete and connected to each other. If any file is missing or not imported, continue working.`,
-                });
-                continuationNudges = 0;
-                continue;
-            }
-            // 4c. Модель работала, но не создавала файлы (читала, искала и т.д.)
-            return { messages };
-        }
-        // ─── Grounding check (ослаблен, агент больше не блокирует) ──
-        // Раньше grounding strict mode гонял модель по retry-циклу.
-        // Теперь grounding-fixer адаптер сам добавляет маркеры —
-        // grounding check только предупреждает, никогда не блокирует.
-        if (validCalls.length > 0) {
-            const groundingCfg = getGroundingConfig(config);
-            if (groundingCfg.enabled) {
-                const groundMatches = Array.from(response.matchAll(/@grounding\[файл:\s*([^\]]+)\]/g));
-                const groundPaths = groundMatches.map((m) => m[1].trim());
-                const pathCalls = validCalls.filter((c) => c.parsed.arguments?.path);
-                if (pathCalls.length > groundPaths.length) {
-                    consecutiveMissingGrounding++;
-                    if (!quiet)
-                        renderer?.writeDim(`  [grounding: ${consecutiveMissingGrounding} call(s) without marker — adapter handled]`);
-                }
-                else {
-                    consecutiveMissingGrounding = 0;
-                    groundingRetryCount = 0;
-                }
-            }
-        }
-        // ─── Enforce: лимиты на запись файлов ────────────────
-        // Отслеживание повторных чтений одного файла для консолидации
-        let lastReadFile = null;
-        writeEnforcer.enforceSingleWrite(validCalls, messages, quiet, renderer);
-        // ─── Исполнение tool calls ──────────────────────────
-        for (const call of validCalls) {
-            const { parsed, cmd } = call;
-            const isBash = parsed.name === "bash";
-            const preview = isBash
-                ? cmd.length > 200
-                    ? cmd.slice(0, 200) + "..."
-                    : cmd
-                : JSON.stringify(parsed.arguments);
-            const toolId = generateToolCallId();
-            logToolCall(parsed.name, preview);
-            if (!quiet) {
-                renderer?.writeToolHeader(parsed.name);
-                renderer?.writeToolPreview(parsed.name, preview);
-            }
-            const hookCmd = isBash
-                ? cmd
-                : `${parsed.name} ${JSON.stringify(parsed.arguments)}`;
-            const preHook = runPreToolUseHooks(process.cwd(), parsed.name, hookCmd);
-            if (!preHook.continue) {
-                if (!quiet) {
-                    renderer?.writeBracketTag("hook blocked", preHook.message || "");
-                }
-                messages.push({
-                    role: "tool",
-                    content: `Hook blocked: ${preHook.message || ""}`,
-                    tool_call_id: toolId,
-                });
-                continue;
-            }
-            if (pendingSyntaxError && !isBash) {
-                const isWriteOp = parsed.name === "write_file" || parsed.name === "edit_file";
-                const newPath = String(parsed.arguments.path ?? "");
-                // Allow editing config files (tsconfig.json, package.json) since they
-                // can fix syntax errors (e.g. missing jsx flag in tsconfig)
-                const isConfig = newPath === "tsconfig.json" || newPath === "package.json";
-                if (isWriteOp && newPath !== pendingSyntaxError && !isConfig) {
-                    const blocked = `BLOCKED: You have a syntax error in ${pendingSyntaxError}. Fix it first before writing new files. If the error is about jsx, module resolution, or missing types — edit tsconfig.json (it is exempt from this block).`;
-                    if (!quiet) {
-                        renderer?.writeError(`  [blocked: fix syntax error in ${pendingSyntaxError} first]`);
-                    }
-                    messages.push({
-                        role: "tool",
-                        content: blocked,
-                        tool_call_id: toolId,
-                    });
-                    continue;
-                }
-            }
-            let toolOutput = "";
-            let toolExitCode = 0;
-            const toolStart = performance.now();
-            // ─── Субагент: изолированный контекст для задачи ──
-            if (parsed.name === "subagent") {
-                const task = String(parsed.arguments.task || "");
-                if (!task) {
-                    toolOutput = "Error: task is required";
-                    toolExitCode = 1;
-                }
-                else {
-                    // Авто-пометка следующего pending шага как in_progress
-                    const nextPending = getNextPendingStep();
-                    if (nextPending) {
-                        updatePlanStep(nextPending.id, "in_progress");
-                    }
-                    // Phase 2.3: Авто-подстановка полного пути в задачу subagent
-                    let finalTask = task;
-                    if (nextPending) {
-                        const expectedDir = extractDirFromStepTitle(nextPending.title);
-                        if (expectedDir && !task.includes(expectedDir + "/")) {
-                            finalTask = `${task} (directory: ${expectedDir}/)`;
-                            logInfo("AGENT", `injected dir path into subagent task: "${expectedDir}"`);
-                        }
-                    }
-                    const autoContext = buildSubagentContext(process.cwd());
-                    logInfo("AGENT", `spawning subagent | task: "${finalTask.slice(0, 150)}"`);
-                    // Показываем спиннер на основном рендерере пока субагент работает
-                    if (!quiet) {
-                        const taskPreview = finalTask.length > 60
-                            ? finalTask.slice(0, 57) + "..."
-                            : finalTask;
-                        renderer?.writeSpinner(` [subagent] ${taskPreview}`);
-                    }
-                    const subRenderer = new SubagentRenderer();
-                    try {
-                        const childResult = await runIsolatedLoop(provider, registry, finalTask, autoContext, process.cwd(), quiet, subRenderer, toolExecutor, modeConfig.subagentMode, llmCfg.toolModel);
-                        toolOutput = childResult.summary;
-                        logInfo("AGENT", `subagent returned | files: ${childResult.createdFiles.length} | turns: ${childResult.turns} | errors: ${childResult.errors.length}`);
-                        if (childResult.createdFiles.length > 0) {
-                            for (const f of childResult.createdFiles) {
-                                if (!createdFiles.includes(f))
-                                    createdFiles.push(f);
-                            }
-                        }
-                        // Phase 2.1: Валидация путей созданных файлов
-                        if (nextPending && childResult.createdFiles.length > 0) {
-                            const expectedDir = extractDirFromStepTitle(nextPending.title);
-                            if (expectedDir) {
-                                const wrongDirFiles = childResult.createdFiles.filter((f) => !f.startsWith(expectedDir + "/") &&
-                                    !f.startsWith(expectedDir + "\\"));
-                                if (wrongDirFiles.length > 0) {
-                                    const correction = `⚠ Files created in wrong directory: ${wrongDirFiles.join(", ")}. ` +
-                                        `They should be in ${expectedDir}/. Use write_file with full path: ${expectedDir}/${wrongDirFiles[0]}`;
-                                    toolOutput += "\n\n" + correction;
-                                    if (!quiet) {
-                                        renderer?.writeWarning(`  [subagent created files in wrong directory: ${wrongDirFiles.join(", ")}]`);
-                                    }
-                                }
-                            }
-                        }
-                        const buf = subRenderer.getBuffer();
-                        if (!quiet && renderer?.writeToolBuffer) {
-                            renderer.writeToolBuffer({
-                                lines: buf.lines,
-                                toolCalls: buf.toolCalls,
-                            });
-                        }
-                    }
-                    catch (e) {
-                        toolOutput = `Subagent error: ${e.message}`;
-                        toolExitCode = 1;
-                        logError("AGENT", `subagent error: ${e.message}`);
-                    }
-                }
-                const subTime = ((performance.now() - toolStart) / 1000).toFixed(1);
-                if (!quiet) {
-                    renderer?.clearSpinner();
-                    renderer?.writeToolResult(subTime, toolExitCode, toolOutput.slice(0, 300));
-                }
-                // ─── MCP: внешние tool-серверы ────────────────────────
-            }
-            else if (isBash && isMCPCommand(cmd)) {
-                const mcpCmd = parseMCPCommand(cmd);
-                if (mcpCmd) {
-                    if (!quiet) {
-                        renderer?.writeBracketTag("mcp", `${mcpCmd.server}/${mcpCmd.tool}`);
-                    }
-                    toolOutput = callMCPTool(process.cwd(), mcpCmd.server, mcpCmd.tool, mcpCmd.args);
-                }
-                else {
-                    toolOutput =
-                        "Invalid MCP command. Format: mcp <server> <tool> [args_json]";
-                    toolExitCode = 1;
-                }
-                // ─── Все инструменты через ToolExecutor ──────────────
-            }
-            else {
-                // Определяем инструмент и аргументы для executor'а
-                let executorName = parsed.name;
-                let executorArgs = parsed.arguments;
-                // Bash-команды
-                if (isBash) {
-                    executorName = "bash";
-                    executorArgs = { cmd, timeout: parsed.arguments?.timeout ?? 120 };
-                }
-                const hookCmd = isBash
-                    ? cmd
-                    : `${parsed.name} ${JSON.stringify(parsed.arguments)}`;
-                const executorCall = {
-                    id: toolId,
-                    name: executorName,
-                    arguments: executorArgs,
-                };
-                const toolCtx = { cwd: process.cwd(), renderer, quiet };
-                const { result, elapsed } = await toolExecutor.execute(executorCall, toolCtx, hookCmd);
-                toolOutput = result.stdout || result.stderr || "(no output)";
-                toolExitCode = result.exitCode;
-                // Обработка question/approve: приостанавливаем цикл
-                if (result.questionPending) {
-                    messages.push({
-                        role: "tool",
-                        content: toolOutput,
-                        tool_call_id: toolId,
-                    });
-                    return {
-                        messages,
-                        questionPending: { question: toolOutput, choices: undefined },
-                    };
-                }
-            }
-            const toolTime = ((performance.now() - toolStart) / 1000).toFixed(1);
-            logToolOutput(parsed.name, toolOutput, toolExitCode);
-            logToolCall(parsed.name, preview, toolExitCode !== 0
-                ? `exit:${toolExitCode} ${toolOutput.slice(0, 100)}`
-                : `ok (${toolTime}s)`);
-            if (toolExitCode !== 0) {
-                const errText = toolOutput;
-                if (!quiet) {
-                    for (const line of errText.split("\n").slice(0, 5)) {
-                        renderer?.writeError(`  ${line}`);
-                    }
-                }
-            }
-            runPostToolUseHooks(process.cwd(), parsed.name, hookCmd, toolOutput, toolExitCode);
-            // Track sequential read_file calls for consolidation
-            if (readConsolidation &&
-                !isBash &&
-                parsed.name === "read_file" &&
-                toolExitCode === 0) {
-                const filePath = String(parsed.arguments.path ?? "");
-                const offset = Math.max(1, Number(parsed.arguments.offset ?? 1));
-                const limit = Math.max(1, Number(parsed.arguments.limit ?? 500));
-                if (lastReadFile &&
-                    lastReadFile.path === filePath &&
-                    offset === lastReadFile.offset + lastReadFile.limit) {
-                    // Sequential read — merge with previous result
-                    lastReadFile.content += "\n" + toolOutput;
-                    lastReadFile.offset = offset;
-                    lastReadFile.limit = limit;
-                    // Replace the last tool message content with merged content
-                    for (let i = messages.length - 1; i >= 0; i--) {
-                        if (messages[i].role === "tool" &&
-                            messages[i].tool_call_id === lastReadFile.toolId) {
-                            messages[i].content = lastReadFile.content;
-                            break;
-                        }
-                    }
-                    // Remove the trailing "Continue." nudge + the new tool result that would be pushed
-                    while (messages.length > 0 &&
-                        messages[messages.length - 1].role === "user" &&
-                        messages[messages.length - 1].content === "Continue.") {
-                        messages.pop();
-                    }
-                    if (!quiet) {
-                        renderer?.writeBracketTag("consolidate", `merged read_file chunks for ${filePath}`);
-                    }
-                    continue; // skip pushing this result separately
-                }
-                else {
-                    // New file or non-sequential — start fresh
-                    lastReadFile = {
-                        path: filePath,
-                        offset,
-                        limit,
-                        content: toolOutput,
-                        toolId,
-                    };
-                }
-            }
-            else if (!isBash && parsed.name !== "read_file") {
-                lastReadFile = null;
-            }
-            // ─── Проверка синтаксиса после записи файлов ────────
-            let hasSyntaxError = false;
-            if (toolExitCode === 0) {
-                const isWriteOp = isBash
-                    ? cmd.match(/Set-Content|Add-Content/)
-                    : parsed.name === "write_file" || parsed.name === "edit_file";
-                if (isWriteOp) {
-                    const rawPath = isBash
-                        ? cmd
-                            .match(/-Path\s+['"]?([^'"]+\.(?:ts|tsx|js|jsx|json))['"]?/i)?.[1]
-                            ?.replace(/\\/g, "/")
-                        : String(parsed.arguments.path ?? "");
-                    if (rawPath && /\.(ts|tsx|js|jsx|json)$/.test(rawPath)) {
-                        const filePath = isAbsolute(rawPath)
-                            ? relative(process.cwd(), rawPath).replace(/\\/g, "/")
-                            : rawPath;
-                        const syntaxResult = checkFileSyntax(filePath, process.cwd());
-                        if (syntaxResult !== "OK") {
-                            const errorLines = syntaxResult
-                                .split("\n")
-                                .filter((l) => l.trim());
-                            const shown = errorLines.slice(0, 3);
-                            const extra = errorLines.length > 3
-                                ? ` (+${errorLines.length - 3} more)`
-                                : "";
-                            if (!quiet) {
-                                renderer?.writeBracketTag("syntax", `${shown.join("; ")}${extra}`);
-                            }
-                            const fullPath = join(process.cwd(), filePath);
-                            let contextLines = "";
-                            try {
-                                const fileContent = readFileSync(fullPath, "utf-8").split("\n");
-                                for (const errLine of shown) {
-                                    const lineMatch = errLine.match(/\((\d+),\d+\)/);
-                                    if (lineMatch) {
-                                        const lineNum = parseInt(lineMatch[1]);
-                                        if (lineNum > 0 && lineNum <= fileContent.length) {
-                                            const start = Math.max(0, lineNum - 2);
-                                            const end = Math.min(fileContent.length, lineNum + 1);
-                                            contextLines += `\n--- Line ${lineNum} ---\n`;
-                                            for (let i = start; i < end; i++) {
-                                                const marker = i === lineNum - 1 ? " >> " : "    ";
-                                                contextLines += `${marker}${i + 1}: ${fileContent[i]}\n`;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch {
-                                /* ignore read errors */
-                            }
-                            toolOutput = `SYNTAX ERROR in ${filePath}:\n${syntaxResult}${contextLines}`;
-                            // Detect config-related TS errors (missing jsx, module issues, etc.)
-                            const isConfigError = syntaxResult.includes("TS17004") ||
-                                syntaxResult.includes("TS2307") ||
-                                syntaxResult.includes("Cannot find module") ||
-                                syntaxResult.includes("jsx") ||
-                                syntaxResult.includes("moduleResolution");
-                            if (isConfigError) {
-                                toolOutput += `\n\nThis looks like a tsconfig.json configuration issue, NOT a code syntax error.\nCheck tsconfig.json — you may need to add "jsx": "react-jsx" or fix module settings.\nDo NOT modify the source code to work around config errors. Edit tsconfig.json instead.`;
-                            }
-                            else {
-                                toolOutput += `\n\nDo NOT rewrite the entire file. Use edit_file to fix the specific broken line:\n{"name":"edit_file","arguments":{"path":"${filePath}","old_string":"broken code here","new_string":"fixed code here"}}`;
-                            }
-                            hasSyntaxError = true;
-                            pendingSyntaxError = filePath;
-                        }
-                        else {
-                            if (pendingSyntaxError === filePath) {
-                                pendingSyntaxError = "";
-                            }
-                        }
-                        // Track created/modified files for completion reporting
-                        if (!hasSyntaxError && !createdFiles.includes(filePath)) {
-                            createdFiles.push(filePath);
-                        }
-                    }
-                }
-            }
-            // Любой выполненный tool call сбрасывает счётчик бездействия
-            consecutiveNoToolSteps = 0;
-            messages.push({
-                role: "tool",
-                content: truncateOutput(parsed.name, toolOutput, toolExitCode),
-                tool_call_id: toolId,
-            });
-            // ─── Error escalation + specialist auto-delegation ──────────
-            if (toolExitCode !== 0 && toolOutput) {
-                const action = await errorEscalator.handleToolError(parsed.name, toolOutput, parsed.arguments, toolId, messages, createdFiles, enrichedPrompt, renderer, quiet, provider, registry, toolExecutor, modeConfig, llmCfg);
-                if (action === "continue")
-                    continue;
-            }
-            else {
-                errorEscalator.resetForTool(parsed.name);
-            }
-            // НЕ добавляем "Continue." после каждого tool-вызова — это нарушает
-            // структуру диалога. Bounded nudge (строка 418) уже покрывает
-            // случай когда модель застряла без tool-вызова.
-            if (hasSyntaxError) {
-                break;
-            }
-        }
-    }
-    if (aborted) {
-        renderer?.writeWarning("Agent stopped (double ESC)");
-    }
-    logInfo("LOOP", `runAgentLoop done: ${messages.length} total messages, aborted=${aborted}`);
-    // Agent:done notification
-    sendNotification("MMA", "Agent finished the task");
-    return { messages };
-}
-//# sourceMappingURL=loop.js.map