micro-models-agent 0.51.1 → 0.52.0

package/dist/modules/execution/module.js

@@ -1,15 +1,24 @@
 import { t } from "../../i18n/index";
 import { PlanTracker } from "./tracker";
 import { StepVerifier } from "./verifier";
-import { StuckDetector } from "./stuck-detector";
+import { StuckDetector, isSearchableError, buildSearchQuery } from "./stuck-detector";
 import { Auditor, findExistingFile } from "./auditor";
 import { PlanStore } from "./plan-store";
 import { getMessageText } from "../../llm/provider";
 import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
+import { performWebSearch } from "../../tools/web-search";
+import { getSessionSecurityConfig } from "../security/session-isolation";
 import { createPlanToolDefinitions } from "./plan-tool";
-import { createExecutionPlugin, STUCK_RECOVERY_COOLDOWN, } from "./execution-plugin";
+import { createExecutionPlugin, STUCK_RECOVERY_COOLDOWN, STUCK_WARN_REPEAT_EVERY, } from "./execution-plugin";
+/**
+ * Minimum interval between automatic error searches. The spec asked for a
+ * STUCK_RECOVERY_COOLDOWN-iteration cap, but onAfterTool has no iteration
+ * counter (executor context), so the same anti-spam protection is
+ * time-based. Injectable via the constructor for tests (0 disables it).
+ */
+const ERROR_SEARCH_MIN_INTERVAL_MS = 30000;
 export class ExecutionModule {
     name = "execution";
     tracker = null;
@@ -21,6 +30,13 @@ export class ExecutionModule {
     // Skip the first audit after restoring a plan from disk — gives the user
     // one chance to change the subject before the audit gate locks in.
     _auditSkipsRemaining = 0;
+    /**
+     * The last plan that was COMPLETED and auto-archived. `plan update` on the
+     * final step clears the tracker, which used to make runFinalAudit() return
+     * null and silently skip the final audit (tests + tsc + file checks) for a
+     * finished task. Keep the completed plan so the audit gate still runs.
+     */
+    completedPlan = null;
     /**
      * Deferred <system-summary> messages. Injected by onBeforeTool/onAfterTool
      * but flushed in onBeforeThink, so they never land between an assistant
@@ -33,6 +49,13 @@ export class ExecutionModule {
     // failure is evidence-based (actual command failures), not task
     // classification (rule #10).
     forbiddenBashFailures = new Map();
+    searchRunner;
+    webSearchThreshold;
+    searchesThisSession = 0;
+    retryWebSearchSignatures = new Set();
+    lastErrorSearchAt = 0;
+    errorSearchCooldownMs;
+    hallucinationDetector = null;
     /**
      * The execution-plugin's mutable state. Owned HERE and passed BY REFERENCE
      * to the plugin factory — the plugin writes deps.state.* directly, so the
@@ -43,7 +66,12 @@ export class ExecutionModule {
         consecutivePlanWarnings: 0,
         lastStepId: -1,
         stuckNotified: false,
+        lastStuckWarnKey: "",
+        lastStuckWarnIter: -STUCK_WARN_REPEAT_EVERY,
         depsGateHints: new Map(),
+        mutationsWithoutPlan: 0,
+        planNudgeSent: false,
+        typecheckFailures: new Map(),
     };
     /**
      * Read/write accessor for the tracker, shared with the plan-tool and
@@ -63,18 +91,40 @@ export class ExecutionModule {
             },
         };
     })();
-    constructor(baseDir, stuckThreshold = 6) {
+    constructor(baseDir, stuckThreshold = 6, webSearchThreshold = 5, searchRunner = performWebSearch, errorSearchCooldownMs = ERROR_SEARCH_MIN_INTERVAL_MS) {
         this.baseDir = baseDir;
         this.verifier = new StepVerifier(baseDir);
-        this.stuckDetector = new StuckDetector(stuckThreshold);
+        this.stuckDetector = new StuckDetector(stuckThreshold, 3, webSearchThreshold);
         this.auditor = new Auditor(baseDir);
         this.store = new PlanStore(baseDir);
+        this.webSearchThreshold = webSearchThreshold;
+        this.searchRunner = searchRunner;
+        this.errorSearchCooldownMs = errorSearchCooldownMs;
     }
     setPlan(plan) {
         this.tracker = new PlanTracker(plan);
+        // Advance the pointer past any done/skipped steps of a restored/replanned
+        // plan so display ("current: step N") and the off-track alignment match
+        // reality instead of always pointing at step 1.
+        this.tracker.syncCurrentStep();
         this.store.saveActive(plan);
+        this.completedPlan = null; // a new plan supersedes the completed one
         this._auditSkipsRemaining = 0; // plan explicitly created — arm the audit gate
     }
+    /** Wire the hallucination detector so the plan tool can check whether
+     *  a file was tracked as deleted (auto-switch kind gate). */
+    setHallucinationDetector(detector) {
+        this.hallucinationDetector = detector;
+    }
+    /** Remember the last completed plan so the final audit can still verify it
+     *  after the tracker was cleared by the auto-archive. */
+    recordCompleted(plan) {
+        this.completedPlan = plan;
+    }
+    /** Forget the completed plan (abort/delete/purge — nothing left to audit). */
+    clearCompleted() {
+        this.completedPlan = null;
+    }
     restorePlan() {
         const plan = this.store.loadActive();
         if (!plan)
@@ -97,19 +147,107 @@ export class ExecutionModule {
     getTracker() {
         return this.tracker;
     }
+    /** The currently tracked plan (single source of truth for UI consumers).
+     *  Null in a fresh session — a disk-resident plan is restored only when
+     *  resuming a session with history, so the REPL must never see stale plans. */
+    getActivePlan() {
+        return this.tracker?.getPlan() ?? null;
+    }
     getStore() {
         return this.store;
     }
     getStuckDetector() {
         return this.stuckDetector;
     }
+    /**
+     * Automatic web search for a repeatedly failing error (>= errorWebSearch.threshold
+     * identical signatures). Fires the search fire-and-forget (never blocks the tool
+     * result) and queues the results as a <system-summary> in pendingMessages.
+     *
+     * Gates: webSearch master switch + errorWebSearch switch → repeated signature
+     * → not-searched (or retried) → session cap → meaningful error text →
+     * cooldown. One search per signature; empty results trigger a single retry
+     * (unmarkErrorSearched once), then the signature stays searched.
+     */
+    maybeSearchError(ctx, call) {
+        if (ctx.config?.webSearch?.enabled === false)
+            return;
+        const cfg = ctx.config?.errorWebSearch;
+        if (!cfg?.enabled)
+            return;
+        const sig = this.stuckDetector.getRepeatedErrorSignature();
+        if (!sig)
+            return;
+        if (this.stuckDetector.hasErrorSearched(sig) && !this.retryWebSearchSignatures.has(sig))
+            return;
+        if (this.searchesThisSession >= (cfg.maxSearchesPerSession ?? 3))
+            return;
+        const lastError = this.stuckDetector.getLastErrorOutput();
+        if (!isSearchableError(lastError)) {
+            ctx.logger?.debug(t("exec.error_search_no_query"));
+            return;
+        }
+        const now = Date.now();
+        if (now - this.lastErrorSearchAt < this.errorSearchCooldownMs)
+            return;
+        const stepDesc = this.tracker?.getCurrentStep()?.description ?? "";
+        const query = buildSearchQuery(stepDesc, this.stuckDetector.getLastBashCommand(), lastError, call.name, cfg.maxQueryChars ?? 200);
+        const count = this.stuckDetector.getErrorSignatureCount(sig);
+        this.stuckDetector.markErrorSearched(sig);
+        this.searchesThisSession++;
+        this.lastErrorSearchAt = now;
+        const networkConfig = getSessionSecurityConfig(ctx.config, ctx.sessionContext).network;
+        this.searchRunner(query, cfg.maxResults ?? 5, networkConfig, cfg.requestTimeoutMs ?? 10000)
+            .then((res) => {
+            if (!res.success || res.results.length === 0) {
+                if (!this.retryWebSearchSignatures.has(sig)) {
+                    this.retryWebSearchSignatures.add(sig);
+                    this.stuckDetector.unmarkErrorSearched(sig);
+                }
+                ctx.logger?.warn(t("exec.error_search_failed", { query }));
+                ctx.sessionLog?.plan("web-search", `empty/failed: ${query}`);
+                return;
+            }
+            const resultsText = res.results
+                .map((r, i) => `${i + 1}. ${r.title} \u2014 ${r.url}\n   ${r.snippet}`)
+                .join("\n");
+            this.pendingMessages.push({
+                role: "user",
+                content: `<system-summary>${t("exec.error_search_results", {
+                    sig,
+                    count: String(count),
+                    query,
+                    results: resultsText,
+                })}</system-summary>`,
+            });
+        })
+            .catch((e) => ctx.logger?.warn(`error web search: ${e.message}`));
+    }
     /**
      * Final audit before the agent may declare the task done. Returns null when
      * no plan is active; otherwise checks plan completion + artifact existence.
      */
     async runFinalAudit() {
-        if (!this.tracker)
-            return null;
+        // No active tracker: audit the last completed plan instead of bailing.
+        // A plan finished via `plan update` auto-archives and clears the tracker;
+        // without this the final audit (tests + tsc + file checks) was silently
+        // skipped and the model could declare success on broken artifacts.
+        if (!this.tracker) {
+            if (!this.completedPlan)
+                return null;
+            const plan = this.completedPlan;
+            const audit = await this.auditor.audit(plan);
+            const pendingSteps = plan.steps.flatMap((s) => s.status !== "done" && s.status !== "skipped" ? [`${s.id}. ${s.description}`] : []);
+            const done = plan.steps.filter((s) => s.status === "done").length;
+            return {
+                passed: audit.passed && pendingSteps.length === 0,
+                done,
+                total: plan.steps.length,
+                pendingSteps,
+                missingFiles: audit.missingFiles,
+                summary: audit.summary,
+            };
+        }
         if (this._auditSkipsRemaining > 0) {
             this._auditSkipsRemaining--;
             return null;
@@ -167,11 +305,18 @@ export class ExecutionModule {
             trackerRef: this.trackerRef,
             preserveActive: () => this.preserveActive(),
             setPlan: (p) => this.setPlan(p),
+            recordCompleted: (p) => this.recordCompleted(p),
+            clearCompleted: () => this.clearCompleted(),
+            hasStepDeliverables: (s) => this.hasStepDeliverables(s),
             missingStepDeliverables: (s) => this.missingStepDeliverables(s),
             stillExistingDeliverables: (s) => this.stillExistingDeliverables(s),
             parseKinds: (a, st) => this.parseKinds(a, st),
             getTaskText: (c) => this.getTaskText(c),
+            typecheckFailures: this.state.typecheckFailures,
             baseDir: this.baseDir,
+            wasFileDeleted: this.hallucinationDetector
+                ? (path) => this.hallucinationDetector.getConsistencyCheck().getDeletedFiles().includes(path)
+                : undefined,
         });
     }
     getPlugin() {
@@ -181,8 +326,10 @@ export class ExecutionModule {
             pendingMessages: this.pendingMessages,
             forbiddenBashFailures: this.forbiddenBashFailures,
             state: this.state,
+            store: this.store,
             checkPlanAlignment: (call) => this.checkPlanAlignment(call),
             advancePlanIfStepComplete: (cm, sl) => this.advancePlanIfStepComplete(cm, sl),
+            maybeSearchError: (ctx, call) => this.maybeSearchError(ctx, call),
         });
     }
     preserveActive() {
@@ -218,7 +365,11 @@ export class ExecutionModule {
         const stepPaths = extractFileLikeTokens(stripUrls(step.description)).map((p) => p.toLowerCase());
         if (stepPaths.length === 0)
             return null;
-        const argStr = JSON.stringify(call.arguments);
+        // Only path-ish arguments are inspected. JSON-stringifying the whole args
+        // blob made write_file/edit_file `content` feed its code tokens into the
+        // off-path check (e.g. `import "./styles.css"` inside the file body) and
+        // raised phantom alignment warnings for on-track writes.
+        const argStr = this.pathArgStrings(call.arguments).join(" ");
         const callPaths = extractFileLikeTokens(stripUrls(argStr)).map((p) => p.toLowerCase());
         if (callPaths.length === 0)
             return null;
@@ -248,6 +399,28 @@ export class ExecutionModule {
             tool: call.name,
         });
     }
+    /** String values of the path-like arguments of a tool call. Limits the
+     *  off-path alignment check to arguments that actually name files (path,
+     *  file, dir, src, dst, source, target, input, output, destination, glob,
+     *  workdir, cwd, command, pattern) and never scans payload content. */
+    pathArgStrings(args) {
+        if (!args)
+            return [];
+        const out = [];
+        for (const [key, value] of Object.entries(args)) {
+            if (!/path|file|dir|src|dst|source|target|input|output|destination|glob|workdir|cwd|command|pattern|query/i.test(key)) {
+                continue;
+            }
+            if (typeof value === "string")
+                out.push(value);
+            else if (Array.isArray(value)) {
+                for (const v of value)
+                    if (typeof v === "string")
+                        out.push(v);
+            }
+        }
+        return out;
+    }
     advancePlanIfStepComplete(contextManager, sessionLog) {
         const step = this.tracker?.getCurrentStep();
         if (!step)
@@ -259,11 +432,11 @@ export class ExecutionModule {
         // allGone trivially true and auto-advancing a delete step while the real
         // files to delete still exist (the raw regex path did exactly that).
         const stepPaths = extractFileLikeTokens(stripUrls(step.description)) || [];
-        // Step gate: verify dependencies when mentioned — check BEFORE file paths
-        const isDepsStep = stepText.includes("install") ||
-            stepText.includes("зависим") ||
-            stepText.includes("init") ||
-            stepText.includes("инициализац");
+        // Step gate: verify dependencies when mentioned — check BEFORE file paths.
+        // Requires an actual package-manager verb (rule #10 — no bare keyword
+        // matching: "init" alone or "setup project" must NOT trigger the lockfile
+        // hint, only concrete dependency-install commands do).
+        const isDepsStep = /(?:npm|bun|yarn|pnpm|pip|pip3|pipenv|poetry|composer|deno|go|gem|cargo)\s+(?:install|add|init|i|get)\b|bun\s+(?:add|install)|npm\s+(?:i|install|add)|(?:install|установ\w*)\s+(?:dependencies|зависимост\w*|пакет\w*|packages?)/i.test(stepText);
         if (isDepsStep) {
             const lockFiles = [
                 "package-lock.json",
@@ -299,23 +472,32 @@ export class ExecutionModule {
         }
         if (stepPaths.length === 0)
             return;
-        const allExist = stepPaths.every((p) => existsSync(resolve(this.baseDir, p)));
-        const allGone = stepPaths.every((p) => !existsSync(resolve(this.baseDir, p)));
+        // Resolve tokens with the SAME subtree walk the deliverable gate and the
+        // auditor use (findExistingFile), so a nested file
+        // ("bicycle-shop/src/bicycles.ts" for token "src/bicycles.ts") counts as
+        // present. The old exact existsSync(resolve()) never matched nested
+        // projects, so auto-advance stayed silent even after the model wrote the
+        // real file.
+        const resolved = stepPaths.map((p) => findExistingFile(this.baseDir, p));
+        const allExist = resolved.every((r) => r !== null);
+        const allGone = resolved.every((r) => r === null);
         const satisfied = step.kind === "delete" ? allGone && !allExist : allExist;
         if (!satisfied)
             return;
         // Step gate: verify files have content (not empty)
         if (step.kind !== "delete") {
             const emptyFiles = [];
-            for (const p of stepPaths) {
+            for (const r of resolved) {
+                if (!r)
+                    continue;
                 try {
-                    const content = readFileSync(resolve(this.baseDir, p), "utf-8");
+                    const content = readFileSync(r, "utf-8");
                     if (content.trim().length < 10) {
-                        emptyFiles.push(p);
+                        emptyFiles.push(r);
                     }
                 }
                 catch {
-                    // If we can't read it, rely on existsSync result
+                    // If we can't read it, rely on the existence result
                 }
             }
             if (emptyFiles.length > 0 && contextManager) {
@@ -354,6 +536,7 @@ export class ExecutionModule {
         if (this.tracker?.isComplete()) {
             const completed = this.tracker.getPlan();
             this.store.archivePlan(completed);
+            this.recordCompleted(completed); // final audit still verifies it
             this.tracker = null;
             sessionLog?.plan("auto-archive", `Plan ${completed.id} complete — archived`);
         }
@@ -383,6 +566,12 @@ export class ExecutionModule {
             return [];
         return tokens.filter((p) => findExistingFile(this.baseDir, p));
     }
+    /** Whether a step description names at least one real file token. Steps
+     *  with no file tokens (pure commands, verification runs) cannot be
+     *  auto-verified — the done-gate is vacuous for them. */
+    hasStepDeliverables(step) {
+        return extractFileLikeTokens(stripUrls(step.description)).length > 0;
+    }
     /**
      * Validate the optional per-step `kinds` argument for plan create and
      * update-with-steps. Returns length-aligned kinds or an i18n error string.

package/dist/modules/execution/moe-executor.js

@@ -86,7 +86,6 @@ async function executeSubtask(subtask, deps, _sharedContext) {
     }
     const maxAttempts = expertConfig.max_attempts || 3;
     let lastError = "";
-    let lastResult = null;
     const stuckDetector = new StuckDetector(maxAttempts * 2, maxAttempts);
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         stuckDetector.recordIteration(1);
@@ -144,7 +143,6 @@ async function executeSubtask(subtask, deps, _sharedContext) {
                 };
             }
             lastError = result.output;
-            lastResult = result;
             stuckDetector.recordToolError("subagent", result.output);
             // Inject actionable hints into the next retry's prompt
             if (attempt < maxAttempts) {
@@ -260,23 +258,41 @@ export class MoEExecutor {
         }
         for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
             const wave = waves[waveIdx];
-            const wavePromises = wave.map((subtask) => executeSubtask(subtask, this.deps, plan.shared_context)
-                .then((result) => {
+            // Cap concurrent subtasks per wave (rateLimits.maxParallelTasks, default 5).
+            const maxParallel = this.deps.config?.security?.rateLimits?.maxParallelTasks ?? 5;
+            let active = 0;
+            const waiters = [];
+            const acquire = () => active < maxParallel
+                ? Promise.resolve(active++)
+                : new Promise((resolve) => waiters.push(() => resolve(active++)));
+            const release = () => {
+                active--;
+                const next = waiters.shift();
+                if (next)
+                    next();
+            };
+            const wavePromises = wave.map(async (subtask) => {
+                await acquire();
+                let result;
+                try {
+                    result = await executeSubtask(subtask, this.deps, plan.shared_context);
+                }
+                catch (e) {
+                    result = {
+                        subtaskId: subtask.id,
+                        success: false,
+                        summary: `Unhandled error: ${subtask.id}`,
+                        result: "",
+                        error: e instanceof Error ? e.message : String(e),
+                        durationMs: 0,
+                    };
+                }
+                finally {
+                    release();
+                }
                 results.push(result);
                 return result;
-            })
-                .catch((e) => {
-                const errResult = {
-                    subtaskId: subtask.id,
-                    success: false,
-                    summary: `Unhandled error: ${subtask.id}`,
-                    result: "",
-                    error: e.message,
-                    durationMs: 0,
-                };
-                results.push(errResult);
-                return errResult;
-            }));
+            });
             await Promise.all(wavePromises);
         }
         const failed = results.filter((r) => !r.success);
@@ -285,7 +301,4 @@ export class MoEExecutor {
         }
         return { success: failed.length === 0, results, errors, warnings };
     }
-    getChainMaxAttempts() {
-        return 3;
-    }
 }

package/dist/modules/execution/plan-store.js

@@ -154,4 +154,43 @@ export class PlanStore {
             return { plan: archived, status: "archived" };
         return null;
     }
+    // ---- Deletion (the user asked for plans to actually go away) ----
+    /** Permanently delete a plan wherever it lives. Returns its status, or null
+     *  when no plan with that id exists. */
+    deletePlan(id) {
+        const active = this.loadActive();
+        if (active && active.id === id) {
+            this.clearActive();
+            return "active";
+        }
+        const draftPath = join(this.draftsDir, `${id}.json`);
+        if (existsSync(draftPath)) {
+            rmSync(draftPath, { force: true });
+            return "draft";
+        }
+        const archivedPath = join(this.archiveDir, `${id}.json`);
+        if (existsSync(archivedPath)) {
+            rmSync(archivedPath, { force: true });
+            return "archived";
+        }
+        return null;
+    }
+    /** Delete every plan (active, drafts, archive). Returns the number removed. */
+    purgeAll() {
+        let n = 0;
+        const active = this.loadActive();
+        if (active) {
+            this.clearActive();
+            n++;
+        }
+        for (const p of this.listDrafts()) {
+            this.removeDraft(p.id);
+            n++;
+        }
+        for (const p of this.listArchived()) {
+            this.removeArchived(p.id);
+            n++;
+        }
+        return n;
+    }
 }