agcel 1.0.1

package/.agent/workflows/execute-plan.md

@@ -0,0 +1,225 @@
+# /execute-plan - Subagent-Driven Plan Execution
+
+## Purpose
+
+Execute a detailed implementation plan using fresh subagents per task with mandatory code review gates between tasks.
+
+## Usage
+
+```
+/execute-plan [plan-file-path]
+```
+
+## Arguments
+
+- `$ARGUMENTS`: Path to the plan file (created with `/plan --detailed`)
+
+---
+
+Execute plan from: **$ARGUMENTS**
+
+## Methodology
+
+**Reference**: `.claude/skills/methodology/executing-plans/SKILL.md`
+
+This command uses the superpowers execution methodology for quality-gated implementation.
+
+## Core Pattern
+
+**"Fresh subagent per task + review between tasks = high quality, fast iteration"**
+
+### Why Fresh Agents?
+
+- Prevents context pollution between tasks
+- Each task gets focused attention
+- Failures don't cascade
+- Easier to retry individual tasks
+
+### Why Code Review Between Tasks?
+
+- Catches issues early
+- Ensures code matches intent
+- Prevents technical debt accumulation
+- Creates natural checkpoints
+
+## Workflow
+
+### Step 1: Load Plan
+
+1. Read the plan file
+2. Verify plan is complete and approved
+3. Create TodoWrite with all tasks from plan
+4. Set first task to `in_progress`
+
+### Step 2: Execute Task (For Each Task)
+
+```markdown
+1. Dispatch fresh subagent with task details
+2. Subagent implements following TDD cycle:
+   - Write failing test
+   - Verify test fails
+   - Implement minimally
+   - Verify test passes
+   - Commit
+3. Subagent returns completion summary
+```
+
+### Step 3: Code Review
+
+After each task:
+
+```markdown
+1. Dispatch code-reviewer subagent
+2. Review scope: only changes from current task
+3. Reviewer returns findings:
+   - Critical: Must fix before proceeding
+   - Important: Should fix before proceeding
+   - Minor: Can fix later
+```
+
+### Step 4: Handle Review Findings
+
+```markdown
+IF Critical or Important issues found:
+  1. Dispatch fix subagent for each issue
+  2. Re-request code review
+  3. Repeat until no Critical/Important issues
+
+IF only Minor issues:
+  1. Note for later cleanup
+  2. Proceed to next task
+```
+
+### Step 5: Mark Complete
+
+1. Update TodoWrite - mark task completed
+2. Move to next task
+3. Repeat from Step 2
+
+### Step 6: Final Review
+
+After all tasks complete:
+
+1. Dispatch comprehensive code review
+2. Review entire implementation against plan
+3. Verify all success criteria met
+4. Run full test suite
+5. Use `finishing-development-branch` skill
+
+## Critical Rules
+
+### Never Skip Code Reviews
+
+Every task must be reviewed before proceeding. No exceptions.
+
+### Never Proceed with Critical Issues
+
+Critical issues must be fixed:
+```
+implement → review → fix critical → re-review → proceed
+```
+
+### Never Run Parallel Implementation
+
+Tasks run sequentially:
+```
+WRONG: Run Task 1, 2, 3 simultaneously
+RIGHT: Task 1 → Review → Task 2 → Review → Task 3 → Review
+```
+
+### Always Read Plan Before Implementing
+
+```
+WRONG: Start coding based on memory of plan
+RIGHT: Read plan file, extract task details, then implement
+```
+
+## Error Handling
+
+### Task Fails
+
+1. Capture error details
+2. Attempt fix (max 2 retries)
+3. If still failing, pause execution
+4. Report to user with:
+   - Which task failed
+   - Error details
+   - Suggested resolution
+5. Wait for user decision
+
+### Review Finds Major Issues
+
+1. List all Critical/Important issues
+2. Dispatch fix subagent for each
+3. Re-run code review
+4. If issues persist after 2 cycles:
+   - Pause execution
+   - Report to user
+   - May need plan revision
+
+## Output
+
+### Progress Updates
+
+```markdown
+## Execution Progress
+
+### Task 1: Create User model ✓
+- Files modified: src/models/user.ts
+- Tests added: 3
+- Review: Passed
+
+### Task 2: Add validation ✓
+- Files modified: src/models/user.ts
+- Tests added: 2
+- Review: Passed (1 minor deferred)
+
+### Task 3: Create endpoint [IN PROGRESS]
+- Status: Implementing...
+```
+
+### Completion Summary
+
+```markdown
+## Execution Complete
+
+### Summary
+- Tasks completed: 8/8
+- Tests added: 24
+- Coverage: 92%
+
+### Files Created
+- src/models/user.ts
+- src/services/user-service.ts
+- src/routes/user.ts
+
+### Files Modified
+- src/routes/index.ts
+- src/types/index.ts
+
+### Deferred Items
+- Minor: Variable rename in user-service.ts line 12
+
+### Next Steps
+- Run full test suite
+- Use /ship to create PR
+```
+
+## Prerequisites
+
+Before using this command:
+
+1. Plan file exists and is complete
+2. Plan was created with `/plan --detailed`
+3. Plan has been reviewed and approved
+4. Tests can be run (`npm test` or `pytest`)
+
+## Related Commands
+
+- `/plan --detailed` - Create detailed plan
+- `/brainstorm` - Design before planning
+- `/ship` - Create PR after execution
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/feature.md

