@codemcp/workflows 6.4.0 → 6.5.1

package/packages/opencode-plugin/resources/workflows/skilled-epcc.yaml

@@ -0,0 +1,171 @@
+---
+name: 'skilled-epcc'
+description: "A comprehensive development workflow based on Anthropic's best practices: Explore, Plan, Code, Commit - ideal for smaller features and iterative development"
+initial_state: 'explore'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'skilled'
+  complexity: 'medium'
+  bestFor:
+    - 'Medium-sized features'
+    - 'Iterative development'
+    - 'Research-heavy tasks'
+    - 'Exploratory coding'
+  useCases:
+    - 'Adding a new API endpoint'
+    - 'Implementing a new algorithm'
+    - 'Integrating a third-party service'
+  examples:
+    - 'Add user profile management'
+    - 'Implement search functionality'
+    - 'Create data export feature'
+
+# States with default instructions and transitions
+states:
+  explore:
+    description: 'Research and exploration phase - understanding the problem space'
+    default_instructions: |
+      Research the codebase to understand existing patterns and gather context about the problem space.
+
+      - **Apply your starting-project skill.** If unavailable, ask user about project setup practices.
+      - **Apply your architecture skill.** If unavailable, ask user about architectural conventions.
+      - If uncertain about conventions or rules, ask the user about them
+      - Read relevant files and documentation
+      - Check whether there is a requirements document in the project and if so, read it carefully)
+
+      Focus on understanding without writing code yet. Document your findings and create tasks as needed.
+    transitions:
+      - trigger: 'exploration_complete'
+        to: 'plan'
+        additional_instructions: 'Present the plan to the user, describing the impact of the changes.'
+        transition_reason: 'Sufficient understanding gained, ready to create implementation plan'
+
+  plan:
+    description: 'Planning phase - creating a detailed implementation strategy'
+    default_instructions: |
+      Create a detailed implementation strategy based on your exploration:
+
+      - **Apply your architecture skill.** If unavailable, ask user about architectural conventions.
+      - **Apply your application-design skill.** If unavailable, ask user about application design practices.
+      - Check whether there is a requirements document in the project and base your strategy on it
+      - Check whether there is a design document in the project and adhere to it; if not, elaborate design options and present them to the user
+
+      Break down the work into specific, actionable tasks. Consider edge cases, dependencies, and potential challenges. Document the planning work thoroughly and create implementation tasks as part of the code phase as needed.
+    transitions:
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        additional_instructions: 'Focus on the specific areas that need clarification and ask the user about needs and preferences.'
+        transition_reason: 'Planning work revealed need for more exploration'
+
+      - trigger: 'plan_complete'
+        to: 'code'
+        transition_reason: 'Implementation plan is complete and ready for coding'
+        review_perspectives:
+          - perspective: 'architect'
+            prompt: 'Review implementation strategy, design decisions, and integration approach for soundness and maintainability. Ensure the plan aligns with existing system architecture and follows best practices.'
+          - perspective: 'security_expert'
+            prompt: 'Assess security considerations and potential risks in the planned implementation approach. Review data handling, authentication, and potential vulnerabilities.'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Feature development abandoned during planning. Return to exploration state for new tasks.
+          Task history will remain for future reference.
+        additional_instructions: 'Feature development abandoned during planning. Clean up any planning work and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during planning phase'
+
+  code:
+    description: 'Implementation phase - writing and building the solution'
+    default_instructions: |
+      Follow your plan to build the solution:
+
+      - **Apply your coding skill.** If unavailable, ask user about coding practices.
+      - **Apply your testing skill.** If unavailable, ask user about testing practices.
+      - Check whether there is a design document in the project and follow it; if not, elaborate design options and present them to the user
+      - Check whether there is a requirements document in the project and ensure all requirements are met
+
+      Write clean, well-structured code with proper error handling. Prevent regression by building, linting, and executing existing tests. Stay flexible and adapt the plan as you learn more during implementation. Update task progress and create new tasks as needed.
+    transitions:
+      - trigger: 'need_replanning'
+        to: 'plan'
+        additional_instructions: "Consider what you've learned during coding and adjust the plan accordingly. Document the changes and reasons."
+        transition_reason: 'Implementation work revealed need to revise the plan'
+
+      - trigger: 'need_more_exploration'
+        to: 'explore'
+        additional_instructions: 'Focus on the specific areas that are blocking implementation progress.'
+        transition_reason: 'Implementation work revealed need for more exploration'
+
+      - trigger: 'code_complete'
+        to: 'commit'
+        transition_reason: 'Core implementation is complete, ready for finalization'
+        review_perspectives:
+          - perspective: 'senior_software_developer'
+            prompt: 'Review code quality, best practices, testing coverage, and readiness for production deployment. Ensure the implementation follows coding standards and is maintainable.'
+          - perspective: 'performance_engineer'
+            prompt: 'Evaluate performance impact, resource efficiency, and scalability of the implemented solution. Check for potential bottlenecks or optimization opportunities.'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Feature development abandoned during implementation. Clean up any incomplete code and return to exploration.
+          Task history and any completed work will remain for future reference.
+        additional_instructions: 'Clean up any incomplete code and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during implementation'
+
+  commit:
+    description: 'Code cleanup and documentation finalization'
+    default_instructions: >
+      Ensure 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. Check whether there is a requirements, architecture, or design document in the project and update any that are affected by the implementation
+      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**
+
+      - **Apply your testing skill.** If unavailable, ask user about testing practices.
+      - Verify documentation accuracy with a final review
+      - Ensure code is ready for production/delivery
+
+      Update task progress and mark completed work as you finalize the feature.
+    transitions:
+      - trigger: 'need_code_changes'
+        to: 'code'
+        additional_instructions: 'Focus on the problems identified during final review.'
+        transition_reason: 'Final review found issues requiring code changes'
+
+      - trigger: 'commit_complete'
+        to: 'explore'
+        transition_reason: 'Feature delivery complete, ready for next task'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Clean up any finalization artifacts and prepare for new tasks.'
+        transition_reason: 'User decided to abandon feature during finalization'

