micro-models-agent 2.16.1 → 2.17.2

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

@@ -1,478 +0,0 @@
-import { t } from "../../i18n/index";
-import { detectTestResults } from "../../tools/bash";
-import { forbiddenWindowsCommand } from "./windows-commands";
-import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
-import { toForwardSlash } from "../../tools/path-utils";
-import { platform } from "os";
-import { switchStepToDelete } from "./plan-steps";
-/**
- * Кулдаун (в итерациях) между инжектами stuck-восстановления. Экспортируется,
- * чтобы ExecutionModule сидировал state.lastRecoveryIteration тем же офсетом,
- * с которым плагин сравнивает.
- */
-export const STUCK_RECOVERY_COOLDOWN = 5;
-const MAX_PLAN_WARNINGS_BEFORE_BLOCK = 3;
-const FORCE_SKIP_THRESHOLD = 10;
-/** Один и тот же stuck-варнинг перелоггируем не чаще каждых N итераций (новый
- *  ключ — всегда сразу). Не даёт идентичному варнингу флудить каждую итерацию
- *  (было в ses_mt4fn58c: "Tool bash failed N times" после ~30 успешных записей,
- *  "No write/exec" на каждом чтении). */
-export const STUCK_WARN_REPEAT_EVERY = 5;
-/** Сколько файл-мутирующих вызовов (write/edit/bash/download) без активного
- *  плана триггерит nudge создания плана. Evidence-based (правило #10):
- *  агент явно работает с файлами — план оправдан. */
-const PLAN_NUDGE_THRESHOLD = 2;
-/** Тулы, чей успех мог поменять ФС — после них перепроверяем deliverables
- *  текущего шага для автопродвижения. Read-only осознанно исключены (см. вызов
- *  advance в onAfterTool ниже). */
-const FS_MUTATING_TOOLS = new Set([
-    "write_file",
-    "edit_file",
-    "delete_file",
-    "move_file",
-    "create_dir",
-    "bash",
-    "download_file",
-    "subagent",
-    "mcp_call",
-    "pipeline_run",
-    "browser",
-]);
-function normalizeBrokenPath(p) {
-    return toForwardSlash(p).replace(/^\.\//, "");
-}
-/** Парсит строку ошибки tsc / bun build / node --check в путь файла.
- *  Null, если в строке нет привязки к файлу (напр. `error: Could not
- *  resolve "..."`). */
-export function parseBrokenFile(line) {
-    const trimmed = line.trim();
-    // tsc: src/index.tsx(17,15): error TS2322: ...
-    const tsc = /^(.+?)\s*\(\d+,\d+\)\s*:\s*error TS\d+/.exec(trimmed);
-    if (tsc)
-        return normalizeBrokenPath(tsc[1]);
-    // bun build / node --check: /abs/file.tsx:1:10: error: ...
-    const bn = /^(.+?):\d+:\d+\s*:\s*(?:error|SyntaxError)/.exec(trimmed);
-    if (bn)
-        return normalizeBrokenPath(bn[1]);
-    return null;
-}
-/** Вытаскивает пофайловые compile-фейлы из вывода write/edit. Смотрит только
- *  строки-маркеры (`[Project typecheck failed]: <line>` /
- *  `[Syntax check failed]: <line>`), чтобы тело диффа не давало ложных. */
-export function extractBrokenFiles(output) {
-    const out = [];
-    for (const line of output.split("\n")) {
-        const marker = /\[(?:Project typecheck failed|Syntax check failed)\]:\s*(.+)$/.exec(line);
-        if (!marker)
-            continue;
-        const errLine = marker[1].trim();
-        out.push({ file: parseBrokenFile(errLine) ?? "", error: errLine.slice(0, 300) });
-    }
-    return out;
-}
-/** Сброс пер-шаговых флагов при смене активного шага (или его отсутствии: -1). */
-function resetStepFlags(state, stepId) {
-    state.consecutivePlanWarnings = 0;
-    state.lastStepId = stepId;
-    state.stuckNotified = false;
-    state.escalationDirectiveSent = false;
-}
-/** Полный сброс состояния плана (завершён или его нет). */
-function resetPlanState(state) {
-    state.consecutivePlanWarnings = 0;
-    state.lastStepId = -1;
-    state.stuckNotified = false;
-    state.mutationsWithoutPlan = 0;
-    state.planNudgeSent = false;
-    state.escalationDirectiveSent = false;
-}
-/**
- * Гейт для `plan update status=done`: реджектит, пока последний write/edit
- * репортит compile-ошибку. Фейл без привязки к файлу блокирует весь проект;
- * иначе именованные токены файлов шага матчатся против битых (суффикс пути,
- * регистронезависимо). Шаг без файлов обвинить не в чем — его done остаётся
- * vacuous. Возвращает первую ошибку для показа модели, или null чтобы пустить.
- */
-export function stepTypecheckGate(failures, stepDescription) {
-    if (failures.size === 0)
-        return null;
-    const projectError = failures.get("");
-    if (projectError)
-        return projectError;
-    const stepTokens = extractFileLikeTokens(stripUrls(stepDescription)).map((p) => normalizeBrokenPath(p).toLowerCase());
-    if (stepTokens.length === 0)
-        return null;
-    for (const [file, err] of failures) {
-        const f = normalizeBrokenPath(file).toLowerCase();
-        if (stepTokens.some((tok) => f.endsWith(tok) || tok.endsWith(f)))
-            return err;
-    }
-    return null;
-}
-/**
- * Хуки execution-плагина, вынесенные дословно из ExecutionModule.getPlugin().
- * Всё разделяемое мутабельное состояние (pendingMessages, forbiddenBashFailures,
- * state, tracker) принадлежит модулю и мутируется по ссылке через `deps`.
- */
-export function createExecutionPlugin(deps) {
-    return {
-        name: "execution",
-        onBeforeThink: (ctx) => {
-            // Отложенные <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()) {
-                // Все шаги done/skipped — перестаём считать "no progress" против
-                // последнего шага и глушим step-stuck варнинги готового плана, НО
-                // историю вызовов храним, чтобы петля чтения-без-записи ловилась
-                // (было: план готов + ложноположительный аудит → модель 50+ итераций
-                // перечитывала файлы с нулем записей без recovery-хинта).
-                deps.stuckDetector.resetStepProgress();
-                resetPlanState(deps.state);
-            }
-            else {
-                const step = deps.trackerRef.current?.getCurrentStep();
-                if (deps.trackerRef.current && step) {
-                    if (step.id !== deps.state.lastStepId) {
-                        resetStepFlags(deps.state, step.id);
-                    }
-                    deps.stuckDetector.setCurrentStep(step.id, step.description);
-                    deps.stuckDetector.recordIteration(step.id);
-                    // A plan is active — any mutation counter no longer applies.
-                    deps.state.mutationsWithoutPlan = 0;
-                    deps.state.planNudgeSent = false;
-                }
-                else {
-                    // До-плана: историю цикла (свежие вызовы, read-only стрик) храним,
-                    // чтобы петли повторов/read-only ловились и без плана. `reset()`
-                    // тёр её каждую итерацию, отключая детекцию.
-                    deps.stuckDetector.resetStepProgress();
-                    resetStepFlags(deps.state, -1);
-                    // Evidence-based nudge плана (правило #10 — без голого счётчика
-                    // итераций, без keyword-классификации задач): только когда агент
-                    // реально сделал файл-мутирующие вызовы (write/edit/bash/download)
-                    // без плана, ему нужен план.
-                    const mutations = deps.state.mutationsWithoutPlan;
-                    if (mutations >= PLAN_NUDGE_THRESHOLD &&
-                        !deps.state.planNudgeSent &&
-                        ctx.contextManager) {
-                        deps.state.planNudgeSent = true;
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${t("exec.plan_nudge", {
-                                count: String(mutations),
-                            })}</system-summary>`,
-                        });
-                    }
-                }
-            }
-            const stuckReason = deps.stuckDetector.getStuckReason();
-            if (stuckReason) {
-                // Логируем раз на эпизод варнинга, а не спамим каждую итерацию: новый
-                // ключ — сразу; ТОТ ЖЕ ключ — только каждые 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;
-                const logIt = isStuck
-                    ? !deps.state.stuckNotified
-                    : warnKey !== deps.state.lastStuckWarnKey ||
-                        iter - deps.state.lastStuckWarnIter >= STUCK_WARN_REPEAT_EVERY;
-                if (logIt) {
-                    ctx.logger?.warn(stuckReason);
-                    ctx.sessionLog?.plan("stuck-warning", stuckReason, typeof ctx.iteration === "number" ? ctx.iteration : undefined);
-                    deps.state.lastStuckWarnKey = warnKey;
-                    deps.state.lastStuckWarnIter = iter;
-                    if (isStuck)
-                        deps.state.stuckNotified = true;
-                }
-            }
-            else {
-                deps.state.lastStuckWarnKey = "";
-            }
-            if (deps.stuckDetector.isStuck() ||
-                deps.stuckDetector.hasRepetitiveToolCalls() ||
-                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) {
-                        // Прикладываем контекст tsc-ошибки, чтобы модель знала, ПОЧЕМУ застряла.
-                        let tscContext = "";
-                        if (deps.state.typecheckFailures.size > 0) {
-                            const currentStep = deps.trackerRef.current?.getCurrentStep();
-                            if (currentStep) {
-                                const stepFiles = extractFileLikeTokens(stripUrls(currentStep.description));
-                                for (const [file, error] of deps.state.typecheckFailures) {
-                                    if (!file || stepFiles.some((f) => file.endsWith(f) || f.endsWith(file))) {
-                                        tscContext = `\nLast compile error: ${error}`;
-                                        break;
-                                    }
-                                }
-                                if (!tscContext) {
-                                    const first = deps.state.typecheckFailures.entries().next().value;
-                                    if (first)
-                                        tscContext = `\nLast compile error: ${first[1]}`;
-                                }
-                            }
-                        }
-                        // Префикс стабильной машиночитаемой классификации: модель видит,
-                        // ПОЧЕМУ застряла, до локализованного recovery-гайданса.
-                        const diagnostic = deps.stuckDetector.getStuckDiagnostic(currentIter);
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${diagnostic ? `${diagnostic}\n` : ""}${recovery}${tscContext}</system-summary>`,
-                        });
-                    }
-                    deps.stuckDetector.recordEscalation();
-                    deps.state.lastRecoveryIteration = currentIter;
-                    if (deps.stuckDetector.shouldEscalate()) {
-                        const escalation = t("exec.escalation", {
-                            stepId: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"),
-                            description: deps.trackerRef.current?.getCurrentStep()?.description ?? "",
-                        });
-                        // Эскалируем МОДЕЛИ, а не только 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);
-                    }
-                    // Форс-скип после слишком долгого сидения на одном шаге
-                    if (deps.stuckDetector.getIterationsOnCurrentStep() >= FORCE_SKIP_THRESHOLD &&
-                        ctx.contextManager) {
-                        const step = deps.trackerRef.current?.getCurrentStep();
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${t("exec.stop_directive", {
-                                stepId: String(step?.id ?? "?"),
-                                description: step?.description ?? "",
-                                iterations: String(deps.stuckDetector.getIterationsOnCurrentStep()),
-                            })}</system-summary>`,
-                        });
-                    }
-                }
-            }
-        },
-        onBeforeTool: (_ctx, call) => {
-            const warning = deps.checkPlanAlignment(call);
-            if (warning) {
-                deps.pendingMessages.push({
-                    role: "user",
-                    content: `<system-summary>${warning}</system-summary>`,
-                });
-                deps.state.consecutivePlanWarnings++;
-                if (deps.state.consecutivePlanWarnings >= MAX_PLAN_WARNINGS_BEFORE_BLOCK) {
-                    deps.pendingMessages.push({
-                        role: "user",
-                        content: `<system-summary>${t("exec.plan_blocked", { step: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"), max: MAX_PLAN_WARNINGS_BEFORE_BLOCK })}</system-summary>`,
-                    });
-                    // Блок с явной причиной, чтобы модель видела, ПОЧЕМУ вызов
-                    // заблокирован (executor показывает через tool.blocked_reason).
-                    return t("exec.plan_blocked", {
-                        step: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"),
-                        max: MAX_PLAN_WARNINGS_BEFORE_BLOCK,
-                    });
-                }
-            }
-            else {
-                deps.state.consecutivePlanWarnings = 0;
-            }
-            return true;
-        },
-        onToolCall: (ctx) => {
-            const toolName = ctx?.toolName;
-            const args = ctx?.args;
-            if (toolName && args) {
-                deps.stuckDetector.recordToolCall(toolName, args);
-                // Считаем файл-мутирующие вызовы БЕЗ активного плана — питают
-                // evidence-based nudge создания плана в onBeforeThink.
-                if (!deps.trackerRef.current &&
-                    (toolName === "write_file" ||
-                        toolName === "edit_file" ||
-                        toolName === "bash" ||
-                        toolName === "download_file")) {
-                    deps.state.mutationsWithoutPlan++;
-                }
-            }
-        },
-        onAfterTool: (ctx, call, result) => {
-            // Запоминаем каждый вызов bash (успех или нет): детекция рассуждает,
-            // напр., о повторных прогонах с пустым выводом.
-            if (call.name === "bash") {
-                deps.stuckDetector.recordBashOutput(String(call.arguments?.command ?? ""), String(result.output ?? ""));
-            }
-            // Авто-детект delete-намерения из действий модели: при вызове delete_file
-            // находим совпадающий шаг плана и ставим kind="delete". Языконезависимо —
-            // по СДЕЛАННОМУ моделью, не по сказанному.
-            if (call.name === "delete_file" && result.success && deps.trackerRef.current) {
-                const deletedPath = String(call.arguments?.path ?? "");
-                if (deletedPath) {
-                    const plan = deps.trackerRef.current.getPlan();
-                    const tokens = extractFileLikeTokens(stripUrls(deletedPath));
-                    for (const step of plan.steps) {
-                        if (step.status !== "pending" && step.status !== "in_progress")
-                            continue;
-                        const stepTokens = extractFileLikeTokens(stripUrls(step.description));
-                        const overlap = tokens.some((t) => stepTokens.some((st) => t.endsWith(st) || st.endsWith(t)));
-                        if (overlap) {
-                            switchStepToDelete(plan, step, (p) => deps.store.saveActive(p));
-                            break;
-                        }
-                    }
-                }
-            }
-            // 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));
-            }
-            // Трекаем 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) {
-                    for (const b of broken)
-                        deps.state.typecheckFailures.set(b.file, b.error);
-                }
-                else if (result.success) {
-                    // Чистим только записи только что писанного/правленного файла (и
-                    // проектную безадресную запись, которую чистая правка вероятно
-                    // закрыла). Сплошной `.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) {
-                // Исход bash-попытки кормим во флейлинг-окно ДО пер-командной обработки —
-                // ротация разных фейлящихся команд (wc → cat → Get-Content → …) обязана
-                // триггерить детектор.
-                if (call.name === "bash") {
-                    deps.stuckDetector.recordBashAttempt(false);
-                }
-                // 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);
-                    if (forbidden) {
-                        const n = (deps.forbiddenBashFailures.get(forbidden) || 0) + 1;
-                        deps.forbiddenBashFailures.set(forbidden, n);
-                        if (n === 2) {
-                            deps.pendingMessages.push({
-                                role: "user",
-                                content: `<system-summary>${t("exec.forbidden_cmd", { cmd: forbidden })}</system-summary>`,
-                            });
-                        }
-                    }
-                }
-                // Type/syntax-ошибка в иначе "успешном" результате уже записана выше.
-                // Фейлящийся вызов (result.success === false) иначе посчитал бы ту же
-                // ошибку дважды (typecheck-ветка + failure-ветка), раздув счётчик
-                // error-сигнатур и триггернув веб-поиск на половине порога.
-                if (!hasTypeError) {
-                    deps.stuckDetector.recordToolError(call.name, result.output);
-                }
-            }
-            else {
-                // "Успешная" запись/правка может нести type/syntax-ошибку (lint-on-write
-                // хук аппендит её, оставляя success:true). Скормленный здесь
-                // recordToolSuccess() отменял recordToolError выше на том же вызове —
-                // rewrite-loop сигнал не накапливался.
-                if (!hasTypeError)
-                    deps.stuckDetector.recordToolSuccess();
-                if (call.name === "bash") {
-                    deps.stuckDetector.recordBashAttempt(true);
-                }
-                // Успешно отработавшая команда 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>${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>${t("exec.test_pass_summary", {
-                                framework: testRun.framework,
-                                passed: String(testRun.passed),
-                                cmd,
-                            })}</system-summary>`,
-                        });
-                    }
-                }
-            }
-            if (result.success && (call.name === "write_file" || call.name === "edit_file")) {
-                const filePath = call.arguments?.path;
-                if (filePath) {
-                    deps.stuckDetector.recordFileRewrite(filePath);
-                    if (deps.stuckDetector.hasExcessiveRewrites()) {
-                        const file = deps.stuckDetector.getExcessiveRewriteFile();
-                        const count = deps.stuckDetector.getFileRewriteCount(file);
-                        if (ctx.onMeta) {
-                            ctx.onMeta(t("exec.file_rewrite_warning", {
-                                file: file,
-                                count: String(count),
-                            }));
-                        }
-                    }
-                }
-            }
-            // Автопродвижение срабатывает после каждого успешного ФС-МУТИРУЮЩЕГО
-            // тула, не только 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.sessionLog);
-            }
-            // Автопоиск в вебе повторяющейся ошибки (fire-and-forget, результаты
-            // падают в pendingMessages на следующем флаше onBeforeThink).
-            deps.maybeSearchError(ctx, call);
-        },
-    };
-}

package/dist/modules/execution/index.js

@@ -1,8 +0,0 @@
-// Модуль исполнения: реэкспорт планов, трекера, верификатора, 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 { PlanStore } from "./plan-store";

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

@@ -1,70 +0,0 @@
-/**
- * Принимает обе формы input_from: компактную (`["task-1"]`) и детальную
- * (`[{"subtaskId": "task-1", "field": "json"}]`).
- */
-export function normalizeInputFrom(input) {
-    if (!Array.isArray(input))
-        return [];
-    const refs = [];
-    for (const entry of input) {
-        if (typeof entry === "string") {
-            refs.push({ subtaskId: entry });
-        }
-        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;
-}
-function truncate(text, cap) {
-    const flat = text.replace(/\s+/g, " ").trim();
-    if (flat.length <= cap)
-        return flat;
-    return `${flat.slice(0, cap)}…`;
-}
-/**
- * Рендерит секцию "Input from previous tasks" для промпта зависимой
- * подзадачи. Упавшие зависимости помечаются явно, чтобы читатель не строил
- * логику на отсутствующих данных.
- */
-export function buildInputSection(subtask, depResults, maxChars) {
-    const refs = normalizeInputFrom(subtask.input_from);
-    if (refs.length === 0)
-        return "";
-    // Агрегатный кап: без него 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) {
-            const line = `- ${ref.subtaskId}: (no result available)`;
-            lines.push(line);
-            used += line.length;
-            continue;
-        }
-        const label = ref.field ? `${ref.subtaskId}.${ref.field}` : ref.subtaskId;
-        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;
-        }
-        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")}`;
-}