micro-models-agent 0.63.3 → 1.1.0

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

@@ -0,0 +1,237 @@
+import { pc } from "../../ui/colors";
+import { t } from "../../i18n/index";
+import { summarizeToolArgs, truncateToolOutput, compactToolError } from "./tool-output";
+import { errMsg } from "../../utils";
+import { MAX_CONSECUTIVE_TOOL_FAILURES, MIN_REPEATED_TOOL_FAILURES, } from "./constants";
+/**
+ * Выполнение пакета тулов, полученных от модели за одну итерацию.
+ *
+ * Отвечает за весь жизненный цикл тула:
+ * - запись assistant-сообщения с tool_calls в контекст и session log;
+ * - plugin-хуки (onToolCall, onToolStart, onToolEnd, onMeta);
+ * - событий UI (onTool start/end), вывод display/diff;
+ * - усечение результата под бюджет и запись role:"tool" сообщения;
+ * - синтез "[interrupted]" результатов для тулов без ответа (иначе
+ *   OpenAI-совместимые бэкенды отклоняют историю HTTP 400);
+ * - учёт неудач (последовательные + общие по тулам) и запись правил в память;
+ * - инъекцию <system-summary> с результатами и статусом плана.
+ *
+ * Не знает о структуре цикла — возвращает флаг `interrupted`, решение о
+ * `break`/`continue` принимает вызывающий цикл.
+ */
+export class ToolBatchExecutor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(state, toolCalls, boundedToolNames, textContent, reasoningContent, input, onTool, onMeta, slog) {
+        const { config, pluginManager, contextManager, logger } = this.deps;
+        const iteration = state.iteration;
+        slog?.logAssistant(textContent || "", reasoningContent, toolCalls, iteration);
+        contextManager.addMessage({
+            role: "assistant",
+            content: textContent || "",
+            tool_calls: toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                    name: tc.name,
+                    arguments: JSON.stringify(tc.arguments),
+                },
+            })),
+        });
+        const answeredToolCallIds = new Set();
+        // OpenAI-совместимые бэкенды (Jinja-шаблоны llama.cpp) отклоняют HTTP 400
+        // любую историю, где assistant(tool_calls) не завершён role:"tool"
+        // результатами для каждого call id — прерывание на середине пакета не
+        // должно оставлять висящую пару.
+        const synthesizePendingToolResults = () => {
+            for (const call of toolCalls) {
+                if (answeredToolCallIds.has(call.id))
+                    continue;
+                logger.debug(`Interrupted before tool ${call.name} (${call.id}) returned a result — synthesizing tool message`);
+                contextManager.addMessage({
+                    role: "tool",
+                    content: "[interrupted]",
+                    name: call.name,
+                    tool_call_id: call.id,
+                    success: false,
+                    arguments: call.arguments,
+                });
+            }
+        };
+        const summaries = [];
+        let anyToolFailed = false;
+        // Информационные read-only тулы, чей "фейл" — ожидаемое поведение
+        // (file_info "Not found" после delete_file) — исключены из учёта неудач.
+        const infoTools = new Set(["file_info"]);
+        for (const call of toolCalls) {
+            this.deps.setScope();
+            const startTime = Date.now();
+            pluginManager.runOnToolCall({
+                toolName: call.name,
+                args: call.arguments,
+            });
+            pluginManager.runOnToolStart({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments });
+            const toolIcon = this.deps.toolExecutor.getRegistry().get(call.name)?.icon;
+            onTool?.({ type: "start", tool: call.name, args: call.arguments, icon: toolIcon });
+            slog?.logToolCall(call, iteration);
+            const tokensBeforeTool = contextManager.getEstimatedTokens();
+            let result;
+            try {
+                result = await this.deps.toolExecutor.execute(call, this.deps.getAbortSignal());
+            }
+            catch (err) {
+                // Abort во время тула должен распространяться, чтобы сессия завершилась
+                // чисто. Любой ДРУГОЙ throw (баг тула/плагина, сбежавший из executor)
+                // не должен убивать сессию — деградируем до failed-результата.
+                if (err instanceof Error && err.name === "AbortError") {
+                    synthesizePendingToolResults();
+                    throw err;
+                }
+                logger.warn(`Tool ${call.name} threw: ${errMsg(err)}`);
+                result = {
+                    success: false,
+                    output: `${t("error.prefix")}${errMsg(err)}`,
+                    toolCallId: call.id,
+                };
+            }
+            // Прерывание во время тула: сессия уже завершается, останавливаемся
+            // сразу — без рендера, логов и обновления контекста для результата,
+            // который никто не увидит.
+            if (this.deps.isShutdownRequested())
+                break;
+            const duration = Date.now() - startTime;
+            if (!result.success && !result.blocked && !infoTools.has(call.name))
+                anyToolFailed = true;
+            if (result.success && call.name === "plan") {
+                const action = String(call.arguments.action ?? "");
+                if (action === "create" || action === "re-plan")
+                    state.iterPlanCreated = true;
+            }
+            if (result.success && call.arguments.path) {
+                const filePath = String(call.arguments.path);
+                if (call.name === "write_file" || call.name === "edit_file") {
+                    this.deps.hallucinationDetector.getConsistencyCheck().trackCreatedFile(filePath);
+                }
+                else if (call.name === "delete_file") {
+                    this.deps.hallucinationDetector.getConsistencyCheck().trackDeletedFile(filePath);
+                }
+            }
+            pluginManager.runOnToolEnd({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
+            // Проверка наличия, а не истинности: read_file возвращает display ""
+            // на полном чтении (заголовок уже показывает путь) — фолбэк на пустую
+            // строку вывалил бы всё содержимое файла в REPL.
+            if (result.display !== undefined) {
+                if (result.display.length > 0) {
+                    onMeta?.("\n" + result.display + "\n");
+                }
+            }
+            else if (result.success) {
+                const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
+                onMeta?.("\n" + pc.dim(metaOut) + "\n");
+            }
+            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)
+                    : "";
+                if (metaOut)
+                    onMeta?.("\n" + pc.red(metaOut) + "\n");
+            }
+            if (result.diff) {
+                onMeta?.("\n" + result.diff + "\n");
+            }
+            const currentTokens = contextManager.getEstimatedTokens();
+            const budget = contextManager.getBudget();
+            const truncatedOutput = truncateToolOutput(result.output, budget, currentTokens, boundedToolNames.has(call.name));
+            contextManager.addMessage({
+                role: "tool",
+                content: truncatedOutput,
+                name: call.name,
+                tool_call_id: call.id,
+                success: result.success,
+                blocked: result.blocked,
+                arguments: call.arguments,
+            });
+            answeredToolCallIds.add(call.id);
+            const tokensAfterTool = contextManager.getEstimatedTokens();
+            onTool?.({
+                type: "end",
+                tool: call.name,
+                args: call.arguments,
+                duration,
+                error: !result.success,
+                ctxDelta: tokensAfterTool - tokensBeforeTool,
+                costUsd: this.deps.costTracker.total,
+            });
+            summaries.push(`[Tool: ${call.name}${summarizeToolArgs(call.arguments)} → ${truncatedOutput.slice(0, 200)}]`);
+            if (config.session.autoSave) {
+                slog?.logToolResult(call, result, duration, iteration);
+            }
+            this.deps.compactionService.compactAfterTool(state);
+            // Учёт общих неудач (НЕ только подряд идущих): тул, который стабильно
+            // падает между успехами других тулов, всё равно учится (наблюдалось:
+            // LSP spawn npx ENOENT упал 8x за сессию, ни разу подряд — и не дошёл
+            // до памяти по пути "5 подряд неудач").
+            if (!result.success && !result.blocked && !infoTools.has(call.name)) {
+                const key = call.name;
+                const prev = state.toolFailureCounts.get(key) ?? { count: 0, error: "" };
+                prev.count++;
+                prev.error = String(result.output ?? "").slice(0, 200);
+                state.toolFailureCounts.set(key, prev);
+                if (prev.count >= MIN_REPEATED_TOOL_FAILURES && !state.memoryRuleRecorded.has(key)) {
+                    state.memoryRuleRecorded.add(key);
+                    const memStore = this.deps.memoryStore;
+                    if (memStore) {
+                        memStore.appendRule("errors", `Tool ${key} failed ${prev.count}x (${prev.error})`, `Repeated ${key} failures suggest a systemic problem (config, environment, or a broken tool), not a one-off`, "Check the error message, verify the tool's dependencies are installed/configured, and consider a different tool");
+                        logger.warn(`Recorded repeated ${key} failures to memory (${prev.count}x)`);
+                    }
+                }
+            }
+        }
+        if (this.deps.isShutdownRequested()) {
+            synthesizePendingToolResults();
+            return { interrupted: true };
+        }
+        // Последовательные неудачи: recovery-сообщение + правило в память.
+        if (anyToolFailed) {
+            state.consecutiveToolFailures++;
+            state.consecutiveToolSuccesses = 0;
+        }
+        else {
+            state.consecutiveToolFailures = 0;
+            state.consecutiveToolSuccesses++;
+        }
+        if (state.consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
+            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;
+            const taskReminder = t("exec.task_reminder", { task: taskSnippet });
+            contextManager.addMessage({
+                role: "user",
+                content: `<system-summary>${recoveryMsg}\n${taskReminder}</system-summary>`,
+            });
+            const memStore = this.deps.memoryStore;
+            if (memStore) {
+                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");
+            }
+        }
+        // Статусная строка плана после каждого пакета тулов. Заменяет динамический
+        // plan-блок, который жил в system prompt (удалён ради KV-cache — план
+        // меняется каждую итерацию).
+        const planLine = this.deps.planSummary?.();
+        if (planLine)
+            summaries.push(planLine);
+        contextManager.addMessage({
+            role: "user",
+            content: `<system-summary>${summaries.join("\n")}</system-summary>`,
+        });
+        return { interrupted: false };
+    }
+}

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

