micro-models-agent 0.13.1 → 0.13.3

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,48 +119,25 @@ 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 = [];
             let sawToolCall = false;
             let emittedReasoning = false;
+            const textChunks = [];
             this.emitPhase(iteration, "thinking", onPhase);
             try {
                 for await (const chunk of llmProvider.chat(history, allTools)) {
@@ -186,8 +146,7 @@ export class Agent {
                             onMeta?.("\n\n");
                         }
                         textContent += chunk.content;
-                        const textOut = pluginManager.runOnText({ iteration, logger }, chunk.content);
-                        onChunk?.(textOut);
+                        textChunks.push(chunk.content);
                     }
                     if (chunk.type === "reasoning" && chunk.content) {
                         reasoningContent += chunk.content;
@@ -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,
@@ -236,6 +189,15 @@ export class Agent {
             finally {
                 this.emitPhase(iteration, "done", onPhase);
             }
+            // Display buffered text only if no tool call in this response.
+            // When a tool call is present, text is just the model describing
+            // its tool call (e.g. raw JSON args) — suppress it.
+            if (!sawToolCall && textChunks.length > 0) {
+                for (const chunk of textChunks) {
+                    const textOut = pluginManager.runOnText({ iteration, logger }, chunk);
+                    onChunk?.(textOut);
+                }
+            }
             let llmResponse = null;
             if (sawToolCall) {
                 llmResponse = { type: "tool_call", calls: toolCalls };
@@ -257,28 +219,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 +245,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 +274,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 +340,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 +357,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 +387,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;

package/dist/core/bootstrap.js

@@ -22,7 +22,7 @@ import { MCPModule } from "../modules/mcp/index";
 import { setLocale } from "../i18n/index";
 import { Agent } from "./agent";
 import { homedir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 function buildSystemInfo(config, baseDir, profileCompressed) {
     const now = new Date().toISOString().replace("T", " ").slice(0, 19);
@@ -45,7 +45,7 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
         `- Do not duplicate code, logic, or configuration (DRY — Don't Repeat Yourself). Extract shared logic into a single place, reuse existing utilities and patterns before writing new ones.`,
     ];
     if (isWin) {
-        lines.push(`OS-specific: You are on Windows. Do not use Unix-only command flags like "mkdir -p". Use the create_dir tool to create directories.`);
+        lines.push(``, `Windows environment — use Windows-compatible commands:`, `- Use "dir" instead of "ls". Use "dir /b" for bare listing.`, `- Use "type" or "Get-Content" instead of "cat".`, `- Use "cd" instead of "pwd". Use "echo %cd%" to print working directory.`, `- Use "copy" instead of "cp", "move" instead of "mv", "del" instead of "rm".`, `- Do not use "mkdir -p" — Windows mkdir creates intermediate dirs by default. Use the create_dir tool instead.`, `- Use forward slashes (/) or escaped backslashes (\\\\) in file paths.`, `- Your working directory is: ${baseDir}`);
     }
     if (config.autoPlan) {
         lines.push(``, `Plan rule: For any task with 2+ steps, create a plan first using the "plan" tool. After each step, call "plan update" to mark progress. Stay focused on the current step.`);
@@ -110,7 +110,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
         retry: config.retry,
         rateLimits: config.security?.rateLimits,
     });
-    const baseDir = projectDir || process.cwd();
+    const baseDir = projectDir ? resolve(projectDir) : process.cwd();
     const projectMapCacheDir = join(baseDir, ".mma");
     const indexerModule = new IndexerModule({
         baseDir,
@@ -191,6 +191,7 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     toolCtx.trackReadPath = (p) => factualCheck.trackReadPath(p);
     toolCtx.trackCreatedPath = (p) => factualCheck.trackCreatedPath(p);
     toolCtx.trackDeletedPath = (p) => factualCheck.trackDeletedPath(p);
+    toolCtx.trackDocumentContent = (c) => factualCheck.trackDocumentContent(c);
     const moduleRegistry = new ModuleRegistry();
     const execModule = new ExecutionModule(baseDir, config.stuckThreshold);
     moduleRegistry.register(execModule);

package/dist/core/session-logger.js

@@ -0,0 +1,122 @@
+/**
+ * Thin wrapper around SessionManager that eliminates repetitive
+ * `if (sessionManager)` + `new Date().toISOString()` boilerplate
+ * from the agent loop.
+ */
+export class SessionLogger {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    get active() {
+        return !!this.session?.getActive();
+    }
+    logSystem(content) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "system",
+            content,
+        });
+    }
+    logUser(content) {
+        this.session?.appendMessage({
+            role: "user",
+            content,
+            timestamp: new Date().toISOString(),
+        });
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "user",
+            content,
+        });
+    }
+    logAssistant(content, reasoning, toolCalls, iteration) {
+        if (reasoning) {
+            this.session?.appendLog({
+                ts: new Date().toISOString(),
+                type: "reasoning",
+                content: reasoning,
+                iteration,
+            });
+        }
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "assistant",
+            content,
+            ...(toolCalls
+                ? { tool_calls: toolCalls.map((tc) => ({ id: tc.id, name: tc.name, arguments: tc.arguments })) }
+                : {}),
+            iteration,
+        });
+    }
+    saveAssistantMessage(content) {
+        this.session?.appendMessage({
+            role: "assistant",
+            content: content.slice(0, 500),
+            timestamp: new Date().toISOString(),
+        });
+    }
+    logToolDefs(toolCount, toolNames, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_defs",
+            toolCount,
+            toolNames,
+            iteration,
+        });
+    }
+    logToolCall(call, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_call",
+            tool: call.name,
+            tool_call_id: call.id,
+            args: call.arguments,
+            iteration,
+        });
+    }
+    logToolResult(call, result, duration, iteration) {
+        this.session?.appendMessage({
+            role: "tool",
+            content: result.output.slice(0, 500),
+            name: call.name,
+            timestamp: new Date().toISOString(),
+        });
+        this.session?.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,
+        });
+    }
+    logCompaction(content, iteration, contextTokens, contextLimit) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "compaction",
+            content,
+            iteration,
+            ...(contextTokens !== undefined ? { contextTokens } : {}),
+            ...(contextLimit !== undefined ? { contextLimit } : {}),
+        });
+    }
+    logError(message) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "error",
+            content: message,
+        });
+    }
+    logAudit(summary, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "audit",
+            content: summary,
+            iteration,
+        });
+    }
+}

