claude-flow-novice 2.18.5 → 2.18.6

package/.claude/commands/cfn-loop/cfn-loop-task.md

@@ -0,0 +1,490 @@
+---
+description: "Execute CFN Loop in Task Mode with direct agent spawning (visible in main chat)"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Bash", "SlashCommand"]
+---
+
+# CFN Loop Task Mode - Direct Agent Spawning
+
+**Version:** 1.2.0  |  **Date:** 2025-12-08  |  **Status:** Production Ready
+
+🚨 **v3.0 ARCHITECTURE:** Spawn agents directly with local MDAP orchestration support
+
+---
+
+## Quick Overview
+
+### What is Task Mode?
+
+**v3.0 Task Mode Architecture:**
+- **Direct agent spawning** in main chat using Task() tool
+- **Visible execution** - all agent work shown in real-time
+- **Local MDAP support** - agents can use orchestrator for complex tasks
+- **No external dependencies** - works without Redis or Trigger.dev
+
+### Task Mode vs CLI Mode
+
+| Feature | Task Mode | CLI Mode |
+|---------|-----------|----------|
+| Visibility | Full (agents in main chat) | Summary only |
+| Coordination | Manual (Task() tool) | Automated (local MDAP) |
+| External Deps | None | None |
+| Speed | Fast (direct spawning) | Fast (local orchestration) |
+| Control | High (manual workflow) | Automated (configured workflow) |
+
+### When to Use Task Mode
+
+- **Debugging** - Need to see agent thought process
+- **Learning** - Understanding how agents work
+- **Complex coordination** - Require custom agent interactions
+- **Rapid prototyping** - Quick iteration with direct control
+
+---
+
+## TDD Enforcement
+
+**All agents spawned in CFN Loop must follow Test-Driven Development:**
+
+```bash
+# Mandatory TDD Workflow for all agents:
+1. Write tests BEFORE implementation (Red Phase)
+2. Implement code to make tests pass (Green Phase)
+3. Refactor while keeping tests passing (Refactor Phase)
+4. Run tests after each implementation step
+5. Ensure tests cover all functionality and edge cases
+```
+
+**TDD Requirements:**
+- Test files must exist for each implementation file
+- Tests must be written at or before implementation time
+- All tests must pass before task completion
+- Minimum coverage thresholds apply (based on mode)
+
+**Post-Edit Pipeline (Required):**
+After ANY file modification, agents MUST invoke:
+```bash
+./.claude/hooks/cfn-invoke-post-edit.sh "$FILE_PATH" --agent-id "$AGENT_ID"
+```
+This validates compilation and TDD compliance automatically.
+
+---
+
+## RuVector Integration
+
+**RuVector** (Rust-based vector database) provides semantic intelligence for Task Mode agents. Available features:
+
+**Semantic Codebase Search:**
+```bash
+# Search codebase before implementing
+/codebase-search "authentication middleware patterns"
+# Returns: Relevant code snippets with semantic similarity scores
+```
+
+**Stale Documentation Detection:**
+```bash
+# Find outdated docs before refactoring
+/detect-stale-docs
+# Returns: Documents semantically distant from current code
+```
+
+**Automatic Indexing:**
+```bash
+# Reindex after major changes
+/codebase-reindex
+# Updates: Vector embeddings of all code files
+```
+
+**Usage in Task Mode:**
+- Agents can call `/codebase-search` via Skill() tool before implementing
+- Main Chat can search context before spawning agents
+- Post-commit hook auto-reindexes (optional: `.claude/hooks/post-commit-codebase-index`)
+
+**Manual Learning & Error Tracking:**
+```bash
+# After task failure - store error pattern for future avoidance
+./.claude/skills/ruvector-codebase-index/store-error-pattern.sh \
+  --task-id "task-123" \
+  --error-type "TypeScript compilation" \
+  --pattern "Missing type imports in multi-file refactor" \
+  --context "Files: auth.ts, types.ts, middleware.ts" \
+  --solution "Always add type imports before interface usage"
+```
+
+
+## Execution Instructions (AUTO-EXECUTE)
+
+**Step 1: Parse Arguments**
+```bash
+# Extract task description (remove flags)
+TASK_DESCRIPTION="$ARGUMENTS"
+TASK_DESCRIPTION=$(echo "$TASK_DESCRIPTION" | sed 's/--mode[[:space:]]*[a-zA-Z]*//' | xargs)
+
+# Parse optional flags
+MODE="standard"
+
+for arg in $ARGUMENTS; do
+  case $arg in
+    --mode=*)
+      MODE="${arg#*=}"
+      ;;
+    --mode)
+      shift
+      MODE="$1"
+      ;;
+  esac
+done
+
+# Validate mode
+if [[ ! "$MODE" =~ ^(mvp|standard|enterprise)$ ]]; then
+  echo "❌ ERROR: Invalid mode '$MODE'. Must be one of: mvp, standard, enterprise"
+  exit 1
+fi
+```
+
+**Step 2: Generate Task ID**
+```bash
+# Generate unique task ID
+TASK_ID="cfn-task-$(date +%s%N | tail -c 7)-${RANDOM}"
+
+echo "📋 Task ID: $TASK_ID"
+echo "🎯 Mode: $MODE"
+echo "📝 Task: ${TASK_DESCRIPTION:0:100}..."
+echo ""
+```
+
+**Step 3: Spawn Task Mode Agents**
+```bash
+# Define agent workflow based on mode
+case $MODE in
+  "mvp")
+    # MVP: Fast cycle with 2 agents
+    echo "🚀 MVP Mode - Spawning 2 agents for rapid prototyping..."
+    Task("backend-developer", `
+      LIFECYCLE:
+      AGENT_ID="backend-dev-${TASK_ID}"
+
+      TASK: Implement MVP solution for: ${TASK_DESCRIPTION}
+
+      TDD Requirements:
+      - Write tests BEFORE implementation
+      - Create test files for each implementation file
+      - Ensure tests pass before completion
+      - Run tests after each implementation step
+      - Call post-edit pipeline after each file change
+
+      RuVector Requirements:
+      - Before implementing, query for similar patterns:
+        /codebase-search "${TASK_DESCRIPTION}" --top 3
+      - Query past errors: ./.claude/skills/cfn-ruvector-codebase-index/query-error-patterns.sh --task-description "${TASK_DESCRIPTION}"
+      - Focus on speed over perfection but avoid duplication
+
+      Use local MDAP orchestration for complex tasks:
+      - Import from lib/mdap/orchestrator.js
+      - Call orchestrate() with appropriate payload
+      - Focus on speed over perfection
+
+      Return: Implementation summary and confidence score
+    `)
+
+    Task("tester", `
+      LIFECYCLE:
+      AGENT_ID="tester-${TASK_ID}"
+
+      TASK: Test MVP implementation for: ${TASK_DESCRIPTION}
+
+      Create basic tests to verify core functionality:
+      - Unit tests for key functions
+      - Integration tests for main flows
+      - Keep tests simple and fast
+
+      Return: Test results and coverage summary
+    `)
+    ;;
+
+  "standard")
+    # Standard: Full workflow with 3-4 agents
+    echo "🚀 Standard Mode - Spawning 3-4 agents for production quality..."
+    Task("backend-developer", `
+      LIFECYCLE:
+      AGENT_ID="backend-dev-${TASK_ID}"
+
+      TASK: Implement production solution for: ${TASK_DESCRIPTION}
+
+      TDD Requirements:
+      - Write tests BEFORE implementation (Red-Green-Refactor)
+      - Create comprehensive test files for each implementation
+      - Ensure >80% test coverage before completion
+      - Run tests after each implementation step
+      - Call post-edit pipeline after each file change
+
+      RuVector Requirements:
+      - Before implementing, ALWAYS query for similar patterns:
+        /codebase-search "${TASK_DESCRIPTION}" --top 5
+        /codebase-search "implementation pattern for ${TASK_DESCRIPTION}" --top 3
+      - Query past errors and learnings:
+        ./.claude/skills/cfn-ruvector-codebase-index/query-error-patterns.sh --task-description "${TASK_DESCRIPTION}"
+        ./.claude/skills/cfn-ruvector-codebase-index/query-learnings.sh --task-description "${TASK_DESCRIPTION}" --category PATTERN
+      - Use findings to avoid duplication and leverage existing solutions
+
+      Use local MDAP orchestration for comprehensive development:
+      - Import from lib/mdap/orchestrator.js
+      - Call orchestrate() with mode: 'standard'
+      - Include error handling and validation
+      - Follow coding standards and best practices
+
+      Return: Implementation details, files created/modified, confidence score
+    `)
+
+    Task("tester", `
+      LIFECYCLE:
+      AGENT_ID="tester-${TASK_ID}"
+
+      TASK: Create comprehensive test suite for: ${TASK_DESCRIPTION}
+
+      Develop full test coverage:
+      - Unit tests (target >80% coverage)
+      - Integration tests
+      - Edge case testing
+      - Performance tests if applicable
+
+      Return: Test report with coverage metrics
+    `)
+
+    Task("code-reviewer", `
+      LIFECYCLE:
+      AGENT_ID="reviewer-${TASK_ID}"
+
+      TASK: Review implementation and tests for: ${TASK_DESCRIPTION}
+
+      Perform thorough code review:
+      - Check code quality and standards
+      - Verify security considerations
+      - Assess performance implications
+      - Validate test coverage
+
+      Return: Review findings and recommendations
+    `)
+
+    # Optional security agent for sensitive tasks
+    if [[ "$TASK_DESCRIPTION" =~ (auth|security|password|token|jwt|encryption| compliance) ]]; then
+      Task("security-specialist", `
+        LIFECYCLE:
+        AGENT_ID="security-${TASK_ID}"
+
+        TASK: Security audit for: ${TASK_DESCRIPTION}
+
+        Conduct security review:
+        - Identify vulnerabilities
+        - Check OWASP top 10 compliance
+        - Verify secure coding practices
+        - Recommend security improvements
+
+        Return: Security assessment report
+      `)
+    fi
+    ;;
+
+  "enterprise")
+    # Enterprise: Comprehensive workflow with 5+ agents
+    echo "🚀 Enterprise Mode - Spawning 5+ agents for compliance-grade solution..."
+    Task("backend-developer", `
+      LIFECYCLE:
+      AGENT_ID="backend-dev-${TASK_ID}"
+
+      TASK: Implement enterprise-grade solution for: ${TASK_DESCRIPTION}
+
+      TDD Requirements:
+      - Write tests BEFORE implementation (Strict TDD)
+      - Create comprehensive test suites for each implementation
+      - Ensure >95% test coverage before completion
+      - Include integration, E2E, performance, and security tests
+      - Run tests after each implementation step
+      - Call post-edit pipeline after each file change
+
+      RuVector Requirements:
+      - Before implementing, perform comprehensive analysis:
+        /codebase-search "${TASK_DESCRIPTION}" --top 10
+        /codebase-search "enterprise implementation pattern for ${TASK_DESCRIPTION}" --top 5
+        /codebase-search "compliance requirements for ${TASK_DESCRIPTION}" --top 3
+      - Query all relevant knowledge bases:
+        ./.claude/skills/cfn-ruvector-codebase-index/query-error-patterns.sh --task-description "${TASK_DESCRIPTION}"
+        ./.claude/skills/cfn-ruvector-codebase-index/query-learnings.sh --task-description "${TASK_DESCRIPTION}" --category PATTERN
+        ./.claude/skills/cfn-ruvector-codebase-index/query-learnings.sh --task-description "${TASK_DESCRIPTION}" --category COMPLIANCE
+      - Document analysis and findings in implementation
+
+      Use local MDAP orchestration with enterprise settings:
+      - Import from lib/mdap/orchestrator.js
+      - Call orchestrate() with mode: 'enterprise'
+      - Include comprehensive error handling
+      - Add extensive logging and monitoring
+      - Ensure compliance with standards
+
+      Return: Detailed implementation with compliance notes
+    `)
+
+    Task("tester", `
+      LIFECYCLE:
+      AGENT_ID="tester-${TASK_ID}"
+
+      TASK: Create enterprise test suite for: ${TASK_DESCRIPTION}
+
+      Develop comprehensive testing:
+      - Unit tests (>95% coverage required)
+      - Integration tests
+      - End-to-end tests
+      - Performance and load tests
+      - Security tests
+      - Compliance validation tests
+
+      Return: Full test report with compliance metrics
+    `)
+
+    Task("code-reviewer", `
+      LIFECYCLE:
+      AGENT_ID="reviewer-${TASK_ID}"
+
+      TASK: Enterprise code review for: ${TASK_DESCRIPTION}
+
+      Perform rigorous review:
+      - Code quality and maintainability
+      - Performance optimization
+      - Security best practices
+      - Compliance requirements
+      - Documentation completeness
+
+      Return: Detailed review with compliance checklist
+    `)
+
+    Task("security-specialist", `
+      LIFECYCLE:
+      AGENT_ID="security-${TASK_ID}"
+
+      TASK: Enterprise security assessment for: ${TASK_DESCRIPTION}
+
+      Comprehensive security review:
+      - Threat modeling
+      - Vulnerability assessment
+      - OWASP top 10 analysis
+      - Compliance audit (GDPR, SOC2, etc.)
+      - Security architecture review
+
+      Return: Full security assessment with remediation plan
+    `)
+
+    Task("performance-specialist", `
+      LIFECYCLE:
+      AGENT_ID="performance-${TASK_ID}"
+
+      TASK: Performance analysis for: ${TASK_DESCRIPTION}
+
+      Evaluate performance characteristics:
+      - Benchmark current performance
+      - Identify bottlenecks
+      - Optimization recommendations
+      - Scalability assessment
+      - Resource usage analysis
+
+      Return: Performance report with optimization roadmap
+    `)
+    ;;
+esac
+```
+
+**Step 4: Await Agent Completion**
+```bash
+# Task Mode agents complete synchronously in main chat
+# No additional coordination needed - Task() tool handles completion
+echo ""
+echo "⏳ Waiting for agent completion..."
+echo ""
+echo "✅ All Task Mode agents spawned successfully"
+echo "📊 Results will appear as agents complete"
+```
+
+**Step 5: Report Summary**
+```bash
+# Collect results from completed agents
+# Results are visible in main chat as agents complete
+
+echo ""
+echo "=== TASK MODE SUMMARY ==="
+echo "Task ID: $TASK_ID"
+echo "Mode: $MODE"
+echo "Task: ${TASK_DESCRIPTION:0:200}..."
+echo ""
+echo "Review agent outputs above for:"
+echo "  • Implementation details"
+echo "  • Test results and coverage"
+echo "  • Code review findings"
+echo "  • Security assessment (if applicable)"
+echo "  • Performance analysis (if applicable)"
+```
+
+---
+
+## Gate Check Thresholds
+
+Loop 3 gate checks are based on test pass rates:
+
+| Mode | Pass Rate Threshold |
+|------|-------------------|
+| MVP | 70% |
+| Standard | 95% |
+| Enterprise | 98% |
+
+---
+
+## Security Considerations
+
+- All agent execution visible in main chat
+- No background processes or hidden coordination
+- Direct control over agent lifecycle
+- Local MDAP includes security validation
+
+---
+
+## Performance Characteristics
+
+- **Startup**: Instant (no external service initialization)
+- **Execution**: Parallel agent execution
+- **Memory**: Managed by main chat session
+- **Cleanup**: Automatic (no persistent processes)
+
+---
+
+## Local MDAP Integration
+
+Agents in Task Mode can use local MDAP:
+
+```javascript
+// Agent can import and use MDAP orchestrator
+import { orchestrate } from "./lib/mdap/orchestrator.js";
+
+const result = await orchestrate({
+  taskDescription: "Complex subtask",
+  workDir: "./src",
+  mode: "standard"
+});
+```
+
+This allows:
+- Decomposition of complex tasks
+- Parallel implementation
+- Automated testing and validation
+- Iterative improvement
+
+---
+
+## Related Documentation
+
+- **CLI Mode Guide**: `.claude/commands/cfn-loop/cfn-loop-cli.md`
+- **Frontend CFN Loop**: `.claude/commands/cfn-loop/CFN_LOOP_FRONTEND.md`
+- **Agent Lifecycle**: `.claude/agents/SHARED_PROTOCOL.md`
+- **Post-Edit Pipeline**: `.claude/hooks/cfn-post-edit.config.json`
+
+---
+
+**Version History:**
+- v1.2.0 (2025-12-08) - Added TDD enforcement and merged documentation
+- v1.1.0 (2025-12-01) - Added RuVector integration, semantic search
+- v1.0.0 (2025-10-28) - Initial Task mode implementation

