micro-models-agent 2.11.0 → 2.13.1

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

@@ -1,8 +1,16 @@
 import { t } from "../../i18n/index";
 import { PlanCreator, getPlanProgress } from "./planner";
+import { parseCheck } from "./plan-checks";
 import { stepTypecheckGate } from "./execution-plugin";
-import { switchStepToDelete } from "./plan-steps";
+import { switchStepToCreate, switchStepToDelete } from "./plan-steps";
 import { checkPlanCoverage } from "./plan-coverage";
+/**
+ * Статусы, которые `plan update` вправе ставить. Остальное (произвольный текст
+ * модели, `pending`/`in_progress`) реджектится: неизвестный статус не закроет
+ * `isComplete()`, план крутился бы вечно, а мусор персистился бы в
+ * `.mma/plans/active.json`.
+ */
+const STEP_UPDATE_STATUSES = ["done", "failed", "skipped"];
 function actionList(deps) {
     const metas = deps.store.listAll();
     if (metas.length === 0) {
@@ -32,9 +40,8 @@ function actionSwitch(deps, _ctx, args) {
             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).
+    // Переключение на уже активный план — no-op, не дубль (было: switch на
+    // активном сохранял active.json и переставлял тот же план, плодя копии).
     if (found.status === "active") {
         return {
             success: true,
@@ -53,9 +60,9 @@ function actionSwitch(deps, _ctx, args) {
         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.
+    // Display из трекера (setPlan подтягивает указатель мимо done/skipped),
+    // чтобы "current: step N" указывал на первый пендинг шаг переключённого
+    // плана, а не вечно на шаг 1.
     const display = deps.trackerRef.current?.toPromptBlock();
     return {
         success: true,
@@ -76,7 +83,11 @@ function actionRePlan(deps, _ctx, args) {
     }
     const tracker = deps.trackerRef.current;
     const oldPlan = tracker.getPlan();
-    const replanned = PlanCreator.replan(oldPlan, newSteps, args.title ? String(args.title) : undefined);
+    const checked = deps.parseChecks(args, newSteps);
+    if (checked.error) {
+        return { success: false, output: checked.error };
+    }
+    const replanned = PlanCreator.replan(oldPlan, newSteps, args.title ? String(args.title) : undefined, checked.checks ?? []);
     const keptCount = replanned.steps.length - newSteps.length;
     deps.setPlan(replanned);
     const display = deps.trackerRef.current?.toPromptBlock();
@@ -99,13 +110,33 @@ function actionCreate(deps, ctx, args) {
     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 checked = deps.parseChecks(args, steps);
+    if (checked.error) {
+        return { success: false, output: checked.error };
+    }
+    // Покрытие валидируем ДО любой мутации состояния: заблокированный create не
+    // оставит полусозданный активный план (следующий create споткнулся бы об
+    // active_in_progress на плане, успех которого модель не видела).
+    const taskText = deps.getTaskText(ctx);
+    if (taskText) {
+        const { missing } = checkPlanCoverage(taskText, steps);
+        if (missing.length > 0) {
+            // Жёсткий блок (не варнинг): 9B-модель читает "success:true + ⚠️" как
+            // успех и 5+ итераций работает по мусору, пока deliverable-gate не
+            // остановит. Стопорим на создании со списком файлов.
+            return {
+                success: false,
+                output: t("plan.coverage_blocked", {
+                    missing: missing.join(", "),
+                }),
+            };
+        }
+    }
+    // Активный план с прогрессом молча не выбрасываем (было: ses_msvuao0h —
+    // сразу после компакции модель снова звала `plan create`, сливая план 1/6 в
+    // черновики и стартуя с нуля). Активный план С прогрессом блокирует создание,
+    // пока модель осознанно его не абортнит. Свежий план (все шаги pending)
+    // заменять безопасно — модель могла передумать насчёт подхода.
     const existing = deps.trackerRef.current;
     if (existing) {
         const activePlan = existing.getPlan();
@@ -124,48 +155,34 @@ function actionCreate(deps, ctx, args) {
         }
     }
     deps.preserveActive();
-    const plan = PlanCreator.createPlan(title, steps, deps.baseDir, parsed.kinds ?? []);
+    const plan = PlanCreator.createPlan(title, steps, deps.baseDir, parsed.kinds ?? [], checked.checks ?? []);
     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.
+    // Модель иногда передаёт id, ожидая план под ним (было: id
+    // "plan_error_check_e07pb2" проигнорирован, появился новый id). Объясняем
+    // явно, чтобы не искала план по неверному id.
     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,
+        display,
     };
 }
 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).
+        // Показываем КОНКРЕТНЫЙ план (активный, черновик, архив), а не игнорируем
+        // id вечным выводом активного (было: модель трижды просила архивный план
+        // и каждый раз получала активный).
         const found = deps.store.find(planId);
         if (!found) {
             return {
@@ -193,96 +210,34 @@ function actionShow(deps, _ctx, args) {
 function actionUpdate(deps, ctx, args) {
     // Обновление конкретного шага.
     if (args.step && deps.trackerRef.current) {
-        return updateStep(deps, ctx, args);
+        return updatePlanStep(deps, ctx, args);
     }
-    // Массовая пересборка плана новыми шагами.
+    // Массовая пересборка плана через update запрещена: она молча меняет
+    // состав/название плана (churn) и теряет статусы. Модель должна осознанно
+    // выбрать `re-plan` (сохраняет завершённые шаги) или `create` (новый план).
     if (Array.isArray(args.steps) && args.steps.length > 0 && !args.step) {
-        return bulkUpdate(deps, args);
+        return { success: false, output: t("plan.bulk_update_rejected") };
     }
     // Ни шага, ни шагов — тот же фолбэк, что был в хвосте монолита.
     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") {
+/**
+ * Выводит kind create/delete шага из СДЕЛАННОГО агентом (не заявленного).
+ * Прямо: create-шаг, чьи файлы пропали И трекнуты удалёнными → флип в delete.
+ * Обратно: delete-шаг, чьи файлы ни существуют, ни удалялись → флип в create
+ * и блок (пустой pass ничего бы не сертифицировал; файлы, снесённые юзером
+ * снаружи — известный tradeoff: скипай шаг). Обратный случай возвращает
+ * блокирующий ToolResult, иначе null.
+ */
+function autoResolveStepKind(deps, tracker, target, stepId) {
+    if (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;
@@ -291,70 +246,266 @@ function updateStep(deps, ctx, args) {
                 }
             }
         }
+        return null;
     }
-    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(", "),
-                    }),
-                };
-            }
+    const leftovers = deps.stillExistingDeliverables(target);
+    if (leftovers.length === 0 && deps.wasFileDeleted) {
+        const tokens = deps.missingStepDeliverables(target);
+        if (tokens.length > 0 && tokens.every((f) => !deps.wasFileDeleted(f))) {
+            switchStepToCreate(tracker.getPlan(), target, (p) => deps.store.saveActive(p));
+            return {
+                success: false,
+                output: t("plan.deliverables_missing", {
+                    step: String(stepId),
+                    files: tokens.join(", "),
+                }),
+            };
         }
-        else {
-            const missing = deps.missingStepDeliverables(target);
-            if (missing.length > 0) {
-                return {
+    }
+    return null;
+}
+/**
+ * Проверяет check-контракт шага на done. "file-exists:" верифицируется жёстко
+ * здесь (kind=delete инвертирует: файл обязан ОТСУТСТВОВАТЬ); "command:"/"manual:"
+ * self-certified с подтверждающей заметкой. Шаги вовсе без check — только из
+ * до-чековых планов (back-compat), заметки не дают.
+ */
+async function verifyCheckContract(deps, target, stepId) {
+    if (!target.check)
+        return { note: "", blocked: null };
+    const parsed = parseCheck(target.check);
+    if (parsed?.kind === "file") {
+        const res = await deps.verifier.checkFileExists(parsed.target);
+        const ok = target.kind === "delete" ? !res.passed : res.passed;
+        if (!ok) {
+            return {
+                note: "",
+                blocked: {
                     success: false,
-                    output: t("plan.deliverables_missing", {
+                    output: t("plan.check_failed", {
                         step: String(stepId),
-                        files: missing.join(", "),
+                        check: target.check,
                     }),
-                };
-            }
+                },
+            };
         }
+        return { note: "", blocked: null };
     }
-    // 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) {
+    if (parsed) {
+        return { note: `\n${t("plan.check_self_certified", { check: target.check })}`, blocked: null };
+    }
+    return { note: "", blocked: null };
+}
+/**
+ * Сеттлит повторную метку на уже завершённом плане: архив + очистка, чтобы
+ * модель создала свежий план вместо прокрутки готового (было: 3× "plan update
+ * step=4 done" на плане 4/4, пока ждала НОВАЯ задача). Возвращает результат
+ * завершения, или null если план ещё в работе.
+ */
+function settleCompletedPlan(deps, tracker) {
+    if (!tracker.isComplete())
+        return null;
+    const plan = tracker.getPlan();
+    deps.store.archivePlan(plan);
+    deps.recordCompleted(plan); // финальный аудит его всё равно проверит
+    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),
+        }),
+    };
+}
+/**
+ * Идемпотентная переметка: подтверждение уже-done шага — УСПЕХ (мелкая модель
+ * читает success:false как провал действия и ретраит/спиннится). Настоящий
+ * спиннинг ловит stuck-детектор.
+ */
+function checkIdempotentDone(tracker, target, stepId, status) {
+    if (status !== "done" || target.status !== "done")
+        return null;
+    const progress = tracker.getProgressString();
+    const display = tracker.toPromptBlock();
+    return {
+        success: true,
+        output: `${t("plan.step_already_done", {
+            step: String(stepId),
+        })}\n${progress}`,
+        display,
+    };
+}
+/**
+ * Порядок: done маркится только ТЕКУЩИЙ шаг (защита от прыжков вперёд —
+ * было: step 5 done раньше шагов 1-4, затем аудит "5/5 steps done, 5 files
+ * missing").
+ */
+function enforceStepOrder(tracker, stepId) {
+    const blockers = tracker
+        .getPlan()
+        .steps.filter((s) => s.id < stepId && s.status !== "done" && s.status !== "skipped");
+    if (blockers.length === 0)
+        return null;
+    return {
+        success: false,
+        output: t("plan.order_blocked", {
+            step: String(stepId),
+            first: String(blockers[0].id),
+            desc: blockers[0].description,
+        }),
+    };
+}
+/**
+ * Deliverable-gate: done обязан совпасть с (уже kind-резолвленным) намерением —
+ * "create" требует файлы на месте, "delete" — их ОТСУТСТВИЕ.
+ */
+function checkDeliverables(deps, target, stepId) {
+    if (target.kind === "delete") {
+        const leftovers = deps.stillExistingDeliverables(target);
+        if (leftovers.length > 0) {
             return {
                 success: false,
-                output: t("plan.typecheck_failed", {
+                output: t("plan.deliverables_remain", {
                     step: String(stepId),
-                    error: blocked,
+                    files: leftovers.join(", "),
                 }),
             };
         }
+        return null;
     }
+    const missing = deps.missingStepDeliverables(target);
+    if (missing.length > 0) {
+        return {
+            success: false,
+            output: t("plan.deliverables_missing", {
+                step: String(stepId),
+                files: missing.join(", "),
+            }),
+        };
+    }
+    return null;
+}
+/**
+ * Typecheck-gate: "done" при всё ещё не компилирующейся последней записи —
+ * самосертификация, которую харнесс обязан реджектить (было: шаги маркились
+ * done при падающем на каждой записи typecheck проекта). Чини или скипай.
+ */
+function checkTypecheckGate(deps, target, stepId) {
+    const blocked = stepTypecheckGate(deps.typecheckFailures, target.description);
+    if (!blocked)
+        return null;
+    return {
+        success: false,
+        output: t("plan.typecheck_failed", {
+            step: String(stepId),
+            error: blocked,
+        }),
+    };
+}
+function guardKnownStatus(c) {
+    if (STEP_UPDATE_STATUSES.includes(c.status))
+        return null;
+    return {
+        success: false,
+        output: t("plan.bad_status", {
+            status: c.status,
+            allowed: STEP_UPDATE_STATUSES.join(", "),
+        }),
+    };
+}
+function guardSettledPlan(c) {
+    return settleCompletedPlan(c.deps, c.tracker);
+}
+function guardIdempotent(c) {
+    return checkIdempotentDone(c.tracker, c.target, c.stepId, c.status);
+}
+function guardOrder(c) {
+    if (c.status !== "done")
+        return null;
+    return enforceStepOrder(c.tracker, c.stepId);
+}
+async function guardKindAndCheck(c) {
+    if (c.status !== "done")
+        return null;
+    // Kind резолвится из поведения первым (оба направления), затем check-
+    // контракт проверяется против резолвленного kind: шаг, флипнутый агентом в
+    // delete, оценивает файловый check как delete.
+    const resolved = autoResolveStepKind(c.deps, c.tracker, c.target, c.stepId);
+    if (resolved)
+        return resolved;
+    const check = await verifyCheckContract(c.deps, c.target, c.stepId);
+    if (check.blocked)
+        return check.blocked;
+    c.checkNote = check.note;
+    return null;
+}
+function guardDeliverables(c) {
+    if (c.status !== "done")
+        return null;
+    return checkDeliverables(c.deps, c.target, c.stepId);
+}
+function guardTypecheck(c) {
+    if (c.status !== "done")
+        return null;
+    return checkTypecheckGate(c.deps, c.target, c.stepId);
+}
+/** Done-гарды в порядке оценки — та же цепочка, что старый инлайн-чейн. */
+const STEP_GUARDS = [
+    guardKnownStatus,
+    guardSettledPlan,
+    guardIdempotent,
+    guardOrder,
+    guardKindAndCheck,
+    guardDeliverables,
+    guardTypecheck,
+];
+/** Обновляет шаг плана через цепочку done-гардов; на последнем шаге — авто-архив. */
+export async function updatePlanStep(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 gctx = {
+        deps,
+        tracker,
+        target,
+        stepId,
+        status: String(args.status || "done"),
+        checkNote: "",
+    };
+    for (const guard of STEP_GUARDS) {
+        const blocked = await guard(gctx);
+        if (blocked)
+            return blocked;
+    }
+    const status = gctx.status;
+    const checkNote = gctx.checkNote;
     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);
+    // Шаги без файловых токенов нормальны в некодовых задачах (research, советы,
+    // сравнения) — не гоним модель материализовывать файлы ради deliverables.
+    // Заметка срабатывает только в планах с хоть одним файловым шагом и просит
+    // лишь task-appropriate проверку.
+    const planSteps = tracker.getPlan().steps ?? [];
+    const planHasFiles = planSteps.some((s) => deps.hasStepDeliverables(s));
+    const vacuousGate = status === "done" && planHasFiles && !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".
+    // Это обновление закрыло последний шаг → авто-архив. Рвёт петлю, где готовый
+    // план остаётся активным и якорит модель на "продолжай шаг N, НЕ создавай
+    // новый план".
     if (tracker.isComplete()) {
         const plan = tracker.getPlan();
         deps.store.archivePlan(plan);
-        deps.recordCompleted(plan); // final audit still verifies it
+        deps.recordCompleted(plan); // финальный аудит его всё равно проверит
         deps.trackerRef.current = null;
         const p = getPlanProgress(plan);
         return {
@@ -363,7 +514,7 @@ function updateStep(deps, ctx, args) {
                 id: plan.id,
                 done: String(p.settled),
                 total: String(plan.steps.length),
-            })}${vacuousNote}`,
+            })}${vacuousNote}${checkNote}`,
         };
     }
     const progress = tracker.getProgressString();
@@ -371,50 +522,15 @@ function updateStep(deps, ctx, args) {
     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,
+        output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}${vacuousNote}${checkNote}`,
         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 {
@@ -428,7 +544,7 @@ function actionAbort(deps, _ctx, args) {
                 output: t("plan.already_archived", { id: planId }),
             };
         }
-        deps.store.archivePlan(found.plan); // clears active if it was active
+        deps.store.archivePlan(found.plan); // был активным — active тоже чистится
         if (found.status === "active") {
             deps.trackerRef.current = null;
             deps.clearCompleted();
@@ -440,9 +556,9 @@ function actionAbort(deps, _ctx, args) {
     }
     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).
+        // Аборт без активного плана и без id — раньше возвращал success:true, и
+        // модель верила, что абортнула несуществующий план (было: 3× abort на
+        // пустом списке).
         return { success: false, output: t("plan.no_active") };
     }
     deps.store.archivePlan(tracker.getPlan());
@@ -451,6 +567,7 @@ function actionAbort(deps, _ctx, args) {
     deps.clearCompleted();
     return { success: true, output: t("plan.aborted") };
 }
+/** Удаляет план по id (активный чистит и трекер). */
 function actionDelete(deps, _ctx, args) {
     const planId = String(args.id || "");
     if (!planId) {
@@ -472,6 +589,7 @@ function actionDelete(deps, _ctx, args) {
         output: t("plan.deleted", { id: planId }),
     };
 }
+/** Удаляет ВСЕ планы (активный, черновики, архив). */
 function actionPurge(deps) {
     const count = deps.store.purgeAll();
     deps.trackerRef.current = null;
@@ -484,10 +602,9 @@ function actionPurge(deps) {
 /** Фолбэк из хвоста монолита: 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).
+        // Update с id на черновик/архив: говорим, что план read-only, а не голое
+        // "No active plan" (было: 10+ итераций re-update архивного плана с тем же
+        // бесполезным ответом).
         if (args.id) {
             const found = deps.store.find(String(args.id));
             if (found && found.status !== "active") {
@@ -504,6 +621,7 @@ function noActiveOrUnknown(deps, args, action) {
         output: t("plan.unknown_action", { action }),
     };
 }
+/** Словарь действий плана: имя → обработчик. */
 export const PLAN_ACTIONS = {
     list: actionList,
     switch: actionSwitch,