micro-models-agent 2.10.0 → 2.12.0

package/dist/modules/execution/execution-plugin.js

@@ -6,25 +6,25 @@ import { toForwardSlash } from "../../tools/path-utils";
 import { platform } from "os";
 import { switchStepToDelete } from "./plan-steps";
 /**
- * Cooldown (in iterations) between stuck-recovery injections. Exported so the
- * ExecutionModule can seed its state's lastRecoveryIteration with the same
- * offset the plugin compares against.
+ * Кулдаун (в итерациях) между инжектами stuck-восстановления. Экспортируется,
+ * чтобы ExecutionModule сидировал state.lastRecoveryIteration тем же офсетом,
+ * с которым плагин сравнивает.
  */
 export const STUCK_RECOVERY_COOLDOWN = 5;
 const MAX_PLAN_WARNINGS_BEFORE_BLOCK = 3;
 const FORCE_SKIP_THRESHOLD = 10;
-/** Re-log the SAME stuck-warning key at most every N iterations (a new key
- *  always logs immediately). Prevents the identical warning from flooding
- *  every iteration (ses_mt4fn58c: "Tool bash failed N times" after ~30
- *  successful writes, "No write/exec" on every read). */
+/** Один и тот же stuck-варнинг перелоггируем не чаще каждых N итераций (новый
+ *  ключ — всегда сразу). Не даёт идентичному варнингу флудить каждую итерацию
+ *  (было в ses_mt4fn58c: "Tool bash failed N times" после ~30 успешных записей,
+ *  "No write/exec" на каждом чтении). */
 export const STUCK_WARN_REPEAT_EVERY = 5;
-/** How many file-mutating tool calls (write/edit/bash/download) without an
- *  active plan trigger the plan-creation nudge. Evidence-based (rule #10):
- *  the agent is clearly working on files, so a plan is warranted. */
+/** Сколько файл-мутирующих вызовов (write/edit/bash/download) без активного
+ *  плана триггерит nudge создания плана. Evidence-based (правило #10):
+ *  агент явно работает с файлами — план оправдан. */
 const PLAN_NUDGE_THRESHOLD = 2;