package/dist/i18n/en.json

@@ -411,6 +411,7 @@
     "migration.dir_bak": "- .mma/ \u2192 .mma.bak/ ({count} files)",
     "migration.migrated": "Migrated:",
     "migration.not_needed": "No migration needed",
+    "migration.security_updated": "[MMA] Security config force-updated from v{from} to v{to} (dangerous operators reset to defaults)",
     "ui.error_prefix": "Error: ",
     "ui.success_prefix": "\u2713 ",
     "ui.warning_prefix": "\u26a0 ",

package/dist/i18n/ru.json

@@ -411,6 +411,7 @@
     "migration.dir_bak": "- .mma/ → .mma.bak/ ({count} файлов)",
     "migration.migrated": "Мигрировано:",
     "migration.not_needed": "Миграция не требуется",
+    "migration.security_updated": "[MMA] Конфигурация безопасности принудительно обновлена с v{from} до v{to} (опасные операторы сброшены)",
     "ui.error_prefix": "Ошибка: ",
     "ui.success_prefix": "✓ ",
     "ui.warning_prefix": "⚠ ",

package/dist/llm/openai-compat.js

@@ -201,13 +201,15 @@ export class OpenAICompatProvider {
             });
             if (!response.ok) {
                 const errorText = await response.text();
-                console.error("[doNonStreaming] HTTP error:", response.status, errorText.slice(0, 500));
-                return [];
+                throw new Error(t("error.llm_api", {
+                    status: response.status,
+                    statusText: response.statusText,
+                    errorText: errorText.slice(0, 500),
+                }));
             }
             const data = await response.json();
             const choice = data.choices?.[0];
             if (!choice) {
-                console.error("[doNonStreaming] No choices in response");
                 return [];
             }
             const msg = choice.message || {};
@@ -230,15 +232,10 @@ export class OpenAICompatProvider {
                     });
                 }
             }
-            console.error("[doNonStreaming] chunks:", chunks.length, "tool_calls:", msg.tool_calls?.length, "content len:", msg.content?.length);
-            if (chunks.length === 0) {
-                console.error("[doNonStreaming] Empty response: no content, no tool_calls, no reasoning");
-            }
             return chunks;
         }
         catch (err) {
-            console.error("[doNonStreaming] Fetch error:", err instanceof Error ? err.message : String(err));
-            return [];
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     countTokens(text) {

package/dist/modules/execution/moe-executor.js

@@ -163,6 +163,19 @@ export class MoEExecutor {
         if (waves.length === 0) {
             return { success: false, results: [], errors: ['Failed to topologically sort subtasks (possible cycle)'], warnings: [] };
         }
+        // Verify all subtasks are included — catch silent drops from unresolved dependencies
+        const sortedCount = waves.flat().length;
+        if (sortedCount < plan.subtasks.length) {
+            const missing = plan.subtasks
+                .filter(s => !waves.flat().some(w => w.id === s.id))
+                .map(s => s.id);
+            return {
+                success: false,
+                results: [],
+                errors: [`Missing subtasks after topological sort: ${missing.join(', ')} (dangling or invalid depends_on)`],
+                warnings: [],
+            };
+        }
         for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
             const wave = waves[waveIdx];
             const wavePromises = wave.map(subtask => executeSubtask(subtask, this.deps, plan.shared_context)