micro-models-agent 0.51.1 → 0.52.0

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

@@ -1,6 +1,7 @@
 import { t } from "../../i18n/index";
-import { PlanCreator } from "./planner";
+import { PlanCreator, getPlanProgress } from "./planner";
 import { checkPlanCoverage } from "./plan-coverage";
+import { stepTypecheckGate } from "./execution-plugin";
 /**
  * The plan / todo / verify tool definitions for the execution module. The
  * handlers were extracted verbatim from ExecutionModule.getToolDefinitions() —
@@ -11,14 +12,25 @@ export function createPlanToolDefinitions(deps) {
     return [
         {
             name: "plan",
+            icon: "📋",
             alwaysOn: true,
-            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?)\n- For steps that REMOVE files, pass kinds: ["delete"] aligned with steps (the done-gate verifies those files are gone instead of demanding they exist).',
+            description: 'Create, update, show, abort, list, switch, delete, purge, 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 the current plan (or the plan given by id) and clear the 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- delete: Permanently delete a plan by id (plan delete id=plan_xxx).\n- purge: Delete ALL plans (active, drafts, archived).\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?)\n- For steps that REMOVE files, pass kinds: ["delete"] aligned with steps (the done-gate verifies those files are gone instead of demanding they exist).',
             parameters: {
                 type: "object",
                 properties: {
                     action: {
                         type: "string",
-                        enum: ["create", "update", "show", "abort", "list", "switch", "re-plan"],
+                        enum: [
+                            "create",
+                            "update",
+                            "show",
+                            "abort",
+                            "list",
+                            "switch",
+                            "re-plan",
+                            "delete",
+                            "purge",
+                        ],
                     },
                     title: { type: "string" },
                     steps: { type: "array", items: { type: "string" } },
@@ -46,6 +58,8 @@ export function createPlanToolDefinitions(deps) {
                         const namePart = m.name ? ` (${m.name})` : "";
                         return `${icon} ${m.id}${namePart} — ${m.title}  ${m.doneCount}/${m.stepCount}`;
                     });
+                    lines.push("");
+                    lines.push(t("plan.list_legend"));
                     return {
                         success: true,
                         output: `${t("plan.list_header")}\n${lines.join("\n")}`,
@@ -63,6 +77,19 @@ export function createPlanToolDefinitions(deps) {
                             output: t("plan.not_found", { id: planId }),
                         };
                     }
+                    // Switching to the plan that is already active must be a no-op, not
+                    // a duplicate (observed: switch on the active plan preserved the
+                    // active.json and re-set the same plan, leaving two copies).
+                    if (found.status === "active") {
+                        return {
+                            success: true,
+                            output: t("plan.already_active", {
+                                id: found.plan.id,
+                                title: found.plan.title,
+                            }),
+                            display: deps.trackerRef.current?.toPromptBlock(),
+                        };
+                    }
                     deps.preserveActive();
                     if (found.status === "draft") {
                         deps.store.removeDraft(found.plan.id);
@@ -71,7 +98,10 @@ export function createPlanToolDefinitions(deps) {
                         deps.store.removeArchived(found.plan.id);
                     }
                     deps.setPlan(found.plan);
-                    const display = PlanCreator.toPromptBlock(found.plan, 0);
+                    // Display from the tracker (setPlan syncs the pointer past any
+                    // done/skipped steps) so "current: step N" points at the first
+                    // pending step of the switched-to plan, not always step 1.
+                    const display = deps.trackerRef.current?.toPromptBlock();
                     return {
                         success: true,
                         output: t("plan.switched", {
@@ -94,7 +124,7 @@ export function createPlanToolDefinitions(deps) {
                     const replanned = PlanCreator.replan(oldPlan, newSteps, args.title ? String(args.title) : undefined);
                     const keptCount = replanned.steps.length - newSteps.length;
                     deps.setPlan(replanned);
-                    const display = PlanCreator.toPromptBlock(replanned, keptCount);
+                    const display = deps.trackerRef.current?.toPromptBlock();
                     return {
                         success: true,
                         output: t("plan.replanned", {
@@ -220,13 +250,14 @@ export function createPlanToolDefinitions(deps) {
                     if (tracker.isComplete()) {
                         const plan = tracker.getPlan();
                         deps.store.archivePlan(plan);
+                        deps.recordCompleted(plan); // final audit still verifies it
                         deps.trackerRef.current = null;
-                        const done = plan.steps.filter((s) => s.status === "done").length;
+                        const p = getPlanProgress(plan);
                         return {
                             success: true,
                             output: t("plan.completed_archived", {
                                 id: plan.id,
-                                done: String(done),
+                                done: String(p.settled),
                                 total: String(plan.steps.length),
                             }),
                         };
@@ -272,6 +303,29 @@ export function createPlanToolDefinitions(deps) {
                     // intent. "create" (default) → named files must exist; "delete"
                     // → named files must be GONE. Intent is model-declared (kind),
                     // never keyword-inferred (rule #10).
+                    //
+                    // Auto-switch: when kind is "create" but ALL named files are gone,
+                    // check if the agent actually deleted them (via delete_file/bash rm).
+                    // Only then switch to "delete" — files that were never created
+                    // (create-kind steps) remain blocked so the agent must create them.
+                    if (status === "done" && target.kind !== "delete") {
+                        const missing = deps.missingStepDeliverables(target);
+                        if (missing.length > 0) {
+                            const existing = deps.stillExistingDeliverables(target);
+                            const allGone = deps.hasStepDeliverables(target) && existing.length === 0;
+                            if (allGone) {
+                                // Confirm the agent actually deleted these files (not just
+                                // never created them) before auto-switching.
+                                const wasDeleted = deps.wasFileDeleted
+                                    ? missing.every((f) => deps.wasFileDeleted(f))
+                                    : false;
+                                if (wasDeleted) {
+                                    target.kind = "delete";
+                                    deps.store.saveActive(tracker.getPlan());
+                                }
+                            }
+                        }
+                    }
                     if (status === "done") {
                         if (target.kind === "delete") {
                             const leftovers = deps.stillExistingDeliverables(target);
@@ -298,26 +352,52 @@ export function createPlanToolDefinitions(deps) {
                             }
                         }
                     }
+                    // Typecheck gate: "done" while the last edit still fails to compile
+                    // is a self-certification the harness must refuse (observed: steps
+                    // marked done with the project typecheck failing on every write —
+                    // a "fix it later" cascade that never got fixed). The model must
+                    // either fix the errors (a clean re-edit clears the map) or mark
+                    // the step skipped.
+                    if (status === "done") {
+                        const blocked = stepTypecheckGate(deps.typecheckFailures, target.description);
+                        if (blocked) {
+                            return {
+                                success: false,
+                                output: t("plan.typecheck_failed", {
+                                    step: String(stepId),
+                                    error: blocked,
+                                }),
+                            };
+                        }
+                    }
                     tracker.updateStepStatus(stepId, status);
                     if (args.note)
                         tracker.addNote(Number(args.step), String(args.note));
                     tracker.syncCurrentStep();
                     deps.store.saveActive(tracker.getPlan());
+                    // A "done" step that names no file tokens has a vacuous gate — its
+                    // completion cannot be auto-verified. Inform the model so it can
+                    // run an explicit check or add file paths to the step description.
+                    const vacuousGate = status === "done" && !deps.hasStepDeliverables(target);
+                    const vacuousNote = vacuousGate
+                        ? `\n${t("plan.no_deliverables", { step: String(stepId) })}`
+                        : "";
                     // If this update completed the last step → auto-archive. This breaks
                     // the loop where a finished plan stays active and anchors the model
                     // to "continue step N, do NOT create a new plan".
                     if (tracker.isComplete()) {
                         const plan = tracker.getPlan();
                         deps.store.archivePlan(plan);
+                        deps.recordCompleted(plan); // final audit still verifies it
                         deps.trackerRef.current = null;
-                        const done = plan.steps.filter((s) => s.status === "done").length;
+                        const p = getPlanProgress(plan);
                         return {
                             success: true,
                             output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${t("plan.completed_archived", {
                                 id: plan.id,
-                                done: String(done),
+                                done: String(p.settled),
                                 total: String(plan.steps.length),
-                            })}`,
+                            })}${vacuousNote}`,
                         };
                     }
                     const progress = tracker.getProgressString();
@@ -325,15 +405,26 @@ export function createPlanToolDefinitions(deps) {
                     _ctx.sessionLog?.plan("step-update", `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })} | ${progress} | current: step ${tracker.getCurrentStepIndex() + 1}`);
                     return {
                         success: true,
-                        output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}`,
+                        output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}${vacuousNote}`,
                         display,
                     };
                 }
                 if (action === "update" &&
                     Array.isArray(args.steps) &&
                     args.steps.length > 0 &&
-                    deps.trackerRef.current) {
+                    !args.step) {
                     const tracker = deps.trackerRef.current;
+                    if (!tracker) {
+                        return { success: false, output: t("plan.no_active") };
+                    }
+                    // Rebuilding a plan that already has progress silently discards
+                    // every status (ses_mt4fn58c: the model sent its whole step list
+                    // with ✅-emoji statuses expecting progress marks and got a fresh
+                    // plan back). A not-yet-started plan is safe to rebuild.
+                    const progressed = tracker.getPlan().steps.some((s) => s.status !== "pending");
+                    if (progressed) {
+                        return { success: false, output: t("plan.bulk_update_rejected") };
+                    }
                     const title = String(args.title || tracker.getPlan().title);
                     const steps = args.steps.map(String);
                     const parsed = deps.parseKinds(args, steps);
@@ -342,7 +433,7 @@ export function createPlanToolDefinitions(deps) {
                     }
                     const plan = PlanCreator.createPlan(title, steps, deps.baseDir, parsed.kinds ?? []);
                     deps.setPlan(plan);
-                    const display = PlanCreator.toPromptBlock(plan, 0);
+                    const display = deps.trackerRef.current?.toPromptBlock();
                     const output = t("plan.updated", {
                         title,
                         steps: String(steps.length),
@@ -354,15 +445,91 @@ export function createPlanToolDefinitions(deps) {
                     };
                 }
                 if (action === "abort") {
+                    const planId = args.id ? String(args.id) : "";
+                    if (planId) {
+                        // Abort a SPECIFIC plan (not the active one). Draft → archive,
+                        // active → archive + clear tracker. Archived plans are already
+                        // terminal — there is nothing to abort.
+                        const found = deps.store.find(planId);
+                        if (!found) {
+                            return {
+                                success: false,
+                                output: t("plan.not_found", { id: planId }),
+                            };
+                        }
+                        if (found.status === "archived") {
+                            return {
+                                success: false,
+                                output: t("plan.already_archived", { id: planId }),
+                            };
+                        }
+                        deps.store.archivePlan(found.plan); // clears active if it was active
+                        if (found.status === "active") {
+                            deps.trackerRef.current = null;
+                            deps.clearCompleted();
+                        }
+                        return {
+                            success: true,
+                            output: t("plan.aborted_id", { id: found.plan.id }),
+                        };
+                    }
                     const tracker = deps.trackerRef.current;
-                    if (tracker) {
-                        deps.store.archivePlan(tracker.getPlan());
+                    if (!tracker) {
+                        // Abort with no active plan and no id — previously returned
+                        // success:true, which made the model believe it aborted a plan
+                        // that did not exist (observed: 3× abort on an empty list).
+                        return { success: false, output: t("plan.no_active") };
                     }
+                    deps.store.archivePlan(tracker.getPlan());
                     deps.trackerRef.current = null;
                     deps.store.clearActive();
+                    deps.clearCompleted();
                     return { success: true, output: t("plan.aborted") };
                 }
+                if (action === "delete") {
+                    const planId = String(args.id || "");
+                    if (!planId) {
+                        return { success: false, output: t("plan.delete_no_id") };
+                    }
+                    const deleted = deps.store.deletePlan(planId);
+                    if (!deleted) {
+                        return {
+                            success: false,
+                            output: t("plan.not_found", { id: planId }),
+                        };
+                    }
+                    if (deleted === "active") {
+                        deps.trackerRef.current = null;
+                        deps.clearCompleted();
+                    }
+                    return {
+                        success: true,
+                        output: t("plan.deleted", { id: planId }),
+                    };
+                }
+                if (action === "purge") {
+                    const count = deps.store.purgeAll();
+                    deps.trackerRef.current = null;
+                    deps.clearCompleted();
+                    return {
+                        success: true,
+                        output: t("plan.purged", { count: String(count) }),
+                    };
+                }
                 if (!deps.trackerRef.current) {
+                    // Update with an id that points at a draft/archived plan: say the
+                    // plan is read-only instead of a bare "No active plan" (observed:
+                    // 10+ iterations re-updating an archived plan and getting the same
+                    // unhelpful answer back).
+                    if (args.id) {
+                        const found = deps.store.find(String(args.id));
+                        if (found && found.status !== "active") {
+                            return {
+                                success: false,
+                                output: t("plan.readonly", { id: found.plan.id, status: found.status }),
+                            };
+                        }
+                    }
                     return { success: false, output: t("plan.no_active") };
                 }
                 return {
@@ -373,6 +540,7 @@ export function createPlanToolDefinitions(deps) {
         },
         {
             name: "todo",
+            icon: "☑️",
             alwaysOn: true,
             description: "Manage sub-tasks within current plan step. Use to break down complex steps into smaller tasks.",
             parameters: {
@@ -450,7 +618,7 @@ export function createPlanToolDefinitions(deps) {
                     });
                     output += ` (${doneCount}/${subs.length})`;
                     if (doneCount === subs.length) {
-                        output += `\nAll sub-tasks done — call plan update step=${currentStep.id} status=done to complete this step.`;
+                        output += `\n${t("plan.subtasks_done", { stepId: String(currentStep.id) })}`;
                     }
                     return { success: true, output, display };
                 }
@@ -458,10 +626,10 @@ export function createPlanToolDefinitions(deps) {
                     const subs = currentStep.subtasks ?? [];
                     const lines = subs.length
                         ? subs.map((s) => `${s.done ? "[x]" : "[ ]"} ${s.text}`)
-                        : ["(no sub-tasks)"];
+                        : [t("plan.no_subtasks")];
                     return {
                         success: true,
-                        output: `Step ${currentStep.id}: ${currentStep.description}\n${lines.join("\n")}`,
+                        output: `${t("plan.step_label", { stepId: String(currentStep.id), description: currentStep.description })}\n${lines.join("\n")}`,
                     };
                 }
                 return {
@@ -472,6 +640,7 @@ export function createPlanToolDefinitions(deps) {
         },
         {
             name: "verify",
+            icon: "✅",
             alwaysOn: true,
             description: "Run verification for the current step. Checks files mentioned in the step description.",
             parameters: {
@@ -487,7 +656,7 @@ export function createPlanToolDefinitions(deps) {
                 const step = args.step ? tracker.getStep(Number(args.step)) : tracker.getCurrentStep();
                 if (!step)
                     return { success: false, output: t("plan.step_not_found") };
-                const result = await deps.verifier.verifyStep(step.description);
+                const result = await deps.verifier.verifyStep(step.description, step.kind);
                 if (result.noFiles) {
                     return {
                         success: true,

package/dist/modules/execution/planner.js

@@ -6,26 +6,20 @@ function generatePlanId() {
     }
     return `plan_${id}`;
 }
+/**
+ * Single source of truth for plan progress counting (ses_mt4fn58c: `show`
+ * said "6/7 done, complete" while `list` said "7/7" for the same plan —
+ * one counted only "done", the other counted done+skipped). A skipped step
+ * needs no further work, so it counts as settled everywhere.
+ */
+export function getPlanProgress(plan) {
+    const done = plan.steps.filter((s) => s.status === "done").length;
+    const skipped = plan.steps.filter((s) => s.status === "skipped").length;
+    const total = plan.steps.length;
+    const settled = done + skipped;
+    return { done, skipped, total, settled, terminal: total > 0 && settled === total };
+}
 export class PlanCreator {
-    static isMultiStep(task) {
-        const fileCount = (task.match(/\b[\w./-]+\.[a-z]+\b/gi) || []).length;
-        if (fileCount > 1)
-            return true;
-        const actionWords = [
-            "implement",
-            "create",
-            "add",
-            "build",
-            "setup",
-            "configure",
-            "write",
-            "make",
-            "develop",
-        ];
-        const words = task.split(/\s+/);
-        const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
-        return hasActionWord && words.length > 8;
-    }
     static createPlan(title, stepDescriptions, baseDir, kinds) {
         const stepCount = stepDescriptions.length;
         return {
@@ -46,16 +40,21 @@ export class PlanCreator {
         const baseTitle = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
         const newTitle = title || baseTitle;
         const totalSteps = kept.length + newSteps.length;
-        const added = newSteps.map((desc, i) => ({
-            id: kept.length + i + 1,
+        const added = newSteps.map((desc) => ({
+            id: -1, // renumbered below
             description: desc,
             status: "pending",
             kind: "create",
         }));
+        // Renumber every step (kept + added) sequentially. Kept steps keep their
+        // status and kind but may collide with the added ids when the original
+        // plan skipped/pending steps in the middle (e.g. done 1, done 3 → kept
+        // [1,3], added [2…] collides with kept id 3).
+        const steps = [...kept, ...added].map((s, i) => ({ ...s, id: i + 1 }));
         return {
             id: plan.id,
             title: `[${totalSteps}] ${newTitle}`,
-            steps: [...kept, ...added],
+            steps,
             createdAt: plan.createdAt,
             baseDir: plan.baseDir,
             name: plan.name,
@@ -63,10 +62,15 @@ export class PlanCreator {
     }
     static toPromptBlock(plan, currentStepIndex) {
         const date = plan.createdAt.slice(0, 10);
+        const p = getPlanProgress(plan);
+        const skippedPart = p.skipped > 0 ? `, ${p.skipped} skipped` : "";
+        const progress = p.terminal
+            ? `${p.settled}/${p.total} done${skippedPart}, complete`
+            : `${p.settled}/${p.total} done${skippedPart}, current: step ${currentStepIndex + 1}`;
         const lines = [
             `[${plan.id}] ${plan.title}`,
             `Dir: ${plan.baseDir}`,
-            `Created: ${date} | Progress: ${plan.steps.filter((s) => s.status === "done").length}/${plan.steps.length} done, current: step ${currentStepIndex + 1}`,
+            `Created: ${date} | Progress: ${progress}`,
             ``,
         ];
         for (const step of plan.steps) {