micro-models-agent 0.51.1 → 0.52.0

package/dist/modules/execution/stuck-detector.js

@@ -65,6 +65,136 @@ const READ_ONLY_TOOLS = new Set([
 ]);
 /** Consecutive read-only tool calls that constitute a loop. */
 const READ_ONLY_LOOP_THRESHOLD = 10;
+/**
+ * Bash flailing: ≥BASH_FLAIL_THRESHOLD failures within the last
+ * BASH_FLAIL_WINDOW bash attempts, regardless of interleaved successes.
+ * The per-word hard-stop (bash.ts) is evaded by rotating commands
+ * (wc → cat → Get-Content → …); this window catches the rotation itself
+ * (observed in ses_mt4x3zbo: 8 failed shell tricks across ~12 iterations
+ * trying to count/merge files on Windows).
+ */
+const BASH_FLAIL_WINDOW = 6;
+const BASH_FLAIL_THRESHOLD = 4;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** Пути (абсолютные/относительные) + опционально :line:col. */
+const ERROR_LOC_RE = /(?:[A-Za-z]:[\\/])?(?:[\w.@+-]+[\\/])+[\w.@+-]+\.[a-zA-Z0-9]{1,6}(?::\d+(?::\d+)?)?/g;
+const SIGNATURE_MAX_CHARS = 120;
+const SEARCHABLE_PATTERNS = [
+    /error TS\d+/i,
+    /ERR_[A-Z_]+/,
+    /ENOENT|EACCES|EPERM|ECONNREFUSED|ETIMEDOUT|ECONNRESET|ENOTFOUND|EADDRINUSE/i,
+    /Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i,
+    /TypeError|ReferenceError|SyntaxError|RangeError/i,
+    /is not a function|is not defined|is not a constructor/i,
+    /Cannot read properties of/i,
+    /failed to (compile|build|resolve|parse)/i,
+    /fatal error|panic/i,
+];
+const RUNTIME_WORDS = [
+    "bun",
+    "node",
+    "deno",
+    "npm",
+    "yarn",
+    "pnpm",
+    "pip",
+    "pip3",
+    "python",
+    "python3",
+    "tsc",
+    "tsx",
+    "npx",
+    "go",
+    "cargo",
+    "gradle",
+    "maven",
+    "make",
+];
+const FRAMEWORK_WORDS = [
+    "react",
+    "vue",
+    "angular",
+    "svelte",
+    "vite",
+    "next",
+    "nest",
+    "express",
+    "fastify",
+    "flask",
+    "django",
+    "spring",
+    "webpack",
+    "tailwind",
+];
+/**
+ * Stable identity for an error: tool + normalized first error lines (ANSI
+ * stripped, paths/locations replaced, whitespace collapsed, capped at 120
+ * chars). Two runs failing with the same root cause produce the same
+ * signature — that is what triggers the automatic web search.
+ */
+export function normalizeErrorSignature(toolName, output) {
+    if (!output)
+        return null;
+    const cleaned = output
+        .replace(ANSI_RE, "")
+        .replace(ERROR_LOC_RE, " <path>")
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!cleaned)
+        return null;
+    return `${toolName}::${cleaned.slice(0, SIGNATURE_MAX_CHARS)}`;
+}
+/**
+ * Gate for the automatic web search: only real, meaningful error text is
+ * worth searching for. "Command failed with exit code 1" without details is
+ * noise — searching it would just burn a query.
+ */
+export function isSearchableError(output) {
+    if (!output || !output.trim())
+        return false;
+    const text = output.trim();
+    return SEARCHABLE_PATTERNS.some((p) => p.test(text));
+}
+/**
+ * Build the search query for a failing error: up to 3 cleaned error lines
+ * (paths stripped), prefixed with the runtime and framework detected from the
+ * step/bash context, suffixed with "how to fix". Falls back to `tool step`
+ * when the error text is empty. Capped at maxQueryChars.
+ */
+export function buildSearchQuery(stepDescription, lastBashCommand, lastErrorOutput, toolName, maxQueryChars) {
+    const errorText = (lastErrorOutput || "")
+        .replace(ANSI_RE, "")
+        .replace(ERROR_LOC_RE, " <path>")
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(0, 3)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const context = `${stepDescription} ${lastBashCommand}`.toLowerCase();
+    const runtime = RUNTIME_WORDS.find((w) => context.includes(w)) || "";
+    const framework = FRAMEWORK_WORDS.find((w) => context.includes(w)) || "";
+    let query;
+    if (errorText) {
+        query =
+            runtime && !errorText.toLowerCase().includes(runtime) ? `${runtime} ${errorText}` : errorText;
+        if (framework && !query.toLowerCase().includes(framework))
+            query = `${query} ${framework}`;
+        query = `${query} how to fix`;
+    }
+    else if (runtime || framework) {
+        query = `${[runtime, framework, "error", "how to fix"].filter(Boolean).join(" ")}`;
+    }
+    else {
+        query = `${toolName} ${stepDescription} how to fix`;
+    }
+    return query.slice(0, maxQueryChars);
+}
 export class StuckDetector {
     threshold;
     errorThreshold;
@@ -86,9 +216,14 @@ export class StuckDetector {
     lastBashOutput = "";
     emptyBashRunCount = 0;
     readOnlyStreak = 0;
-    constructor(threshold = 6, errorThreshold = 3) {
+    bashRecent = [];
+    errorSignatureCounts = new Map();
+    searchedErrorSignatures = new Set();
+    webSearchThreshold;
+    constructor(threshold = 6, errorThreshold = 3, webSearchThreshold = 5) {
         this.threshold = threshold;
         this.errorThreshold = errorThreshold;
+        this.webSearchThreshold = webSearchThreshold;
     }
     recordIteration(stepId) {
         if (stepId === this.currentStepId) {
@@ -127,6 +262,10 @@ export class StuckDetector {
         this.lastFailedTool = toolName;
         if (output)
             this.lastErrorOutput = output;
+        const sig = normalizeErrorSignature(toolName, output);
+        if (sig) {
+            this.errorSignatureCounts.set(sig, (this.errorSignatureCounts.get(sig) || 0) + 1);
+        }
     }
     getLastErrorOutput() {
         return this.lastErrorOutput;
@@ -147,6 +286,22 @@ export class StuckDetector {
         this.lastBashCommand = command;
         this.lastBashOutput = output;
     }
+    /** Outcome of one bash attempt (success or failure), for flailing detection. */
+    recordBashAttempt(success) {
+        this.bashRecent.push(success);
+        if (this.bashRecent.length > BASH_FLAIL_WINDOW)
+            this.bashRecent.shift();
+    }
+    /** True when most recent bash attempts failed — the model is flailing. */
+    hasBashFlailing() {
+        if (this.bashRecent.length < BASH_FLAIL_THRESHOLD)
+            return false;
+        let failures = 0;
+        for (const ok of this.bashRecent)
+            if (!ok)
+                failures++;
+        return failures >= BASH_FLAIL_THRESHOLD;
+    }
     getLastBashCommand() {
         return this.lastBashCommand;
     }
@@ -156,6 +311,32 @@ export class StuckDetector {
     getLastFailedTool() {
         return this.lastFailedTool;
     }
+    /**
+     * First error signature whose repetition count reached the web-search
+     * threshold and that has NOT been searched yet (or was unmarked for a
+     * retry). This is what triggers the automatic web search — not iterations
+     * and not the per-tool error count.
+     */
+    getRepeatedErrorSignature() {
+        for (const [sig, count] of this.errorSignatureCounts) {
+            if (count >= this.webSearchThreshold && !this.searchedErrorSignatures.has(sig)) {
+                return sig;
+            }
+        }
+        return null;
+    }
+    getErrorSignatureCount(sig) {
+        return this.errorSignatureCounts.get(sig) || 0;
+    }
+    markErrorSearched(sig) {
+        this.searchedErrorSignatures.add(sig);
+    }
+    unmarkErrorSearched(sig) {
+        this.searchedErrorSignatures.delete(sig);
+    }
+    hasErrorSearched(sig) {
+        return this.searchedErrorSignatures.has(sig);
+    }
     getIterationsOnCurrentStep() {
         return this.iterationsOnCurrentStep;
     }
@@ -163,6 +344,23 @@ export class StuckDetector {
         this.consecutiveFailures = 0;
         this.lastFailedTool = "";
         this.escalationCount = 0;
+        // Decay per-tool error counters on productive calls: a tool that failed
+        // early must not keep the "Tool X failed N times" warning alive forever
+        // (ses_mt4fn58c — bash failed 3x, warning re-logged after 30 successful
+        // writes). Fresh failures rebuild the count.
+        for (const [tool, count] of this.toolErrors) {
+            if (count <= 1)
+                this.toolErrors.delete(tool);
+            else
+                this.toolErrors.set(tool, count - 1);
+        }
+        // Decay iteration counter on productive tool calls — reading new files,
+        // writing, editing all count as progress. Prevents false-positive stuck
+        // warnings during legitimate file exploration (e.g. reading 12 files in
+        // an analysis step).
+        if (this.iterationsOnCurrentStep > 0) {
+            this.iterationsOnCurrentStep = Math.max(0, this.iterationsOnCurrentStep - 1);
+        }
     }
     setCurrentStep(stepId, description) {
         if (stepId !== this.currentStepId) {
@@ -231,16 +429,16 @@ export class StuckDetector {
         const hints = [];
         const desc = this.currentStepDescription.toLowerCase();
         if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
-            hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
+            hints.push(t("exec.hint_deps"));
         }
         if (desc.includes("test") || desc.includes("spec")) {
-            hints.push("Make sure the source files exist and have real code before running tests.");
+            hints.push(t("exec.hint_test"));
         }
         if (desc.includes("build") || desc.includes("compile")) {
-            hints.push("Check that all dependencies are installed and source files are not empty.");
+            hints.push(t("exec.hint_build"));
         }
         if (desc.includes("deploy") || desc.includes("publish")) {
-            hints.push("Verify credentials and network access before deploying.");
+            hints.push(t("exec.hint_deploy"));
         }
         // State-based bullets. The recovery message (getRecoveryMessage) already
         // reports the PRIMARY reason (priority: stuck > tool-errors > consecutive
@@ -249,13 +447,13 @@ export class StuckDetector {
         // bullet when the recovery message is NOT already covering that state.
         const primary = this.getPrimaryReason();
         if (this.hasRepetitiveToolCalls() && primary !== "repetitive") {
-            hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
+            hints.push(t("exec.hint_repetitive"));
         }
         if (this.hasConsecutiveFailures() && primary !== "consecutive") {
-            hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
+            hints.push(t("exec.hint_consecutive"));
         }
         if (this.hasReadOnlyLoop() && primary !== "read-only") {
-            hints.push("You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps.");
+            hints.push(t("exec.hint_read_only"));
         }
         return hints;
     }
@@ -379,6 +577,26 @@ export class StuckDetector {
             count: this.repetitionThreshold,
         });
     }
+    /**
+     * Stable warning identity for anti-spam dedup: the same key re-logged every
+     * iteration is spam, a NEW key (or a long gap) deserves a re-warn.
+     */
+    getWarningKey() {
+        if (this.isStuck())
+            return "stuck";
+        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        if (errorTool)
+            return `tool-errors:${errorTool[0]}`;
+        if (this.hasBashFlailing())
+            return "bash-flailing";
+        if (this.hasConsecutiveFailures())
+            return "consecutive";
+        if (this.hasRepetitiveToolCalls())
+            return "repetitive";
+        if (this.hasReadOnlyLoop())
+            return "read-only";
+        return "";
+    }
     getStuckReason() {
         if (this.isStuck()) {
             return t("exec.stuck", {
@@ -421,6 +639,13 @@ export class StuckDetector {
                 count: this.consecutiveFailures,
             });
         }
+        if (reason === "bash-flailing") {
+            const fails = this.bashRecent.filter((ok) => !ok).length;
+            return t("exec.bash_flailing_recovery", {
+                fails: String(fails),
+                window: String(this.bashRecent.length),
+            });
+        }
         if (reason === "repetitive") {
             return this.getRepetitiveToolMessage();
         }
@@ -444,6 +669,8 @@ export class StuckDetector {
         const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
         if (errorTool)
             return "tool-errors";
+        if (this.hasBashFlailing())
+            return "bash-flailing";
         if (this.hasConsecutiveFailures())
             return "consecutive";
         if (this.hasRepetitiveToolCalls())
@@ -465,7 +692,10 @@ export class StuckDetector {
         this.lastBashCommand = "";
         this.lastBashOutput = "";
         this.emptyBashRunCount = 0;
+        this.bashRecent = [];
         this.readOnlyStreak = 0;
+        this.errorSignatureCounts.clear();
+        this.searchedErrorSignatures.clear();
     }
     /**
      * Reset only step-progress state, keeping the tool-call history and the
@@ -485,6 +715,9 @@ export class StuckDetector {
         this.lastBashCommand = "";
         this.lastBashOutput = "";
         this.emptyBashRunCount = 0;
+        this.bashRecent = [];
+        this.errorSignatureCounts.clear();
+        this.searchedErrorSignatures.clear();
     }
     /**
      * Reset all per-step state when moving to a new step. Prevents errors and
@@ -503,7 +736,10 @@ export class StuckDetector {
         this.lastBashCommand = "";
         this.lastBashOutput = "";
         this.emptyBashRunCount = 0;
+        this.bashRecent = [];
         this.readOnlyStreak = 0;
+        this.errorSignatureCounts.clear();
+        this.searchedErrorSignatures.clear();
         // Preserve escalationCount — prevents agent from "gaming" stuck detection
         // by marking a step done and moving to the next one
     }

package/dist/modules/execution/tracker.js

@@ -1,4 +1,4 @@
-import { PlanCreator } from "./planner";
+import { PlanCreator, getPlanProgress } from "./planner";
 export class PlanTracker {
     plan;
     currentStepIndex = 0;
@@ -53,13 +53,15 @@ export class PlanTracker {
         return this.plan.steps.every((s) => s.status === "done" || s.status === "skipped");
     }
     getProgressString() {
-        const done = this.plan.steps.filter((s) => s.status === "done").length;
-        const total = this.plan.steps.length;
-        const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+        const p = getPlanProgress(this.plan);
+        const total = p.total;
+        const settled = p.settled;
+        const pct = total > 0 ? Math.round((settled / total) * 100) : 0;
         const barWidth = 10;
-        const filled = Math.round((done / total) * barWidth);
+        const filled = Math.round((settled / total) * barWidth);
         const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
-        return `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${bar}  ${pct}%`;
+        const skippedPart = p.skipped > 0 ? ` (${p.skipped} skipped)` : "";
+        return `[${this.plan.id}] ${this.plan.title}  ${settled}/${total}${skippedPart}  ${bar}  ${pct}%`;
     }
     toPromptBlock() {
         return PlanCreator.toPromptBlock(this.plan, this.currentStepIndex);

package/dist/modules/execution/verifier.js

@@ -116,7 +116,7 @@ export class StepVerifier {
             details,
         };
     }
-    async verifyStep(stepDescription) {
+    async verifyStep(stepDescription, kind) {
         const fileMatches = extractFileLikeTokens(stripUrls(stepDescription));
         // No named files — this step cannot be verified by file existence. Do NOT
         // trivially pass (empty every() = true); signal noFiles so the tool guides
@@ -128,7 +128,20 @@ export class StepVerifier {
         let syntaxValid = true;
         for (const filePath of fileMatches) {
             const resolved = findExistingFile(this.baseDir, filePath);
-            if (!resolved) {
+            const exists = !!resolved;
+            if (kind === "delete") {
+                // For delete steps: file NOT existing is a pass
+                results.push({
+                    passed: !exists,
+                    message: exists
+                        ? t("verify.file_still_exists", { path: filePath })
+                        : t("verify.file_not_found", { path: filePath }),
+                });
+                // Don't syntax-check a deleted file
+                continue;
+            }
+            // Create steps: file must exist + valid syntax
+            if (!exists) {
                 results.push({ passed: false, message: t("verify.file_not_found", { path: filePath }) });
                 continue;
             }

package/dist/modules/hallucination/detector.js

@@ -19,6 +19,10 @@ export class HallucinationDetector {
     getConfidenceCheck() {
         return this.confidence;
     }
+    /** Add files known from compaction summaries to the factual checker. */
+    addKnownFiles(files) {
+        this.factual?.addKnownFiles(files);
+    }
     async validate(response) {
         const confidenceResult = this.confidence.validate(response);
         if (confidenceResult.status === "retry" || confidenceResult.status === "block") {

package/dist/modules/hallucination/factual.js

@@ -20,9 +20,18 @@ export class FactualCheck {
     static NAME_CACHE_TTL_MS = 5_000;
     static RESCAN_COOLDOWN_MS = 2_000;
     static MAX_INDEXED_FILES = 20_000;
+    /** Files known from compaction summaries — survive context resets. */
+    knownFiles = new Set();
     constructor(baseDir) {
         this.baseDir = baseDir;
     }
+    /** Add file paths known from compaction summaries. These are checked
+     *  before the filesystem scan so bare filenames from compacted turns
+     *  are recognized even when the directory is in IGNORED_DIRS. */
+    addKnownFiles(files) {
+        for (const f of files)
+            this.knownFiles.add(f);
+    }
     validate(response) {
         const filePaths = this.extractFilePaths(response);
         if (filePaths.length === 0)
@@ -50,19 +59,50 @@ export class FactualCheck {
     pathExists(fp) {
         if (isAbsolute(fp))
             return existsSync(fp);
+        // Check known files from compaction summaries first
+        if (this.knownFiles.has(fp))
+            return true;
+        for (const cand of this.dotfileVariants(fp)) {
+            if (this.knownFiles.has(cand))
+                return true;
+            if (existsSync(resolve(this.baseDir, cand)))
+                return true;
+        }
         // "foo.json" has no directory part — treat it as a bare name that may
         // live anywhere under baseDir (e.g. src/data/bikes.json). Resolving it
         // against the workspace root alone produced false "unknown file" warnings.
         if (!fp.includes("/") && !fp.includes("\\")) {
             return this.bareNameExists(fp);
         }
-        return existsSync(resolve(this.baseDir, fp));
+        return false;
+    }
+    /**
+     * The token regex cannot anchor a leading dot (`\b` never matches between a
+     * non-word char and `.`), so dotfiles (.prettierrc.json, .env, …) are
+     * extracted as "prettierrc.json". Try the dot-prefixed basename too before
+     * declaring the file missing. "src/config.json" also yields
+     * "src/.config.json".
+     */
+    dotfileVariants(fp) {
+        const idx = Math.max(fp.lastIndexOf("/"), fp.lastIndexOf("\\"));
+        const base = idx >= 0 ? fp.slice(idx + 1) : fp;
+        if (base.startsWith("."))
+            return [fp];
+        return idx >= 0 ? [fp, `${fp.slice(0, idx + 1)}.${base}`] : [fp, `.${fp}`];
     }
     bareNameExists(name) {
-        if (existsSync(resolve(this.baseDir, name)))
-            return true;
-        if (this.indexHas(name))
-            return true;
+        for (const cand of this.dotfileVariants(name)) {
+            if (existsSync(resolve(this.baseDir, cand)))
+                return true;
+            if (this.indexHas(cand))
+                return true;
+            // Check known files — a bare name may match a full path from compaction
+            for (const known of this.knownFiles) {
+                if (known.endsWith(`/${cand}`) || known.endsWith(`\\${cand}`) || known === cand) {
+                    return true;
+                }
+            }
+        }
         // A write_file from this session may have created the file after the
         // index was built. Do a one-off rescan (rate-limited) before warning.
         const now = Date.now();

package/dist/modules/indexer/module.js

@@ -180,6 +180,7 @@ export class IndexerModule {
     createProjectMapTool() {
         return {
             name: "project_map",
+            icon: "🗺️",
             alwaysOn: true,
             description: t("indexer.project_map_desc"),
             parameters: {