@uniswap/ai-toolkit-nx-claude 0.5.9 → 0.5.10-next.1

package/dist/content/agents/agnostic/commit-message-generator.md

@@ -1,7 +1,7 @@
 ---
 name: commit-message-generator
 description: Generate well-structured git commit messages that clearly communicate the WHAT and WHY of code changes. Your messages should help future developers (including the author) understand the purpose and context of the commit.
-model: sonnet-4
+model: sonnet-4.5
 ---
 
 # commit-message-generator Agent

package/dist/content/agents/agnostic/pr-creator.md

@@ -1,7 +1,7 @@
 ---
 name: pr-creator
 description: Creates or updates Graphite PRs with auto-generated conventional commit messages and comprehensive PR descriptions based on diffs
-model: sonnet-4
+model: sonnet-4.5
 ---
 
 You are a Graphite PR management specialist who creates and updates pull requests with well-crafted conventional commit messages and informative PR descriptions.

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

@@ -1,12 +1,13 @@
 ---
-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:*)
+description: Create clear, actionable implementation plans for any task, feature, refactor, or architectural change through collaborative multi-agent refinement
+argument-hint: <task/feature description or plan file path>
+allowed-tools: Read(*), Glob(*), Grep(*), LS(*), Task(*), WebSearch(*), WebFetch(*), Write(*.md), MultiEdit(*.md), Bash(git ls-files:*), Bash(mkdir:*)
+model: claude-sonnet-4-5-20250929
 ---
 
 # Plan Command
 
-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.
+Create clear, actionable implementation plans through collaborative multi-agent discussion. Plans are refined through expert consensus, constructive disagreement, and cross-domain collaboration to ensure comprehensive coverage and high-quality implementation strategy.
 
 ## Workflow Integration
 
@@ -19,19 +20,53 @@ This command is **Step 2** of the implementation workflow:
 **BEST PRACTICE: Use this command AFTER running `/explore` for optimal results**
 
 1. First: `/explore <relevant area>` - Builds comprehensive context
-2. Then: `/plan <task>` - Creates plan using that context automatically
+2. Then: `/plan <task>` - Creates plan through collaborative refinement
 3. Next: `/review-plan <plan-file>` - Review and validate the plan
 4. Finally: `/execute-plan <plan-file>` - Executes the approved implementation
 
 This four-step process ensures optimal understanding, planning, validation, and execution.
 
-**Note for Claude Code**: When you have context-loader findings from a previous `/explore` command, automatically pass them to the planner agent. The user doesn't need to specify any flags.
+**Note for Claude Code**: When you have context-loader findings from a previous `/explore` command, automatically pass them to the planning process. The user doesn't need to specify any flags.
+
+## Overview
+
+This command takes a task description or existing plan and orchestrates a collaborative refinement process using 3-10 specialized agents selected based on the plan's context and requirements.
+
+**Key Features:**
+
+- **Intelligent Agent Selection**: Automatically identifies and selects 3-10 specialized agents based on plan context
+- **True Collaboration**: Agents engage in multi-round discussions, building on each other's feedback
+- **Constructive Disagreement**: Agents respectfully challenge ideas and propose alternatives
+- **Consensus Building**: Multiple discussion rounds lead to a refined, consensus-based final plan
+- **Expert Emulation**: Mimics how human experts would collaboratively refine a plan
+- **Context Integration**: Leverages findings from `/explore` command automatically
 
 ## Inputs
 
-Accept natural language description and extract:
+Accept natural language description or file path to existing plan:
+
+**Description-based:**
+
+```
+/plan add user authentication with JWT tokens
+/plan implement real-time notifications using WebSockets
+/plan migrate monolith to microservices
+/plan implement real-time collaborative editing with CRDT
+/plan optimize database queries for the user dashboard
+```
+
+**File-based (for refining existing plans):**
+
+```
+/plan /tmp/plans/plan-20250821-a4b3c2.md
+/plan plans/user-auth-implementation.md
+```
+
+Extract:
 
-- `task`: The full description of what needs to be implemented/fixed/refactored
+- `plan_input`: Either file path or description
+- `is_file`: Boolean indicating if input is a file path
+- `plan_content`: The actual plan content (read from file or use description directly)
 - `scope`: Any specific scope or boundaries mentioned
 - `constraints`: Any explicit constraints or requirements
 - `context_findings`: Automatically include context-loader findings from `/explore` if available
@@ -66,77 +101,131 @@ Examples:
 
 ## Task
 
-Generate a clear, actionable implementation plan:
+Execute a structured collaborative refinement process:
 
-### Core Planning Capabilities
+### Phase 1: Context Understanding & Agent Selection
 
-1. **Context Integration**
+1. **Analyze Plan Context**
 
