micro-models-agent 0.41.0 → 0.41.2

package/dist/modules/execution/moe-executor.js

@@ -2,6 +2,7 @@ import { getExpertConfig } from "../../config/experts";
 import { filterToolsByTags } from "../../tools/filter-tools";
 import { StuckDetector } from "./stuck-detector";
 import { t } from "../../i18n/index";
+import { ArtifactStore } from "../artifacts/store";
 const TRANSIENT_ERROR_PATTERNS = [
     "timeout",
     "Timeout",
@@ -102,14 +103,38 @@ async function executeSubtask(subtask, deps, _sharedContext) {
                 read_only_files: readOnlyFiles,
                 tool_tags: expertConfig.tool_tags,
             };
+            if (deps.config.subagent?.resultMode === "file") {
+                subagentArgs.result_mode = "file";
+                subagentArgs.artifact_name = subtask.id;
+            }
             const result = await subagentTool.handler({
                 config: deps.config,
                 baseDir: deps.baseDir,
                 logger: deps.logger,
                 llmProvider: deps.llmProvider,
                 toolExecutor: deps.toolExecutor,
+                sessionId: "moe",
             }, subagentArgs);
             if (result.success) {
+                if (deps.config.subagent?.resultMode === "file") {
+                    const pathMatch = result.output.match(/saved to artifact: (.+)/);
+                    const abs = pathMatch ? pathMatch[1].trim() : "";
+                    if (abs) {
+                        const store = new ArtifactStore({
+                            baseDir: deps.baseDir,
+                            sessionId: "moe",
+                        });
+                        const full = store.read(abs.split(/[\\/]/).pop() || ""); // file name only, scoped to root
+                        deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
+                        return {
+                            subtaskId: subtask.id,
+                            success: true,
+                            summary: `Artifact: ${abs}`,
+                            result: full ?? result.output,
+                            durationMs: Date.now() - startTime,
+                        };
+                    }
+                }
                 return {
                     subtaskId: subtask.id,
                     success: true,

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

@@ -29,9 +29,7 @@ function listDir(dir, baseDir) {
     if (!existsSync(dir))
         return [];
     const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-    return files
-        .map((f) => readPlanFile(join(dir, f), baseDir))
-        .filter((p) => p !== null);
+    return files.map((f) => readPlanFile(join(dir, f), baseDir)).filter((p) => p !== null);
 }
 function toMeta(plan, status) {
     return {

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

@@ -0,0 +1,508 @@
+import { t } from "../../i18n/index";
+import { PlanCreator } from "./planner";
+import { checkPlanCoverage } from "./plan-coverage";
+/**
+ * The plan / todo / verify tool definitions for the execution module. The
+ * handlers were extracted verbatim from ExecutionModule.getToolDefinitions() —
+ * all state access goes through the `deps` closures (the module owns the
+ * tracker and the plan store).
+ */
+export function createPlanToolDefinitions(deps) {
+    return [
+        {
+            name: "plan",
+            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).',
+            parameters: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: ["create", "update", "show", "abort", "list", "switch", "re-plan"],
+                    },
+                    title: { type: "string" },
+                    steps: { type: "array", items: { type: "string" } },
+                    kinds: {
+                        type: "array",
+                        items: { type: "string", enum: ["create", "delete"] },
+                        description: 'Optional per-step intent, aligned 1:1 with steps. Pass "delete" for steps whose purpose is REMOVING files — the done-gate then requires those files to be GONE (not present). Defaults to "create".',
+                    },
+                    step: { type: "number" },
+                    status: { type: "string", enum: ["done", "failed", "skipped"] },
+                    note: { type: "string" },
+                    id: { type: "string", description: "Plan id (for switch action)" },
+                },
+                required: ["action"],
+            },
+            handler: async (_ctx, args) => {
+                const action = String(args.action);
+                if (action === "list") {
+                    const metas = 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}`;
+                    });
+                    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 }),
+                        };
+                    }
+                    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);
+                    const display = PlanCreator.toPromptBlock(found.plan, 0);
+                    return {
+                        success: true,
+                        output: t("plan.switched", {
+                            id: found.plan.id,
+                            title: found.plan.title,
+                        }),
+                        display,
+                    };
+                }
+                if (action === "re-plan") {
+                    if (!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 = PlanCreator.toPromptBlock(replanned, keptCount);
+                    return {
+                        success: true,
+                        output: t("plan.replanned", {
+                            kept: String(keptCount),
+                            steps: String(newSteps.length),
+                        }),
+                        display,
+                    };
+                }
+                if (action === "create") {
+                    const title = String(args.title || "Task Plan");
+                    const steps = Array.isArray(args.steps) ? args.steps.map(String) : [];
+                    if (steps.length === 0) {
+                        return { success: false, output: t("plan.no_steps") };
+                    }
+                    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.trackerRef.current = null;
+                        const done = plan.steps.filter((s) => s.status === "done").length;
+                        return {
+                            success: true,
+                            output: t("plan.completed_archived", {
+                                id: plan.id,
+                                done: String(done),
+                                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).
+                    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(", "),
+                                    }),
+                                };
+                            }
+                        }
+                    }
+                    tracker.updateStepStatus(stepId, status);
+                    if (args.note)
+                        tracker.addNote(Number(args.step), String(args.note));
+                    tracker.syncCurrentStep();
+                    deps.store.saveActive(tracker.getPlan());
+                    // 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.trackerRef.current = null;
+                        const done = plan.steps.filter((s) => s.status === "done").length;
+                        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),
+                                total: String(plan.steps.length),
+                            })}`,
+                        };
+                    }
+                    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}`,
+                        display,
+                    };
+                }
+                if (action === "update" &&
+                    Array.isArray(args.steps) &&
+                    args.steps.length > 0 &&
+                    deps.trackerRef.current) {
+                    const tracker = deps.trackerRef.current;
+                    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 = PlanCreator.toPromptBlock(plan, 0);
+                    const output = t("plan.updated", {
+                        title,
+                        steps: String(steps.length),
+                    });
+                    return {
+                        success: true,
+                        output,
+                        display,
+                    };
+                }
+                if (action === "abort") {
+                    const tracker = deps.trackerRef.current;
+                    if (tracker) {
+                        deps.store.archivePlan(tracker.getPlan());
+                    }
+                    deps.trackerRef.current = null;
+                    deps.store.clearActive();
+                    return { success: true, output: t("plan.aborted") };
+                }
+                if (!deps.trackerRef.current) {
+                    return { success: false, output: t("plan.no_active") };
+                }
+                return {
+                    success: false,
+                    output: t("plan.unknown_action", { action }),
+                };
+            },
+        },
+        {
+            name: "todo",
+            alwaysOn: true,
+            description: "Manage sub-tasks within current plan step. Use to break down complex steps into smaller tasks.",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["add", "done", "list"] },
+                    items: { type: "array", items: { type: "string" } },
+                },
+                required: ["action"],
+            },
+            handler: async (_ctx, args) => {
+                if (!deps.trackerRef.current) {
+                    return { success: false, output: t("plan.no_active") };
+                }
+                const tracker = deps.trackerRef.current;
+                const action = String(args.action);
+                const currentStep = tracker.getCurrentStep();
+                if (!currentStep) {
+                    return { success: false, output: t("plan.step_not_found") };
+                }
+                if (action === "add" && Array.isArray(args.items)) {
+                    const items = args.items.map(String);
+                    const existing = currentStep.subtasks ?? [];
+                    let nextId = existing.reduce((m, s) => Math.max(m, s.id), 0) + 1;
+                    for (const item of items) {
+                        existing.push({ id: nextId++, text: item, done: false });
+                    }
+                    currentStep.subtasks = existing;
+                    deps.store.saveActive(tracker.getPlan());
+                    const display = tracker.toPromptBlock();
+                    return {
+                        success: true,
+                        output: t("todo.added", {
+                            count: String(items.length),
+                            items: items.join(", "),
+                        }),
+                        display,
+                    };
+                }
+                if (action === "done") {
+                    const items = Array.isArray(args.items) ? args.items.map(String) : [];
+                    if (items.length === 0) {
+                        return {
+                            success: false,
+                            output: t("todo.no_items"),
+                        };
+                    }
+                    const subs = currentStep.subtasks ?? [];
+                    let marked = 0;
+                    for (const item of items) {
+                        const sub = subs.find((s) => !s.done && s.text.toLowerCase() === item.toLowerCase());
+                        if (sub) {
+                            sub.done = true;
+                            marked++;
+                        }
+                    }
+                    if (marked === 0) {
+                        return {
+                            success: false,
+                            output: t("todo.subtask_not_found", {
+                                items: items.join(", "),
+                            }),
+                        };
+                    }
+                    currentStep.subtasks = subs;
+                    deps.store.saveActive(tracker.getPlan());
+                    const doneCount = subs.filter((s) => s.done).length;
+                    const display = tracker.toPromptBlock();
+                    // Marking a sub-task done must NOT auto-complete the plan
+                    // step — the step is only done when the model confirms the
+                    // whole step via plan update (observed: 3 × "todo done"
+                    // returned "Step 3: done" and marked the step done early).
+                    let output = t("todo.marked_done", {
+                        count: String(marked),
+                    });
+                    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.`;
+                    }
+                    return { success: true, output, display };
+                }
+                if (action === "list") {
+                    const subs = currentStep.subtasks ?? [];
+                    const lines = subs.length
+                        ? subs.map((s) => `${s.done ? "[x]" : "[ ]"} ${s.text}`)
+                        : ["(no sub-tasks)"];
+                    return {
+                        success: true,
+                        output: `Step ${currentStep.id}: ${currentStep.description}\n${lines.join("\n")}`,
+                    };
+                }
+                return {
+                    success: false,
+                    output: t("todo.unknown_action", { action }),
+                };
+            },
+        },
+        {
+            name: "verify",
+            alwaysOn: true,
+            description: "Run verification for the current step. Checks files mentioned in the step description.",
+            parameters: {
+                type: "object",
+                properties: {
+                    step: { type: "number", description: "Step number to verify" },
+                },
+            },
+            handler: async (_ctx, args) => {
+                if (!deps.trackerRef.current)
+                    return { success: false, output: t("plan.no_active") };
+                const tracker = deps.trackerRef.current;
+                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);
+                if (result.noFiles) {
+                    return {
+                        success: true,
+                        output: t("verify.no_files", { step: String(step.id) }),
+                    };
+                }
+                return {
+                    success: result.passed,
+                    output: result.passed
+                        ? t("verify.passed")
+                        : t("verify.failed", {
+                            details: result.failed.map((f) => f.message).join("; "),
+                        }),
+                };
+            },
+        },
+    ];
+}

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

