micro-models-agent 0.41.2 → 0.43.0

package/dist/modules/execution/module.js

@@ -1,15 +1,17 @@
 import { t } from "../../i18n/index";
+import { PlanCreator } from "./planner";
 import { PlanTracker } from "./tracker";
 import { StepVerifier } from "./verifier";
 import { StuckDetector } from "./stuck-detector";
-import { Auditor, findExistingFile } from "./auditor";
+import { Auditor } from "./auditor";
 import { PlanStore } from "./plan-store";
+import { checkPlanCoverage } from "./plan-coverage";
 import { getMessageText } from "../../llm/provider";
-import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
-import { createPlanToolDefinitions } from "./plan-tool";
-import { createExecutionPlugin, STUCK_RECOVERY_COOLDOWN, } from "./execution-plugin";
+const STUCK_RECOVERY_COOLDOWN = 5;
+const MAX_PLAN_WARNINGS_BEFORE_BLOCK = 3;
+const FORCE_SKIP_THRESHOLD = 10;
 export class ExecutionModule {
     name = "execution";
     tracker = null;
@@ -18,9 +20,17 @@ export class ExecutionModule {
     auditor;
     store;
     baseDir;
+    lastRecoveryIteration = -STUCK_RECOVERY_COOLDOWN;
+    consecutivePlanWarnings = 0;
+    lastStepId = -1;
+    // How many times the deps-step gate has warned for each step id — used to
+    // escalate from a soft hint to a MUST-update instruction (models otherwise
+    // spin on "install dependencies" steps they invented themselves).
+    depsGateHints = new Map();
     // 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;
+    stuckNotified = false;
     /**
      * Deferred <system-summary> messages. Injected by onBeforeTool/onAfterTool
      * but flushed in onBeforeThink, so they never land between an assistant
@@ -28,41 +38,6 @@ export class ExecutionModule {
      * buries the warnings the model should react to).
      */
     pendingMessages = [];
-    // Per-command failure counters for forbidden Windows commands (grep/sed/ls/
-    // find/… invoked through the bash tool). A hard stop after the second
-    // failure is evidence-based (actual command failures), not task
-    // classification (rule #10).
-    forbiddenBashFailures = new Map();
-    /**
-     * The execution-plugin's mutable state. Owned HERE and passed BY REFERENCE
-     * to the plugin factory — the plugin writes deps.state.* directly, so the
-     * assignments are visible on the module without any write-back.
-     */
-    state = {
-        lastRecoveryIteration: -STUCK_RECOVERY_COOLDOWN,
-        consecutivePlanWarnings: 0,
-        lastStepId: -1,
-        stuckNotified: false,
-        depsGateHints: new Map(),
-    };
-    /**
-     * Read/write accessor for the tracker, shared with the plan-tool and
-     * execution-plugin factories. The `plan` tool's abort action clears it
-     * (current = null) — the setter keeps this.tracker in sync. Object-literal
-     * getters bind `this` to the literal, so the instance is captured in a
-     * closure instead.
-     */
-    trackerRef = (() => {
-        const self = this;
-        return {
-            get current() {
-                return self.tracker;
-            },
-            set current(v) {
-                self.tracker = v;
-            },
-        };
-    })();
     constructor(baseDir, stuckThreshold = 6) {
         this.baseDir = baseDir;
         this.verifier = new StepVerifier(baseDir);
@@ -79,16 +54,7 @@ export class ExecutionModule {
         const plan = this.store.loadActive();
         if (!plan)
             return false;
-        const restored = new PlanTracker(plan);
-        // A plan that was already complete when saved must not come back as the
-        // active plan — archive it so it cannot re-anchor the agent (restored
-        // completed plans caused the "continue step 4" loop on restart).
-        if (restored.isComplete()) {
-            this.store.archivePlan(plan);
-            this.tracker = null;
-            return false;
-        }
-        this.tracker = restored;
+        this.tracker = new PlanTracker(plan);
         // Advance to the first non-done step
         this.tracker.syncCurrentStep();
         this._auditSkipsRemaining = 1; // restored plan — one free pass
@@ -116,7 +82,9 @@ export class ExecutionModule {
         }
         const plan = this.tracker.getPlan();
         const audit = await this.auditor.audit(plan);
-        const pendingSteps = plan.steps.flatMap((s) => s.status !== "done" && s.status !== "skipped" ? [`${s.id}. ${s.description}`] : []);
+        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;
         const passed = audit.passed && pendingSteps.length === 0;
         return {
@@ -129,7 +97,7 @@ export class ExecutionModule {
         };
     }
     getSystemPromptBlock() {
-        if (!this.tracker || this.tracker.isComplete())
+        if (!this.tracker)
             return null;
         return {
             content: this.tracker.toPromptBlock(),
@@ -138,52 +106,505 @@ export class ExecutionModule {
             estimatedTokens: 200,
         };
     }
-    /**
-     * Short "current plan" line for the compaction summary. Null when no plan
-     * is active. For 9B models the explicit instruction "continue it, do NOT
-     * create a new plan" matters — after compaction the plan block is visible
-     * but the model re-creates the plan anyway (observed: ses_msvuao0h).
-     *
-     * When the plan is complete, the summary says the plan is done and the
-     * model may create a new plan — NOT "continue step 4, do NOT create a
-     * new plan" which anchored the ses_msxjbnm4 loop.
-     */
-    getPlanSummary() {
-        if (!this.tracker)
-            return null;
-        const plan = this.tracker.getPlan();
-        const done = plan.steps.filter((s) => s.status === "done").length;
-        const total = plan.steps.length;
-        if (this.tracker.isComplete()) {
-            return `[${plan.id}] "${plan.title}" ${done}/${total} done — plan complete. You may create a new plan for new work (plan create), or reply with your final answer.`;
-        }
-        const current = this.tracker.getCurrentStepIndex() + 1;
-        return `[${plan.id}] "${plan.title}" ${done}/${total} done, current: step ${current} — continue it (plan show / re-plan), do NOT create a new plan`;
-    }
     getToolDefinitions() {
-        return createPlanToolDefinitions({
-            store: this.store,
-            verifier: this.verifier,
-            trackerRef: this.trackerRef,
-            preserveActive: () => this.preserveActive(),
-            setPlan: (p) => this.setPlan(p),
-            missingStepDeliverables: (s) => this.missingStepDeliverables(s),
-            stillExistingDeliverables: (s) => this.stillExistingDeliverables(s),
-            parseKinds: (a, st) => this.parseKinds(a, st),
-            getTaskText: (c) => this.getTaskText(c),
-            baseDir: this.baseDir,
-        });
+        return [
+            {
+                name: "plan",
+                description: 'Create, update, show, abort, list, switch, or re-plan multi-step plans.\n\nActions:\n- create: Start a new plan. Previous active plan is auto-preserved: incomplete → draft, complete → archive.\n- update: Mark step status (done/failed/skipped), or rebuild plan with new steps.\n- show: Print current plan checklist.\n- abort: Archive current plan and clear active slot.\n- list: Show all plans (active, drafts, archived) with progress.\n- switch: Make a different plan active (by plan id).\n- re-plan: Iterative replanning: keep completed steps, replace remaining with new steps.\n\nWrite CONCRETE steps with exact file paths and commands:\n- Specify WHICH files to create with exact paths (e.g. "create src/components/Header.tsx with navigation and logo")\n- Specify WHICH packages to install (e.g. "run npm install react react-dom")\n- Specify WHICH CLI commands to run with exact arguments\n- Each step should include at least one file extension (.ts, .tsx, .json, etc.) or a command verb (install, create, build, run, add, init)\n- Good: "Создать src/components/Header.tsx с навигацией и логотипом"\n- Bad: "Настройка проекта" (too vague — what exactly needs to be configured?)',
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: [
+                                "create",
+                                "update",
+                                "show",
+                                "abort",
+                                "list",
+                                "switch",
+                                "re-plan",
+                            ],
+                        },
+                        title: { type: "string" },
+                        steps: { type: "array", items: { type: "string" } },
+                        step: { type: "number" },
+                        status: { type: "string", enum: ["done", "failed", "skipped"] },
+                        note: { type: "string" },
+                        id: { type: "string", description: "Plan id (for switch action)" },
+                    },
+                    required: ["action"],
+                },
+                handler: async (_ctx, args) => {
+                    const action = String(args.action);
+                    if (action === "list") {
+                        const metas = this.store.listAll();
+                        if (metas.length === 0) {
+                            return { success: true, output: t("plan.list_empty") };
+                        }
+                        const lines = metas.map((m) => {
+                            const icon = m.status === "active"
+                                ? "[*]"
+                                : m.status === "draft"
+                                    ? "[ ]"
+                                    : "[-]";
+                            const namePart = m.name ? ` (${m.name})` : "";
+                            return `${icon} ${m.id}${namePart} — ${m.title}  ${m.doneCount}/${m.stepCount}`;
+                        });
+                        return {
+                            success: true,
+                            output: `${t("plan.list_header")}\n${lines.join("\n")}`,
+                        };
+                    }
+                    if (action === "switch") {
+                        const planId = String(args.id || "");
+                        if (!planId) {
+                            return { success: false, output: t("plan.switch_no_id") };
+                        }
+                        const found = this.store.find(planId);
+                        if (!found) {
+                            return {
+                                success: false,
+                                output: t("plan.not_found", { id: planId }),
+                            };
+                        }
+                        this.preserveActive();
+                        if (found.status === "draft") {
+                            this.store.removeDraft(found.plan.id);
+                        }
+                        else if (found.status === "archived") {
+                            this.store.removeArchived(found.plan.id);
+                        }
+                        this.setPlan(found.plan);
+                        const display = PlanCreator.toPromptBlock(found.plan, 0);
+                        return {
+                            success: true,
+                            output: t("plan.switched", {
+                                id: found.plan.id,
+                                title: found.plan.title,
+                            }),
+                            display,
+                        };
+                    }
+                    if (action === "re-plan") {
+                        if (!this.tracker) {
+                            return { success: false, output: t("plan.no_active") };
+                        }
+                        const newSteps = Array.isArray(args.steps)
+                            ? args.steps.map(String)
+                            : [];
+                        if (newSteps.length === 0) {
+                            return { success: false, output: t("plan.replan_no_steps") };
+                        }
+                        const oldPlan = this.tracker.getPlan();
+                        const replanned = PlanCreator.replan(oldPlan, newSteps, args.title ? String(args.title) : undefined);
+                        const keptCount = replanned.steps.length - newSteps.length;
+                        this.setPlan(replanned);
+                        const display = PlanCreator.toPromptBlock(replanned, keptCount);
+                        return {
+                            success: true,
+                            output: t("plan.replanned", {
+                                kept: String(keptCount),
+                                steps: String(newSteps.length),
+                            }),
+                            display,
+                        };
+                    }
+                    if (action === "create") {
+                        const title = String(args.title || "Task Plan");
+                        const steps = Array.isArray(args.steps)
+                            ? args.steps.map(String)
+                            : [];
+                        if (steps.length === 0) {
+                            return { success: false, output: t("plan.no_steps") };
+                        }
+                        this.preserveActive();
+                        const plan = PlanCreator.createPlan(title, steps, this.baseDir);
+                        this.setPlan(plan);
+                        const display = PlanCreator.toPromptBlock(plan, 0);
+                        let output = t("plan.created", {
+                            title,
+                            steps: String(steps.length),
+                        });
+                        let displayOut = display;
+                        const taskText = this.getTaskText(_ctx);
+                        if (taskText) {
+                            const { missing } = checkPlanCoverage(taskText, steps);
+                            if (missing.length > 0) {
+                                const warn = t("plan.coverage_warning", {
+                                    missing: missing.join(", "),
+                                });
+                                output += `\n⚠️ ${warn}`;
+                                displayOut = `${display}\n⚠️ ${warn}`;
+                            }
+                        }
+                        return {
+                            success: true,
+                            output,
+                            display: displayOut,
+                        };
+                    }
+                    if (action === "show") {
+                        if (!this.tracker) {
+                            return { success: false, output: t("plan.no_active") };
+                        }
+                        const display = this.tracker.toPromptBlock();
+                        return {
+                            success: true,
+                            output: `${t("plan.show_header")}\n${display}`,
+                            display,
+                        };
+                    }
+                    if (action === "update" && args.step && this.tracker) {
+                        this.tracker.updateStepStatus(Number(args.step), args.status || "done");
+                        if (args.note)
+                            this.tracker.addNote(Number(args.step), String(args.note));
+                        this.tracker.syncCurrentStep();
+                        this.store.saveActive(this.tracker.getPlan());
+                        const progress = this.tracker.getProgressString();
+                        const display = this.tracker.toPromptBlock();
+                        _ctx.sessionLog?.plan("step-update", `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })} | ${progress} | current: step ${this.tracker.getCurrentStepIndex() + 1}`);
+                        return {
+                            success: true,
+                            output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}`,
+                            display,
+                        };
+                    }
+                    if (action === "update" &&
+                        Array.isArray(args.steps) &&
+                        args.steps.length > 0 &&
+                        this.tracker) {
+                        const title = String(args.title || this.tracker.getPlan().title);
+                        const steps = args.steps.map(String);
+                        const plan = PlanCreator.createPlan(title, steps, this.baseDir);
+                        this.setPlan(plan);
+                        const display = PlanCreator.toPromptBlock(plan, 0);
+                        const output = t("plan.updated", {
+                            title,
+                            steps: String(steps.length),
+                        });
+                        return {
+                            success: true,
+                            output,
+                            display,
+                        };
+                    }
+                    if (action === "abort") {
+                        if (this.tracker) {
+                            this.store.archivePlan(this.tracker.getPlan());
+                        }
+                        this.tracker = null;
+                        this.store.clearActive();
+                        return { success: true, output: t("plan.aborted") };
+                    }
+                    if (!this.tracker) {
+                        return { success: false, output: t("plan.no_active") };
+                    }
+                    return {
+                        success: false,
+                        output: t("plan.unknown_action", { action }),
+                    };
+                },
+            },
+            {
+                name: "todo",
+                description: "Manage sub-tasks within current plan step. Use to break down complex steps into smaller tasks.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["add", "done", "list"] },
+                        items: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["action"],
+                },
+                handler: async (_ctx, args) => {
+                    if (!this.tracker) {
+                        return { success: false, output: t("plan.no_active") };
+                    }
+                    const action = String(args.action);
+                    const currentStep = this.tracker.getCurrentStep();
+                    if (!currentStep) {
+                        return { success: false, output: t("plan.step_not_found") };
+                    }
+                    if (action === "add" && Array.isArray(args.items)) {
+                        const items = args.items.map(String);
+                        currentStep.note = currentStep.note
+                            ? `${currentStep.note}; ${items.join(", ")}`
+                            : items.join(", ");
+                        return {
+                            success: true,
+                            output: t("todo.added", {
+                                count: String(items.length),
+                                items: items.join(", "),
+                            }),
+                        };
+                    }
+                    if (action === "done") {
+                        if (!currentStep) {
+                            return { success: false, output: t("plan.step_not_found") };
+                        }
+                        this.tracker.updateStepStatus(currentStep.id, "done");
+                        this.tracker.syncCurrentStep();
+                        this.store.saveActive(this.tracker.getPlan());
+                        const display = this.tracker.toPromptBlock();
+                        return {
+                            success: true,
+                            output: t("plan.step_status", {
+                                step: String(currentStep.id),
+                                status: "done",
+                            }),
+                            display,
+                        };
+                    }
+                    if (action === "list") {
+                        const note = currentStep.note || "(no sub-tasks)";
+                        return {
+                            success: true,
+                            output: `Step ${currentStep.id}: ${currentStep.description}\nSub-tasks: ${note}`,
+                        };
+                    }
+                    return {
+                        success: false,
+                        output: t("todo.unknown_action", { action }),
+                    };
+                },
+            },
+            {
+                name: "verify",
+                description: "Run verification for the current step. Checks files mentioned in the step description.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        step: { type: "number", description: "Step number to verify" },
+                    },
+                },
+                handler: async (_ctx, args) => {
+                    if (!this.tracker)
+                        return { success: false, output: t("plan.no_active") };
+                    const step = args.step
+                        ? this.tracker.getStep(Number(args.step))
+                        : this.tracker.getCurrentStep();
+                    if (!step)
+                        return { success: false, output: t("plan.step_not_found") };
+                    const result = await this.verifier.verifyStep(step.description);
+                    return {
+                        success: result.passed,
+                        output: result.passed
+                            ? t("verify.passed")
+                            : t("verify.failed", {
+                                details: result.failed.map((f) => f.message).join("; "),
+                            }),
+                    };
+                },
+            },
+        ];
     }
     getPlugin() {
-        return createExecutionPlugin({
-            stuckDetector: this.stuckDetector,
-            trackerRef: this.trackerRef,
-            pendingMessages: this.pendingMessages,
-            forbiddenBashFailures: this.forbiddenBashFailures,
-            state: this.state,
-            checkPlanAlignment: (call) => this.checkPlanAlignment(call),
-            advancePlanIfStepComplete: (cm, sl) => this.advancePlanIfStepComplete(cm, sl),
-        });
+        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 && this.pendingMessages.length > 0) {
+                    for (const m of this.pendingMessages.splice(0)) {
+                        ctx.contextManager.addMessage(m);
+                    }
+                }
+                if (this.tracker?.isComplete()) {
+                    // All steps done/skipped — stop counting "no progress" against the
+                    // last step and silence stuck warnings for a finished plan.
+                    this.stuckDetector.reset();
+                    this.consecutivePlanWarnings = 0;
+                    this.lastStepId = -1;
+                    this.stuckNotified = false;
+                }
+                else {
+                    const step = this.tracker?.getCurrentStep();
+                    if (this.tracker && step) {
+                        if (step.id !== this.lastStepId) {
+                            this.consecutivePlanWarnings = 0;
+                            this.lastStepId = step.id;
+                            this.stuckNotified = false;
+                        }
+                        this.stuckDetector.setCurrentStep(step.id, step.description);
+                        this.stuckDetector.recordIteration(step.id);
+                    }
+                    else {
+                        this.stuckDetector.reset();
+                        this.consecutivePlanWarnings = 0;
+                        this.lastStepId = -1;
+                        this.stuckNotified = false;
+                        const iter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
+                        if (iter === 3 && !this.tracker && 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 && !this.tracker && ctx.contextManager) {
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>STOP. ${iter} iterations without a plan. You MUST call plan create RIGHT NOW. No more tool calls until you create a plan.</system-summary>`,
+                            });
+                        }
+                    }
+                }
+                const stuckReason = this.stuckDetector.getStuckReason();
+                if (stuckReason) {
+                    // Log once per stuck episode instead of spamming every iteration.
+                    const logIt = this.stuckDetector.isStuck()
+                        ? !this.stuckNotified
+                        : true;
+                    if (logIt) {
+                        ctx.logger?.warn(stuckReason);
+                        ctx.sessionLog?.plan("stuck-warning", stuckReason, typeof ctx.iteration === "number" ? ctx.iteration : undefined);
+                        if (this.stuckDetector.isStuck())
+                            this.stuckNotified = true;
+                    }
+                }
+                if (this.stuckDetector.isStuck() ||
+                    this.stuckDetector.hasRepetitiveToolCalls()) {
+                    const currentIter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
+                    if (currentIter - this.lastRecoveryIteration >=
+                        STUCK_RECOVERY_COOLDOWN) {
+                        const recovery = this.stuckDetector.getRecoveryMessage();
+                        if (recovery && ctx.contextManager) {
+                            const lastError = this.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 = this.stuckDetector.getActionableHints();
+                            const actionableHintStr = actionableHints.length > 0
+                                ? `\n${t("exec.hints", { hints: actionableHints.map((h) => `- ${h}`).join("\n") })}`
+                                : "";
+                            // Tool alternative suggestion
+                            const alternative = this.stuckDetector.getToolAlternative();
+                            const altHint = alternative
+                                ? `\nTool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}" instead.`
+                                : "";
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>${recovery}${skillHint}${actionableHintStr}${altHint}</system-summary>`,
+                            });
+                        }
+                        const hints = this.stuckDetector.getHints();
+                        if (hints.length > 0 && ctx.contextManager) {
+                            const hintMsg = t("exec.hints", {
+                                hints: hints.map((h) => `- ${h}`).join("\n"),
+                            });
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>${hintMsg}</system-summary>`,
+                            });
+                        }
+                        this.stuckDetector.recordEscalation();
+                        this.lastRecoveryIteration = currentIter;
+                        if (this.stuckDetector.shouldEscalate() && ctx.onMeta) {
+                            const escalation = t("exec.escalation", {
+                                stepId: String(this.tracker?.getCurrentStep()?.id ?? "?"),
+                                description: this.tracker?.getCurrentStep()?.description ?? "",
+                            });
+                            ctx.onMeta(escalation);
+                        }
+                        // Force skip after too many iterations on the same step
+                        if (this.stuckDetector.getIterationsOnCurrentStep() >=
+                            FORCE_SKIP_THRESHOLD &&
+                            ctx.contextManager) {
+                            const step = this.tracker?.getCurrentStep();
+                            ctx.contextManager.addMessage({
+                                role: "user",
+                                content: `<system-summary>STOP. Step ${step?.id ?? "?"} ("${step?.description ?? ""}") took ${this.stuckDetector.getIterationsOnCurrentStep()} iterations with no progress. DO NOT continue this step. Immediately call: plan update step=${step?.id ?? "?"} status=done (if code works despite warnings) OR plan update step=${step?.id ?? "?"} status=skipped note="reason". Do NOT make any other tool calls before updating the plan.</system-summary>`,
+                            });
+                        }
+                    }
+                }
+            },
+            onBeforeTool: (_ctx, call) => {
+                const warning = this.checkPlanAlignment(call);
+                if (warning) {
+                    this.pendingMessages.push({
+                        role: "user",
+                        content: `<system-summary>${warning}</system-summary>`,
+                    });
+                    this.consecutivePlanWarnings++;
+                    if (this.consecutivePlanWarnings >= MAX_PLAN_WARNINGS_BEFORE_BLOCK) {
+                        this.pendingMessages.push({
+                            role: "user",
+                            content: `<system-summary>${t("exec.plan_blocked", { step: String(this.tracker?.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(this.tracker?.getCurrentStep()?.id ?? "?"),
+                            max: MAX_PLAN_WARNINGS_BEFORE_BLOCK,
+                        });
+                    }
+                }
+                else {
+                    this.consecutivePlanWarnings = 0;
+                }
+                return true;
+            },
+            onToolCall: (ctx) => {
+                const toolName = ctx?.toolName;
+                const args = ctx?.args;
+                if (toolName && args) {
+                    this.stuckDetector.recordToolCall(toolName, args);
+                }
+            },
+            onAfterTool: (ctx, call, result) => {
+                if (!result.success) {
+                    this.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 = this.stuckDetector.getActionableHints();
+                    const alternative = this.stuckDetector.getToolAlternative();
+                    if (actionableHints.length > 0 || alternative) {
+                        const parts = [...actionableHints];
+                        if (alternative) {
+                            parts.push(`Tool "${call.name}" crashed. Try "${alternative}" instead.`);
+                        }
+                        this.pendingMessages.push({
+                            role: "user",
+                            content: `<system-summary>${t("exec.hints", { hints: parts.map((h) => `- ${h}`).join("\n") })}</system-summary>`,
+                        });
+                    }
+                }
+                else {
+                    this.stuckDetector.recordToolSuccess();
+                    // When a bash command runs code successfully, suggest marking step as done
+                    if (call.name === "bash" && result.success) {
+                        const cmd = String(call.arguments?.command ?? "");
+                        if (/node|tsx|ts-node|python|npm\s+(start|test|run)/.test(cmd)) {
+                            this.pendingMessages.push({
+                                role: "user",
+                                content: `<system-summary>The command "${cmd}" completed successfully. If this was testing your code, mark the current step as done via plan update step=N status=done.</system-summary>`,
+                            });
+                        }
+                    }
+                }
+                if (result.success &&
+                    (call.name === "write_file" || call.name === "edit_file")) {
+                    const filePath = call.arguments?.path;
+                    if (filePath) {
+                        this.stuckDetector.recordFileRewrite(filePath);
+                        if (this.stuckDetector.hasExcessiveRewrites()) {
+                            const file = this.stuckDetector.getExcessiveRewriteFile();
+                            const count = this.stuckDetector.getFileRewriteCount(file);
+                            if (ctx.onMeta) {
+                                ctx.onMeta(t("exec.file_rewrite_warning", {
+                                    file: file,
+                                    count: String(count),
+                                }));
+                            }
+                        }
+                    }
+                    this.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
+                }
+            },
+        };
     }
     preserveActive() {
         if (!this.tracker)
@@ -215,11 +636,11 @@ export class ExecutionModule {
         ];
         if (allowedAlways.includes(call.name))
             return null;
-        const stepPaths = extractFileLikeTokens(stripUrls(step.description)).map((p) => p.toLowerCase());
+        const stepPaths = (step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
         if (stepPaths.length === 0)
             return null;
-        const argStr = JSON.stringify(call.arguments);
-        const callPaths = extractFileLikeTokens(stripUrls(argStr)).map((p) => p.toLowerCase());
+        const argStr = JSON.stringify(call.arguments).toLowerCase();
+        const callPaths = (argStr.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
         if (callPaths.length === 0)
             return null;
         // Files that already belong to COMPLETED (done/skipped) steps are
@@ -229,13 +650,15 @@ export class ExecutionModule {
         const finishedPaths = new Set();
         for (const s of plan.steps) {
             if (s.status === "done" || s.status === "skipped") {
-                extractFileLikeTokens(stripUrls(s.description))
-                    .map((p) => p.toLowerCase())
-                    .forEach((p) => finishedPaths.add(p));
+                const ps = s.description
+                    .match(/\b[\w./\\-]+\.[a-z]+/gi)
+                    ?.map((p) => p.toLowerCase()) ?? [];
+                ps.forEach((p) => finishedPaths.add(p));
             }
         }
         const offPath = callPaths.some((p) => {
-            if (finishedPaths.has(p) || [...finishedPaths].some((s) => s.includes(p))) {
+            if (finishedPaths.has(p) ||
+                [...finishedPaths].some((s) => s.includes(p))) {
                 return false;
             }
             return !stepPaths.some((s) => p.includes(s) || s.includes(p));
@@ -253,12 +676,7 @@ export class ExecutionModule {
         if (!step)
             return;
         const stepText = step.description.toLowerCase();
-        // Shared file-token filter (allow-list of real extensions, extension-only
-        // segments rejected). A step like "Удалить .js, оставить .tsx/.ts" must
-        // NOT produce the phantom token "tsx/.ts" — that never exists, making
-        // 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)) || [];
+        const stepPaths = step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || [];
         // Step gate: verify dependencies when mentioned — check BEFORE file paths
         const isDepsStep = stepText.includes("install") ||
             stepText.includes("зависим") ||
@@ -280,8 +698,8 @@ export class ExecutionModule {
             const hasLockFile = lockFiles.some((f) => existsSync(resolve(this.baseDir, f)));
             if (!hasLockFile) {
                 if (contextManager) {
-                    const hints = this.state.depsGateHints.get(step.id) || 0;
-                    this.state.depsGateHints.set(step.id, hints + 1);
+                    const hints = this.depsGateHints.get(step.id) || 0;
+                    this.depsGateHints.set(step.id, hints + 1);
                     const force = hints >= 1;
                     const content = force
                         ? t("exec.step_gate_deps_force", { step: String(step.id) })
@@ -300,32 +718,28 @@ 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)));
-        const satisfied = step.kind === "delete" ? allGone && !allExist : allExist;
-        if (!satisfied)
+        if (!allExist)
             return;
         // Step gate: verify files have content (not empty)
-        if (step.kind !== "delete") {
-            const emptyFiles = [];
-            for (const p of stepPaths) {
-                try {
-                    const content = readFileSync(resolve(this.baseDir, p), "utf-8");
-                    if (content.trim().length < 10) {
-                        emptyFiles.push(p);
-                    }
-                }
-                catch {
-                    // If we can't read it, rely on existsSync result
+        const emptyFiles = [];
+        for (const p of stepPaths) {
+            try {
+                const content = readFileSync(resolve(this.baseDir, p), "utf-8");
+                if (content.trim().length < 10) {
+                    emptyFiles.push(p);
                 }
             }
-            if (emptyFiles.length > 0 && contextManager) {
-                contextManager.addMessage({
-                    role: "user",
-                    content: `<system-summary>${t("exec.step_gate_empty", { step: String(step.id), files: emptyFiles.join(", ") })}</system-summary>`,
-                });
-                return;
+            catch {
+                // If we can't read it, rely on existsSync result
             }
         }
+        if (emptyFiles.length > 0 && contextManager) {
+            contextManager.addMessage({
+                role: "user",
+                content: `<system-summary>${t("exec.step_gate_empty", { step: String(step.id), files: emptyFiles.join(", ") })}</system-summary>`,
+            });
+            return;
+        }
         // All checks passed — advance
         this.tracker?.updateStepStatus(step.id, "done");
         const hadNext = this.tracker?.advance() ?? false;
@@ -347,68 +761,6 @@ export class ExecutionModule {
                 content: `<system-summary>${nextMsg}</system-summary>`,
             });
         }
-        // Auto-archive a plan that just became complete (all steps done/skipped).
-        // Keeps a finished plan from staying active forever and anchoring the agent
-        // to a completed task ("continue step 4, do NOT create a new plan" — the
-        // ses_msxjbnm4 loop). The per-step deliverable gate already verified files.
-        if (this.tracker?.isComplete()) {
-            const completed = this.tracker.getPlan();
-            this.store.archivePlan(completed);
-            this.tracker = null;
-            sessionLog?.plan("auto-archive", `Plan ${completed.id} complete — archived`);
-        }
-    }
-    /**
-     * File tokens named in a step description that do not resolve to a real
-     * file. Uses the same shared token extractor (allow-list of real file
-     * extensions, URLs stripped) and the auditor's subtree resolver, so
-     * "bicycles.ts" finds "bicycle-shop/src/data/bicycles.ts" and a hostname in
-     * the description is never reported as a missing deliverable. Steps with no
-     * file tokens (pure commands, verification runs) cannot be verified.
-     */
-    missingStepDeliverables(step) {
-        const tokens = extractFileLikeTokens(stripUrls(step.description));
-        if (tokens.length === 0)
-            return [];
-        return tokens.filter((p) => !findExistingFile(this.baseDir, p));
-    }
-    /**
-     * File tokens named in a step description that still resolve to a real
-     * file. The inverse of missingStepDeliverables — used by the gate for
-     * delete-kind steps ("done" means the files are gone).
-     */
-    stillExistingDeliverables(step) {
-        const tokens = extractFileLikeTokens(stripUrls(step.description));
-        if (tokens.length === 0)
-            return [];
-        return tokens.filter((p) => findExistingFile(this.baseDir, p));
-    }
-    /**
-     * Validate the optional per-step `kinds` argument for plan create and
-     * update-with-steps. Returns length-aligned kinds or an i18n error string.
-     * Absent kinds → null (caller falls back to all-create semantics). Used by
-     * BOTH branches so a rebuild via update can never silently drop kinds.
-     */
-    parseKinds(args, steps) {
-        if (args.kinds === undefined)
-            return { kinds: null, error: null };
-        if (!Array.isArray(args.kinds)) {
-            return { kinds: null, error: t("plan.kinds_not_array") };
-        }
-        const kindsRaw = args.kinds.map(String);
-        if (kindsRaw.length !== steps.length) {
-            return { kinds: null, error: t("plan.kinds_mismatch") };
-        }
-        const invalid = kindsRaw.filter((k) => k !== "create" && k !== "delete");
-        if (invalid.length > 0) {
-            return {
-                kinds: null,
-                error: t("plan.kinds_invalid", {
-                    kinds: invalid.join(", "),
-                }),
-            };
-        }
-        return { kinds: kindsRaw, error: null };
     }
     /**
      * Extract the original task statement from the first user message in the
@@ -419,16 +771,7 @@ export class ExecutionModule {
         if (!manager)
             return "";
         const history = manager.getActiveHistory();
-        // The first user message may be an injected <system-summary> (compaction
-        // block) — it is NOT the task. Coverage must compare the plan against the
-        // model's real instruction (observed: a compaction summary's stale file
-        // list produced a bogus "plan is missing files" warning).
-        const firstUser = history.find((m) => {
-            if (m.role !== "user")
-                return false;
-            const text = getMessageText(m.content);
-            return !text.startsWith("<system-summary>") && !text.includes("[Compressed:");
-        });
+        const firstUser = history.find((m) => m.role === "user");
         if (!firstUser)
             return "";
         return getMessageText(firstUser.content).trim();