micro-models-agent 0.47.0 → 0.48.1

package/dist/modules/execution/planner.js

@@ -0,0 +1,90 @@
+function generatePlanId() {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let id = "";
+    for (let i = 0; i < 6; i++) {
+        id += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return `plan_${id}`;
+}
+export class PlanCreator {
+    static isMultiStep(task) {
+        const fileCount = (task.match(/\b[\w./-]+\.[a-z]+\b/gi) || []).length;
+        if (fileCount > 1)
+            return true;
+        const actionWords = [
+            "implement",
+            "create",
+            "add",
+            "build",
+            "setup",
+            "configure",
+            "write",
+            "make",
+            "develop",
+        ];
+        const words = task.split(/\s+/);
+        const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
+        return hasActionWord && words.length > 8;
+    }
+    static createPlan(title, stepDescriptions, baseDir, kinds) {
+        const stepCount = stepDescriptions.length;
+        return {
+            id: generatePlanId(),
+            title: `[${stepCount}] ${title}`,
+            steps: stepDescriptions.map((desc, i) => ({
+                id: i + 1,
+                description: desc,
+                status: "pending",
+                kind: kinds?.[i] ?? "create",
+            })),
+            createdAt: new Date().toISOString(),
+            baseDir,
+        };
+    }
+    static replan(plan, newSteps, title) {
+        const kept = plan.steps.filter((s) => s.status === "done" || s.status === "skipped");
+        const baseTitle = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
+        const newTitle = title || baseTitle;
+        const totalSteps = kept.length + newSteps.length;
+        const added = newSteps.map((desc, i) => ({
+            id: kept.length + i + 1,
+            description: desc,
+            status: "pending",
+            kind: "create",
+        }));
+        return {
+            id: plan.id,
+            title: `[${totalSteps}] ${newTitle}`,
+            steps: [...kept, ...added],
+            createdAt: plan.createdAt,
+            baseDir: plan.baseDir,
+            name: plan.name,
+        };
+    }
+    static toPromptBlock(plan, currentStepIndex) {
+        const date = plan.createdAt.slice(0, 10);
+        const lines = [
+            `[${plan.id}] ${plan.title}`,
+            `Dir: ${plan.baseDir}`,
+            `Created: ${date} | Progress: ${plan.steps.filter((s) => s.status === "done").length}/${plan.steps.length} done, current: step ${currentStepIndex + 1}`,
+            ``,
+        ];
+        for (const step of plan.steps) {
+            const icon = step.status === "done"
+                ? "[x]"
+                : step.status === "in_progress"
+                    ? "[*]"
+                    : step.status === "failed"
+                        ? "[!]"
+                        : step.status === "skipped"
+                            ? "[-]"
+                            : "[ ]";
+            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");
+    }
+}

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

@@ -0,0 +1,510 @@
+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,
+];
+const BLOCKING_PATTERNS = [
+    /EACCES/i,
+    /permission denied/i,
+    /EPERM/i,
+    /ENOENT.*node_modules/i,
+    /ENOTDIR/i,
+    /invalid.*token/i,
+    /unauthorized/i,
+    /401/i,
+    /403/i,
+];
+export function classifyError(output) {
+    for (const p of TRANSIENT_PATTERNS) {
+        if (p.test(output))
+            return "transient";
+    }
+    for (const p of BLOCKING_PATTERNS) {
+        if (p.test(output))
+            return "blocking";
+    }
+    return "systematic";
+}
+/**
+ * Tools that only observe state and never change it. A long run of only these
+ * with no write/exec in between means the model is reading/exploring without
+ * producing anything — a read-only loop that the stuck detector must surface
+ * (observed: 50+ read_file iterations with zero writes after a false-positive
+ * audit rejected a completed task).
+ */
+const READ_ONLY_TOOLS = new Set([
+    "read_file",
+    "glob",
+    "grep",
+    "list_dir",
+    "file_info",
+    "browser",
+    "web_search",
+    "web_fetch",
+    "web_browse",
+    "search_history",
+    "recall",
+    "project_map",
+    "chunk_query",
+    "process_list",
+    "process_log",
+    "plan",
+    "todo",
+    "verify",
+    "load_skill",
+]);
+/** Consecutive read-only tool calls that constitute a loop. */
+const READ_ONLY_LOOP_THRESHOLD = 10;
+export class StuckDetector {
+    threshold;
+    errorThreshold;
+    iterationsOnCurrentStep = 0;
+    currentStepId = null;
+    toolErrors = new Map();
+    currentStepDescription = "";
+    recentToolCalls = [];
+    maxRecentCalls = 10;
+    repetitionThreshold = 3;
+    consecutiveFailures = 0;
+    lastFailedTool = "";
+    lastErrorOutput = "";
+    escalationCount = 0;
+    escalationThreshold = 3;
+    fileRewriteCount = new Map();
+    fileRewriteThreshold = 3;
+    lastBashCommand = "";
+    lastBashOutput = "";
+    emptyBashRunCount = 0;
+    readOnlyStreak = 0;
+    constructor(threshold = 6, errorThreshold = 3) {
+        this.threshold = threshold;
+        this.errorThreshold = errorThreshold;
+    }
+    recordIteration(stepId) {
+        if (stepId === this.currentStepId) {
+            this.iterationsOnCurrentStep++;
+        }
+        else {
+            this.resetStepState(stepId);
+        }
+    }
+    recordToolCall(name, args) {
+        const argsKey = JSON.stringify(args);
+        this.recentToolCalls.push({ name, argsKey });
+        if (this.recentToolCalls.length > this.maxRecentCalls) {
+            this.recentToolCalls.shift();
+        }
+        // Track the consecutive read-only streak. A write/exec tool resets it;
+        // plan/todo bookkeeping counts as read-only (it is not real progress).
+        if (READ_ONLY_TOOLS.has(name)) {
+            this.readOnlyStreak++;
+        }
+        else {
+            this.readOnlyStreak = 0;
+        }
+    }
+    /**
+     * True after a long run of read-only tool calls with no write in between.
+     * The model is exploring/looping without producing anything — inject a
+     * recovery hint so it stops re-reading and actually edits files.
+     */
+    hasReadOnlyLoop() {
+        return this.readOnlyStreak >= READ_ONLY_LOOP_THRESHOLD;
+    }
+    recordToolError(toolName, output) {
+        this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
+        this.consecutiveFailures++;
+        this.lastFailedTool = toolName;
+        if (output)
+            this.lastErrorOutput = output;
+    }
+    getLastErrorOutput() {
+        return this.lastErrorOutput;
+    }
+    /**
+     * Record every bash invocation (successful or not) so stuck detection can
+     * reason about repeated runs with empty output, entry-point issues, and
+     * platform mistakes (PowerShell cmdlets in cmd.exe, bash heredocs, ...).
+     */
+    recordBashOutput(command, output) {
+        const trimmed = output.trim();
+        if (command === this.lastBashCommand && !trimmed) {
+            this.emptyBashRunCount++;
+        }
+        else {
+            this.emptyBashRunCount = 0;
+        }
+        this.lastBashCommand = command;
+        this.lastBashOutput = output;
+    }
+    getLastBashCommand() {
+        return this.lastBashCommand;
+    }
+    getLastBashOutput() {
+        return this.lastBashOutput;
+    }
+    getLastFailedTool() {
+        return this.lastFailedTool;
+    }
+    getIterationsOnCurrentStep() {
+        return this.iterationsOnCurrentStep;
+    }
+    recordToolSuccess() {
+        this.consecutiveFailures = 0;
+        this.lastFailedTool = "";
+        this.escalationCount = 0;
+    }
+    setCurrentStep(stepId, description) {
+        if (stepId !== this.currentStepId) {
+            this.resetStepState(stepId);
+        }
+        this.currentStepDescription = description;
+    }
+    isStuck() {
+        return this.iterationsOnCurrentStep > this.threshold;
+    }
+    hasRepetitiveErrors(toolName) {
+        if (toolName) {
+            return (this.toolErrors.get(toolName) || 0) >= this.errorThreshold;
+        }
+        return Array.from(this.toolErrors.values()).some((c) => c >= this.errorThreshold);
+    }
+    hasRepetitiveToolCalls() {
+        if (this.recentToolCalls.length < this.repetitionThreshold)
+            return false;
+        const last = this.recentToolCalls[this.recentToolCalls.length - 1];
+        // Check consecutive identical calls (original logic)
+        let consecutiveCount = 1;
+        for (let i = this.recentToolCalls.length - 2; i >= 0; i--) {
+            if (this.recentToolCalls[i].name === last.name &&
+                this.recentToolCalls[i].argsKey === last.argsKey) {
+                consecutiveCount++;
+            }
+            else {
+                break;
+            }
+        }
+        if (consecutiveCount >= this.repetitionThreshold)
+            return true;
+        // Also detect interleaved patterns (A, B, A, B, A) — count any single
+        // tool+args combo in the window and flag if it appears >= threshold times
+        const counts = new Map();
+        for (const call of this.recentToolCalls) {
+            const key = `${call.name}::${call.argsKey}`;
+            counts.set(key, (counts.get(key) || 0) + 1);
+        }
+        for (const count of counts.values()) {
+            if (count >= this.repetitionThreshold)
+                return true;
+        }
+        return false;
+    }
+    hasConsecutiveFailures() {
+        return this.consecutiveFailures >= this.errorThreshold;
+    }
+    getConsecutiveFailuresCount() {
+        return this.consecutiveFailures;
+    }
+    recordEscalation() {
+        this.escalationCount++;
+    }
+    shouldEscalate() {
+        return this.escalationCount >= this.escalationThreshold;
+    }
+    resetEscalation() {
+        this.escalationCount = 0;
+    }
+    getEscalationCount() {
+        return this.escalationCount;
+    }
+    getHints() {
+        const hints = [];
+        const desc = this.currentStepDescription.toLowerCase();
+        if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
+            hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
+        }
+        if (desc.includes("test") || desc.includes("spec")) {
+            hints.push("Make sure the source files exist and have real code before running tests.");
+        }
+        if (desc.includes("build") || desc.includes("compile")) {
+            hints.push("Check that all dependencies are installed and source files are not empty.");
+        }
+        if (desc.includes("deploy") || desc.includes("publish")) {
+            hints.push("Verify credentials and network access before deploying.");
+        }
+        // State-based bullets. The recovery message (getRecoveryMessage) already
+        // reports the PRIMARY reason (priority: stuck > tool-errors > consecutive
+        // > repetitive > read-only). Repeating that same state here as a hint
+        // would duplicate the guidance in the same cooldown block. Only add the
+        // bullet when the recovery message is NOT already covering that state.
+        const primary = this.getPrimaryReason();
+        if (this.hasRepetitiveToolCalls() && primary !== "repetitive") {
+            hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
+        }
+        if (this.hasConsecutiveFailures() && primary !== "consecutive") {
+            hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
+        }
+        if (this.hasReadOnlyLoop() && primary !== "read-only") {
+            hints.push("You have made many read-only tool calls (read_file/glob/grep/browser) without writing anything. Stop exploring — make the edit/write the task needs, or use the plan tool to decide next steps.");
+        }
+        return hints;
+    }
+    getActionableHints() {
+        const hints = [];
+        const error = this.lastErrorOutput;
+        // Bash-specific hints do not depend on a tool failure — they fire even
+        // when the command "succeeded" with empty output (missing entry point).
+        const isScriptRun = /(^|[\s&])(bun|node|tsx|ts-node|deno|python|python3)\S*\s+[^|&]+\s+[^\s]+$/.test(this.lastBashCommand);
+        if (isScriptRun && !this.lastBashOutput.trim() && this.emptyBashRunCount >= 2) {
+            hints.push(`The command "${this.lastBashCommand}" ran ${this.emptyBashRunCount} times with EMPTY output. The program likely has no entry point — read the file with read_file and check that it actually calls its main function with process.argv / CLI arguments and prints results (console.log). Then run it again.`);
+        }
+        if (!error)
+            return hints;
+        // Runtime incompatibility — tool/module crashes on this Node version
+        if (/Cannot read properties of undefined|is not a function|is not a constructor/i.test(error)) {
+            if (/node_modules/.test(error)) {
+                hints.push("A dependency is incompatible with your Node.js version. Check if there is an alternative package or use a different runtime.");
+            }
+        }
+        // TypeScript syntax errors — model generated invalid code
+        if (/TS1005|TS1003|TS1109|TS1128|TS1434/i.test(error)) {
+            hints.push("TypeScript syntax error. Read the error message carefully — it tells you the exact line and column. Fix the syntax before retrying.");
+        }
+        // TypeScript type errors — model doesn't understand the types
+        if (/TS2322|TS2345|TS2769|TS7006|TS7016/i.test(error)) {
+            hints.push("TypeScript type mismatch. Check the type signature of the function/API you are using. If a package lacks type declarations, install @types/<package> or use skipLibCheck.");
+        }
+        // Module not found — missing dependency or wrong import
+        if (/Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i.test(error)) {
+            hints.push("Module not found. Run npm install or check if the import path is correct.");
+        }
+        // Permission / access errors
+        if (/EACCES|EPERM|permission denied/i.test(error)) {
+            hints.push("Permission denied. Check file permissions or run with appropriate privileges.");
+        }
+        // Network errors
+        if (/ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(error)) {
+            hints.push("Network error. Check if the server is running and accessible.");
+        }
+        // Command not found
+        if (/is not recognized|command not found|not found in path/i.test(error)) {
+            hints.push("Command not found. Check if the tool is installed and in PATH.");
+        }
+        // File rewrite loop — same file keeps failing
+        if (this.hasExcessiveRewrites()) {
+            const file = this.getExcessiveRewriteFile();
+            hints.push(`File ${file} has been rewritten ${this.getFileRewriteCount(file)} times without success. Stop rewriting and try a fundamentally different approach.`);
+        }
+        // Repeated identical bash runs with empty output — likely a missing
+        // entry point (the program never calls its main function).
+        // PowerShell cmdlets used inside cmd.exe (Windows shell mismatch).
+        if (/Write-Host|Get-Content|Select-String|Out-File|Set-Content/i.test(error)) {
+            hints.push("That looks like a PowerShell cmdlet — the shell here is cmd.exe. Use echo/type for output or the read_file/write_file tools instead.");
+        }
+        // Model invented a Bun API that does not exist.
+        if (/Bun\.\w+ is not a function|Bun\.\w+ is not defined|Bun\.\w+ is not a constructor/i.test(error)) {
+            hints.push("That Bun API does not exist. Verify the API name in the Bun docs — common ones are Bun.file, Bun.write, Bun.spawn, Bun.serve. For file checks use fs.existsSync from node:fs.");
+        }
+        // The model keeps writing a file whose output shows a type/syntax
+        // error — read the actual error and fix it, don't rewrite blindly.
+        if (/error TS\d+|typecheck failed|syntax check failed/i.test(error)) {
+            hints.push("The file still has a type/syntax error (see the error line in the output). Read the file with read_file around the reported line, fix the actual error, then re-run — rewriting the whole file blindly usually makes it worse.");
+        }
+        // Bash heredoc in cmd.exe.
+        if (/unexpected.*<<|Непредвиденное появление/i.test(error)) {
+            hints.push("Heredoc (<< EOF) is a bash feature — this shell is cmd.exe and does not support it. Write the file with write_file instead.");
+        }
+        return hints;
+    }
+    getToolAlternative() {
+        const tool = this.lastFailedTool;
+        const error = this.lastErrorOutput;
+        if (!tool)
+            return null;
+        // If a tool fails with a runtime crash, suggest alternatives
+        if (/Cannot read properties of undefined|is not a function|TypeError|ReferenceError/i.test(error)) {
+            // Map of tools to their common alternatives
+            const alternatives = {
+                "ts-node": "tsx",
+                jest: "vitest",
+                mocha: "vitest",
+                webpack: "vite",
+                rollup: "vite",
+                parcel: "vite",
+                babel: "tsc",
+                eslint: "biome",
+                prettier: "biome",
+            };
+            for (const [failed, alt] of Object.entries(alternatives)) {
+                if (tool.includes(failed) || error.includes(failed)) {
+                    return alt;
+                }
+            }
+        }
+        return null;
+    }
+    recordFileRewrite(filePath) {
+        const count = (this.fileRewriteCount.get(filePath) || 0) + 1;
+        this.fileRewriteCount.set(filePath, count);
+    }
+    getFileRewriteCount(filePath) {
+        return this.fileRewriteCount.get(filePath) || 0;
+    }
+    hasExcessiveRewrites() {
+        return Array.from(this.fileRewriteCount.values()).some((c) => c >= this.fileRewriteThreshold);
+    }
+    getExcessiveRewriteFile() {
+        for (const [file, count] of this.fileRewriteCount) {
+            if (count >= this.fileRewriteThreshold)
+                return file;
+        }
+        return null;
+    }
+    getRepetitiveToolMessage() {
+        if (!this.hasRepetitiveToolCalls())
+            return "";
+        const last = this.recentToolCalls[this.recentToolCalls.length - 1];
+        return t("exec.repetitive_tool", {
+            tool: last.name,
+            count: this.repetitionThreshold,
+        });
+    }
+    getStuckReason() {
+        if (this.isStuck()) {
+            return t("exec.stuck", {
+                stepId: String(this.currentStepId ?? "?"),
+                description: this.currentStepDescription,
+                iterations: this.iterationsOnCurrentStep,
+            });
+        }
+        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        if (errorTool) {
+            return t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
+        }
+        if (this.hasReadOnlyLoop()) {
+            return t("exec.read_only_loop", {
+                count: String(this.readOnlyStreak),
+            });
+        }
+        return "";
+    }
+    getRecoveryMessage() {
+        const reason = this.getPrimaryReason();
+        if (reason === "stuck") {
+            return t("exec.stuck_recovery", {
+                iterations: this.iterationsOnCurrentStep,
+                stepId: String(this.currentStepId ?? "?"),
+                description: this.currentStepDescription,
+            });
+        }
+        // Per-tool error recovery (more specific — e.g., "bash failed 3 times")
+        if (reason === "tool-errors") {
+            const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+            return t("exec.tool_errors_recovery", {
+                tool: errorTool[0],
+                count: errorTool[1],
+            });
+        }
+        // Consecutive failures from different tools (generic — e.g., "5 consecutive failures")
+        if (reason === "consecutive") {
+            return t("exec.consecutive_failures_recovery", {
+                count: this.consecutiveFailures,
+            });
+        }
+        if (reason === "repetitive") {
+            return this.getRepetitiveToolMessage();
+        }
+        if (reason === "read-only") {
+            return t("exec.read_only_loop_recovery", {
+                count: String(this.readOnlyStreak),
+            });
+        }
+        return "";
+    }
+    /**
+     * Single source of truth for the recovery reason priority. Used by BOTH
+     * getRecoveryMessage() and getHints() so the two cannot drift apart: the
+     * state bullet that getRecoveryMessage already reports is NOT repeated as a
+     * hint (priority: stuck > tool-errors > consecutive > repetitive >
+     * read-only).
+     */
+    getPrimaryReason() {
+        if (this.isStuck())
+            return "stuck";
+        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+        if (errorTool)
+            return "tool-errors";
+        if (this.hasConsecutiveFailures())
+            return "consecutive";
+        if (this.hasRepetitiveToolCalls())
+            return "repetitive";
+        if (this.hasReadOnlyLoop())
+            return "read-only";
+        return null;
+    }
+    reset() {
+        this.currentStepId = null;
+        this.iterationsOnCurrentStep = 0;
+        this.toolErrors.clear();
+        this.consecutiveFailures = 0;
+        this.lastFailedTool = "";
+        this.lastErrorOutput = "";
+        this.recentToolCalls = [];
+        this.fileRewriteCount.clear();
+        this.escalationCount = 0;
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
+        this.readOnlyStreak = 0;
+    }
+    /**
+     * Reset only step-progress state, keeping the tool-call history and the
+     * read-only streak. Used when the plan is complete but the loop continues
+     * (e.g. the audit gate rejected a finished task): step-stuck warnings are
+     * silenced, but a read-without-write loop is still detected.
+     */
+    resetStepProgress() {
+        this.currentStepId = null;
+        this.iterationsOnCurrentStep = 0;
+        this.toolErrors.clear();
+        this.consecutiveFailures = 0;
+        this.lastFailedTool = "";
+        this.lastErrorOutput = "";
+        this.fileRewriteCount.clear();
+        this.escalationCount = 0;
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
+    }
+    /**
+     * Reset all per-step state when moving to a new step. Prevents errors and
+     * tool repetitions from one step leaking into the next (false-positive
+     * stuck/recovery on the first iteration of the new step).
+     */
+    resetStepState(stepId) {
+        this.currentStepId = stepId;
+        this.iterationsOnCurrentStep = 1;
+        this.toolErrors.clear();
+        this.consecutiveFailures = 0;
+        this.lastFailedTool = "";
+        this.lastErrorOutput = "";
+        this.recentToolCalls = [];
+        this.fileRewriteCount.clear();
+        this.lastBashCommand = "";
+        this.lastBashOutput = "";
+        this.emptyBashRunCount = 0;
+        this.readOnlyStreak = 0;
+        // Preserve escalationCount — prevents agent from "gaming" stuck detection
+        // by marking a step done and moving to the next one
+    }
+}

