claude-autopm 2.8.1 → 2.8.3

package/packages/plugin-core/rules/agent-mandatory.md

@@ -0,0 +1,170 @@
+# Agent Usage - MANDATORY
+
+**🚨 CRITICAL: This rule has HIGHEST PRIORITY and MUST be followed for ALL tasks.**
+
+## Core Requirement
+
+**YOU MUST USE SPECIALIZED AGENTS FOR ALL NON-TRIVIAL TASKS.**
+
+Do NOT perform complex tasks yourself. Use the Task tool to delegate to appropriate agents.
+
+## When to Use Agents
+
+### ✅ ALWAYS Use Agents For:
+
+1. **Writing Code** (any language)
+   - Use: `python-backend-engineer`, `react-frontend-engineer`, `nodejs-backend-engineer`
+   - Example: "I need to create an API endpoint" → Use python-backend-engineer
+
+2. **Testing**
+   - Use: `test-runner`, `frontend-testing-engineer`, `e2e-test-engineer`
+   - Example: "Run the test suite" → Use test-runner
+
+3. **Infrastructure/DevOps**
+   - Use: `kubernetes-orchestrator`, `docker-containerization-expert`, `terraform-infrastructure-expert`
+   - Example: "Deploy to Kubernetes" → Use kubernetes-orchestrator
+
+4. **Database Work**
+   - Use: `postgresql-expert`, `mongodb-expert`, `bigquery-expert`
+   - Example: "Design database schema" → Use postgresql-expert
+
+5. **Code Analysis**
+   - Use: `code-analyzer`
+   - Example: "Review this code for bugs" → Use code-analyzer
+
+6. **GitHub/Azure DevOps Operations**
+   - Use: `github-operations-specialist`, `azure-devops-specialist`
+   - Example: "Create a PR" → Use github-operations-specialist
+
+7. **Large File Analysis**
+   - Use: `file-analyzer`
+   - Example: "Summarize this 10k line log file" → Use file-analyzer
+
+### ⚪ Can Do Yourself:
+
+1. **Simple file reads** (1-2 files, quick lookup)
+2. **Simple bash commands** (ls, pwd, basic git commands)
+3. **Answering questions** about existing code/documentation
+4. **Creating todo lists** with TodoWrite
+
+## Agent Selection Guide
+
+### By Task Type
+
+| Task | Agent | Example |
+|------|-------|---------|
+| Python API development | `python-backend-engineer` | Build FastAPI endpoint |
+| React component | `react-frontend-engineer` | Create dashboard UI |
+| Database schema | `postgresql-expert` | Design user tables |
+| Kubernetes deployment | `kubernetes-orchestrator` | Deploy to K8s cluster |
+| Docker container | `docker-containerization-expert` | Create Dockerfile |
+| GitHub workflow | `github-operations-specialist` | Setup CI/CD |
+| Code review | `code-analyzer` | Find bugs in PR |
+| Test execution | `test-runner` | Run test suite |
+| Log analysis | `file-analyzer` | Parse 50MB log file |
+
+### By Technology
+
+| Technology | Primary Agent | Secondary Agent |
+|------------|---------------|-----------------|
+| Python/FastAPI | `python-backend-engineer` | `postgresql-expert` for DB |
+| React/Next.js | `react-frontend-engineer` | `tailwindcss-expert` for styles |
+| Node.js/Express | `nodejs-backend-engineer` | `mongodb-expert` for DB |
+| TypeScript | `javascript-frontend-engineer` | Language-specific |
+| Kubernetes | `kubernetes-orchestrator` | `docker-containerization-expert` |
+| Terraform | `terraform-infrastructure-expert` | Cloud-specific architects |
+| Testing | `test-runner` | `frontend-testing-engineer` |
+
+## Violation Examples
+
+### ❌ WRONG - Doing It Yourself:
+
+```
+User: "Create a FastAPI endpoint for user registration"
+You: *writes Python code directly*
+```
+
+### ✅ CORRECT - Using Agent:
+
+```
+User: "Create a FastAPI endpoint for user registration"
+You: "I'll use the python-backend-engineer agent to create this endpoint"
+*Uses Task tool with python-backend-engineer*
+```
+
+### ❌ WRONG - Not Using Agent for Analysis:
+
+```
+User: "Review this 5000 line file for security issues"
+You: *reads file and tries to analyze*
+```
+
+### ✅ CORRECT - Using Agent:
+
+```
+User: "Review this 5000 line file for security issues"
+You: "I'll use the code-analyzer agent to review this file"
+*Uses Task tool with code-analyzer*
+```
+
+## How to Use Agents
+
+### Single Task:
+
+```markdown
+I'll use the [agent-name] agent to [task description].
+```
+
+Then invoke Task tool:
+- `subagent_type`: Agent name (e.g., "python-backend-engineer")
+- `description`: Short task description
+- `prompt`: Detailed task requirements
+
+### Multiple Parallel Tasks:
+
+```markdown
+I'll launch multiple agents in parallel:
+1. python-backend-engineer - Create API endpoints
+2. react-frontend-engineer - Build dashboard UI
+3. postgresql-expert - Design database schema
+```
+
+Then invoke multiple Task tools IN SINGLE MESSAGE.
+
+## Active Team Agents
+
+**Check the "Active Team Agents" section at the top of CLAUDE.md** for the current list of available agents in this project.
+
+If you need an agent that's not listed, you can still use any agent from the registry. The active team list is just a convenience reference.
+
+## Common Mistakes to Avoid
+
+1. ❌ **Not reading Active Team Agents section** - Always check what agents are available
+2. ❌ **Writing code yourself for non-trivial tasks** - Use appropriate agent
+3. ❌ **Not using parallel agents** - Launch multiple agents when tasks are independent
+4. ❌ **Using wrong agent for task** - Match agent specialty to task type
+5. ❌ **Forgetting file-analyzer for large files** - Use it for files >1000 lines or logs
+
+## Enforcement
+
+This rule is enforced through:
+
+1. **Git Hooks** - Pre-commit checks for agent usage patterns
+2. **Code Review** - Human reviewers check for proper agent delegation
+3. **Self-Monitoring** - You must self-enforce and explain why you're using/not using agents
+
+## Questions?
+
+If you're unsure whether to use an agent:
+- **Default: YES, use an agent**
+- When in doubt, delegate to specialist
+- Better to over-use agents than under-use them
+
+## Summary
+
+**Before doing ANY complex task, ask yourself:**
+1. Is there a specialized agent for this?
+2. Would an agent do this better/faster/more thoroughly?
+3. Am I trying to do something I should delegate?
+
+**If answer is YES to any → USE THE AGENT!**