@@ -0,0 +1,255 @@
+# /feature - Feature Development Workflow
+
+## Purpose
+
+End-to-end feature development workflow that orchestrates planning, implementation guidance, testing, and code review.
+
+## Usage
+
+```
+/feature [feature description or issue reference]
+```
+
+## Arguments
+
+- `$ARGUMENTS`: Feature description, issue number, or requirement specification
+
+---
+
+Implement a complete feature development workflow for: **$ARGUMENTS**
+
+## Workflow
+
+### Phase 1: Planning
+
+First, analyze the feature request and create an implementation plan:
+
+1. **Understand Requirements**
+   - Parse the feature description thoroughly
+   - Identify acceptance criteria
+   - List assumptions that need validation
+   - Clarify any ambiguous requirements with the user
+
+2. **Explore Codebase**
+   - Find related existing implementations
+   - Identify patterns and conventions to follow
+   - Locate integration points
+   - Note dependencies
+
+3. **Create Task Breakdown**
+   - Decompose into atomic, verifiable tasks
+   - Order tasks by dependencies
+   - Include testing requirements
+   - Estimate complexity (S/M/L)
+
+4. **Use TodoWrite** to track all tasks
+
+### Phase 2: Research (If Needed)
+
+If the feature involves unfamiliar technology:
+
+1. Research best practices and patterns
+2. Find examples in the codebase or documentation
+3. Identify potential pitfalls
+4. Document key decisions
+
+### Phase 3: Implementation Guidance
+
+For each implementation task:
+
+1. **Identify Target Files**
+   - Existing files to modify
+   - New files to create
+   - Tests to add/update
+
+2. **Provide Implementation Direction**
+   - Code structure recommendations
+   - Patterns to follow
+   - Edge cases to handle
+   - Error handling approach
+
+3. **Review Progress**
+   - Mark tasks complete as you go
+   - Identify blockers early
+   - Adjust plan if needed
+
+### Phase 4: Testing
+
+After implementation:
+
+1. **Generate Tests**
+   - Unit tests for new functions
+   - Integration tests for workflows
+   - Edge case coverage
+
+2. **Run Test Suite**
+   ```bash
+   # Python
+   pytest -v --cov=src
+
+   # TypeScript
+   pnpm test
+   ```
+
+3. **Verify Coverage**
+   - Ensure new code is tested
+   - Coverage should not decrease
+
+### Phase 5: Code Review
+
+Before completion:
+
+1. **Self-Review Checklist**
+   - [ ] Code follows project conventions
+   - [ ] No security vulnerabilities
+   - [ ] Error handling is complete
+   - [ ] Documentation updated
+   - [ ] Tests are passing
+
+2. **Review Staged Changes**
+   ```bash
+   git diff --staged
+   ```
+
+3. **Address Any Issues**
+   - Fix critical issues immediately
+   - Note recommendations for future
+
+### Phase 6: Completion
+
+1. **Verify All Tasks Complete**
+   - All TodoWrite items done
+   - All tests passing
+   - Documentation updated
+
+2. **Prepare for Commit**
+   - Stage appropriate files
+   - Generate commit message
+   - Create PR if requested
+
+## Output
+
+### Deliverables
+
+1. **Implementation Plan** - Structured task breakdown
+2. **Code Changes** - Feature implementation
+3. **Tests** - Comprehensive test coverage
+4. **Documentation** - Updated docs if needed
+5. **Commit/PR** - Ready for merge
+
+### Summary Format
+
+```markdown
+## Feature Implementation Complete
+
+### Feature
+[Feature description]
+
+### Changes Made
+- `path/to/file.ts` - [What was added/modified]
+- `path/to/file.test.ts` - [Tests added]
+
+### Tests
+- [x] Unit tests passing
+- [x] Integration tests passing
+- [x] Coverage: XX%
+
+### Documentation
+- [x] Code comments added
+- [x] README updated (if applicable)
+
+### Ready for Review
+```bash
+git status
+git diff --staged
+```
+
+### Next Steps
+1. Review changes
+2. Run full test suite
+3. Create PR
+```
+
+## Example
+
+**Input**: `/feature Add password reset functionality with email verification`
+
+**Output**:
+1. Plan with 8 tasks covering model, service, routes, email, tests
+2. Implementation of password reset flow
+3. Tests for happy path and error cases
+4. Updated API documentation
+5. Commit message and PR description
+
+## Flags
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `--mode=[mode]` | Use specific behavioral mode | `--mode=implementation` |
+| `--depth=[1-5]` | Planning thoroughness level | `--depth=3` |
+| `--checkpoint` | Create checkpoint before starting | `--checkpoint` |
+| `--skip-tests` | Skip test generation phase | `--skip-tests` |
+| `--skip-review` | Skip code review phase | `--skip-review` |
+| `--format=[fmt]` | Output format (concise/detailed) | `--format=concise` |
+
+### Flag Usage Examples
+
+```bash
+/feature --mode=implementation "add user profile page"
+/feature --depth=5 --checkpoint "implement payment flow"
+/feature --format=concise "add logging utility"
+```
+
+## MCP Integration
+
+This command leverages MCP servers for enhanced capabilities:
+
+### Web Search - Library Documentation
+When researching unfamiliar libraries or frameworks:
+```
+Use web search and get-library-docs tools to fetch
+current documentation for any libraries involved in the feature.
+```
+
+### Reasoning - Structured Planning
+For complex feature breakdowns:
+```
+Use reasoning for step-by-step
+analysis when decomposing requirements or designing architecture.
+```
+
+### Memory - Context Persistence
+Store and recall project context:
+```
+- Store architectural decisions made during planning
+- Recall user preferences from previous sessions
+- Remember patterns used in similar features
+```
+
+### Filesystem - File Operations
+For creating and modifying files:
+```
+- Use list_dir to understand project structure
+- Use grep_search to find related implementations
+- Use view_file and write_to_file for file operations
+```
+
+### Browser tools - E2E Testing
+For features with UI components:
+```
+Use Browser tools for browser testing of the implemented feature.
+Validate user flows and interactions in real browser environment.
+```
+
+<!-- CUSTOMIZATION POINT -->
+## Variations
+
+Modify behavior via CLAUDE.md:
+- Set minimum test coverage requirements
+- Define required documentation updates
+- Configure branch naming conventions
+- Set PR template requirements
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.