claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/CFN-LOOP-VALIDATION.md

@@ -1,202 +0,0 @@
----
-name: cfn-loop-validation
-description: Automated validation skill for Claude Flow Novice CFN Loop with intelligent auto-retry mechanisms
-version: 1.0.0
-allowed-tools:
-  - Bash
-  - Task
-  - TodoWrite
-  - SQLite
-  - Redis
-  - Grep
-
-# Skill Taxonomy
-skill-type: validation
-complexity: advanced
-domain: ai-agent-orchestration
-
-# Validation Modes
-modes:
-  - name: MVP
-    gate-threshold: 0.65
-    consensus-threshold: 0.85
-    max-iterations: 5
-    validators: 2
-
-  - name: Standard
-    gate-threshold: 0.75
-    consensus-threshold: 0.90
-    max-iterations: 10
-    validators: 4
-
-  - name: Enterprise
-    gate-threshold: 0.85
-    consensus-threshold: 0.95
-    max-iterations: 15
-    validators: 5
-
----
-
-# CFN Loop Validation Skill
-
-## 1. Mode Selection & Thresholds
-
-### Threshold Evaluation Matrix
-
-| Mode       | Gate Threshold | Consensus | Max Iterations | Validators | Escalation |
-|------------|----------------|-----------|---------------|------------|------------|
-| MVP        | ≥0.65          | ≥0.85     | 5             | 2          | Low        |
-| Standard   | ≥0.75          | ≥0.90     | 10            | 4          | Medium     |
-| Enterprise | ≥0.85          | ≥0.95     | 15            | 5          | High       |
-
-## 2. Execution Pattern: Auto-Retry Bash Script
-
-### Validation Script Template (`cfn-loop-validation.sh`)
-
-```bash
-#!/usr/bin/env bash
-
-# CFN Loop Validation Script
-# Handles intelligent auto-retry with progressive complexity
-
-CFN_VALIDATION_MODE="${1:-standard}"
-MAX_ITERATIONS=10
-CURRENT_ITERATION=0
-CONSENSUS_THRESHOLD=0.90
-GATE_THRESHOLD=0.75
-
-# Validation Function
-validate_loop() {
-    local task_id="$1"
-    local mode="$2"
-
-    # Invoke consensus calculator
-    local validation_result=$(node consensus-calculator.js \
-        --task-id "$task_id" \
-        --mode "$mode")
-
-    # Parse validation metrics
-    local confidence=$(echo "$validation_result" | jq '.confidence')
-    local consensus=$(echo "$validation_result" | jq '.consensus')
-    local gate_score=$(echo "$validation_result" | jq '.gate_score')
-
-    # Validation decision tree
-    if (( $(echo "$confidence >= $CONSENSUS_THRESHOLD" | bc -l) )) &&
-       (( $(echo "$gate_score >= $GATE_THRESHOLD" | bc -l) )); then
-        return 0  # Success
-    else
-        return 1  # Retry needed
-    }
-}
-
-# Main Validation Loop
-while [[ $CURRENT_ITERATION -lt $MAX_ITERATIONS ]]; do
-    if validate_loop "$TASK_ID" "$CFN_VALIDATION_MODE"; then
-        # Successful validation
-        redis-cli lpush "swarm:validation:complete" \
-            "$(jq -n \
-                --arg task "$TASK_ID" \
-                --arg mode "$CFN_VALIDATION_MODE" \
-                '{task: $task, mode: $mode, status: "success"}')"
-        exit 0
-    else
-        # Increment iteration, potential escalation
-        CURRENT_ITERATION=$((CURRENT_ITERATION + 1))
-
-        # Optional: Escalation strategy
-        if [[ $CURRENT_ITERATION -ge $((MAX_ITERATIONS * 0.8)) ]]; then
-            redis-cli lpush "swarm:validation:escalation" \
-                "$(jq -n \
-                    --arg task "$TASK_ID" \
-                    --arg mode "$CFN_VALIDATION_MODE" \
-                    '{task: $task, mode: $mode, status: "escalate"}')"
-        fi
-
-        # Exponential backoff
-        sleep $((2 ** CURRENT_ITERATION))
-    fi
-done
-
-# Final failure state
-redis-cli lpush "swarm:validation:failure" \
-    "$(jq -n \
-        --arg task "$TASK_ID" \
-        --arg mode "$CFN_VALIDATION_MODE" \
-        '{task: $task, mode: $mode, status: "failure"}')"
-exit 1
-```
-
-## 3. Memory Integration: Evidence Chain
-
-### SQLite Schema (`evidence-chain.sql`)
-
-```sql
--- Evidence Chain Schema for CFN Loop Validation
-CREATE TABLE validation_evidence (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    task_id TEXT NOT NULL,
-    validation_mode TEXT NOT NULL,
-    confidence REAL,
-    consensus_score REAL,
-    gate_score REAL,
-    iteration INTEGER,
-    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-    status TEXT CHECK(status IN ('pending', 'success', 'retry', 'escalate', 'failure'))
-);
-
-CREATE INDEX idx_task_validation ON validation_evidence(task_id, validation_mode);
-```
-
-## 4. Consensus Calculator Interface
-
-### `consensus-calculator.js`
-
-```javascript
-const calculateConsensus = (taskMetrics) => {
-    const {
-        validatorScores,
-        confidenceScores,
-        gateways
-    } = taskMetrics;
-
-    const consensusScore = calculateWeightedConsensus(validatorScores);
-    const confidenceScore = calculateConfidenceMetric(confidenceScores);
-    const gateScore = calculateGatewayScore(gateways);
-
-    return {
-        consensus: consensusScore,
-        confidence: confidenceScore,
-        gate_score: gateScore,
-        recommendation: decideNextAction(consensusScore, confidenceScore, gateScore)
-    };
-};
-
-module.exports = { calculateConsensus };
-```
-
-## 5. Automatic Relaunch Logic
-
-### Decision Matrix
-
-| Scenario | Condition | Action | Escalation Level |
-|----------|-----------|--------|-----------------|
-| Low Confidence | consensus < 0.75 | Retry | Low |
-| Medium Confidence | 0.75 ≤ consensus < 0.90 | Retry with Specialized Agents | Medium |
-| High Confidence Failure | consensus ≥ 0.90 but gate fails | Manual Review | High |
-| Persistent Failure | Max iterations reached | Escalate to Human | Critical |
-
-## 6. Usage Example
-
-```bash
-# Invoke validation for a task
-./cfn-loop-validation.sh "task-auth-system" standard
-```
-
-## Performance & Telemetry
-
-- Average Execution Time: <500ms
-- Memory Footprint: <50MB
-- Redis Pub/Sub Latency: <100ms
-- SQLite Write Latency: <20ms
-
----

