@codemcp/workflows 6.0.1 → 6.0.2

package/packages/cli/resources/workflows/sdd-feature-crowd.yaml

@@ -0,0 +1,713 @@
+# yaml-language-server: $schema=../../state-machine-schema.json
+---
+name: 'sdd-feature-crowd'
+description: 'Collaborative specification-driven feature development: Business Analyst → Architect → Developer working as a team'
+initial_state: 'analyze'
+
+# Enhanced metadata for better discoverability
+metadata:
+  domain: 'sdd-crowd'
+  complexity: 'medium'
+  collaboration: true
+  requiredRoles:
+    - business-analyst
+    - architect
+    - developer
+  bestFor:
+    - 'Team-based feature development'
+    - 'Multi-agent collaboration'
+    - 'Specification-driven development with specialized roles'
+  useCases:
+    - 'Add new functionality with separate BA, architect, and developer agents'
+    - 'Enhance existing features with collaborative team'
+  examples:
+    - 'Team builds user profile management system'
+    - 'Collaborative search functionality implementation'
+
+# States with default instructions and role-specific transitions
+states:
+  analyze:
+    description: 'Analyze current state and requirements'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Your team members can help you at any time through messaging.
+
+    transitions:
+      # Business Analyst is RESPONSIBLE for analyze phase
+      - trigger: 'analysis_complete'
+        to: 'specify'
+        role: business-analyst
+        transition_reason: 'Analysis completed, moving to specification'
+        additional_instructions: |
+          **Drive the analyze phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Proceed to the next phase
+
+          **STEP 1: Gather Context**
+          - Review existing codebase and architecture
+          - Understand current user workflows
+          - Identify constraints and dependencies
+          - Document assumptions about the current state
+
+          **STEP 2: Analyze Requirements**
+
+          For New Features:
+          - Identify how the feature fits into the existing system
+          - Map integration points with current functionality
+          - Document existing patterns and conventions to follow
+
+          For Enhancements:
+          - Review current implementation and its limitations
+          - Identify user pain points and feedback
+          - Analyze performance or usability issues
+          - Document technical debt that should be addressed
+
+          **STEP 3: Collaborate for Insights**
+          - Use send_message to ask architect about existing architecture constraints
+          - Use send_message to ask developer about current implementation details
+          - Wait for responses to inform your analysis
+
+          **STEP 4: Document and Transition**
+          - Create `$VIBE_DIR/specs/$BRANCH_NAME/current-state-analysis.md`
+          - Use send_message_to_operator to report analysis completion
+          - You remain RESPONSIBLE in the specify phase (continue driving the work)
+          - Call proceed_to_phase only when ready
+
+      # Architect is CONSULTED during analyze phase
+      - trigger: 'analysis_complete'
+        to: 'specify'
+        role: architect
+        transition_reason: 'Analysis completed, transitioning to specification'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Business-analyst is driving this work. You are in consultative mode.
+
+          **Monitor and Respond:**
+          - Check get_my_messages for questions from business-analyst
+          - Answer when asked about architecture constraints
+          - Discuss system integration points
+          - Address technical feasibility concerns
+
+          **Constraints:**
+          - Do NOT edit the plan file (business-analyst has exclusive control)
+          - Do NOT proceed to next phase
+          - Wait for business-analyst to ask questions
+
+          **Provide Value:**
+          - Share clear, actionable feedback about architecture
+          - Document knowledge about existing system patterns
+          - Use send_message to proactively share relevant insights
+
+      # Developer is CONSULTED during analyze phase
+      - trigger: 'analysis_complete'
+        to: 'specify'
+        role: developer
+        transition_reason: 'Analysis completed, transitioning to specification'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Business-analyst is driving this work. You are in consultative mode.
+
+          **Monitor and Respond:**
+          - Check get_my_messages for questions from business-analyst
+          - Answer when asked about current implementation details
+          - Discuss existing code patterns
+          - Provide technical complexity estimates
+
+          **Constraints:**
+          - Do NOT edit the plan file (business-analyst has exclusive control)
+          - Do NOT proceed to next phase
+          - Wait for business-analyst to ask questions
+
+          **Provide Value:**
+          - Share insights about existing codebase
+          - Document implementation challenges and patterns
+          - Use send_message to proactively share relevant knowledge
+
+      # Skip analysis option (all agents can use this)
+      - trigger: 'skip_analysis'
+        to: 'specify'
+        transition_reason: 'Analysis not needed, proceeding to specification'
+        additional_instructions: |
+          Skip the analysis phase for straightforward new features.
+          Proceed directly to specification using provided requirements.
+
+  specify:
+    description: 'Create feature specification'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Business-analyst is responsible. Architect and developer are consulted.
+
+    transitions:
+      # Business Analyst is RESPONSIBLE for specify phase
+      - trigger: 'specification_complete'
+        to: 'clarify'
+        role: business-analyst
+        transition_reason: 'Specification completed, ready for clarification'
+        additional_instructions: |
+          **Drive the specify phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Proceed to the next phase
+
+          **STEP 1: Extract Requirements**
+          - Parse key concepts from user's description
+          - Identify actors, actions, data, and constraints
+          - Use existing system context from analysis (if performed)
+          - Focus on WHAT users need and WHY, not HOW to implement
+
+          **STEP 2: Gather Clarifications**
+          Ask questions about:
+          - Integration points with existing features
+          - User impact and affected users
+          - Data dependencies
+          - Performance requirements
+          - Backward compatibility concerns
+
+          **STEP 3: Resolve Ambiguities**
+          - Make informed guesses based on context and industry standards
+          - Use `[NEEDS CLARIFICATION: question]` only for critical decisions (max 3)
+          - Prioritize: scope > security/privacy > user experience > technical details
+
+          **STEP 4: Collaborate for Feedback**
+          - Use send_message to ask architect: "Is this technically feasible?"
+          - Use send_message to ask developer: "How complex is this to implement?"
+          - Wait for responses and incorporate feedback
+
+          **STEP 5: Document and Transition**
+          - Create `$VIBE_DIR/specs/$BRANCH_NAME/spec.md` with:
+            - User scenarios and testing
+            - Functional requirements
+            - Success criteria
+            - Integration points
+          - Use send_message to ask architect and developer to review spec.md
+          - Wait for their feedback and address concerns
+          - Use send_message_to_operator: "Specification complete, moving to clarification"
+          - You remain RESPONSIBLE in clarify phase
+          - Call proceed_to_phase only when ready
+
+      # Architect is CONSULTED during specify phase
+      - trigger: 'specification_complete'
+        to: 'clarify'
+        role: architect
+        transition_reason: 'Specification completed, transitioning to clarification'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Business-analyst is driving this work. You are in consultative mode.
+
+          **Monitor and Provide Feedback:**
+          - Check get_my_messages for review requests from business-analyst
+          - Assess technical feasibility of requirements
+          - Discuss architecture constraints and integration concerns
+          - Analyze system scalability and performance implications
+          - Evaluate technology stack compatibility
+
+          **Constraints:**
+          - Do NOT edit the plan file (business-analyst has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for review requests
+          - Use send_message to provide detailed feedback
+          - Ask clarifying questions if requirements are unclear
+          - Suggest alternatives if requirements are problematic
+
+      # Developer is CONSULTED during specify phase
+      - trigger: 'specification_complete'
+        to: 'clarify'
+        role: developer
+        transition_reason: 'Specification completed, transitioning to clarification'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Business-analyst is driving this work. You are in consultative mode.
+
+          **Monitor and Provide Feedback:**
+          - Check get_my_messages for review requests from business-analyst
+          - Assess implementation complexity and effort
+          - Identify technical challenges and risks
+          - Evaluate compatibility with existing codebase
+          - Discuss testing requirements
+
+          **Constraints:**
+          - Do NOT edit the plan file (business-analyst has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for review requests
+          - Use send_message to provide honest complexity estimates
+          - Highlight potential implementation challenges
+          - Suggest simplifications if requirements are too complex
+
+      # For needs_clarification loop
+      - trigger: 'needs_clarification'
+        to: 'specify'
+        role: business-analyst
+        transition_reason: 'Specification needs user clarification'
+        additional_instructions: |
+          Resolve unresolved clarifications by:
+          - Present structured questions to the user
+          - Wait for their responses
+          - Update the specification accordingly
+
+  clarify:
+    description: 'Review and clarify specification details'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Business-analyst is responsible. Architect is consulted.
+
+    transitions:
+      # Business Analyst is RESPONSIBLE for clarify phase
+      - trigger: 'clarification_complete'
+        to: 'plan'
+        role: business-analyst
+        transition_reason: 'All clarifications resolved, handing off to architect'
+        additional_instructions: |
+          **Drive the clarify phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Proceed to the next phase
+
+          **STEP 1: Review Specification**
+          - Check for any remaining `[NEEDS CLARIFICATION]` markers
+          - Verify all functional requirements are testable
+          - Ensure success criteria are measurable
+          - Validate user scenarios are complete
+
+          **STEP 2: Resolve Remaining Clarifications**
+          If `[NEEDS CLARIFICATION]` markers exist:
+          - Extract all markers from the spec (max 3)
+          - Present structured questions with options to the user
+          - Wait for user responses
+          - Update specification with chosen answers
+
+          **STEP 3: Validate and Prepare Handoff**
+          - Ensure no implementation details leaked in
+          - Verify requirements align with existing system
+          - Use send_message to ask architect for final spec review
+
+          **STEP 4: Hand Off to Architect**
+          - Use send_message to architect: "Specification is complete and clarified. Please take the lead for the plan phase. Review: `$VIBE_DIR/specs/$BRANCH_NAME/spec.md`"
+          - Use send_message to developer: "Specification finalized, architect will create the plan next"
+          - Use send_message_to_operator: "Clarification complete, handing off to architect for planning"
+          - You transition to CONSULTED role in plan phase
+          - Call proceed_to_phase only when ready
+
+      # Architect is CONSULTED during clarify phase
+      - trigger: 'clarification_complete'
+        to: 'plan'
+        role: architect
+        transition_reason: 'Clarifications resolved, preparing to take lead in plan phase'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Business-analyst is finalizing clarifications. You are in consultative mode.
+
+          **Monitor and Provide Feedback:**
+          - Check get_my_messages for final review requests
+          - Validate specification is ready for technical planning
+          - Provide feedback on any remaining technical concerns
+
+          **Constraints:**
+          - Do NOT edit the plan file (business-analyst has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Prepare for Your Leadership Role:**
+          When business-analyst completes clarify phase, YOU become RESPONSIBLE:
+          - You will take the lead in the plan phase
+          - Prepare to design the system architecture and create implementation plan
+
+      # Developer is INFORMED during clarify phase
+      - trigger: 'clarification_complete'
+        to: 'plan'
+        role: developer
+        transition_reason: 'Clarifications resolved, architect taking lead for planning'
+        additional_instructions: |
+          **Monitor Progress as INFORMED Agent**
+
+          Business-analyst is finalizing clarifications. You are in monitoring mode.
+
+          **Stay Aware:**
+          - Monitor specification updates
+          - Prepare for consultation during planning phase
+          - No active work required in this phase
+
+          **Get Ready for Next Phase:**
+          - Architect will take the lead in plan phase
+          - You will be CONSULTED during planning
+          - Prepare to provide implementation feedback when architect asks
+
+      # For needs_user_input loop
+      - trigger: 'needs_user_input'
+        to: 'clarify'
+        role: business-analyst
+        transition_reason: 'Waiting for user responses to clarification questions'
+        additional_instructions: |
+          Resolve user input needs by:
+          - Present clarification questions clearly
+          - Wait for user input
+          - Process responses before proceeding
+
+  plan:
+    description: 'Generate implementation plan with constitutional compliance'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Architect is responsible. Business-analyst and developer are consulted.
+
+    transitions:
+      # Business Analyst is CONSULTED during plan phase
+      - trigger: 'plan_complete'
+        to: 'tasks'
+        role: business-analyst
+        transition_reason: 'Plan completed, architect moving to tasks'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Architect is driving technical planning. You are in consultative mode.
+
+          **Monitor and Validate:**
+          - Check get_my_messages for questions from architect
+          - Validate plan aligns with specification requirements
+          - Clarify any ambiguous requirements
+          - Approve or suggest adjustments to technical approach
+
+          **Constraints:**
+          - Do NOT edit the plan file (architect has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for architect's questions
+          - Use send_message to validate alignment with spec
+          - Raise concerns if plan doesn't meet business requirements
+          - Clarify user needs when architect asks
+
+      # Architect is RESPONSIBLE for plan phase
+      - trigger: 'plan_complete'
+        to: 'tasks'
+        role: architect
+        transition_reason: 'Implementation plan completed, moving to task breakdown'
+        additional_instructions: |
+          **Drive the plan phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Proceed to the next phase
+
+          **STEP 1: Load Context**
+          - Read specification: `$VIBE_DIR/specs/$BRANCH_NAME/spec.md`
+          - Read analysis: `$VIBE_DIR/specs/$BRANCH_NAME/current-state-analysis.md` (if exists)
+          - Review existing project patterns and conventions
+
+          **STEP 2: Collaborate on Technical Approach**
+          - Use send_message to business-analyst: "Does this approach align with requirements?"
+          - Use send_message to developer: "Is this implementation strategy sound?"
+          - Wait for feedback and incorporate it
+
+          **STEP 3: Analyze Technical Context**
+          - Identify integration with existing system
+          - Map dependencies and integration points
+          - Choose appropriate technology stack
+          - Mark unknowns for research
+
+          **STEP 4: Create Plan**
+          Document in `$VIBE_DIR/specs/$BRANCH_NAME/plan.md`:
+          - High-level architecture
+          - Technology decisions
+          - Integration strategy
+          - Implementation phases
+
+          **STEP 5: Transition to Tasks**
+          - You remain RESPONSIBLE in tasks phase (continue driving technical work)
+          - Use send_message_to_operator: "Planning complete, moving to task breakdown"
+          - Call proceed_to_phase only when ready
+
+      # Developer is CONSULTED during plan phase
+      - trigger: 'plan_complete'
+        to: 'tasks'
+        role: developer
+        transition_reason: 'Plan completed, architect moving to tasks'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Architect is driving technical planning. You are in consultative mode.
+
+          **Monitor and Provide Feedback:**
+          - Check get_my_messages for questions from architect
+          - Assess implementation feasibility and complexity
+          - Discuss existing code patterns and conventions
+          - Identify potential technical challenges
+          - Suggest testing requirements and strategies
+
+          **Constraints:**
+          - Do NOT edit the plan file (architect has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for architect's questions
+          - Use send_message to provide honest implementation feedback
+          - Suggest alternative approaches if needed
+          - Raise concerns about technical risks
+
+      # For architectural_conflict loop
+      - trigger: 'architectural_conflict'
+        to: 'plan'
+        role: architect
+        transition_reason: 'Plan conflicts with existing architecture, needs revision'
+        additional_instructions: |
+          Resolve architectural conflicts by:
+          - Review how plan conflicts with existing architecture or principles
+          - Revise the approach to ensure proper integration
+
+  tasks:
+    description: 'Generate actionable, dependency-ordered tasks'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Architect is responsible. Business-analyst is informed. Developer is consulted.
+
+    transitions:
+      # Business Analyst is INFORMED during tasks phase
+      - trigger: 'tasks_generated'
+        to: 'implement'
+        role: business-analyst
+        transition_reason: 'Tasks generated, developer taking lead for implementation'
+        additional_instructions: |
+          **Monitor Progress as INFORMED Agent**
+
+          Architect is creating the task breakdown. You are in monitoring mode.
+
+          **Stay Aware:**
+          - Monitor task structure
+          - Prepare for consultation during implementation
+          - No active work required in this phase
+
+          **Get Ready for Next Phase:**
+          - Developer will take the lead in implement phase
+          - You will be CONSULTED during implementation
+          - Prepare to clarify requirements when developer asks
+
+      # Architect is RESPONSIBLE for tasks phase
+      - trigger: 'tasks_generated'
+        to: 'implement'
+        role: architect
+        transition_reason: 'Tasks generated, handing off to developer'
+        additional_instructions: |
+          **Drive the tasks phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Proceed to the next phase
+
+          **STEP 1: Load Design Documents**
+          - Required: `$VIBE_DIR/specs/$BRANCH_NAME/plan.md`, `$VIBE_DIR/specs/$BRANCH_NAME/spec.md`
+          - Optional: `$VIBE_DIR/specs/$BRANCH_NAME/technology-research.md`
+
+          **STEP 2: Extract User Stories**
+          - From spec.md with priorities (P1, P2, P3...)
+
+          **STEP 3: Generate Task Breakdown**
+          - Setup Phase: Integration and shared infrastructure
+          - Foundational Phase: Prerequisites for the feature
+          - User Story Phases (P1, P2, P3...): One phase per story
+          - Mark parallelizable tasks with `[P]`
+
+          **STEP 4: Collaborate with Developer**
+          - Use send_message to developer: "Please review task breakdown for implementability"
+          - Wait for feedback and adjust
+
+          **STEP 5: Create Documentation**
+          - `$VIBE_DIR/specs/$BRANCH_NAME/data-model.md`
+          - `$VIBE_DIR/specs/$BRANCH_NAME/contracts/` (API contracts)
+          - `$VIBE_DIR/specs/$BRANCH_NAME/quickstart.md`
+          - `$VIBE_DIR/specs/$BRANCH_NAME/tasks.md`
+
+          **STEP 6: Hand Off to Developer**
+          - Use send_message to developer: "Task breakdown complete. Please take the lead for implementation phase. See: `$VIBE_DIR/specs/$BRANCH_NAME/tasks.md`"
+          - Use send_message to business-analyst: "Implementation will begin, you'll be consulted for requirement clarifications"
+          - Use send_message_to_operator: "Tasks ready, handing off to developer"
+          - You transition to CONSULTED role in implement phase
+          - Call proceed_to_phase only when ready
+
+      # Developer is CONSULTED during tasks phase
+      - trigger: 'tasks_generated'
+        to: 'implement'
+        role: developer
+        transition_reason: 'Tasks generated, preparing to take lead for implementation'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Architect is creating the task breakdown. You are in consultative mode.
+
+          **Monitor and Provide Feedback:**
+          - Check get_my_messages for review requests from architect
+          - Assess task granularity and completeness
+          - Discuss implementation order and dependencies
+          - Provide complexity estimates
+          - Suggest testing approach
+
+          **Constraints:**
+          - Do NOT edit the plan file (architect has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Prepare for Your Leadership Role:**
+          When architect completes tasks phase, YOU become RESPONSIBLE:
+          - You will take the lead in the implement phase
+          - Review the tasks.md and prepare to begin implementation
+
+  implement:
+    description: 'Execute implementation following the task breakdown'
+    default_instructions: |
+      **Team Collaboration Mode**
+
+      You are `$VIBE_ROLE` working in a collaborative team on this feature development.
+
+      Developer is responsible. Architect and business-analyst are consulted.
+
+    transitions:
+      # Business Analyst is CONSULTED during implement phase
+      - trigger: 'implementation_complete'
+        to: 'implement'
+        role: business-analyst
+        transition_reason: 'Implementation complete'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Developer is driving implementation. You are in consultative mode.
+
+          **Monitor and Clarify:**
+          - Check get_my_messages for questions from developer
+          - Clarify requirements interpretation
+          - Explain user story acceptance criteria
+          - Document business rules and constraints
+          - Validate success criteria
+
+          **Constraints:**
+          - Do NOT edit the plan file (developer has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for developer's questions
+          - Use send_message to clarify requirements quickly
+          - Validate implementation against specification when asked
+          - Approve acceptance criteria when developer completes features
+
+      # Architect is CONSULTED during implement phase
+      - trigger: 'implementation_complete'
+        to: 'implement'
+        role: architect
+        transition_reason: 'Implementation complete'
+        additional_instructions: |
+          **Provide Consultation as CONSULTED Agent**
+
+          Developer is driving implementation. You are in consultative mode.
+
+          **Monitor and Provide Guidance:**
+          - Check get_my_messages for questions from developer
+          - Guide architecture decisions and patterns
+          - Discuss design patterns and best practices
+          - Address integration approaches
+          - Clarify technical trade-offs
+
+          **Constraints:**
+          - Do NOT edit the plan file (developer has exclusive control)
+          - Do NOT proceed to next phase
+
+          **Provide Value:**
+          - Use get_my_messages to check for developer's questions
+          - Use send_message to provide architecture guidance
+          - Review code against architecture plan when asked
+          - Help resolve technical blockers
+
+      # Developer is RESPONSIBLE for implement phase
+      - trigger: 'implementation_complete'
+        to: 'implement'
+        role: developer
+        transition_reason: 'Implementation complete, feature ready'
+        additional_instructions: |
+          **Drive the implement phase as the RESPONSIBLE agent.**
+
+          **Your Exclusive Permissions:**
+          - Edit the plan file
+          - Mark work as complete
+
+          **STEP 1: Execute Tasks**
+          - Follow task breakdown from `$VIBE_DIR/specs/$BRANCH_NAME/tasks.md`
+          - Work through tasks in order
+          - Mark completed tasks with `[x]` in plan file
+          - Focus on one user story at a time
+
+          **STEP 2: Collaborate When Needed**
+          - Use send_message to architect when design questions arise
+          - Use send_message to business-analyst when requirements unclear
+          - Wait for team responses to unblock your work
+
+          **STEP 3: Maintain Quality Standards**
+          - Follow existing code patterns
+          - Write tests for new functionality
+          - Ensure integration with existing system
+          - Handle errors appropriately
+
+          **STEP 4: Track Progress**
+          - Update plan file with completed tasks
+          - Document any deviations or decisions
+          - Keep implementation aligned with specification
+
+          **STEP 5: Final Validation Before Completion**
+          - Use send_message to architect: "Please review implementation against architecture plan"
+          - Use send_message to business-analyst: "Please validate implementation meets specification"
+          - Wait for their reviews and address any concerns
+          - Run all tests and ensure they pass
+          - Use send_message_to_operator: "Implementation complete and reviewed by team"
+          - This is a terminal state - feature is complete
+
+      # Implementation blocked - return to plan phase
+      - trigger: 'implementation_blocked'
+        to: 'plan'
+        role: developer
+        transition_reason: 'Implementation blocked, need to revise plan'
+        additional_instructions: |
+          Resolve blocking issues by:
+          - Use send_message to architect: "Implementation blocked: [explain issue]. Need to revise plan."
+          - Use send_message to business-analyst: "Implementation blocked, may need requirement changes: [explain]"
+          - Use send_message_to_operator: "Implementation blocked, returning to plan phase"
+          - Call proceed_to_phase - architect will take lead again in plan phase
+
+      # Integration issues - return to analyze
+      - trigger: 'integration_issues'
+        to: 'analyze'
+        role: developer
+        transition_reason: 'Integration issues require deeper system analysis'
+        additional_instructions: |
+          Resolve integration issues by:
+          - Use send_message to business-analyst: "Integration issues found: [explain]. Need deeper analysis."
+          - Use send_message to architect: "Integration problems require re-analysis: [explain]"
+          - Use send_message_to_operator: "Integration issues, returning to analyze phase"
+          - Call proceed_to_phase - business-analyst will take lead in analyze phase
+
+# Global transitions available from any state
+global_transitions:
+  - trigger: 'abandon_feature'
+    to: 'analyze'
+    transition_reason: 'Feature abandoned, restart from beginning'
+    additional_instructions: |
+      If you want to restart, begin again by analyzing the requirements and current state.