claude-flow-novice 2.8.1 → 2.9.0

package/.claude/templates/bulk-optimization-strategy.md

@@ -1,367 +0,0 @@
-# Bulk Agent Optimization Strategy
-
-**Target:** 83 remaining agents (38,965 lines)
-**Goal:** Reduce to 200-250 lines per agent (~16,600-20,750 lines total)
-**Expected reduction:** 18,215-22,365 lines (47-57%)
-
----
-
-## Agent Categories & Priorities
-
-### Priority 1: Large Coordinators/CFN (6 files, 6,267 lines → ~1,500 lines)
-**Savings:** ~4,800 lines (77%)
-
-| File | Lines | Target | Templates |
-|------|-------|--------|-----------|
-| product-owner.md | 1306 | 250 | cfn-loop, redis, memory, team |
-| cfn-coordinator-unified.md | 974 | 200 | cfn-loop, redis, memory |
-| mesh-coordinator.md | 936 | 200 | redis, team |
-| adaptive-coordinator.md | 660 | 200 | redis, team |
-| adaptive-coordinator-enhanced.md | 534 | 200 | redis, team |
-| hierarchical-coordinator.md | 608 | 200 | redis, team |
-
-### Priority 2: Testing/Validation (8 files, 5,999 lines → ~1,800 lines)
-**Savings:** ~4,200 lines (70%)
-
-| File | Lines | Target | Templates |
-|------|-------|--------|-----------|
-| interaction-tester.md | 1204 | 250 | team, redis, memory, post-edit |
-| production-validator.md (2) | 1443 | 500 | team, redis, memory, post-edit |
-| tdd-london-swarm.md | 668 | 200 | team, redis, memory |
-| interaction-tester.md (testing/) | 533 | 200 | team, redis, memory |
-
-### Priority 3: Analysis/Performance (3 files, 2,437 lines → ~650 lines)
-**Savings:** ~1,800 lines (74%)
-
-| File | Lines | Target | Templates |
-|------|-------|--------|-----------|
-| code-analyzer.md | 1025 | 250 | team, redis, memory, post-edit |
-| perf-analyzer.md | 820 | 200 | team, redis, memory |
-| context-curator.md | 592 | 200 | team, redis, memory |
-
-### Priority 4: SPARC/Planning (10 files, 6,392 lines → ~2,200 lines)
-**Savings:** ~4,200 lines (66%)
-
-| File | Lines | Target | Templates |
-|------|-------|--------|-----------|
-| refinement.md | 775 | 200 | team, redis, memory, post-edit |
-| architecture.md | 715 | 200 | team, redis, memory |
-| pseudocode.md | 561 | 200 | team, redis |
-| api-designer-persona.md | 752 | 250 | team, redis |
-| security-architect-persona.md | 660 | 200 | team, redis |
-| system-architect-persona.md | 602 | 200 | team, redis |
-| system-architect.md | 642 | 200 | team, redis, memory |
-| Others (3 files) | 1685 | 550 | team, redis |
-
-### Priority 5: Consensus/Specialized (8 files, 4,177 lines → ~1,800 lines)
-**Savings:** ~2,400 lines (57%)
-
-| File | Lines | Target | Templates |
-|------|-------|--------|-----------|
-| goal-planner.md | 832 | 250 | team, redis, memory |
-| security-manager.md | 556 | 200 | team, redis, memory |
-| blocking-coordinator-example (2) | 1508 | 400 | redis, team |
-| task-coordinator.md | 681 | 250 | team, redis, memory |
-| mobile-dev.md | 548 | 200 | team, redis, memory |
-| Others | ~50 | ~250 | team, redis |
-
-### Priority 6: Remaining Workers (46 files, ~13,693 lines → ~10,000 lines)
-**Savings:** ~3,700 lines (27%)
-
-Most already <300 lines, quick optimization:
-- Add team-dynamics.md reference
-- Extract Redis/memory patterns
-- Target: 200-250 lines each
-
----
-
-## Standard Optimization Pattern
-
-### Every Agent Gets
-
-**1. Team Dynamics Section**
-```markdown
-## Team Role Awareness
-
-→ See: `.claude/templates/team-dynamics.md`
-
-**Your role adapts based on team:**
-- **Solo:** [Full responsibility] - confidence ≥0.80
-- **With [Specialist]:** [Collaboration pattern]
-- **Authority:** [High/Medium/Implementation]
-
-**Communication:**
-- Check team: `redis-cli smembers "swarm:${swarm_id}:agents"`
-- Questions: `swarm:${swarm_id}:questions`
-- Progress: `agent:${AGENT_ID}:progress`
-- Completion: `swarm:${swarm_id}:${role}:${AGENT_ID}:done`
-```
-
-**2. Redis Coordination Reference**
-```markdown
-## Redis Coordination
-
-→ See: `.claude/templates/redis-coordination.md`
-
-**Quick reference:**
-- Signal progress: `redis-cli publish "swarm:${SWARM_ID}:${AGENT_ID}:progress"`
-- Report completion: `redis-cli publish "swarm:${SWARM_ID}:${AGENT_ID}:complete"`
-```
-
-**3. Memory Operations Reference**
-```markdown
-## Memory Management
-
-→ See: `.claude/templates/memory-operations.md`
-
-**Quick reference:**
-- SQLite: `memory.set(key, value, {agentId, aclLevel})`
-- Redis: `redis-cli setex "key" 3600 "value"`
-```
-
-**4. Post-Edit Validation Reference**
-```markdown
-## Post-Edit Validation
-
-→ See: `.claude/templates/post-edit-validation.md`
-
-**Critical:** Run hook after every Edit/Write operation
-```
-
-**5. CFN Loop Reference (if applicable)**
-```markdown
-## CFN Loop Integration
-
-→ See: `.claude/templates/cfn-loop-mechanics.md`
-
-**Mode:** [MVP/Standard/Enterprise]
-- Gate: [threshold]
-- Consensus: [threshold]
-```
-
----
-
-## Extraction Rules
-
-### Remove (Extract to Templates)
-
-1. **Redis patterns** (200-400 lines typically)
-   - LPUSH/BLPOP mechanics
-   - Channel patterns
-   - Message formats
-   - Error handling
-
-2. **Memory operations** (150-250 lines typically)
-   - SQLite initialization
-   - ACL patterns
-   - Redis cache
-   - Performance metrics
-
-3. **Post-edit hooks** (100-200 lines typically)
-   - Hook execution
-   - Feedback handling
-   - Validation types
-
-4. **CFN Loop mechanics** (300-500 lines typically)
-   - Loop structure
-   - Decision framework
-   - Mode thresholds
-   - Auto-progression
-
-5. **Generic patterns** (variable)
-   - Error handling boilerplate
-   - Standard workflows
-   - Common examples
-
-### Keep (Agent-Specific)
-
-1. **Unique specialty** (50-100 lines)
-   - What makes this agent different
-   - Core algorithm/approach
-   - Specialty-specific patterns
-
-2. **Frontmatter** (always)
-   - name, description, tools
-   - model, provider, capabilities
-   - validation_hooks, lifecycle
-
-3. **Role-specific workflows** (50-80 lines)
-   - Unique decision logic
-   - Specialty algorithms
-   - Domain-specific patterns
-
-4. **Success metrics** (10-20 lines)
-   - Agent-specific targets
-   - Quality thresholds
-
----
-
-## Batch Processing Strategy
-
-### Batch 1: High-Value Targets (Priority 1-3, 20 files)
-**Savings:** ~10,800 lines (72%)
-**Time:** 15-20 minutes
-**Agents:** 3-4 code-booster agents in parallel
-
-### Batch 2: Medium-Value Targets (Priority 4-5, 18 files)
-**Savings:** ~6,600 lines (62%)
-**Time:** 10-15 minutes
-**Agents:** 3-4 code-booster agents in parallel
-
-### Batch 3: Quick Wins (Priority 6, 46 files)
-**Savings:** ~3,700 lines (27%)
-**Time:** 20-25 minutes
-**Agents:** 4-5 code-booster agents in parallel (10 files each)
-
-**Total Time:** 45-60 minutes
-**Total Savings:** ~21,100 lines (54%)
-
----
-
-## Quality Validation
-
-### Post-Optimization Checks
-
-1. **File size validation**
-   ```bash
-   find .claude/agents -name "*.md" -exec wc -l {} + | \
-     awk '$1 > 300 {print $2": "$1" lines (REVIEW)"}'
-   ```
-
-2. **Template reference validation**
-   ```bash
-   grep -L "team-dynamics.md" .claude/agents/**/*.md | \
-     wc -l  # Should be 0 for workers
-   ```
-
-3. **Frontmatter validation**
-   ```bash
-   ./scripts/validate-agent-profiles.sh --check-frontmatter
-   ```
-
-4. **Rule-following test**
-   - Spawn sample agents
-   - Verify team awareness
-   - Test Redis communication
-   - Validate confidence calibration
-
----
-
-## Success Metrics
-
-### Target Outcomes
-
-| Metric | Before | Target | Improvement |
-|--------|--------|--------|-------------|
-| Total agents | 83 | 83 | - |
-| Total lines | 38,965 | 17,500 | 55% |
-| Avg size | 470 lines | 211 lines | 55% |
-| Files >500 lines | 20 | 0 | 100% |
-| Files >300 lines | 35 | 5 | 86% |
-| Team dynamics | 9/83 (11%) | 83/83 (100%) | 100% |
-
-### Quality Metrics
-
-- **Consistency:** 100% template usage
-- **Clarity:** Avg 211 lines per agent
-- **Team awareness:** 100% coverage
-- **Rule-following:** Improved through brevity
-- **Maintainability:** Single source of truth
-
----
-
-## Execution Plan
-
-### Phase 4A: Batch 1 (High-Value, 20 files)
-```bash
-# Spawn 4 code-booster agents in parallel
-# Each handles 5 files
-# Estimated: 15-20 minutes
-```
-
-### Phase 4B: Batch 2 (Medium-Value, 18 files)
-```bash
-# Spawn 3 code-booster agents in parallel
-# Each handles 6 files
-# Estimated: 10-15 minutes
-```
-
-### Phase 4C: Batch 3 (Quick Wins, 46 files)
-```bash
-# Spawn 5 code-booster agents in parallel
-# Each handles 9-10 files
-# Estimated: 20-25 minutes
-```
-
-### Phase 4D: Validation & Cleanup
-```bash
-# Run validation scripts
-# Fix any outliers
-# Generate final report
-# Estimated: 5-10 minutes
-```
-
-**Total Duration:** ~60 minutes for 83 agents
-
----
-
-## Agent Assignment Strategy
-
-### Batch 1 Distribution (4 agents)
-
-**Agent 1:** CFN/Coordinators (6 files)
-- product-owner.md
-- cfn-coordinator-unified.md
-- mesh-coordinator.md
-- adaptive-coordinator.md
-- adaptive-coordinator-enhanced.md
-- hierarchical-coordinator.md
-
-**Agent 2:** Testing (4 files)
-- interaction-tester.md (frontend)
-- production-validator.md (2 files)
-- tdd-london-swarm.md
-
-**Agent 3:** Analysis (3 files)
-- code-analyzer.md
-- perf-analyzer.md
-- context-curator.md
-
-**Agent 4:** Large SPARC (4 files)
-- refinement.md
-- architecture.md
-- api-designer-persona.md
-- security-architect-persona.md
-
-### Batch 2 Distribution (3 agents)
-
-**Agent 5:** Planning/Persona (6 files)
-- system-architect-persona.md
-- system-architect.md
-- pseudocode.md
-- + 3 medium planning agents
-
-**Agent 6:** Consensus/Goal (6 files)
-- goal-planner.md
-- security-manager.md
-- blocking-coordinator examples (2)
-- task-coordinator.md
-- mobile-dev.md
-
-**Agent 7:** Specialized (6 files)
-- Remaining consensus agents
-- Remaining specialized workers
-
-### Batch 3 Distribution (5 agents, 10 files each)
-
-**Agents 8-12:** Quick optimization of <300 line agents
-- Add team-dynamics reference
-- Add template references
-- Extract common patterns
-- Target: 180-220 lines each
-
----
-
-**Status:** Strategy ready for execution
-**Estimated Total Savings:** 21,100 lines (54% reduction)
-**Target Completion:** 60 minutes