package/.claude/commands/cfn-loop/cfn-loop-trigger.md

@@ -0,0 +1,56 @@
+---
+description: "DEPRECATED: CFN Loop trigger.dev mode has been removed"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise] [--test-command=<cmd>] [--pass-rate=<0.0-1.0>]"
+allowed-tools: ["Bash", "TodoWrite", "Read"]
+---
+
+# ⚠️ DEPRECATED: CFN Loop trigger.dev Mode
+
+**This command has been deprecated and is no longer functional.**
+**Trigger.dev has been removed from the CFN Loop architecture.**
+
+## Migration Path
+
+Use one of the following alternatives:
+
+### 1. CLI Mode (Recommended for production)
+```bash
+/cfn-loop-cli "Task description" --mode=standard --provider kimi
+```
+
+### 2. Task Mode (For debugging/development)
+```bash
+/cfn-loop-task "Task description" --mode=standard
+```
+
+## Architecture Changes
+
+**Previous State:**
+- CFN Loop used trigger.dev for orchestration
+- Required Redis for coordination
+- Dashboard at http://localhost:3040
+- MDAP (Massively Decomposed Agentic Processes) support
+
+**Current State:**
+- CFN Loop uses local `lib/mdap/` orchestration
+- Local Promise.all() implementation
+- No external dependencies required
+- All functionality preserved with improved performance
+
+## Removal Details
+
+The trigger.dev infrastructure was completely removed in Sprint 5.4 (2025-12-07):
+- Removed 302MB of infrastructure code
+- Migrated core logic to `lib/mdap/`
+- Eliminated external dependencies
+- Improved system reliability and performance
+
+## Documentation
+
+For current CFN Loop architecture and usage:
+- See: `.claude/commands/cfn-loop/cfn-loop-cli.md`
+- See: `.claude/commands/cfn-loop/cfn-loop-task.md`
+- Migration report: `planning/phases/sprints/SPRINT_5_4_COMPLETION_REPORT.md`
+
+---
+*Last updated: 2025-12-09*

