micro-models-agent 0.63.0 → 1.1.0

package/dist/modules/execution/module.js

@@ -6,6 +6,7 @@ import { Auditor, findExistingFile } from "./auditor";
 import { PlanStore } from "./plan-store";
 import { getMessageText } from "../../llm/provider";
 import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
+import { toForwardSlash } from "../../tools/path-utils";
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { performWebSearch } from "../../tools/web-search";
@@ -19,6 +20,63 @@ import { createExecutionPlugin, STUCK_RECOVERY_COOLDOWN, STUCK_WARN_REPEAT_EVERY
  * time-based. Injectable via the constructor for tests (0 disables it).
  */
 const ERROR_SEARCH_MIN_INTERVAL_MS = 30000;
+/**
+ * Tools that may run while a plan step is active WITHOUT a step-alignment
+ * check. They either cannot touch the filesystem, or are structural/read-only
+ * inspection tools the agent legitimately needs at any point (diagnostics,
+ * index/search, memory, process introspection, interactive prompts). Only
+ * file-mutating tools are pinned to the current step's file tokens.
+ *
+ * `lsp_check` and `project_map` belong here explicitly: both are alwaysOn and
+ * the system prompt MANDATES `lsp_check` after every write (including rewrites
+ * of files owned by already-completed steps). Leaving them off the list made
+ * every diagnostic call burn a plan warning and could hard-block a legitimate
+ * write on the 3rd call (observed: "3 вызовов подряд вне текущего шага" while
+ * the agent was writing the current step's own deliverable).
+ */
+const PLAN_ALIGNMENT_EXEMPT_TOOLS = new Set([
+    // structural / execution control
+    "plan",
+    "todo",
+    "verify",
+    "enable_tools",
+    // filesystem reads
+    "list_dir",
+    "read_file",
+    "glob",
+    "grep",
+    "file_info",
+    // read-only diagnostics + code index
+    "lsp_check",
+    "project_map",
+    "chunk_query",
+    // web / memory / session reads
+    "web_search",
+    "web_fetch",
+    "web_browse",
+    "recall",
+    "search_history",
+    "session_info",
+    // process introspection
+    "process_list",
+    "process_log",
+    // interactive prompts (no filesystem mutation)
+    "question",
+    "approve",
+    // skills
+    "load_skill",
+]);
+/**
+ * Canonical form of a file token for plan alignment: forward slashes + lower
+ * case. Model tool calls pass absolute Windows paths
+ * (`C:\…\test\src\main.ts`) while plan steps name files relatively
+ * (`src/main.ts`); comparing the raw strings made every on-track write look
+ * off-path (backslash vs forward slash never intersects). Normalizing both
+ * sides lets the substring/`endsWith` overlap below match.
+ */
+function planPathToken(p) {
+    return toForwardSlash(p).toLowerCase();
+}
 export class ExecutionModule {
     name = "execution";
     tracker = null;
@@ -227,6 +285,34 @@ export class ExecutionModule {
      * Final audit before the agent may declare the task done. Returns null when
      * no plan is active; otherwise checks plan completion + artifact existence.
      */
+    /**
+     * Evidence-based auto-close of pending plan steps whose deliverables exist
+     * on disk. Small models routinely finish the actual work but forget the
+     * `plan update` bookkeeping (observed ses_mthn3c2a: 2/5 steps marked done
+     * while every artifact existed — the audit gate then rejected a correct
+     * final answer and burned all retry budget on bookkeeping, not on work).
+     *
+     * Standard is the SAME one the auditor already applies to done steps: every
+     * file-like token in the step description resolves to an existing file.
+     * Steps without any file token stay pending (nothing to verify).
+     */
+    autoCloseEvidenceSteps(plan) {
+        let closed = 0;
+        for (const step of plan.steps) {
+            if (step.status === "done" || step.status === "skipped")
+                continue;
+            const tokens = extractFileLikeTokens(stripUrls(step.description));
+            if (tokens.length === 0)
+                continue;
+            const allExist = tokens.every((f) => findExistingFile(this.baseDir, f) !== null);
+            if (!allExist)
+                continue;
+            step.status = "done";
+            step.note = `auto-closed by final audit: all named files exist (${tokens.join(", ")})`;
+            closed++;
+        }
+        return closed;
+    }
     async runFinalAudit() {
         // No active tracker: audit the last completed plan instead of bailing.
         // A plan finished via `plan update` auto-archives and clears the tracker;
@@ -236,9 +322,13 @@ export class ExecutionModule {
             if (!this.completedPlan)
                 return null;
             const plan = this.completedPlan;
+            const autoClosed = this.autoCloseEvidenceSteps(plan);
             const audit = await this.auditor.audit(plan);
             const pendingSteps = plan.steps.flatMap((s) => s.status !== "done" && s.status !== "skipped" ? [`${s.id}. ${s.description}`] : []);
             const done = plan.steps.filter((s) => s.status === "done").length;
+            if (autoClosed > 0) {
+                this.store.saveActive(plan);
+            }
             return {
                 passed: audit.passed && pendingSteps.length === 0,
                 done,
@@ -253,6 +343,10 @@ export class ExecutionModule {
             return null;
         }
         const plan = this.tracker.getPlan();
+        const autoClosed = this.autoCloseEvidenceSteps(plan);
+        if (autoClosed > 0) {
+            this.store.saveActive(plan);
+        }
         const audit = await this.auditor.audit(plan);
         const pendingSteps = plan.steps.flatMap((s) => s.status !== "done" && s.status !== "skipped" ? [`${s.id}. ${s.description}`] : []);
         const done = plan.steps.filter((s) => s.status === "done").length;
@@ -349,20 +443,9 @@ export class ExecutionModule {
         const step = this.tracker.getCurrentStep();
         if (!step)
             return null;
-        const allowedAlways = [
-            "plan",
-            "todo",
-            "verify",
-            "list_dir",
-            "read_file",
-            "glob",
-            "grep",
-            "file_info",
-            "load_skill",
-        ];
-        if (allowedAlways.includes(call.name))
+        if (PLAN_ALIGNMENT_EXEMPT_TOOLS.has(call.name))
             return null;
-        const stepPaths = extractFileLikeTokens(stripUrls(step.description)).map((p) => p.toLowerCase());
+        const stepPaths = extractFileLikeTokens(stripUrls(step.description)).map(planPathToken);
         if (stepPaths.length === 0)
             return null;
         // Only path-ish arguments are inspected. JSON-stringifying the whole args
@@ -370,7 +453,7 @@ export class ExecutionModule {
         // off-path check (e.g. `import "./styles.css"` inside the file body) and
         // raised phantom alignment warnings for on-track writes.
         const argStr = this.pathArgStrings(call.arguments).join(" ");
-        const callPaths = extractFileLikeTokens(stripUrls(argStr)).map((p) => p.toLowerCase());
+        const callPaths = extractFileLikeTokens(stripUrls(argStr)).map(planPathToken);
         if (callPaths.length === 0)
             return null;
         // Files that already belong to COMPLETED (done/skipped) steps are
@@ -381,15 +464,21 @@ export class ExecutionModule {
         for (const s of plan.steps) {
             if (s.status === "done" || s.status === "skipped") {
                 extractFileLikeTokens(stripUrls(s.description))
-                    .map((p) => p.toLowerCase())
+                    .map(planPathToken)
                     .forEach((p) => finishedPaths.add(p));
             }
         }
+        // Bidirectional path-token overlap, used for BOTH checks below. A step may
+        // name "main.ts" while the tool calls "src/main.ts" (or vice versa), so a
+        // one-directional `s.includes(p)` missed the common nested/partial case
+        // (observed: rewriting a completed step's src/main.ts was flagged as
+        // off-path for the current step and helped hard-block the third call).
+        const matchesAny = (p, tokens) => tokens.some((t) => t === p || t.includes(p) || p.includes(t));
+        const finished = [...finishedPaths];
         const offPath = callPaths.some((p) => {
-            if (finishedPaths.has(p) || [...finishedPaths].some((s) => s.includes(p))) {
+            if (matchesAny(p, finished))
                 return false;
-            }
-            return !stepPaths.some((s) => p.includes(s) || s.includes(p));
+            return !matchesAny(p, stepPaths);
         });
         if (!offPath)
             return null;

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

@@ -3,27 +3,34 @@ import { filterToolsByTags } from "../../tools/filter-tools";
 import { StuckDetector } from "./stuck-detector";
 import { t } from "../../i18n/index";
 import { ArtifactStore } from "../artifacts/store";
-const TRANSIENT_ERROR_PATTERNS = [
-    "timeout",
-    "Timeout",
-    "TIMEOUT",
-    "5xx",
-    "500",
-    "502",
-    "503",
-    "network",
-    "Network",
-    "ECONNREFUSED",
-    "ECONNRESET",
-    "fetch failed",
-    "abort",
-    "Abort",
-];
-function isTransientError(error) {
-    return TRANSIENT_ERROR_PATTERNS.some((p) => error.includes(p));
+import { buildInputSection } from "./input-from";
+import { parseScopeRequest } from "../../tools/scope-request";
+import { isTransientError } from "./transient-error";
+import { sleep } from "../../utils/sleep";
+import { backoffDelay } from "../../utils/retry";
+import { errMsg } from "../../utils";
+export const MAX_SCOPE_EXPANSION_CYCLES = 2;
+/** Uniform interrupt error recognized by the agent loop (err.name === "AbortError"). */
+export function newAbortError() {
+    const e = new Error(t("tool.aborted", { name: "MoE execution" }));
+    e.name = "AbortError";
+    return e;
 }
-function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+/**
+ * Сборка детального сообщения об ошибке подзадачи: базовый текст + подсказки
+ * stuck-детектора + совет про load_skill. Дублировался 2× в executeSubtask.
+ */
+function buildErrorDetail(stuckDetector, baseError, lastError) {
+    const hints = stuckDetector.getActionableHints();
+    let errorDetail = baseError;
+    if (hints.length > 0) {
+        errorDetail += `\n\n${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join("\n") })}`;
+    }
+    if (lastError) {
+        errorDetail +=
+            "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
+    }
+    return errorDetail;
 }
 export function topologicalSort(subtasks) {
     const sorted = [];
@@ -48,7 +55,7 @@ export function topologicalSort(subtasks) {
     }
     return sorted;
 }
-async function executeSubtask(subtask, deps, _sharedContext) {
+async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage) {
     const startTime = Date.now();
     const expertConfig = getExpertConfig(deps.config, subtask.expert_tag);
     if (!expertConfig) {
@@ -95,7 +102,11 @@ async function executeSubtask(subtask, deps, _sharedContext) {
             const scopePrompt = allowedFiles.length > 0 || readOnlyFiles.length > 0
                 ? `\n\nAllowed files to write: ${allowedFiles.join(", ") || "(none)"}\nRead-only files: ${readOnlyFiles.join(", ") || "(none)"}`
                 : "";
-            const taskPrompt = `${subtask.description}\n\nExpected output: ${subtask.expected_output}\nSuccess criteria:\n${(subtask.success_criteria || []).map((c) => `- ${c}`).join("\n")}${scopePrompt}`;
+            const sharedRules = sharedContext?.rules;
+            const sharedContextPrompt = sharedRules && sharedRules.length > 0
+                ? `\n\nShared rules:\n${sharedRules.map((r) => `- ${r}`).join("\n")}`
+                : "";
+            const taskPrompt = `${subtask.description}\n\nExpected output: ${subtask.expected_output}\nSuccess criteria:\n${(subtask.success_criteria || []).map((c) => `- ${c}`).join("\n")}${scopePrompt}${sharedContextPrompt}${buildInputSection(subtask, depResults, deps.config.subagent?.maxSummaryChars ?? 2000)}`;
             const subagentArgs = {
                 task: taskPrompt,
                 allowed_files: allowedFiles,
@@ -106,22 +117,39 @@ async function executeSubtask(subtask, deps, _sharedContext) {
                 subagentArgs.result_mode = "file";
                 subagentArgs.artifact_name = subtask.id;
             }
+            const subagentStart = Date.now();
+            deps.onTool?.({
+                type: "start",
+                tool: "subagent",
+                args: { subtask: subtask.id, description: subtask.description },
+            });
             const result = await subagentTool.handler({
                 config: deps.config,
                 baseDir: deps.baseDir,
                 logger: deps.logger,
                 llmProvider: deps.llmProvider,
                 toolExecutor: deps.toolExecutor,
-                sessionId: "moe",
+                sessionId: deps.sessionId || "moe",
             }, subagentArgs);
+            if (result.usage) {
+                onUsage?.(subtask.expert_tag, result.usage);
+            }
+            deps.onTool?.({
+                type: "end",
+                tool: "subagent",
+                args: { subtask: subtask.id, description: subtask.description },
+                duration: Date.now() - subagentStart,
+                error: !result.success,
+            });
             if (result.success) {
                 if (deps.config.subagent?.resultMode === "file") {
-                    const pathMatch = result.output.match(/saved to artifact: (.+)/);
-                    const abs = pathMatch ? pathMatch[1].trim() : "";
+                    // Structured field from the subagent tool — locale-independent
+                    // (parsing the localized output string broke under ru).
+                    const abs = result.artifactPath ?? "";
                     if (abs) {
                         const store = new ArtifactStore({
                             baseDir: deps.baseDir,
-                            sessionId: "moe",
+                            sessionId: deps.sessionId || "moe",
                         });
                         const full = store.read(abs.split(/[\\/]/).pop() || ""); // file name only, scoped to root
                         deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
@@ -156,48 +184,38 @@ async function executeSubtask(subtask, deps, _sharedContext) {
                 }
             }
             if (isTransientError(lastError) && attempt < maxAttempts) {
-                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+                const delay = backoffDelay(attempt - 1, 1000, 8000);
                 deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: transient error`);
                 await sleep(delay);
                 continue;
             }
             // Non-transient failure — build detailed error with hints
-            const hints = stuckDetector.getActionableHints();
-            let errorDetail = result.output;
-            if (hints.length > 0) {
-                errorDetail += `\n\n${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join("\n") })}`;
-            }
-            if (lastError) {
-                errorDetail +=
-                    "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
-            }
+            const errorDetail = buildErrorDetail(stuckDetector, result.output, lastError);
             return {
                 subtaskId: subtask.id,
                 success: false,
                 summary: `Failed: ${subtask.id}`,
                 result: result.output,
                 error: errorDetail,
+                scopeRequest: parseScopeRequest(result.output) ?? undefined,
                 durationMs: Date.now() - startTime,
             };
         }
         catch (e) {
             lastError = e.message;
             stuckDetector.recordToolError("subagent", e.message);
+            // User interrupt (Esc) is NEVER transient — propagate immediately so
+            // the wave barrier and the agent loop see the abort instead of retrying.
+            if (e?.name === "AbortError") {
+                throw e;
+            }
             if (isTransientError(lastError) && attempt < maxAttempts) {
-                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+                const delay = backoffDelay(attempt - 1, 1000, 8000);
                 deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: ${lastError}`);
                 await sleep(delay);
                 continue;
             }
-            const hints = stuckDetector.getActionableHints();
-            let errorDetail = e.message;
-            if (hints.length > 0) {
-                errorDetail += `\n\n${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join("\n") })}`;
-            }
-            if (lastError) {
-                errorDetail +=
-                    "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
-            }
+            const errorDetail = buildErrorDetail(stuckDetector, e.message, lastError);
             return {
                 subtaskId: subtask.id,
                 success: false,
@@ -225,14 +243,35 @@ async function executeSubtask(subtask, deps, _sharedContext) {
 }
 export class MoEExecutor {
     deps;
+    usageByTag = new Map();
     constructor(deps) {
         this.deps = deps;
     }
-    async executePlan(plan) {
-        const results = [];
+    /** Aggregated token usage per expert_tag across all executed subtasks. */
+    getUsageByTag() {
+        return Object.fromEntries(this.usageByTag);
+    }
+    recordUsage(expertTag, usage) {
+        const entry = this.usageByTag.get(expertTag) ?? {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            subtasks: 0,
+        };
+        entry.promptTokens += usage.promptTokens;
+        entry.completionTokens += usage.completionTokens;
+        entry.totalTokens += usage.totalTokens;
+        entry.subtasks += 1;
+        this.usageByTag.set(expertTag, entry);
+    }
+    async executePlan(plan, opts) {
+        const skipIds = opts?.skipIds;
+        const carried = opts?.carriedResults ?? [];
+        const results = carried.map((r) => ({ ...r }));
         const errors = [];
         const warnings = [];
-        const waves = topologicalSort(plan.subtasks);
+        const subtasks = skipIds && skipIds.size > 0 ? plan.subtasks.filter((s) => !skipIds.has(s.id)) : plan.subtasks;
+        const waves = topologicalSort(subtasks);
         if (waves.length === 0) {
             return {
                 success: false,
@@ -243,8 +282,8 @@ export class MoEExecutor {
         }
         // 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
+        if (sortedCount < subtasks.length) {
+            const missing = subtasks
                 .filter((s) => !waves.flat().some((w) => w.id === s.id))
                 .map((s) => s.id);
             return {
@@ -258,6 +297,7 @@ export class MoEExecutor {
         }
         for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
             const wave = waves[waveIdx];
+            const depResults = new Map(results.map((r) => [r.subtaskId, r]));
             // Cap concurrent subtasks per wave (rateLimits.maxParallelTasks, default 5).
             const maxParallel = this.deps.config?.security?.rateLimits?.maxParallelTasks ?? 5;
             let active = 0;
@@ -273,32 +313,104 @@ export class MoEExecutor {
             };
             const wavePromises = wave.map(async (subtask) => {
                 await acquire();
+                if (this.deps.signal?.aborted) {
+                    // Checked after acquiring so subtasks queued behind an in-flight one
+                    // never start once Esc was pressed mid-wave.
+                    release();
+                    throw newAbortError();
+                }
+                this.deps.onEvent?.({
+                    type: "moe_subtask",
+                    data: { subtaskId: subtask.id, expertTag: subtask.expert_tag, status: "start" },
+                });
                 let result;
                 try {
-                    result = await executeSubtask(subtask, this.deps, plan.shared_context);
+                    result = await executeSubtask(subtask, this.deps, depResults, plan.shared_context, (tag, usage) => this.recordUsage(tag, usage));
+                    if (!result.success && this.deps.onScopeRequest) {
+                        result = await this.resolveScopeAndRetry(subtask, result, depResults, plan.shared_context);
+                    }
                 }
                 catch (e) {
+                    if (e instanceof Error && e.name === "AbortError")
+                        throw e;
                     result = {
                         subtaskId: subtask.id,
                         success: false,
                         summary: `Unhandled error: ${subtask.id}`,
                         result: "",
-                        error: e instanceof Error ? e.message : String(e),
+                        error: errMsg(e),
                         durationMs: 0,
                     };
                 }
                 finally {
                     release();
                 }
+                this.deps.onEvent?.({
+                    type: "moe_subtask",
+                    data: {
+                        subtaskId: subtask.id,
+                        expertTag: subtask.expert_tag,
+                        status: result.success ? "done" : "failed",
+                        durationMs: result.durationMs,
+                        summary: result.summary,
+                    },
+                });
                 results.push(result);
                 return result;
             });
             await Promise.all(wavePromises);
+            // Wave barrier: once interrupted, stop before the next wave instead of
+            // starting new sub-agents after Esc.
+            if (this.deps.signal?.aborted)
+                throw newAbortError();
         }
         const failed = results.filter((r) => !r.success);
         if (failed.length > 0) {
             errors.push(...failed.map((f) => `[${f.subtaskId}] ${f.error || f.summary}`));
         }
-        return { success: failed.length === 0, results, errors, warnings };
+        return {
+            success: failed.length === 0,
+            results,
+            errors,
+            warnings,
+            ...(carried.length > 0 ? { carriedSubtaskIds: carried.map((r) => r.subtaskId) } : {}),
+        };
+    }
+    /**
+     * Scope expansion protocol (spec §Post-MVP): a failed sub-agent's
+     * <scope-request> goes to the Router; approve extends the subtask scope and
+     * re-executes ONLY this subtask, reject fails it (it can still be fixed by
+     * a full re-plan). Expansion is capped — never automatic.
+     */
+    async resolveScopeAndRetry(subtask, failed, depResults, sharedContext) {
+        let current = failed;
+        for (let cycle = 0; cycle < MAX_SCOPE_EXPANSION_CYCLES; cycle++) {
+            const req = current.scopeRequest;
+            if (!req)
+                return current;
+            const decision = await this.deps.onScopeRequest(subtask.id, req);
+            if (decision.action !== "approve") {
+                this.deps.logger.info?.(`MoE: router rejected scope request for "${subtask.id}" (${req.reason})`);
+                return {
+                    ...current,
+                    error: `${current.error}\nRouter rejected scope request for files: ${req.files.join(", ")}`,
+                };
+            }
+            subtask.allowed_files = uniq([...(subtask.allowed_files || []), ...decision.write]);
+            subtask.read_only_files = uniq([...(subtask.read_only_files || []), ...decision.read]);
+            this.deps.logger.info?.(`MoE: approved scope expansion for "${subtask.id}": +write [${decision.write.join(", ")}] +read [${decision.read.join(", ")}]`);
+            const retry = await executeSubtask(subtask, this.deps, depResults, sharedContext, (tag, usage) => this.recordUsage(tag, usage));
+            if (retry.success || !retry.scopeRequest)
+                return retry;
+            current = retry;
+        }
+        return {
+            ...current,
+            summary: `Failed after ${MAX_SCOPE_EXPANSION_CYCLES} scope expansions: ${subtask.id}`,
+            error: `${current.error}\nScope expansion limit (${MAX_SCOPE_EXPANSION_CYCLES}) reached`,
+        };
     }
 }
+function uniq(arr) {
+    return Array.from(new Set(arr));
+}