claude-autopm 2.11.1 → 2.12.0

package/autopm/.claude/hooks/pre-action-agent-reminder.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Action Agent Reminder Hook
+ *
+ * Reminds Claude to use specialized agents BEFORE performing tasks.
+ * This hook analyzes the user's request and suggests appropriate agents.
+ *
+ * IMPORTANT: This is a REMINDER, not a blocker. Claude can proceed,
+ * but should consider using agents for non-trivial tasks.
+ */
+
+const patterns = {
+  // Code writing patterns
+  code: {
+    patterns: [
+      /writ(e|ing) code/i,
+      /creat(e|ing) (a |an )?(function|class|component|module|api|endpoint)/i,
+      /implement(ing)?/i,
+      /add (a |an )?(feature|functionality)/i,
+      /build (a |an )?/i,
+      /develop(ing)?/i
+    ],
+    agents: [
+      'python-backend-engineer (Python)',
+      'nodejs-backend-engineer (Node.js/JavaScript)',
+      'react-frontend-engineer (React/Frontend)',
+      'bash-scripting-expert (Bash scripts)'
+    ],
+    context7: [
+      'Query Context7 for framework-specific best practices',
+      'Check API patterns and conventions',
+      'Verify current library versions and syntax'
+    ]
+  },
+
+  // Testing patterns
+  testing: {
+    patterns: [
+      /test(s|ing)?/i,
+      /unit test/i,
+      /integration test/i,
+      /e2e test/i,
+      /run.*(test|spec)/i,
+      /write.*test/i
+    ],
+    agents: [
+      'test-runner (Run and analyze tests)',
+      'frontend-testing-engineer (Frontend tests)',
+      'e2e-test-engineer (E2E tests)'
+    ],
+    context7: [
+      'mcp://context7/jest/best-practices',
+      'mcp://context7/testing/tdd-patterns',
+      'mcp://context7/<framework>/testing'
+    ]
+  },
+
+  // Database patterns
+  database: {
+    patterns: [
+      /database/i,
+      /schema/i,
+      /migration/i,
+      /query/i,
+      /sql/i,
+      /(postgres|mysql|mongodb|redis)/i
+    ],
+    agents: [
+      'postgresql-expert (PostgreSQL)',
+      'mongodb-expert (MongoDB)',
+      'redis-expert (Redis)'
+    ],
+    context7: [
+      'mcp://context7/<database>/schema-design',
+      'mcp://context7/<database>/query-optimization',
+      'mcp://context7/<database>/best-practices'
+    ]
+  },
+
+  // DevOps patterns
+  devops: {
+    patterns: [
+      /deploy(ing|ment)?/i,
+      /docker/i,
+      /kubernetes/i,
+      /k8s/i,
+      /container/i,
+      /ci\/cd/i,
+      /pipeline/i
+    ],
+    agents: [
+      'kubernetes-orchestrator (Kubernetes)',
+      'docker-containerization-expert (Docker)',
+      'terraform-infrastructure-expert (Terraform)',
+      'github-operations-specialist (GitHub Actions)'
+    ],
+    context7: [
+      'mcp://context7/kubernetes/deployment-patterns',
+      'mcp://context7/docker/best-practices',
+      'mcp://context7/terraform/infrastructure-patterns'
+    ]
+  },
+
+  // Code analysis patterns
+  analysis: {
+    patterns: [
+      /review/i,
+      /analyze/i,
+      /check.*bug/i,
+      /find.*issue/i,
+      /security/i,
+      /optimize/i
+    ],
+    agents: [
+      'code-analyzer (Bug detection, logic tracing)',
+      'security-scanning-expert (Security analysis)'
+    ],
+    context7: [
+      'mcp://context7/<language>/code-quality',
+      'mcp://context7/security/best-practices'
+    ]
+  },
+
+  // Large file patterns
+  files: {
+    patterns: [
+      /log file/i,
+      /analyze.*file/i,
+      /summarize.*file/i,
+      /parse.*(log|output)/i
+    ],
+    agents: [
+      'file-analyzer (File and log analysis)'
+    ],
+    context7: [
+      'mcp://context7/logging/analysis-patterns'
+    ]
+  }
+};
+
+function analyzeRequest(userMessage) {
+  const matches = [];
+
+  for (const [category, config] of Object.entries(patterns)) {
+    for (const pattern of config.patterns) {
+      if (pattern.test(userMessage)) {
+        matches.push({
+          category,
+          agents: config.agents,
+          context7: config.context7
+        });
+        break;
+      }
+    }
+  }
+
+  return matches;
+}
+
+function generateReminder(matches) {
+  if (matches.length === 0) {
+    return null;
+  }
+
+  let reminder = '\n🤖 AGENT USAGE REMINDER\n';
+  reminder += '━'.repeat(80) + '\n\n';
+
+  reminder += '⚠️  This task may benefit from using specialized agents:\n\n';
+
+  for (const match of matches) {
+    reminder += `📋 ${match.category.toUpperCase()} TASK DETECTED\n\n`;
+
+    reminder += '**Recommended Agents:**\n';
+    for (const agent of match.agents) {
+      reminder += `   • ${agent}\n`;
+    }
+
+    reminder += '\n**Context7 Queries:**\n';
+    for (const query of match.context7) {
+      reminder += `   • ${query}\n`;
+    }
+
+    reminder += '\n';
+  }
+
+  reminder += '📖 See: .claude/rules/agent-mandatory.md for complete guidance\n';
+  reminder += '━'.repeat(80) + '\n\n';
+
+  reminder += '💡 You can proceed directly if this is simple, but consider:\n';
+  reminder += '   1. Using agents for better quality and consistency\n';
+  reminder += '   2. Querying Context7 for up-to-date best practices\n';
+  reminder += '   3. Following TDD cycle (RED-GREEN-REFACTOR)\n\n';
+
+  return reminder;
+}
+
+function main() {
+  // Get user message from command line args or stdin
+  const args = process.argv.slice(2);
+  const userMessage = args.join(' ') || '';
+
+  if (!userMessage) {
+    // No message to analyze
+    process.exit(0);
+  }
+
+  const matches = analyzeRequest(userMessage);
+  const reminder = generateReminder(matches);
+
+  if (reminder) {
+    console.log(reminder);
+  }
+
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { analyzeRequest, generateReminder };

package/autopm/.claude/hooks/pre-commit-clear-reminder.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# Pre-Commit Clear Reminder Hook
+#
+# Detects when an issue is being closed and reminds to run /clear
+# before starting the next issue.
+
+# Get the commit message
+COMMIT_MSG_FILE="$1"
+COMMIT_MSG=$(cat "$COMMIT_MSG_FILE" 2>/dev/null || git log --format=%B -n 1 HEAD 2>/dev/null)
+
+# Patterns that indicate issue closure
+CLOSING_PATTERNS=(
+    "close #"
+    "closes #"
+    "closed #"
+    "fix #"
+    "fixes #"
+    "fixed #"
+    "resolve #"
+    "resolves #"
+    "resolved #"
+    "complete #"
+    "completes #"
+    "completed #"
+)
+
+# Check if commit message contains issue closing keywords
+issue_closed=false
+for pattern in "${CLOSING_PATTERNS[@]}"; do
+    if echo "$COMMIT_MSG" | grep -qi "$pattern"; then
+        issue_closed=true
+        break
+    fi
+done
+
+# If issue is being closed, show reminder
+if [ "$issue_closed" = true ]; then
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "🧹 CONTEXT HYGIENE REMINDER"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "⚠️  This commit closes an issue!"
+    echo ""
+    echo "📋 IMPORTANT: After this commit, run /clear before starting"
+    echo "   the next issue to prevent context bleed."
+    echo ""
+    echo "Why this matters:"
+    echo "  • Prevents mixing context from different issues"
+    echo "  • Ensures Claude starts fresh for each task"
+    echo "  • Reduces token usage"
+    echo "  • Improves response quality"
+    echo ""
+    echo "Next steps:"
+    echo "  1. ✅ Complete this commit"
+    echo "  2. 🧹 Type: /clear"
+    echo "  3. 📝 Start next issue with clean context"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Optional: Create a reminder file
+    echo "REMINDER: Run /clear before next issue" > .claude/.clear-reminder
+fi
+
+# Always allow commit to proceed
+exit 0

package/autopm/.claude/rules/agent-mandatory.md

@@ -2,12 +2,43 @@
 
 **🚨 CRITICAL: This rule has HIGHEST PRIORITY and MUST be followed for ALL tasks.**
 
+## ⚠️ BEFORE YOU START ANY TASK - READ THIS
+
+**MANDATORY SELF-CHECK:**
+
+Before doing ANYTHING complex, ask yourself:
+1. ❓ Is this writing code? → **USE AGENT**
+2. ❓ Is this testing code? → **USE test-runner**
+3. ❓ Is this analyzing code/files? → **USE code-analyzer or file-analyzer**
+4. ❓ Is this database work? → **USE database expert agent**
+5. ❓ Is this DevOps/infrastructure? → **USE DevOps agent**
+
+**If YES to ANY → STOP and USE the appropriate agent!**
+
 ## 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.
 
+### Why This Rule Exists
+
+1. **Quality**: Specialized agents have deeper expertise
+2. **Consistency**: Agents follow established patterns
+3. **Context7**: Agents query live documentation (you should too!)
+4. **TDD**: Agents enforce RED-GREEN-REFACTOR cycle
+5. **Best Practices**: Agents apply industry standards
+
+### What Happens When You Don't Use Agents
+
+❌ **Common failures:**
+- Code without tests (violates TDD)
+- Missing Context7 queries (outdated patterns)
+- Inconsistent code style
+- Security vulnerabilities
+- Performance issues
+- Missing error handling
+
 ## When to Use Agents
 
 ### ✅ ALWAYS Use Agents For:
@@ -160,11 +191,59 @@ If you're unsure whether to use an agent:
 - When in doubt, delegate to specialist
 - Better to over-use agents than under-use them
 
+## Context7 Integration - ALSO MANDATORY
+
+**In addition to using agents, you MUST query Context7 for up-to-date documentation.**
+
+### When to Query Context7
+
+**BEFORE implementing ANY code:**
+```bash
+# Query relevant documentation
+mcp://context7/<framework>/<topic>
+mcp://context7/<language>/best-practices
+mcp://context7/<library>/api-reference
+```
+
+### Why Context7 is Required
+
+1. **Up-to-date info**: Your training data may be outdated
+2. **API changes**: Libraries evolve, APIs change
+3. **Best practices**: Current industry standards
+4. **Bug fixes**: Known issues and workarounds
+
+### Examples
+
+**Writing Python FastAPI code:**
+```bash
+# Query BEFORE implementation
+mcp://context7/fastapi/routing
+mcp://context7/fastapi/validation
+mcp://context7/pydantic/models
+```
+
+**Writing React components:**
+```bash
+# Query BEFORE implementation
+mcp://context7/react/hooks
+mcp://context7/react/18.0/best-practices
+mcp://context7/typescript/react-patterns
+```
+
+**Database schema design:**
+```bash
+# Query BEFORE implementation
+mcp://context7/postgresql/schema-design
+mcp://context7/postgresql/indexing
+mcp://context7/postgresql/performance
+```
+
 ## 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?
+4. Should I query Context7 for current best practices?
 
-**If answer is YES to any → USE THE AGENT!**
+**If answer is YES to any → USE THE AGENT! AND QUERY CONTEXT7!**

package/autopm/.claude/rules/context-hygiene.md

@@ -0,0 +1,270 @@
+# Context Hygiene - MANDATORY
+
+**🧹 CRITICAL: Run `/clear` between issues to prevent context bleed.**
+
+## Core Requirement
+
+**YOU MUST CLEAR CONTEXT AFTER COMPLETING EACH ISSUE.**
+
+Context from previous issues can:
+- ❌ Cause incorrect assumptions
+- ❌ Mix concerns from different tasks
+- ❌ Waste tokens on irrelevant history
+- ❌ Reduce response quality
+
+## When to Run /clear
+
+### ✅ ALWAYS Clear After:
+
+1. **Issue/Task Completion**
+   - After merging PR that closes an issue
+   - After marking task as complete
+   - Before starting new issue
+
+2. **Context Switches**
+   - Switching between different features
+   - Moving to different part of codebase
+   - Changing from bug fix to feature development
+
+3. **Long Conversations**
+   - After 20+ messages in one issue
+   - When context window getting full
+   - When conversation becomes unfocused
+
+4. **Daily Boundaries**
+   - At end of work day
+   - At start of new work session
+   - After long breaks
+
+### 🔴 NEVER Skip /clear When:
+
+- Closing an issue (MOST IMPORTANT)
+- Starting a new issue
+- Switching work contexts
+- After merge conflicts resolved
+- After completing refactoring
+
+## How to Use /clear
+
+### Manual Trigger:
+
+```bash
+# Type this in Claude Code CLI:
+/clear
+```
+
+### Expected Behavior:
+
+```
+Claude Code: "Context cleared. Ready for next task."
+```
+
+## Enforcement
+
+### Git Hook Reminder
+
+Pre-commit hook detects issue closure and reminds:
+
+```
+🧹 CONTEXT HYGIENE REMINDER
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚠️  This commit closes an issue!
+
+📋 IMPORTANT: After this commit, run /clear before starting
+   the next issue to prevent context bleed.
+
+Next steps:
+  1. ✅ Complete this commit
+  2. 🧹 Type: /clear
+  3. 📝 Start next issue with clean context
+```
+
+### PM Command Integration
+
+PM commands include `/clear` reminders:
+
+```bash
+# After completing issue
+/pm:issue-complete 123
+
+# Output includes:
+# ✅ Issue #123 marked as complete
+# 🧹 REMINDER: Run /clear before starting next issue
+```
+
+## Workflow Integration
+
+### Standard Issue Workflow:
+
+```bash
+# 1. Start issue
+/pm:issue-start 123
+
+# 2. Work on issue...
+# ... implement, test, commit ...
+
+# 3. Complete issue
+git commit -m "fix: resolve issue #123"
+git push
+
+# 4. CLEAR CONTEXT (MANDATORY)
+/clear
+
+# 5. Start next issue with clean slate
+/pm:issue-start 124
+```
+
+### Example Violation:
+
+❌ **WRONG - No /clear:**
+```bash
+# Complete issue 123
+git commit -m "fix: issue #123"
+
+# Immediately start issue 124 (BAD!)
+/pm:issue-start 124
+# Context from #123 still present!
+```
+
+✅ **CORRECT - With /clear:**
+```bash
+# Complete issue 123
+git commit -m "fix: issue #123"
+
+# Clear context (REQUIRED)
+/clear
+
+# Now start issue 124
+/pm:issue-start 124
+# Fresh context, no bleed from #123
+```
+
+## Why This Matters
+
+### Context Bleed Examples:
+
+**Without /clear:**
+```
+Issue #123: Add user authentication
+Claude remembers: "We're working on auth..."
+
+Issue #124: Fix database query bug
+Claude thinks: "This must be related to auth system from #123"
+# WRONG ASSUMPTION - wastes time debugging wrong area
+```
+
+**With /clear:**
+```
+Issue #123: Add user authentication
+/clear
+
+Issue #124: Fix database query bug
+Claude thinks: "Fresh start, what's the actual issue?"
+# CORRECT - focuses on actual problem
+```
+
+### Token Efficiency:
+
+**Without /clear:**
+- Context window: 50k+ tokens from previous issues
+- Available for work: 150k tokens
+- Efficiency: 75%
+
+**With /clear:**
+- Context window: 5k tokens (fresh start)
+- Available for work: 195k tokens
+- Efficiency: 97.5%
+
+## Best Practices
+
+### 1. Clear After Every PR Merge
+
+```bash
+# Merge PR
+gh pr merge 123 --squash
+
+# Immediate clear
+/clear
+
+# Ready for next task
+```
+
+### 2. Clear Before Starting New Feature
+
+```bash
+# Check what's next
+/pm:backlog
+
+# Pick issue
+/pm:issue-start 125
+
+# But first...
+/clear
+
+# Now start fresh
+/pm:issue-start 125
+```
+
+### 3. Clear After Context Gets Large
+
+Check context size with:
+```bash
+# If conversation has 20+ messages
+# Or if responses become slow
+# Or if Claude seems confused
+
+# CLEAR IT
+/clear
+```
+
+## Automation Ideas
+
+### Option 1: Auto-Clear on Issue Close
+
+**PM command auto-clears:**
+```bash
+/pm:issue-complete 123
+# Automatically runs /clear internally
+```
+
+### Option 2: Clear Reminder File
+
+**Hook creates reminder:**
+```bash
+# After commit that closes issue
+# Creates: .claude/.clear-reminder
+
+# Next Claude interaction checks:
+if [ -f .claude/.clear-reminder ]; then
+  echo "⚠️  REMINDER: Run /clear before continuing"
+fi
+```
+
+### Option 3: Session Start Check
+
+**Check on session start:**
+```bash
+# In CLAUDE.md:
+## Session Start Protocol
+1. Check for .clear-reminder file
+2. If exists, warn user
+3. Remove file after /clear
+```
+
+## Summary
+
+**Context hygiene is as important as code hygiene.**
+
+### Remember:
+- 🧹 **ALWAYS** `/clear` after issue completion
+- 🧹 **ALWAYS** `/clear` before new issue
+- 🧹 **ALWAYS** `/clear` on context switch
+
+### Benefits:
+- ✅ No context bleed between issues
+- ✅ Better response quality
+- ✅ More efficient token usage
+- ✅ Clearer thinking for each task
+
+**Make `/clear` a habit, not an afterthought.**

package/autopm/.claude/scripts/check-clear-reminder.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Check for /clear reminder
+#
+# This script checks if there's a pending /clear reminder
+# and displays it to the user.
+#
+# Should be run at session start or before new commands.
+
+REMINDER_FILE=".claude/.clear-reminder"
+
+if [ -f "$REMINDER_FILE" ]; then
+    echo ""
+    echo "╔════════════════════════════════════════════════════════════════╗"
+    echo "║                   🧹 PENDING /clear REMINDER                   ║"
+    echo "╚════════════════════════════════════════════════════════════════╝"
+    echo ""
+    echo "⚠️  You have a pending context clear reminder from:"
+    echo ""
+    cat "$REMINDER_FILE"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "Why this is important:"
+    echo "  • Prevents context bleed from previous issue"
+    echo "  • Ensures fresh start for new task"
+    echo "  • Improves response quality"
+    echo "  • Reduces token waste"
+    echo ""
+    echo "Action required:"
+    echo "  1. Type: /clear"
+    echo "  2. This reminder will be automatically removed"
+    echo "  3. Then proceed with your new task"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+
+    # Optional: Block until /clear is run
+    # Uncomment to enforce /clear before proceeding:
+    # read -p "Press Enter after running /clear to continue..."
+    # rm "$REMINDER_FILE"
+fi

package/autopm/.claude/templates/claude-templates/addons/task-workflow.md

@@ -16,15 +16,9 @@
 └─────────────────────────────────────────────────────────────────────┘
 ```
 
-### 📋 Overview
-
-Every task follows a structured workflow to ensure quality, traceability, and team coordination. This workflow applies to all development tasks: features, bugs, improvements, and technical debt.
-
-**MANDATORY**: All code development MUST follow TDD (Test-Driven Development) cycle. This is not optional.
-
 ### 🎯 Core Workflow Principles
 
-1. **Follow TDD Religiously** - Test FIRST, code SECOND (see banner above)
+1. **Follow TDD Religiously** - Test FIRST, code SECOND
 2. **Work in Branches** - Never commit directly to main
 3. **Create Pull Requests** - All changes go through PR review
 4. **Resolve Conflicts** - Address merge conflicts immediately
@@ -32,134 +26,26 @@ Every task follows a structured workflow to ensure quality, traceability, and te
 6. **Merge When Ready** - Only merge after all checks pass
 7. **Mark Complete** - Update task status and move to next task
 
-### 🚀 Standard Task Workflow
-
-#### 1. Pick a Task from Backlog
-
-```bash
-# View available tasks (GitHub Issues, Azure DevOps, Jira, etc.)
-gh issue list --label="ready"
-
-# Or use project management commands
-/pm:backlog
-/azure:work-items --state=Ready
-```
-
-**Task Selection Criteria:**
-- Task has clear **Acceptance Criteria**
-- Task has **Definition of Done** documented
-- Dependencies are resolved
-- Task is properly sized (not too large)
-
-#### 2. Create Feature Branch
-
-```bash
-# Create branch from latest main
-git checkout main
-git pull origin main
-git checkout -b feature/TASK-ID-short-description
-
-# Examples:
-# git checkout -b feature/ISSUE-123-user-authentication
-# git checkout -b bugfix/ISSUE-456-fix-login-error
-# git checkout -b improvement/ISSUE-789-optimize-api
-```
-
-**Branch Naming Convention:**
-- `feature/TASK-ID-description` - New features
-- `bugfix/TASK-ID-description` - Bug fixes
-- `improvement/TASK-ID-description` - Improvements
-- `docs/TASK-ID-description` - Documentation
-- `refactor/TASK-ID-description` - Refactoring
-
-#### 3. Implement Solution
-
-**🚨 CRITICAL: ALWAYS Follow TDD Cycle (RED-GREEN-REFACTOR)**
-
-See `.claude/rules/tdd.enforcement.md` for complete TDD enforcement rules.
-
-**Before Starting:**
-```bash
-# Use specialized agents for implementation
-@python-backend-engineer implement user authentication API following TDD
-@react-frontend-engineer create login component following TDD
-@test-runner run existing tests to ensure baseline
-```
-
-**🔴 TDD STEP 1: RED Phase (Write Failing Test First)**
-
-```bash
-# ALWAYS write the test FIRST
-# Example for authentication endpoint:
-
-# 1. Create test file BEFORE implementation
-touch tests/test_authentication.py  # Python
-touch __tests__/authentication.test.ts  # TypeScript
-
-# 2. Write failing test that describes desired behavior
-# Example test:
-```
-
-```python
-# tests/test_authentication.py
-def test_user_registration_creates_user():
-    """Test that user registration creates a new user in database"""
-    response = client.post('/api/register', json={
-        'email': 'test@example.com',
-        'password': 'SecurePassword123!'
-    })
-
-    assert response.status_code == 201
-    assert 'id' in response.json()
-    assert 'token' in response.json()
-    # Test MUST fail because endpoint doesn't exist yet
-```
-
-```bash
-# 3. Run test and CONFIRM it fails
-@test-runner run authentication tests  # MUST SEE RED ❌
-
-# 4. Commit the failing test
-git add tests/test_authentication.py
-git commit -m "test: add failing test for user registration"
-```
+### 🚀 Task Execution Steps
 
-**✅ TDD STEP 2: GREEN Phase (Minimum Code to Pass)**
+#### 1. Pick Task → 2. Create Branch → 3. Implement (TDD) → 4. Verify → 5. Create PR → 6. Address Feedback → 7. Merge → 8. Complete → 9. Next Task
 
+**TDD Implementation (Step 3):**
 ```bash
-# 1. Write MINIMUM code to make test pass
-# Don't add extra features, don't over-engineer
-# Just make the test green
+# 🔴 RED: Write failing test FIRST
+touch tests/test_feature.py
+@test-runner run tests/test_feature.py  # MUST FAIL ❌
+git commit -m "test: add failing test for feature"
 
-# 2. Run test and CONFIRM it passes
-@test-runner run authentication tests  # MUST SEE GREEN ✅
-
-# 3. Commit the passing implementation
-git add src/routes/authentication.py
-git commit -m "feat: add user registration endpoint"
-```
-
-**♻️ TDD STEP 3: REFACTOR Phase (Clean Up Code)**
-
-```bash
-# 1. Improve code structure
-# 2. Remove duplication
-# 3. Enhance readability
-# 4. Run tests to ensure they STAY GREEN
-@test-runner run all tests  # ALL must be GREEN ✅
+# ✅ GREEN: Write MINIMUM code to pass
+@test-runner run tests/test_feature.py  # MUST PASS ✅
+git commit -m "feat: implement feature"
 
-# 5. Commit the refactored code
-git add .
-git commit -m "refactor: improve authentication code structure"
+# ♻️ REFACTOR: Improve while tests stay green
+@test-runner run all tests  # ALL MUST PASS ✅
+git commit -m "refactor: improve feature structure"
 ```
 
-**🔁 REPEAT TDD Cycle for Each Feature**
-
-For EVERY new function, class, or feature:
-1. 🔴 Write failing test FIRST
-2. ✅ Write minimum code to pass
-3. ♻️ Refactor while keeping tests green
-
 **Integration with Context7:**
 ```bash
 # Query documentation BEFORE implementing
@@ -168,445 +54,62 @@ mcp://context7/<framework>/authentication-patterns
 mcp://context7/<language>/test-frameworks
 ```
 
-**TDD Commit Pattern (MANDATORY):**
-```bash
-# For each feature, you MUST have this commit sequence:
-git commit -m "test: add failing test for [feature]"      # RED ❌
-git commit -m "feat: implement [feature]"                  # GREEN ✅
-git commit -m "refactor: improve [feature] structure"      # REFACTOR ♻️
-git commit -m "docs: document [feature]"                   # DOCS 📚
-```
-
-**❌ PROHIBITED (Will be rejected):**
-```bash
-# DON'T do this:
-git commit -m "feat: add feature without tests"  # ❌ NO TESTS
-git commit -m "WIP: partial implementation"      # ❌ PARTIAL CODE
-git commit -m "TODO: add tests later"            # ❌ DELAYED TESTING
-```
-
-**Commit Message Format:**
-- `test:` - Test additions/changes (ALWAYS FIRST)
-- `feat:` - New feature (AFTER test passes)
-- `refactor:` - Code refactoring (AFTER test stays green)
-- `fix:` - Bug fix (AFTER failing test reproduces bug)
-- `docs:` - Documentation
-- `perf:` - Performance improvements
-- `chore:` - Maintenance tasks
-
-#### 4. Verify Acceptance Criteria
-
-**Before Creating PR:**
-
-Check against task's **Acceptance Criteria:**
-```markdown
-Example Acceptance Criteria:
-- [ ] User can register with email and password
-- [ ] Password is hashed and stored securely
-- [ ] Registration sends confirmation email
-- [ ] User receives JWT token after successful registration
-- [ ] All tests pass (unit, integration, e2e)
-- [ ] API documentation is updated
-```
-
-**Run Quality Checks:**
-```bash
-# Run tests
-npm test          # JavaScript/TypeScript
-pytest            # Python
-go test ./...     # Go
-
-# Run linters
-npm run lint      # JavaScript/TypeScript
-ruff check        # Python
-golangci-lint run # Go
-
-# Check type safety
-npm run typecheck # TypeScript
-mypy src/         # Python
-
-# Run formatters
-npm run format    # JavaScript/TypeScript
-black .           # Python
-go fmt ./...      # Go
-```
-
-#### 5. Create Pull Request
-
-```bash
-# Push branch to remote
-git push origin feature/TASK-ID-short-description
-
-# Create PR using GitHub CLI
-gh pr create \
-  --title "Feature: TASK-ID Short Description" \
-  --body "$(cat <<'EOF'
-## Summary
-Brief description of changes
-
-## Related Issue
-Closes #TASK-ID
-
-## Acceptance Criteria
-- [x] Criterion 1
-- [x] Criterion 2
-- [x] Criterion 3
-
-## Definition of Done
-- [x] Code implemented and tested
-- [x] All tests passing
-- [x] Documentation updated
-- [x] No breaking changes (or documented)
-- [x] Security considerations addressed
-
-## Test Plan
-1. Unit tests: `npm test`
-2. Integration tests: `npm run test:integration`
-3. Manual testing: [steps performed]
-
-## Screenshots/Evidence
-[If applicable]
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-EOF
-)"
-```
-
-**PR Title Format:**
-- `Feature: TASK-ID Short description`
-- `Bugfix: TASK-ID Short description`
-- `Improvement: TASK-ID Short description`
-
-#### 6. Monitor and Address PR Feedback
-
-**Check PR Status:**
-```bash
-# View PR status
-gh pr view --web
-
-# Check for CI/CD failures
-gh pr checks
-
-# View PR comments
-gh pr view
-```
-
-**If CI/CD Fails:**
-```bash
-# Analyze failures
-@test-runner analyze failed tests
-@code-analyzer review changes for issues
-
-# Fix issues
-git add .
-git commit -m "fix: address CI failures"
-git push origin feature/TASK-ID-short-description
-```
-
-**If Merge Conflicts:**
-```bash
-# Update branch with latest main
-git checkout main
-git pull origin main
-git checkout feature/TASK-ID-short-description
-git merge main
-
-# Resolve conflicts (use specialized agents)
-@code-analyzer help resolve merge conflicts in <file>
-
-# After resolving
-git add .
-git commit -m "chore: resolve merge conflicts with main"
-git push origin feature/TASK-ID-short-description
-```
-
-**Address Review Comments:**
-```bash
-# Interpret reviewer feedback
-# Make requested changes
-git add .
-git commit -m "refactor: address PR feedback - improve error handling"
-git push origin feature/TASK-ID-short-description
-
-# Respond to comments on GitHub
-gh pr comment <PR-NUMBER> --body "Fixed as requested"
-```
-
-#### 7. Merge Pull Request
-
-**Pre-merge Checklist:**
-- [ ] All CI/CD checks passing
-- [ ] No merge conflicts
-- [ ] All review comments addressed
-- [ ] At least one approval (if required)
-- [ ] Definition of Done satisfied
-- [ ] Documentation updated
-
-**Merge:**
-```bash
-# Merge PR (using GitHub CLI)
-gh pr merge --squash --delete-branch
-
-# Or via web interface
-# Click "Squash and merge" button
-# Delete branch after merge
-```
-
-#### 8. Mark Task Complete
-
-**Update Task Status:**
-```bash
-# GitHub Issues
-gh issue close TASK-ID --comment "Completed in PR #PR-NUMBER"
-
-# Azure DevOps
-/azure:update-work-item TASK-ID --state=Closed
-
-# Jira (via MCP)
-mcp://jira/update TASK-ID status:Done
-```
-
-**Update Task Labels:**
-- Remove: `in-progress`, `ready`
-- Add: `completed`, `merged`
-
-**Verify Deployment:**
-```bash
-# Check if changes are deployed
-# (depends on your CD pipeline)
-git checkout main
-git pull origin main
-git log --oneline -5  # Verify your commit is in main
-```
-
-#### 9. Move to Next Task
-
-```bash
-# Clean up local branches
-git branch -d feature/TASK-ID-short-description
-
-# Return to main
-git checkout main
-git pull origin main
-
-# Pick next task and repeat workflow
-/pm:backlog
-gh issue list --label="ready"
-```
-
-### 🎨 Workflow Variations
-
-#### Hotfix Workflow (Production Bugs)
-
+**Quality Checks (Step 4):**
 ```bash
