centaurus-cli 3.1.2 → 3.1.4

package/dist/tools/plan-mode.js

@@ -2,27 +2,23 @@ let currentPlan = null;
 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.
+    description: `Use this tool when in planning mode to submit your detailed implementation plan.
 
-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
+You MUST provide:
+1. A clear title for the plan
+2. A comprehensive markdown document detailing the full plan (analysis, mappings, tables, etc.)
+3. An array of implementation steps extracted from the document
 
-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
+The markdown document should be detailed and include sections like:
+- Overview/summary of what will be done
+- Analysis (current state, proposed changes, tables, mappings)
+- Implementation Steps section with numbered steps
+- Verification/testing notes
 
-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`,
+The implementation_steps array should contain one string per step, matching the numbered steps in your document.
+Each step should be a concise one-line description.
+
+IMPORTANT: Only use this tool when in planning mode.`,
     parameters: {
       type: "object",
       properties: {
@@ -30,92 +26,48 @@ Example structure:
           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: {
+        document: {
           type: "string",
-          description: "Brief 1-2 sentence summary of the overall approach"
+          description: "The full markdown plan document with detailed analysis, tables, mappings, and implementation steps"
         },
-        tasks: {
+        implementation_steps: {
           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"]
+            type: "string"
           },
-          description: "List of main tasks to execute, in order"
+          description: "Array of implementation step descriptions, one per step. These are the actionable items that will be tracked."
         }
       },
-      required: ["title", "summary", "tasks"]
+      required: ["title", "document", "implementation_steps"]
     }
   },
   async execute(args, context) {
     const title = args.title;
-    const designSummary = args.designSummary || "";
-    const summary = args.summary;
-    const tasks = args.tasks;
+    const document = args.document;
+    const implementationSteps = args.implementation_steps;
     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");
+    if (!document || document.trim().length === 0) {
+      throw new Error("Plan document cannot be empty");
+    }
+    if (!implementationSteps || implementationSteps.length === 0) {
+      throw new Error("Plan must have at least one implementation step");
     }
     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()
-      })),
+      document: document.trim(),
+      implementationSteps: implementationSteps.map((step, index) => {
+        const cleaned = step.trim().replace(/^\d+[\.\)\:\-]\s*/, "");
+        return {
+          id: index + 1,
+          description: cleaned,
+          status: "pending"
+        };
+      }),
       createdAt: /* @__PURE__ */ new Date(),
       approved: false,
-      isActive: false,
-      currentTaskIndex: 0,
-      currentSubtaskIndex: -1
+      isActive: false
     };
     currentPlan = plan;
     return `PLAN_CREATED:${JSON.stringify(plan)}`;
@@ -124,35 +76,33 @@ Example structure:
 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.
+    description: `Use this tool to mark an implementation step as completed in the current plan.
+Call this after successfully completing each step 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
+1. Update the step status to 'completed'
+2. Show a tick mark next to the step in the UI
+3. Report progress on all steps
 
-You can mark:
-- A main task: task_number=2
-- A subtask: task_number="2.1" (marks subtask 1 of task 2)
+You must provide the step number (1-indexed) matching the implementation steps list.
 
 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`,
+- Mark steps complete in order as you finish them
+- After marking the LAST step 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")'
+        step_number: {
+          type: "number",
+          description: "The step number to mark complete (1-indexed, e.g., 1, 2, 3...)"
         },
         completion_note: {
           type: "string",
           description: "Optional note about what was accomplished"
         }
       },
-      required: ["task_number"]
+      required: ["step_number"]
     }
   },
   async execute(args, context) {
@@ -160,107 +110,100 @@ IMPORTANT:
       throw new Error("No active plan. Create a plan first using create_plan.");
     }
     if (!currentPlan.approved || !currentPlan.isActive) {
-      throw new Error("Plan must be approved and active before marking tasks complete.");
+      throw new Error("Plan must be approved and active before marking steps complete.");
     }
-    const taskNumberStr = String(args.task_number);
+    const stepNumber = Number(args.step_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.`;
+    if (isNaN(stepNumber) || stepNumber < 1 || stepNumber > currentPlan.implementationSteps.length) {
+      throw new Error(`Invalid step number. Must be between 1 and ${currentPlan.implementationSteps.length}.`);
     }