package/.claude/skills/REDIS-COORDINATION.md

@@ -1,187 +0,0 @@
-# Redis Coordination Skill
-
-## Metadata
-```yaml
-name: redis-coordination
-description: Advanced Redis-based agent coordination and communication
-version: 1.1
-complexity: advanced
-allowed-tools:
-  - Redis
-  - SQLite
-  - Bash
-  - TypeScript
-constraints:
-  - Low-latency communication
-  - Persistent state management
-  - Distributed consensus
-```
-
-## Overview
-Redis Coordination is a sophisticated communication and state management skill for multi-agent systems, enabling real-time, fault-tolerant interactions across distributed environments.
-
-## 1. When to Use
-
-### Topology Selection
-- **Mesh Network (2-7 agents)**:
-  - Peer-to-peer communication
-  - Low-complexity tasks
-  - Direct channel subscriptions
-
-- **Hierarchical Network (8+ agents)**:
-  - Centralized coordination
-  - Complex, multi-stage workflows
-  - Coordinator-mediated communication
-
-### Decision Criteria
-✅ Use Redis Coordination when:
-- Task requires real-time agent interactions
-- Agents need persistent state tracking
-- Work involves multiple independent/dependent steps
-- Fault tolerance is critical
-- Low-latency communication is required
-
-❌ Avoid when:
-- Single-agent, linear tasks
-- Extremely low-compute environments
-- No persistent storage needed
-
-## 2. Channel Naming Convention
-
-### Fundamental Patterns
-```bash
-# Swarm-level coordination
-swarm:{swarm_id}:coordination
-
-# Agent-specific channels
-agent:{agent_id}:feedback
-agent:{agent_id}:status
-
-# Task-specific channels
-task:{task_id}:progress
-task:{task_id}:results
-```
-
-### Advanced Namespacing
-```bash
-# Complex task routing
-swarm:{project}:{phase}:{task_type}:coordination
-```
-
-## 3. Timeout & Resilience Handling
-
-### Timeout Template
-```bash
-# Basic timeout pattern
-timeout 300 redis-cli --csv blpop "channel:name" 0
-
-# Advanced timeout with fallback
-function redis_robust_pop() {
-  local channel="$1"
-  local timeout="${2:-300}"
-  local fallback_action="${3:-continue}"
-
-  result=$(timeout "$timeout" redis-cli --csv blpop "$channel" 0)
-
-  if [ $? -ne 0 ]; then
-    echo "TIMEOUT: Channel $channel unresponsive"
-    case "$fallback_action" in
-      "continue") return 0 ;;
-      "retry") redis_robust_pop "$channel" "$timeout" ;;
-      "abort") exit 1 ;;
-    esac
-  fi
-}
-```
-
-## 4. Consensus & Validation
-
-### Confidence Thresholds
-- MVP Mode: Gate ≥0.65, Consensus ≥0.85
-- Standard Mode: Gate ≥0.75, Consensus ≥0.90
-- Enterprise Mode: Gate ≥0.85, Consensus ≥0.95
-
-### Validation Workflow
-1. Publish coordination message
-2. Collect agent responses
-3. Calculate consensus
-4. Decide: Continue/Retry/Abort
-
-## 5. Best Practices
-
-### Performance Optimization
-- Use `LPUSH`/`RPOP` for queues
-- Implement short TTLs
-- Minimize payload size
-- Use pipeline for batch operations
-
-### Security Considerations
-- Use Redis ACLs
-- Encrypt sensitive payloads
-- Validate all incoming messages
-- Implement rate limiting
-
-## 6. Error Handling
-
-### Common Failure Modes
-- Network interruption
-- Redis connection loss
-- Timeout scenarios
-- Partial task completion
-
-### Recommended Mitigation
-```bash
-# Resilient Redis interaction
-function safe_redis_publish() {
-  local channel="$1"
-  local message="$2"
-
-  max_retries=3
-  retry_delay=1
-
-  for ((i=1; i<=max_retries; i++)); do
-    redis-cli PUBLISH "$channel" "$message"
-    if [ $? -eq 0 ]; then
-      return 0
-    fi
-
-    echo "Publish attempt $i failed. Retrying in $retry_delay seconds..."
-    sleep "$retry_delay"
-    retry_delay=$((retry_delay * 2))
-  done
-
-  echo "Fatal: Unable to publish message after $max_retries attempts"
-  return 1
-}
-```
-
-## 7. Monitoring & Metrics
-
-### Key Performance Indicators
-- Message latency
-- Successful publish rate
-- Consensus achievement time
-- Error rate
-
-### Recommended Logging
-```json
-{
-  "timestamp": "2025-10-18T12:34:56Z",
-  "swarm_id": "skills-sprint-1.1",
-  "event_type": "coordination",
-  "status": "success",
-  "latency_ms": 42,
-  "consensus_score": 0.92
-}
-```
-
-## Resources
-- Redis Documentation
-- Distributed Systems Design Patterns
-- High Performance Redis Techniques
-
----
-
-✅ Skill Status: Active
-📅 Last Updated: 2025-10-18
-🔬 Complexity Level: Advanced