-# Create hotfix from main
-git checkout main
-git pull origin main
-git checkout -b hotfix/ISSUE-ID-critical-bug
-
-# Implement fix
-# ...
-
-# Create PR with HIGH PRIORITY label
-gh pr create --label="priority:high,type:hotfix"
-
-# After merge, ensure it's deployed immediately
-# Follow your emergency deployment process
+npm test          # or pytest, go test, etc.
+npm run lint      # or ruff check, golangci-lint, etc.
+npm run typecheck # or mypy, go vet, etc.
 ```
 
-#### Feature Flag Workflow
-
+**PR Creation (Step 5):**
 ```bash
-# For large features, use feature flags
-# Implement behind flag
-# Deploy to production (flag disabled)
-# Test in production environment
-# Gradually enable for users
-
-# Example:
-if (featureFlags.newAuthentication) {
-  // New implementation
-} else {
-  // Existing implementation
-}
-```
-
-### 📊 Definition of Done (Standard)
-
-Every task is **complete** when:
-
-- [ ] **Code Complete**
-  - All Acceptance Criteria met
-  - Code follows project conventions
-  - No TODOs or FIXMEs left unresolved
-
-- [ ] **Tests Pass**
-  - All unit tests passing
-  - All integration tests passing
-  - All e2e tests passing (if applicable)
-  - Code coverage meets threshold
-
-- [ ] **Quality Checks**
-  - Linters pass (no warnings)
-  - Formatters applied
-  - Type checking passes
-  - Security scan passes
-
-- [ ] **Documentation**
-  - Code comments added (why, not what)
-  - API documentation updated
-  - README updated (if needed)
-  - CHANGELOG updated (if applicable)
-
-- [ ] **Review Complete**
-  - PR created and approved
-  - All comments addressed
-  - No merge conflicts
-  - CI/CD pipeline green
-
-- [ ] **Deployed**
-  - Changes merged to main
-  - Deployed to target environment
-  - Verified in production/staging
-
-- [ ] **Task Closed**
-  - Issue/ticket closed
-  - Status updated to "completed"
-  - Labels updated
-
-### 🔍 Common Acceptance Criteria Patterns
-
-#### For Features
-```markdown
-## Acceptance Criteria
-- [ ] User can [action] with [constraints]
-- [ ] System responds with [expected output]
-- [ ] Error handling for [edge case]
-- [ ] Performance: [metric] under [threshold]
-- [ ] Security: [requirement] implemented
-- [ ] Accessibility: [WCAG level] compliance
-```
-
-#### For Bug Fixes
-```markdown
-## Acceptance Criteria
-- [ ] Bug no longer reproducible
-- [ ] Root cause identified and documented
-- [ ] Regression test added
-- [ ] Related bugs checked (not introduced)
-- [ ] Error logging improved
+git push origin feature/TASK-ID-description
+gh pr create --title "Feature: TASK-ID Description" --body "..."
 ```
 
-#### For Improvements
-```markdown
-## Acceptance Criteria
-- [ ] Performance improved by [X%]
-- [ ] Code complexity reduced
-- [ ] Technical debt addressed
-- [ ] Backward compatibility maintained
-- [ ] Migration path documented (if breaking)
-```
-
-### 🛠️ Using Specialized Agents in Workflow
-
-#### Throughout Workflow:
-```bash
-# Code Analysis
-@code-analyzer review my changes for potential issues
-@code-analyzer trace logic flow in authentication module
-
-# Testing
-@test-runner execute test suite and analyze failures
-@test-runner run only authentication-related tests
+### 📊 Definition of Done
 