@@ -3,7 +3,7 @@ export function validatePlan(plan, config) {
     const warnings = [];
     const autoFixes = [];
     if (!plan.subtasks || plan.subtasks.length === 0) {
-        return { valid: false, errors: ['Plan has no subtasks'], warnings: [], autoFixes: [] };
+        return { valid: false, errors: ["Plan has no subtasks"], warnings: [], autoFixes: [] };
     }
     errors.push(...expertTagsExist(plan.subtasks, config));
     errors.push(...hasCycle(plan.subtasks));
@@ -30,7 +30,7 @@ export function expertTagsExist(subtasks, config) {
     const knownExperts = new Set(Object.keys(config.experts || {}));
     for (const subtask of subtasks) {
         if (!knownExperts.has(subtask.expert_tag)) {
-            errors.push(`Subtask "${subtask.id}" references unknown expert_tag "${subtask.expert_tag}". Known experts: ${Array.from(knownExperts).join(', ')}`);
+            errors.push(`Subtask "${subtask.id}" references unknown expert_tag "${subtask.expert_tag}". Known experts: ${Array.from(knownExperts).join(", ")}`);
         }
     }
     return errors;
@@ -81,12 +81,12 @@ export function hasAllowedFilesOverlap(subtasks) {
     }
     for (const [file, writers] of writeFiles) {
         if (writers.length > 1) {
-            const noDep = writers.filter(w => {
-                const sub = subtasks.find(s => s.id === w);
-                return sub && !sub.depends_on?.some(d => writers.includes(d));
+            const noDep = writers.filter((w) => {
+                const sub = subtasks.find((s) => s.id === w);
+                return sub && !sub.depends_on?.some((d) => writers.includes(d));
             });
             if (noDep.length > 1) {
-                errors.push(`Write-write overlap on "${file}" between subtasks: ${writers.join(', ')} without dependency chain`);
+                errors.push(`Write-write overlap on "${file}" between subtasks: ${writers.join(", ")} without dependency chain`);
             }
         }
     }
@@ -104,7 +104,7 @@ export function deleteReadOverlap(subtasks) {
                 continue;
             const readFiles = new Set(reader.read_only_files);
             const writeFiles = writer.allowed_files;
-            const overlapping = writeFiles.filter(f => {
+            const overlapping = writeFiles.filter((f) => {
                 for (const rf of readFiles) {
                     if (f.startsWith(rf) || rf.startsWith(f))
                         return true;
@@ -125,7 +125,7 @@ export function deleteReadOverlap(subtasks) {
                         subtaskId: reader.id,
                         dependsOn: writer.id,
                         canAutoFix: false,
-                        error: `Read-after-write overlap between "${writer.id}" (writer) and "${reader.id}" (reader) on "${overlapping.join(', ')}" — add depends_on: [${writer.id}]`,
+                        error: `Read-after-write overlap between "${writer.id}" (writer) and "${reader.id}" (reader) on "${overlapping.join(", ")}" — add depends_on: [${writer.id}]`,
                     });
                 }
             }
@@ -134,9 +134,9 @@ export function deleteReadOverlap(subtasks) {
     return results;
 }
 export function applyAutoFixes(plan, autoFixes) {
-    const fixed = { ...plan, subtasks: plan.subtasks.map(s => ({ ...s })) };
+    const fixed = { ...plan, subtasks: plan.subtasks.map((s) => ({ ...s })) };
     for (const fix of autoFixes) {
-        const sub = fixed.subtasks.find(s => s.id === fix.subtaskId);
+        const sub = fixed.subtasks.find((s) => s.id === fix.subtaskId);
         if (!sub)
             continue;
         const dependsOnMatch = fix.fix.match(/depends_on:\s*(\S+)/);

package/dist/modules/execution/planner.js

@@ -26,7 +26,7 @@ export class PlanCreator {
         const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
         return hasActionWord && words.length > 8;
     }
-    static createPlan(title, stepDescriptions, baseDir) {
+    static createPlan(title, stepDescriptions, baseDir, kinds) {
         const stepCount = stepDescriptions.length;
         return {
             id: generatePlanId(),
@@ -35,6 +35,7 @@ export class PlanCreator {
                 id: i + 1,
                 description: desc,
                 status: "pending",
+                kind: kinds?.[i] ?? "create",
             })),
             createdAt: new Date().toISOString(),
             baseDir,
@@ -49,6 +50,7 @@ export class PlanCreator {
             id: kept.length + i + 1,
             description: desc,
             status: "pending",
+            kind: "create",
         }));
         return {
             id: plan.id,
@@ -79,6 +81,9 @@ export class PlanCreator {
                             : "[ ]";
             const note = step.note ? ` — ${step.note}` : "";
             lines.push(`${icon} ${step.id}. ${step.description}${note}`);
+            for (const sub of step.subtasks ?? []) {
+                lines.push(`    ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
+            }
         }
         return lines.join("\n");
     }