package/.claude/skills/SKILL.md

@@ -1,229 +0,0 @@
-# Hook Pipeline Auto-Resolution Skill
-
-## DEPRECATED - CONSOLIDATED INTO HOOK PIPELINE SKILL
-
-**Status:** This skill has been consolidated into the main Hook Pipeline skill.
-
-**Reason:** Auto-resolution is an integral part of the post-edit validation workflow, not a separate skill. The feedback-resolver.sh implementation already exists in the Hook Pipeline directory and works in concert with post-edit-handler.sh.
-
-**Migration Path:**
-- All auto-resolution functionality is now documented in: `.claude/skills/hook-pipeline/SKILL.md`
-- Use the convenience wrapper: `.claude/skills/hook-pipeline/auto-resolve.sh`
-- Original implementation: `.claude/skills/hook-pipeline/feedback-resolver.sh`
-
-## Quick Reference
-
-### Old Usage (DEPRECATED)
-```bash
-# This documentation is outdated
-```
-
-### New Usage (CURRENT)
-```bash
-# Resolve most recent feedback
-./.claude/skills/hook-pipeline/auto-resolve.sh
-
-# Resolve with auto-fix enabled
-./.claude/skills/hook-pipeline/auto-resolve.sh --auto-fix
-
-# Resolve specific feedback type
-./.claude/skills/hook-pipeline/auto-resolve.sh --type ROOT_WARNING --auto-fix
-```
-
-## Complete Documentation
-
-See: `.claude/skills/hook-pipeline/SKILL.md` - Section "Automatic Feedback Resolution"
-
-## Components Now Located In Hook Pipeline
-
-| Component | Location |
-|-----------|----------|
-| Auto-resolver | `.claude/skills/hook-pipeline/feedback-resolver.sh` |
-| Convenience wrapper | `.claude/skills/hook-pipeline/auto-resolve.sh` |
-| Post-edit handler | `.claude/skills/hook-pipeline/post-edit-handler.sh` |
-| Documentation | `.claude/skills/hook-pipeline/SKILL.md` |
-
----
-
-## Legacy Documentation (For Historical Reference Only)
-
-The content below is preserved for historical reference but should NOT be used. Refer to Hook Pipeline SKILL.md instead.
-
-<details>
-<summary>Click to view legacy documentation</summary>
-
-## Metadata (OUTDATED)
-```yaml
-name: hook-pipeline-auto-resolver
-version: 1.0.0
-description: Automatic resolution for post-edit hook feedback
-type: system-skill
-allowed-tools:
-  - Bash
-  - Read
-  - Edit
-  - Grep
-configuration:
-  max-retry-attempts: 3
-  default-timeout: 300ms
-```
-
-## 1. Architectural Decision Record (OUTDATED)
-
-### Context
-- Complex multi-agent workflows require intelligent, automatic feedback resolution
-- Minimize manual intervention in common error scenarios
-- Provide clear, actionable feedback for agents
-
-### Decision
-Implement a hierarchical, type-based auto-resolution skill with progressive complexity and Redis-backed communication.
-
-### Consequences
-- Reduced manual oversight
-- Standardized error handling
-- Enhanced system resilience
-- Minimal performance overhead
-
-## 2. Automatic Execution Workflow
-
-### 2.1 Hook Trigger Sequence
-```bash
-#!/bin/bash
-# post-edit-handler.sh
-set -euo pipefail
-
-FILE_PATH="${1:-}"
-MEMORY_KEY="${2:-swarm/default}"
-
-# Validate input
-[[ -z "$FILE_PATH" ]] && {
-  echo "Error: No file path provided" >&2
-  exit 1
-}
-
-# Run feedback resolver
-/bin/bash /config/hooks/feedback-resolver.sh "$FILE_PATH" "$MEMORY_KEY"
-```
-
-### 2.2 Execution Phases
-1. File modification detected
-2. Post-edit hook triggered
-3. Feedback resolver analyzes file
-4. Auto-resolution attempted
-5. Optional human intervention
-
-## 3. Feedback Types Priority Matrix
-
-| Type | Severity | Auto-Resolution | Human Intervention |
-|------|----------|-----------------|-------------------|
-| ROOT_WARNING | High | Auto-move | Optional review |
-| TDD_VIOLATION | High | Generate test scaffolding | Code review required |
-| LOW_COVERAGE | Medium | Generate additional tests | Optional optimization |
-| RUST_QUALITY | Medium | Apply auto-linting | Style guide alignment |
-| LINT_ISSUES | Low | Auto-fix via ESLint | Optional refinement |
-
-## 4. ROOT_WARNING Handling
-
-### 4.1 Auto-Move Script
-```bash
-#!/bin/bash
-# auto-move-handler.sh
-handle_root_warning() {
-  local file_path="$1"
-  local filename=$(basename "$file_path")
-
-  # Predefined move destinations
-  declare -A destinations=(
-    ["*.js"]="src/"
-    ["*.ts"]="src/"
-    ["*.md"]="docs/"
-    ["*.test.js"]="tests/"
-    ["*.config.js"]="config/"
-  )
-
-  for pattern in "${!destinations[@]}"; do
-    if [[ "$filename" == $pattern ]]; then
-      destination="${destinations[$pattern]}"
-      mv "$file_path" "$destination$filename"
-      echo "Moved $filename to $destination"
-      return 0
-    fi
-  done
-
-  # Fallback: generate warning
-  redis-cli publish "agent:feedback" "{
-    \"type\": \"ROOT_WARNING\",
-    \"file\": \"$file_path\",
-    \"message\": \"Unable to auto-resolve file location\"
-  }"
-}
-```
-
-## 5. TDD_VIOLATION Handling
-
-### 5.1 Test Generation Strategy
-```bash
-#!/bin/bash
-# tdd-violation-handler.sh
-generate_test_scaffold() {
-  local source_file="$1"
-  local test_file="${source_file/.js/.test.js}"
-
-  # Basic test scaffold generation
-  cat > "$test_file" <<EOF
-import { describe, it, expect } from 'vitest'
-import { $(basename "${source_file%.*}") } from '$source_file'
-
-describe('${source_file}', () => {
-  it('should have basic test coverage', () => {
-    // TODO: Implement specific tests
-    expect(true).toBe(true)
-  })
-})
-EOF
-}
-```
-
-## 6. Redis Feedback Integration
-
-### 6.1 CLI Subscription Pattern
-```bash
-#!/bin/bash
-# redis-feedback-subscriber.sh
-redis-cli subscribe "agent:feedback" | while read -r event; do
-  case "$event" in
-    *ROOT_WARNING*)
-      handle_root_warning "$event"
-      ;;
-    *TDD_VIOLATION*)
-      generate_test_scaffold "$event"
-      ;;
-    # Additional handlers
-  esac
-done
-```
-
-## 7. Confidence and Performance Metrics
-
-```json
-{
-  "skill_confidence": 0.87,
-  "resolution_success_rate": 0.92,
-  "avg_resolution_time_ms": 42,
-  "total_auto_resolutions": 1247
-}
-```
-
-## 8. Deployment and Configuration
-
-### Installation
-```bash
-npm install @claude-flow/hook-resolver
-claude-flow hooks install post-edit-resolver
-```
-
-## 9. Future Improvements
-- Machine learning-based resolution recommendations
-- Expanded pattern matching
-- More granular feedback types
-- Enhanced test generation