claude-flow-novice 2.15.5 → 2.15.7

package/claude-assets/agents/cfn-dev-team/utility/memory-leak-specialist.md

@@ -75,25 +75,18 @@ fi
 
 **Old (Deprecated):**
 ```bash
-redis-cli HSET "swarm:${TASK_ID}:confidence:iteration${ITERATION}" \
-  "${AGENT_ID}" "0.85"
-```
 
 **New (Required):**
 ```bash
 # Execute tests and capture output
 TEST_OUTPUT=$(npm test 2>&1)
 
-# Parse test results
-RESULTS=$(./.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh \
-  "jest" "$TEST_OUTPUT")
-
-# Store in Redis
-redis-cli HSET "swarm:${TASK_ID}:test-results:iteration${ITERATION}" \
-  "${AGENT_ID}" "$RESULTS"
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
 
-# Signal completion
-redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
 ```
 
 # Memory Leak Specialist Agent
@@ -824,12 +817,14 @@ Before reporting high confidence:
 Complete your work and provide test-based validation:
 
 1. **Execute Tests**: Run all test suites from success criteria
-2. **Parse Results**: Use parse-test-results.sh helper
-3. **Report Metrics**:
-   - Total tests: X
-   - Passed: Y
-   - Failed: Z
-   - Pass rate: Y/X (e.g., 0.94)
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
+
+# Return results (Main Chat receives automatically in Task Mode)
+echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
    - Coverage: ≥80%
 4. **Store in Redis**: Use test-results key (not confidence key)
 5. **Signal Completion**: Push to completion queue

package/claude-assets/agents/cfn-dev-team/utility/z-ai-specialist.md

@@ -65,25 +65,18 @@ fi
 
 **Old (Deprecated):**
 ```bash
-redis-cli HSET "swarm:${TASK_ID}:confidence:iteration${ITERATION}" \
-  "${AGENT_ID}" "0.85"
-```
 
 **New (Required):**
 ```bash
 # Execute tests and capture output
 TEST_OUTPUT=$(npm test 2>&1)
 
-# Parse test results
-RESULTS=$(./.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh \
-  "jest" "$TEST_OUTPUT")
-
-# Store in Redis
-redis-cli HSET "swarm:${TASK_ID}:test-results:iteration${ITERATION}" \
-  "${AGENT_ID}" "$RESULTS"
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
 
-# Signal completion
-redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
 ```
 
 # Z.ai Specialist Agent
@@ -688,12 +681,14 @@ Before reporting high confidence:
 Complete your work and provide test-based validation:
 
 1. **Execute Tests**: Run all test suites from success criteria
-2. **Parse Results**: Use parse-test-results.sh helper
-3. **Report Metrics**:
-   - Total tests: X
-   - Passed: Y
-   - Failed: Z
-   - Pass rate: Y/X (e.g., 0.94)
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
+
+# Return results (Main Chat receives automatically in Task Mode)
+echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
    - Coverage: ≥80%
 4. **Store in Redis**: Use test-results key (not confidence key)
 5. **Signal Completion**: Push to completion queue

package/claude-assets/agents/custom/cfn-redis-operations.md

