@codemcp/workflows-core 3.1.21 → 3.2.0

package/resources/workflows/greenfield.yaml

@@ -0,0 +1,189 @@
+# yaml-language-server: $schema=../state-machine-schema.json
+---
+name: '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: 'code'
+  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: |
+      You are in the ideation phase for greenfield project.
+      Understand WHAT the system should do, WHO will use it, WHY it's needed, and WHAT'S in/out of scope, e. g.
+      • 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. Document all findings in $REQUIREMENTS_DOC and the plan file.
+    transitions:
+      - trigger: 'ideation_complete'
+        to: 'architecture'
+        additional_instructions: 'Ideation is complete! ✅ Present the PRD to the user. Mark completed ideation tasks.'
+        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.'
+
+      - trigger: 'abandon_project'
+        to: 'ideation'
+        instructions: >
+          Project development abandoned. Return to ideation state for new projects.
+          The plan file will remain for future reference if needed.
+        additional_instructions: 'Project development abandoned. Clean up any ideation work and prepare for new projects.'
+        transition_reason: 'User decided to abandon current project development'
+
+  architecture:
+    description: 'Tech stack selection and architecture design phase'
+    default_instructions: "You are in the architecture phase. Based on the requirements from $REQUIREMENTS_DOC, now design the technical solution. 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. Create a comprehensive architecture document in $ARCHITECTURE_DOC. 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: 'Architecture is complete! ✅ You have a solid technical foundation with clear tech stack choices and architectural decisions. Present the implementation plan to the user and document it thoroughly. Mark completed architecture tasks.'
+        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.
+          The plan file 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: 'You are in the planning phase. Based on your completed architecture in $ARCHITECTURE_DOC and requirements from $REQUIREMENTS_DOC, create a detailed implementation strategy. Break down the work into specific, actionable tasks considering the chosen tech stack and architectural decisions. Plan the implementation order, identify dependencies, and consider potential risks. Document the detailed design in $DESIGN_DOC and the plan thoroughly with clear milestones. Important: Tasks for the actual coding should be organized in the Code section of the plan.'
+    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. Mark completed planning tasks."
+        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.
+          The plan file, 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: 'You are in the implementation phase. Follow your plan and detailed design from $DESIGN_DOC to build the solution using the architecture from $ARCHITECTURE_DOC. Ensure all requirements from $REQUIREMENTS_DOC 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 progress in the plan file. Important: Focus on tasks in the Code section of your plan.'
+    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'
+        additional_instructions: 'Implementation is complete! ✅ Now transition to finalization phase. Mark completed implementation tasks.'
+        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.
+          The plan file, 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: >
+      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**
+      6. **Comprehensive Documentation**: Ensure project has complete documentation for newcomers including setup, usage, architecture overview, and contribution guidelines
+
+      **STEP 3: Final Validation**
+      - Run existing tests to ensure cleanup didn't break functionality
+      - Verify documentation accuracy with a final review
+      - Ensure project is ready for users and contributors
+
+      Update the plan file with finalization progress and mark completed tasks.
+    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'
+        additional_instructions: 'Greenfield project is complete and ready for delivery! All phases successfully finished. Prepare for the next greenfield project.'
+        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/resources/workflows/minor.yaml

