micro-models-agent 0.63.3 → 1.1.0

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

@@ -1,7 +1,5 @@
 import { t } from "../../i18n/index";
-import { PlanCreator, getPlanProgress } from "./planner";
-import { checkPlanCoverage } from "./plan-coverage";
-import { stepTypecheckGate } from "./execution-plugin";
+import { dispatchPlanAction } from "./plan-actions";
 /**
  * The plan / todo / verify tool definitions for the execution module. The
  * handlers were extracted verbatim from ExecutionModule.getToolDefinitions() —
@@ -46,492 +44,12 @@ export function createPlanToolDefinitions(deps) {
                 },
                 required: ["action"],
             },
-            handler: async (_ctx, args) => {
+            handler: async (ctx, args) => {
                 const action = String(args.action);
-                if (action === "list") {
-                    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")}`,
-                    };
-                }
-                if (action === "switch") {
-                    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,
-                    };
-                }
-                if (action === "re-plan") {
-                    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,
-                    };
-                }
-                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") };
-                    }
-                    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,
-                    };
-                }
-                if (action === "show") {
-                    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,
-                    };
-                }
-                if (action === "update" && args.step && deps.trackerRef.current) {
-                    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) {
-                                    target.kind = "delete";
-                                    deps.store.saveActive(tracker.getPlan());
-                                }
-                            }
-                        }
-                    }
-                    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,
-                    };
-                }
-                if (action === "update" &&
-                    Array.isArray(args.steps) &&
-                    args.steps.length > 0 &&
-                    !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);
-                    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,
-                    };
-                }
-                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) {
-                        // 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") };
-                }
+                // Диспетчер по действию: по одной функции на action (plan-actions.ts).
+                const result = dispatchPlanAction(action, deps, ctx, args);
+                if (result !== null)
+                    return result;
                 return {
                     success: false,
                     output: t("plan.unknown_action", { action }),

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

@@ -1,3 +1,4 @@
+import { normalizeInputFrom } from "./input-from";
 export function validatePlan(plan, config) {
     const errors = [];
     const warnings = [];
@@ -18,6 +19,9 @@ export function validatePlan(plan, config) {
             errors.push(overlap.error);
         }
     }
+    const inputRefErrors = validateInputFromRefs(plan.subtasks);
+    errors.push(...inputRefErrors.errors);
+    autoFixes.push(...inputRefErrors.autoFixes);
     return {
         valid: errors.length === 0,
         errors,
@@ -25,6 +29,26 @@ export function validatePlan(plan, config) {
         autoFixes,
     };
 }
+/**
+ * Every input_from reference must point at an existing subtask and be backed
+ * by a depends_on edge — otherwise the reader may run before its producer.
+ */
+export function validateInputFromRefs(subtasks) {
+    const errors = [];
+    const autoFixes = [];
+    const ids = new Set(subtasks.map((s) => s.id));
+    for (const s of subtasks) {
+        for (const ref of normalizeInputFrom(s.input_from)) {
+            if (!ids.has(ref.subtaskId)) {
+                errors.push(`Subtask "${s.id}" input_from references unknown subtask "${ref.subtaskId}". Known subtasks: ${Array.from(ids).join(", ")}`);
+            }
+            else if (!s.depends_on?.includes(ref.subtaskId)) {
+                autoFixes.push({ subtaskId: s.id, fix: `Add depends_on: ${ref.subtaskId}` });
+            }
+        }
+    }
+    return { errors, autoFixes };
+}
 export function expertTagsExist(subtasks, config) {
     const errors = [];
     const knownExperts = new Set(Object.keys(config.experts || {}));

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

@@ -1,18 +1,5 @@
 import { t } from "../../i18n/index";
-const TRANSIENT_PATTERNS = [
-    /timeout/i,
-    /timed out/i,
-    /ECONNREFUSED/i,
-    /ETIMEDOUT/i,
-    /ECONNRESET/i,
-    /killed/i,
-    /SIGTERM/i,
-    /SIGKILL/i,
-    /rate limit/i,
-    /429/i,
-    /503/i,
-    /502/i,
-];
+import { isTransientError } from "./transient-error";
 const BLOCKING_PATTERNS = [
     /EACCES/i,
     /permission denied/i,
@@ -25,10 +12,8 @@ const BLOCKING_PATTERNS = [
     /403/i,
 ];
 export function classifyError(output) {
-    for (const p of TRANSIENT_PATTERNS) {
-        if (p.test(output))
-            return "transient";
-    }
+    if (isTransientError(output))
+        return "transient";
     for (const p of BLOCKING_PATTERNS) {
         if (p.test(output))
             return "blocking";

package/dist/modules/execution/tracker.js

@@ -28,12 +28,21 @@ export class PlanTracker {
             step.note = note;
     }
     advance() {
-        if (this.currentStepIndex < this.plan.steps.length - 1) {
-            this.currentStepIndex++;
-            this.plan.steps[this.currentStepIndex].status = "in_progress";
-            return true;
+        // Move past any already-settled (skipped/done) steps without mutating
+        // them — overwriting a "skipped" step with "in_progress" deadlocks the
+        // plan (the model will never work on a step it deliberately skipped).
+        let idx = this.currentStepIndex + 1;
+        while (idx < this.plan.steps.length &&
+            (this.plan.steps[idx].status === "skipped" || this.plan.steps[idx].status === "done")) {
+            idx++;
+        }
+        if (idx >= this.plan.steps.length)
+            return false;
+        this.currentStepIndex = idx;
+        if (this.plan.steps[idx].status === "pending") {
+            this.plan.steps[idx].status = "in_progress";
         }
-        return false;
+        return true;
     }
     /**
      * Advance the pointer past any done/skipped steps without mutating their

package/dist/modules/execution/transient-error.js

@@ -0,0 +1,30 @@
+/**
+ * Единая классификация транзиентных (временно сбойных) ошибок.
+ *
+ * Ранее существовало ДВЕ расходящиеся копии: `TRANSIENT_PATTERNS` в
+ * stuck-detector.ts и `TRANSIENT_ERROR_PATTERNS` в moe-executor.ts. Из-за
+ * этого одна и та же ошибка по-разному ретраилась в разных подсистемах:
+ * moe-executor считал транзиентными 500/504/"network"/"fetch failed",
+ * stuck-detector — "killed"/"SIGTERM"/"rate limit" и т.д.
+ *
+ * Здесь — объединение обеих копий в единый источник истины, чтобы решение
+ * "эту ошибку можно ретраить" было одинаковым во всей системе.
+ */
+const TRANSIENT_PATTERNS = [
+    /timeout/i,
+    /timed out/i,
+    /ECONNREFUSED/i,
+    /ETIMEDOUT/i,
+    /ECONNRESET/i,
+    /killed/i,
+    /SIGTERM/i,
+    /SIGKILL/i,
+    /rate limit/i,
+    /\b(429|500|502|503|504)\b/,
+    /network/i,
+    /fetch failed/i,
+];
+/** Истинно, если сообщение похоже на транзиентную (временно сбойную) ошибку. */
+export function isTransientError(message) {
+    return TRANSIENT_PATTERNS.some((p) => p.test(message));
+}