package/.claude/templates/cfn-loop-mechanics.md

@@ -1,80 +0,0 @@
-# CFN Loop Mechanics Template
-
-## Loop Progression Mechanics
-
-### Loop Objectives
-- **Loop 2 (Validation)**: Consensus building, identify potential issues
-- **Loop 3 (Implementation)**: Address in-scope concerns
-- **Loop 4 (Strategic Decisions)**: Scope enforcement, phase progression
-
-## Decision Framework
-
-### Decision Gate Criteria
-- **MVP Mode**: 
-  - Gate: ≥0.65
-  - Consensus: ≥0.85
-  - Max Iterations: 5
-  - Validators: 2
-
-- **Standard Mode**:
-  - Gate: ≥0.75
-  - Consensus: ≥0.90
-  - Max Iterations: 10
-  - Validators: 4
-
-- **Enterprise Mode**:
-  - Gate: ≥0.85
-  - Consensus: ≥0.95
-  - Max Iterations: 15
-  - Validators: 5
-
-## Decision Actions
-
-### Proceed
-- Relaunch Loop 3 with targeted fixes
-- In-scope concerns addressed
-- Consensus building continues
-
-### Defer
-- Approve current phase
-- Add out-of-scope items to backlog
-- Transition to next phase
-
-### Escalate
-- Critical ambiguity detected
-- Requires human review
-- Blocked by persistent disagreements
-
-## Typical Workflow
-
-1. **Observe**: Gather current state data
-2. **Orient**: Analyze context, classify concerns
-3. **Decide**: Apply GOAP to find optimal path
-4. **Act**: Execute decision autonomously
-
-## Scope Management
-
-### In-Scope
-- Directly related to current phase goals
-- Implementable within current resources
-- Aligned with project requirements
-
-### Out-of-Scope
-- Future enhancements
-- Requires significant additional resources
-- Not critical for current phase completion
-
-## Cost Function Philosophy
-
-- **Scope Maintenance**: Lowest cost
-- **Scope Expansion**: Prohibitively expensive (cost=1000)
-- **Scope Reduction**: Heavily penalized (cost=500)
-
-## Confidence Tracking
-
-### Metrics to Monitor
-- Consensus Score
-- Iteration Count
-- Validator Concerns
-- Implementation Quality
-- Scope Adherence

