micro-models-agent 0.58.2 → 0.60.0

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,431 +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 { 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;
-/** 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). */
-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. */
-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). */
-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 p.replace(/\\/g, "/").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
- *  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;
-}
-/** 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. */
-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;
-}
-/**
- * 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.
- */
-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;
-}
-/**
- * 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;
-                deps.state.mutationsWithoutPlan = 0;
-                deps.state.planNudgeSent = 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);
-                    // A plan is active — any mutation counter no longer applies.
-                    deps.state.mutationsWithoutPlan = 0;
-                    deps.state.planNudgeSent = false;
-                }
-                else {
-                    deps.stuckDetector.reset();
-                    deps.state.consecutivePlanWarnings = 0;
-                    deps.state.lastStepId = -1;
-                    deps.state.stuckNotified = false;
-                    // 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.
-                    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) {
-                // 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.
-                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()) {
-                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.
-                        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]}`;
-                                }
-                            }
-                        }
-                        ctx.contextManager.addMessage({
-                            role: "user",
-                            content: `<system-summary>${recovery}${tscContext}</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>${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>`,
-                    });
-                    // 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);
-                // Count file-mutating calls made with NO active plan — feeds the
-                // evidence-based plan-creation nudge in onBeforeThink.
-                if (!deps.trackerRef.current &&
-                    (toolName === "write_file" ||
-                        toolName === "edit_file" ||
-                        toolName === "bash" ||
-                        toolName === "download_file")) {
-                    deps.state.mutationsWithoutPlan++;
-                }
-            }
-        },
-        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 ?? ""));
-            }
-            // 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.
-            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 && step.kind !== "delete") {
-                            step.kind = "delete";
-                            deps.store.saveActive(plan);
-                            break;
-                        }
-                    }
-                }
-            }
-            // 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 ?? "");
-            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.
-            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) {
-                    deps.state.typecheckFailures.clear();
-                }
-            }
-            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.
-                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.
-                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>`,
-                            });
-                        }
-                    }
-                }
-                // 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.
-                if (!hasTypeError) {
-                    deps.stuckDetector.recordToolError(call.name, result.output);
-                }
-            }
-            else {
-                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.
-                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>`,
-                        });
-                    }
-                }
-            }
-            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),
-                            }));
-                        }
-                    }
-                }
-            }
-            // 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.
-            if (result.success && FS_MUTATING_TOOLS.has(call.name)) {
-                deps.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
-            }
-            // Automatic web search for a repeatedly failing error (fire-and-forget,
-            // results land in pendingMessages on the next onBeforeThink flush).
-            deps.maybeSearchError(ctx, call);
-        },
-    };
-}

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";