package/.claude/commands/cfn-loop/cfn-mode.md

@@ -0,0 +1,20 @@
+---
+name: cfn-mode
+description: Toggle CFN Loop v3 spawning mode (cli vs task) for cost optimization or debugging
+---
+
+Toggle between CLI spawning (cost-optimized, Z.ai routing) and Task spawning (simplified, full visibility).
+
+**Usage:**
+/cfn-mode cli      # Enable CLI spawning (default, 95-98% savings)
+/cfn-mode task     # Enable Task spawning (debugging, full visibility)
+/cfn-mode status   # Show current mode
+
+**Current Mode:**
+Check `.cfn-mode.json` or run `/cfn-mode status`
+
+**Mode Details:**
+- **CLI Mode**: Coordinator → orchestrator → CLI agents (Z.ai routing)
+- **Task Mode**: main chat is Coordinator → JSON → Main Chat spawns Task() agents (Anthropic)
+
+Only CLI mode use Redis context storage for swarm recovery.

package/.claude/commands/cfn-loop/cfn-optimize-agents.md

@@ -0,0 +1,103 @@
+---
+name: cfn-optimize-agents
+description: |
+  Optimize agent profiles for CFN loops, CLI commands, and swarm coordination using cli-agent-optimizer agents.
+  Launches multiple cli-agent-optimizer agents in parallel to review and optimize existing agent profiles.
+  Triggers CFN coordinators for autonomous optimization execution.
+
+parameters:
+  - name: scope
+    type: string
+    default: all
+    description: Optimization scope (all, core, specialized)
+    required: false
+  - name: agents
+    type: string
+    description: Specific agent types to optimize (comma-separated)
+    required: false
+  - name: parallel
+    type: number
+    default: 3
+    description: Number of parallel optimizer agents to run
+    required: false
+
+examples:
+  - /cfn-optimize-agents
+  - /cfn-optimize-agents --scope=all
+  - /cfn-optimize-agents --scope=core --parallel=3
+  - /cfn-optimize-agents --agents=coder,architect,tester --parallel=5
+  - /cfn-optimize-agents --scope=specialized --parallel=5
+
+category: cfn-loop
+subcategory: optimization
+---
+
+# CFN Optimize Agents
+
+Optimize agent profiles for CFN loops, CLI commands, and swarm coordination using multiple cli-agent-optimizer agents.
+
+## Usage
+
+```bash
+/cfn-optimize-agents [options]
+```
+
+## Options
+
+- `--scope=<scope>` - Optimization scope (all, core, specialized) [default: all]
+- `--agents=<types>` - Specific agent types to optimize (comma-separated)
+- `--parallel=<count>` - Number of parallel optimizer agents [default: 3]
+
+## Examples
+
+Basic optimization:
+```bash
+/cfn-optimize-agents
+```
+
+Core agents only with 5 parallel optimizers:
+```bash
+/cfn-optimize-agents --scope=core --parallel=5
+```
+
+Specific agents with more parallel workers:
+```bash
+/cfn-optimize-agents --agents=coder,architect,tester --parallel=5
+```
+
+## What It Does
+
+1. **Launches** a coordinator agent via Task tool to manage the optimization process
+2. **Discovers** all agent profiles in .claude/agents/cfn-dev-team/ directory structure
+3. **Distributes** profiles evenly among parallel optimizers (zero overlap)
+4. **Coordinates** parallel work via Redis pub/sub messaging
+5. **Spawns** multiple cli-agent-optimizer agents via CLI with specific assignments
+6. **Monitors** progress and ensures complete coverage of all profiles
+7. **Aggregates** results and validates all optimizations are completed
+
+## Coordinator-Managed Integration
+
+This command triggers autonomous optimization execution with:
+- **Coordinator Agent**: Manages distribution, monitoring, and aggregation via Task tool
+- **Profile Distribution**: Intelligent assignment to prevent overlap (15-20 profiles per optimizer)
+- **Parallel Optimization**: 1-10 cli-agent-optimizer agents with non-overlapping work
+- **Redis Coordination**: Real-time progress tracking via pub/sub channels
+- **Quality Assurance**: Verification of complete coverage and confidence scores
+- **Overlap Prevention**: Ensures zero duplication across optimizer assignments
+
+## Output
+
+- Optimized agent profiles with improved structure
+- Enhanced CLI commands with better error handling
+- Improved Redis coordination patterns
+- Performance metrics and improvement measurements
+- Optimization recommendations and best practices
+
+## Coordinator Pattern Benefits
+
+- **Zero Overlap**: Intelligent distribution prevents duplicate work across optimizers
+- **Complete Coverage**: Coordinator ensures all discovered profiles are assigned and optimized
+- **Real-time Monitoring**: Redis pub/sub coordination provides live progress tracking
+- **Quality Assurance**: Confidence score monitoring and validation of all optimizations
+- **Scalable**: Supports 1-10 parallel optimizers with automatic workload balancing
+- **Fault Tolerant**: Coordinator handles failed assignments and redistributes work