agcel 1.0.1

package/.agent/workflows/mode.md

@@ -0,0 +1,170 @@
+# /mode
+
+## Purpose
+
+Switch between behavioral modes to optimize responses for different task types. Modes adjust communication style, output format, and problem-solving approach.
+
+---
+
+Switch to the specified behavioral mode.
+
+## Available Modes
+
+| Mode | Description | Best For |
+|------|-------------|----------|
+| `default` | Balanced standard behavior | General tasks |
+| `brainstorm` | Creative exploration, more questions | Design, ideation |
+| `token-efficient` | Compressed, concise output | High-volume, cost savings |
+| `deep-research` | Thorough analysis, citations | Investigation, audits |
+| `implementation` | Code-focused, minimal prose | Executing plans |
+| `review` | Critical analysis, finding issues | Code review, QA |
+| `orchestration` | Multi-task coordination | Complex parallel work |
+
+## Mode Switching
+
+### Activate Mode
+```bash
+/mode [mode-name]
+```
+
+### Check Current Mode
+```bash
+/mode
+```
+(Shows current active mode)
+
+### Reset to Default
+```bash
+/mode default
+```
+
+## Mode Details
+
+### Default Mode
+- Standard balanced responses
+- Mix of explanation and code
+- Normal verification steps
+
+### Brainstorm Mode
+- Ask more clarifying questions
+- Present multiple alternatives
+- Explore trade-offs explicitly
+- Delay convergence on solutions
+
+### Token-Efficient Mode
+- Minimal explanations
+- Code-only responses where possible
+- Skip obvious context
+- 30-70% token savings
+
+### Deep-Research Mode
+- Thorough investigation
+- Evidence and citations
+- Confidence levels stated
+- Comprehensive analysis
+
+### Implementation Mode
+- Jump straight to code
+- Progress indicators
+- Minimal discussion
+- Execute don't deliberate
+
+### Review Mode
+- Look for issues first
+- Categorized findings
+- Severity levels
+- Actionable feedback
+
+### Orchestration Mode
+- Task breakdown
+- Parallel execution planning
+- Result aggregation
+- Coordination focus
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `--info` | Show detailed mode description |
+| `--list` | List all available modes |
+
+## Usage Examples
+
+```bash
+/mode brainstorm            # Switch to brainstorm mode
+/mode token-efficient       # Switch to efficient mode
+/mode                       # Show current mode
+/mode --list                # List all modes
+/mode default               # Reset to default
+```
+
+## Arguments
+
+$ARGUMENTS
+
+If mode name provided: switch to that mode
+If no arguments: show current mode
+If `--list`: show all modes
+
+---
+
+## Mode Persistence
+
+- Modes persist for the session
+- Explicitly switch when task type changes
+- Mode affects all subsequent responses
+- Can be overridden per-command with flags
+
+## Command Flag Override
+
+Override mode for single command:
+```bash
+/feature --mode=implementation [desc]
+/review --mode=deep-research [file]
+/plan --mode=brainstorm [task]
+```
+
+## Recommended Workflows
+
+### Feature Development
+```
+/mode brainstorm           # Explore approaches
+[discuss design]
+/mode implementation       # Execute plan
+[write code]
+/mode review               # Check quality
+[review code]
+```
+
+### Bug Investigation
+```
+/mode deep-research        # Investigate thoroughly
+[analyze bug]
+/mode implementation       # Apply fix
+[fix bug]
+/mode default              # Return to normal
+```
+
+### Cost-Conscious Session
+```
+/mode token-efficient      # Set for session
+[work on multiple tasks]
+/mode default              # Reset when done
+```
+
+## Mode Files
+
+Mode definitions are in `.claude/modes/`:
+- `default.md`
+- `brainstorm.md`
+- `token-efficient.md`
+- `deep-research.md`
+- `implementation.md`
+- `review.md`
+- `orchestration.md`
+
+Customize modes by editing these files.
+
+
+## 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/optimize.md