package/packages/opencode-plugin/resources/workflows/skilled-greenfield.yaml

@@ -0,0 +1,207 @@
+---
+name: 'skilled-greenfield'
+description: 'A comprehensive workflow for starting new projects from scratch: Ideation, Architecture, Plan, Code, Document - ideal for greenfield projects requiring thorough upfront planning'
+initial_state: 'ideation'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'skilled'
+  complexity: 'high'
+  bestFor:
+    - 'New projects from scratch'
+    - 'Greenfield development'
+    - 'Complex system design'
+    - 'Comprehensive planning needed'
+  useCases:
+    - 'Starting a new application'
+    - 'Building a new service'
+    - 'Creating a new library'
+  examples:
+    - 'Build a new web application'
+    - 'Create a microservice architecture'
+    - 'Develop a new CLI tool'
+  requiresDocumentation: true
+
+# States with default instructions and transitions
+states:
+  ideation:
+    description: 'Deep requirements discovery and PRD creation phase'
+    default_instructions: |
+      Understand WHAT the system should do, WHO will use it, WHY it's needed, and WHAT'S in/out of scope by exploring:
+
+      **Apply your starting-project skill.** If unavailable, ask user about project setup practices.
+
+      - Are there existing solutions? What gaps do they have?
+      - What technologies must/cannot be used? Why?
+      - How will you measure product success?
+      - Have you validated this need with potential users?
+
+      Don't discuss technical implementation yet - focus purely on understanding the problem space and requirements. Check whether there is a requirements document in the project and if so, read it carefully. Create tasks as needed.
+    transitions:
+      - trigger: 'ideation_complete'
+        to: 'architecture'
+        transition_reason: 'PRD is complete with clear requirements, ready for technical architecture design'
+        review_perspectives:
+          - perspective: 'business_analyst'
+            prompt: 'Review the Product Requirements Document for completeness, clarity, and business value. Ensure all stakeholder needs are captured, requirements are testable, and scope is well-defined.'
+          - perspective: 'ux_expert'
+            prompt: 'Evaluate user experience requirements and usability considerations. Ensure user personas, workflows, and interaction patterns are properly defined for the greenfield project.'
+
+  architecture:
+    description: 'Tech stack selection and architecture design phase'
+    default_instructions: |
+      Design the technical solution based on the requirements discovered during ideation.
+
+      - **Apply your architecture skill.** If unavailable, ask user about architectural conventions.
+      - Ask about the user's technical preferences and experience
+      - Challenge their choices by presenting alternatives
+      - Evaluate pros and cons of different tech stacks, frameworks, and architectural patterns
+      - Consider non-functional requirements like scalability, performance, maintainability, and deployment
+
+      Check whether there is an architecture document in the project and if so, read and build on it. Don't start coding yet - focus on technical design decisions.
+    transitions:
+      - trigger: 'need_more_ideation'
+        to: 'ideation'
+        additional_instructions: 'Architecture work revealed gaps in requirements understanding. Focus on the specific requirements areas that need clarification before continuing with technical design.'
+        transition_reason: 'Architecture work revealed need for more requirements clarification'
+
+      - trigger: 'architecture_complete'
+        to: 'plan'
+        additional_instructions: 'Present the implementation plan to the user and document it thoroughly.'
+        transition_reason: 'Technical architecture is complete, ready for implementation planning'
+        review_perspectives:
+          - perspective: 'architect'
+            prompt: 'Review the technical architecture for completeness, scalability, and maintainability. Ensure technology choices are appropriate and architectural patterns are sound for a greenfield project.'
+          - perspective: 'security_expert'
+            prompt: 'Evaluate security architecture, data protection strategies, and potential vulnerabilities. Ensure security is built into the foundation of the greenfield project from the start.'
+
+      - trigger: 'abandon_project'
+        to: 'ideation'
+        instructions: >
+          Project development abandoned during architecture phase. Return to ideation state for new projects.
+          Task history and PRD will remain for future reference.
+        additional_instructions: 'Project development abandoned during architecture phase. Clean up any architecture work and prepare for new projects.'
+        transition_reason: 'User decided to abandon project during architecture phase'
+
+  plan:
+    description: 'Implementation planning phase based on established architecture'
+    default_instructions: |
+      Create a detailed implementation strategy based on your completed architecture and requirements.
+
+      - **Apply your application-design skill.** If unavailable, ask user about application design practices.
+      - Check whether there is a design document in the project and adhere to it
+
+      **STEP 1: Break Down Work**
+      - Break down the work into specific, actionable tasks
+      - Consider the chosen tech stack and architectural decisions
+      - Plan the implementation order and identify dependencies
+
+      **STEP 2: Assess Risks**
+      - Consider potential risks and mitigation strategies
+      - Document the detailed design if needed
+
+      **STEP 3: Create Tasks**
+      - Create tasks thoroughly with clear milestones for implementation work
+      - Ensure each task is actionable and has clear acceptance criteria
+    transitions:
+      - trigger: 'need_architecture_changes'
+        to: 'architecture'
+        additional_instructions: "Planning revealed issues with the current architecture. Consider what you've learned during planning and adjust the technical design accordingly. Document the changes and reasons."
+        transition_reason: 'Planning work revealed need to revise the architecture'
+
+      - trigger: 'plan_complete'
+        to: 'code'
+        additional_instructions: "Implementation plan is complete! ✅ Now transition to coding phase. Read specific documentation before using the chosen libraries and frameworks. Follow the architectural patterns and tech stack decisions you've made. Modularize your code according to best practices. Stay focused on the current project scope defined in your PRD. Update task progress as you complete planning work."
+        transition_reason: 'Implementation plan is complete and ready for coding'
+
+      - trigger: 'abandon_project'
+        to: 'ideation'
+        instructions: >
+          Project development abandoned during planning. Return to ideation state for new projects.
+          Task history, PRD, and architecture documentation will remain for future reference.
+        additional_instructions: 'Project development abandoned during planning. Clean up any planning work and prepare for new projects.'
+        transition_reason: 'User decided to abandon project during planning phase'
+
+  code:
+    description: 'Implementation phase following the established plan and architecture'
+    default_instructions: |
+      Build the solution following your plan and architecture.
+
+      - **Apply your coding skill.** If unavailable, ask user about coding practices.
+      - **Apply your testing skill.** If unavailable, ask user about testing practices.
+      - Check whether there is a design document in the project and follow it
+      - Check whether there is a requirements document in the project and ensure all requirements you are currently working on are met
+      - Write clean, well-structured code with proper error handling
+      - Prevent regression by building, linting, and executing existing tests
+      - Stay flexible and adapt the plan as you learn more during implementation, but maintain alignment with your architecture decisions
+      - Update task progress and create new tasks as needed for current phase work
+    transitions:
+      - trigger: 'need_replanning'
+        to: 'plan'
+        additional_instructions: "Implementation revealed issues with the current plan. Consider what you've learned during coding and adjust the implementation strategy accordingly while maintaining architectural consistency. Document the changes and reasons."
+        transition_reason: 'Implementation work revealed need to revise the plan'
+
+      - trigger: 'need_architecture_changes'
+        to: 'architecture'
+        additional_instructions: 'Implementation revealed fundamental issues with the architecture that require design changes. Focus on the specific architectural problems that are blocking implementation progress.'
+        transition_reason: 'Implementation work revealed need for architectural changes'
+
+      - trigger: 'code_complete'
+        to: 'finalize'
+        transition_reason: 'Core implementation is complete, ready for comprehensive documentation'
+
+      - trigger: 'abandon_project'
+        to: 'ideation'
+        instructions: >
+          Project development abandoned during implementation. Clean up any incomplete code and return to ideation.
+          Task history, PRD, architecture documentation, and any completed work will remain for future reference.
+        additional_instructions: 'Project development abandoned during implementation. Clean up any incomplete code and prepare for new projects.'
+        transition_reason: 'User decided to abandon project during implementation'
+
+  finalize:
+    description: 'Code cleanup and documentation finalization'
+    default_instructions: |
+      This phase ensures code quality and documentation accuracy through systematic cleanup and review.
+
+      **STEP 1: Code Cleanup**
+      Systematically clean up development artifacts:
+
+      1. Remove all temporary debug output statements used during development (console logging, print statements, debug functions)
+      2. 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, temporary test code, and commented-out code
+         - Ensure proper error handling replaces temporary debug logging
+
+      **STEP 2: Documentation Review**
+      Update documentation to reflect final implementation:
+
+      1. Check whether there is a requirements, architecture, or design document in the project and update any that are affected by the implementation
+      2. Review documentation against actual implemented functionality
+      3. Only modify documentation sections that have functional changes
+      4. Remove references to development iterations, progress notes, and temporary decisions
+      5. Ensure documentation describes the final implemented state, not the development process
+      6. Ask user to review document updates
+
+      **STEP 3: Comprehensive Documentation**
+      Ensure project has complete documentation for newcomers including setup, usage, architecture overview, and contribution guidelines.
+
+      **STEP 4: Final Validation**
+      - **Apply your testing skill.** If unavailable, ask user about testing practices.
+      - Verify documentation accuracy with a final review
+      - Ensure project is ready for users and contributors
+      - Update task progress and mark completed work as you finalize the project
+    transitions:
+      - trigger: 'need_code_changes'
+        to: 'code'
+        additional_instructions: 'Finalization revealed issues that require code changes. Focus on the problems identified during final review that affect usability or functionality.'
+        transition_reason: 'Finalization revealed issues requiring code changes'
+
+      - trigger: 'finalization_complete'
+        to: 'ideation'
+        transition_reason: 'Project delivery complete with finalized code and documentation, ready for next greenfield project'
+
+      - trigger: 'abandon_project'
+        to: 'ideation'
+        additional_instructions: 'Project development abandoned during finalization. Clean up any finalization artifacts and prepare for new projects.'
+        transition_reason: 'User decided to abandon project during finalization phase'

