micro-models-agent 0.13.1 → 0.13.2

package/dist/cli/commands.js

@@ -6,11 +6,12 @@ import { t } from "../i18n/index";
 import { join } from "path";
 import { homedir } from "os";
 import { createSecurityCommand } from "./security-commands";
+import { version } from "../../package.json";
 export function createProgram() {
     const program = new Command()
         .name("mma")
         .description(t("cli.description"))
-        .version("0.4.0")
+        .version(version)
         .option("--no-agents-md", t("cli.no_agents_md"))
         .option("-d, --dir <path>", t("cli.dir"))
         .option("-e, --exit-on-complete", t("cli.exit_on_complete"))

package/dist/cli/repl.js

@@ -43,6 +43,7 @@ export class Repl {
     commands = new Map();
     completer = new Completer();
     running = false;
+    agentRunning = false;
     agent;
     config;
     sessionManager;
@@ -609,6 +610,15 @@ export class Repl {
         let inMultiLine = false;
         this.rl.on("line", async (line) => {
             const trimmed = line.trim();
+            if (this.agentRunning) {
+                if (trimmed) {
+                    this.history.push(trimmed);
+                    if (this.history.length > this.maxHistory) {
+                        this.history = this.history.slice(-this.maxHistory);
+                    }
+                }
+                return;
+            }
             if (trimmed) {
                 this.history.push(trimmed);
                 if (this.history.length > this.maxHistory) {
@@ -692,29 +702,41 @@ export class Repl {
         return false;
     }
     async runAgent(input) {
-        process.stdout.write("\n" + pc.green(t("repl.agent")));
-        const renderer = new Renderer({ spinner: this.config.ui?.spinner ?? true });
-        const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
-            if (ev.type === "start") {
-                renderer.toolStart(ev.tool, ev.args);
-            }
-            else {
-                renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error);
-            }
-        }, (phase) => {
-            if (phase === "thinking") {
-                renderer.thinkingStart();
+        if (this.agentRunning)
+            return;
+        this.agentRunning = true;
+        this.rl.pause();
+        try {
+            process.stdout.write("\n" + pc.green(t("repl.agent")));
+            const renderer = new Renderer({ spinner: this.config.ui?.spinner ?? true });
+            const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
+                if (ev.type === "start") {
+                    renderer.toolStart(ev.tool, ev.args);
+                }
+                else {
+                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error);
+                }
+            }, (phase) => {
+                if (phase === "thinking") {
+                    renderer.thinkingStart();
+                }
+                else {
+                    renderer.thinkingEnd();
+                }
+            });
+            renderer.flush();
+            process.stdout.write("\n");
+            if (!result.success) {
+                console.error(pc.red(`${t("error.prefix")}${result.error}`));
             }
-            else {
-                renderer.thinkingEnd();
+            this.showContextBar(result);
+        }
+        finally {
+            this.agentRunning = false;
+            if (this.running) {
+                this.rl.resume();
             }
-        });
-        renderer.flush();
-        process.stdout.write("\n");
-        if (!result.success) {
-            console.error(pc.red(`${t("error.prefix")}${result.error}`));
         }
-        this.showContextBar(result);
     }
     registerCommand(cmd) {
         this.commands.set(cmd.name, cmd);

package/dist/config/config.js

@@ -7,6 +7,13 @@ import { MigrationDetector } from '../migration/detect';
 import { BackupManager } from '../migration/backup';
 import { validateExpertConfig } from './experts';
 import { ConfigEncryptor } from '../modules/security/encryption';
+/**
+ * When the user's config version is older than this, force-overwrite
+ * the security bash settings with the current defaults.
+ * This ensures critical security changes (like operator allowlists)
+ * are applied even if the user has a saved config.
+ */
+const FORCE_SECURITY_UPDATE_VERSION = '2.1.0';
 /**
  * Restore RegExp instances in dangerousPatterns that were serialized as {}
  * (pre-0.8.0 configs) or as {__regex, source, flags} (new format).
@@ -115,6 +122,39 @@ function applyEnvVars(config) {
         result.moe = { ...result.moe, enabled: env.MMA_MOE_ENABLED === 'true' };
     return result;
 }
+/**
+ * Force-update security settings when upgrading from an older version.
+ * This overrides user config for critical security fields that must
+ * match the current code defaults (e.g. dangerousOperators).
+ */
+function forceSecurityUpdate(config) {
+    const userVersion = config.version || '0.0.0';
+    if (userVersion >= FORCE_SECURITY_UPDATE_VERSION)
+        return config;
+    // Force-overwrite bash security with current defaults
+    const security = config.security || {};
+    const userBash = security.bash || {};
+    security.bash = {
+        ...DEFAULT_SECURITY_CONFIG.bash,
+        // Keep user's custom blacklist additions, but ensure defaults are present
+        blacklist: [...new Set([
+                ...DEFAULT_SECURITY_CONFIG.bash.blacklist,
+                ...(userBash.blacklist || []),
+            ])],
+        whitelist: userBash.whitelist || DEFAULT_SECURITY_CONFIG.bash.whitelist,
+        dangerousFlags: [...new Set([
+                ...DEFAULT_SECURITY_CONFIG.bash.dangerousFlags,
+                ...(userBash.dangerousFlags || []),
+            ])],
+        // dangerousOperators: ALWAYS use defaults — user overrides are dangerous
+        dangerousOperators: [...DEFAULT_SECURITY_CONFIG.bash.dangerousOperators],
+        blockDangerousFlags: DEFAULT_SECURITY_CONFIG.bash.blockDangerousFlags,
+        logCommands: DEFAULT_SECURITY_CONFIG.bash.logCommands,
+    };
+    config.security = security;
+    console.log(t('migration.security_updated', { from: userVersion, to: FORCE_SECURITY_UPDATE_VERSION }));
+    return config;
+}
 export function loadConfig(options) {
     const globalPath = join(options.configDir, 'config.json');
     mkdirSync(options.configDir, { recursive: true });
@@ -146,6 +186,8 @@ export function loadConfig(options) {
     if (config.security?.contentScan?.dangerousPatterns) {
         config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
     }
+    // Force-update security settings when upgrading from older version
+    config = forceSecurityUpdate(config);
     config = applyEnvVars(config);
     // Decrypt sensitive fields in the loaded config
     try {

package/dist/config/defaults.js

@@ -76,7 +76,7 @@ export const DEFAULTS = {
             transport: "http",
             url: "https://mcp.context7.com/mcp",
             headers: {
-                CONTEXT7_API_KEY: "ctx7sk-f3dd1f44-bc3a-4f6b-94c0-87cacb6c084b",
+                CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY || "",
             },
             enabled: true,
             timeout: 30000,

package/dist/config/security.js

@@ -65,7 +65,7 @@ export const DEFAULT_SECURITY_CONFIG = {
             "--no-confirm",
         ],
         // Dangerous operators that are always blocked
-        dangerousOperators: [">", ">>", "2>", "2>>", "|", "&&", "||", ";", "&", "`"],
+        dangerousOperators: [">", ">>", "2>", "2>>", "&", "`"],
     },
     paths: {
         // Glob patterns for paths that are always denied

package/dist/core/agent-moe.js

@@ -0,0 +1,98 @@
+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";
+/**
+ * Execute the MoE (Mixture of Experts) path: plan → validate → execute → verify.
+ * 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);
+    if (!orchestrator.isEnabled()) {
+        logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
+        return fallback();
+    }
+    onMeta?.("🤖 Planning with MoE mode...\n");
+    onPhase?.("thinking");
+    const planResult = await orchestrator.plan(input);
+    onPhase?.("done");
+    if ("error" in planResult) {
+        logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
+        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();
+        }
+        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");
+    const 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,
+    });
+    onPhase?.("done");
+    const outputLines = [`## MoE Execution Results\n`];
+    for (const r of planResults.results) {
+        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 || ""}`);
+    }
+    const failedCount = planResults.results.filter((r) => !r.success).length;
+    return {
+        success: failedCount === 0 && verification.success,
+        text: outputLines.join("\n"),
+        iterationCount: planResults.results.length,
+    };
+}

package/dist/core/agent.js

@@ -1,11 +1,9 @@
 import { t } from "../i18n/index";
 import { pc } from "../ui/colors";
 import { PromptBuilder } from "./prompt-builder";
-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 { processRegistry } from "../modules/processes";
+import { SessionLogger } from "./session-logger";
+import { runWithMoE } from "./agent-moe";
 const TOOL_RESULT_MAX_TOKENS_RATIO = 0.3;
 const TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
 export class Agent {
@@ -15,9 +13,8 @@ export class Agent {
         this.deps = deps;
     }
     setScope() {
-        const executor = this.deps.toolExecutor;
-        if (executor && executor.ctx && this.deps.scope) {
-            executor.ctx.scope = this.deps.scope;
+        if (this.deps.scope) {
+            this.deps.toolExecutor.setScope(this.deps.scope);
         }
     }
     buildSystemPrompt() {
@@ -42,7 +39,6 @@ export class Agent {
         }
         return builder.build();
     }
-    /** Refresh the system prompt in context if dynamic blocks changed. */
     refreshSystemPrompt() {
         const { prompt } = this.buildSystemPrompt();
         const current = this.deps.contextManager
@@ -70,7 +66,8 @@ export class Agent {
     }
     async run(input, onChunk, onMeta, onTool, onPhase) {
         this.setScope();
-        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, } = this.deps;
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, } = this.deps;
+        const slog = new SessionLogger(sessionManager);
         if (sessionManager && !sessionManager.getActive()) {
             sessionManager.create();
             logger.debug(`Session started: ${sessionManager.getActive()}`);
@@ -80,19 +77,9 @@ export class Agent {
             const { prompt: systemPrompt, excluded } = this.buildSystemPrompt();
             contextManager.addMessage({ role: "system", content: systemPrompt });
             this.systemPromptAdded = true;
-            if (sessionManager) {
-                sessionManager.appendLog({
-                    ts: new Date().toISOString(),
-                    type: "system",
-                    content: systemPrompt.slice(0, 2000),
-                });
-                if (excluded.length > 0) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "system",
-                        content: `[Excluded prompt blocks: ${excluded.length}]`,
-                    });
-                }
+            slog.logSystem(systemPrompt.slice(0, 2000));
+            if (excluded.length > 0) {
+                slog.logSystem(`[Excluded prompt blocks: ${excluded.length}]`);
             }
             pluginManager.runOnSessionStart({
                 logger,
@@ -100,25 +87,21 @@ export class Agent {
             });
         }
         contextManager.addMessage({ role: "user", content: input });
-        if (sessionManager) {
-            sessionManager.appendMessage({
-                role: "user",
-                content: input,
-                timestamp: new Date().toISOString(),
-            });
-            sessionManager.appendLog({
-                ts: new Date().toISOString(),
-                type: "user",
-                content: input,
-            });
-        }
+        slog.logUser(input);
         if (config.moe?.enabled) {
-            return this.runWithMoE(input, onChunk, onMeta, onTool, onPhase);
+            return runWithMoE({
+                config,
+                llmProvider,
+                toolExecutor,
+                logger,
+                baseDir: this.deps.baseDir,
+            }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase), { onMeta, onTool, onPhase });
         }
         return this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase);
     }
     async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
         const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, } = this.deps;
+        const slog = new SessionLogger(sessionManager);
         let iteration = 0;
         let lastText = "";
         let hallucinationRetries = 0;
@@ -136,43 +119,19 @@ export class Agent {
             if (contextManager.needsCompaction()) {
                 contextManager.compact();
                 logger.debug("Context compacted");
-                if (sessionManager) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "compaction",
-                        content: `regular compaction, iteration ${iteration}`,
-                        iteration,
-                    });
-                }
+                slog.logCompaction(`regular compaction, iteration ${iteration}`, iteration);
             }
             const currentTokens = contextManager.getEstimatedTokens();
             const budget = contextManager.getBudget();
             if (currentTokens > budget.history) {
                 contextManager.compact();
                 logger.warn(`Context overflow (${currentTokens} > ${budget.history}), forced compaction`);
-                if (sessionManager) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "compaction",
-                        content: `forced compaction (${currentTokens} > ${budget.history}), iteration ${iteration}`,
-                        iteration,
-                        contextTokens: currentTokens,
-                        contextLimit: budget.history,
-                    });
-                }
+                slog.logCompaction(`forced compaction (${currentTokens} > ${budget.history}), iteration ${iteration}`, iteration, currentTokens, budget.history);
             }
             this.refreshSystemPrompt();
             const history = contextManager.getActiveHistory();
             const allTools = toolExecutor.getToolDefinitions(this.deps.toolTags);