package/dist/modules/execution/tracker.js

@@ -0,0 +1,67 @@
+import { PlanCreator } from "./planner";
+export class PlanTracker {
+    plan;
+    currentStepIndex = 0;
+    constructor(plan) {
+        this.plan = plan;
+    }
+    getPlan() {
+        return this.plan;
+    }
+    getCurrentStepIndex() {
+        return this.currentStepIndex;
+    }
+    getCurrentStep() {
+        return this.plan.steps[this.currentStepIndex];
+    }
+    getStep(id) {
+        return this.plan.steps.find((s) => s.id === id);
+    }
+    updateStepStatus(id, status) {
+        const step = this.getStep(id);
+        if (step)
+            step.status = status;
+    }
+    addNote(id, note) {
+        const step = this.getStep(id);
+        if (step)
+            step.note = note;
+    }
+    advance() {
+        if (this.currentStepIndex < this.plan.steps.length - 1) {
+            this.currentStepIndex++;
+            this.plan.steps[this.currentStepIndex].status = "in_progress";
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Advance the pointer past any done/skipped steps without mutating their
+     * status. Keeps currentStepIndex in sync when the model marks steps done via
+     * the `plan update` tool (which never calls advance()). Without this,
+     * getCurrentStep() stays on the first step forever and the stuck detector
+     * accumulates false-positive "no progress" warnings.
+     */
+    syncCurrentStep() {
+        while (this.currentStepIndex < this.plan.steps.length - 1 &&
+            (this.plan.steps[this.currentStepIndex].status === "done" ||
+                this.plan.steps[this.currentStepIndex].status === "skipped")) {
+            this.currentStepIndex++;
+        }
+    }
+    isComplete() {
+        return this.plan.steps.every((s) => s.status === "done" || s.status === "skipped");
+    }
+    getProgressString() {
+        const done = this.plan.steps.filter((s) => s.status === "done").length;
+        const total = this.plan.steps.length;
+        const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+        const barWidth = 10;
+        const filled = Math.round((done / total) * barWidth);
+        const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+        return `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${bar}  ${pct}%`;
+    }
+    toPromptBlock() {
+        return PlanCreator.toPromptBlock(this.plan, this.currentStepIndex);
+    }
+}

package/dist/modules/execution/types.js

@@ -0,0 +1 @@
+export {};