package/packages/plugin-core/rules/command-pipelines.md

@@ -0,0 +1,208 @@
+# Command Pipeline Specifications
+
+> **CRITICAL**: Follow these exact command sequences for each workflow.
+
+## Command Categories
+
+### Context Management (`/context:*`)
+
+- `/context:create` - Build initial project documentation
+- `/context:update` - Refresh context with recent changes  
+- `/context:prime` - Load context into conversation
+
+### Testing (`/testing:*`)
+
+- `/testing:prime` - Configure testing framework and detect test runner
+- `/testing:run` - Execute tests via test-runner agent
+
+### Project Management (`/pm:*`)
+
+#### System Management
+
+- `/pm:init` - Initialize PM system (REQUIRED FIRST)
+- `/pm:status` - Show current PM status
+- `/pm:standup` - Daily standup report
+- `/pm:validate` - Validate PM structure
+- `/pm:sync` - Sync with external systems
+
+#### PRD Management
+
+- `/pm:prd-new` - Create new Product Requirements Document
+- `/pm:prd-parse` - Convert PRD to technical epic
+- `/pm:prd-edit` - Edit existing PRD
+- `/pm:prd-status` - Show PRD status
+
+#### Epic Management
+
+- `/pm:epic-decompose` - Break epic into tasks
+- `/pm:epic-start` - Launch parallel agents for epic
+- `/pm:epic-status` - Show execution status
+- `/pm:epic-merge` - Merge epic branch
+- `/pm:epic-close` - Close completed epic
+
+#### Issue Management
+
+- `/pm:issue-analyze` - Identify parallel work streams
+- `/pm:issue-start` - Begin work on issue
+- `/pm:issue-status` - Show issue status
+- `/pm:issue-close` - Mark issue complete
+- `/pm:import` - Import GitHub issues
+
+#### Workflow Navigation
+
+- `/pm:next` - Get next task recommendation
+- `/pm:in-progress` - Show current work
+- `/pm:blocked` - Show blocked tasks
+- `/pm:search` - Search PM system
+
+### Utilities
+
+- `/prompt` - Handle complex prompts with @ references
+- `/re-init` - Update CLAUDE.md with PM rules
+- `/code-rabbit` - Process CodeRabbit review comments
+
+## Mandatory Command Pipelines
+
+### 1. NEW PROJECT INITIALIZATION
+
+```
+REQUIRED SEQUENCE:
+1. /pm:init           → Initialize PM system
+2. /context:create    → Build project documentation
+3. /testing:prime     → Configure test framework
+4. /context:prime     → Load context for work
+```
+
+### 2. FEATURE DEVELOPMENT PIPELINE
+
+```
+REQUIRED SEQUENCE:
+1. /pm:prd-new <name>        → Create requirements document
+2. /pm:prd-parse <name>      → Convert to technical epic
+3. /pm:epic-decompose <name> → Break into parallel tasks
+4. /pm:epic-sync <name>      → Sync with GitHub
+5. /pm:epic-start <name>     → Launch parallel agents:
+   - Each agent follows TDD cycle
+   - Agents work in shared branch
+   - Progress tracked in execution-status.md
+6. /pm:epic-status <name>    → Monitor progress
+7. /pm:epic-merge <name>     → Merge when complete
+```
+
+### 3. ISSUE RESOLUTION PIPELINE
+
+```
+REQUIRED SEQUENCE:
+1. /pm:import                → Import from GitHub
+2. /pm:issue-analyze <id>    → Identify work streams
+3. /pm:issue-start <id>      → Begin implementation:
+   - Spawns parallel-worker agent
+   - Creates sub-agents per stream
+   - Follows TDD for each fix
+4. /pm:issue-status <id>     → Check progress
+5. /pm:issue-close <id>      → Mark complete
+```
+
+### 4. DAILY WORKFLOW PIPELINE
+
+```
+MORNING SEQUENCE:
+1. /context:prime       → Load project context
+2. /pm:standup         → Review status & blockers
+3. /pm:next            → Get task recommendation
+
+DURING WORK:
+- Use agents for all searches/analysis
+- Follow TDD cycle for changes
+- Run /testing:run after implementations
+
+END OF DAY SEQUENCE:
+1. /testing:run        → Verify all tests pass
+2. /context:update     → Update project context
+3. /pm:status          → Review accomplishments
+```
+
+### 5. CODE REVIEW PIPELINE
+
+```
+REQUIRED SEQUENCE:
+1. /code-rabbit        → Paste review comments
+2. code-analyzer       → Analyze each suggestion
+3. Implement fixes following TDD
+4. test-runner         → Verify all changes
+5. Update PR with fixes
+```
+
+## Command Prerequisites
+
+### PM Commands
+
+- Require `/pm:init` first
+- Must have `.pm/` directory structure
+
+### Epic Commands
+
+- Require PRD to exist
+- Must have parsed epic file
+
+### Issue Commands
+
+- Require GitHub integration
+- Must have valid issue ID
+
+### Testing Commands
+
+- Require framework detection
+- Must have test configuration
+
+### Context Commands
+
+- Require `.claude/` directory
+- Must have project structure
+
+## Command Execution Rules
+
+### All Commands MUST
+
+1. Validate prerequisites before execution
+2. Use real datetime (`date -u +"%Y-%m-%dT%H:%M:%SZ"`)
+3. Ask before overwriting data
+4. Provide detailed execution summaries
+5. Delegate to specialized agents
+
+### Agent Delegation Rules
+
+- **Always use test-runner** for test execution
+- **Always use file-analyzer** for reading logs/outputs
+- **Always use code-analyzer** for code search/analysis
+- **Always use parallel-worker** for multi-file operations
+
+## Command Anti-Patterns
+
+### NEVER DO
+
+- ❌ Running tests without `/testing:prime`
+- ❌ Starting epics without decomposition
+- ❌ Closing issues without verification
+- ❌ Skipping context updates
+- ❌ Direct command execution without agents
+- ❌ Manual datetime entry
+- ❌ Ignoring command prerequisites
+
+## Success Verification
+
+### Command Success Indicators
+
+- ✅ Prerequisites validated
+- ✅ Agents properly delegated
+- ✅ Real datetime used
+- ✅ Summary provided
+- ✅ Next steps clear
+
+### Pipeline Completion
+
+- ✅ All steps executed in order
+- ✅ No steps skipped
+- ✅ Tests passing
+- ✅ Documentation updated
+- ✅ Context preserved