-            if (sessionManager) {
-                sessionManager.appendLog({
-                    ts: new Date().toISOString(),
-                    type: "tool_defs",
-                    toolCount: allTools.length,
-                    toolNames: allTools.map((t) => t.name),
-                    iteration,
-                });
-            }
+            slog.logToolDefs(allTools.length, allTools.map((t) => t.name), iteration);
             let textContent = "";
             let reasoningContent = "";
             const toolCalls = [];
@@ -218,13 +177,7 @@ export class Agent {
             }
             catch (err) {
                 logger.error(`LLM call failed: ${err.message}`);
-                if (sessionManager) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "error",
-                        content: err.message,
-                    });
-                }
+                slog.logError(err.message);
                 pluginManager.runOnError({ iteration, logger }, err);
                 return {
                     success: false,
@@ -257,28 +210,8 @@ export class Agent {
                 }
                 lastToolSignature = signature;
             }
-            if (sessionManager) {
-                if (reasoningContent) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "reasoning",
-                        content: reasoningContent,
-                        iteration,
-                    });
-                }
-                if (sawToolCall) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "assistant",
-                        content: textContent || "",
-                        tool_calls: toolCalls.map((tc) => ({
-                            id: tc.id,
-                            name: tc.name,
-                            arguments: tc.arguments,
-                        })),
-                        iteration,
-                    });
-                }
+            if (sawToolCall) {
+                slog.logAssistant(textContent || "", reasoningContent, toolCalls, iteration);
             }
             if (sawToolCall) {
                 contextManager.addMessage({
@@ -303,16 +236,7 @@ export class Agent {
                     });
                     pluginManager.runOnToolStart({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments });
                     onTool?.({ type: "start", tool: call.name, args: call.arguments });
-                    if (sessionManager) {
-                        sessionManager.appendLog({
-                            ts: new Date().toISOString(),
-                            type: "tool_call",
-                            tool: call.name,
-                            tool_call_id: call.id,
-                            args: call.arguments,
-                            iteration,
-                        });
-                    }
+                    slog.logToolCall(call, iteration);
                     const result = await toolExecutor.execute(call);
                     const duration = Date.now() - startTime;
                     pluginManager.runOnToolEnd({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
@@ -341,24 +265,8 @@ export class Agent {
                         tool_call_id: call.id,
                     });
                     summaries.push(`[Tool: ${call.name} (${JSON.stringify(call.arguments)}) → ${truncatedOutput.slice(0, 200)}]`);
-                    if (sessionManager && config.session.autoSave) {
-                        sessionManager.appendMessage({
-                            role: "tool",
-                            content: truncatedOutput.slice(0, 500),
-                            name: call.name,
-                            timestamp: new Date().toISOString(),
-                        });
-                        sessionManager.appendLog({
-                            ts: new Date().toISOString(),
-                            type: "tool_result",
-                            tool: call.name,
-                            tool_call_id: call.id,
-                            success: result.success,
-                            content: result.output.slice(0, 1000),
-                            diff: result.diff,
-                            duration,
-                            iteration,
-                        });
+                    if (config.session.autoSave) {
+                        slog.logToolResult(call, result, duration, iteration);
                     }
                     if (contextManager.needsCompaction()) {
                         contextManager.compact();
@@ -423,39 +331,8 @@ export class Agent {
             }
             if (textContent) {
                 contextManager.addMessage({ role: "assistant", content: textContent });
-                if (sessionManager && config.session.autoSave) {
-                    sessionManager.appendMessage({
-                        role: "assistant",
-                        content: textContent.slice(0, 500),
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-            }
-            if (sessionManager) {
-                if (reasoningContent) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "reasoning",
-                        content: reasoningContent,
-                        iteration,
-                    });
-                }
-                if (textContent) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "assistant",
-                        content: textContent,
-                        iteration,
-                    });
-                }
-                else if (reasoningContent) {
-                    sessionManager.appendLog({
-                        ts: new Date().toISOString(),
-                        type: "assistant",
-                        content: reasoningContent,
-                        iteration,
-                    });
-                }
+                slog.saveAssistantMessage(textContent);
+                slog.logAssistant(textContent, reasoningContent, undefined, iteration);
             }
             lastText = textContent;
             if (!sawToolCall) {
@@ -471,14 +348,7 @@ export class Agent {
                                 steps,
                             })}</system-summary>`,
                         });
-                        if (sessionManager) {
-                            sessionManager.appendLog({
-                                ts: new Date().toISOString(),
-                                type: "audit",
-                                content: audit.summary,
-                                iteration,
-                            });
-                        }
+                        slog.logAudit(audit.summary, iteration);
                         if (iteration >= config.maxToolIterations - 1) {
                             break;
                         }
@@ -508,94 +378,6 @@ export class Agent {
             contextLimit: budget.history,
         };
     }
-    async runWithMoE(input, _onChunk, onMeta, onTool, onPhase) {
-        const { config, llmProvider, logger } = this.deps;
-        const orchestrator = new OrchestratorClient({
-            model: config.orchestrator.model,
-            provider: config.orchestrator.provider,
-        }, llmProvider);
-        if (!orchestrator.isEnabled()) {
-            logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
-            return this.executeSingleAgentLoop(input, _onChunk, onMeta, onTool, onPhase);
-        }
-        onMeta?.("🤖 Planning with MoE mode...\n");
-        this.emitPhase(0, "thinking", onPhase);
-        const planResult = await orchestrator.plan(input);
-        this.emitPhase(0, "done", onPhase);
-        if ("error" in planResult) {
-            logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
-            return this.executeSingleAgentLoop(input, _onChunk, onMeta, onTool);
-        }
-        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 this.executeSingleAgentLoop(input, _onChunk, onMeta, onTool);
-            }
-            Object.assign(plan, applied);
-            onMeta?.(`🔧 Auto-fixed ${validation.autoFixes.length} plan issues.\n`);
-        }
-        const moeDeps = {
-            config,
-            toolRegistry: this.deps.toolExecutor.registry,
-            toolExecutor: this.deps.toolExecutor,
-            llmProvider,
-            logger,
-            baseDir: this.deps.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(this.deps.baseDir);
-        const knownTags = [
-            "file",
-            "code",
-            "shell",
-            "research",
-            "browser",
-            "vision",
-            "core",
-        ];
-        const verification = await verifier.verifyMoEManifest(plan, config, knownTags);
-        this.emitPhase(0, "thinking", onPhase);
-        const 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,
-        });
-        this.emitPhase(0, "done", onPhase);
-        const outputLines = [`## MoE Execution Results\n`];
-        for (const r of planResults.results) {
-            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 || ""}`);
-        }
-        const failedCount = planResults.results.filter((r) => !r.success).length;
-        return {
-            success: failedCount === 0 && verification.success,
-            text: outputLines.join("\n"),
-            iterationCount: planResults.results.length,
-        };
-    }
     clearContext() {
         this.deps.contextManager.clear();
         this.systemPromptAdded = false;