centaurus-cli 3.0.1 → 3.1.0

package/dist/tools/plan-mode.js

@@ -1,534 +1,490 @@
-/**
- * Plan Mode - Structured Task Planning and Execution
- * Enables AI to create structured plans with hierarchical tasks and track completion
- *
- * Enhanced Features:
- * - Hierarchical tasks with subtasks (e.g., Task 1 -> 1.1, 1.2, 1.3)
- * - Design summary for context understanding
- * - Phased execution (one task at a time)
- * - Subtask-level completion tracking
- */
-// ============================================================================
-// STATE
-// ============================================================================
-// In-memory plan state
 let currentPlan = null;
-// ============================================================================
-// TOOLS
-// ============================================================================
-/**
- * Create Plan Tool
- * AI uses this to generate a structured plan with hierarchical tasks
- */
-export const createPlanTool = {
-    schema: {
-        name: 'create_plan',
-        description: `Use this tool when in planning mode to create a detailed implementation plan.
-This will present the plan to the user for review and approval before execution begins.
-
-The plan should include:
-1. A clear title describing what will be accomplished
-2. A detailed design summary explaining your understanding of the codebase and approach
-3. A brief summary of the overall approach
-4. A numbered list of main tasks, each optionally containing subtasks
-
-IMPORTANT: Only use this tool when in planning mode. Each task should be:
-- Specific and actionable
-- Can have subtasks for more granular steps
-- Ordered in a logical sequence
-
-Example structure:
-- Task 1: Set up core infrastructure
-  - 1.1: Create directory structure
-  - 1.2: Define TypeScript interfaces
-- Task 2: Implement main feature
-  - 2.1: Create component files
+const createPlanTool = {
+  schema: {
+    name: "create_plan",
+    description: `Use this tool when in planning mode to create a detailed implementation plan.
+This will present the plan to the user for review and approval before execution begins.
+
+The plan should include:
+1. A clear title describing what will be accomplished
+2. A detailed design summary explaining your understanding of the codebase and approach
+3. A brief summary of the overall approach
+4. A numbered list of main tasks, each optionally containing subtasks
+
+IMPORTANT: Only use this tool when in planning mode. Each task should be:
+- Specific and actionable
+- Can have subtasks for more granular steps
+- Ordered in a logical sequence
+
+Example structure:
+- Task 1: Set up core infrastructure
+  - 1.1: Create directory structure
+  - 1.2: Define TypeScript interfaces
+- Task 2: Implement main feature
+  - 2.1: Create component files
   - 2.2: Add unit tests`,
-        parameters: {
-            type: 'object',
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "A clear, concise title for the plan"
+        },
+        designSummary: {
+          type: "string",
+          description: "Detailed understanding of the codebase and how the changes will be implemented. Include architecture decisions, file structure understanding, and implementation approach."
+        },
+        summary: {
+          type: "string",
+          description: "Brief 1-2 sentence summary of the overall approach"
+        },
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
             properties: {
-                title: {
-                    type: 'string',
-                    description: 'A clear, concise title for the plan'
-                },
-                designSummary: {
-                    type: 'string',
-                    description: 'Detailed understanding of the codebase and how the changes will be implemented. Include architecture decisions, file structure understanding, and implementation approach.'
-                },
-                summary: {
-                    type: 'string',
-                    description: 'Brief 1-2 sentence summary of the overall approach'
-                },
-                tasks: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            description: {
-                                type: 'string',
-                                description: 'Clear description of what this main task accomplishes'
-                            },
-                            subtasks: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        description: {
-                                            type: 'string',
-                                            description: 'Specific subtask description'
-                                        },
-                                        requirements: {
-                                            type: 'string',
-                                            description: 'Optional traceability requirements'
-                                        }
-                                    },
-                                    required: ['description']
-                                },
-                                description: 'Optional list of subtasks within this main task'
-                            },
-                            complexity: {
-                                type: 'string',
-                                enum: ['low', 'medium', 'high'],
-                                description: 'Estimated complexity of the task'
-                            },
-                            requirements: {
-                                type: 'string',
-                                description: 'Optional traceability requirements'
-                            }
-                        },
-                        required: ['description']
+              description: {
+                type: "string",
+                description: "Clear description of what this main task accomplishes"
+              },
+              subtasks: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    description: {
+                      type: "string",
+                      description: "Specific subtask description"
                     },
-                    description: 'List of main tasks to execute, in order'
-                }
+                    requirements: {
+                      type: "string",
+                      description: "Optional traceability requirements"
+                    }
+                  },
+                  required: ["description"]
+                },
+                description: "Optional list of subtasks within this main task"
+              },
+              complexity: {
+                type: "string",
+                enum: ["low", "medium", "high"],
+                description: "Estimated complexity of the task"
+              },
+              requirements: {
+                type: "string",
+                description: "Optional traceability requirements"
+              }
             },
-            required: ['title', 'summary', 'tasks']
+            required: ["description"]
+          },
+          description: "List of main tasks to execute, in order"
         }
-    },
-    async execute(args, context) {
-        const title = args.title;
-        const designSummary = args.designSummary || '';
-        const summary = args.summary;
-        const tasks = args.tasks;
-        if (!title || title.trim().length === 0) {
-            throw new Error('Plan title cannot be empty');
-        }
-        if (!tasks || tasks.length === 0) {
-            throw new Error('Plan must have at least one task');
-        }
-        // Create the plan object with hierarchical structure
-        const plan = {
-            title: title.trim(),
-            designSummary: designSummary?.trim() || '',
-            summary: summary?.trim() || '',
-            steps: tasks.map((task, taskIndex) => ({
-                id: `task_${taskIndex + 1}`,
-                description: task.description.trim(),
-                subtasks: (task.subtasks || []).map((subtask, subtaskIndex) => ({
-                    id: `${taskIndex + 1}.${subtaskIndex + 1}`,
-                    description: subtask.description.trim(),
-                    status: 'pending',
-                    requirements: subtask.requirements?.trim()
-                })),
-                status: 'pending',
-                estimatedComplexity: task.complexity,
-                requirements: task.requirements?.trim()
-            })),
-            createdAt: new Date(),
-            approved: false,
-            isActive: false,
-            currentTaskIndex: 0,
-            currentSubtaskIndex: -1
-        };
-        currentPlan = plan;
-        // Return confirmation - the UI will handle displaying the plan
-        return `PLAN_CREATED:${JSON.stringify(plan)}`;
+      },
+      required: ["title", "summary", "tasks"]
+    }
+  },
+  async execute(args, context) {
+    const title = args.title;
+    const designSummary = args.designSummary || "";
+    const summary = args.summary;
+    const tasks = args.tasks;
+    if (!title || title.trim().length === 0) {
+      throw new Error("Plan title cannot be empty");
     }
+    if (!tasks || tasks.length === 0) {
+      throw new Error("Plan must have at least one task");
+    }
+    const plan = {
+      title: title.trim(),
+      designSummary: designSummary?.trim() || "",
+      summary: summary?.trim() || "",
+      steps: tasks.map((task, taskIndex) => ({
+        id: `task_${taskIndex + 1}`,
+        description: task.description.trim(),
+        subtasks: (task.subtasks || []).map((subtask, subtaskIndex) => ({
+          id: `${taskIndex + 1}.${subtaskIndex + 1}`,
+          description: subtask.description.trim(),
+          status: "pending",
+          requirements: subtask.requirements?.trim()
+        })),
+        status: "pending",
+        estimatedComplexity: task.complexity,
+        requirements: task.requirements?.trim()
+      })),
+      createdAt: /* @__PURE__ */ new Date(),
+      approved: false,
+      isActive: false,
+      currentTaskIndex: 0,
+      currentSubtaskIndex: -1
+    };
+    currentPlan = plan;
+    return `PLAN_CREATED:${JSON.stringify(plan)}`;
+  }
 };
-/**
- * Mark Task Complete Tool
- * AI uses this to mark individual tasks or subtasks as completed during execution
- */
-export const markTaskCompleteTool = {
-    schema: {
-        name: 'mark_task_complete',
-        description: `Use this tool to mark a task or subtask as completed in the current plan.
-Call this after successfully completing each task/subtask in the plan.
-
-This will:
-1. Update the task/subtask status to 'completed'
-2. Show a completion message in the UI
-3. Automatically advance to the next task/subtask
-
-You can mark:
-- A main task: task_number=2
-- A subtask: task_number="2.1" (marks subtask 1 of task 2)
-
-IMPORTANT: 
-- Must have an active approved plan
-- Mark subtasks complete as you finish them
+const markTaskCompleteTool = {
+  schema: {
+    name: "mark_task_complete",
+    description: `Use this tool to mark a task or subtask as completed in the current plan.
+Call this after successfully completing each task/subtask in the plan.
+
+This will:
+1. Update the task/subtask status to 'completed'
+2. Show a completion message in the UI
+3. Automatically advance to the next task/subtask
+
+You can mark:
+- A main task: task_number=2
+- A subtask: task_number="2.1" (marks subtask 1 of task 2)
+
+IMPORTANT: 
+- Must have an active approved plan
+- Mark subtasks complete as you finish them
 - After marking the LAST task/subtask complete, output your summary then call task_complete to end the session`,
-        parameters: {
-            type: 'object',
-            properties: {
-                task_number: {
-                    type: 'string',
-                    description: 'The task number to mark complete. Use integer for main task (e.g., "2") or dot notation for subtask (e.g., "2.1")'
-                },
-                completion_note: {
-                    type: 'string',
-                    description: 'Optional note about what was accomplished'
-                }
-            },
-            required: ['task_number']
-        }
-    },
-    async execute(args, context) {
-        if (!currentPlan) {
-            throw new Error('No active plan. Create a plan first using create_plan.');
+    parameters: {
+      type: "object",
+      properties: {
+        task_number: {
+          type: "string",
+          description: 'The task number to mark complete. Use integer for main task (e.g., "2") or dot notation for subtask (e.g., "2.1")'
+        },
+        completion_note: {
+          type: "string",
+          description: "Optional note about what was accomplished"
         }
-        if (!currentPlan.approved || !currentPlan.isActive) {
-            throw new Error('Plan must be approved and active before marking tasks complete.');
-        }
-        const taskNumberStr = String(args.task_number);
-        const completionNote = args.completion_note;
-        // Parse task number - can be "2" or "2.1"
-        const parts = taskNumberStr.split('.');
-        const mainTaskNum = parseInt(parts[0], 10);
-        const subtaskNum = parts.length > 1 ? parseInt(parts[1], 10) : null;
-        if (isNaN(mainTaskNum) || mainTaskNum < 1 || mainTaskNum > currentPlan.steps.length) {
-            throw new Error(`Invalid task number. Must be between 1 and ${currentPlan.steps.length}.`);
-        }
-        const taskIndex = mainTaskNum - 1;
-        const task = currentPlan.steps[taskIndex];
-        // Handle subtask completion
-        if (subtaskNum !== null) {
-            if (!task.subtasks || subtaskNum < 1 || subtaskNum > task.subtasks.length) {
-                throw new Error(`Invalid subtask number. Task ${mainTaskNum} has ${task.subtasks?.length || 0} subtasks.`);
-            }
-            const subtaskIndex = subtaskNum - 1;
-            const subtask = task.subtasks[subtaskIndex];
-            if (subtask.status === 'completed') {
-                return `Subtask ${taskNumberStr} is already marked as completed.`;
-            }
-            // Mark subtask complete
-            subtask.status = 'completed';
-            subtask.completedAt = new Date();
-            // Check if all subtasks are complete, then mark main task as complete
-            const allSubtasksComplete = task.subtasks.every(st => st.status === 'completed' || st.status === 'skipped');
-            if (allSubtasksComplete) {
-                task.status = 'completed';
-                task.completedAt = new Date();
-            }
-            else {
-                task.status = 'in_progress';
-            }
-            // Update current subtask index
-            const nextPendingSubtaskIndex = task.subtasks.findIndex((st, idx) => idx > subtaskIndex && st.status === 'pending');
-            currentPlan.currentSubtaskIndex = nextPendingSubtaskIndex;
-            // Calculate progress
-            const { completedCount, totalCount, allComplete } = calculateProgress();
-            const result = {
-                type: 'subtask',
-                taskNumber: taskNumberStr,
-                taskDescription: subtask.description,
-                completionNote: completionNote || null,
-                completedCount,
-                totalCount,
-                allComplete,
-                nextSubtask: nextPendingSubtaskIndex !== -1 ? task.subtasks[nextPendingSubtaskIndex].description : null,
-                mainTaskComplete: allSubtasksComplete
-            };
-            return `TASK_COMPLETED:${JSON.stringify(result)}`;
-        }
-        // Handle main task completion (mark all subtasks as complete too)
-        if (task.status === 'completed') {
-            return `Task ${mainTaskNum} is already marked as completed.`;
-        }
-        // Mark the main task and all its subtasks as complete
-        task.status = 'completed';
-        task.completedAt = new Date();
-        task.subtasks.forEach(st => {
-            if (st.status !== 'completed' && st.status !== 'skipped') {
-                st.status = 'completed';
-                st.completedAt = new Date();
-            }
-        });
-        // Update current task index to next pending task
-        const nextPendingIndex = currentPlan.steps.findIndex((step, idx) => idx > taskIndex && step.status === 'pending');
-        if (nextPendingIndex !== -1) {
-            currentPlan.currentTaskIndex = nextPendingIndex;
-            currentPlan.currentSubtaskIndex = -1;
-        }
-        // Calculate progress
-        const { completedCount, totalCount, allComplete } = calculateProgress();
-        const result = {
-            type: 'task',
-            taskNumber: mainTaskNum,
-            taskDescription: task.description,
-            completionNote: completionNote || null,
-            completedCount,
-            totalCount,
-            allComplete,
-            nextTask: allComplete ? null : currentPlan.steps[currentPlan.currentTaskIndex]?.description
-        };
-        return `TASK_COMPLETED:${JSON.stringify(result)}`;
+      },
+      required: ["task_number"]
     }
-};
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-/**
- * Calculate overall progress including subtasks
- */
-function calculateProgress() {
+  },
+  async execute(args, context) {
     if (!currentPlan) {
-        return { completedCount: 0, totalCount: 0, allComplete: false };
+      throw new Error("No active plan. Create a plan first using create_plan.");
     }
-    let completedCount = 0;
-    let totalCount = 0;
-    currentPlan.steps.forEach(step => {
-        if (step.subtasks.length > 0) {
-            // Count subtasks
-            totalCount += step.subtasks.length;
-            completedCount += step.subtasks.filter(st => st.status === 'completed').length;
-        }
-        else {
-            // Count the main task if no subtasks
-            totalCount += 1;
-            if (step.status === 'completed')
-                completedCount += 1;
-        }
+    if (!currentPlan.approved || !currentPlan.isActive) {
+      throw new Error("Plan must be approved and active before marking tasks complete.");
+    }
+    const taskNumberStr = String(args.task_number);
+    const completionNote = args.completion_note;
+    const parts = taskNumberStr.split(".");
+    const mainTaskNum = parseInt(parts[0], 10);
+    const subtaskNum = parts.length > 1 ? parseInt(parts[1], 10) : null;
+    if (isNaN(mainTaskNum) || mainTaskNum < 1 || mainTaskNum > currentPlan.steps.length) {
+      throw new Error(`Invalid task number. Must be between 1 and ${currentPlan.steps.length}.`);
+    }
+    const taskIndex = mainTaskNum - 1;
+    const task = currentPlan.steps[taskIndex];
+    if (subtaskNum !== null) {
+      if (!task.subtasks || subtaskNum < 1 || subtaskNum > task.subtasks.length) {
+        throw new Error(`Invalid subtask number. Task ${mainTaskNum} has ${task.subtasks?.length || 0} subtasks.`);
+      }
+      const subtaskIndex = subtaskNum - 1;
+      const subtask = task.subtasks[subtaskIndex];
+      if (subtask.status === "completed") {
+        return `Subtask ${taskNumberStr} is already marked as completed.`;
+      }
+      subtask.status = "completed";
+      subtask.completedAt = /* @__PURE__ */ new Date();
+      const allSubtasksComplete = task.subtasks.every((st) => st.status === "completed" || st.status === "skipped");
+      if (allSubtasksComplete) {
+        task.status = "completed";
+        task.completedAt = /* @__PURE__ */ new Date();
+      } else {
+        task.status = "in_progress";
+      }
+      const nextPendingSubtaskIndex = task.subtasks.findIndex(
+        (st, idx) => idx > subtaskIndex && st.status === "pending"
+      );
+      currentPlan.currentSubtaskIndex = nextPendingSubtaskIndex;
+      const { completedCount: completedCount2, totalCount: totalCount2, allComplete: allComplete2 } = calculateProgress();
+      const result2 = {
+        type: "subtask",
+        taskNumber: taskNumberStr,
+        taskDescription: subtask.description,
+        completionNote: completionNote || null,
+        completedCount: completedCount2,
+        totalCount: totalCount2,
+        allComplete: allComplete2,
+        nextSubtask: nextPendingSubtaskIndex !== -1 ? task.subtasks[nextPendingSubtaskIndex].description : null,
+        mainTaskComplete: allSubtasksComplete
+      };
+      return `TASK_COMPLETED:${JSON.stringify(result2)}`;
+    }
+    if (task.status === "completed") {
+      return `Task ${mainTaskNum} is already marked as completed.`;
+    }
+    task.status = "completed";
+    task.completedAt = /* @__PURE__ */ new Date();
+    task.subtasks.forEach((st) => {
+      if (st.status !== "completed" && st.status !== "skipped") {
+        st.status = "completed";
+        st.completedAt = /* @__PURE__ */ new Date();
+      }
     });
-    return {
-        completedCount,
-        totalCount,
-        allComplete: completedCount === totalCount && totalCount > 0
+    const nextPendingIndex = currentPlan.steps.findIndex(
+      (step, idx) => idx > taskIndex && step.status === "pending"
+    );
+    if (nextPendingIndex !== -1) {
+      currentPlan.currentTaskIndex = nextPendingIndex;
+      currentPlan.currentSubtaskIndex = -1;
+    }
+    const { completedCount, totalCount, allComplete } = calculateProgress();
+    const result = {
+      type: "task",
+      taskNumber: mainTaskNum,
+      taskDescription: task.description,
+      completionNote: completionNote || null,
+      completedCount,
+      totalCount,
+      allComplete,
+      nextTask: allComplete ? null : currentPlan.steps[currentPlan.currentTaskIndex]?.description
     };
+    return `TASK_COMPLETED:${JSON.stringify(result)}`;
+  }
+};
+function calculateProgress() {
+  if (!currentPlan) {
+    return { completedCount: 0, totalCount: 0, allComplete: false };
+  }
+  let completedCount = 0;
+  let totalCount = 0;
+  currentPlan.steps.forEach((step) => {
+    if (step.subtasks.length > 0) {
+      totalCount += step.subtasks.length;
+      completedCount += step.subtasks.filter((st) => st.status === "completed").length;
+    } else {
+      totalCount += 1;
+      if (step.status === "completed") completedCount += 1;
+    }
+  });
+  return {
+    completedCount,
+    totalCount,
+    allComplete: completedCount === totalCount && totalCount > 0
+  };
 }
-/**
- * Set the current plan (used by CLI adapter)
- */
-export function setPlan(plan) {
-    currentPlan = plan;
+function setPlan(plan) {
+  currentPlan = plan;
 }
-/**
- * Get the current plan
- */
-export function getCurrentPlan() {
-    return currentPlan;
+function getCurrentPlan() {
+  return currentPlan;
 }
-/**
- * Clear the current plan
- */
-export function clearPlan() {
-    currentPlan = null;
+function clearPlan() {
+  currentPlan = null;
 }
-/**
- * Approve the current plan and make it active
- */
-export function approvePlan() {
-    if (currentPlan) {
-        currentPlan.approved = true;
-        currentPlan.isActive = true;
-        currentPlan.currentTaskIndex = 0;
-        currentPlan.currentSubtaskIndex = currentPlan.steps[0]?.subtasks?.length > 0 ? 0 : -1;
-    }
-    return currentPlan;
+function approvePlan() {
+  if (currentPlan) {
+    currentPlan.approved = true;
+    currentPlan.isActive = true;
+    currentPlan.currentTaskIndex = 0;
+    currentPlan.currentSubtaskIndex = currentPlan.steps[0]?.subtasks?.length > 0 ? 0 : -1;
+  }
+  return currentPlan;
 }
-/**
- * Mark a task as complete by task number (for compatibility)
- */
-export function markTaskComplete(taskNumber) {
-    if (!currentPlan || taskNumber < 1 || taskNumber > currentPlan.steps.length) {
-        return null;
-    }
-    const task = currentPlan.steps[taskNumber - 1];
-    task.status = 'completed';
-    task.completedAt = new Date();
-    // Also mark all subtasks as complete
-    task.subtasks.forEach(st => {
-        st.status = 'completed';
-        st.completedAt = new Date();
-    });
-    return task;
-}
-/**
- * Get the current phase (task) with all its subtasks
- */
-export function getCurrentPhase() {
-    if (!currentPlan || !currentPlan.isActive)
-        return null;
-    const taskIndex = currentPlan.currentTaskIndex;
-    if (taskIndex < 0 || taskIndex >= currentPlan.steps.length)
-        return null;
-    const task = currentPlan.steps[taskIndex];
-    if (task.status === 'completed') {
-        // Find next pending task
-        const nextIndex = currentPlan.steps.findIndex((step, idx) => idx > taskIndex && step.status === 'pending');
-        if (nextIndex === -1)
-            return null;
-        return { taskNumber: nextIndex + 1, task: currentPlan.steps[nextIndex] };
-    }
-    return { taskNumber: taskIndex + 1, task };
+function markTaskComplete(taskNumber) {
+  if (!currentPlan || taskNumber < 1 || taskNumber > currentPlan.steps.length) {
+    return null;
+  }
+  const task = currentPlan.steps[taskNumber - 1];
+  task.status = "completed";
+  task.completedAt = /* @__PURE__ */ new Date();
+  task.subtasks.forEach((st) => {
+    st.status = "completed";
+    st.completedAt = /* @__PURE__ */ new Date();
+  });
+  return task;
 }
-/**
- * Advance to the next phase after current task is complete
- * Returns the new phase or null if all phases are done
- */
-export function advanceToNextPhase() {
-    if (!currentPlan || !currentPlan.isActive)
-        return null;
-    const currentTask = currentPlan.steps[currentPlan.currentTaskIndex];
-    // Mark current task as complete if not already
-    if (currentTask && currentTask.status !== 'completed') {
-        currentTask.status = 'completed';
-        currentTask.completedAt = new Date();
-    }
-    // Find next pending task
-    const nextIndex = currentPlan.steps.findIndex((step, idx) => idx > currentPlan.currentTaskIndex && step.status === 'pending');
-    if (nextIndex === -1) {
-        return null; // All phases complete
-    }
-    currentPlan.currentTaskIndex = nextIndex;
-    currentPlan.currentSubtaskIndex = currentPlan.steps[nextIndex].subtasks.length > 0 ? 0 : -1;
+function getCurrentPhase() {
+  if (!currentPlan || !currentPlan.isActive) return null;
+  const taskIndex = currentPlan.currentTaskIndex;
+  if (taskIndex < 0 || taskIndex >= currentPlan.steps.length) return null;
+  const task = currentPlan.steps[taskIndex];
+  if (task.status === "completed") {
+    const nextIndex = currentPlan.steps.findIndex(
+      (step, idx) => idx > taskIndex && step.status === "pending"
+    );
+    if (nextIndex === -1) return null;
     return { taskNumber: nextIndex + 1, task: currentPlan.steps[nextIndex] };
+  }
+  return { taskNumber: taskIndex + 1, task };
 }
-/**
- * Get the next incomplete task
- */
-export function getNextIncompleteTask() {
-    if (!currentPlan)
-        return null;
-    const index = currentPlan.steps.findIndex(step => step.status === 'pending' || step.status === 'in_progress');
-    if (index === -1)
-        return null;
-    return {
-        taskNumber: index + 1,
-        task: currentPlan.steps[index]
-    };
+function advanceToNextPhase() {
+  if (!currentPlan || !currentPlan.isActive) return null;
+  const currentTask = currentPlan.steps[currentPlan.currentTaskIndex];
+  if (currentTask && currentTask.status !== "completed") {
+    currentTask.status = "completed";
+    currentTask.completedAt = /* @__PURE__ */ new Date();
+  }
+  const nextIndex = currentPlan.steps.findIndex(
+    (step, idx) => idx > currentPlan.currentTaskIndex && step.status === "pending"
+  );
+  if (nextIndex === -1) {
+    return null;
+  }
+  currentPlan.currentTaskIndex = nextIndex;
+  currentPlan.currentSubtaskIndex = currentPlan.steps[nextIndex].subtasks.length > 0 ? 0 : -1;
+  return { taskNumber: nextIndex + 1, task: currentPlan.steps[nextIndex] };
 }
-/**
- * Check if all tasks are complete
- */
-export function areAllTasksComplete() {
-    if (!currentPlan)
-        return false;
-    return currentPlan.steps.every(step => step.status === 'completed' || step.status === 'skipped');
+function getNextIncompleteTask() {
+  if (!currentPlan) return null;
+  const index = currentPlan.steps.findIndex((step) => step.status === "pending" || step.status === "in_progress");
+  if (index === -1) return null;
+  return {
+    taskNumber: index + 1,
+    task: currentPlan.steps[index]
+  };
 }
-/**
- * Get plan progress summary (including subtasks)
- */
-export function getPlanProgress() {
-    if (!currentPlan)
-        return null;
-    const { completedCount, totalCount } = calculateProgress();
-    const percentage = totalCount > 0 ? Math.round((completedCount / totalCount) * 100) : 0;
-    const completedTasks = currentPlan.steps.filter(s => s.status === 'completed').length;
-    return {
-        completed: completedCount,
-        total: totalCount,
-        percentage,
-        currentTask: currentPlan.currentTaskIndex + 1,
-        totalTasks: currentPlan.steps.length
-    };
+function areAllTasksComplete() {
+  if (!currentPlan) return false;
+  return currentPlan.steps.every((step) => step.status === "completed" || step.status === "skipped");
 }
-/**
- * Generate plan context for AI system prompt injection (shows all tasks)
- */
-export function getPlanContextForPrompt() {
-    if (!currentPlan || !currentPlan.isActive)
-        return '';
-    const progress = getPlanProgress();
-    if (!progress)
-        return '';
-    let context = `\n\n## ACTIVE PLAN: ${currentPlan.title}\n`;
-    if (currentPlan.designSummary) {
-        context += `\n### Design Summary:\n${currentPlan.designSummary}\n`;
-    }
-    context += `\nProgress: ${progress.completed}/${progress.total} items completed (${progress.percentage}%)\n`;
-    context += `Current Task: ${progress.currentTask}/${progress.totalTasks}\n\n`;
-    context += `### Tasks:\n`;
-    currentPlan.steps.forEach((step, index) => {
-        const statusIcon = step.status === 'completed' ? '✅' :
-            step.status === 'in_progress' ? '🔄' :
-                step.status === 'skipped' ? '⏭️' : '⏳';
-        const isCurrent = index === currentPlan.currentTaskIndex && step.status !== 'completed';
-        const marker = isCurrent ? ' 👈 CURRENT' : '';
-        context += `${index + 1}. ${statusIcon} ${step.description}${marker}\n`;
-        // Add subtasks
-        step.subtasks.forEach((subtask, subIndex) => {
-            const subStatusIcon = subtask.status === 'completed' ? '✅' :
-                subtask.status === 'in_progress' ? '🔄' : '⬜';
-            context += `   ${index + 1}.${subIndex + 1}. ${subStatusIcon} ${subtask.description}\n`;
-        });
+function getPlanProgress() {
+  if (!currentPlan) return null;
+  const { completedCount, totalCount } = calculateProgress();
+  const percentage = totalCount > 0 ? Math.round(completedCount / totalCount * 100) : 0;
+  const completedTasks = currentPlan.steps.filter((s) => s.status === "completed").length;
+  return {
+    completed: completedCount,
+    total: totalCount,
+    percentage,
+    currentTask: currentPlan.currentTaskIndex + 1,
+    totalTasks: currentPlan.steps.length
+  };
+}
+function getPlanContextForPrompt() {
+  if (!currentPlan || !currentPlan.isActive) return "";
+  const progress = getPlanProgress();
+  if (!progress) return "";
+  let context = `
+
+## ACTIVE PLAN: ${currentPlan.title}
+`;
+  if (currentPlan.designSummary) {
+    context += `
+### Design Summary:
+${currentPlan.designSummary}
+`;
+  }
+  context += `
+Progress: ${progress.completed}/${progress.total} items completed (${progress.percentage}%)
+`;
+  context += `Current Task: ${progress.currentTask}/${progress.totalTasks}
+
+`;
+  context += `### Tasks:
+`;
+  currentPlan.steps.forEach((step, index) => {
+    const statusIcon = step.status === "completed" ? "\u2705" : step.status === "in_progress" ? "\u{1F504}" : step.status === "skipped" ? "\u23ED\uFE0F" : "\u23F3";
+    const isCurrent = index === currentPlan.currentTaskIndex && step.status !== "completed";
+    const marker = isCurrent ? " \u{1F448} CURRENT" : "";
+    context += `${index + 1}. ${statusIcon} ${step.description}${marker}
+`;
+    step.subtasks.forEach((subtask, subIndex) => {
+      const subStatusIcon = subtask.status === "completed" ? "\u2705" : subtask.status === "in_progress" ? "\u{1F504}" : "\u2B1C";
+      context += `   ${index + 1}.${subIndex + 1}. ${subStatusIcon} ${subtask.description}
+`;
     });
-    const nextTask = getNextIncompleteTask();
-    if (nextTask) {
-        context += `\n**NEXT ACTION**: Complete task ${nextTask.taskNumber}: ${nextTask.task.description}\n`;
-        context += `After completing this task, call mark_task_complete with task_number=${nextTask.taskNumber}\n`;
-    }
-    else {
-        context += `\n**ALL TASKS COMPLETE**: Output your summary of what was accomplished, then call task_complete().\n`;
-    }
-    return context;
+  });
+  const nextTask = getNextIncompleteTask();
+  if (nextTask) {
+    context += `
+**NEXT ACTION**: Complete task ${nextTask.taskNumber}: ${nextTask.task.description}
+`;
+    context += `After completing this task, call mark_task_complete with task_number=${nextTask.taskNumber}
+`;
+  } else {
+    context += `
+**ALL TASKS COMPLETE**: Output your summary of what was accomplished, then call task_complete().
+`;
+  }
+  return context;
 }
-/**
- * Generate context for only the current phase (single task with its subtasks)
- * Used for phased execution where AI only sees one task at a time
- */
-export function getPhaseContextForPrompt() {
-    if (!currentPlan || !currentPlan.isActive)
-        return '';
-    const currentPhase = getCurrentPhase();
-    if (!currentPhase) {
-        return `\n**ALL TASKS COMPLETE**: Output your summary of what was accomplished, then call task_complete().\n`;
-    }
-    const progress = getPlanProgress();
-    const { taskNumber, task } = currentPhase;
-    let context = `\n\n## CURRENT TASK: ${currentPlan.title}\n`;
-    if (currentPlan.designSummary) {
-        context += `\n### Design Context:\n${currentPlan.designSummary}\n`;
-    }
-    context += `\n### Overall Progress: Task ${taskNumber}/${currentPlan.steps.length}\n`;
-    context += `${progress ? `(${progress.completed}/${progress.total} items completed - ${progress.percentage}%)` : ''}\n\n`;
-    context += `### YOUR CURRENT TASK:\n`;
-    context += `**Task ${taskNumber}: ${task.description}**\n\n`;
-    if (task.subtasks.length > 0) {
-        context += `Subtasks to complete:\n`;
-        task.subtasks.forEach((subtask, index) => {
-            const subStatusIcon = subtask.status === 'completed' ? '✅' :
-                subtask.status === 'in_progress' ? '🔄' : '⬜';
-            const isCurrentSubtask = index === currentPlan.currentSubtaskIndex;
-            const marker = isCurrentSubtask && subtask.status === 'pending' ? ' 👈 CURRENT' : '';
-            context += `   ${taskNumber}.${index + 1}. ${subStatusIcon} ${subtask.description}${marker}\n`;
-        });
-        context += `\n**Instructions**: Complete each subtask in order.\n`;
-        context += `After completing a subtask, call: mark_task_complete(task_number="${taskNumber}.X")\n`;
-        context += `When all subtasks are done, the main task will be automatically marked complete.\n`;
-    }
-    else {
-        context += `\n**Instructions**: Complete this task.\n`;
-        context += `When done, call: mark_task_complete(task_number="${taskNumber}")\n`;
-    }
-    return context;
+function getPhaseContextForPrompt() {
+  if (!currentPlan || !currentPlan.isActive) return "";
+  const currentPhase = getCurrentPhase();
+  if (!currentPhase) {
+    return `
+**ALL TASKS COMPLETE**: Output your summary of what was accomplished, then call task_complete().
+`;
+  }
+  const progress = getPlanProgress();
+  const { taskNumber, task } = currentPhase;
+  let context = `
+
+## CURRENT TASK: ${currentPlan.title}
+`;
+  if (currentPlan.designSummary) {
+    context += `
+### Design Context:
+${currentPlan.designSummary}
+`;
+  }
+  context += `
+### Overall Progress: Task ${taskNumber}/${currentPlan.steps.length}
+`;
+  context += `${progress ? `(${progress.completed}/${progress.total} items completed - ${progress.percentage}%)` : ""}
+
+`;
+  context += `### YOUR CURRENT TASK:
+`;
+  context += `**Task ${taskNumber}: ${task.description}**
+
+`;
+  if (task.subtasks.length > 0) {
+    context += `Subtasks to complete:
+`;
+    task.subtasks.forEach((subtask, index) => {
+      const subStatusIcon = subtask.status === "completed" ? "\u2705" : subtask.status === "in_progress" ? "\u{1F504}" : "\u2B1C";
+      const isCurrentSubtask = index === currentPlan.currentSubtaskIndex;
+      const marker = isCurrentSubtask && subtask.status === "pending" ? " \u{1F448} CURRENT" : "";
+      context += `   ${taskNumber}.${index + 1}. ${subStatusIcon} ${subtask.description}${marker}
+`;
+    });
+    context += `
+**Instructions**: Complete each subtask in order.
+`;
+    context += `After completing a subtask, call: mark_task_complete(task_number="${taskNumber}.X")
+`;
+    context += `When all subtasks are done, the main task will be automatically marked complete.
+`;
+  } else {
+    context += `
+**Instructions**: Complete this task.
+`;
+    context += `When done, call: mark_task_complete(task_number="${taskNumber}")
+`;
+  }
+  return context;
 }
-// ============================================================================
-// EXPORTS
-// ============================================================================
-export default {
-    createPlanTool,
-    markTaskCompleteTool,
-    setPlan,
-    getCurrentPlan,
-    clearPlan,
-    approvePlan,
-    markTaskComplete,
-    getCurrentPhase,
-    advanceToNextPhase,
-    getNextIncompleteTask,
-    areAllTasksComplete,
-    getPlanProgress,
-    getPlanContextForPrompt,
-    getPhaseContextForPrompt
+var plan_mode_default = {
+  createPlanTool,
+  markTaskCompleteTool,
+  setPlan,
+  getCurrentPlan,
+  clearPlan,
+  approvePlan,
+  markTaskComplete,
+  getCurrentPhase,
+  advanceToNextPhase,
+  getNextIncompleteTask,
+  areAllTasksComplete,
+  getPlanProgress,
+  getPlanContextForPrompt,
+  getPhaseContextForPrompt
+};
+export {
+  advanceToNextPhase,
+  approvePlan,
+  areAllTasksComplete,
+  clearPlan,
+  createPlanTool,
+  plan_mode_default as default,
+  getCurrentPhase,
+  getCurrentPlan,
+  getNextIncompleteTask,
+  getPhaseContextForPrompt,
+  getPlanContextForPrompt,
+  getPlanProgress,
+  markTaskComplete,
+  markTaskCompleteTool,
+  setPlan
 };
 //# sourceMappingURL=plan-mode.js.map