micro-models-agent 0.46.2 → 0.46.3

package/dist/modules/execution/audit-runners.js

@@ -1,152 +0,0 @@
-import { existsSync, readdirSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { detectTestResults } from "../../tools/bash";
-import { processRegistry } from "../processes";
-/** Directories never searched for test files. */
-export const SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    ".mma",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    ".nuxt",
-    "vendor",
-]);
-const TEST_EXT_RE = /\.(test|spec)\.[jt]sx?$/i;
-const TEST_STEP_RE = /\b(test(ing|s)?|тест(ы|ирование|ировать)?|провер\w*\s+тест|запустить\s+тест)\b|bun test|npm test|vitest|pytest|go test|jest|mocha/i;
-/** Recursive, depth-limited walk that stops early on the first test file. */
-export function findTestFile(dir, depth = 0) {
-    if (depth > 5)
-        return null;
-    let entries;
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const e of entries) {
-        const full = join(dir, e.name);
-        if (e.isDirectory()) {
-            if (SKIP_DIRS.has(e.name))
-                continue;
-            const found = findTestFile(full, depth + 1);
-            if (found)
-                return found;
-        }
-        else if (TEST_EXT_RE.test(e.name)) {
-            return full;
-        }
-    }
-    return null;
-}
-/** The plan's step descriptions mention running/checking tests. */
-export function hasTestStep(plan) {
-    return plan.steps.some((s) => TEST_STEP_RE.test(s.description));
-}
-/** Extract failing test names from a runner's output (bun/vitest style). */
-function extractFailingNames(output, limit = 5) {
-    const names = [];
-    for (const m of output.matchAll(/\(fail\)\s*([^\n]+)/g)) {
-        const name = m[1].trim();
-        if (name && !names.includes(name))
-            names.push(name);
-        if (names.length >= limit)
-            break;
-    }
-    return names;
-}
-export async function runTests(baseDir) {
-    const entry = processRegistry.start("bun test", baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    if (!exited) {
-        // Timed out — we cannot claim success or failure from an unfinished run.
-        return {
-            checked: true,
-            passed: true, // don't block completion on an inconclusive run
-            failed: 0,
-            passedCount: 0,
-            detail: "test run timed out after 90s — result unknown",
-            command: "bun test",
-        };
-    }
-    const run = detectTestResults(output);
-    if (!run) {
-        // No recognizable runner summary. A non-zero exit means the test run
-        // (or its runner) failed — the audit must not pass on it; report a
-        // single "at least one failed" since we cannot count them. Exit 0
-        // with unrecognized output stays checked-but-inconclusive.
-        return {
-            checked: true,
-            passed: entry.exitCode === 0,
-            failed: entry.exitCode === 0 ? 0 : 1,
-            passedCount: 0,
-            detail: output.slice(0, 200).trim(),
-            command: "bun test",
-        };
-    }
-    const names = extractFailingNames(output);
-    return {
-        checked: true,
-        passed: run.failed === 0,
-        failed: run.failed,
-        passedCount: run.passed,
-        detail: names.length
-            ? names.join("; ")
-            : run.summary || `${run.failed} failed / ${run.passed} passed`,
-        command: "bun test",
-    };
-}
-/** First `error TS…` line in a tsc output, or null when none/inconclusive. */
-export function parseTypecheckErrors(output) {
-    const line = output.split("\n").find((l) => /error TS\d+/.test(l));
-    return line ? line.trim().slice(0, 300) : null;
-}
-/**
- * Locate the nearest project root that owns a tsconfig.json.
- *
- * The agent frequently creates the project in a nested subfolder of its
- * baseDir (e.g. `bicycle-shop/`), so the tsconfig lives at
- * `baseDir/bicycle-shop/` and the old `existsSync(baseDir/tsconfig.json)`
- * gate silently skipped the final typecheck — the audit passed even with
- * dozens of tsc errors (observed in both analyzed sessions). This walks each
- * candidate (baseDir plus the resolved step files) upward to the nearest
- * tsconfig.json, preferring the shallowest hit so the baseDir project wins
- * over a stray tsconfig further up. Returns null when no tsconfig exists in
- * any reachable subtree. `existingFiles` must contain resolved absolute paths
- * (relative tokens would resolve against the process cwd, not baseDir).
- */
-export function findTypecheckRoot(baseDir, existingFiles = []) {
-    const candidates = [baseDir, ...existingFiles];
-    let best = null;
-    for (const start of candidates) {
-        let dir = resolve(start);
-        for (let depth = 0; depth <= 10; depth++) {
-            if (existsSync(join(dir, "tsconfig.json"))) {
-                if (!best || depth < best.depth)
-                    best = { depth, root: dir };
-                break;
-            }
-            const parent = dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    return best?.root ?? null;
-}
-export async function runTypecheck(baseDir) {
-    const entry = processRegistry.start("npx --no-install tsc --noEmit --skipLibCheck", baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    // A timeout, or output with no `error TS` lines (missing typescript / wrong
-    // working dir) is inconclusive — never block completion on those.
-    if (!exited)
-        return null;
-    return parseTypecheckErrors(output);
-}

package/dist/modules/execution/auditor.js

@@ -1,218 +0,0 @@
-import { existsSync, readdirSync } from "fs";
-import { resolve, join, basename } from "path";
-import { t } from "../../i18n/index";
-import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
-import { SKIP_DIRS, findTestFile, findTypecheckRoot, hasTestStep, runTests, runTypecheck, } from "./audit-runners";
-export { parseTypecheckErrors } from "./audit-runners";
-const MASS_EDIT_THRESHOLD = 10;
-/** Subtree walk depth cap for file resolution. */
-const RESOLVE_MAX_DEPTH = 8;
-/**
- * Resolve a plan-step file token to an existing file.
- *
- * A step description frequently names a file by its bare basename
- * ("App.tsx") or a partially-prefixed path ("src/App.tsx") while the real
- * file lives in a nested project directory relative to the agent baseDir
- * (e.g. `bicycle-shop/src/App.tsx`). Naively resolving against baseDir
- * reports the file as missing — observed in session ses_mssl5izw where the
- * final audit gate rejected a fully-completed task with "1 files missing"
- * forever, sending the model into a read/retry loop.
- *
- * Strategy: exact resolve first, then a bounded subtree walk matching either
- * the exact basename or a path suffix (so both "App.tsx" and
- * "src/App.tsx" find "bicycle-shop/src/App.tsx").
- */
-export function findExistingFile(baseDir, filePath) {
-    const direct = resolve(baseDir, filePath);
-    if (existsSync(direct))
-        return direct;
-    const name = basename(filePath).toLowerCase();
-    const suffix = filePath.replace(/\\/g, "/").toLowerCase();
-    let found = null;
-    const walk = (dir, depth) => {
-        if (found || depth > RESOLVE_MAX_DEPTH)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const e of entries) {
-            if (found)
-                return;
-            const full = join(dir, e.name);
-            if (e.isDirectory()) {
-                if (SKIP_DIRS.has(e.name))
-                    continue;
-                walk(full, depth + 1);
-            }
-            else if (e.name.toLowerCase() === name ||
-                full
-                    .replace(/\\/g, "/")
-                    .toLowerCase()
-                    .endsWith("/" + suffix)) {
-                found = full;
-                return;
-            }
-        }
-    };
-    walk(baseDir, 0);
-    return found;
-}
-export class Auditor {
-    baseDir;
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-    }
-    async audit(plan) {
-        // Only steps the model claims completed may require their named files to
-        // exist. Skipped/pending steps must never contribute "missing files"
-        // (observed: a skipped step's prose mention of "type.ts" kept the audit
-        // gate rejecting a finished task with "1 files missing" forever).
-        const doneCreate = plan.steps.filter((s) => s.status === "done" && s.kind !== "delete");
-        const doneDelete = plan.steps.filter((s) => s.status === "done" && s.kind === "delete");
-        const createText = doneCreate.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-        const deleteText = doneDelete.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-        // File tokens are extracted with the SAME shared filter as the
-        // hallucination factual check (js-identifiers.ts). URLs are stripped
-        // first so a hostname / https://host/repo.git in a step description
-        // can never be reported as a missing file (observed: a git-remote
-        // plan flagged `whom-pointing-jewel-maine.trycloudflare.com`).
-        const createFiles = extractFileLikeTokens(stripUrls(createText));
-        const deleteFiles = extractFileLikeTokens(stripUrls(deleteText));
-        const missingFiles = [];
-        const existingFiles = [];
-        const leftoverFiles = [];
-        for (const filePath of createFiles) {
-            const resolved = findExistingFile(this.baseDir, filePath);
-            if (resolved) {
-                // Keep the resolved absolute path: findTypecheckRoot walks up
-                // from it to the nearest tsconfig, and a relative token would
-                // resolve against the process cwd instead of baseDir.
-                existingFiles.push(resolved);
-            }
-            else {
-                missingFiles.push(filePath);
-            }
-        }
-        // A done delete-kind step requires its named files to be GONE.
-        for (const filePath of deleteFiles) {
-            if (findExistingFile(this.baseDir, filePath)) {
-                leftoverFiles.push(filePath);
-            }
-        }
-        // Real test run: when the plan includes a verification step, do not
-        // trust the model's word (or exit codes) — actually execute the tests
-        // and check the runner summary. This catches the "all 7 passing ✅"
-        // final answers that hide 3 failing tests.
-        let testRun = null;
-        if (hasTestStep(plan) && findTestFile(this.baseDir)) {
-            try {
-                testRun = await runTests(this.baseDir);
-            }
-            catch {
-                testRun = null; // infra failure — don't block on it
-            }
-        }
-        // Real typecheck: the audit must catch "the build is broken" even when
-        // every file exists (observed: deleting .js files left the .tsx sources
-        // with 11 tsc errors and the agent still declared success). Runs only
-        // when a tsconfig.json is reachable from baseDir or the resolved step
-        // files AND the file checks already passed — an audit that is doomed by
-        // missing/leftover files must not pay a 90s tsc spawn. Inconclusive
-        // results never block.
-        let typecheckError = null;
-        if (missingFiles.length === 0 && leftoverFiles.length === 0) {
-            const root = findTypecheckRoot(this.baseDir, existingFiles);
-            if (root) {
-                try {
-                    typecheckError = await runTypecheck(root);
-                }
-                catch {
-                    typecheckError = null;
-                }
-            }
-        }
-        const doneSteps = plan.steps.filter((s) => s.status === "done").length;
-        // done + skipped are both deliberate terminal states: `done` claims the
-        // work, `skipped` documents a decision that the step is not needed (the
-        // deliverable gate's documented escape hatch). Neither is a lie the
-        // audit must catch — a plan with a legitimately skipped step must be
-        // able to pass (observed: skipped step 1 kept the task rejected forever).
-        const terminalSteps = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
-        const totalSteps = plan.steps.length;
-        const auditedFiles = [...new Set([...createFiles, ...deleteFiles])];
-        let massEditWarning = null;
-        if (auditedFiles.length > MASS_EDIT_THRESHOLD) {
-            massEditWarning = t("exec.mass_edit_warning", {
-                count: String(auditedFiles.length),
-            });
-        }
-        const testsFailing = testRun !== null && !testRun.passed;
-        const typecheckFailing = typecheckError !== null;
-        const passed = missingFiles.length === 0 && leftoverFiles.length === 0 && !testsFailing && !typecheckFailing;
-        // A "Task complete ✓" summary for an unfinished plan is a lie the model
-        // reads as a green light (observed: audit gate injected "[✓] Task
-        // complete: 1/3 steps done" while the plan had 2 pending steps). The
-        // summary must only claim completion when every step is actually done.
-        const stepsPending = terminalSteps < totalSteps;
-        let summary;
-        if (missingFiles.length > 0) {
-            summary = t("exec.audit_fail", {
-                done: doneSteps,
-                total: totalSteps,
-                files: missingFiles.length,
-            });
-        }
-        else if (leftoverFiles.length > 0) {
-            summary = t("exec.audit_leftovers", {
-                done: doneSteps,
-                total: totalSteps,
-                files: leftoverFiles.length,
-            });
-        }
-        else if (testsFailing) {
-            summary = t("exec.audit_fail_tests", {
-                done: doneSteps,
-                total: totalSteps,
-                failed: String(testRun.failed),
-                passed: String(testRun.passedCount),
-                detail: testRun.detail,
-            });
-        }
-        else if (typecheckFailing) {
-            summary = t("exec.audit_fail_typecheck", {
-                done: doneSteps,
-                total: totalSteps,
-                missing: String(missingFiles.length),
-                typeError: typecheckError,
-            });
-        }
-        else if (stepsPending) {
-            summary = t("exec.audit_pending", {
-                done: doneSteps,
-                total: totalSteps,
-            });
-        }
-        else {
-            summary = t("exec.audit_pass", {
-                done: doneSteps,
-                total: totalSteps,
-                files: existingFiles.length,
-            });
-        }
-        return {
-            passed,
-            missingFiles,
-            leftoverFiles,
-            createdFiles: existingFiles,
-            modifiedFiles: [],
-            summary,
-            massEditWarning,
-            testRun,
-            typecheckError,
-        };
-    }
-}

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

@@ -1,272 +0,0 @@
-import { t } from "../../i18n/index";
-import { detectTestResults } from "../../tools/bash";
-import { forbiddenWindowsCommand } from "./windows-commands";
-import { platform } from "os";
-/**
- * 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.
- */
-export const STUCK_RECOVERY_COOLDOWN = 5;
-const MAX_PLAN_WARNINGS_BEFORE_BLOCK = 3;
-const FORCE_SKIP_THRESHOLD = 10;
-/**
- * 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`.
- */
-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.
-            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).
-                deps.stuckDetector.resetStepProgress();
-                deps.state.consecutivePlanWarnings = 0;
-                deps.state.lastStepId = -1;
-                deps.state.stuckNotified = false;
-            }
-            else {
-                const step = deps.trackerRef.current?.getCurrentStep();
-                if (deps.trackerRef.current && step) {
-                    if (step.id !== deps.state.lastStepId) {
-                        deps.state.consecutivePlanWarnings = 0;
-                        deps.state.lastStepId = step.id;
-                        deps.state.stuckNotified = false;
-                    }
-                    deps.stuckDetector.setCurrentStep(step.id, step.description);
-                    deps.stuckDetector.recordIteration(step.id);
-                }
-                else {
-                    deps.stuckDetector.reset();
-                    deps.state.consecutivePlanWarnings = 0;
-                    deps.state.lastStepId = -1;
-                    deps.state.stuckNotified = false;
-                    const iter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
-                    if (iter === 3 && !deps.trackerRef.current && ctx.contextManager) {
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>You have made 3 tool calls without creating a plan. For any task that involves creating files, installing packages, or multiple steps — you MUST use plan create BEFORE continuing. Use the plan tool now with concrete steps (exact filenames, commands, deliverables). Do NOT make any more write/edit/bash calls until you have a plan.</system-summary>`,
-                        });
-                    }
-                    if (iter >= 6 && !deps.trackerRef.current && ctx.contextManager) {
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>STOP. ${iter} iterations without a plan. You MUST call plan create RIGHT NOW. No more tool calls until you create a plan.</system-summary>`,
-                        });
-                    }
-                }
-            }
-            const stuckReason = deps.stuckDetector.getStuckReason();
-            if (stuckReason) {
-                // Log once per stuck episode instead of spamming every iteration.
-                const logIt = deps.stuckDetector.isStuck() ? !deps.state.stuckNotified : true;
-                if (logIt) {
-                    ctx.logger?.warn(stuckReason);
-                    ctx.sessionLog?.plan("stuck-warning", stuckReason, typeof ctx.iteration === "number" ? ctx.iteration : undefined);
-                    if (deps.stuckDetector.isStuck())
-                        deps.state.stuckNotified = true;
-                }
-            }
-            if (deps.stuckDetector.isStuck() ||
-                deps.stuckDetector.hasRepetitiveToolCalls() ||
-                deps.stuckDetector.hasReadOnlyLoop()) {
-                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) {
-                        const lastError = deps.stuckDetector.getLastErrorOutput();
-                        const skillHint = lastError
-                            ? "\nIf you have relevant skills available, consider loading one with load_skill for expert guidance."
-                            : "";
-                        // Actionable hints based on actual error output
-                        const actionableHints = deps.stuckDetector.getActionableHints();
-                        const actionableHintStr = actionableHints.length > 0
-                            ? `\n${t("exec.hints", { hints: actionableHints.map((h) => `- ${h}`).join("\n") })}`
-                            : "";
-                        // Tool alternative suggestion
-                        const alternative = deps.stuckDetector.getToolAlternative();
-                        const altHint = alternative
-                            ? `\nTool "${deps.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}" instead.`
-                            : "";
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${recovery}${skillHint}${actionableHintStr}${altHint}</system-summary>`,
-                        });
-                    }
-                    const hints = deps.stuckDetector.getHints();
-                    if (hints.length > 0 && ctx.contextManager) {
-                        const hintMsg = t("exec.hints", {
-                            hints: hints.map((h) => `- ${h}`).join("\n"),
-                        });
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${hintMsg}</system-summary>`,
-                        });
-                    }
-                    deps.stuckDetector.recordEscalation();
-                    deps.state.lastRecoveryIteration = currentIter;
-                    if (deps.stuckDetector.shouldEscalate() && ctx.onMeta) {
-                        const escalation = t("exec.escalation", {
-                            stepId: String(deps.trackerRef.current?.getCurrentStep()?.id ?? "?"),
-                            description: deps.trackerRef.current?.getCurrentStep()?.description ?? "",
-                        });
-                        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();
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>STOP. Step ${step?.id ?? "?"} ("${step?.description ?? ""}") took ${deps.stuckDetector.getIterationsOnCurrentStep()} iterations with no progress. DO NOT continue this step. Immediately call: plan update step=${step?.id ?? "?"} status=done (if code works despite warnings) OR plan update step=${step?.id ?? "?"} status=skipped note="reason". Do NOT make any other tool calls before updating the plan.</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>`,
-                    });
-                    // Block with an explicit reason so the model sees WHY the call
-                    // was blocked (executor shows it via 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);
-            }
-        },
-        onAfterTool: (ctx, call, result) => {
-            // Remember every bash invocation (successful or not) so stuck
-            // detection can reason about e.g. repeated runs with empty output.
-            if (call.name === "bash") {
-                deps.stuckDetector.recordBashOutput(String(call.arguments?.command ?? ""), String(result.output ?? ""));
-            }
-            // 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.
-            const toolText = String(result.output ?? "");
-            if (/error TS\d+|\[Project typecheck failed\]|\[Syntax check failed\]/.test(toolText)) {
-                deps.stuckDetector.recordToolError(call.name, toolText.slice(0, 300));
-            }
-            if (!result.success) {
-                // 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.
-                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>`,
-                            });
-                        }
-                    }
-                }
-                deps.stuckDetector.recordToolError(call.name, result.output);
-                // Immediately queue an actionable hint on failure (don't wait for
-                // the stuck threshold). Flushed in onBeforeThink so it does not
-                // land between tool messages.
-                const actionableHints = deps.stuckDetector.getActionableHints();
-                const alternative = deps.stuckDetector.getToolAlternative();
-                if (actionableHints.length > 0 || alternative) {
-                    const parts = [...actionableHints];
-                    if (alternative) {
-                        parts.push(`Tool "${call.name}" crashed. Try "${alternative}" instead.`);
-                    }
-                    deps.pendingMessages.push({
-                        role: "user",
-                        content: `<system-summary>${t("exec.hints", { hints: parts.map((h) => `- ${h}`).join("\n") })}</system-summary>`,
-                    });
-                }
-            }
-            else {
-                deps.stuckDetector.recordToolSuccess();
-                // 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.
-                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>`,
-                        });
-                    }
-                    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>`,
-                        });
-                    }
-                    else if (/node|tsx|ts-node|python|npm\s+(start|test|run)/.test(cmd)) {
-                        deps.pendingMessages.push({
-                            role: "user",
-                            content: `<system-summary>The command "${cmd}" completed successfully. If this was testing your code, mark the current step as done via plan update step=N status=done.</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),
-                            }));
-                        }
-                    }
-                }
-                deps.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
-            }
-        },
-    };
-}

package/dist/modules/execution/index.js

@@ -1,8 +0,0 @@
-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";