agcel 1.0.1

package/.agent/workflows/ship.md

@@ -0,0 +1,221 @@
+# /ship - Ship Code Command
+
+## Purpose
+
+Complete workflow to commit changes, run reviews, execute tests, and create a pull request ready for merge.
+
+## Usage
+
+```
+/ship [commit message or 'quick']
+```
+
+## Arguments
+
+- `$ARGUMENTS`:
+  - Commit message: Use as commit subject
+  - `quick`: Auto-generate message, skip review
+
+---
+
+Ship the current changes with: **$ARGUMENTS**
+
+## Workflow
+
+### Phase 1: Pre-Ship Checks
+
+1. **Check Repository Status**
+   ```bash
+   git status
+   git diff --staged
+   ```
+
+2. **Identify Changes**
+   - Files modified
+   - Files added
+   - Files deleted
+
+3. **Quick Validation**
+   - No secrets in changes
+   - No debug statements
+   - No commented-out code
+
+### Phase 2: Code Review (unless 'quick')
+
+1. **Run Self-Review**
+   - Check code quality
+   - Verify style compliance
+   - Identify security issues
+
+2. **Address Critical Issues**
+   - Fix any critical problems
+   - Note recommendations
+
+### Phase 3: Run Tests
+
+1. **Execute Test Suite**
+   ```bash
+   # Python
+   pytest -v
+
+   # TypeScript
+   pnpm test
+   ```
+
+2. **Verify All Pass**
+   - No failing tests
+   - No new warnings
+
+3. **Check Coverage**
+   - Coverage not decreased
+   - New code is tested
+
+### Phase 4: Create Commit
+
+1. **Stage Changes**
+   ```bash
+   git add -A
+   ```
+
+2. **Generate Commit Message**
+   - Follow conventional commit format
+   - Reference issues if applicable
+
+3. **Create Commit**
+   ```bash
+   git commit -m "$(cat <<'EOF'
+   type(scope): subject
+
+   body
+
+   🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+   Co-Authored-By: Claude <noreply@anthropic.com>
+   EOF
+   )"
+   ```
+
+### Phase 5: Push and Create PR
+
+1. **Push to Remote**
+   ```bash
+   git push -u origin [branch-name]
+   ```
+
+2. **Create Pull Request**
+   ```bash
+   gh pr create --title "type(scope): description" --body "$(cat <<'EOF'
+   ## Summary
+   - Change 1
+   - Change 2
+
+   ## Test Plan
+   - [ ] Tests pass
+   - [ ] Manual testing
+
+   🤖 Generated with [Claude Code](https://claude.com/claude-code)
+   EOF
+   )"
+   ```
+
+## Output
+
+### Ship Report
+
+```markdown
+## Ship Complete
+
+### Commit
+**Hash**: `abc1234`
+**Message**: `feat(auth): add password reset functionality`
+
+### Changes
+| File | Change |
+|------|--------|
+| `src/auth/reset.ts` | Added |
+| `src/auth/routes.ts` | Modified |
+| `tests/auth/reset.test.ts` | Added |
+
+### Checks
+- [x] Code review passed
+- [x] Tests passing (42 tests)
+- [x] Coverage: 85% (+3%)
+- [x] No security issues
+
+### Pull Request
+**URL**: https://github.com/org/repo/pull/123
+**Title**: feat(auth): add password reset functionality
+**Base**: main
+**Status**: Ready for review
+
+### Next Steps
+1. Request review from team
+2. Address any feedback
+3. Merge when approved
+```
+
+## Quick Ship Mode
+
+When using `/ship quick`:
+- Skip detailed code review
+- Auto-generate commit message
+- Minimal output
+
+```bash
+# Quick ship for small changes
+/ship quick
+```
+
+## Commit Message Generation
+
+Based on changes, generate appropriate message:
+
+### Feature
+```
+feat(scope): add [feature]
+
+- Added [component/function]
+- Implemented [functionality]
+- Added tests for [scenarios]
+```
+
+### Bug Fix
+```
+fix(scope): resolve [issue]
+
+- Fixed [bug description]
+- Added null check for [case]
+- Updated tests
+```
+
+### Refactor
+```
+refactor(scope): improve [area]
+
+- Extracted [logic] to [location]
+- Renamed [old] to [new]
+- Simplified [complex code]
+```
+
+## Pre-Ship Checklist
+
+- [ ] All changes staged
+- [ ] No unintended files included
+- [ ] Tests pass
+- [ ] No secrets in code
+- [ ] No debug statements
+- [ ] Commit message is descriptive
+- [ ] PR description is complete
+
+<!-- CUSTOMIZATION POINT -->
+## Variations
+
+Modify behavior via CLAUDE.md:
+- Required checks before ship
+- Commit message format
+- PR template requirements
+- Auto-merge settings
+
+
+## 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/spawn.md

