Agents

> Launch code-explorer to trace how user authentication works

Entry Points:
- src/app.js:23 - Login route handler
- src/middleware/auth.js:12 - Authentication middleware

Execution Flow:
1. Request received at /auth/login (app.js:23)
2. Validate credentials (auth/validate.js:45)
3. Hash password check (auth/hash.js:67)
4. Database query (db/users.js:89)
5. Generate JWT token (auth/jwt.js:34)
6. Return token to client (app.js:56)

Key Files:
- src/app.js:23-67 - Main authentication logic
- src/auth/validate.js:45-78 - Input validation
- src/auth/hash.js:67-92 - Password hashing

> Launch code-architect to design a caching layer for the API

Architecture Design: API Caching Layer

Approach: Redis-based cache with middleware pattern

Components:
1. CacheMiddleware (src/middleware/cache.js)
   - Intercepts requests
   - Checks cache before handler
   - Stores responses after handler

2. RedisClient (src/cache/redis.js)
   - Connection management
   - Get/set operations
   - TTL management

3. CacheKeyGenerator (src/cache/keys.js)
   - Generates consistent keys
   - Handles query parameters
   - Version support

Implementation Order:
1. Set up Redis client and connection
2. Create cache key generator
3. Build middleware
4. Integrate with existing routes
5. Add cache invalidation logic

> Launch code-reviewer to check my recent changes

Code Review Results (Confidence-filtered ≥80%)

Critical Issues:
1. [Bug] Unhandled promise rejection (src/api.js:67)
   Confidence: 95%
   Fix: Add .catch() handler or wrap in try-catch

2. [Security] SQL injection risk (src/db/users.js:89)
   Confidence: 90%
   Fix: Use parameterized queries

Important Issues:
1. [Quality] Duplicate code in handlers (src/api/*.js)
   Confidence: 85%
   Suggestion: Extract to shared utility

2. [Convention] Missing JSDoc comments (src/utils/helpers.js)
   Confidence: 80%
   CLAUDE.md reference: "All exported functions must have JSDoc"

---
description: Analyze API endpoint performance
model: claude-sonnet-4.6
tools: ["Read", "Grep", "Bash"]
---

# API Performance Analyzer

Analyze the specified API endpoint for performance issues:

1. Find the endpoint implementation
2. Identify:
   - Database queries (N+1 problems)
   - Synchronous operations
   - Missing indexes
   - Large data transfers
3. Check for caching opportunities
4. Review error handling overhead
5. Suggest optimizations with examples

Endpoint to analyze: $ARGUMENTS

> Launch api-performance-analyzer for /users/:id

---
# Required
description: Short description for agent selection

# Optional
model: claude-sonnet-4.6           # Model to use
tools: ["Read", "Grep", "Bash"]    # Allowed tools
isolation: worktree                 # Run in isolated git worktree
background: true                    # Always run as background task
memory: project                     # Memory scope (user/project/local)
---

tools: ["Read", "Grep", "Glob"]  # Read-only agent

isolation: none

isolation: worktree

memory: project  # Remembers across sessions in this project

> How does the payment processing work?

> Launch code-architect to design the user notification system

> Launch 3 code-explorer agents:
  1. Trace the authentication flow
  2. Analyze the database layer
  3. Map the API routes

> Launch code-reviewer in the background

background: true

> Launch a team to build the user dashboard:
  - code-explorer: Analyze existing dashboard patterns
  - code-architect: Design the new dashboard
  - Implementation agent: Build the components
  - code-reviewer: Review the implementation

> /tasks

---
description: Implement feature after design
dependencies: ["architect-agent"]
---

Agent: code-explorer [Complete]
Found 5 API endpoints using the /auth prefix

Agent: code-reviewer [Complete]
Detailed results: /tmp/claude/agent-12345.txt

{
  "issues": [
    {
      "severity": "critical",
      "file": "src/api.js",
      "line": 67,
      "description": "Unhandled promise rejection",
      "confidence": 0.95
    }
  ]
}

Launch 2-3 code-explorer agents:
- Find similar features
- Map architecture
- Analyze current implementation

Launch 2-3 code-architect agents:
- Minimal change approach
- Clean architecture approach
- Pragmatic balance approach

Launch 3 code-reviewer agents:
- Simplicity/DRY/elegance
- Bugs/functional correctness
- Conventions/abstractions

> /review-pr --aspects all

> I'm seeing memory leaks in production. Launch code-explorer
  to trace all object allocations and retention paths.

{
  "hooks": {
    "events": ["SubagentStop"],
    "command": "./notify-completion.sh"
  }
}

If the codebase is large, launch 3 code-explorer sub-agents
to analyze different modules in parallel.

tools: ["Task(code-explorer)", "Task(code-reviewer)"]

> Launch 3 agents in parallel:
  - code-explorer for auth
  - code-explorer for API
  - code-explorer for database

> Launch code-explorer for auth
> (wait for completion)
> Launch code-explorer for API

> Run the full test suite in the background while I review the code

> Launch 3 code-explorer agents to analyze the payment system:
  1. Trace the checkout flow from cart to confirmation
  2. Analyze payment gateway integration and error handling
  3. Map database transactions and rollback logic

> Launch 3 code-architect agents for the notification system:
  1. Minimal approach: extend existing email service
  2. Clean approach: dedicated notification service with providers
  3. Pragmatic approach: notification queue with worker pattern

> Launch 3 code-reviewer agents for @src/api/payments.js:
  1. Security review (SQL injection, XSS, auth issues)
  2. Performance review (N+1 queries, caching, indexing)
  3. Maintainability review (DRY, complexity, documentation)