@@ -0,0 +1,53 @@
+# /optimize - Performance Optimization Command
+
+## Purpose
+
+Analyze and optimize code performance.
+
+## Usage
+
+```
+/optimize [file or function]
+```
+
+---
+
+Optimize: **$ARGUMENTS**
+
+## Workflow
+
+1. **Analyze Current Performance**
+   - Identify bottlenecks
+   - Check complexity
+   - Profile if possible
+
+2. **Identify Opportunities**
+   - Algorithm improvements
+   - Caching opportunities
+   - Async optimizations
+
+3. **Implement Optimizations**
+   - Make targeted changes
+   - Verify improvements
+   - Ensure correctness
+
+## Output
+
+```markdown
+## Optimization Report
+
+### Before
+- Time complexity: O(n²)
+- Estimated time: 500ms
+
+### After
+- Time complexity: O(n log n)
+- Estimated time: 50ms
+
+### Changes Made
+- [Description of optimizations]
+```
+
+
+## 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/plan.md

@@ -0,0 +1,337 @@
+# /plan - Task Planning Command
+
+## Purpose
+
+Create structured implementation plans with task breakdown, dependencies, and time estimates for complex work.
+
+## Usage
+
+```
+/plan [task description or feature request]
+```
+
+## Arguments
+
+- `$ARGUMENTS`: Description of the task, feature, or work to plan
+
+---
+
+Create a detailed implementation plan for: **$ARGUMENTS**
+
+## Workflow
+
+### Phase 1: Understanding
+
+1. **Parse Requirements**
+   - Identify core functionality needed
+   - List explicit requirements
+   - Note implicit requirements
+   - Identify acceptance criteria
+
+2. **Clarify Ambiguities**
+   - Ask questions if unclear
+   - List assumptions made
+   - Note dependencies on decisions
+
+### Phase 2: Research
+
+1. **Explore Codebase**
+   - Find related implementations
+   - Identify patterns to follow
+   - Locate integration points
+   - Note conventions
+
+2. **Technical Research** (if needed)
+   - Research unfamiliar technologies
+   - Find best practices
+   - Identify potential pitfalls
+
+### Phase 3: Task Breakdown
+
+1. **Decompose Work**
+   - Break into atomic tasks
+   - Each task: 15-60 minutes
+   - Clear completion criteria
+
+2. **Order by Dependencies**
+   - What blocks what
+   - Parallel opportunities
+   - Critical path
+
+3. **Add Estimates**
+   - S: <30 min
+   - M: 30-60 min
+   - L: 1-2 hours
+   - XL: 2-4 hours
+
+### Phase 4: Documentation
+
+1. **Create Plan Document**
+   - Summary
+   - Task list
+   - Files to modify
+   - Risks
+
+2. **Track with TodoWrite**
+   - Add all tasks
+   - Set initial status
+
+## Output
+
+### Implementation Plan
+
+```markdown
+## Plan: [Feature/Task Name]
+
+### Summary
+[2-3 sentence overview of what will be built]
+
+### Scope
+
+**In Scope**
+- [What will be done]
+
+**Out of Scope**
+- [What won't be done]
+
+**Assumptions**
+- [Key assumptions made]
+
+---
+
+### Tasks
+
+#### Phase 1: Setup [Total: Xh]
+| # | Task | Size | Depends On |
+|---|------|------|------------|
+| 1 | Create data model | M | - |
+| 2 | Set up database migration | S | 1 |
+| 3 | Add model tests | M | 1 |
+
+#### Phase 2: Core Implementation [Total: Xh]
+| # | Task | Size | Depends On |
+|---|------|------|------------|
+| 4 | Implement service layer | L | 1 |
+| 5 | Add business logic | M | 4 |
+| 6 | Write service tests | M | 5 |
+
+#### Phase 3: API Layer [Total: Xh]
+| # | Task | Size | Depends On |
+|---|------|------|------------|
+| 7 | Create API endpoints | M | 5 |
+| 8 | Add validation | S | 7 |
+| 9 | Write API tests | M | 8 |
+
+#### Phase 4: Integration [Total: Xh]
+| # | Task | Size | Depends On |
+|---|------|------|------------|
+| 10 | Integrate with frontend | M | 7 |
+| 11 | End-to-end testing | M | 10 |
+| 12 | Update documentation | S | 11 |
+
+---
+
+### Files to Create/Modify
+
+**Create**
+- `src/models/feature.py` - Data model
+- `src/services/feature.py` - Business logic
+- `src/api/feature.py` - API endpoints
+- `tests/test_feature.py` - Tests
+
+**Modify**
+- `src/api/__init__.py` - Register routes
+- `docs/api.md` - API documentation
+
+---
+
+### Dependencies
+
+**External**
+- [Package X] - For [purpose]
+
+**Internal**
+- Requires [existing feature] to be complete
+
+---
+
+### Risks
+
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| [Risk 1] | High | [How to mitigate] |
+| [Risk 2] | Medium | [How to mitigate] |
+
+---
+
+### Questions for Stakeholders
+1. [Question about requirement]
+2. [Question about edge case]
+
+---
+
+### Success Criteria
+- [ ] All tasks completed
+- [ ] Tests passing with 80%+ coverage
+- [ ] API documentation updated
+- [ ] Code reviewed and approved
+```
+
+## Plan Templates
+
+### Feature Plan
+For new functionality
+
+### Bug Fix Plan
+For debugging and fixing issues
+
+### Refactor Plan
+For code improvements
+
+### Migration Plan
+For data or system migrations
+
+## Detailed Mode (Superpowers Methodology)
+
+Use `--detailed` flag for superpowers-style plans with 2-5 minute tasks:
+
+```
+/plan --detailed [task description]
+```
+
+### Detailed Mode Features
+
+**Reference**: `.claude/skills/methodology/writing-plans/SKILL.md`
+
+When `--detailed` is specified:
+- **Bite-sized tasks**: 2-5 minutes each (vs standard 15-60 min)
+- **Exact file paths**: Always include full paths
+- **Complete code samples**: Actual code, not descriptions
+- **TDD steps per task**: Write test → verify fail → implement → verify pass → commit
+- **Expected command outputs**: Specify what success looks like
+
+### Detailed Task Template
+
+```markdown
+## Task [N]: [Task Name]
+
+**Files**:
+- Create: `path/to/new-file.ts`
+- Modify: `path/to/existing-file.ts`
+- Test: `path/to/test-file.test.ts`
+
+**Steps**:
+
+1. Write failing test
+   ```typescript
+   // Exact test code
+   ```
+
+2. Verify test fails
+   ```bash
+   npm test -- --grep "test name"
+   # Expected: 1 failing
+   ```
+
+3. Implement minimally
+   ```typescript
+   // Exact implementation code
+   ```
+
+4. Verify test passes
+   ```bash
+   npm test -- --grep "test name"
+   # Expected: 1 passing
+   ```
+
+5. Commit
+   ```bash
+   git commit -m "feat: add [feature]"
+   ```
+```
+
+### Execution After Planning
+
+Use `/execute-plan [plan-file]` for subagent-driven execution with code review gates.
+
+**Reference**: `.claude/skills/methodology/executing-plans/SKILL.md`
+
+## Flags
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `--mode=[mode]` | Use specific behavioral mode | `--mode=brainstorm` |
+| `--detailed` | Use superpowers methodology (2-5 min tasks) | `--detailed` |
+| `--depth=[1-5]` | Planning thoroughness level | `--depth=4` |
+| `--format=[fmt]` | Output format (concise/detailed/json) | `--format=detailed` |
+| `--save=[path]` | Save plan to file | `--save=plans/auth.md` |
+| `--checkpoint` | Create checkpoint after planning | `--checkpoint` |
+
+### Flag Usage Examples
+
+```bash
+/plan --detailed "implement user authentication"
+/plan --mode=brainstorm "redesign checkout flow"
+/plan --depth=5 --save=plans/migration.md "database migration"
+/plan --format=json "api endpoint structure"
+```
+
+### Mode Recommendations
+
+| Mode | Best For |
+|------|----------|
+| `default` | Standard planning |
+| `brainstorm` | Exploratory planning, multiple approaches |
+| `deep-research` | Complex features needing investigation |
+| `implementation` | Quick plans for clear tasks |
+
+## MCP Integration
+
+This command leverages MCP servers for enhanced planning:
+
+### Reasoning - Structured Planning (Primary)
+```
+ALWAYS use Reasoning for task decomposition:
+- Break complex tasks into logical thought sequences
+- Track dependencies between steps
+- Revise plan as understanding deepens
+- Use for risk identification and mitigation planning
+```
+
+### Memory - Decision Persistence
+```
+Store and recall planning context:
+- Remember decisions from previous planning sessions
+- Recall user preferences for task sizing
+- Store architectural patterns for reuse
+- Create entities for major features/components
+```
+
+### Web Search - Technology Research
+```
+When planning involves unfamiliar technologies:
+- Fetch current documentation for accurate estimates
+- Understand API patterns before estimating complexity
+- Identify potential integration challenges
+```
+
+### Filesystem - Codebase Analysis
+```
+For accurate file identification:
+- Use list_dir to understand project structure
+- Use grep_search to find existing patterns
+- Identify files to create vs modify
+```
+
+<!-- CUSTOMIZATION POINT -->
+## Variations
+
+Modify behavior via CLAUDE.md:
+- Task size definitions (standard: 15-60 min, detailed: 2-5 min)
+- Required plan sections
+- Estimation approach
+- Risk assessment criteria
+
+
+## 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/pr.md

