micro-models-agent 2.11.0 → 2.12.0

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

@@ -9,8 +9,9 @@ import { isTransientError } from "./transient-error";
 import { sleep } from "../../utils/sleep";
 import { backoffDelay } from "../../utils/retry";
 import { errMsg } from "../../utils";
+/** Макс. циклов расширения scope на подзадачу. */
 export const MAX_SCOPE_EXPANSION_CYCLES = 2;
-/** Uniform interrupt error recognized by the agent loop (err.name === "AbortError"). */
+/** Униформная ошибка прерывания для цикла агента (err.name === "AbortError"). */
 export function newAbortError() {
     const e = new Error(t("tool.aborted", { name: "MoE execution" }));
     e.name = "AbortError";
@@ -28,10 +29,11 @@ function buildErrorDetail(stuckDetector, baseError, lastError) {
     }
     if (lastError) {
         errorDetail +=
-            "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
+            `\n\n${t("exec.skills_hint")}`;
     }
     return errorDetail;
 }
+/** Топосорт подзадач в волны готовых (зависимости удовлетворены). Пусто при цикле. */
 export function topologicalSort(subtasks) {
     const sorted = [];
     const remaining = new Set(subtasks.map((s) => s.id));
@@ -95,6 +97,9 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
     let lastError = "";
     const stuckDetector = new StuckDetector(maxAttempts * 2, maxAttempts);
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        // Стабильный id между попытками: передача `attempt` ресетила состояние
+        // детектора на каждом ретрае (новый stepId → resetStepState), ошибки тулов
+        // не накапливались и exhausted-retries диагностика всегда пустовала.
         stuckDetector.recordIteration(1);
         try {
             const allowedFiles = subtask.allowed_files || [];
@@ -143,15 +148,15 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
             });
             if (result.success) {
                 if (deps.config.subagent?.resultMode === "file") {
-                    // Structured field from the subagent tool — locale-independent
-                    // (parsing the localized output string broke under ru).
+                    // Структурное поле из тула subagent — языконезависимо (парсинг
+                    // локализованной строки вывода ломался под ru).
                     const abs = result.artifactPath ?? "";
                     if (abs) {
                         const store = new ArtifactStore({
                             baseDir: deps.baseDir,
                             sessionId: deps.sessionId || "moe",
                         });
-                        const full = store.read(abs.split(/[\\/]/).pop() || ""); // file name only, scoped to root
+                        const full = store.read(abs.split(/[\\/]/).pop() || ""); // только имя файла, в jail root
                         deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
                         return {
                             subtaskId: subtask.id,
@@ -172,7 +177,7 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
             }
             lastError = result.output;
             stuckDetector.recordToolError("subagent", result.output);
-            // Inject actionable hints into the next retry's prompt
+            // Инжектим actionable-хинты в промпт следующего ретрая
             if (attempt < maxAttempts) {
                 const hints = stuckDetector.getActionableHints();
                 const recovery = stuckDetector.getRecoveryMessage();
@@ -186,10 +191,10 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
             if (isTransientError(lastError) && attempt < maxAttempts) {
                 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);
+                await sleep(delay, deps.signal);
                 continue;
             }
-            // Non-transient failure — build detailed error with hints
+            // Нетранзиентный фейл — собираем детальную ошибку с хинтами
             const errorDetail = buildErrorDetail(stuckDetector, result.output, lastError);
             return {
                 subtaskId: subtask.id,
@@ -204,15 +209,15 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
         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.
+            // Прерывание юзера (Esc) — НИКОГДА не транзиент: пробрасываем сразу, чтобы
+            // барьер волны и цикл агента увидели abort вместо ретрая.
             if (e?.name === "AbortError") {
                 throw e;
             }
             if (isTransientError(lastError) && attempt < maxAttempts) {
                 const delay = backoffDelay(attempt - 1, 1000, 8000);
                 deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: ${lastError}`);
-                await sleep(delay);
+                await sleep(delay, deps.signal);
                 continue;
             }
             const errorDetail = buildErrorDetail(stuckDetector, e.message, lastError);
@@ -226,7 +231,7 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
             };
         }
     }
-    // Exhausted retries — build detailed failure
+    // Ретраи исчерпаны — собираем итоговый фейл
     const stuckReason = stuckDetector.getStuckReason();
     let finalError = lastError;
     if (stuckReason) {
@@ -241,13 +246,14 @@ async function executeSubtask(subtask, deps, depResults, sharedContext, onUsage)
         durationMs: Date.now() - startTime,
     };
 }
+/** Исполнитель MoE-плана: волны, параллелизм, scope-ретраи, usage по тегам. */
 export class MoEExecutor {
     deps;
     usageByTag = new Map();
     constructor(deps) {
         this.deps = deps;
     }
-    /** Aggregated token usage per expert_tag across all executed subtasks. */
+    /** Агрегированный usage токенов по expert_tag всех исполненных подзадач. */
     getUsageByTag() {
         return Object.fromEntries(this.usageByTag);
     }
@@ -264,6 +270,14 @@ export class MoEExecutor {
         entry.subtasks += 1;
         this.usageByTag.set(expertTag, entry);
     }
+    /**
+     * Исполняет план волнами топосорта с капом параллелизма. Поддерживает
+     * селективный re-plan (skipIds + carriedResults). Abort (Esc) останавливает
+     * на барьере волны.
+     * @param opts.skipIds подзадачи, НЕ переисполняемые — их прошлые успешные
+     * результаты инжектятся как carriedResults, чтобы резолвились зависимости
+     * переисполняемых.
+     */
     async executePlan(plan, opts) {
         const skipIds = opts?.skipIds;
         const carried = opts?.carriedResults ?? [];
@@ -271,6 +285,12 @@ export class MoEExecutor {
         const errors = [];
         const warnings = [];
         const subtasks = skipIds && skipIds.size > 0 ? plan.subtasks.filter((s) => !skipIds.has(s.id)) : plan.subtasks;
+        // Селективный re-plan, где все подзадачи уже успешны: исполнять нечего.
+        // Раньше проваливалось в topologicalSort([]) и репортилось bogus
+        // "possible cycle", сжигая оставшиеся re-plan циклы.
+        if (subtasks.length === 0) {
+            return { success: true, results, errors: [], warnings };
+        }
         const waves = topologicalSort(subtasks);
         if (waves.length === 0) {
             return {
@@ -280,7 +300,7 @@ export class MoEExecutor {
                 warnings: [],
             };
         }
-        // Verify all subtasks are included — catch silent drops from unresolved dependencies
+        // Проверяем, что все подзадачи вошли — ловим молчаливые дропы от висячих зависимостей
         const sortedCount = waves.flat().length;
         if (sortedCount < subtasks.length) {
             const missing = subtasks
@@ -298,7 +318,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).
+            // Кап конкурентных подзадач на волну (rateLimits.maxParallelTasks, по умолчанию 5).
             const maxParallel = this.deps.config?.security?.rateLimits?.maxParallelTasks ?? 5;
             let active = 0;
             const waiters = [];
@@ -314,8 +334,8 @@ 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.
+                    // Проверяем после acquire: подзадачи, queued за летящей, не стартуют,
+                    // если Esc нажат посреди волны.
                     release();
                     throw newAbortError();
                 }
@@ -359,8 +379,8 @@ export class MoEExecutor {
                 return result;
             });
             await Promise.all(wavePromises);
-            // Wave barrier: once interrupted, stop before the next wave instead of
-            // starting new sub-agents after Esc.
+            // Барьер волны: при прерывании встаём перед следующей волной, а не
+            // стартуем новых сабагентов после Esc.
             if (this.deps.signal?.aborted)
                 throw newAbortError();
         }
@@ -377,13 +397,17 @@ export class MoEExecutor {
         };
     }
     /**
-     * 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.
+     * Scope-протокол (спек §Post-MVP): <scope-request> упавшего сабагента идёт
+     * роутеру; approve расширяет scope подзадачи и переисполняет ТОЛЬКО её,
+     * reject фейлит её (чинится полным re-plan). Расширение капировано, не
+     * автоматически.
      */
     async resolveScopeAndRetry(subtask, failed, depResults, sharedContext) {
         let current = failed;
+        // Расширение scope применяем к ЛОКАЛЬНОЙ копии: оригинальный объект плана
+        // остаётся неизменным для verifier/re-plan (иначе верификация видит scope,
+        // которого не было в утверждённом плане).
+        let scoped = subtask;
         for (let cycle = 0; cycle < MAX_SCOPE_EXPANSION_CYCLES; cycle++) {
             const req = current.scopeRequest;
             if (!req)
@@ -396,10 +420,13 @@ export class MoEExecutor {
                     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]);
+            scoped = {
+                ...scoped,
+                allowed_files: uniq([...(scoped.allowed_files || []), ...decision.write]),
+                read_only_files: uniq([...(scoped.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));
+            const retry = await executeSubtask(scoped, this.deps, depResults, sharedContext, (tag, usage) => this.recordUsage(tag, usage));
             if (retry.success || !retry.scopeRequest)
                 return retry;
             current = retry;