package/.claude/templates/coordinator-patterns.md

@@ -1,75 +0,0 @@
-# Coordinator Orchestration Patterns
-
-## Core Coordination Principles
-
-### Signal ACK Protocol
-```typescript
-class BlockingCoordinationSignals {
-  async sendSignal(data: SignalData): Promise<void>
-  async waitForAck(targetAgentId: string, timeout: number): Promise<boolean>
-}
-
-class CoordinatorTimeoutHandler {
-  async checkCoordinatorHealth(): Promise<boolean>
-  async start(): Promise<void>
-  async stop(): Promise<void>
-}
-
-// Mandatory: HMAC secret for authentication
-const signals = new BlockingCoordinationSignals({
-  hmacSecret: process.env.BLOCKING_COORDINATION_SECRET
-});
-```
-
-### Swarm Initialization
-```typescript
-const swarmConfig = {
-  topology: agentCount <= 7 ? 'mesh' : 'hierarchical',
-  maxAgents: determinedByTaskComplexity(),
-  strategy: 'balanced' || 'adaptive',
-  phaseScoped: true  // Persist across tasks
-};
-```
-
-### Error Handling Strategies
-```typescript
-async function handleAgentTimeout(agentId: string): Promise<void> {
-  const isCoordinatorAlive = await timeoutHandler.checkCoordinatorHealth();
-
-  if (!isCoordinatorAlive) {
-    await escalateCoordinatorDeath();
-  } else {
-    await spawnReplacementAgent(agentId);
-  }
-}
-
-function retryWithBackoff(operation: () => Promise<void>, maxRetries = 3): Promise<void> {
-  // Exponential backoff for transient errors
-}
-```
-
-### Multi-Agent Coordination Metrics
-```typescript
-const coordinationMetrics = {
-  swarmEfficiency: {
-    optimalAgentCount: [5, 6, 7],
-    completionTimeReduction: 0.5,  // 50% faster
-    bottleneckReductionRate: 0.92  // 92% reduction
-  },
-  validationStrategy: {
-    earlyValidationTimeSavings: 1800000,  // 30 minutes
-    issueDetectionRate: 0.80  // 80% issues caught early
-  }
-};
-```
-
-## Best Practices
-
-1. Initialize swarm once per phase
-2. Use 5-7 agents for optimal coordination
-3. Be extremely specific in task assignments
-4. Track dependencies using Redis
-5. Validate milestone progress early
-6. Maintain weighted confidence aggregation
-7. Always use Signal ACK protocol
-8. Persist critical state in SQLite