@@ -0,0 +1,127 @@
+# yaml-language-server: $schema=../state-machine-schema.json
+---
+name: 'minor'
+description: 'A streamlined workflow for small-impact changes: Explore (analysis + design) → Implement (code + test + commit) - optimized for minor enhancements'
+initial_state: 'explore'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'code'
+  complexity: 'low'
+  bestFor:
+    - 'Small bug fixes'
+    - 'Minor feature enhancements'
+    - 'Code refactoring'
+    - 'Documentation updates'
+  useCases:
+    - 'Adding a new parameter to an existing function'
+    - 'Improving error messages'
+    - 'Small UI adjustments'
+  examples:
+    - 'Fix a typo in user interface text'
+    - 'Add validation to an input field'
+    - 'Enhance logging in a specific module'
+
+# States with default instructions and transitions
+states:
+  explore:
+    description: 'Analysis and design phase - understanding and planning without implementation'
+    default_instructions: >
+      You are in the exploration phase for minor enhancement.
+      This phase should be efficient since it's a minor enhancement.
+      Understand the problem, analyze existing patterns, and design your approach.
+      Consider the scope and impact of the change. If $REQUIREMENTS_DOC exists, document requirements there, otherwise document them in the plan file. If $DESIGN_DOC exists, respect the design approach in $DESIGN_DOC.
+      Document your analysis and design decisions in the plan file.
+      Focus on analysis and design only - do not write any code yet.
+    transitions:
+      - trigger: 'exploration_complete'
+        to: 'implement'
+        additional_instructions: 'Analysis and design complete! ✅ Now transition to implementation phase. You have a clear understanding of the problem and a solid design approach. Keep the scope focused on the minor enhancement. Mark completed exploration tasks.'
+        transition_reason: 'Analysis and design complete, ready for streamlined implementation'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Minor enhancement abandoned. Revert potentially made changes.
+          Return to exploration state for new tasks.
+          The plan file will remain for future reference if needed.
+        additional_instructions: 'Minor enhancement development abandoned. Clean up any analysis work and prepare for new tasks.'
+        transition_reason: 'User decided to abandon current minor enhancement'
+
+  implement:
+    description: 'Combined implementation phase - code, test, and commit'
+    default_instructions: "You are in the implementation phase for minor enhancement. This phase combines coding, testing, and commit preparation. If $DESIGN_DOC exists, follow your design from $DESIGN_DOC. If $REQUIREMENTS_DOC exists, ensure the relevant requirements from $REQUIREMENTS_DOC are met, otherwise ensure plan file requirements are met. Write clean, focused code for the minor enhancement. Test your changes to ensure they work correctly and don't break existing functionality. Prepare documentation and commit when ready. Update progress in the plan file."
+    transitions:
+      - trigger: 'need_more_analysis'
+        to: 'explore'
+        additional_instructions: 'Implementation revealed gaps in analysis or design. Focus on the specific areas that need clarification before continuing with implementation.'
+        transition_reason: 'Implementation work revealed need for more analysis or design'
+
+      - trigger: 'implementation_complete'
+        to: 'finalize'
+        additional_instructions: 'Implementation is complete! Clean up code and finalize documentation to ensure everything is ready for delivery. Mark all implementation tasks as complete.'
+        transition_reason: 'Implementation complete, ready for finalization'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        instructions: >
+          Minor enhancement abandoned during implementation. Clean up any incomplete code and return to exploration.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Minor enhancement abandoned during implementation. Clean up any incomplete code and prepare for new tasks.'
+        transition_reason: 'User decided to abandon minor enhancement during implementation'
+
+  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:
+          • If $REQUIREMENTS_DOC exists, update $REQUIREMENTS_DOC if requirements changed during development
+          • If $DESIGN_DOC exists, 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 minor enhancement is ready for delivery
+
+      Update the plan file with finalization progress and mark completed tasks.
+    transitions:
+      - trigger: 'need_implementation_changes'
+        to: 'implement'
+        additional_instructions: 'Finalization revealed issues that require implementation changes. Focus on the specific problems identified during final review.'
+        transition_reason: 'Finalization revealed issues requiring implementation changes'
+
+      - trigger: 'finalization_complete'
+        to: 'explore'
+        additional_instructions: 'Minor enhancement is complete and finalized! All work is finished and ready for delivery. Prepare for the next development task.'
+        transition_reason: 'Minor enhancement delivery complete, ready for next task'
+
+      - trigger: 'abandon_feature'
+        to: 'explore'
+        additional_instructions: 'Minor enhancement abandoned during finalization. Clean up any finalization artifacts and prepare for new tasks.'
+        transition_reason: 'User decided to abandon minor enhancement during finalization'

package/resources/workflows/posts.yaml