-   - Leverage any context-loader findings if available
-   - Analyze the current codebase state and architecture
-   - Map existing patterns, conventions, and constraints
+   - If file provided, read and analyze the plan document
+   - If description provided, understand the high-level goals and requirements
+   - Leverage any context-loader findings from `/explore` if available
+   - Identify key technical domains (e.g., frontend, backend, database, security, performance)
+   - Identify complexity factors (e.g., distributed systems, real-time features, data migration)
+   - Identify architectural concerns (e.g., scalability, reliability, maintainability)
 
-2. **Implementation Breakdown**
+2. **Select Specialized Agents** (3-10 agents)
 
-   - 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
+   Query available agents and select based on:
 
-3. **Challenge Identification**
-   - Identify critical, blocking, or high-risk challenges
-   - Provide mitigation strategies for significant issues
-   - Skip minor edge cases (trust the implementer)
+   - **Domain Relevance**: Match agent capabilities to technical domains in the plan
+   - **Perspective Diversity**: Include different viewpoints (architecture, security, performance, testing, DevOps, etc.)
+   - **Complexity Alignment**: More complex plans warrant more agents
 
-## Context Integration
+   **Selection Guidelines:**
 
-**Claude Code**: When you have findings from a previous `/explore` command, automatically extract and pass:
+   - **Simple plans** (bug fixes, minor features): 3-4 agents
+   - **Medium plans** (features, refactors): 5-7 agents
+   - **Complex plans** (architecture changes, major features): 8-10 agents
 
-- Key components and their responsibilities
-- Existing patterns and conventions
-- Dependencies and integration points
-- Known gotchas and edge cases
+   **Example Agent Combinations:**
 
-## Delegation
+   _For "migrate monolith to microservices":_
 
-Invoke the **planner agent** with:
+   - backend-architect (system design)
+   - cloud-architect (infrastructure)
+   - database-optimizer (data architecture)
+   - performance-engineer (scalability)
+   - devops-troubleshooter (deployment)
+   - security-auditor (service boundaries)
 
-### Required Parameters
+   _For "implement real-time collaborative editing":_
 
-- `task`: The complete task description
+   - frontend-developer (UI/state management)
+   - backend-architect (API design)
+   - performance-engineer (optimization)
+   - database-optimizer (conflict resolution)
+   - security-auditor (data integrity)
 
-### Optional Parameters
+3. **Brief Each Agent**
+   - Provide full plan content/description to each selected agent
+   - Include context-loader findings from `/explore` if available
+   - Request each agent to analyze from their specialized perspective
+   - Ask agents to prepare initial feedback focusing on their domain
 
-- `scope`: Extracted scope/boundaries
-- `constraints`: Any specific constraints or requirements
-- `context_findings`: Structured findings from context-loader if available:
-  - `key_components`: Core files and responsibilities
-  - `patterns`: Conventions to follow
-  - `dependencies`: External integrations
-  - `gotchas`: Known issues/edge cases
+### Phase 2: Multi-Round Collaborative Discussion
 
-## Output
+**Round 1: Initial Perspectives**
+
+1. Invoke each agent in parallel with the plan and ask for:
+
+   - Initial assessment from their specialized perspective
+   - Key concerns or risks they identify
+   - Suggestions for improvement in their domain
+   - Questions for other specialists
+
+2. Synthesize all initial feedback into a structured summary
+
+**Round 2: Cross-Domain Discussion**
+
+1. Share Round 1 feedback with all agents
+2. Invoke agents again (in parallel or sequentially based on dependencies) asking them to:
+
+   - Respond to feedback from other agents
+   - Identify areas of agreement and disagreement
+   - Propose solutions to concerns raised by others
+   - Refine their own recommendations based on peer input
+   - Respectfully challenge ideas when they see potential issues
+
+3. Look for:
+   - **Consensus areas**: Where agents agree
+   - **Disagreements**: Where agents have conflicting views
+   - **Gaps**: Issues not yet addressed by any agent
+   - **Synergies**: How different agents' suggestions complement each other
 
-Return the plan summary from the planner agent:
+**Round 3: Consensus Building** (if needed)
 
