micro-models-agent 0.63.3 → 1.1.0

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

@@ -0,0 +1,524 @@
+import { t } from "../../i18n/index";
+import { PlanCreator, getPlanProgress } from "./planner";
+import { stepTypecheckGate } from "./execution-plugin";
+import { switchStepToDelete } from "./plan-steps";
+import { checkPlanCoverage } from "./plan-coverage";
+function actionList(deps) {
+    const metas = deps.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}`;
+    });
+    lines.push("");
+    lines.push(t("plan.list_legend"));
+    return {
+        success: true,
+        output: `${t("plan.list_header")}\n${lines.join("\n")}`,
+    };
+}
+function actionSwitch(deps, _ctx, args) {
+    const planId = String(args.id || "");
+    if (!planId) {
+        return { success: false, output: t("plan.switch_no_id") };
+    }
+    const found = deps.store.find(planId);
+    if (!found) {
+        return {
+            success: false,
+            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);
+    }
+    else if (found.status === "archived") {
+        deps.store.removeArchived(found.plan.id);
+    }
+    deps.setPlan(found.plan);
+    // 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", {
+            id: found.plan.id,
+            title: found.plan.title,
+        }),
+        display,
+    };
+}
+function actionRePlan(deps, _ctx, args) {
+    if (!deps.trackerRef.current) {
+        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 tracker = deps.trackerRef.current;
+    const oldPlan = tracker.getPlan();
+    const replanned = PlanCreator.replan(oldPlan, newSteps, args.title ? String(args.title) : undefined);
+    const keptCount = replanned.steps.length - newSteps.length;
+    deps.setPlan(replanned);
+    const display = deps.trackerRef.current?.toPromptBlock();
+    return {
+        success: true,
+        output: t("plan.replanned", {
+            kept: String(keptCount),
+            steps: String(newSteps.length),
+        }),
+        display,
+    };
+}
+function actionCreate(deps, ctx, args) {
+    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") };
+    }
+    const parsed = deps.parseKinds(args, steps);
+    if (parsed.error) {
+        return { success: false, output: parsed.error };
+    }
+    // Never silently discard an in-progress plan (observed:
+    // ses_msvuao0h — right after compaction the model called
+    // `plan create` again, dumping the 1/6 plan into drafts and
+    // starting from scratch). An active plan WITH progress blocks
+    // creation until the model consciously aborts it. A fresh plan
+    // (all steps pending) is safe to replace — the model may have
+    // just changed its mind about the approach.
+    const existing = deps.trackerRef.current;
+    if (existing) {
+        const activePlan = existing.getPlan();
+        const progressed = activePlan.steps.some((s) => s.status === "done" || s.status === "failed" || s.status === "skipped");
+        if (progressed) {
+            const done = activePlan.steps.filter((s) => s.status === "done").length;
+            return {
+                success: false,
+                output: t("plan.active_in_progress", {
+                    id: activePlan.id,
+                    done: String(done),
+                    total: String(activePlan.steps.length),
+                    current: String(existing.getCurrentStepIndex() + 1),
+                }),
+            };
+        }
+    }
+    deps.preserveActive();
+    const plan = PlanCreator.createPlan(title, steps, deps.baseDir, parsed.kinds ?? []);
+    deps.setPlan(plan);
+    const display = PlanCreator.toPromptBlock(plan, 0);
+    let output = t("plan.created", {
+        title,
+        steps: String(steps.length),
+    });
+    // The model sometimes passes an id expecting the plan to be
+    // created under it (observed: id "plan_error_check_e07pb2" was
+    // ignored, a new id appeared). Be explicit so it doesn't look
+    // for a plan by the wrong id afterwards.
+    if (args.id) {
+        output += `\n${t("plan.id_ignored")}`;
+    }
+    if (existing) {
+        output += `\n${t("plan.existing_fresh")}`;
+    }
+    let displayOut = display;
+    const taskText = deps.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,
+    };
+}
+function actionShow(deps, _ctx, args) {
+    const planId = args.id ? String(args.id) : "";
+    if (planId && planId !== deps.trackerRef.current?.getPlan()?.id) {
+        // Show a specific plan (active, draft, or archived) instead
+        // of ignoring the id and always printing the active one
+        // (observed: the model asked for an archived plan three
+        // times and got the active plan back every time).
+        const found = deps.store.find(planId);
+        if (!found) {
+            return {
+                success: false,
+                output: t("plan.not_found", { id: planId }),
+            };
+        }
+        const display = PlanCreator.toPromptBlock(found.plan, 0);
+        return {
+            success: true,
+            output: `${t("plan.show_header")}\n${display}`,
+            display,
+        };
+    }
+    if (!deps.trackerRef.current) {
+        return { success: false, output: t("plan.no_active") };
+    }
+    const display = deps.trackerRef.current.toPromptBlock();
+    return {
+        success: true,
+        output: `${t("plan.show_header")}\n${display}`,
+        display,
+    };
+}
+function actionUpdate(deps, ctx, args) {
+    // Обновление конкретного шага.
+    if (args.step && deps.trackerRef.current) {
+        return updateStep(deps, ctx, args);
+    }
+    // Массовая пересборка плана новыми шагами.
+    if (Array.isArray(args.steps) && args.steps.length > 0 && !args.step) {
+        return bulkUpdate(deps, args);
+    }
+    // Ни шага, ни шагов — тот же фолбэк, что был в хвосте монолита.
+    return noActiveOrUnknown(deps, args, "update");
+}
+function updateStep(deps, ctx, args) {
+    const tracker = deps.trackerRef.current;
+    const stepId = Number(args.step);
+    const target = tracker.getStep(stepId);
+    if (!target) {
+        return { success: false, output: t("plan.step_not_found") };
+    }
+    const status = String(args.status || "done");
+    // Completed plan: re-marking a done step of a finished plan is the
+    // loop anchor (observed: 3× "plan update step=4 done" on a 4/4 plan
+    // while a NEW task waited). Archive + clear so the model can create a
+    // fresh plan for the new task instead of spinning.
+    if (tracker.isComplete()) {
+        const plan = tracker.getPlan();
+        deps.store.archivePlan(plan);
+        deps.recordCompleted(plan); // final audit still verifies it
+        deps.trackerRef.current = null;
+        const p = getPlanProgress(plan);
+        return {
+            success: true,
+            output: t("plan.completed_archived", {
+                id: plan.id,
+                done: String(p.settled),
+                total: String(plan.steps.length),
+            }),
+        };
+    }
+    // Idempotency: re-marking a done step as done usually means the
+    // plan was already auto-advanced (all step files exist) and the
+    // model is confirming its own work. Return SUCCESS so the loop
+    // isn't confused — a small model misreads success:false as a
+    // failed action and retries/spins. Genuine spinning (repeated
+    // identical calls without new work) is still caught by the
+    // stuck-detector's consecutive-identical-call check.
+    if (status === "done" && target.status === "done") {
+        const progress = tracker.getProgressString();
+        const display = tracker.toPromptBlock();
+        return {
+            success: true,
+            output: `${t("plan.step_already_done", {
+                step: String(stepId),
+            })}\n${progress}`,
+            display,
+        };
+    }
+    // Order enforcement: only the CURRENT step may be marked done.
+    // Prevents jumping ahead (step 5 marked done before steps 1-4,
+    // observed in the post-mortem session) and the follow-on audit
+    // failures ("5/5 steps done, 5 files missing").
+    if (status === "done") {
+        const blockers = tracker
+            .getPlan()
+            .steps.filter((s) => s.id < stepId && s.status !== "done" && s.status !== "skipped");
+        if (blockers.length > 0) {
+            return {
+                success: false,
+                output: t("plan.order_blocked", {
+                    step: String(stepId),
+                    first: String(blockers[0].id),
+                    desc: blockers[0].description,
+                }),
+            };
+        }
+    }
+    // Deliverable gate: marking a step done must match its declared
+    // 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) {
+                    switchStepToDelete(tracker.getPlan(), target, (p) => deps.store.saveActive(p));
+                }
+            }
+        }
+    }
+    if (status === "done") {
+        if (target.kind === "delete") {
+            const leftovers = deps.stillExistingDeliverables(target);
+            if (leftovers.length > 0) {
+                return {
+                    success: false,
+                    output: t("plan.deliverables_remain", {
+                        step: String(stepId),
+                        files: leftovers.join(", "),
+                    }),
+                };
+            }
+        }
+        else {
+            const missing = deps.missingStepDeliverables(target);
+            if (missing.length > 0) {
+                return {
+                    success: false,
+                    output: t("plan.deliverables_missing", {
+                        step: String(stepId),
+                        files: missing.join(", "),
+                    }),
+                };
+            }
+        }
+    }
+    // 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 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(p.settled),
+                total: String(plan.steps.length),
+            })}${vacuousNote}`,
+        };
+    }
+    const progress = tracker.getProgressString();
+    const display = tracker.toPromptBlock();
+    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}${vacuousNote}`,
+        display,
+    };
+}
+function bulkUpdate(deps, args) {
+    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);
+    // Диспетчер вызывает bulkUpdate только когда steps — непустой массив, но
+    // внутри отдельной функции сужение теряется — восстанавливаем безопасно.
+    const steps = Array.isArray(args.steps) ? args.steps.map(String) : [];
+    const parsed = deps.parseKinds(args, steps);
+    if (parsed.error) {
+        return { success: false, output: parsed.error };
+    }
+    const plan = PlanCreator.createPlan(title, steps, deps.baseDir, parsed.kinds ?? []);
+    deps.setPlan(plan);
+    const display = deps.trackerRef.current?.toPromptBlock();
+    const output = t("plan.updated", {
+        title,
+        steps: String(steps.length),
+    });
+    return {
+        success: true,
+        output,
+        display,
+    };
+}
+function actionAbort(deps, _ctx, args) {
+    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) {
+        // 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") };
+}
+function actionDelete(deps, _ctx, args) {
+    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 }),
+    };
+}
+function actionPurge(deps) {
+    const count = deps.store.purgeAll();
+    deps.trackerRef.current = null;
+    deps.clearCompleted();
+    return {
+        success: true,
+        output: t("plan.purged", { count: String(count) }),
+    };
+}
+/** Фолбэк из хвоста монолита: readonly-план по id или "нет активного плана". */
+function noActiveOrUnknown(deps, args, action) {
+    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 {
+        success: false,
+        output: t("plan.unknown_action", { action }),
+    };
+}
+export const PLAN_ACTIONS = {
+    list: actionList,
+    switch: actionSwitch,
+    "re-plan": actionRePlan,
+    create: actionCreate,
+    show: actionShow,
+    update: actionUpdate,
+    abort: actionAbort,
+    delete: actionDelete,
+    purge: actionPurge,
+};
+/** Диспетчер: возвращает обработчик действия или null для неизвестного action. */
+export function dispatchPlanAction(action, deps, ctx, args) {
+    const fn = PLAN_ACTIONS[action];
+    if (!fn)
+        return null;
+    return fn(deps, ctx, args);
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Авто-переключение шага плана на kind="delete".
+ *
+ * Два независимых механизма писали `step.kind = "delete"` и сами персистили
+ * план:
+ * - plan-tool: шаг помечается done, а все его дативные файлы подтверждённо
+ *   удалены (deliverable gate);
+ * - execution-plugin: модель вызвала delete_file, и удалённый путь
+ *   пересекается с описанием шага.
+ *
+ * Здесь — единая точка, чтобы инвариант «сменить kind и сохранить план»
+ * жил в одном месте и не расходился между авторами.
+ *
+ * @returns true, если шаг был переключён (и план сохранён); false, если
+ * kind уже был "delete" — ничего не менялось.
+ */
+export function switchStepToDelete(plan, step, save) {
+    if (step.kind === "delete")
+        return false;
+    step.kind = "delete";
+    save(plan);
+    return true;
+}

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

@@ -1,5 +1,8 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, rmSync } from "fs";
+import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync, readdirSync, rmSync } from "fs";
 import { join } from "path";
+import { Logger } from "../../logger/app-logger";
+import { errMsg } from "../../utils";
+const log = new Logger("info", "plan-store");
 const LEGACY_FILE = "plan.json";
 function readPlanFile(path, fallbackBaseDir) {
     try {
@@ -23,7 +26,11 @@ function readPlanFile(path, fallbackBaseDir) {
     }
 }
 function writePlanFile(path, plan) {
-    writeFileSync(path, JSON.stringify(plan, null, 2), "utf-8");
+    // Atomic write: a crash mid-write must not leave a truncated plan file
+    // (readPlanFile silently returns null on broken JSON → active plan lost).
+    const tmpPath = `${path}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(plan, null, 2), "utf-8");
+    renameSync(tmpPath, path);
 }
 function listDir(dir, baseDir) {
     if (!existsSync(dir))
@@ -84,7 +91,12 @@ export class PlanStore {
                 try {
                     rmSync(this.legacyPath, { force: true });
                 }
-                catch { }
+                catch (err) {
+                    log.warn("Failed to remove migrated legacy plan.json", {
+                        path: this.legacyPath,
+                        error: errMsg(err),
+                    });
+                }
                 return legacy;
             }
         }