-    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();
-      }
-    });
-    const nextPendingIndex = currentPlan.steps.findIndex(
-      (step, idx) => idx > taskIndex && step.status === "pending"
-    );
-    if (nextPendingIndex !== -1) {
-      currentPlan.currentTaskIndex = nextPendingIndex;
-      currentPlan.currentSubtaskIndex = -1;
+    const stepIndex = stepNumber - 1;
+    const step = currentPlan.implementationSteps[stepIndex];
+    if (step.status === "completed") {
+      return `Step ${stepNumber} is already marked as completed.`;
     }
-    const { completedCount, totalCount, allComplete } = calculateProgress();
+    step.status = "completed";
+    step.completedAt = /* @__PURE__ */ new Date();
+    const completedCount = currentPlan.implementationSteps.filter((s) => s.status === "completed").length;
+    const totalCount = currentPlan.implementationSteps.length;
+    const allComplete = completedCount === totalCount;
+    const nextStep = currentPlan.implementationSteps.find((s) => s.status === "pending");
     const result = {
-      type: "task",
-      taskNumber: mainTaskNum,
-      taskDescription: task.description,
+      stepNumber,
+      stepDescription: step.description,
       completionNote: completionNote || null,
       completedCount,
       totalCount,
       allComplete,
-      nextTask: allComplete ? null : currentPlan.steps[currentPlan.currentTaskIndex]?.description
+      nextStep: nextStep ? nextStep.description : null,
+      nextStepNumber: nextStep ? nextStep.id : null,
+      // Include all steps with their current status for UI rendering
+      allSteps: currentPlan.implementationSteps.map((s) => ({
+        id: s.id,
+        description: s.description,
+        status: s.status
+      }))
     };
     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;
+const planAskQuestionTool = {
+  schema: {
+    name: "plan_ask_question",
+    description: `Use this tool during planning mode to ask the user a clarifying question when you need more information before creating the plan.
+
+Use this when:
+- The user's request is ambiguous and could be interpreted in multiple ways
+- You need to know about specific preferences (e.g., framework, architecture style)
+- There are multiple valid approaches and you want the user to choose
+- Important details are missing from the request
+
+You provide:
+1. The question text
+2. An array of suggested answer options (2-4 options)
+
+The user can select one of your suggested options, type a custom answer, or skip the question.
+If the user skips, proceed with the most appropriate default approach.
+
+IMPORTANT: Only use this during planning mode, before calling create_plan.
+Do not ask too many questions \u2014 1-2 targeted questions maximum.`,
+    parameters: {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "The clarifying question to ask the user"
+        },
+        options: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Array of 2-4 suggested answer options for the user to choose from"
+        }
+      },
+      required: ["question", "options"]
     }
-  });
-  return {
-    completedCount,
-    totalCount,
-    allComplete: completedCount === totalCount && totalCount > 0
-  };
-}
+  },
+  async execute(args, context) {
+    const question = args.question;
+    const options = args.options;
+    if (!question || question.trim().length === 0) {
+      throw new Error("Question cannot be empty");
+    }
+    if (!options || options.length < 2) {
+      throw new Error("Must provide at least 2 answer options");
+    }
+    if (options.length > 4) {
+      throw new Error("Maximum 4 answer options allowed");
+    }
+    const result = {
+      question: question.trim(),
+      options: options.map((o) => o.trim())
+    };
+    return `ASK_QUESTION:${JSON.stringify(result)}`;
+  }
+};
 function setPlan(plan) {
   currentPlan = plan;
 }
@@ -274,80 +217,27 @@ 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 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;
-}
-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 };
-}
-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] };
-}
-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 getAllStepsStatus() {
+  if (!currentPlan) return [];
+  return currentPlan.implementationSteps.map((s) => ({ ...s }));
 }
 function areAllTasksComplete() {
   if (!currentPlan) return false;
-  return currentPlan.steps.every((step) => step.status === "completed" || step.status === "skipped");
+  return currentPlan.implementationSteps.every((step) => step.status === "completed");
 }
 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