package/packages/opencode-plugin/resources/workflows/slides.yaml

@@ -0,0 +1,237 @@
+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: |
+      **Clarify the presentation foundation** with the user by gathering essential information:
+
+      - 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
+
+      **Update** the plan file with ideation progress and key decisions before proceeding to structure.
+
+    transitions:
+      - trigger: ideation_complete
+        to: structure
+        transition_reason: 'Presentation concept and goals clearly defined, ready for content structuring'
+
+  structure:
+    description: 'Organize content flow and logical progression'
+    default_instructions: |
+      **Create a detailed presentation structure** by organizing your content logically and effectively:
+
+      - 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
+
+      **Update** the plan file with structural decisions and progress before moving to content drafting.
+
+    transitions:
+      - trigger: structure_complete
+        to: draft
+        additional_instructions: |
+          **Structure phase 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: |
+          **Abandon structural work** - 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: |
+      **Create content and speaker notes** to establish the presentation material and delivery guide:
+
+      - 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
+
+      **Update** the plan file with drafting progress and content decisions before moving to styling.
+
+    transitions:
+      - trigger: draft_complete
+        to: style
+        additional_instructions: |
+          **Draft phase 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: |
+          **Abandon drafting work** - 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: |
+      **Apply visual design and create presentation aesthetics** to bring professional appeal and consistency:
+
+      - 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
+
+      **Update** the plan file with styling progress and design decisions before moving to review.
+
+    transitions:
+      - trigger: style_complete
+        to: review
+        additional_instructions: |
+          **Style phase 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: |
+          **Abandon styling work** - 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: |
+      **Validate presentation quality** by reviewing content, timing, visuals, and delivery readiness:
+
+      - 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
+
+      **Update** the plan file with review progress and refinements before moving to delivery preparation.
+
+    transitions:
+      - trigger: review_complete
+        to: deliver
+        additional_instructions: |
+          **Review phase 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: |
+          **Abandon review work** - 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: |
+      **Prepare final delivery** by exporting formats, testing setup, and ensuring flawless execution:
+
+      - 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
+
+      **Update** the plan file with delivery preparation progress to ensure successful delivery.
+
+    transitions:
+      - trigger: delivery_complete
+        to: ideate
+        additional_instructions: |
+          **Delivery phase 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: |
+          **Abandon delivery preparation** - 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'