micro-models-agent 0.51.1 → 0.52.0

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

@@ -1,6 +1,7 @@
 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
@@ -10,6 +11,87 @@ import { platform } from "os";
 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,
@@ -37,6 +119,8 @@ export function createExecutionPlugin(deps) {
                 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();
@@ -48,38 +132,58 @@ export function createExecutionPlugin(deps) {
                     }
                     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;
-                    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) {
+                    // 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>STOP. ${iter} iterations without a plan. You MUST call plan create RIGHT NOW. No more tool calls until you create a plan.</system-summary>`,
+                            content: `<system-summary>${t("exec.plan_nudge", {
+                                count: String(mutations),
+                            })}</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;
+                // 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);
-                    if (deps.stuckDetector.isStuck())
+                    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()) {
@@ -87,33 +191,28 @@ export function createExecutionPlugin(deps) {
                 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"),
-                        });
+                        // 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>${hintMsg}</system-summary>`,
+                            content: `<system-summary>${recovery}${tscContext}</system-summary>`,
                         });
                     }
                     deps.stuckDetector.recordEscalation();
@@ -131,7 +230,11 @@ export function createExecutionPlugin(deps) {
                         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>`,
+                            content: `<system-summary>${t("exec.stop_directive", {
+                                stepId: String(step?.id ?? "?"),
+                                description: step?.description ?? "",
+                                iterations: String(deps.stuckDetector.getIterationsOnCurrentStep()),
+                            })}</system-summary>`,
                         });
                     }
                 }
@@ -168,6 +271,15 @@ export function createExecutionPlugin(deps) {
             const args = ctx?.args;
             if (toolName && args) {
                 deps.stuckDetector.recordToolCall(toolName, args);
+                // Count file-mutating calls made with NO active plan — feeds the
+                // evidence-based plan-creation nudge in onBeforeThink.
+                if (!deps.trackerRef.current &&
+                    (toolName === "write_file" ||
+                        toolName === "edit_file" ||
+                        toolName === "bash" ||
+                        toolName === "download_file")) {
+                    deps.state.mutationsWithoutPlan++;
+                }
             }
         },
         onAfterTool: (ctx, call, result) => {
@@ -176,15 +288,59 @@ export function createExecutionPlugin(deps) {
             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 ?? "");
-            if (/error TS\d+|\[Project typecheck failed\]|\[Syntax check failed\]/.test(toolText)) {
+            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
@@ -205,25 +361,20 @@ export function createExecutionPlugin(deps) {
                         }
                     }
                 }
-                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>`,
-                    });
+                // 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.
@@ -242,12 +393,6 @@ export function createExecutionPlugin(deps) {
                             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")) {
@@ -265,8 +410,22 @@ export function createExecutionPlugin(deps) {
                         }
                     }
                 }
+            }
+            // Auto-advance fires after every successful FILESYSTEM-MUTATING tool —
+            // not just write_file/edit_file. Small models often create files through
+            // bash (`echo ... > f`, heredocs) or delete/move via shell instead of the
+            // dedicated tools, and the plan then never advances past the step even
+            // though its deliverables exist (certification 3.5/3.8: files on disk,
+            // plan stuck at 1/4 and 4/5). Read-only tools MUST stay excluded: a
+            // successful read/glob would otherwise complete an "Update X" step whose
+            // target file already exists from an earlier step — without any edit.
+            // advancePlanIfStepComplete is a no-op when tokens don't resolve.
+            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);
         },
     };
 }