-# File Analysis
-@file-analyzer summarize large log file
-@file-analyzer extract errors from CI output
+- [ ] Code Complete (Acceptance Criteria met, no TODOs)
+- [ ] Tests Pass (unit, integration, e2e, coverage threshold met)
+- [ ] Quality Checks (linters pass, formatters applied, type checking)
+- [ ] Documentation (code comments, API docs, README, CHANGELOG)
+- [ ] Review Complete (PR approved, comments addressed, CI/CD green)
+- [ ] Deployed (merged to main, deployed, verified in production)
+- [ ] Task Closed (issue closed, status updated)
 
-# Documentation
-@agent-manager document this workflow pattern
-
-# Multi-stream Work (Advanced)
-@parallel-worker coordinate feature implementation across services
-```
-
-### ⚠️ Important Reminders
+### ⚠️ Critical Rules
 
 **🚨 HIGHEST PRIORITY:**
-
-1. **FOLLOW TDD CYCLE (RED-GREEN-REFACTOR)** - This is MANDATORY, not optional
-   - 🔴 Write failing test FIRST (ALWAYS!)
-   - ✅ Write minimum code to pass (no more, no less)
-   - ♻️ Refactor while keeping tests green (never skip)
-   - See `.claude/rules/tdd.enforcement.md` for enforcement rules
-   - **ZERO TOLERANCE**: No code without tests. No exceptions.
-
-**📋 Critical Workflow Rules:**
-
-2. **ALWAYS query Context7** before implementing:
-   ```bash
-   mcp://context7/<framework>/<topic>
-   ```
-
-3. **NEVER commit code before tests**:
-   - First commit: `test: add failing test`
-   - Second commit: `feat: implement feature`
-   - Third commit: `refactor: improve structure`
-
+1. **FOLLOW TDD CYCLE** - ZERO TOLERANCE for code without tests
+2. **ALWAYS query Context7** before implementing: `mcp://context7/<framework>/<topic>`
+3. **NEVER commit code before tests** - Test first, code second, refactor third
 4. **ALWAYS use specialized agents** for non-trivial tasks
 