@@ -0,0 +1,207 @@
+name: posts
+description: 'A comprehensive workflow for writing posts - from blog posts to short-form content, with research, story development, and multi-platform publishing'
+initial_state: discovery
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'office'
+  complexity: 'medium'
+  bestFor:
+    - 'Blog post writing'
+    - 'Content creation'
+    - 'Article development'
+    - 'Social media content'
+  useCases:
+    - 'Writing technical blog posts'
+    - 'Creating marketing content'
+    - 'Developing thought leadership articles'
+  examples:
+    - 'Write a tutorial blog post'
+    - 'Create a product announcement'
+    - 'Develop a technical deep-dive article'
+
+states:
+  discovery:
+    description: 'Research topic, decide format, and analyze competitive landscape'
+    default_instructions: |
+      You are in the discovery phase for post development. This is where you define the foundation of your post.
+
+      Focus on understanding the topic and format:
+      - Help user decide post format: Ask about goal (quick insight vs deep exploration), topic complexity, available time
+      - Research existing content on this topic to identify gaps and opportunities
+      - Guide user to articulate personal motivation and unique angle
+      - Conduct competitive landscape analysis to avoid duplication
+      - Define target audience and platform considerations
+      - Gather initial sources and reference materials
+
+      Work with the user to establish clear direction before moving to story development.
+      Update the plan file with discovery progress and key decisions.
+
+    transitions:
+      - trigger: discovery_complete
+        to: story
+        additional_instructions: |
+          Discovery complete! ✅ You have clear format decision, unique angle, and research foundation.
+
+          Update the plan file with story development tasks and mark completed discovery work.
+        transition_reason: 'Topic researched and format decided, ready for story structure development'
+
+      - trigger: abandon_post
+        to: discovery
+        instructions: |
+          Post development abandoned. Clean up any discovery work and prepare for new post topics.
+          The plan file will remain for future reference if needed.
+        additional_instructions: 'Post development abandoned. Prepare for new post topics.'
+        transition_reason: 'User decided to abandon current post development'
+
+  story:
+    description: 'Create narrative structure and story outline'
+    default_instructions: |
+      Working on story development phase. Focus on creating a compelling narrative structure.
+
+      Key activities for this phase:
+      - Create detailed story outline with clear beginning, middle, end
+      - Identify key messages and memorable metaphors/examples
+      - Define content scope boundaries to maintain focus and avoid adjacent topics
+      - Plan how content will adapt across different platforms
+      - Ensure narrative arc matches chosen format (concise for short posts, comprehensive for long-form)
+      - Structure content to maintain user's personal voice and conversational style
+
+      Work with the user to create a solid story foundation before moving to writing.
+      Update the plan file with story decisions and structural progress.
+
+    transitions:
+      - trigger: story_complete
+        to: writing
+        additional_instructions: |
+          Story complete! ✅ You have a clear narrative structure and content outline.
+
+          Update the plan file with writing tasks and mark completed story work.
+        transition_reason: 'Story structure and outline complete, ready for content creation'
+
+      - trigger: need_more_discovery
+        to: discovery
+        additional_instructions: 'Story development revealed gaps in research or format clarity. Focus on clarifying these foundational aspects.'
+        transition_reason: 'Story work revealed need for additional discovery or research'
+
+      - trigger: abandon_post
+        to: discovery
+        instructions: |
+          Post development abandoned during story phase. Clean up story work and return to discovery.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Post abandoned during story phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon post during story phase'
+
+  writing:
+    description: 'Create the actual post content following story outline'
+    default_instructions: |
+      Working on writing phase. Focus purely on creating engaging content.
+
+      Key activities for this phase:
+      - Write content following the established story outline
+      - Maintain consistent narrative flow and personal voice
+      - Create engaging, conversational content in user's style
+      - Ensure content length matches chosen format (3-10 lines for short, 2000-5000+ words for long)
+      - Stay within defined content scope to avoid adjacent topics
+      - Include concrete examples and metaphors as planned
+      - Create clear section structure with appropriate headings (for long-form)
+
+      Focus on high-quality content creation without visual elements.
+      Update the plan file with writing progress and content decisions.
+
+    transitions:
+      - trigger: writing_complete
+        to: illustration
+        additional_instructions: |
+          Writing complete! ✅ You have solid content that follows your story outline.
+
+          Update the plan file with illustration tasks and mark completed writing work.
+        transition_reason: 'Content creation complete, ready for visual enhancement'
+
+      - trigger: need_story_revision
+        to: story
+        additional_instructions: 'Writing revealed issues with story structure or narrative flow. Focus on refining the story foundation.'
+        transition_reason: 'Content creation revealed need for story structure refinement'
+
+      - trigger: abandon_post
+        to: discovery
+        instructions: |
+          Post development abandoned during writing. Clean up writing work and return to discovery.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Post abandoned during writing phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon post during writing phase'
+
+  illustration:
+    description: 'Create and integrate visual elements'
+    default_instructions: |
+      Working on illustration phase. Focus on visual enhancement of your content.
+
+      Key activities for this phase:
+      - Identify strategic locations for visual elements
+      - Create or source appropriate visuals (screenshots, diagrams, metaphorical images)
+      - Ensure visual density matches format (minimal for short posts, comprehensive for long-form)
+      - Maintain visual consistency and professional appearance
+      - Ensure visuals support and enhance the written content
+      - Consider accessibility and platform compatibility
+      - Plan visual integration and placement
+
+      Focus on creating visuals that enhance rather than distract from the content.
+      Update the plan file with illustration progress and visual decisions.
+
+    transitions:
+      - trigger: illustration_complete
+        to: distribution
+        additional_instructions: |
+          Illustration complete! ✅ You have visually enhanced content ready for publishing.
+
+          Update the plan file with distribution tasks and mark completed illustration work.
+        transition_reason: 'Visual elements complete, ready for SEO optimization and publishing'
+
+      - trigger: need_more_content
+        to: writing
+        additional_instructions: 'Illustration work revealed gaps in written content. Focus on completing the content foundation.'
+        transition_reason: 'Visual work revealed need for additional written content'
+
+      - trigger: abandon_post
+        to: discovery
+        instructions: |
+          Post development abandoned during illustration. Clean up illustration work and return to discovery.
+          The plan file and any completed work will remain for future reference.
+        additional_instructions: 'Post abandoned during illustration phase. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon post during illustration phase'
+
+  distribution:
+    description: 'Optimize for SEO and publish across platforms'
+    default_instructions: |
+      Working on distribution phase. Focus on optimization and multi-platform publishing.
+
+      Key activities for this phase:
+      - Create compelling, SEO-optimized titles and descriptions
+      - Add appropriate tags and metadata for discoverability
+      - Adapt content formatting for different platforms (LinkedIn, Medium, HN)
+      - Maintain core message while adjusting for platform-specific requirements
+      - Conduct final quality review and polish
+      - Prepare publishing materials and schedule
+      - Execute multi-platform publishing strategy
+
+      Focus on maximizing reach while maintaining content quality and consistency.
+      Update the plan file with distribution progress and publishing decisions.
+
+    transitions:
+      - trigger: distribution_complete
+        to: discovery
+        additional_instructions: 'Post successfully published. Ready for next post project.'
+        transition_reason: 'Post publishing completed successfully, ready for new projects'
+
+      - trigger: need_final_review
+        to: illustration
+        additional_instructions: 'Distribution preparation revealed issues with visuals or content presentation. Focus on final refinements.'
+        transition_reason: 'Publishing preparation identified issues requiring visual or content refinement'
+
+      - trigger: abandon_post
+        to: discovery
+        instructions: |
+          Post development abandoned before distribution. Clean up distribution preparation and return to discovery.
+          The plan file and completed work will remain for future reference.
+        additional_instructions: 'Post abandoned before distribution. Clean up and prepare for new topics.'
+        transition_reason: 'User decided to abandon post before distribution'