-/** Tools whose success can have changed the filesystem — the plan auto-advance
- *  re-checks the current step's deliverables after them. Read-only tools are
- *  deliberately excluded (see the onAfterTool advance call below). */
+/** Тулы, чей успех мог поменять ФС — после них перепроверяем deliverables
+ *  текущего шага для автопродвижения. Read-only осознанно исключены (см. вызов
+ *  advance в onAfterTool ниже). */
 const FS_MUTATING_TOOLS = new Set([
     "write_file",
     "edit_file",
@@ -41,8 +41,8 @@ const FS_MUTATING_TOOLS = new Set([
 function normalizeBrokenPath(p) {
     return toForwardSlash(p).replace(/^\.\//, "");
 }
-/** Parse a tsc / bun build / node --check error line into its file path.
- *  Returns null when the line carries no file anchor (e.g. `error: Could not
+/** Парсит строку ошибки tsc / bun build / node --check в путь файла.
+ *  Null, если в строке нет привязки к файлу (напр. `error: Could not
  *  resolve "..."`). */
 export function parseBrokenFile(line) {
     const trimmed = line.trim();
@@ -56,9 +56,9 @@ export function parseBrokenFile(line) {
         return normalizeBrokenPath(bn[1]);
     return null;
 }
-/** Extract per-file compile failures from a write/edit result output. Only
- *  the marker lines are inspected (`[Project typecheck failed]: <line>` /
- *  `[Syntax check failed]: <line>`) so a diff body can never false-positive. */
+/** Вытаскивает пофайловые compile-фейлы из вывода write/edit. Смотрит только
+ *  строки-маркеры (`[Project typecheck failed]: <line>` /
+ *  `[Syntax check failed]: <line>`), чтобы тело диффа не давало ложных. */
 export function extractBrokenFiles(output) {
     const out = [];
     for (const line of output.split("\n")) {
@@ -75,6 +75,7 @@ function resetStepFlags(state, stepId) {
     state.consecutivePlanWarnings = 0;
     state.lastStepId = stepId;
     state.stuckNotified = false;
+    state.escalationDirectiveSent = false;
 }
 /** Полный сброс состояния плана (завершён или его нет). */
 function resetPlanState(state) {
@@ -83,14 +84,14 @@ function resetPlanState(state) {
     state.stuckNotified = false;
     state.mutationsWithoutPlan = 0;
     state.planNudgeSent = false;
+    state.escalationDirectiveSent = false;
 }
 /**
- * Gate for `plan update status=done`: refuse while the last write/edit still
- * reports a compile error. A failure with no file anchor blocks the whole
- * project; otherwise a step's named file tokens are matched against the
- * broken files (path-suffix match, case-insensitive). A step naming no files
- * cannot be blamed — its done stays vacuous. Returns the first error to show
- * the model, or null to allow the done.
+ * Гейт для `plan update status=done`: реджектит, пока последний write/edit
+ * репортит compile-ошибку. Фейл без привязки к файлу блокирует весь проект;
+ * иначе именованные токены файлов шага матчатся против битых (суффикс пути,
+ * регистронезависимо). Шаг без файлов обвинить не в чем — его done остаётся
+ * vacuous. Возвращает первую ошибку для показа модели, или null чтобы пустить.
  */
 export function stepTypecheckGate(failures, stepDescription) {
     if (failures.size === 0)
@@ -109,28 +110,27 @@ export function stepTypecheckGate(failures, stepDescription) {
     return null;
 }
 /**
- * The execution plugin hooks, extracted verbatim from ExecutionModule.getPlugin().
- * All shared mutable state (pendingMessages, forbiddenBashFailures, state,
- * tracker) is owned by the module and mutated by reference through `deps`.
+ * Хуки execution-плагина, вынесенные дословно из ExecutionModule.getPlugin().
+ * Всё разделяемое мутабельное состояние (pendingMessages, forbiddenBashFailures,
+ * state, tracker) принадлежит модулю и мутируется по ссылке через `deps`.
  */
 export function createExecutionPlugin(deps) {
     return {
         name: "execution",
         onBeforeThink: (ctx) => {
-            // Flush deferred <system-summary> messages first so they are visible
-            // to the next model call but never interleave tool messages.
+            // Отложенные <system-summary> флашим первыми: видны следующему вызову
+            // модели, но не interleav'ят tool-сообщения.
             if (ctx.contextManager && deps.pendingMessages.length > 0) {
                 for (const m of deps.pendingMessages.splice(0)) {
                     ctx.contextManager.addMessage(m);
                 }
             }
             if (deps.trackerRef.current?.isComplete()) {
-                // All steps done/skipped — stop counting "no progress" against
-                // the last step and silence step-stuck warnings for a finished
-                // plan, BUT keep the tool-call history so a read-without-write
-                // loop is still caught (observed: plan complete + false-positive
-                // audit → the model re-read files for 50+ iterations with zero
-                // writes and no recovery hint).
+                // Все шаги done/skipped — перестаём считать "no progress" против
+                // последнего шага и глушим step-stuck варнинги готового плана, НО
+                // историю вызовов храним, чтобы петля чтения-без-записи ловилась
+                // (было: план готов + ложноположительный аудит → модель 50+ итераций
+                // перечитывала файлы с нулем записей без recovery-хинта).
                 deps.stuckDetector.resetStepProgress();
                 resetPlanState(deps.state);
             }
@@ -147,12 +147,15 @@ export function createExecutionPlugin(deps) {
                     deps.state.planNudgeSent = false;
                 }
                 else {
-                    deps.stuckDetector.reset();
+                    // До-плана: историю цикла (свежие вызовы, read-only стрик) храним,
+                    // чтобы петли повторов/read-only ловились и без плана. `reset()`
+                    // тёр её каждую итерацию, отключая детекцию.
+                    deps.stuckDetector.resetStepProgress();
                     resetStepFlags(deps.state, -1);
-                    // Evidence-based plan nudge (rule #10 — no bare iteration counter,
-                    // no keyword task classification): only after the agent actually
-                    // made file-mutating tool calls (write/edit/bash/download) without
-                    // a plan does the agent need a plan.
+                    // Evidence-based nudge плана (правило #10 — без голого счётчика
+                    // итераций, без keyword-классификации задач): только когда агент
+                    // реально сделал файл-мутирующие вызовы (write/edit/bash/download)
+                    // без плана, ему нужен план.
                     const mutations = deps.state.mutationsWithoutPlan;
                     if (mutations >= PLAN_NUDGE_THRESHOLD &&
                         !deps.state.planNudgeSent &&
@@ -169,10 +172,9 @@ export function createExecutionPlugin(deps) {
             }
             const stuckReason = deps.stuckDetector.getStuckReason();
             if (stuckReason) {
-                // Log once per warning episode instead of spamming every iteration:
-                // a new warning key logs immediately; the SAME key re-logs only every
-                // STUCK_WARN_REPEAT_EVERY iterations. The step-stuck reason keeps its
-                // dedicated once-per-episode flag.
+                // Логируем раз на эпизод варнинга, а не спамим каждую итерацию: новый
+                // ключ — сразу; ТОТ ЖЕ ключ — только каждые STUCK_WARN_REPEAT_EVERY
+                // итераций. Step-stuck причина хранит свой once-per-episode флаг.
                 const isStuck = deps.stuckDetector.isStuck();
                 const warnKey = deps.stuckDetector.getWarningKey();
                 const iter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
@@ -194,12 +196,14 @@ export function createExecutionPlugin(deps) {
             }
             if (deps.stuckDetector.isStuck() ||
                 deps.stuckDetector.hasRepetitiveToolCalls() ||
-                deps.stuckDetector.hasReadOnlyLoop()) {
+                deps.stuckDetector.hasReadOnlyLoop() ||
+                deps.stuckDetector.hasBashFlailing() ||
+                deps.stuckDetector.hasConsecutiveFailures()) {
                 const currentIter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
                 if (currentIter - deps.state.lastRecoveryIteration >= STUCK_RECOVERY_COOLDOWN) {
                     const recovery = deps.stuckDetector.getRecoveryMessage();
                     if (recovery && ctx.contextManager) {
-                        // Include tsc error context so the model knows WHY it is stuck.
+                        // Прикладываем контекст tsc-ошибки, чтобы модель знала, ПОЧЕМУ застряла.
                         let tscContext = "";
                         if (deps.state.typecheckFailures.size > 0) {
                             const currentStep = deps.trackerRef.current?.getCurrentStep();
@@ -218,21 +222,35 @@ export function createExecutionPlugin(deps) {
                                 }
                             }
                         }
+                        // Префикс стабильной машиночитаемой классификации: модель видит,
+                        // ПОЧЕМУ застряла, до локализованного recovery-гайданса.
+                        const diagnostic = deps.stuckDetector.getStuckDiagnostic(currentIter);
                         ctx.contextManager.addMessage({
                             role: "user",
-                            content: `<system-summary>${recovery}${tscContext}</system-summary>`,
+                            content: `<system-summary>${diagnostic ? `${diagnostic}\n` : ""}${recovery}${tscContext}</system-summary>`,
                         });
                     }
                     deps.stuckDetector.recordEscalation();
                     deps.state.lastRecoveryIteration = currentIter;
-                    if (deps.stuckDetector.shouldEscalate() && ctx.onMeta) {
+                    if (deps.stuckDetector.shouldEscalate()) {
                         const escalation = t("exec.escalation", {
                             stepId: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"),
                             description: deps.trackerRef.current?.getCurrentStep()?.description ?? "",
                         });
-                        ctx.onMeta(escalation);
+                        // Эскалируем МОДЕЛИ, а не только UI-баннеру: после нескольких попыток
+                        // восстановления даём явные общие опции (сменить подход, поискать
+                        // ошибку, спросить юзера, re-plan/skip) вместо повтора того же
+                        // фейлящегося действия. Инжектится раз на эпизод.
+                        if (!deps.state.escalationDirectiveSent && ctx.contextManager) {
+                            deps.state.escalationDirectiveSent = true;
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>${t("exec.escalation_directive")}</system-summary>`,
+                            });
+                        }
+                        ctx.onMeta?.(escalation);
                     }
-                    // Force skip after too many iterations on the same step
+                    // Форс-скип после слишком долгого сидения на одном шаге
                     if (deps.stuckDetector.getIterationsOnCurrentStep() >= FORCE_SKIP_THRESHOLD &&
                         ctx.contextManager) {
                         const step = deps.trackerRef.current?.getCurrentStep();
@@ -261,8 +279,8 @@ export function createExecutionPlugin(deps) {
                         role: "user",
                         content: `<system-summary>${t("exec.plan_blocked", { step: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"), max: MAX_PLAN_WARNINGS_BEFORE_BLOCK })}</system-summary>`,
                     });
-                    // Block with an explicit reason so the model sees WHY the call
-                    // was blocked (executor shows it via tool.blocked_reason).
+                    // Блок с явной причиной, чтобы модель видела, ПОЧЕМУ вызов
+                    // заблокирован (executor показывает через tool.blocked_reason).
                     return t("exec.plan_blocked", {
                         step: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"),
                         max: MAX_PLAN_WARNINGS_BEFORE_BLOCK,
@@ -279,8 +297,8 @@ export function createExecutionPlugin(deps) {
             const args = ctx?.args;
             if (toolName && args) {
                 deps.stuckDetector.recordToolCall(toolName, args);
-                // Count file-mutating calls made with NO active plan — feeds the
-                // evidence-based plan-creation nudge in onBeforeThink.
+                // Считаем файл-мутирующие вызовы БЕЗ активного плана — питают
+                // evidence-based nudge создания плана в onBeforeThink.
                 if (!deps.trackerRef.current &&
                     (toolName === "write_file" ||
                         toolName === "edit_file" ||
@@ -291,14 +309,14 @@ export function createExecutionPlugin(deps) {
             }
         },
         onAfterTool: (ctx, call, result) => {
-            // Remember every bash invocation (successful or not) so stuck
-            // detection can reason about e.g. repeated runs with empty output.
+            // Запоминаем каждый вызов bash (успех или нет): детекция рассуждает,
+            // напр., о повторных прогонах с пустым выводом.
             if (call.name === "bash") {
                 deps.stuckDetector.recordBashOutput(String(call.arguments?.command ?? ""), String(result.output ?? ""));
             }
-            // Auto-detect delete intent from model actions: when delete_file is
-            // called, find the matching plan step and set kind="delete". This is
-            // language-agnostic — based on what the model DID, not what it said.
+            // Авто-детект delete-намерения из действий модели: при вызове delete_file
+            // находим совпадающий шаг плана и ставим kind="delete". Языконезависимо —
+            // по СДЕЛАННОМУ моделью, не по сказанному.
             if (call.name === "delete_file" && result.success && deps.trackerRef.current) {
                 const deletedPath = String(call.arguments?.path ?? "");
                 if (deletedPath) {
@@ -316,21 +334,20 @@ export function createExecutionPlugin(deps) {
                     }
                 }
             }
-            // A write/edit/bash that reports success but still carries a
-            // type/syntax error in its output is NOT a success — the model must
-            // fix the actual error, not keep rewriting the file blindly. Feed it
-            // to the stuck detector so the rewrite-loop hint fires.
+            // write/edit/bash с успехом, но type/syntax-ошибкой в выводе — НЕ успех:
+            // модель чинит реальную ошибку, а не переписывает файл вслепую. Кормим
+            // stuck-детектор, чтобы сработал хинт rewrite-петли.
             const toolText = String(result.output ?? "");
             const hasTypeError = /error TS\d+|\[Project typecheck failed\]|\[Syntax check failed\]/.test(toolText);
             if (hasTypeError) {
                 deps.stuckDetector.recordToolError(call.name, toolText.slice(0, 300));
             }
-            // Track compile failures per-file so the plan done-gate can refuse
-            // "done" while the last edit still doesn't compile (observed: the agent
-            // marked plan steps done while the project typecheck failed on every
-            // write — a "fix it later" cascade). A CLEAN result clears the map: the
-            // debounced project tsc re-ran and passed (or no tsconfig applies), so
-            // old failures must not block completion forever.
+            // Трекаем compile-фейлы пофайлово: done-gate плана реджектит "done", пока
+            // последняя правка не компилируется (было: агент маркил шаги done, а
+            // проектный typecheck фейлился на каждой записи — каскад "починю позже").
+            // ЧИСТЫЙ результат чистит карту: дебаунснутый проектный tsc перегнал и
+            // прошёл (или tsconfig неприменим) — старые фейлы завершение вечно не
+            // блокируют.
             if (call.name === "write_file" || call.name === "edit_file") {
                 const broken = extractBrokenFiles(toolText);
                 if (broken.length > 0) {
@@ -338,22 +355,34 @@ export function createExecutionPlugin(deps) {
                         deps.state.typecheckFailures.set(b.file, b.error);
                 }
                 else if (result.success) {
-                    deps.state.typecheckFailures.clear();
+                    // Чистим только записи только что писанного/правленного файла (и
+                    // проектную безадресную запись, которую чистая правка вероятно
+                    // закрыла). Сплошной `.clear()` стирал несвязанный успешной правкой
+                    // чужой фейл, обходя done-gate.
+                    const edited = normalizeBrokenPath(String(call.arguments?.path ?? ""));
+                    for (const key of [...deps.state.typecheckFailures.keys()]) {
+                        if (key === "" ||
+                            !edited ||
+                            key === edited ||
+                            key.endsWith(edited) ||
+                            edited.endsWith(key)) {
+                            deps.state.typecheckFailures.delete(key);
+                        }
+                    }
                 }
             }
             if (!result.success) {
-                // Feed the bash attempt outcome into the flailing window BEFORE the
-                // per-command handling — rotation across different failing commands
-                // (wc → cat → Get-Content → …) must still trip the detector.
+                // Исход bash-попытки кормим во флейлинг-окно ДО пер-командной обработки —
+                // ротация разных фейлящихся команд (wc → cat → Get-Content → …) обязана
+                // триггерить детектор.
                 if (call.name === "bash") {
                     deps.stuckDetector.recordBashAttempt(false);
                 }
-                // Hard stop for forbidden Windows commands: after the second
-                // failure of the same forbidden command (grep/sed/ls/find/…),
-                // inject a STOP message so the session stops burning bash calls
-                // on commands cmd.exe does not have. Mirrors the bash tool's own
-                // win32-gated hard-stop (src/tools/bash.ts) — on macOS/Linux
-                // these commands exist and fail for legit reasons.
+                // Hard stop для запрещённых Windows-команд: после второго фейла той же
+                // запрещённой команды (grep/sed/ls/find/…) инжектим STOP, чтобы сессия
+                // не жгла bash-вызовы на командах без cmd.exe. Зеркалит собственный
+                // win32-gated hard-stop тула bash (src/tools/bash.ts) — на macOS/Linux
+                // эти команды есть и фейлятся по легитимным причинам.
                 if (call.name === "bash" && platform() === "win32") {
                     const cmd = String(call.arguments?.command ?? "");
                     const forbidden = forbiddenWindowsCommand(cmd);
@@ -368,36 +397,48 @@ export function createExecutionPlugin(deps) {
                         }
                     }
                 }
-                // A type/syntax error in an otherwise "successful" result was already
-                // recorded above. A failing call (result.success === false) would
-                // otherwise double-count the same error (typecheck branch + failure
-                // branch), inflating the error-signature count and triggering the
-                // web search at half the intended threshold.
+                // Type/syntax-ошибка в иначе "успешном" результате уже записана выше.
+                // Фейлящийся вызов (result.success === false) иначе посчитал бы ту же
+                // ошибку дважды (typecheck-ветка + failure-ветка), раздув счётчик
+                // error-сигнатур и триггернув веб-поиск на половине порога.
                 if (!hasTypeError) {
                     deps.stuckDetector.recordToolError(call.name, result.output);
                 }
             }
             else {
-                deps.stuckDetector.recordToolSuccess();
+                // "Успешная" запись/правка может нести type/syntax-ошибку (lint-on-write
+                // хук аппендит её, оставляя success:true). Скормленный здесь
+                // recordToolSuccess() отменял recordToolError выше на том же вызове —
+                // rewrite-loop сигнал не накапливался.
+                if (!hasTypeError)
+                    deps.stuckDetector.recordToolSuccess();
                 if (call.name === "bash") {
                     deps.stuckDetector.recordBashAttempt(true);
                 }
-                // When a bash command runs code successfully, suggest marking the
-                // step done — unless the output shows failing tests, which must
-                // never be reported as a clean success.
+                // Успешно отработавшая команда bash с кодом — предлагаем маркить шаг
+                // done, если только вывод не показывает упавшие тесты (их нельзя
+                // репортить чистым успехом).
                 if (call.name === "bash" && result.success) {
                     const cmd = String(call.arguments?.command ?? "");
                     const testRun = detectTestResults(String(result.output ?? ""));
                     if (testRun && testRun.failed > 0) {
                         deps.pendingMessages.push({
                             role: "user",
-                            content: `<system-summary>${testRun.framework} reported ${testRun.failed} FAILING test(s) (${testRun.passed} passing). Do NOT mark the current step as done — fix the failing tests (read the failure output, correct the code) and re-run them until all pass.</system-summary>`,
+                            content: `<system-summary>${t("exec.test_fail_summary", {
+                                framework: testRun.framework,
+                                failed: String(testRun.failed),
+                                passed: String(testRun.passed),
+                            })}</system-summary>`,
                         });
                     }
                     else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
                         deps.pendingMessages.push({
                             role: "user",
-                            content: `<system-summary>${testRun.framework}: all ${testRun.passed} test(s) passed for "${cmd}". You may mark the current step as done via plan update step=N status=done.</system-summary>`,
+                            content: `<system-summary>${t("exec.test_pass_summary", {
+                                framework: testRun.framework,
+                                passed: String(testRun.passed),
+                                cmd,
+                            })}</system-summary>`,
                         });
                     }
                 }
@@ -418,20 +459,19 @@ export function createExecutionPlugin(deps) {
                     }
                 }
             }
-            // Auto-advance fires after every successful FILESYSTEM-MUTATING tool —
-            // not just write_file/edit_file. Small models often create files through
-            // bash (`echo ... > f`, heredocs) or delete/move via shell instead of the
-            // dedicated tools, and the plan then never advances past the step even
-            // though its deliverables exist (certification 3.5/3.8: files on disk,
-            // plan stuck at 1/4 and 4/5). Read-only tools MUST stay excluded: a
-            // successful read/glob would otherwise complete an "Update X" step whose
-            // target file already exists from an earlier step — without any edit.
-            // advancePlanIfStepComplete is a no-op when tokens don't resolve.
+            // Автопродвижение срабатывает после каждого успешного ФС-МУТИРУЮЩЕГО
+            // тула, не только write_file/edit_file. Мелкие модели часто создают файлы
+            // через bash (`echo ... > f`, heredoc'и) или delete/move через shell
+            // вместо выделенных тулов — план тогда не двигается с шага, хотя
+            // deliverables на диске (сертификация 3.5/3.8: файлы на месте, план
+            // висит на 1/4 и 4/5). Read-only тулы исключены: успешный read/glob иначе
+            // закрыл бы шаг "Update X", чей файл существует с раннего шага, — без
+            // единой правки. advancePlanIfStepComplete — no-op, если токены не резолвятся.
             if (result.success && FS_MUTATING_TOOLS.has(call.name)) {
-                deps.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
+                deps.advancePlanIfStepComplete(ctx.sessionLog);
             }
-            // Automatic web search for a repeatedly failing error (fire-and-forget,
-            // results land in pendingMessages on the next onBeforeThink flush).
+            // Автопоиск в вебе повторяющейся ошибки (fire-and-forget, результаты
+            // падают в pendingMessages на следующем флаше onBeforeThink).
             deps.maybeSearchError(ctx, call);
         },
     };

package/dist/modules/execution/index.js

@@ -1,8 +1,8 @@
+// Модуль исполнения: реэкспорт планов, трекера, верификатора, stuck-детектора, аудитора.
 export { ExecutionModule } from "./module";
 export { PlanCreator } from "./planner";
 export { PlanTracker } from "./tracker";
 export { StepVerifier } from "./verifier";
 export { StuckDetector } from "./stuck-detector";
 export { Auditor } from "./auditor";
-export { PlanPersister } from "./plan-persister";
 export { PlanStore } from "./plan-store";

package/dist/modules/execution/input-from.js

@@ -1,6 +1,6 @@
 /**
- * Accept both compact (`["task-1"]`) and detailed
- * (`[{"subtaskId": "task-1", "field": "json"}]`) forms of input_from.
+ * Принимает обе формы input_from: компактную (`["task-1"]`) и детальную
+ * (`[{"subtaskId": "task-1", "field": "json"}]`).
  */
 export function normalizeInputFrom(input) {
     if (!Array.isArray(input))
@@ -10,8 +10,14 @@ export function normalizeInputFrom(input) {
         if (typeof entry === "string") {
             refs.push({ subtaskId: entry });
         }
-        else if (entry && typeof entry === "object" && typeof entry.subtaskId === "string") {
-            refs.push({ subtaskId: entry.subtaskId, field: entry.field });
+        else if (entry && typeof entry === "object") {
+            const obj = entry;
+            if (typeof obj.subtaskId === "string") {
+                refs.push({
+                    subtaskId: obj.subtaskId,
+                    field: typeof obj.field === "string" ? obj.field : undefined,
+                });
+            }
         }
     }
     return refs;
@@ -23,24 +29,42 @@ function truncate(text, cap) {
     return `${flat.slice(0, cap)}…`;
 }
 /**
- * Render the "Input from previous tasks" section injected into a dependent
- * subtask's prompt. Failed dependencies are marked explicitly so the reader
- * cannot build logic on missing data.
+ * Рендерит секцию "Input from previous tasks" для промпта зависимой
+ * подзадачи. Упавшие зависимости помечаются явно, чтобы читатель не строил
+ * логику на отсутствующих данных.
  */
 export function buildInputSection(subtask, depResults, maxChars) {
     const refs = normalizeInputFrom(subtask.input_from);
     if (refs.length === 0)
         return "";
-    const lines = refs.map((ref) => {
+    // Агрегатный кап: без него 10 зависимостей × maxChars раздувают промпт
+    // выше бюджета контекста маленькой модели.
+    const totalCap = maxChars * 4;
+    const lines = [];
+    let used = 0;
+    let omitted = 0;
+    for (const ref of refs) {
         const dep = depResults.get(ref.subtaskId);
         if (!dep) {
-            return `- ${ref.subtaskId}: (no result available)`;
+            const line = `- ${ref.subtaskId}: (no result available)`;
+            lines.push(line);
+            used += line.length;
+            continue;
         }
         const label = ref.field ? `${ref.subtaskId}.${ref.field}` : ref.subtaskId;
-        if (!dep.success) {
-            return `- ${label}: [FAILED] ${truncate(dep.error || dep.summary || "unknown error", maxChars)}`;
+        const body = dep.success
+            ? truncate(dep.result || dep.summary, maxChars)
+            : `[FAILED] ${truncate(dep.error || dep.summary || "unknown error", maxChars)}`;
+        const line = `- ${label}: ${body}`;
+        if (used + line.length > totalCap) {
+            omitted++;
+            continue;
         }
-        return `- ${label}: ${truncate(dep.result || dep.summary, maxChars)}`;
-    });
+        lines.push(line);
+        used += line.length;
+    }
+    if (omitted > 0) {
+        lines.push(`- (${omitted} more input(s) omitted: input budget reached)`);
+    }
     return `\n\nInput from previous tasks:\n${lines.join("\n")}`;
 }