@@ -0,0 +1,177 @@
+# /spawn
+
+## Purpose
+
+Launch background tasks for parallel execution. Enables concurrent work on independent tasks with result aggregation.
+
+---
+
+Launch a background task or manage running tasks.
+
+## Spawn Operations
+
+### Launch Task
+
+Start a new background task:
+
+```bash
+/spawn "[task description]"
+```
+
+**Process:**
+1. Analyze task for parallelizability
+2. Launch subagent with task
+3. Return task ID for tracking
+4. Continue main conversation
+
+**Output:**
+```markdown
+Spawned: Task #1
+- Description: Research authentication patterns
+- Status: Running
+- Agent: researcher
+
+Continue working. Use `/spawn --list` to check status.
+```
+
+### List Tasks
+
+Show running and completed tasks:
+
+```bash
+/spawn --list
+```
+
+**Output:**
+```markdown
+## Active Tasks
+
+| ID | Description | Status | Duration |
+|----|-------------|--------|----------|
+| #1 | Research auth patterns | Running | 2m |
+| #2 | Analyze security | Complete | 5m |
+
+## Completed Tasks (last hour)
+| #2 | Analyze security | ✅ Complete | Results ready |
+```
+
+### Collect Results
+
+Gather results from completed tasks:
+
+```bash
+/spawn --collect
+```
+
+**Output:**
+```markdown
+## Collected Results
+
+### Task #1: Research auth patterns
+**Status**: Complete
+**Findings**:
+- Pattern A: JWT with refresh tokens
+- Pattern B: Session-based with Redis
+- Recommendation: JWT for stateless API
+
+### Task #2: Analyze security
+**Status**: Complete
+**Findings**:
+- 2 high-priority issues found
+- See detailed report below
+```
+
+### Cancel Task
+
+Stop a running task:
+
+```bash
+/spawn --cancel [id]
+```
+
+## Task Types
+
+| Type | Best For | Agent Used |
+|------|----------|------------|
+| Research | Information gathering | researcher |
+| Analysis | Code analysis | scout |
+| Review | Code review | code-reviewer |
+| Test | Test generation | tester |
+| Scan | Security scanning | security-auditor |
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `--list` | Show all tasks |
+| `--collect` | Gather completed results |
+| `--cancel [id]` | Cancel running task |
+| `--wait` | Wait for all tasks to complete |
+| `--agent=[type]` | Specify agent type |
+| `--priority=[high\|normal]` | Task priority |
+
+## Usage Examples
+
+```bash
+/spawn "Research OAuth2 best practices"
+/spawn "Analyze user service for performance issues"
+/spawn "Review security of auth module" --agent=security-auditor
+/spawn --list
+/spawn --collect
+/spawn --wait                    # Block until all complete
+```
+
+## Arguments
+
+$ARGUMENTS
+
+If quoted text: spawn that task
+If flag: execute that operation
+
+---
+
+## Parallel Workflow
+
+### Pattern: Research Phase
+```bash
+/spawn "Research authentication approaches"
+/spawn "Analyze current auth implementation"
+/spawn "Review competitor auth patterns"
+# Continue other work...
+/spawn --wait
+/spawn --collect
+# Synthesize findings
+```
+
+### Pattern: Multi-File Review
+```bash
+/spawn "Review src/auth/ for security"
+/spawn "Review src/api/ for performance"
+/spawn "Review src/db/ for SQL injection"
+/spawn --collect
+# Address findings
+```
+
+## Best Practices
+
+1. **Independent Tasks**: Only spawn truly independent work
+2. **Clear Descriptions**: Specific task descriptions get better results
+3. **Regular Collection**: Don't let results pile up
+4. **Resource Awareness**: Don't spawn too many concurrent tasks
+
+## Limitations
+
+- Tasks cannot communicate with each other
+- Results are collected, not streamed
+- Heavy tasks may take time
+- Some tasks benefit from sequential execution
+
+## Combines With
+
+- Orchestration mode: Manages multiple spawned tasks
+- `/plan`: Plan tasks, then spawn parallel execution
+- `/execute-plan`: Orchestrated task 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/status.md

