@krr2020/taskflow-core 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/commands/workflow/commit.js

@@ -10,6 +10,7 @@ import { BaseCommand } from "../base.js";
 export class CommitCommand extends BaseCommand {
     async execute(bulletPoints) {
         const configLoader = new ConfigLoader(this.context.projectRoot);
+        const config = configLoader.load();
         const paths = configLoader.getPaths();
         // Load tasks progress
         const tasksProgress = loadTasksProgress(paths.tasksDir);
@@ -72,6 +73,120 @@ export class CommitCommand extends BaseCommand {
         updateTaskStatus(paths.tasksDir, tasksProgress, taskId, "completed");
         // Find next available task
         const nextTask = findNextAvailableTask(tasksProgress, taskId);
+        // Check AI config for context management and auto-continue
+        const autoContinue = config.ai?.autoContinueTask ?? false;
+        const clearContext = config.ai?.clearContextOnComplete ?? true;
+        // Build context clearing instruction
+        const contextInstruction = clearContext && nextTask
+            ? [
+                "",
+                "🧹 CONTEXT MANAGEMENT:",
+                "─────────────────────────",
+                "IMPORTANT: Clear your AI model context before starting the next task.",
+                "",
+                "Why? Each SETUP state loads all reference files (RETROSPECTIVE, AI PROTOCOL,",
+                "ARCHITECTURE RULES, CODING STANDARDS, SKILLS). This context accumulates",
+                "and can reduce model performance.",
+                "",
+                "Action:",
+                "- Clear/reset your AI assistant's context window",
+                "- Start fresh with only the next task's context",
+                "",
+                "This ensures optimal performance for each task.",
+            ].join("\n")
+            : [];
+        // Build auto-continue instruction
+        const continueInstruction = autoContinue && nextTask
+            ? [
+                "",
+                "🚀 AUTO-CONTINUE ENABLED:",
+                "───────────────────────────",
+                "You are configured to automatically continue to the next task.",
+                "",
+                "IMMEDIATE ACTION:",
+                "──────────────────",
+                `Run this command NOW: taskflow start ${nextTask.task.id}`,
+                "",
+                "Do NOT wait for user confirmation.",
+                "Do NOT ask for permission.",
+                "",
+                "Proceed directly to the next task without any delay.",
+            ].join("\n")
+            : [];
+        // Build next steps based on auto-continue flag
+        const nextSteps = nextTask
+            ? autoContinue
+                ? [
+                    `🎯 AUTO-CONTINUE TO NEXT TASK:`,
+                    `Run: taskflow start ${nextTask.task.id}`,
+                    "",
+                    `Task: ${nextTask.task.title}`,
+                    `Story: ${nextTask.story.title}`,
+                    `Feature: ${nextTask.feature.title}`,
+                ].join("\n")
+                : [
+                    `1. Start the next task:`,
+                    `   taskflow start ${nextTask.task.id}`,
+                    "",
+                    `   Task: ${nextTask.task.title}`,
+                    `   Story: ${nextTask.story.title}`,
+                    `   Feature: ${nextTask.feature.title}`,
+                ].join("\n")
+            : [
+                "All tasks completed! 🎉",
+                "",
+                "Options:",
+                "1. Run 'taskflow status' to see project overview",
+                "2. Generate more tasks with 'taskflow tasks generate'",
+                "3. Create a new PRD with 'taskflow prd create'",
+            ].join("\n");
+        // Build AI guidance
+        const aiGuidance = nextTask
+            ? [
+                "Task Completed Successfully!",
+                "",
+                "WHAT JUST HAPPENED:",
+                "───────────────────",
+                "1. ✓ Changes committed with proper message format",
+                "2. ✓ Pushed to remote repository",
+                "3. ✓ Task marked as completed",
+                "4. ✓ Next task identified",
+                "",
+                "NEXT TASK:",
+                "──────────",
+                `ID: ${nextTask.task.id}`,
+                `Title: ${nextTask.task.title}`,
+                `Story: ${nextTask.story.title}`,
+                `Feature: ${nextTask.feature.title}`,
+                "",
+                ...contextInstruction,
+                ...continueInstruction,
+                "TO START NEXT TASK:",
+                "─────────────────────",
+                `Run: taskflow start ${nextTask.task.id}`,
+                "",
+                "This will:",
+                "1. Check out the correct story branch",
+                "2. Load task requirements",
+                "3. Provide all context files",
+                "4. Set status to SETUP",
+                "",
+                "Then follow the workflow again:",
+                "SETUP → PLANNING → IMPLEMENTING → VERIFYING → VALIDATING → COMMITTING → COMPLETED",
+            ].join("\n")
+            : [
+                "Task Completed Successfully!",
+                "",
+                "All Tasks Complete! 🎉",
+                "───────────────────────",
+                "You've completed all available tasks.",
+                ...contextInstruction,
+                "",
+                "What's next:",
+                "1. Review project progress: taskflow status",
+                "2. Create new tasks: taskflow tasks generate",
+                "3. Start a new feature: taskflow prd create",
+            ].join("\n");
         return this.success([
             `✓ Task ${taskId} completed!`,
             `✓ Changes committed and pushed`,
@@ -85,66 +200,8 @@ export class CommitCommand extends BaseCommand {
             nextTask
                 ? `NEXT TASK: ${nextTask.task.id} - ${nextTask.task.title}`
                 : "No more tasks available",
-        ].join("\n"), nextTask
-            ? [
-                `1. Start the next task:`,
-                `   taskflow start ${nextTask.task.id}`,
-                "",
-                `   Task: ${nextTask.task.title}`,
-                `   Story: ${nextTask.story.title}`,
-                `   Feature: ${nextTask.feature.title}`,
-            ].join("\n")
-            : [
-                "All tasks completed! 🎉",
-                "",
-                "Options:",
-                "1. Run 'taskflow status' to see project overview",
-                "2. Generate more tasks with 'taskflow tasks generate'",
-                "3. Create a new PRD with 'taskflow prd create'",
-            ].join("\n"), {
-            aiGuidance: nextTask
-                ? [
-                    "Task Completed Successfully!",
-                    "",
-                    "WHAT JUST HAPPENED:",
-                    "───────────────────",
-                    "1. ✓ Changes committed with proper message format",
-                    "2. ✓ Pushed to remote repository",
-                    "3. ✓ Task marked as completed",
-                    "4. ✓ Next task identified",
-                    "",
-                    "NEXT TASK:",
-                    "──────────",
-                    `ID: ${nextTask.task.id}`,
-                    `Title: ${nextTask.task.title}`,
-                    `Story: ${nextTask.story.title}`,
-                    `Feature: ${nextTask.feature.title}`,
-                    "",
-                    "TO START:",
-                    "──────────",
-                    `Run: taskflow start ${nextTask.task.id}`,
-                    "",
-                    "This will:",
-                    "1. Check out the correct story branch",
-                    "2. Load task requirements",
-                    "3. Provide all context files",
-                    "4. Set status to SETUP",
-                    "",
-                    "Then follow the workflow again:",
-                    "SETUP → IMPLEMENTING → VERIFYING → VALIDATING → COMMITTING → COMPLETED",
-                ].join("\n")
-                : [
-                    "Task Completed Successfully!",
-                    "",
-                    "All Tasks Complete! 🎉",
-                    "───────────────────────",
-                    "You've completed all available tasks.",
-                    "",
-                    "What's next:",
-                    "1. Review project progress: taskflow status",
-                    "2. Create new tasks: taskflow tasks generate",
-                    "3. Start a new feature: taskflow prd create",
-                ].join("\n"),
+        ].join("\n"), nextSteps, {
+            aiGuidance,
             warnings: [
                 "Task is now completed and cannot be reopened",
                 "If you need to make changes, create a new task or hotfix",

package/dist/commands/workflow/do.d.ts

@@ -8,6 +8,7 @@ export declare class DoCommand extends BaseCommand {
     private formatReference;
     private formatTaskDetails;
     private getSetupState;
+    private getPlanningState;
     private getImplementState;
     private getVerifyState;
     private getValidateState;

package/dist/commands/workflow/do.js

@@ -36,16 +36,19 @@ export class DoCommand extends BaseCommand {
         let result = {};
         switch (status) {
             case "setup":
-                result = this.getSetupState(paths.refDir, content, taskId);
+                result = await this.getSetupState(paths.refDir, content, taskId);
+                break;
+            case "planning":
+                result = await this.getPlanningState(paths.refDir, content, taskId);
                 break;
             case "implementing":
-                result = this.getImplementState(paths.refDir, content, taskId);
+                result = await this.getImplementState(paths.refDir, content, taskId);
                 break;
             case "verifying":
-                result = this.getVerifyState(paths.refDir, content, taskId);
+                result = await this.getVerifyState(paths.refDir, content, taskId);
                 break;
             case "validating":
-                result = this.getValidateState();
+                result = await this.getValidateState();
                 break;
             case "committing":
                 result = this.getCommitState(feature.id, taskId, task.title);
@@ -96,7 +99,7 @@ export class DoCommand extends BaseCommand {
         }
         return parts.join("\n");
     }
-    getSetupState(refDir, taskContent, taskId) {
+    async getSetupState(refDir, taskContent, taskId) {
         const skill = taskContent.skill || "backend";
         parseTaskId(taskId);
         const outputParts = [];
@@ -121,10 +124,28 @@ export class DoCommand extends BaseCommand {
         outputParts.push("1. Read RETROSPECTIVE to avoid known errors");
         outputParts.push("2. Read AI PROTOCOL to understand workflow rules");
         outputParts.push("3. Review TASK DETAILS and subtasks");
+        // Get LLM guidance if available
+        let llmGuidance = "Read and understand. Do not code yet.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "setup",
+                    files: taskContent.context,
+                    instructions: "Focus on understanding the task context, not on implementation. Emphasize files to read and patterns to learn.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
-            nextSteps: " When you understand the task, run 'taskflow check' to advance to IMPLEMENTING",
-            aiGuidance: "Read and understand. do not code yet.",
+            nextSteps: " When you understand the task, run 'taskflow check' to advance to PLANNING",
+            aiGuidance: llmGuidance,
             contextFiles: [
                 REF_FILES.aiProtocol,
                 REF_FILES.retrospective,
@@ -132,7 +153,128 @@ export class DoCommand extends BaseCommand {
             ],
         };
     }
-    getImplementState(refDir, taskContent, taskId) {
+    async getPlanningState(refDir, taskContent, taskId) {
+        const skill = taskContent.skill || "backend";
+        const outputParts = [];
+        outputParts.push(colors.infoBold(`${icons.brain} PLANNING STATE - CREATE EXECUTION PLAN`));
+        outputParts.push(colors.info("DO: Analyze context, create implementation plan"));
+        outputParts.push(colors.error("DO NOT: Write code yet - planning must come first"));
+        // TASK DETAILS
+        outputParts.push(this.formatTaskDetails(taskId, taskContent.title, skill, taskContent.description, taskContent.subtasks || [], taskContent.context || []));
+        // CRITICAL CONTEXT
+        outputParts.push(this.formatReference("RETROSPECTIVE - KNOWN ERRORS TO AVOID", getRefFilePath(refDir, REF_FILES.retrospective), colors.error));
+        outputParts.push(this.formatReference("AI PROTOCOL - WORKFLOW RULES", getRefFilePath(refDir, REF_FILES.aiProtocol), colors.warning));
+        // REFERENCE SECTION
+        outputParts.push("", colors.infoBold(`${icons.memo} REFERENCE (Read as Needed)`));
+        outputParts.push(colors.info("─".repeat(50)));
+        outputParts.push(this.formatReference(`SKILL: ${skill.toUpperCase()}`, getSkillFilePath(refDir, skill), colors.command));
+        outputParts.push(this.formatReference("ARCHITECTURE RULES", getRefFilePath(refDir, REF_FILES.architectureRules), colors.info));
+        outputParts.push(this.formatReference("CODING STANDARDS", getRefFilePath(refDir, REF_FILES.codingStandards), colors.info));
+        // PLANNING CHECKLIST
+        outputParts.push("", colors.warningBold(`${icons.info} PLANNING CHECKLIST`));
+        outputParts.push("□ 1. Reviewed RETROSPECTIVE - know what NOT to do");
+        outputParts.push("□ 2. Understood TASK DETAILS and requirements");
+        outputParts.push("□ 3. Identified files to modify");
+        outputParts.push("□ 4. Determined implementation approach");
+        outputParts.push("□ 5. Planned subtask execution order");
+        outputParts.push("□ 6. Considered edge cases and error handling");
+        // QUICK START
+        outputParts.push("", colors.successBold(`${icons.rocket} PLAN CREATION STEPS`));
+        outputParts.push("1. Search for similar implementations");
+        outputParts.push("2. List files to modify and patterns to follow");
+        outputParts.push("3. Define implementation approach");
+        outputParts.push("4. Order subtasks logically");
+        outputParts.push("5. Document your plan");
+        // Get LLM guidance if available
+        let llmGuidance = [
+            "Current Status: PLANNING",
+            "Your Goal: Create a clear, documented plan before coding",
+            "",
+            "PLANNING PROCESS:",
+            "────────────────",
+            "1. SEARCH FIRST:",
+            "   - Find existing implementations to match",
+            "   - Study patterns used in similar code",
+            "   - Identify relevant files and modules",
+            "",
+            "2. CONTEXT REVIEW:",
+            "   - RETROSPECTIVE: Learn what NOT to do",
+            "   - AI PROTOCOL: Understand workflow rules",
+            "   - SKILL GUIDES: Domain-specific patterns",
+            "   - ARCHITECTURE/STANDARDS: Project conventions",
+            "",
+            "3. PLAN CREATION:",
+            "   - List files to modify",
+            "   - Define implementation approach",
+            "   - Order subtasks logically",
+            "   - Note integration points",
+            "   - Plan error handling",
+            "",
+            "4. RISK CHECK:",
+            "   - Check RETROSPECTIVE for similar issues",
+            "   - Identify edge cases",
+            "   - Consider backward compatibility",
+            "",
+            "CRITICAL RULES:",
+            "───────────────",
+            "- Search BEFORE planning",
+            "- Match existing patterns, don't invent new ones",
+            "- Consider all subtasks in your plan",
+            "- Document the approach clearly",
+            "",
+            "DO NOT:",
+            "───────",
+            "- Skip planning and start coding",
+            "- Assume patterns without searching",
+            "- Ignore RETROSPECTIVE warnings",
+            "- Create vague or incomplete plans",
+            "",
+            "WHEN READY:",
+            "────────────",
+            "Run 'taskflow check' to advance to IMPLEMENTING",
+            "Be ready to execute your plan",
+        ].join("\n");
+        if (this.isLLMAvailable()) {
+            try {
+                // Read retrospective to include known error patterns in LLM guidance
+                const retrospectivePath = getRefFilePath(refDir, REF_FILES.retrospective);
+                const retrospectiveContent = loadReferenceFile(retrospectivePath);
+                // Build instructions with retrospective context
+                let instructions = "Focus on planning guidance: files to modify, patterns to follow, subtask order, potential pitfalls. Keep under 200 words.";
+                if (retrospectiveContent) {
+                    instructions += `\n\nIMPORTANT - Learn from known errors in this project:\n${retrospectiveContent}\n\nAvoid repeating these mistakes in your plan.`;
+                }
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "planning",
+                    files: taskContent.context,
+                    instructions,
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
+        return {
+            output: outputParts.join("\n"),
+            nextSteps: [
+                "1. Search codebase for similar implementations",
+                "2. Create execution plan (files, approach, order)",
+                "3. Complete all planning checklist items",
+                "4. taskflow check (When plan is ready)",
+            ].join("\n"),
+            aiGuidance: llmGuidance,
+            warnings: [
+                "Most common AI mistake: Skipping planning and writing code immediately",
+                "Always search for existing implementations first",
+                "Your plan should be specific and actionable",
+            ],
+        };
+    }
+    async getImplementState(refDir, taskContent, taskId) {
         const skill = taskContent.skill || "backend";
         const outputParts = [];
         outputParts.push(colors.successBold(`${icons.code} IMPLEMENTING STATE - WRITE CODE NOW`));
@@ -140,6 +282,24 @@ export class DoCommand extends BaseCommand {
         outputParts.push(colors.error("DO NOT: Modify .taskflow/ or tasks/ directly"));
         outputParts.push(this.formatTaskDetails(taskId, taskContent.title, skill, taskContent.description, taskContent.subtasks || [], taskContent.context || []));
         outputParts.push(this.formatReference("AVOID THESE KNOWN ERRORS", getRefFilePath(refDir, REF_FILES.retrospective), colors.error));
+        // Get LLM guidance if available
+        let llmGuidance = "Implement subtasks one by one. Check off subtasks mostly mentally or via subtask command if available.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "implementing",
+                    files: taskContent.context,
+                    instructions: "Focus on implementation guidance: files to modify, patterns to follow, subtask execution order. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: [
@@ -147,10 +307,10 @@ export class DoCommand extends BaseCommand {
                 "2. Test your changes locally",
                 "3. taskflow check  (When ALL subtasks are complete)",
             ].join("\n"),
-            aiGuidance: "Implement subtasks one by one. Check off subtasks mostly mentally or via subtask command if available.",
+            aiGuidance: llmGuidance,
         };
     }
-    getVerifyState(refDir, taskContent, _taskId) {
+    async getVerifyState(refDir, taskContent, _taskId) {
         const outputParts = [];
         outputParts.push(colors.infoBold(`${icons.search} VERIFYING STATE - SELF-REVIEW YOUR CODE`));
         outputParts.push("DO: Review ALL code changes. Verify against checklists.");
@@ -169,6 +329,23 @@ export class DoCommand extends BaseCommand {
             }
         }
         outputParts.push(this.formatReference("CHECK AGAINST RETROSPECTIVE", getRefFilePath(refDir, REF_FILES.retrospective), colors.error));
+        // Get LLM guidance if available
+        let llmGuidance = "Self-review strictly. Don't skip this step.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "verifying",
+                    instructions: "Focus on self-review guidance: common mistakes to check, patterns to verify. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: [
@@ -176,19 +353,35 @@ export class DoCommand extends BaseCommand {
                 "2. Fix any issues found",
                 "3. taskflow check (When self-review is complete)",
             ].join("\n"),
-            aiGuidance: "Self-review strictly. Don't skip this step.",
+            aiGuidance: llmGuidance,
         };
     }
-    getValidateState() {
+    async getValidateState() {
         const outputParts = [];
         outputParts.push(colors.infoBold(`${icons.test} VALIDATING STATE - AUTOMATED CHECKS`));
         outputParts.push("System will run configured checks (format, lint, test, etc.)");
         outputParts.push("", "ON SUCCESS: Advances to COMMITTING");
         outputParts.push("ON FAILURE: Stay in VALIDATING details, fix errors.");
+        // Get LLM guidance if available
+        let llmGuidance = "Run validation. If fails, fix and retry.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    status: "validating",
+                    instructions: "Focus on validation guidance: how to fix errors, error analysis approach. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: "Run 'taskflow check' to run validations",
-            aiGuidance: "Run validation. If fails, fix and retry.",
+            aiGuidance: llmGuidance,
         };
     }
     getCommitState(featureId, taskId, taskTitle) {

package/dist/commands/workflow/next.js

@@ -118,15 +118,15 @@ export class NextCommand extends BaseCommand {
                 "",
                 "This will begin the SETUP phase where you'll:",
                 "1. Read the task file with full requirements",
-                "2. Review AI-PROTOCOL.md for operating discipline",
-                "3. Check RETROSPECTIVE.md for known mistakes",
-                "4. Study CODING-STANDARDS.md and ARCHITECTURE-RULES.md",
+                "2. Review ai-protocol.md for operating discipline",
+                "3. Check retrospective.md for known mistakes",
+                "4. Study coding-standards.md and architecture-rules.md",
                 "5. Review skill-specific guidelines",
                 "6. Understand the complete task before coding",
                 "",
                 "WORKFLOW PHASES:",
                 "─────────────────",
-                "SETUP → IMPLEMENTING → VERIFYING → VALIDATING → COMMITTING → COMPLETED",
+                "SETUP → PLANNING → IMPLEMENTING → VERIFYING → VALIDATING → COMMITTING → COMPLETED",
                 "",
                 "Each phase has specific requirements and checks.",
                 "The system will guide you through each transition.",

package/dist/commands/workflow/resume.js

@@ -73,9 +73,9 @@ export class ResumeCommand extends BaseCommand {
                 next: "Read context files and understand the task",
                 actions: [
                     "1. Review the task file completely",
-                    "2. Read AI-PROTOCOL.md for operating discipline",
-                    "3. Check RETROSPECTIVE.md for known mistakes",
-                    "4. Study CODING-STANDARDS.md and ARCHITECTURE-RULES.md",
+                    "2. Read ai-protocol.md for operating discipline",
+                    "3. Check retrospective.md for known mistakes",
+                    "4. Study coding-standards.md and architecture-rules.md",
                     "5. When ready, run: taskflow check",
                 ],
             },
@@ -96,7 +96,7 @@ export class ResumeCommand extends BaseCommand {
                     "2. Look for 'any' types",
                     "3. Verify error handling",
                     "4. Ensure imports are correct",
-                    "5. Review against RETROSPECTIVE.md",
+                    "5. Review against retrospective.md",
                     "6. When self-review is complete, run: taskflow check",
                 ],
             },
@@ -115,6 +115,9 @@ export class ResumeCommand extends BaseCommand {
             },
         };
         const guidance = statusGuidance[targetStatus];
+        if (!guidance) {
+            throw new Error(`No guidance found for status: ${targetStatus}`);
+        }
         return this.success([
             `✓ Task ${taskId} resumed!`,
             `✓ Status: ${content.status} → ${targetStatus}`,
@@ -153,7 +156,7 @@ export class ResumeCommand extends BaseCommand {
                 ...guidance.actions,
                 "",
                 "Remember to:",
-                "- Review RETROSPECTIVE.md to avoid known mistakes",
+                "- Review retrospective.md to avoid known mistakes",
                 "- Follow existing code patterns",
                 "- Verify imports before using them",
                 "- Handle errors properly",
@@ -161,7 +164,7 @@ export class ResumeCommand extends BaseCommand {
             contextFiles,
             warnings: [
                 "Review previous work before making changes",
-                "Check RETROSPECTIVE.md for mistakes related to the block reason",
+                "Check retrospective.md for mistakes related to the block reason",
                 "DO NOT rush - understand why it was blocked first",
             ],
         });

package/dist/commands/workflow/start.js

@@ -81,10 +81,10 @@ export class StartCommand extends BaseCommand {
             "1. Read ALL context files listed above",
             "   CRITICAL: Read these files in order:",
             "   a) Task file - understand requirements",
-            "   b) AI-PROTOCOL.md - core discipline",
-            "   c) RETROSPECTIVE.md - avoid known mistakes",
-            "   d) CODING-STANDARDS.md - follow project standards",
-            "   e) ARCHITECTURE-RULES.md - follow project architecture",
+            "   b) ai-protocol.md - core discipline",
+            "   c) retrospective.md - avoid known mistakes",
+            "   d) coding-standards.md - follow project standards",
+            "   e) architecture-rules.md - follow project architecture",
             `   f) skills/${taskContent.skill || "backend"}.md - skill-specific guidance`,
             "",
             "2. Understand the complete task before proceeding",
@@ -95,7 +95,7 @@ export class StartCommand extends BaseCommand {
             "",
             "3. When you've read everything and understand the task, run:",
             "   taskflow check",
-            "   This will advance you to IMPLEMENTING status",
+            "   This will advance you to PLANNING status",
         ].join("\n"), {
             aiGuidance: [
                 "Current Status: SETUP",
@@ -111,9 +111,9 @@ export class StartCommand extends BaseCommand {
                 "CRITICAL - Discovery First:",
                 "────────────────────────────",
                 "1. Read the task file completely",
-                "2. Read AI-PROTOCOL.md - this is your operating manual",
-                "3. Read RETROSPECTIVE.md - these are mistakes already made",
-                "4. Read project standards (CODING-STANDARDS.md, ARCHITECTURE-RULES.md)",
+                "2. Read ai-protocol.md - this is your operating manual",
+                "3. Read retrospective.md - these are mistakes already made",
+                "4. Read project standards (coding-standards.md, architecture-rules.md)",
                 `5. Read skill file (skills/${taskContent.skill || "backend"}.md)`,
                 "6. Search for similar implementations in the codebase",
                 "7. Understand existing patterns before writing code",
@@ -127,13 +127,13 @@ export class StartCommand extends BaseCommand {
                 "",
                 "WHEN READY:",
                 "────────────",
-                "Run 'taskflow check' to advance to IMPLEMENTING status",
-                "Only then can you start writing code",
+                "Run 'taskflow check' to advance to PLANNING status",
+                "Then create your execution plan before writing code",
             ].join("\n"),
             contextFiles,
             warnings: [
                 "DO NOT write code in SETUP status - read and understand first",
-                "DO NOT skip reading RETROSPECTIVE.md - it contains critical learnings",
+                "DO NOT skip reading retrospective.md - it contains critical learnings",
                 "DO NOT edit .taskflow/ or tasks/ directories - use taskflow commands only",
                 "DO NOT proceed without reading ALL context files",
             ],

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  */
 export * from "./cli/index.js";
 export * from "./commands/base.js";
+export * from "./commands/configure.js";
 export * from "./commands/init.js";
 export * from "./commands/prd/create.js";
 export * from "./commands/prd/generate-arch.js";
@@ -23,9 +24,12 @@ export * from "./lib/config-loader.js";
 export * from "./lib/config-paths.js";
 export * from "./lib/data-access.js";
 export * from "./lib/errors.js";
+export * from "./lib/file-validator.js";
 export * from "./lib/git.js";
+export * from "./lib/log-parser.js";
 export * from "./lib/output.js";
 export * from "./lib/retrospective.js";
 export type { ActiveStatus, Criticality, ErrorCategory, Feature, RetrospectiveItem, Story, Subtask, TaskFileContent, TaskflowConfig, TaskRef, TaskStatus, TasksProgress, TimeEntry, } from "./lib/types.js";
 export { parseTaskId, STATUS_TRANSITIONS, TaskStatusSchema, } from "./lib/types.js";
 export * from "./lib/validation.js";
+export * from "./llm/index.js";