@@ -0,0 +1,62 @@
+import { t } from "../../i18n/index";
+import { TOOL_RESULT_MAX_TOKENS_RATIO, TOOL_RESULT_ABSOLUTE_MAX_CHARS, TOOL_ARGS_SUMMARY_MAX_CHARS, } from "./constants";
+/**
+ * Макс. число символов результата тула при заданном остатке бюджета и
+ * признаке того, что тул сам ограничивает свой вывод.
+ *
+ * Тулы с `boundedOutput` (например, read_file с лимитом строк) НИКОГДА не
+ * усекаются бюджетом — почти полный контекст раньше резал их до ~2K символов,
+ * и модель верила, что файлы обрезаны, перечитывая их бесконечно.
+ */
+export function toolOutputCharLimit(remainingBudget, historyBudget, bounded) {
+    if (bounded)
+        return Number.MAX_SAFE_INTEGER;
+    const maxCharsByRatio = Math.floor(historyBudget * TOOL_RESULT_MAX_TOKENS_RATIO * 2);
+    return Math.min(remainingBudget, maxCharsByRatio, TOOL_RESULT_ABSOLUTE_MAX_CHARS);
+}
+/** Усечение вывода тула под бюджет с честной пометкой о потере. */
+export function truncateToolOutput(output, budget, currentTokens, bounded) {
+    const remainingBudget = Math.max(0, budget.history - currentTokens);
+    const maxChars = toolOutputCharLimit(remainingBudget, budget.history, bounded);
+    if (output.length <= maxChars)
+        return output;
+    const truncated = output.slice(0, maxChars);
+    const removedChars = output.length - maxChars;
+    return truncated + `\n\n${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
+}
+/**
+ * JSON-сериализация аргументов тула для <system-summary>, ограниченная по
+ * размеру. Большой аргумент (content у write_file) не должен дублироваться в
+ * сводке поверх role:"tool" сообщения, которое уже несёт результат.
+ */
+export function summarizeToolArgs(args) {
+    let s;
+    try {
+        s = JSON.stringify(args);
+    }
+    catch {
+        s = String(args);
+    }
+    if (!s || s === "{}")
+        return "";
+    if (s.length <= TOOL_ARGS_SUMMARY_MAX_CHARS)
+        return ` (${s})`;
+    return ` (${s.slice(0, TOOL_ARGS_SUMMARY_MAX_CHARS)}…(${s.length} chars total))`;
+}
+/**
+ * Компактная пользовательская строка для упавшего тула.
+ *
+ * Полный `result.output` — это model-facing текст: хвост с Hint / recovery /
+ * "Do NOT …" инструкциями. В чат он попадать не должен: пользователю нужна
+ * суть ошибки (первая непустая строка), обрезанная по длине.
+ */
+export function compactToolError(output, max = 200) {
+    const text = String(output ?? "");
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        return trimmed.length > max ? `${trimmed.slice(0, max - 1)}…` : trimmed;
+    }
+    return "";
+}

package/dist/core/agent-moe.js

@@ -2,101 +2,246 @@ import { OrchestratorClient } from "../llm/orchestrator";
 import { validatePlan, applyAutoFixes } from "../modules/execution/plan-validator";
 import { MoEExecutor } from "../modules/execution/moe-executor";
 import { StepVerifier } from "../modules/execution/verifier";
+import { newAbortError } from "../modules/execution/moe-executor";
+import { t } from "../i18n/index";
+export const DEFAULT_MOE_MAX_REPLAN_CYCLES = 3;
 /**
- * Execute the MoE (Mixture of Experts) path: plan → validate → execute → verify.
+ * Execute the MoE (Mixture of Experts) path: plan → validate → execute → verify,
+ * with a re-plan loop driven by the orchestrator's verifyAndMerge decision.
  * Returns a fallback signal when MoE cannot proceed so the caller can fall
  * back to the single-agent loop.
  */
 export async function runWithMoE(deps, input, fallback, opts = {}) {
     const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
-    const { onMeta, onPhase } = opts;
-    const orchestrator = new OrchestratorClient({
-        model: config.orchestrator.model,
-        provider: config.orchestrator.provider,
-    }, llmProvider);
+    const { onMeta, onPhase, onTool, signal, onEvent, sessionId } = opts;
+    const emit = (type, data) => onEvent?.({ type, data });
+    const ensureNotAborted = () => {
+        if (signal?.aborted)
+            throw newAbortError();
+    };
+    // Orchestration one-liners are machine-facing: emit them to the chat only
+    // when the user opted into verbose UI (config.ui.verbose).
+    const verbose = config.ui?.verbose === true;
+    const status = (message) => {
+        if (verbose)
+            onMeta?.(message);
+    };
+    ensureNotAborted();
+    let orchestrator = deps.orchestratorOverride;
+    if (!orchestrator) {
+        orchestrator = new OrchestratorClient({
+            model: config.orchestrator.model,
+            provider: config.orchestrator.provider,
+            contextWindow: config.orchestrator.contextWindow,
+            retry: config.retry,
+            rateLimits: config.security?.rateLimits,
+            logger,
+            experts: config.experts,
+        }, llmProvider, { getSessionId: () => sessionId });
+    }
     if (!orchestrator.isEnabled()) {
-        logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
+        // Visible at default log level: a user who enabled moe.enabled must be
+        // able to tell why MoE never kicked in (missing orchestrator.model).
+        logger.warn("MoE enabled but no orchestrator model configured — falling back to single-agent. Set orchestrator.model to activate MoE.");
         return fallback();
     }
-    onMeta?.("🤖 Planning with MoE mode...\n");
+    status("🤖 Planning with MoE mode...\n");
     onPhase?.("thinking");
-    const planResult = await orchestrator.plan(input);
+    const planResult = await orchestrator.plan(input, undefined, signal);
     onPhase?.("done");
     if ("error" in planResult) {
         logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
+        emit("moe_plan", { status: "error", error: planResult.error });
         return fallback();
     }
-    const { plan } = planResult;
-    onMeta?.(`📋 Plan created: "${plan.title}" (${plan.subtasks.length} subtasks)\n`);
-    const validation = validatePlan(plan, config);
-    if (!validation.valid) {
-        const applied = applyAutoFixes(plan, validation.autoFixes);
-        const retry = validatePlan(applied, config);
-        if (!retry.valid) {
-            logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")} — falling back to single-agent`);
-            onMeta?.(`⚠️ Plan validation failed. Falling back to single-agent mode.\n`);
-            return fallback();
+    emit("moe_plan", {
+        status: "ok",
+        title: planResult.plan.title,
+        subtaskIds: planResult.plan.subtasks.map((s) => s.id),
+    });
+    const maxCycles = Math.max(1, config.moe?.maxReplanCycles ?? DEFAULT_MOE_MAX_REPLAN_CYCLES);
+    const mergedResults = new Map();
+    let currentPlan = planResult.plan;
+    const usageByTag = {};
+    for (let cycle = 1; cycle <= maxCycles; cycle++) {
+        ensureNotAborted();
+        if (cycle > 1) {
+            status(t("moe.replan_started", { cycle, max: maxCycles }) + "\n");
+            emit("moe_replan", {
+                cycle,
+                title: currentPlan.title,
+                subtaskIds: currentPlan.subtasks.map((s) => s.id),
+            });
         }
-        Object.assign(plan, applied);
-        onMeta?.(`🔧 Auto-fixed ${validation.autoFixes.length} plan issues.\n`);
-    }
-    const moeDeps = {
-        config,
-        toolRegistry: toolExecutor.getRegistry(),
-        toolExecutor,
-        llmProvider,
-        logger,
-        baseDir,
-    };
-    const executor = new MoEExecutor(moeDeps);
-    onMeta?.(`⚙️ Executing ${plan.subtasks.length} subtasks...\n`);
-    const planResults = await executor.executePlan(plan);
-    onMeta?.(`✅ Execution complete: ${planResults.results.filter((r) => r.success).length}/${planResults.results.length} succeeded\n`);
-    const verifier = new StepVerifier(baseDir);
-    const knownTags = ["file", "code", "shell", "research", "browser", "vision", "core"];
-    const verification = await verifier.verifyMoEManifest(plan, config, knownTags);
-    onPhase?.("thinking");
-    let verifyResult;
-    try {
-        verifyResult = await orchestrator.verifyAndMerge({
-            plan,
-            results: planResults.results.map((r) => ({
-                subtaskId: r.subtaskId,
-                success: r.success,
-                summary: r.summary,
-                result: r.result,
-                error: r.error,
-            })),
-            verifierErrors: verification.errors,
-            verifierWarnings: verification.warnings,
+        // Validate every plan before executing it — never trust an LLM-produced
+        // plan, including re-plans produced by verifyAndMerge.
+        const validation = validatePlan(currentPlan, config);
+        if (!validation.valid) {
+            const applied = applyAutoFixes(currentPlan, validation.autoFixes);
+            const retry = validatePlan(applied, config);
+            if (!retry.valid) {
+                logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")}`);
+                if (cycle === 1) {
+                    status(`⚠️ Plan validation failed. Falling back to single-agent mode.\n`);
+                    return fallback();
+                }
+                return partialFailure(mergedResults, retry.errors.join("; "));
+            }
+            currentPlan = applied;
+            if (validation.autoFixes.length > 0) {
+                status(`🔧 Auto-fixed ${validation.autoFixes.length} plan issues.\n`);
+            }
+        }
+        const executor = deps.executorOverride ??
+            new MoEExecutor({
+                config,
+                toolRegistry: toolExecutor.getRegistry(),
+                toolExecutor,
+                llmProvider,
+                logger,
+                baseDir,
+                onTool,
+                sessionId,
+                onEvent: (e) => emit(e.type, e.data),
+                onScopeRequest: async (subtaskId, req) => {
+                    const decision = await orchestrator.resolveScopeRequest(subtaskId, req, signal);
+                    if (decision.action === "approve") {
+                        status(t("moe.scope_approved", {
+                            subtask: subtaskId,
+                            files: [...decision.write, ...decision.read].join(", "),
+                        }) + "\n");
+                    }
+                    else {
+                        status(t("moe.scope_rejected", { subtask: subtaskId }) + "\n");
+                    }
+                    return decision;
+                },
+            });
+        status(t("moe.executing", { count: String(currentPlan.subtasks.length), cycle: String(cycle) }) + "\n");
+        // Selective re-plan (Plan 5.1): subtasks already successfully executed in
+        // an earlier cycle are carried over — only failed/new ones re-execute.
+        const skipIds = new Set();
+        const carriedResults = [];
+        for (const s of currentPlan.subtasks) {
+            const prev = mergedResults.get(s.id);
+            if (prev?.success) {
+                skipIds.add(s.id);
+                carriedResults.push(prev);
+            }
+        }
+        for (const id of skipIds) {
+            emit("moe_subtask", { subtaskId: id, status: "carried", cycle });
+        }
+        const planResults = await executor.executePlan(currentPlan, { skipIds, carriedResults });
+        ensureNotAborted();
+        const cycleUsage = executor.getUsageByTag?.();
+        if (cycleUsage) {
+            for (const [tag, usage] of Object.entries(cycleUsage)) {
+                const agg = usageByTag[tag] ?? {
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    subtasks: 0,
+                };
+                agg.promptTokens += usage.promptTokens;
+                agg.completionTokens += usage.completionTokens;
+                agg.totalTokens += usage.totalTokens;
+                agg.subtasks += usage.subtasks;
+                usageByTag[tag] = agg;
+            }
+        }
+        for (const r of planResults.results) {
+            mergedResults.set(r.subtaskId, r);
+        }
+        const succeeded = [...mergedResults.values()].filter((r) => r.success).length;
+        status(`✅ ${t("moe.execution_complete", { succeeded: String(succeeded), total: String(mergedResults.size) })}\n`);
+        const verifier = deps.verifierOverride ??
+            new StepVerifier(baseDir);
+        const knownTags = collectKnownToolTags(toolExecutor);
+        const verification = await verifier.verifyMoEManifest(currentPlan, config, knownTags);
+        onPhase?.("thinking");
+        ensureNotAborted();
+        let verifyResult;
+        try {
+            verifyResult = await orchestrator.verifyAndMerge({
+                plan: currentPlan,
+                results: [...mergedResults.values()].map((r) => ({
+                    subtaskId: r.subtaskId,
+                    success: r.success,
+                    summary: r.summary,
+                    result: r.result,
+                    error: r.error,
+                })),
+                verifierErrors: verification.errors,
+                verifierWarnings: verification.warnings,
+            }, signal);
+        }
+        catch (err) {
+            onPhase?.("done");
+            if (err?.name === "AbortError")
+                throw err;
+            emit("moe_verify", { status: "error", error: err.message });
+            return {
+                success: false,
+                text: `MoE verifyAndMerge crashed: ${err.message}`,
+                error: err.message,
+                iterationCount: mergedResults.size,
+            };
+        }
+        onPhase?.("done");
+        emit("moe_verify", {
+            decision: verifyResult.type,
+            explanation: verifyResult.explanation,
+            usageByTag: Object.keys(usageByTag).length > 0 ? usageByTag : undefined,
         });
+        if (verifyResult.type === "final") {
+            return buildFinalResult(mergedResults, verification.success, verifyResult);
+        }
+        if (!verifyResult.plan || !Array.isArray(verifyResult.plan.subtasks)) {
+            // Verifier asked for a re-plan but produced none usable — stop honestly.
+            return partialFailure(mergedResults, verifyResult.explanation || "re-plan requested but no plan returned");
+        }
+        currentPlan = verifyResult.plan;
     }
-    catch (err) {
-        onPhase?.("done");
-        return {
-            success: false,
-            text: `MoE verifyAndMerge crashed: ${err.message}`,
-            error: err.message,
-            iterationCount: 0,
-        };
+    return partialFailure(mergedResults, t("moe.cycles_exhausted", { max: String(maxCycles) }));
+}
+function collectKnownToolTags(toolExecutor) {
+    const tags = new Set();
+    for (const tool of toolExecutor.getRegistry().getAll()) {
+        for (const tag of tool.tags || [])
+            tags.add(tag);
     }
-    onPhase?.("done");
+    return Array.from(tags);
+}
+function buildFinalResult(mergedResults, verificationSuccess, verifyResult) {
     const outputLines = [`## MoE Execution Results\n`];
-    for (const r of planResults.results) {
+    for (const r of mergedResults.values()) {
         const icon = r.success ? "✅" : "❌";
         outputLines.push(`${icon} **${r.subtaskId}**: ${r.summary} (${r.durationMs}ms)`);
     }
     outputLines.push("");
-    if (verifyResult.type === "final") {
-        outputLines.push(`**Result:** ${verifyResult.finalAnswer || "Complete"}`);
-    }
-    else {
-        outputLines.push(`**Re-plan requested:** ${verifyResult.explanation || ""}`);
+    outputLines.push(`**Result:** ${verifyResult.finalAnswer || "Complete"}`);
+    const failedCount = [...mergedResults.values()].filter((r) => !r.success).length;
+    return {
+        success: failedCount === 0 && verificationSuccess,
+        text: outputLines.join("\n"),
+        iterationCount: mergedResults.size,
+        moeHandled: true,
+    };
+}
+function partialFailure(mergedResults, reason) {
+    const outputLines = [`## MoE Execution Results\n`];
+    for (const r of mergedResults.values()) {
+        const icon = r.success ? "✅" : "❌";
+        outputLines.push(`${icon} **${r.subtaskId}**: ${r.summary} (${r.durationMs}ms)`);
     }
-    const failedCount = planResults.results.filter((r) => !r.success).length;
+    outputLines.push("");
+    outputLines.push(`**${t("moe.partial_result")}:** ${reason}`);
     return {
-        success: failedCount === 0 && verification.success,
+        success: false,
         text: outputLines.join("\n"),
-        iterationCount: planResults.results.length,
+        error: reason,
+        iterationCount: mergedResults.size,
+        moeHandled: true,
     };
 }