@@ -0,0 +1,74 @@
+# /pr - Create Pull Request
+
+## Purpose
+
+Create a well-documented pull request with proper description and checks.
+
+## Usage
+
+```
+/pr [title or 'auto']
+```
+
+---
+
+Create a pull request: **$ARGUMENTS**
+
+## Workflow
+
+### Step 1: Prepare Changes
+
+```bash
+git status
+git diff main...HEAD
+```
+
+### Step 2: Verify Ready
+
+- [ ] All tests passing
+- [ ] Code reviewed
+- [ ] No merge conflicts
+- [ ] Branch pushed
+
+### Step 3: Create PR
+
+```bash
+gh pr create --title "type(scope): description" --body "$(cat <<'EOF'
+## Summary
+- [Change 1]
+- [Change 2]
+
+## Test Plan
+- [ ] Unit tests
+- [ ] Manual testing
+
+## Screenshots
+[If applicable]
+
+## Checklist
+- [ ] Tests added/updated
+- [ ] Documentation updated
+- [ ] No breaking changes
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+EOF
+)"
+```
+
+## Output
+
+```markdown
+## Pull Request Created
+
+**URL**: https://github.com/org/repo/pull/123
+**Title**: feat(auth): add OAuth support
+**Base**: main ← feature/oauth
+
+### Changes
+- 5 files changed
+- +234 -12 lines
+```
+
+
+## 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/product-plan.md