package/.claude/templates/memory-operations.md

@@ -1,200 +0,0 @@
-## Memory Operations Template
-
-### SQLite Lifecycle Hooks
-
-```typescript
-// Agent spawn registration
-await sqlite.query(`
-  INSERT INTO agents (id, type, status, spawned_at)
-  VALUES (?, ?, 'active', CURRENT_TIMESTAMP)
-`, [agentId, agentType]);
-
-// Confidence score update
-await sqlite.query(`
-  UPDATE agents
-  SET status = ?,
-      confidence = ?,
-      updated_at = CURRENT_TIMESTAMP
-  WHERE id = ?
-`, [status, confidenceScore, agentId]);
-
-// Agent termination
-await sqlite.query(`
-  UPDATE agents
-  SET status = 'completed',
-      completed_at = CURRENT_TIMESTAMP
-  WHERE id = ?
-`, [agentId]);
-```
-
-### ACL Level Guidelines
-
-| Level | Scope | Encryption | Retention | Use Cases |
-|-------|-------|------------|-----------|-----------|
-| 1 (Private) | Agent-scoped | AES-256 | 30 days | Temporary state, confidence scores, implementation details |
-| 3 (Swarm) | Validation team | None | 90 days | Shared review feedback, test results |
-| 4 (Project) | Project-wide | None | 365 days | Strategic decisions, backlog items |
-
-### Mode-Specific Memory Keys
-
-```typescript
-const modeMemoryKeys = {
-  mvp: {
-    loop3: `cfn/phase-{id}/mvp/loop3/implementation`,
-    loop2: `cfn/phase-{id}/mvp/loop2/validation`
-  },
-  standard: {
-    loop3: `cfn/phase-{id}/standard/loop3/implementation`,
-    loop2: `cfn/phase-{id}/standard/loop2/validation`
-  },
-  enterprise: {
-    loop3: `cfn/phase-{id}/enterprise/loop3/implementation`,
-    loop2: `cfn/phase-{id}/enterprise/loop2/validation`,
-    loop2b: `cfn/phase-{id}/enterprise/loop2b/board-decision`
-  }
-};
-```
-
-### Memory Operations with ACL
-
-```javascript
-// Store agent-specific data (ACL Level 1)
-await sqlite.memoryAdapter.set(
-  `agent/${agentId}/confidence/${taskId}`,
-  confidenceScore,
-  {
-    aclLevel: 1,    // Private to agent
-    ttl: 2592000    // 30 days
-  }
-);
-
-// Store swarm-level data (ACL Level 3)
-await sqlite.memoryAdapter.set(
-  `cfn/phase-${phaseId}/loop2/validation/${validatorId}`,
-  validationResults,
-  {
-    aclLevel: 3,    // Swarm-accessible
-    ttl: 7776000    // 90 days
-  }
-);
-```
-
-### Memory Persistence Pattern
-
-```typescript
-async function persistWithRetry(key, value, options) {
-  const maxRetries = 3;
-
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      await sqlite.memoryAdapter.set(key, value, options);
-      return;
-    } catch (error) {
-      if (error.code === 'SQLITE_BUSY' && attempt < maxRetries - 1) {
-        const delay = Math.pow(2, attempt) * 100;
-        await new Promise(resolve => setTimeout(resolve, delay));
-      } else {
-        // Fallback to Redis for non-critical data
-        if (options.aclLevel < 4) {
-          await redis.set(key, JSON.stringify(value));
-        } else {
-          throw new Error('Critical data persistence failed');
-        }
-      }
-    }
-  }
-}
-```
-
-### Performance Optimization
-
-```javascript
-// Caching mechanism to reduce SQLite write overhead
-class MemoryOptimizer {
-  private writeCache = new Map<string, any>();
-  private lastFlushTime = Date.now();
-
-  async set(key, value, options) {
-    // Cache write to reduce SQLite overhead
-    this.writeCache.set(key, { value, options });
-
-    // Periodic flush to prevent cache growth
-    if (Date.now() - this.lastFlushTime > 5000) {
-      await this.flushCache();
-    }
-  }
-
-  async flushCache() {
-    const flushStart = Date.now();
-    const batchWrites = [];
-
-    for (const [key, { value, options }] of this.writeCache) {
-      batchWrites.push(
-        persistWithRetry(key, value, options).catch(console.error)
-      );
-    }
-
-    await Promise.all(batchWrites);
-
-    // Record performance metrics
-    await sqlite.query(`
-      INSERT INTO memory_operation_metrics
-      (operation_type, key, acl_level, latency_ms, success)
-      VALUES ('batch_write', ?, ?, ?, ?)
-    `, [
-      Array.from(this.writeCache.keys()).join(','),
-      options.aclLevel,
-      Date.now() - flushStart,
-      true
-    ]);
-
-    this.writeCache.clear();
-    this.lastFlushTime = Date.now();
-  }
-}
-```
-
-### Monitoring and Metrics
-
-```sql
--- Track memory operation performance
-CREATE TABLE memory_operation_metrics (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  operation_type TEXT NOT NULL,  -- 'set', 'get', 'delete'
-  key TEXT NOT NULL,
-  acl_level INTEGER NOT NULL,
-  latency_ms INTEGER NOT NULL,
-  success BOOLEAN NOT NULL,
-  timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-```
-
-### Key Coordination Principles
-
-1. Use mode-specific memory namespaces
-2. Implement retry logic for transient errors
-3. Fallback to Redis for non-critical data
-4. Maintain strict ACL levels
-5. Preserve audit trail with comprehensive logging
-6. Always specify ACL level
-7. Use appropriate TTL for data retention
-8. Minimize direct SQLite writes with caching
-9. Log all memory operations
-10. Keep keys descriptive and structured
-11. Monitor memory operation performance
-
-### Reliability Strategies
-
-- Use exponential backoff for retries
-- Fallback to Redis for non-critical data
-- Implement periodic cache flushing
-- Track memory operation metrics
-- Handle SQLite lock and busy states gracefully
-
-### Security Considerations
-
-- Encrypt sensitive data (AES-256 for Level 1)
-- Validate and sanitize input before writing
-- Use prepared statements to prevent injection
-- Rotate encryption keys periodically
-- Implement access logging for sensitive operations