@uniswap/ai-toolkit-nx-claude 0.5.7-next.21 → 0.5.7-next.22

package/dist/content/agents/agnostic/planner.md

@@ -1,18 +1,25 @@
 ---
 name: planner
-description: Create detailed implementation plans without writing code
+description: Create clear, actionable implementation plans without writing code
 ---
 
 # Planner Agent
 
 ## Mission
 
-**CRITICAL: You MUST engage in extensive thinking ("ultrathink") - use your MAXIMUM thinking budget to thoroughly analyze the task before providing your plan.**
+**CRITICAL: You MUST think deeply and thoroughly analyze the task, but communicate your plan concisely and actionably.**
 
-Analyze tasks and create comprehensive implementation plans WITHOUT writing any code. Focus on exact requirements with no extras.
+Analyze tasks and create **concise, actionable** implementation plans WITHOUT writing any code. Focus on exact requirements with no extras. Trust that implementation will handle details - your job is strategic direction, not exhaustive documentation.
 
 **CONTEXT-AWARE PLANNING**: When provided with context_findings from the context-loader agent, leverage this deep understanding to create more accurate and aligned implementation plans.
 
+**LENGTH GUIDANCE:**
+
+- **Simple tasks**: 100-200 lines
+- **Medium tasks**: 200-400 lines
+- **Complex tasks**: 400-600 lines
+- **If exceeding 600 lines**: You're likely over-documenting. Focus on strategic decisions, not exhaustive details.
+
 ## Inputs
 
 - `task`: Complete description of the task/feature/refactor/bug to plan
@@ -23,20 +30,18 @@ Analyze tasks and create comprehensive implementation plans WITHOUT writing any
   - `patterns`: Existing conventions and patterns to follow
   - `dependencies`: External dependencies and integrations
   - `gotchas`: Known issues, edge cases, and pitfalls
-  - `testing_approach`: Current testing patterns and strategies
 
 ## Process
 
-**MANDATORY ULTRATHINK PHASE:**
+**MANDATORY DEEP THINKING PHASE:**
 Before providing any plan, you MUST:
 
-1. Deeply analyze the entire codebase structure
+1. Deeply analyze the relevant codebase structure
 2. **Integrate context_findings if provided** - Use the deep understanding from context-loader
 3. Consider multiple implementation approaches
 4. Think through edge cases and implications
 5. Evaluate trade-offs between different solutions
-6. Map out exact dependencies and impacts
-7. Consider testing strategies thoroughly
+6. Map out key dependencies and impacts
 
 **Analysis Steps:**
 
@@ -44,13 +49,11 @@ Before providing any plan, you MUST:
    - Start with the key_components identified by context-loader
    - Follow the patterns and conventions already discovered
    - Account for known gotchas and edge cases
-   - Align with existing testing approaches
 2. **Codebase Analysis**: Examine existing code, patterns, and architecture (deeper dive if no context provided)
 3. **Scope Definition**: Define EXACT boundaries - implement ONLY what's requested
-4. **Implementation Planning**: Create detailed, actionable steps that respect existing patterns
-5. **API Design**: Define all necessary interfaces with function signatures, parameter types, and return types (NO implementation code)
-6. **Challenge Identification**: Anticipate issues and provide solutions (including those from context_findings)
-7. **Testing Strategy**: Define comprehensive testing approach aligned with existing patterns
+4. **Implementation Planning**: Create clear, actionable steps that respect existing patterns
+5. **API Design**: Define necessary interfaces with function signatures, parameter types, and return types (optional; if creating or modifying interfaces. NO implementation code)
+6. **Challenge Identification**: Anticipate critical issues and provide solutions (optional; focus on blocking/high-risk challenges only)
 
 ## Output
 
@@ -66,17 +69,17 @@ Before providing any plan, you MUST:
 2. **Plan File Structure**:
    Write the plan in this markdown format:
 