@@ -0,0 +1,36 @@
+---
+description: Ideation and Requirements Planning
+---
+
+# /product-plan Workflow
+
+This workflow transforms a rough idea into a concrete product plan and requirements document.
+
+## Steps
+
+1.  **Brainstorming & Ideation**
+    - Use key: `brainstorming`
+    - Goal: Generate feature ideas, explore alternatives, and define the core value proposition.
+    - Output: A list of prioritized features and concepts.
+
+2.  **Feasibility Check**
+    - Use key: `senior-architect`
+    - Goal: Assess technical feasibility and high-level constraints.
+    - Output: Technical risk assessment.
+
+3.  **Requirements Definition**
+    - Use key: `product-manager` (New Skill)
+    - Goal: Write detailed User Stories and Acceptance Criteria.
+    - Output: A draft Product Requirements Document (PRD).
+
+4.  **Finalize Plan**
+    - Use key: `writing-plans`
+    - Goal: Synthesize all inputs into a final `PRD.md` artifact.
+    - Instruction: Create a file named `PRD.md` in the current directory with the full plan.
+
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+
+
+## 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/production-deploy.md

@@ -0,0 +1,39 @@
+---
+description: Production Deployment
+---
+
+# /production-deploy Workflow
+
+This workflow prepares the application for production deployment.
+
+## Steps
+
+1.  **Containerization**
+    - Use key: `docker-expert`
+    - Goal: Create or optimize `Dockerfile` and `docker-compose.yml`.
+    - Output: Production-ready container configuration.
+
+2.  **Infrastructure as Code**
+    - Use key: `aws-serverless` / `vercel-deployment`
+    - Goal: Generate deployment configuration (Terraform, CDK, or Vercel/Netlify config).
+    - Instruction: Choose the provider based on user preference or project type.
+
+3.  **CI/CD Pipeline**
+    - Use key: `ci-cd-engineer`
+    - Goal: Create GitHub Actions or GitLab CI pipeline files.
+    - Output: `.github/workflows/deploy.yml` or equivalent.
+
+4.  **Pre-Flight Checks**
+    - Use key: `seo-audit`
+    - Goal: Check public-facing pages for SEO if applicable.
+
+5.  **Documentation**
+    - Use key: `security-documentation`
+    - Goal: Update `README.md` and security docs with deployment instructions.
+
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+
+
+## 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.