@codemcp/workflows-core 3.1.22 → 3.2.1

package/resources/workflows/slides.yaml

@@ -0,0 +1,256 @@
+name: slides
+description: 'A comprehensive workflow for creating presentations - tool-agnostic approach that works with Slidev, PowerPoint, Google Slides, or any presentation platform'
+initial_state: ideate
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'office'
+  complexity: 'medium'
+  bestFor:
+    - 'Presentation creation'
+    - 'Slide deck development'
+    - 'Conference talks'
+    - 'Training materials'
+  useCases:
+    - 'Creating a technical presentation'
+    - 'Building training slides'
+    - 'Preparing a conference talk'
+  examples:
+    - 'Create a product demo presentation'
+    - 'Build onboarding slides'
+    - 'Develop a technical workshop'
+
+states:
+  ideate:
+    description: 'Brainstorm presentation concept and define strategic foundation'
+    default_instructions: |
+      You are in the ideation phase for presentation development. This is where you define the foundation of your presentation.
+
+      Focus on understanding the core purpose and audience:
+      - Brainstorm presentation topic and key messages
+      - Define target audience and their knowledge level
+      - Set presentation goals and success criteria
+      - Research topic and gather reference materials
+      - Define scope, time constraints, and context
+
+      Work with the user to clarify these fundamental aspects before moving to structure.
+      Update the plan file with ideation progress and key decisions.
+
+    transitions:
+      - trigger: ideation_complete
+        to: structure
+        additional_instructions: |
+          Ideation complete! ✅ You have a clear presentation concept, defined audience, and established goals.
+
+          Update the plan file with structural planning tasks and mark completed ideation work.
+        transition_reason: 'Presentation concept and goals clearly defined, ready for content structuring'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned. Clean up any ideation work and prepare for new presentation topics.
+          The plan file will remain for future reference if needed.
+        additional_instructions: 'Presentation development abandoned. Prepare for new presentation topics.'
+        transition_reason: 'User decided to abandon current presentation development'
+
+  structure:
+    description: 'Organize content flow and logical progression'
+    default_instructions: |
+      Working on presentation structure phase. Focus on organizing your content logically and effectively.
+
+      Key activities for this phase:
+      - Create detailed presentation outline with main sections
+      - Define slide sequence and narrative flow
+      - Plan smooth transitions between topics
+      - Identify key examples, case studies, or demonstrations needed
+      - Estimate timing for each section and overall presentation
+      - Consider audience engagement points and interaction opportunities
+
+      Work with the user to create a solid structural foundation before moving to content drafting.
+      Update the plan file with structural decisions and progress.
+
+    transitions:
+      - trigger: structure_complete
+        to: draft
+        additional_instructions: |
+          Structure complete! ✅ You have a well-organized outline and clear content flow.
+
+          Update the plan file with drafting tasks and mark completed structural work.
+        transition_reason: 'Content structure and flow established, ready for content creation'
+
+      - trigger: need_more_ideation
+        to: ideate
+        additional_instructions: 'Structural work revealed gaps in the initial concept or goals. Focus on clarifying these fundamental aspects.'
+        transition_reason: 'Structure work revealed need for more ideation or concept refinement'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned during structuring. Clean up structural work and return to ideation.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Presentation abandoned during structure phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon presentation during structure phase'
+
+  draft:
+    description: 'Create content, speaker notes, and visual planning'
+    default_instructions: |
+      Working on content drafting phase. This is where you create the actual presentation content and materials.
+
+      Key activities for this phase:
+      - Write clear, engaging content for each slide/section
+      - Create comprehensive speaker notes as a main deliverable
+      - Make strategic decisions about visual vs. spoken content split
+      - Identify concepts that can be effectively visualized
+      - Define what each visualization should communicate
+      - Create placeholders and specifications for visual content
+      - Ensure content aligns with timing and audience needs
+
+      Focus on creating high-quality content that serves both the slides and the speaker.
+      Update the plan file with drafting progress and content decisions.
+
+    transitions:
+      - trigger: draft_complete
+        to: style
+        additional_instructions: |
+          Draft complete! ✅ You have solid content, speaker notes, and visual planning.
+
+          Update the plan file with styling tasks and mark completed drafting work.
+        transition_reason: 'Content and speaker notes complete, ready for visual design and styling'
+
+      - trigger: need_more_structure
+        to: structure
+        additional_instructions: 'Drafting revealed issues with content organization or flow. Focus on refining the structural foundation.'
+        transition_reason: 'Content creation revealed need for better structure or organization'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned during drafting. Clean up content work and return to ideation.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Presentation abandoned during draft phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon presentation during draft phase'
+
+  style:
+    description: 'Apply design, create visuals, and enhance presentation aesthetics'
+    default_instructions: |
+      Working on styling and visual design phase. This is where you bring visual appeal and consistency to your presentation.
+
+      Key activities for this phase:
+      - Evaluate presentation requirements and choose appropriate tool/platform
+      - Select themes, templates, and establish visual design approach
+      - Source existing visuals, images, and graphic elements
+      - Create detailed AI image generation prompts for missing visuals
+      - Generate or create required visual content using AI tools or other methods
+      - Apply consistent visual design, colors, and branding
+      - Ensure visual elements effectively support and enhance the content
+      - Test visual consistency across all slides/sections
+
+      Focus on creating a visually appealing and professional presentation.
+      Update the plan file with styling progress and design decisions.
+
+    transitions:
+      - trigger: style_complete
+        to: review
+        additional_instructions: |
+          Styling complete! ✅ You have a visually appealing presentation with consistent design.
+
+          Update the plan file with review tasks and mark completed styling work.
+        transition_reason: 'Visual design and styling complete, ready for content and delivery review'
+
+      - trigger: need_more_content
+        to: draft
+        additional_instructions: 'Styling work revealed gaps in content or speaker notes. Focus on completing the content foundation.'
+        transition_reason: 'Visual design revealed need for additional content or speaker note refinement'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned during styling. Clean up design work and return to ideation.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Presentation abandoned during style phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon presentation during style phase'
+
+  review:
+    description: 'Validate content quality and presentation effectiveness'
+    default_instructions: |
+      Working on review and validation phase. This is where you ensure your presentation is ready for delivery.
+
+      Key activities for this phase:
+      - Review content flow, narrative coherence, and logical progression
+      - Test presentation timing and pacing for your allocated time
+      - Verify visual quality, consistency, and professional appearance
+      - Practice delivery to identify potential issues or improvements
+      - Gather feedback from test audience, colleagues, or stakeholders
+      - Check technical setup, compatibility, and backup plans
+      - Ensure all interactive elements and visuals work correctly
+      - Refine speaker notes and delivery preparation
+
+      Focus on validating that your presentation achieves its goals effectively.
+      Update the plan file with review progress and any refinements made.
+
+    transitions:
+      - trigger: review_complete
+        to: deliver
+        additional_instructions: |
+          Review complete! ✅ Your presentation has been validated and refined for delivery.
+
+          Update the plan file with delivery preparation tasks and mark completed review work.
+        transition_reason: 'Presentation reviewed and validated, ready for final delivery preparation'
+
+      - trigger: need_style_changes
+        to: style
+        additional_instructions: 'Review revealed visual or design issues that need attention. Focus on addressing these styling concerns.'
+        transition_reason: 'Review process identified visual or design issues requiring style phase work'
+
+      - trigger: need_content_changes
+        to: draft
+        additional_instructions: 'Review revealed content gaps or issues that need addressing. Focus on refining the content and speaker notes.'
+        transition_reason: 'Review process identified content issues requiring draft phase work'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned during review. Clean up review work and return to ideation.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Presentation abandoned during review phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon presentation during review phase'
+
+  deliver:
+    description: 'Prepare final presentation for delivery'
+    default_instructions: |
+      Working on delivery preparation phase. This is the final phase to ensure your presentation is ready for successful delivery.
+
+      Key activities for this phase:
+      - Export presentation to all required formats (native, PDF, backup formats)
+      - Finalize speaker setup, notes, and delivery materials
+      - Configure and test presentation environment and technical setup
+      - Create comprehensive contingency plans for potential technical issues
+      - Conduct final rehearsal in actual delivery environment if possible
+      - Prepare handouts, follow-up materials, or additional resources
+      - Ensure all backup plans and alternatives are ready
+      - Final check of timing, flow, and delivery readiness
+
+      Focus on ensuring flawless delivery execution and professional presentation.
+      Update the plan file with delivery preparation progress.
+
+    transitions:
+      - trigger: delivery_complete
+        to: ideate
+        additional_instructions: |
+          Presentation delivery complete! ✅ Your presentation has been successfully delivered.
+
+          Mark all delivery tasks as complete in the plan file and prepare for new work.
+        transition_reason: 'Presentation delivery completed successfully, ready for new projects'
+
+      - trigger: need_final_review
+        to: review
+        additional_instructions: 'Final preparation revealed issues requiring additional review. Focus on addressing these concerns before delivery.'
+        transition_reason: 'Delivery preparation identified issues requiring additional review'
+
+      - trigger: abandon_presentation
+        to: ideate
+        instructions: |
+          Presentation development abandoned before delivery. Clean up delivery preparation and return to ideation.
+          The plan file and completed work will remain for future reference.
+        additional_instructions: 'Presentation abandoned before delivery. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon presentation before delivery'