-  };
+  const completed = currentPlan.implementationSteps.filter((s) => s.status === "completed").length;
+  const total = currentPlan.implementationSteps.length;
+  const percentage = total > 0 ? Math.round(completed / total * 100) : 0;
+  return { completed, total, percentage };
+}
+function getPlanDocument() {
+  if (!currentPlan) return null;
+  return currentPlan.document;
 }
 function getPlanContextForPrompt() {
   if (!currentPlan || !currentPlan.isActive) return "";
@@ -357,118 +247,73 @@ function getPlanContextForPrompt() {
 
 ## 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 += `Progress: ${progress.completed}/${progress.total} steps completed (${progress.percentage}%)
 
 `;
-  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}
+  context += `### Implementation Steps:
 `;
-    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}
+  currentPlan.implementationSteps.forEach((step) => {
+    const statusIcon = step.status === "completed" ? "[x]" : "[ ]";
+    const marker = step.status === "pending" && !currentPlan.implementationSteps.slice(0, step.id - 1).some((s) => s.status === "pending") ? " <-- NEXT" : "";
+    context += `${step.id}. ${statusIcon} ${step.description}${marker}
 `;
-    });
   });
-  const nextTask = getNextIncompleteTask();
-  if (nextTask) {
+  const nextStep = currentPlan.implementationSteps.find((s) => s.status === "pending");
+  if (nextStep) {
     context += `
-**NEXT ACTION**: Complete task ${nextTask.taskNumber}: ${nextTask.task.description}
+**NEXT ACTION**: Complete step ${nextStep.id}: ${nextStep.description}
 `;
-    context += `After completing this task, call mark_task_complete with task_number=${nextTask.taskNumber}
+    context += `After completing this step, call mark_task_complete with step_number=${nextStep.id}
 `;
   } else {
     context += `
-**ALL TASKS COMPLETE**: Output your summary of what was accomplished, then call task_complete().
+**ALL STEPS COMPLETE**: Output your summary of what was accomplished, then call task_complete().
 `;
   }
   return context;
 }
+function getCurrentPhase() {
+  if (!currentPlan || !currentPlan.isActive) return null;
+  const nextStep = currentPlan.implementationSteps.find((s) => s.status === "pending");
+  if (!nextStep) return null;
+  return { taskNumber: nextStep.id, task: nextStep };
+}
+function advanceToNextPhase() {
+  return getCurrentPhase();
+}
+function getNextIncompleteTask() {
+  return getCurrentPhase();
+}
 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 getPlanContextForPrompt();
+}
+function markTaskComplete(taskNumber) {
+  if (!currentPlan || taskNumber < 1 || taskNumber > currentPlan.implementationSteps.length) {
+    return null;
   }
-  return context;
+  const step = currentPlan.implementationSteps[taskNumber - 1];
+  step.status = "completed";
+  step.completedAt = /* @__PURE__ */ new Date();
+  return step;
 }
 var plan_mode_default = {
   createPlanTool,
   markTaskCompleteTool,
+  planAskQuestionTool,
   setPlan,
   getCurrentPlan,
   clearPlan,
   approvePlan,
-  markTaskComplete,
-  getCurrentPhase,
-  advanceToNextPhase,
-  getNextIncompleteTask,
+  getAllStepsStatus,
   areAllTasksComplete,
   getPlanProgress,
+  getPlanDocument,
   getPlanContextForPrompt,
-  getPhaseContextForPrompt
+  getPhaseContextForPrompt,
+  getCurrentPhase,
+  advanceToNextPhase,
+  getNextIncompleteTask,
+  markTaskComplete
 };
 export {
   advanceToNextPhase,
@@ -477,14 +322,17 @@ export {
   clearPlan,
   createPlanTool,
   plan_mode_default as default,
+  getAllStepsStatus,
   getCurrentPhase,
   getCurrentPlan,
   getNextIncompleteTask,
   getPhaseContextForPrompt,
   getPlanContextForPrompt,
+  getPlanDocument,
   getPlanProgress,
   markTaskComplete,
   markTaskCompleteTool,
+  planAskQuestionTool,
   setPlan
 };
 //# sourceMappingURL=plan-mode.js.map