@@ -0,0 +1,59 @@
+# /status - Project Status Command
+
+## Purpose
+
+Get current project status including tasks, git state, and recent activity.
+
+## Usage
+
+```
+/status
+```
+
+---
+
+Show current project status.
+
+## Workflow
+
+1. **Check Git Status**
+   ```bash
+   git status
+   git log --oneline -5
+   ```
+
+2. **Review Todos**
+   - In progress
+   - Pending
+   - Completed today
+
+3. **Recent Activity**
+   - Recent commits
+   - Open PRs
+   - Open issues
+
+## Output
+
+```markdown
+## Project Status
+
+### Git
+- Branch: `feature/xyz`
+- Status: Clean / X modified files
+
+### Tasks
+- In Progress: X
+- Pending: Y
+- Completed: Z
+
+### Recent Commits
+1. [commit message]
+2. [commit message]
+
+### Open PRs
+- #123: [title]
+```
+
+
+## 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/tdd.md

@@ -0,0 +1,139 @@
+# /tdd - Test-Driven Development Workflow
+
+## Purpose
+
+Start a TDD workflow: write failing tests first, then implement to make them pass.
+
+## Usage
+
+```
+/tdd [feature or function description]
+```
+
+---
+
+Start TDD workflow for: **$ARGUMENTS**
+
+## Workflow
+
+### Phase 1: Red - Write Failing Tests
+
+1. **Understand Requirements**
+   - What should the code do?
+   - What are the inputs/outputs?
+   - What edge cases exist?
+
+2. **Write Tests First**
+   ```python
+   def test_feature_does_expected_thing():
+       result = feature("input")
+       assert result == "expected"
+   ```
+
+3. **Run Tests (Expect Failure)**
+   ```bash
+   pytest -v  # Should fail
+   ```
+
+### Phase 2: Green - Make Tests Pass
+
+1. **Implement Minimal Code**
+   - Just enough to pass tests
+   - No premature optimization
+
+2. **Run Tests (Expect Success)**
+   ```bash
+   pytest -v  # Should pass
+   ```
+
+### Phase 3: Refactor
+
+1. **Improve Code Quality**
+   - Clean up implementation
+   - Remove duplication
+   - Improve naming
+
+2. **Run Tests (Ensure Still Passing)**
+   ```bash
+   pytest -v  # Should still pass
+   ```
+
+### Phase 4: Repeat
+
+Add more test cases and repeat the cycle.
+
+## TDD Best Practices
+
+- Write one test at a time
+- Tests should be specific and focused
+- Keep the red-green-refactor cycle short
+- Commit after each green phase
+
+## Superpowers TDD Methodology
+
+**Reference**: `.claude/skills/methodology/test-driven-development/SKILL.md`
+
+### Non-Negotiable Rule
+
+**NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST**
+
+This is not a guideline - it's a rule.
+
+### If You Already Wrote Code
+
+Delete it. Completely. Don't keep it as reference.
+
+```
+WRONG: "I'll keep this code as reference while writing tests"
+RIGHT: Delete the code, write test, rewrite implementation
+```
+
+### Verification Before Completion
+
+**Reference**: `.claude/skills/methodology/verification-before-completion/SKILL.md`
+
+Before claiming tests pass:
+1. **Identify** the command that proves assertion
+2. **Execute** it fully and freshly
+3. **Read** complete output
+4. **Verify** output matches claim
+5. **Only then** make the claim
+
+### Forbidden Language
+
+Never use without verification:
+- "should work"
+- "probably fixed"
+- "seems to pass"
+
+### Testing Anti-Patterns to Avoid
+
+**Reference**: `.claude/skills/methodology/testing-anti-patterns/SKILL.md`
+
+1. Testing mock behavior instead of real code
+2. Polluting production with test-only methods
+3. Mocking without understanding dependencies
+4. Creating incomplete mocks
+5. Writing tests as afterthoughts
+
+## Output
+
+```markdown
+## TDD Session: [Feature]
+
+### Tests Written
+1. `test_basic_functionality` - [description]
+2. `test_edge_case` - [description]
+
+### Implementation
+`src/feature.py` - [description]
+
+### Cycle Summary
+- Red: 3 tests written
+- Green: All passing
+- Refactor: Extracted helper function
+```
+
+
+## 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.