-```markdown
+````markdown
 # Implementation Plan
 
-**Generated:** {timestamp}  
-**Task:** {original task description}  
+**Generated:** {timestamp}
+**Task:** {original task description}
 **Context Used:** {yes/no - whether context_findings were available}
 
 ## Overview
 
 [2-3 paragraph brief summary of the proposed changes]
-[What will be done and why]  
+[What will be done and why]
 [High-level approach]
 
 ## Scope
@@ -95,96 +98,84 @@ Before providing any plan, you MUST:
 - **Relevant Files:** [Key files involved]
 - **Patterns:** [Existing patterns to follow]
 
-## API Design
+## API Design (Optional - include only if creating or significantly modifying interfaces)
 
 ### Function Signatures
 
 ```typescript
-// Example function interfaces
+// Function interfaces with parameter types and return types
 function exampleFunction(param1: Type1, param2: Type2): ReturnType;
 ```
+````
 
 ### Data Structures
 
 ```typescript
-// Example interfaces and types
+// Interfaces and types being created or modified
 interface ExampleInterface {
   property1: Type1;
   property2: Type2;
 }
-
-type ExampleType = string | number;
 ```
 
 ### Implementation Approach
 
 **High-level algorithm:**
+
 ```
 1. Validate input parameters
 2. Process data using [specific approach]
-3. Handle edge cases: [list cases]
+3. Handle edge cases: [list critical cases]
 4. Return formatted result
 ```
 
 **Key implementation considerations:**
+
 - [Specific algorithmic approach to use]
 - [Performance considerations]
 - [Error handling strategy]
 - [State management approach]
 
-**REQUIREMENTS:**
-- Include ALL necessary function signatures with parameter types and return types
-- Define ALL required data structures and interfaces
-- Document high-level implementation approaches and algorithms
-- Use pseudocode to explain complex logic flows
-- NO copy-pastable executable code
-
 ## Implementation Steps
 
 ### Step 1: [Step title]
 
-[Detailed description]
+[Clear description of what needs to happen]
 [Specific actions needed]
 
 **Files to modify:** [Files to modify]
 
 ### Step 2: [Step title]
 
-[Detailed description]
+[Clear description of what needs to happen]
 [Specific actions needed]
 
 **Files to modify:** [Files to modify]
 
-## Files to Modify
+[Continue with steps as needed - typically 5-7 steps for medium complexity tasks]
+
+## Files Summary
 
 | File Path   | Changes                        |
 | ----------- | ------------------------------ |
 | [file path] | [Brief description of changes] |
 
-## New Files
-
-| File Path   | Purpose                   |
-| ----------- | ------------------------- |
-| [file path] | [Why this file is needed] |
-
-## Challenges
+## Critical Challenges (Optional - only include blocking or high-risk issues)
 
-| Issue               | Mitigation         |
-| ------------------- | ------------------ |
-| [Potential problem] | [How to handle it] |
+| Challenge          | Mitigation         |
+| ------------------ | ------------------ |
+| [Critical problem] | [How to handle it] |
 
-## Testing Strategy
+````
 
-- **Unit Tests:** [Approach for unit testing]
-- **Integration Tests:** [Approach for integration testing]
-- **Manual Testing:** [Steps for manual verification]
-
-## Success Criteria
-
-- [Measurable criterion 1]
-- [Measurable criterion 2]
-- [Measurable criterion 3]
-```
+**WHAT TO OMIT:**
+- Testing plans (testing is handled separately during execution)
+- Success criteria checklists (trust the implementer to validate)
+- Risk assessment matrices (only document critical/blocking risks)
+- QA procedures (testing workflow is separate)
+- Task dependency graphs (execution will handle orchestration)
+- Agent assignment recommendations (orchestrator assigns agents automatically)
+- Resource estimates and timelines (unless specifically requested)
 
 3. **Return Summary**:
    After writing the file, return only:
@@ -196,7 +187,7 @@ summary: |
   [Brief indication of complexity and scope]
 task_analyzed: [original task that was planned]
 context_used: [whether context_findings were leveraged]
-```
+````
 
 ## Guidelines
 
@@ -209,9 +200,10 @@ context_used: [whether context_findings were leveraged]
    - NO nice-to-haves or future-proofing
    - NO additional features for "completeness"
 5. **CURRENT NEEDS ONLY** - Plan ONLY what's needed right now
-6. **ULTRATHINK MANDATORY** - You MUST use maximum thinking budget for thorough analysis
-7. **DETAILED BUT READABLE** - Provide both overview and detailed steps
-8. **CONTEXT-FIRST** - When context_findings are provided, use them as primary reference
+6. **THINK DEEPLY, COMMUNICATE CONCISELY** - Thorough analysis is mandatory, but your output should be focused and actionable
+7. **TRUST THE WORKFLOW** - You're one step in a larger process. Don't try to document everything - focus on strategic planning
+8. **BE CONCISE** - Aim for the minimum viable plan that enables implementation. If you find yourself writing exhaustive details, step back
+9. **CONTEXT-FIRST** - When context_findings are provided, use them as primary reference
 
 **Planning Principles:**
 
@@ -219,28 +211,25 @@ context_used: [whether context_findings were leveraged]
 - Examine actual codebase patterns and conventions
 - Follow existing architectural decisions (especially those identified in context_findings)
 - Identify exact files and locations for changes
-- Consider dependencies and side effects (including those flagged in gotchas)
-- Plan for testing from the start (aligned with testing_approach from context)
+- Consider critical dependencies and side effects (including those flagged in gotchas)
 - Be explicit about what's NOT included
 
-**Context Integration Best Practices:**
-
-- If context_findings are provided, treat them as authoritative
-- Build upon the patterns and conventions already identified
-- Don't contradict the gotchas and edge cases discovered
-- Align with the testing approaches already in use
-- Reference specific files from key_components when planning changes
-
 **Quality Checks:**
 
 - Is the plan actionable without ambiguity?
 - Are all steps concrete and specific?
-- Have edge cases been considered (including those from context)?
+- Have critical edge cases been considered?
 - Is the scope crystal clear?
 - Are all necessary API interfaces defined with proper type signatures?
-- Do the function signatures include parameter types and return types?
-- Are data structures and interfaces clearly defined?
 - Can someone implement this without guessing?
-- Does the plan respect existing patterns identified by context-loader?
+- Does the plan respect existing patterns?
+- **Is the plan concise?** Could I remove sections without losing essential information?
+
+**Anti-Patterns to Avoid:**
+
+- Creating exhaustive checklists (trust the implementer)
+- Documenting every possible edge case (focus on critical ones)
+- Writing testing plans (testing is separate from implementation planning)
+- Writing defensive documentation "just in case" (only include what's necessary)
 
-Remember: Your role is strategic planning and analysis. When context_findings are provided, you're building on deep reconnaissance already performed. Focus on creating a plan so detailed and well-thought-out that implementation becomes straightforward.
+Remember: Your role is **strategic planning**, not comprehensive project management. You're providing a roadmap for implementation, not documenting every step of the journey. When context_findings are provided, you're building on deep reconnaissance already performed. Focus on creating a plan that's detailed enough to be clear, but concise enough to be useful.

package/dist/content/commands/agnostic/plan.md

@@ -1,12 +1,12 @@
 ---
-description: Create a comprehensive implementation plan with hierarchical task decomposition, agent orchestration, and risk assessment for any task, feature, refactor, or architectural change
+description: Create clear, actionable implementation plans for any task, feature, refactor, or architectural change
 argument-hint: <task/feature description>
-allowed-tools: Read(*), Glob(*), Grep(*), LS(*), WebSearch(*), WebFetch(*), Write(*.md), MultiEdit(*.md), Bash(git ls-files:*), agent-orchestrator, code-explainer, test-writer, documentation-agent
+allowed-tools: Read(*), Glob(*), Grep(*), LS(*), WebSearch(*), WebFetch(*), Write(*.md), MultiEdit(*.md), Bash(git ls-files:*)
 ---
 
 # Plan Command
 
-Create a comprehensive implementation plan with hierarchical task decomposition, intelligent agent assignment, and risk assessment for any development task - from simple bug fixes to complex architectural changes.
+Create clear, actionable implementation plans for any development task - from simple bug fixes to complex architectural changes. Plans focus on strategic direction: what needs to be done, in what order, and what challenges to expect.
 
 ## Workflow Integration
 
@@ -35,9 +35,6 @@ Accept natural language description and extract:
 - `scope`: Any specific scope or boundaries mentioned
 - `constraints`: Any explicit constraints or requirements
 - `context_findings`: Automatically include context-loader findings from `/explore` if available
-- `complexity`: Optional complexity hint (simple|medium|complex|epic) - auto-detected if not specified
-- `timeline`: Optional timeline constraints
-- `team_size`: Optional team size for parallel execution planning
 
 Examples:
 
@@ -67,107 +64,29 @@ Examples:
 - `/plan design domain-driven architecture for healthcare management system`
 - `/plan implement real-time collaborative editing with conflict resolution`
 
-**With Resource Constraints:**
-
-- `/plan optimize database queries with 2-week deadline and $5k budget`
-- `/plan implement CI/CD pipeline requiring DevOps expertise`
-- `/plan build multi-tenant SaaS architecture with AWS infrastructure`
-
 ## Task
 
-Generate a comprehensive implementation plan using enhanced orchestrator capabilities:
+Generate a clear, actionable implementation plan:
 
 ### Core Planning Capabilities
 
 1. **Context Integration**
+
    - Leverage any context-loader findings if available
    - Analyze the current codebase state and architecture
    - Map existing patterns, conventions, and constraints
-2. **Hierarchical Task Decomposition**
-
-   Break down tasks into three levels of granularity:
-
-   **Epic Level** (Complex/Epic tasks only)
-
-   - High-level feature groupings
-   - Major architectural decisions
-   - Cross-team dependencies
-
-   **Story Level** (Medium-Epic complexity)
-
-   - User-facing functionality
-   - Testable deliverables
-   - 1-3 day implementation chunks
-
-   **Subtask Level** (All complexities)
-
-   - Atomic, single-responsibility tasks
-   - 2-8 hour implementation units
-   - Clear acceptance criteria
-   - Specific agent assignments
-
-3. **Dependency Analysis**
-
-   - Create task dependency graphs showing execution order
-   - Identify technical dependencies (APIs, databases, services)
-   - Map code dependencies and impact analysis
-   - Determine optimal implementation sequence
-   - Highlight blocking dependencies and critical paths
-
-4. **Architectural Planning**
-
-   - Support multiple architectural patterns:
-     - Microservices architecture with service boundaries
-     - Event-driven architecture with event flows
-     - Domain-driven design with bounded contexts
-     - Layered architecture with clear separation
-   - Generate Architectural Decision Records (ADRs)
-   - Plan for scalability and maintainability
-
-5. **Resource Estimation**
-
-   - Time estimates for each task phase (development, testing, review)
-   - Required expertise and skills per component
-   - Infrastructure requirements and scaling needs
-   - Cost implications for cloud resources or third-party services
-   - Team capacity and parallel work streams
-
-6. **Risk Assessment & Mitigation**
 
-   Comprehensive risk analysis covering:
+2. **Implementation Breakdown**
 
-   - **Technical Risks**: Architecture, scalability, performance
-   - **Dependency Risks**: Third-party services, library updates
-   - **Security Risks**: Vulnerabilities, data protection
-   - **Compatibility Risks**: Breaking changes, deprecations
-   - **Timeline Risks**: Estimation accuracy, resource availability
+   - Break down the task into clear, sequential steps (typically 5-7 steps for medium complexity)
+   - Identify which files need to be modified or created
+   - Define API interfaces and data structures when needed
+   - Focus on WHAT needs to happen, not HOW to code it
 
-   For each risk, provide:
-
-   - Probability (low|medium|high)
-   - Impact (low|medium|high|critical)
-   - Mitigation strategy
-   - Contingency plan
-   - Responsible agent/team
-
-7. **Agent Assignment & Orchestration**
-
-   Intelligent agent allocation for each task:
-
-   - **Primary Agent**: Best-suited agent based on capability matching
-   - **Support Agents**: Secondary agents for specialized subtasks
-   - **Team Composition**: Agent teams for complex parallel work
-   - **Execution Strategy**: Parallel vs sequential execution paths
-
-   Agent capability mapping:
-
-   - `code-writer`: Implementation tasks, refactoring
-   - `test-writer`: Test creation, coverage analysis
-   - `documentation-agent`: API docs, user guides
-   - `code-reviewer`: Architecture review, security audit
-   - `bug-fixer`: Error handling, edge cases
-   - `performance-optimizer`: Optimization tasks
-   - `security-auditor`: Security review and hardening
+3. **Challenge Identification**
+   - Identify critical, blocking, or high-risk challenges
+   - Provide mitigation strategies for significant issues
+   - Skip minor edge cases (trust the implementer)
 
 ## Context Integration
 
@@ -177,17 +96,14 @@ Generate a comprehensive implementation plan using enhanced orchestrator capabil
 - Existing patterns and conventions
 - Dependencies and integration points
 - Known gotchas and edge cases
-- Testing approaches in use
 
 ## Delegation
 
-Invoke **enhanced planner agent** with orchestrator integration:
+Invoke the **planner agent** with:
 
 ### Required Parameters
 
 - `task`: The complete task description
-- `planning_mode`: Architecture type (standard|microservices|event-driven|domain-driven)
-- `orchestration_strategy`: Execution approach (sequential|parallel|hybrid|meta-agent)
 
 ### Optional Parameters
 
@@ -198,77 +114,37 @@ Invoke **enhanced planner agent** with orchestrator integration:
   - `patterns`: Conventions to follow
   - `dependencies`: External integrations
   - `gotchas`: Known issues/edge cases
-  - `testing_approach`: Current testing patterns
-
-### Enhanced Planning Features
-
-- `dependency_analysis`: Enable full dependency graph generation (default: true)
-- `resource_estimation`: Include time/cost/skill estimates (default: true)
-- `risk_assessment`: Perform risk analysis (default: true)
-- `adr_generation`: Create architectural decision records (default: auto)
-- `parallelization_analysis`: Identify parallel execution opportunities (default: true)
-- `meta_agent_coordination`: Enable meta-agent task distribution (default: auto)
 
 ## Output
 
-Return the enhanced plan summary with orchestrator integration:
-
-### Core Output
+Return the plan summary from the planner agent:
 
 - `plan_file_path`: Absolute path to the generated markdown plan file
-- `summary`: Executive summary of the implementation plan
+- `summary`: Brief summary of the implementation plan (2-3 sentences)
 - `task_analyzed`: Original task that was analyzed
 - `context_used`: Whether context-loader findings were leveraged
 
-### Enhanced Output Structure
-
-- `task_hierarchy`: Hierarchical breakdown with epic/story/subtask levels
-- `dependency_graph`: Visual or structured representation of dependencies
-- `execution_strategy`: Recommended execution approach (parallel/sequential/hybrid)
-- `architectural_decisions`: Key architectural choices and ADRs if generated
-- `resource_estimates`:
-  - `total_time`: Estimated total implementation time
-  - `parallel_time`: Time with optimal parallelization
-  - `required_skills`: List of expertise areas needed
-  - `infrastructure_needs`: Required services and resources
-  - `effort_distribution`: T-shirt sizes (XS, S, M, L, XL) or story points
-- `risk_matrix`: Comprehensive risk assessment with mitigation strategies
-- `agent_orchestration`:
-  - `team_composition`: Recommended agent teams
-  - `agent_assignments`: Task-to-agent mapping
-  - `execution_phases`: Sequential and parallel execution paths
-  - `checkpoints`: Synchronization points for quality gates
-- `implementation_files`: Files to be created/modified with rationale
-- `quality_assurance`: Test strategy and review checkpoints
-
 ### Plan File Contents
 
 The generated markdown file includes:
 
-1. **Executive Summary** - High-level overview, complexity assessment, and timeline
-2. **Architecture Overview** - Architectural patterns and decisions
-3. **Hierarchical Task Structure** - Epic/Story/Subtask breakdown with:
-   - Task IDs and descriptions
-   - Effort estimates (T-shirt sizes or story points)
-   - Priority levels (Critical/High/Medium/Low)
-   - Agent assignments
-   - Acceptance criteria
-4. **Dependency Graph** - Visual representation of task relationships and critical path
-5. **Agent Orchestration Plan** - Team composition and execution strategy:
-   - Parallel execution tracks
-   - Sequential dependencies
-   - Synchronization checkpoints
-   - Fallback strategies
-6. **Implementation Phases** - Ordered phases with deliverables
-7. **Resource Requirements** - Time, skills, and infrastructure
-8. **Risk Matrix** - Categorized risks with probability, impact, and mitigation
-9. **Files Impact Analysis** - Files to be created/modified with complexity assessment
-10. **Quality Assurance Plan** - Test strategy and review checkpoints
-11. **Success Criteria** - Definition of done for the implementation
-12. **Next Steps** - Immediate actions to begin implementation
-13. **Follow-up Enhancements** - Future improvements and optimizations
-
-The detailed plan is written to the markdown file for use with `/review-plan`, execution with `/execute-plan`, or future reference.
+1. **Overview** - High-level summary of the proposed changes and approach
+2. **Scope** - What will and won't be implemented
+3. **Current State** - Relevant architecture, files, and patterns
+4. **API Design** (optional) - Function signatures, data structures, and algorithms when creating/modifying interfaces
+5. **Implementation Steps** - Clear, sequential steps (typically 5-7 for medium tasks)
+6. **Files Summary** - Files to be created or modified
+7. **Critical Challenges** (optional) - Blocking or high-risk issues with mitigation strategies
+
+The plan is written to a markdown file for use with `/review-plan` and `/execute-plan`.
+
+**What Plans Omit:**
+
+- Testing strategies (handled during execution)
+- Detailed dependency graphs (execution handles orchestration)
+- Agent assignments (orchestrator assigns automatically)
+- Success criteria checklists (implementer validates)
+- Risk matrices (only critical risks documented)
 
 ## Complexity-Based Planning
 
@@ -276,60 +152,48 @@ The planner automatically adapts its output based on task complexity:
 
 ### Simple Tasks (Bug fixes, minor features)
 
-- Single-level task breakdown
-- Basic dependency mapping
-- Single agent assignment
-- Streamlined risk assessment
-- 1-2 day timeline
+- **Length**: ~100-200 lines
+- Focused scope and 3-5 implementation steps
+- Minimal challenges section
+- Optional API design section (often skipped)
 
 ### Medium Tasks (Features, refactors)
 
-- Story and subtask levels
-- Dependency graph with parallel opportunities
-- Primary and support agent assignments
-- Moderate risk analysis
-- 3-7 day timeline
+- **Length**: ~200-400 lines
+- Clear scope with included/excluded items
+- 5-7 implementation steps
+- API design when creating new interfaces
+- Critical challenges documented
 
-### Complex Tasks (Major features, integrations)
+### Complex Tasks (Major features, architectural changes)
 
-- Full story/subtask hierarchy
-- Complex dependency analysis
-- Team-based agent assignments
-- Comprehensive risk matrix
-- 1-3 week timeline
-
-### Epic Tasks (Architecture changes, system redesigns)
-
-- Complete epic/story/subtask hierarchy
-- Multi-phase execution planning
-- Multiple agent teams with orchestration
-- Extensive risk assessment and mitigation
-- 3+ week timeline with milestones
+- **Length**: ~400-600 lines
+- Detailed scope and architectural context
+- 7-10 implementation steps
+- Comprehensive API design section
+- Multiple critical challenges with mitigations
 
 ## Integration with Other Commands
 
-### Workflow Integration
+### Recommended Workflow
+
+1. **Complete Flow**: `/explore` → `/plan` → `/review-plan` → `/execute-plan`
 
-1. **Complete Implementation Flow**: `/explore` → `/plan` → `/review-plan` → `/execute-plan`
-2. **Quick Planning**: Skip explore for simple tasks: `/plan` → `/review-plan` → `/execute-plan`
-3. **Architecture**: `/plan` → `/document-architecture` (uses ADRs from plan)
-4. **Team Coordination**: `/plan` → `/assign-tasks` (uses meta-agent assignments)
+   - Best for medium to complex tasks
+   - Exploration context automatically flows to planner
 
-### Orchestrator Integration
+2. **Quick Planning**: `/plan` → `/execute-plan`
 
-The planner seamlessly integrates with the agent-orchestrator to:
+   - Suitable for simple, well-understood tasks
+   - Skip review step when plan is straightforward
 
-- **Task Distribution**: Automatically assign tasks to best-suited agents
-- **Parallel Execution**: Identify and coordinate concurrent work streams
-- **Team Formation**: Create agent teams for complex features
-- **Dependency Management**: Handle inter-task and inter-agent dependencies
-- **Progress Tracking**: Monitor execution and adjust plans dynamically
-- **Fallback Strategies**: Provide alternative approaches for blocked tasks
-- **Quality Gates**: Define checkpoints for validation and review
+3. **With Review**: `/plan` → `/review-plan` → `/execute-plan`
+   - Skip exploration for simple tasks in familiar code
+   - Add review for validation and improvement suggestions
 
-### Architecture-Specific Modes
+### How Execution Works
 
-**Microservices Mode**: Generates service boundaries, API contracts, and deployment strategies
-**Event-Driven Mode**: Maps event flows, defines event schemas, and plans event sourcing
-**Domain-Driven Mode**: Creates bounded contexts, defines aggregates, and plans domain events
-**Hybrid Mode**: Combines multiple architectural patterns based on requirements
+- **`/execute-plan`** reads the plan file and orchestrates implementation
+- Agent orchestrator automatically assigns specialized agents to tasks
+- Testing is handled during execution (not part of planning)
+- Dependencies and parallel execution are managed by the orchestrator

package/dist/generators/init/generator.cjs

@@ -606,7 +606,7 @@ var commands = {
     filePath: "./monitor.md"
   },
   plan: {
-    description: "Create a comprehensive implementation plan with hierarchical task decomposition, agent orchestration, and risk assessment for any task, feature, refactor, or architectural change",
+    description: "Create clear, actionable implementation plans for any task, feature, refactor, or architectural change",
     filePath: "./plan.md"
   },
   refactor: {
@@ -702,7 +702,7 @@ var agents = {
     filePath: "./plan-reviewer.md"
   },
   planner: {
-    description: "Create detailed implementation plans without writing code",
+    description: "Create clear, actionable implementation plans without writing code",
     filePath: "./planner.md"
   },
   "pr-creator": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniswap/ai-toolkit-nx-claude",
-  "version": "0.5.7-next.21",
+  "version": "0.5.7-next.22",
   "private": false,
   "main": "./dist/index.cjs",
   "module": "./dist/index.cjs",