-- `plan_file_path`: Absolute path to the generated markdown plan file
-- `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
+If significant disagreements remain:
 
-### Plan File Contents
+1. Identify the key points of contention
+2. Invoke specific agents involved in disagreements
+3. Ask them to:
+   - Find middle ground or propose compromises
+   - Evaluate trade-offs explicitly
+   - Consider the full system perspective beyond their domain
+4. Work toward resolution of major conflicts
 
-The generated markdown file includes:
+### Phase 3: Final Plan Synthesis
 
-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
+1. **Integrate Feedback**
 
-The plan is written to a markdown file for use with `/review-plan` and `/execute-plan`.
+   - Compile all agent feedback across rounds
+   - Identify consensus recommendations
+   - Document remaining trade-offs and decisions needed
+   - Organize feedback by category (architecture, implementation, testing, deployment, etc.)
+
+2. **Generate Final Plan**
+
+   Create a comprehensive implementation plan that includes:
+
+   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
+   8. **Agent Collaboration Summary**:
+      - List of agents involved and their focus areas
+      - Key consensus recommendations by category
+      - Design decisions and trade-offs
+      - Open questions requiring human decision
+      - Dissenting opinions (important disagreements with rationale)
+
+3. **Output Format**
+   - Write plan to markdown file: `./.claude-output/plan-[timestamp]-[hash].md`
+   - Include conversation transcript (summarized) showing agent discussions
+   - Highlight areas of strong consensus vs. areas needing human judgment
 
 **What Plans Omit:**
 
@@ -153,6 +242,8 @@ The planner automatically adapts its output based on task complexity:
 ### Simple Tasks (Bug fixes, minor features)
 
 - **Length**: ~100-200 lines
+- **Agents**: 3-4 specialized agents
+- **Rounds**: 1-2 discussion rounds
 - Focused scope and 3-5 implementation steps
 - Minimal challenges section
 - Optional API design section (often skipped)
@@ -160,6 +251,8 @@ The planner automatically adapts its output based on task complexity:
 ### Medium Tasks (Features, refactors)
 
 - **Length**: ~200-400 lines
+- **Agents**: 5-7 specialized agents
+- **Rounds**: 2-3 discussion rounds
 - Clear scope with included/excluded items
 - 5-7 implementation steps
 - API design when creating new interfaces
@@ -168,11 +261,105 @@ The planner automatically adapts its output based on task complexity:
 ### Complex Tasks (Major features, architectural changes)
 
 - **Length**: ~400-600 lines
+- **Agents**: 8-10 specialized agents
+- **Rounds**: 2-3 discussion rounds
 - Detailed scope and architectural context
 - 7-10 implementation steps
 - Comprehensive API design section
 - Multiple critical challenges with mitigations
 
+## Agent Discussion Guidelines
+
+To emulate realistic expert collaboration:
+
+### Encourage Agents To
+
+- **Be Direct**: State opinions clearly without over-hedging
+- **Challenge Constructively**: Disagree when they see issues, but propose alternatives
+- **Build On Ideas**: Reference and expand on other agents' suggestions
+- **Ask Questions**: Seek clarification from other agents
+- **Change Positions**: Update views when presented with good arguments
+- **Acknowledge Limits**: Recognize when an issue is outside their expertise
+
+### Discussion Prompts
+
+- "Agent X raised concerns about [Y]. What's your perspective on this?"
+- "How would your domain be affected by Agent X's suggestion to [Y]?"
+- "Agent X and Agent Y disagree about [Z]. Can you provide a third perspective?"
+- "Are there any trade-offs in Agent X's proposal that we haven't considered?"
+
+### Realistic Disagreement Examples
+
+- Security agent wants encryption everywhere; Performance agent warns of latency impact
+- Backend architect prefers microservices; DevOps engineer concerned about operational complexity
+- Frontend developer wants rich interactivity; Performance engineer pushes for progressive enhancement
+
+## Output
+
+Return a structured summary and file path:
+
+```markdown
+## Implementation Plan Complete
+
+**Plan File**: [./.claude-output/plan-20250821-a4b3c2.md](link)
+
+**Participants**: [N agents]
+
+- [agent-1]: [focus area]
+- [agent-2]: [focus area]
+  ...
+
+**Discussion Rounds**: [2-3]
+
+**Key Outcomes**:
+
+- [Consensus item 1]
+- [Consensus item 2]
+- [Trade-off decision 1]
+
+**Open Questions**: [N]
+
+- [Question requiring human decision]
+
+**Summary**:
+[2-3 sentences summarizing the collaborative planning process and key implementation strategy]
+
+**Next Steps**:
+
+- Review the plan document using `/review-plan <plan-file>`
+- Address any open questions before proceeding
+- Execute with `/execute-plan <plan-file>` when ready
+```
+
+## Implementation Notes
+
+### Agent Orchestration
+
+- Use Task tool to invoke agents
+- Run agents in parallel when gathering independent perspectives
+- Run sequentially when one agent needs to respond to another's specific feedback
+- Limit to 3 discussion rounds maximum to avoid diminishing returns
+
+### Context Management
+
+- Keep agent prompts focused on their domain while providing full plan context
+- In later rounds, provide relevant excerpts from other agents' feedback
+- Summarize previous rounds to keep context manageable
+- Automatically include context-loader findings from `/explore` when available
+
+### Handling Edge Cases
+
+- **No consensus reached**: Document the disagreement and provide trade-off analysis
+- **Too many agents selected**: Prioritize and cap at 10 most relevant agents
+- **Agent unavailable**: Select next best alternative or proceed with available agents
+- **Circular disagreements**: Invoke a meta-level agent (e.g., architect-reviewer) to arbitrate
+
+### File Management
+
+- Create a `./.claude-output` directory if it doesn't exist
+- Use descriptive filenames with timestamps and content hash
+- Include conversation metadata (agents used, rounds completed, timestamp)
+
 ## Integration with Other Commands
 
 ### Recommended Workflow
@@ -181,15 +368,19 @@ The planner automatically adapts its output based on task complexity:
 
    - Best for medium to complex tasks
    - Exploration context automatically flows to planner
+   - Collaborative refinement ensures comprehensive coverage
+   - Review validates the plan before execution
 
 2. **Quick Planning**: `/plan` → `/execute-plan`
 
    - Suitable for simple, well-understood tasks
    - Skip review step when plan is straightforward
+   - Still benefits from multi-agent collaboration
 
 3. **With Review**: `/plan` → `/review-plan` → `/execute-plan`
    - Skip exploration for simple tasks in familiar code
    - Add review for validation and improvement suggestions
+   - Multi-agent discussion ensures quality
 
 ### How Execution Works
 
@@ -197,3 +388,66 @@ The planner automatically adapts its output based on task complexity:
 - 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
+
+## Example Session
+
+**Input:**
+
+```
+/plan implement real-time collaborative editing with CRDTs
+```
+
+**Process:**
+
+1. Analyzes the task and identifies it as a complex feature
+2. Selects 6 agents: frontend-developer, backend-architect, database-optimizer, performance-engineer, security-auditor, test-automator
+3. Round 1: Each agent provides initial assessment
+   - Frontend: Concerns about conflict UI/UX
+   - Backend: Suggests operational transform vs CRDT comparison
+   - Database: Warns about storage overhead for history
+   - Performance: Highlights network bandwidth considerations
+   - Security: Questions access control in real-time sync
+   - Testing: Notes complexity of testing concurrent edits
+4. Round 2: Cross-pollination
+   - Backend responds to performance's bandwidth concerns with compression strategy
+   - Security and Frontend discuss access control UX
+   - Database and Performance agree on hybrid approach for history retention
+5. Round 3: Final consensus
+   - Agree on CRDT with compression
+   - Consensus on 30-day history retention
+   - Security and Frontend align on access control approach
+   - Testing strategy defined for concurrent scenarios
+
+**Output:**
+Comprehensive implementation plan with consensus recommendations, remaining trade-offs, and implementation roadmap informed by multi-domain expert discussion.
+
+## Best Practices
+
+### For Simple Plans
+
+- Limit to 3-4 agents
+- 1-2 discussion rounds sufficient
+- Focus on quick validation and obvious improvements
+
+### For Complex Plans
+
+- Use 7-10 agents for comprehensive coverage
+- Allow 2-3 discussion rounds for thorough exploration
+- Document dissenting views even if consensus reached
+- Highlight areas needing human architectural decisions
+
+### Quality Indicators
+
+- **Good collaboration**: Multiple agents reference each other's feedback
+- **Productive disagreement**: Conflicting views backed by clear rationale
+- **Convergence**: Later rounds show narrowing of options and growing consensus
+- **Actionable output**: Recommendations are specific and implementable
+
+### Avoiding Common Pitfalls
+
+- **Don't** force consensus on genuinely ambiguous trade-offs
+- **Don't** let one agent dominate the discussion
+- **Don't** run endless rounds hoping for perfect agreement
+- **Do** document when human judgment is needed
+- **Do** preserve valuable dissenting opinions
+- **Do** prioritize practical over theoretical perfection

package/dist/generators/add-agent/schema.json

@@ -48,7 +48,7 @@
     "model": {
       "type": "string",
       "description": "The AI model to use for this agent",
-      "enum": ["sonnet-4", "opus-4.1"],
+      "enum": ["sonnet-4.5", "opus-4.1"],
       "x-prompt": {
         "message": "🧠 Which AI model should this agent use?",
         "type": "list"

package/dist/generators/init/generator.cjs

@@ -726,7 +726,7 @@ var commands = {
     filePath: "./monitor.md"
   },
   plan: {
-    description: "Create clear, actionable implementation plans for any task, feature, refactor, or architectural change",
+    description: "Create clear, actionable implementation plans for any task, feature, refactor, or architectural change through collaborative multi-agent refinement",
     filePath: "./plan.md"
   },
   refactor: {

package/package.json

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