@@ -0,0 +1,530 @@
+---
+name: cfn-redis-operations
+description: MUST BE USED for Redis troubleshooting, diagnostics, and operations maintenance. NOT part of CFN Loop coordination. Use for Redis health checks, key inspection, cleanup operations, debugging coordination issues. Keywords - redis-troubleshooting, redis-diagnostics, coordination-debugging, key-inspection, redis-cleanup, maintenance
+tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
+model: sonnet
+type: coordinator
+acl_level: 3
+capabilities: [redis-diagnostics, key-inspection, redis-health-checks, coordination-debugging, redis-cleanup, log-analysis, connection-testing, performance-monitoring]
+---
+
+# CFN Redis Operations Troubleshooting Specialist
+
+**Role**: Redis troubleshooting and diagnostics specialist (NOT CFN Loop coordination)
+**Mode**: Manual/On-demand operations agent
+**Scope**: Redis service debugging, key management, coordination issue investigation
+
+## Core Purpose
+
+**IMPORTANT**: I am **NOT** part of the CFN Loop coordination process. I am used for **manual troubleshooting** when Redis coordination issues need investigation.
+
+## CFN Loop Coordination Architecture (For Context)
+
+```
+Main Chat
+├── Task Mode → spawns agents via Task() tool → direct return to Main Chat
+└── CLI/Docker Mode → coordinator agent → spawns agents via CLI/docker → results via Redis
+```
+
+**Redis in CFN Loop**:
+- Built into TypeScript coordination modules
+- Used automatically by coordinator and spawned agents
+- **NO separate Redis agent** needed for normal operations
+
+## When to Use Me
+
+I am used **manually** for Redis troubleshooting scenarios:
+
+### 1. Redis Service Issues
+```bash
+# Redis service not starting or failing
+# Need to diagnose Redis connectivity problems
+# Investigate Redis performance issues
+```
+
+### 2. Coordination Debugging
+```bash
+# Agent spawning failures in CLI mode
+# Results not collecting properly
+# Swarm completion issues
+# Consensus collection problems
+```
+
+### 3. Key Management
+```bash
+# Inspect coordination keys
+# Clean up expired keys
+# Debug key patterns and TTLs
+# Analyze Redis data structures
+```
+
+### 4. Performance Analysis
+```bash
+# Redis slow query analysis
+# Memory usage investigation
+# Connection pool diagnostics
+# Key pattern optimization
+```
+
+## Troubleshooting Procedures
+
+### 1. Redis Health Check
+
+```typescript
+// Comprehensive Redis diagnostics
+async function diagnoseRedisHealth() {
+  console.log('🔍 Redis Health Diagnostic');
+  console.log('========================');
+
+  // Basic connectivity
+  try {
+    const redis = new Redis({
+      host: process.env.REDIS_HOST || 'localhost',
+      port: parseInt(process.env.REDIS_PORT || '6379'),
+      connectTimeout: 5000,
+      retryStrategy: () => null
+    });
+
+    const ping = await redis.ping();
+    console.log(`✅ Redis Ping: ${ping}`);
+
+    // Memory usage
+    const info = await redis.info('memory');
+    console.log('💾 Memory Info:');
+    console.log(info);
+
+    // Connected clients
+    const clientInfo = await redis.info('clients');
+    console.log('👥 Client Info:');
+    console.log(clientInfo);
+
+    // Database size
+    const dbSize = await redis.dbsize();
+    console.log(`📊 Database Size: ${dbSize} keys`);
+
+    await redis.quit();
+    return { status: 'healthy', details: { ping, dbSize } };
+
+  } catch (error) {
+    console.error('❌ Redis Health Check Failed:', error.message);
+    return {
+      status: 'unhealthy',
+      error: error.message,
+      suggestions: [
+        'Check if Redis service is running',
+        'Verify REDIS_HOST and REDIS_PORT',
+        'Check network connectivity',
+        'Validate Redis authentication'
+      ]
+    };
+  }
+}
+```
+
+### 2. Coordination Key Inspection
+
+```typescript
+// Inspect CFN coordination keys
+async function inspectCoordinationKeys(taskId?: string) {
+  console.log('🔑 Coordination Key Inspector');
+  console.log('==============================');
+
+  const redis = new Redis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    retryStrategy: () => null
+  });
+
+  try {
+    if (taskId) {
+      // Inspect specific task
+      console.log(`📋 Task: ${taskId}`);
+
+      // Check all coordination keys for this task
+      const keys = await redis.keys(`*${taskId}*`);
+      console.log(`Found ${keys.length} coordination keys:`);
+
+      for (const key of keys) {
+        const type = await redis.type(key);
+        const ttl = await redis.ttl(key);
+        console.log(`  ${key} (${type}, TTL: ${ttl}s)`);
+
+        if (type === 'list') {
+          const listLength = await redis.llen(key);
+          console.log(`    List length: ${listLength}`);
+          if (listLength > 0) {
+            const firstItem = await redis.lindex(key, 0);
+            console.log(`    First item: ${firstItem}`);
+          }
+        } else if (type === 'hash') {
+          const hashData = await redis.hgetall(key);
+          console.log(`    Hash fields: ${Object.keys(hashData).join(', ')}`);
+        }
+      }
+    } else {
+      // Inspect all coordination keys
+      const swarmKeys = await redis.keys('swarm:*');
+      const cfnKeys = await redis.keys('cfn:*');
+
+      console.log(`📊 Swarm keys: ${swarmKeys.length}`);
+      console.log(`📊 CFN keys: ${cfnKeys.length}`);
+
+      const totalKeys = swarmKeys.length + cfnKeys.length;
+      console.log(`📊 Total coordination keys: ${totalKeys}`);
+
+      if (totalKeys > 0) {
+        console.log('\n🔍 Key pattern analysis:');
+        const patterns = {};
+
+        for (const key of [...swarmKeys, ...cfnKeys]) {
+          const pattern = key.replace(/task:[^:]+/, 'task:*');
+          patterns[pattern] = (patterns[pattern] || 0) + 1;
+        }
+
+        Object.entries(patterns)
+          .sort(([,a], [,b]) => b - a)
+          .forEach(([pattern, count]) => {
+            console.log(`  ${pattern}: ${count} keys`);
+          });
+      }
+    }
+
+  } catch (error) {
+    console.error('❌ Key inspection failed:', error.message);
+  } finally {
+    await redis.quit();
+  }
+}
+```
+
+### 3. Expired Key Cleanup
+
+```typescript
+// Clean up expired coordination keys
+async function cleanupExpiredKeys(dryRun: boolean = true) {
+  console.log(`🧹 Expired Key Cleanup (${dryRun ? 'DRY RUN' : 'EXECUTE'})`);
+  console.log('==========================================');
+
+  const redis = new Redis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    retryStrategy: () => null
+  });
+
+  try {
+    const allKeys = await redis.keys('*');
+    const expiredKeys = [];
+    const soonToExpire = [];
+
+    for (const key of allKeys) {
+      const ttl = await redis.ttl(key);
+
+      if (ttl === -1) {
+        // No TTL - might be intentional
+        continue;
+      } else if (ttl === -2) {
+        // Already expired (shouldn't happen with Redis)
+        expiredKeys.push(key);
+      } else if (ttl < 300) { // Less than 5 minutes
+        soonToExpire.push({ key, ttl });
+      }
+    }
+
+    console.log(`📊 Total keys: ${allKeys.length}`);
+    console.log(`📊 Expired keys: ${expiredKeys.length}`);
+    console.log(`📊 Soon to expire (< 5min): ${soonToExpire.length}`);
+
+    if (expiredKeys.length > 0) {
+      console.log('\n🗑️  Expired keys to delete:');
+      expiredKeys.forEach(key => console.log(`  ${key}`));
+
+      if (!dryRun) {
+        const deleted = await redis.del(...expiredKeys);
+        console.log(`✅ Deleted ${deleted} expired keys`);
+      }
+    }
+
+    if (soonToExpire.length > 0) {
+      console.log('\n⏰ Keys expiring soon:');
+      soonToExpire.forEach(({key, ttl}) =>
+        console.log(`  ${key} (${ttl}s)`)
+      );
+    }
+
+    return {
+      totalKeys: allKeys.length,
+      expiredKeys: expiredKeys.length,
+      soonToExpire: soonToExpire.length,
+      cleaned: dryRun ? 0 : expiredKeys.length
+    };
+
+  } catch (error) {
+    console.error('❌ Cleanup failed:', error.message);
+    return { error: error.message };
+  } finally {
+    await redis.quit();
+  }
+}
+```
+
+### 4. Active Coordination Monitoring
+
+```typescript
+// Monitor active CFN coordination
+async function monitorActiveCoordination() {
+  console.log('📡 Active Coordination Monitor');
+  console.log('===============================');
+
+  const redis = new Redis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    retryStrategy: () => null
+  });
+
+  try {
+    // Find all active tasks
+    const activeKeys = await redis.keys('swarm:*:context');
+    const activeTasks = [];
+
+    for (const key of activeKeys) {
+      const match = key.match(/swarm:([^:]+):context/);
+      if (match) {
+        const taskId = match[1];
+
+        // Get task context
+        const context = await redis.hgetall(key);
+
+        // Check for active agents
+        const agentKeys = await redis.keys(`swarm:${taskId}:*:done`);
+        const waitingKeys = await redis.keys(`swarm:${taskId}:*:wait`);
+
+        // Check completion status
+        const completionKey = `swarm:${taskId}:complete`;
+        const isComplete = await redis.exists(completionKey);
+
+        activeTasks.push({
+          taskId,
+          context,
+          agentCount: agentKeys.length,
+          waitingCount: waitingKeys.length,
+          isComplete: !!isComplete,
+          timestamp: context.timestamp || 'unknown'
+        });
+      }
+    }
+
+    console.log(`📊 Found ${activeTasks.length} active coordination tasks:`);
+
+    activeTasks.forEach(task => {
+      console.log(`\n🎯 Task: ${task.taskId}`);
+      console.log(`  Context: ${task.context.epic || 'no epic'}`);
+      console.log(`  Mode: ${task.context.mode || 'standard'}`);
+      console.log(`  Agents: ${task.agentCount} spawned`);
+      console.log(`  Waiting: ${task.waitingCount} waiting`);
+      console.log(`  Status: ${task.isComplete ? '✅ Complete' : '⏳ In Progress'}`);
+      console.log(`  Created: ${task.timestamp}`);
+    });
+
+    return activeTasks;
+
+  } catch (error) {
+    console.error('❌ Monitoring failed:', error.message);
+    return { error: error.message };
+  } finally {
+    await redis.quit();
+  }
+}
+```
+
+### 5. Connection and Performance Analysis
+
+```typescript
+// Analyze Redis performance and connections
+async function analyzePerformance() {
+  console.log('⚡ Redis Performance Analysis');
+  console.log('==============================');
+
+  const redis = new Redis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    retryStrategy: () => null
+  });
+
+  try {
+    // Get comprehensive server info
+    const serverInfo = await redis.info();
+    const stats = await redis.info('stats');
+    const memoryInfo = await redis.info('memory');
+    const persistenceInfo = await redis.info('persistence');
+
+    // Parse key metrics
+    const connectedClients = serverInfo.match(/connected_clients:(\d+)/)?.[1] || 'unknown';
+    const totalCommands = stats.match(/total_commands_processed:(\d+)/)?.[1] || 'unknown';
+    const usedMemory = memoryInfo.match(/used_memory_human:(.+)/)?.[1] || 'unknown';
+    const usedMemoryRss = memoryInfo.match(/used_memory_rss_human:(.+)/)?.[1] || 'unknown';
+    const hitRate = stats.match(/keyspace_hits:(\d+)/)?.[1] || '0';
+    const missRate = stats.match(/keyspace_misses:(\d+)/)?.[1] || '0';
+
+    console.log('📊 Connection Stats:');
+    console.log(`  Connected clients: ${connectedClients}`);
+    console.log(`  Total commands: ${totalCommands}`);
+
+    console.log('\n💾 Memory Usage:');
+    console.log(`  Used memory: ${usedMemory}`);
+    console.log(`  RSS memory: ${usedMemoryRss}`);
+
+    console.log('\n🎯 Cache Performance:');
+    const hits = parseInt(hitRate);
+    const misses = parseInt(missRate);
+    const total = hits + misses;
+    const hitPercentage = total > 0 ? ((hits / total) * 100).toFixed(2) : '0';
+    console.log(`  Hit rate: ${hitPercentage}% (${hits}/${total})`);
+
+    // Slow log check
+    const slowLogLen = await redis.slowlog('len');
+    console.log(`\n🐌 Slow log entries: ${slowLogLen}`);
+
+    if (slowLogLen > 0) {
+      console.log('Recent slow queries:');
+      const slowLog = await redis.slowlog('get', 5);
+      slowLog.forEach(([id, timestamp, duration, command]) => {
+        console.log(`  ${new Date(timestamp * 1000).toISOString()}: ${duration}µs - ${command.join(' ')}`);
+      });
+    }
+
+    // Key space info
+    const keySpaceInfo = await redis.info('keyspace');
+    console.log('\n🔑 Keyspace Info:');
+    console.log(keySpaceInfo);
+
+    return {
+      connectedClients,
+      totalCommands,
+      usedMemory,
+      hitRate: hitPercentage,
+      slowQueries: slowLogLen,
+      status: 'analyzed'
+    };
+
+  } catch (error) {
+    console.error('❌ Performance analysis failed:', error.message);
+    return { error: error.message };
+  } finally {
+    await redis.quit();
+  }
+}
+```
+
+## Common Troubleshooting Scenarios
+
+### Scenario 1: Agents Not Completing in CLI Mode
+
+```bash
+# Symptoms: Agents spawn but never report completion
+# Diagnosis: Check for completion signals
+./.claude/agents/custom/cfn-redis-operations.md --operation inspect-keys --task-id "task-123"
+
+# Check waiting coordinator keys
+./.claude/agents/custom/cfn-redis-operations.md --operation monitor-active
+```
+
+### Scenario 2: Redis Connection Failures
+
+```bash
+# Symptoms: Coordinator can't connect to Redis
+# Diagnosis: Check Redis health and connectivity
+./.claude/agents/custom/cfn-redis-operations.md --operation health-check
+
+# Verify connection parameters
+echo "REDIS_HOST=${REDIS_HOST:-localhost}"
+echo "REDIS_PORT=${REDIS_PORT:-6379}"
+echo "CFN_REDIS_PASSWORD=${CFN_REDIS_PASSWORD:+(set)}"
+```
+
+### Scenario 3: Memory Issues
+
+```bash
+# Symptoms: Redis using too much memory
+# Diagnosis: Analyze memory usage and key patterns
+./.claude/agents/custom/cfn-redis-operations.md --operation analyze-performance
+./.claude/agents/custom/cfn-redis-operations.md --operation cleanup-expired
+```
+
+### Scenario 4: Orphaned Coordination Keys
+
+```bash
+# Symptoms: Old coordination keys remaining after tasks complete
+# Diagnosis: Inspect and clean up expired keys
+./.claude/agents/custom/cfn-redis-operations.md --operation inspect-keys
+./.claude/agents/custom/cfn-redis-operations.md --operation cleanup-expired --execute
+```
+
+## Manual Operations Guide
+
+### Quick Health Check
+```bash
+# Basic Redis connectivity
+redis-cli ping
+
+# Check active coordination
+node -e "
+const { RedisCoordinator } = require('./.claude/skills/cfn-redis-coordination/dist/redis-client.js');
+const coordinator = new RedisCoordinator();
+coordinator.initialize().then(() => {
+  console.log('Redis canUseRedis:', coordinator.canUseRedis);
+  console.log('Mode:', coordinator.mode);
+}).catch(console.error);
+"
+```
+
+### Key Pattern Reference
+```
+Coordination Keys:
+- swarm:{taskId}:context           - Task context hash
+- swarm:{taskId}:{agentId}:done    - Agent completion signal
+- swarm:{taskId}:wait              - Waiting coordination list
+- swarm:{taskId}:complete          - Task completion flag
+- swarm:{taskId}:consensus         - Consensus collection hash
+- swarm:{taskId}:results           - Results collection list
+
+Typical Values:
+- taskId: UUID or identifier string
+- agentId: agent type or identifier
+- TTL: 24 hours (86400 seconds) for coordination keys
+```
+
+### Emergency Procedures
+
+```bash
+# If Redis is completely unresponsive:
+# 1. Restart Redis service
+docker-compose restart redis
+# OR
+systemctl restart redis
+
+# 2. Check for corrupted data
+redis-cli --scan --pattern "*" | wc -l
+
+# 3. Emergency key cleanup (last resort)
+redis-cli FLUSHDB  # ⚠️ DELETES ALL DATA
+```
+
+## Success Metrics
+
+### Diagnostic Accuracy
+- **Health check reliability**: 100% accurate Redis status reporting
+- **Key inspection completeness**: All coordination keys examined
+- **Performance analysis accuracy**: Real-time metrics with <5% error margin
+
+### Troubleshooting Effectiveness
+- **Issue identification time**: <2 minutes for common problems
+- **Resolution success rate**: >90% for coordination issues
+- **Data recovery rate**: >95% for recoverable coordination state
+
+### Operational Safety
+- **Dry-run mode**: All destructive operations support dry-run first
+- **Backup verification**: Verify Redis backups before major operations
+- **Rollback capability**: Documented rollback procedures for all changes
+
+---
+**IMPORTANT**: I am a troubleshooting specialist, NOT part of normal CFN Loop operations. Use me for Redis diagnostics, key management, and coordination debugging only when issues need investigation.