package/packages/plugin-core/rules/context-optimization.md

@@ -0,0 +1,176 @@
+# Context Optimization Strategies
+
+> **CRITICAL**: Preserve conversation context through intelligent agent delegation.
+
+## Core Philosophy
+
+**Context Management**: Use specialized agents to preserve conversation context
+**Information Hierarchy**: Only critical information in main thread
+**Efficiency Target**: Agents return <20% of processed data
+
+## Agent Usage Requirements
+
+### ALWAYS USE file-analyzer WHEN
+
+- Reading any log file
+- Analyzing test outputs  
+- Reviewing configuration files
+- Summarizing verbose outputs
+- Reading multiple files for comparison
+- Extracting key information from large files
+
+### ALWAYS USE code-analyzer WHEN
+
+- Searching for code patterns
+- Tracing logic flow
+- Investigating bugs
+- Reviewing code changes
+- Finding security vulnerabilities
+- Analyzing dependencies
+- Understanding code structure
+
+### ALWAYS USE test-runner WHEN
+
+- Running any tests
+- Validating implementations
+- Checking for regressions
+- Debugging test failures
+- Verifying fixes
+
+### ALWAYS USE parallel-worker WHEN
+
+- Implementing features with multiple components
+- Working on multiple files simultaneously
+- Decomposing epics into parallel tasks
+- Handling independent work streams
+
+### ALWAYS USE fastapi-expert WHEN
+
+- Building FastAPI endpoints
+- Implementing API authentication
+- Optimizing API performance
+- Adding WebSocket functionality
+- Debugging FastAPI-specific issues
+
+## Context Firewall Pattern
+
+### Main Thread (High-Level Only)
+
+- Task coordination
+- Critical decisions
+- User interaction
+- Success/failure reporting
+- Next step determination
+
+### Agent Threads (Heavy Lifting)
+
+- File reading and analysis
+- Code searching and parsing
+- Test execution and analysis
+- Multi-file operations
+- Verbose processing
+
+### Information Return Rules
+
+- Return only actionable insights
+- Summarize findings to 10-20% of original
+- Focus on decisions needed
+- Exclude implementation details
+- Never dump raw output
+
+## Batch Operation Strategies
+
+### Parallel Execution
+
+- Use parallel-worker for multi-file changes
+- Group related tests in test-runner
+- Combine searches in code-analyzer
+- Batch similar operations together
+
+### Sequential When Required
+
+- Dependencies between operations
+- State changes affecting next steps
+- User approval needed between steps
+
+## Anti-Patterns to Avoid
+
+### NEVER DO
+
+- ❌ Direct grep/find/cat usage
+- ❌ Reading files without file-analyzer
+- ❌ Running tests without test-runner
+- ❌ Searching code without code-analyzer
+- ❌ Dumping verbose output to main thread
+- ❌ Processing logs in main conversation
+
+### Context Waste Examples
+
+```
+BAD: Dumping entire log file to main thread
+GOOD: Use file-analyzer to extract key errors
+
+BAD: Running grep directly and showing all matches
+GOOD: Use code-analyzer to find and summarize patterns
+
+BAD: Showing full test output in conversation
+GOOD: Use test-runner to run and summarize results
+```
+
+## Information Hierarchy
+
+### Priority 1: Critical (Main Thread)
+
+- Blocking errors
+- Security vulnerabilities
+- Data loss risks
+- User decisions required
+
+### Priority 2: Important (Agent Summary)
+
+- Test failures
+- Performance issues
+- Code quality problems
+- Configuration errors
+
+### Priority 3: Verbose (Agent Internal)
+
+- Detailed logs
+- Full test output
+- Complete search results
+- Implementation details
+
+## Success Metrics
+
+### Context Efficiency
+
+- ✅ All agents return <20% of processed data
+- ✅ No raw logs in main thread
+- ✅ No direct file reads without agents
+- ✅ Batch operations when possible
+- ✅ Clear summaries over raw data
+
+### Agent Utilization
+
+- ✅ 100% file reads through file-analyzer
+- ✅ 100% code search through code-analyzer
+- ✅ 100% test runs through test-runner
+- ✅ Multi-file work through parallel-worker
+
+## Enforcement
+
+### Violation Detection
+
+If context wastage detected:
+
+1. Stop current approach
+2. Identify appropriate agent
+3. Delegate task to agent
+4. Resume with summary only
+
+### Continuous Improvement
+
+- Monitor context usage
+- Identify patterns for new agents
+- Update agent capabilities
+- Document new patterns in CLAUDE.md