package/resources/workflows/tdd.yaml

@@ -0,0 +1,157 @@
+# yaml-language-server: $schema=../state-machine-schema.json
+---
+name: 'tdd'
+description: 'Test-Driven Development workflow: Explore → Red → Green → Refactor cycle for quality-focused development'
+initial_state: 'explore'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'code'
+  complexity: 'medium'
+  bestFor:
+    - 'TDD development'
+    - 'Test-first coding'
+    - 'Quality-focused development'
+    - 'Refactoring existing code'
+  useCases:
+    - 'Adding new features with comprehensive tests'
+    - 'Refactoring legacy code safely'
+    - 'Building robust, well-tested components'
+  examples:
+    - 'Add new API endpoint with full test coverage'
+    - 'Refactor existing function with safety net of tests'
+    - 'Build new feature following TDD principles'
+
+# States with default instructions and transitions
+states:
+  explore:
+    description: 'Research and exploration phase - understanding the problem space and codebase'
+    default_instructions: |
+      You are in the TDD exploration phase.
+      Your main objective now is to gather context about what needs to be developed. Focus on the WHY and WHAT, not the HOW.
+      Research the codebase, understand existing patterns,
+      If you are not certain about conventions or rules, ask the user about them.
+      Read relevant files and documentation. If $REQUIREMENTS_DOC exists, understand and document requirements there, otherwise document them in the plan file.
+      Don't write code or tests yet - focus on understanding. Document your findings in the plan file.
+    transitions:
+      - trigger: 'exploration_complete'
+        to: 'red'
+        additional_instructions: 'Mark completed exploration tasks.'
+        transition_reason: 'Sufficient understanding gained, ready to start TDD cycle with failing test'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Feature development abandoned. Return to exploration state for new tasks.
+          The plan file will remain for future reference if needed.
+        additional_instructions: 'Clean up any work in progress and prepare for new tasks.'
+        transition_reason: 'User decided to abandon current feature development'
+
+  red:
+    description: 'RED phase - Write a failing test that defines the expected behavior'
+    default_instructions: |
+      You are in the RED phase of TDD. Write a failing test that defines the expected behavior.
+
+      **CRITICAL QUALITY GATE**: Before writing the test, ask the user about:
+      1. What type of test is appropriate (unit, integration, acceptance, etc.)
+      2. Validate with the user that your test actually tests what needs to be developed
+
+      Write a test that:
+      - Clearly defines the expected behavior
+      - Will fail initially (since the functionality doesn't exist yet)
+      - Is specific and focused on one aspect of the functionality
+      - Uses appropriate assertions (not assert(true) or similar meaningless checks)
+
+      Run the test to confirm it fails for the right reason. Document the test in the plan file.
+    transitions:
+      - trigger: 'test_written_and_failing'
+        to: 'green'
+        additional_instructions: 'Mark completed test tasks.'
+        transition_reason: 'Failing test successfully written and validated, ready to implement'
+
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        transition_reason: 'Test writing revealed need for more exploration'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Clean up any test artifacts and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during test phase'
+
+  green:
+    description: 'GREEN phase - Write only the necessary code to make the test pass'
+    default_instructions: |
+      You are in the GREEN phase of TDD. Write only the necessary code to make the failing test pass with a proper implementation.
+
+      **CRITICAL QUALITY GATE**: Verify your implementation has NO dirty hacks such as:
+      - assert(true) or similar meaningless assertions
+      - Hardcoded return values that don't represent real logic
+      - Shortcuts that bypass the actual functionality
+      - Copy-paste code without understanding
+
+      Focus on:
+      - Making the test pass with real, working code
+      - Writing only what's necessary (no over-engineering)
+      - Ensuring the solution actually solves the problem
+      - Implementing proper logic, not shortcuts
+      - Running the test to confirm it passes
+
+      Document your implementation approach in the plan file.
+    transitions:
+      - trigger: 'test_passing'
+        to: 'refactor'
+        additional_instructions: 'Mark completed implementation tasks.'
+        transition_reason: 'Test passes with proper implementation, ready for refactoring'
+
+      - trigger: 'need_different_test'
+        to: 'red'
+        transition_reason: 'Implementation work revealed need to revise the test'
+
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        transition_reason: 'Implementation work revealed need for more exploration'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Clean up any incomplete code and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during implementation'
+
+  refactor:
+    description: 'REFACTOR phase - Improve code quality while keeping tests green (cleanup phase)'
+    default_instructions: |
+      You are in the REFACTOR phase of TDD. This is the cleanup phase - improve code quality while keeping all tests green.
+
+      Focus on:
+      - Removing code duplication
+      - Improving variable and function names
+      - Extracting methods for better organization
+      - Simplifying complex logic
+      - Enhancing readability and maintainability
+      - Applying appropriate design patterns
+
+      **Safety Rules**:
+      - Run tests after each refactoring change
+      - If any test breaks, immediately revert the change
+      - Make small, incremental improvements
+      - Stop when code is clean and no obvious improvements remain
+
+      Document significant refactoring decisions in the plan file.
+    transitions:
+      - trigger: 'refactoring_complete'
+        to: 'red'
+        additional_instructions: 'Mark completed refactoring tasks.'
+        transition_reason: 'Code cleanup complete, ready for next TDD cycle'
+
+      - trigger: 'need_different_approach'
+        to: 'green'
+        transition_reason: 'Refactoring revealed need to revise implementation'
+
+      - trigger: 'feature_complete'
+        to: 'explore'
+        additional_instructions: 'Mark feature as complete in plan file.'
+        transition_reason: 'Feature fully implemented and cleaned up, ready for new tasks'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Clean up any refactoring work and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during refactoring'

package/resources/workflows/waterfall.yaml

@@ -0,0 +1,195 @@
+# yaml-language-server: $schema=../state-machine-schema.json
+---
+name: 'waterfall'
+description: 'V-Model: Specification down to test – the historical way. Ideal for larger, design-heavy tasks with well-defined requirements'
+initial_state: 'requirements'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'code'
+  complexity: 'high'
+  bestFor:
+    - 'Large feature development'
+    - 'Complex system changes'
+    - 'Well-defined requirements'
+    - 'Design-heavy projects'
+  useCases:
+    - 'Building a new module from scratch'
+    - 'Implementing complex business logic'
+    - 'Major architectural changes'
+  examples:
+    - 'Create a new authentication system'
+    - 'Build a reporting dashboard'
+    - 'Implement a payment processing workflow'
+  requiresDocumentation: true
+
+# States with default instructions and transitions
+states:
+  requirements:
+    description: 'Gathering and analyzing requirements'
+    default_instructions: |
+      Make yourself familiar with the code base.
+      Focus on understanding their goals, scope, constraints, and success criteria, e. g.
+      • Who are the key stakeholders? (end users, business owners, technical teams)
+      • Which requirements are must-have vs nice-to-have?
+      • How will you measure success? What are the acceptance criteria?
+      • What are your time, budget, technical, or regulatory constraints?
+      • What existing systems must this integrate with?
+      Break down their needs into specific requirements in $REQUIREMENTS_DOC. Plan actionable tasks referencing those requirements in the plan file.
+    transitions:
+      - trigger: 'requirements_complete'
+        to: 'design'
+        additional_instructions: 'Requirements are complete! ✅ Now transition to design phase. Mark completed requirements tasks.'
+        transition_reason: 'All requirements tasks completed, moving to technical design'
+        review_perspectives:
+          - perspective: 'business_analyst'
+            prompt: 'Review requirements completeness, clarity, and business value. Ensure all stakeholder needs are captured and requirements are testable. Check for missing edge cases or unclear acceptance criteria.'
+          - perspective: 'ux_expert'
+            prompt: 'Evaluate user experience implications and usability requirements. Ensure user needs and workflows are properly defined. Identify potential UX challenges or accessibility concerns.'
+
+  design:
+    description: 'Technical design and architecture planning'
+    default_instructions: |
+      You are in the design phase. Re-analyze important interfaces of the application.
+      Review requirements from $REQUIREMENTS_DOC and design the technical solution
+      Focus on HOW to implement what's needed including architecture, technologies, data models, API design, and quality goals.
+      Clarify performance expectations and technology preferences if not already obvious from the current analysis.
+      Document architectural decisions in $ARCHITECTURE_DOC and detailed design in $DESIGN_DOC. Update the plan file and ensure the approach is solid before implementation."
+    transitions:
+      - trigger: 'need_more_requirements'
+        to: 'requirements'
+        additional_instructions: 'Design work revealed gaps in requirements understanding. Focus on clarifying the specific requirements that are blocking design decisions.'
+        transition_reason: 'Design work revealed need for additional requirements clarification'
+
+      - trigger: 'design_complete'
+        to: 'implementation'
+        additional_instructions: 'Design is complete! ✅ Now transition to implementation phase. Mark completed design tasks.'
+        transition_reason: 'Technical design is complete, ready for implementation'
+        review_perspectives:
+          - perspective: 'architect'
+            prompt: 'Review technical architecture, design patterns, and system integration. Ensure scalability, maintainability, and alignment with existing systems. Evaluate technology choices and architectural decisions.'
+          - perspective: 'security_expert'
+            prompt: 'Evaluate security considerations, data protection, and potential vulnerabilities in the proposed design. Review authentication, authorization, data handling, and potential attack vectors.'
+
+  implementation:
+    description: 'Building the solution according to design'
+    default_instructions: |
+      You are in the implementation phase. Follow the architecture from $ARCHITECTURE_DOC and detailed design from $DESIGN_DOC to build the solution. Before starting, clarify the approach:
+      • Should this be implemented incrementally or all at once? Any specific order of implementation?
+      • Are there high-risk parts that need extra validation or careful implementation?
+      Ensure requirements from $REQUIREMENTS_DOC are met. Focus on code structure, error handling, security, and maintainability. Write clean, well-documented code and include basic testing. Update the plan file with implementation progress.
+    transitions:
+      - trigger: 'need_design_changes'
+        to: 'design'
+        additional_instructions: "Implementation revealed issues with the current design. Consider what you've learned during coding and adjust the design accordingly. Document the changes and reasons."
+        transition_reason: 'Implementation work revealed need to revise the design'
+
+      - trigger: 'need_more_requirements'
+        to: 'requirements'
+        additional_instructions: 'Implementation revealed gaps in requirements understanding. Focus on clarifying the specific requirements that are blocking implementation.'
+        transition_reason: 'Implementation work revealed need for additional requirements'
+
+      - trigger: 'implementation_complete'
+        to: 'qa'
+        additional_instructions: 'Implementation is complete! ✅ Now transition to quality assurance phase.'
+        transition_reason: 'Core implementation is complete, ready for quality assurance'
+        review_perspectives:
+          - perspective: 'senior_software_developer'
+            prompt: 'Review code quality, best practices, and implementation approach. Ensure clean, maintainable, and efficient code. Check for proper error handling, logging, and code organization.'
+          - perspective: 'performance_engineer'
+            prompt: 'Assess performance implications, resource usage, and potential bottlenecks in the implementation. Review algorithms, data structures, and system resource utilization.'
+
+  qa:
+    description: 'Quality assurance and code review'
+    default_instructions: 'You are in the quality assurance phase. Take the following specific actions: 1) Syntax Check: Run syntax checking tools or validate syntax manually, 2) Build Project: Build the project to verify it compiles without errors, 3) Run Linter: Execute linting tools to ensure code style consistency, 4) Execute Tests: Run existing tests to verify functionality. Then conduct a multi-perspective code review from security, performance, UX, maintainability, and requirement compliance perspectives. Verify implementation matches $DESIGN_DOC specifications and fulfills the targeted requirements from $REQUIREMENTS_DOC. Update the plan file with QA progress and mark completed tasks.'
+    transitions:
+      - trigger: 'need_implementation_fixes'
+        to: 'implementation'
+        additional_instructions: 'Quality assurance revealed issues that require code changes. Focus on the specific problems identified during QA review.'
+        transition_reason: 'QA found issues requiring implementation fixes'
+
+      - trigger: 'need_design_changes'
+        to: 'design'
+        additional_instructions: 'Quality assurance revealed fundamental design issues. Consider the QA findings and adjust the design accordingly.'
+        transition_reason: 'QA found issues requiring design changes'
+
+      - trigger: 'qa_complete'
+        to: 'testing'
+        additional_instructions: 'Quality assurance is complete! ✅ Now transition to testing phase. Mark completed QA tasks.'
+        transition_reason: 'Quality assurance is complete, ready for comprehensive testing'
+
+  testing:
+    description: 'Comprehensive testing and validation'
+    default_instructions: 'You are in the testing phase. Create comprehensive test plans, write and execute tests, validate feature completeness, and ensure everything works as expected. Focus on test coverage, edge cases, integration testing, and user acceptance validation.'
+    transitions:
+      - trigger: 'need_implementation_fixes'
+        to: 'implementation'
+        additional_instructions: 'Testing revealed bugs or issues that require code changes. Focus on the specific problems identified during testing.'
+        transition_reason: 'Testing found issues requiring implementation fixes'
+
+      - trigger: 'need_qa_review'
+        to: 'qa'
+        additional_instructions: 'Testing revealed quality issues that need additional QA review. Focus on the specific quality concerns identified.'
+        transition_reason: 'Testing found issues requiring additional QA review'
+
+      - trigger: 'testing_complete'
+        to: 'finalize'
+        additional_instructions: 'Testing is complete! ✅ All tests pass and the feature is validated. Transition to finalization phase. Mark all testing tasks as complete.'
+        transition_reason: 'All testing is complete, feature is ready for delivery'
+        review_perspectives:
+          - perspective: 'business_analyst'
+            prompt: 'Verify that all requirements have been met and business objectives are achieved. Ensure the solution delivers the expected business value and meets acceptance criteria.'
+          - perspective: 'ux_expert'
+            prompt: 'Confirm user experience goals are met and the solution is user-friendly and accessible. Validate that user workflows are intuitive and efficient.'
+
+  finalize:
+    description: 'Code cleanup and documentation finalization'
+    default_instructions: >
+      You are in the finalize phase. This phase ensures code quality and documentation accuracy through systematic cleanup and review.
+
+      **STEP 1: Code Cleanup**
+      Systematically clean up development artifacts:
+
+      1. **Remove Debug Output**: Search for and remove all temporary debug output statements used during development.
+         Look for language-specific debug output methods (console logging, print statements, debug output functions).
+         Remove any debugging statements that were added for development purposes.
+
+      2. **Review TODO/FIXME Comments**:
+         - Address each TODO/FIXME comment by either implementing the solution or documenting why it's deferred
+         - Remove completed TODOs
+         - Convert remaining TODOs to proper issue tracking if needed
+
+      3. **Remove Debugging Code Blocks**:
+         - Remove temporary debugging code, test code blocks, and commented-out code
+         - Clean up any experimental code that's no longer needed
+         - Ensure proper error handling replaces temporary debug logging
+
+      **STEP 2: Documentation Review**
+      Review and update documentation to reflect final implementation:
+
+      1. **Update Long-Term Memory Documents**: Based on what was actually implemented:
+         • Update $REQUIREMENTS_DOC if requirements changed during development
+         • Update $ARCHITECTURE_DOC if architectural decisions evolved
+         • Update $DESIGN_DOC if design details were refined or changed
+      2. **Compare Against Implementation**: Review documentation against actual implemented functionality
+      3. **Update Changed Sections**: Only modify documentation sections that have functional changes
+      4. **Remove Development Progress**: Remove references to development iterations, progress notes, and temporary decisions
+      5. **Focus on Final State**: Ensure documentation describes the final implemented state, not the development process
+      6. **Ask User to Review Document Updates**
+
+      **STEP 3: Final Validation**
+      - Run existing tests to ensure cleanup didn't break functionality
+      - Verify documentation accuracy with a final review
+      - Ensure code is ready for production/delivery
+
+      Update the plan file with finalization progress and mark completed tasks.
+    transitions:
+      - trigger: 'need_final_changes'
+        to: 'implementation'
+        additional_instructions: 'Finalization revealed issues that require code changes. Focus on the specific problems identified during final review.'
+        transition_reason: 'Final review found issues requiring implementation changes'
+
+      - trigger: 'finalization_complete'
+        to: 'requirements'
+        additional_instructions: 'Feature is complete and finalized! All work is finished and ready for delivery. Prepare to gather requirements for the next feature or iteration.'
+        transition_reason: 'Feature delivery complete, beginning new development cycle'

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @codemcp/workflows-core@3.1.22 build /home/runner/work/responsible-vibe-mcp/responsible-vibe-mcp/packages/core
-> tsc -p tsconfig.build.json
-