-5. **NEVER commit to main** - always work in branches
-
-6. **ALWAYS address PR feedback** - don't merge until resolved
-
-7. **REMEMBER Definition of Done** - not complete until all criteria met
-
-8. **VERIFY in production** - deployment is part of completion
-
-**❌ PROHIBITED PATTERNS (Auto-Reject):**
+**❌ PROHIBITED PATTERNS:**
 - Writing code before tests
 - Committing "WIP" or "TODO: add tests"
 - Partial implementations without test coverage
 - Skipping refactor phase
 - Mock services in tests (use real implementations)
 
-### 📚 Additional Resources
-
-- `.claude/rules/development-workflow.md` - Complete development patterns
-- `.claude/rules/git-strategy.md` - Git branch and merge strategies
-- `.claude/rules/tdd.enforcement.md` - Test-Driven Development requirements
-- `.claude/rules/github-operations.md` - GitHub CLI and PR management
-- `.claude/commands/pm/` - Project management command reference
-
-### 🎯 Quick Reference Commands
+### 🎯 Quick Commands
 
 ```bash
 # Start task
-/pm:backlog                    # View tasks
+/pm:backlog
 git checkout -b feature/ID-desc
 
 # During work
-@<agent> <task>               # Use specialized agents
-mcp://context7/<lib>/<topic>  # Query documentation
+@<agent> <task>
+mcp://context7/<lib>/<topic>
 git commit -m "type: message"
 
 # Before PR
-npm test                      # Run tests
-npm run lint                  # Run linters
+npm test && npm run lint
 git push origin <branch>
 
-# Create PR
+# Create & merge PR
 gh pr create
-
-# After feedback
-git merge main                # Update branch
-git push origin <branch>
-
-# Merge and complete
 gh pr merge --squash --delete-branch
 gh issue close ID
-git checkout main && git pull
-
-# Next task
-/pm:backlog
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "2.11.1",
+  "version": "2.12.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "workspaces": [