claude-flow-novice 2.6.0 → 2.8.1

package/.claude/skills/agent-selector/SKILL.md

@@ -0,0 +1,90 @@
+# Agent Selector Skill
+
+**Version:** 1.0.0
+**Purpose:** Select optimal agents for CFN Loop v3 based on task type and requirements
+
+## Overview
+
+Recommends Loop 3 (producers) and Loop 2 (evaluators) agents based on:
+- Task type (from task-classifier)
+- Task description keywords
+- Complexity requirements
+
+## Usage
+
+```bash
+AGENTS=$(./.claude/skills/agent-selector/select-agents.sh \
+  --task-type "software-development" \
+  --description "Implement JWT authentication with refresh tokens")
+
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
+echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
+```
+
+## Output Format
+
+```json
+{
+  "loop3": ["agent1", "agent2", "agent3"],
+  "loop2": ["validator1", "validator2", "validator3"],
+  "loop4": "product-owner",
+  "reasoning": "Explanation of agent selection"
+}
+```
+
+## Agent Selection Rules
+
+### Software Development
+**Base Loop 3:** backend-dev, coder
+**Add if keywords:**
+- "security", "authentication", "JWT" → security-specialist
+- "database", "SQL", "schema" → database-engineer (if exists)
+- "deploy", "CI/CD", "infrastructure" → devops-engineer
+- "frontend", "React", "UI" → react-frontend-engineer
+
+**Loop 2:** reviewer, tester, security-auditor
+
+### Content Creation
+**Base Loop 3:** copywriter, content-strategist
+**Add if keywords:**
+- "SEO", "search", "keywords" → seo-specialist
+- "technical", "documentation" → technical-writer (if exists)
+
+**Loop 2:** editor, brand-reviewer, compliance-checker
+
+### Research
+**Base Loop 3:** researcher, data-analyst
+**Add if keywords:**
+- "statistics", "data analysis" → statistician (if exists)
+- "domain-specific" → domain-expert
+
+**Loop 2:** fact-checker, methodology-reviewer, statistician
+
+### Design
+**Base Loop 3:** ui-designer, ux-researcher
+**Add if keywords:**
+- "visual", "branding" → visual-designer
+- "accessibility" → accessibility-advocate
+
+**Loop 2:** accessibility-advocate, design-critic, user-tester
+
+### Infrastructure
+**Base Loop 3:** devops-engineer, terraform-engineer
+**Add if keywords:**
+- "Kubernetes", "k8s", "container" → kubernetes-architect
+- "network", "security" → network-engineer (if exists)
+
+**Loop 2:** security-auditor, cost-optimizer, compliance-checker
+
+### Data Engineering
+**Base Loop 3:** data-engineer, pipeline-builder
+**Add if keywords:**
+- "ETL", "transformation" → etl-specialist
+- "streaming", "real-time" → streaming-specialist (if exists)
+
+**Loop 2:** data-quality-validator, schema-reviewer, performance-tester
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Agent selection

package/.claude/skills/agent-selector/select-agents.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# Dynamic Agent Selection with JSON Registry
+
+set -euo pipefail
+
+# Paths
+REGISTRY_PATH=".claude/skills/agent-discovery/agents-registry.json"
+LOG_PATH="/tmp/agent_selection_$(date +%s).log"
+
+# Validate inputs
+if [[ $# -lt 2 ]]; then
+    echo "Usage: $0 --task-type TYPE --description 'task description'" >&2
+    exit 1
+fi
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --task-type) TASK_TYPE="$2"; shift 2 ;;
+        --description) DESCRIPTION="$2"; shift 2 ;;
+        *) echo "Unknown parameter: $1" >&2; exit 1 ;;
+    esac
+done
+
+# Validate registry
+if [[ ! -f "$REGISTRY_PATH" ]]; then
+    echo "Error: Agent registry not found at $REGISTRY_PATH. Run agent discovery first." >&2
+    exit 1
+fi
+
+# Score agents function with simple matching
+score_agents() {
+    local registry_path="$1"
+    local description="$2"
+    local task_type="$3"
+
+    # Simple JQ query for agent matching
+    jq -r --arg desc "$description" --arg task_type "$task_type" '
+        [
+            .agents[]
+            | select(.type == $task_type)
+            | {
+                name: .name,
+                score: (
+                    # Base type match score
+                    10 +
+                    # Keyword matching
+                    (
+                        [.keywords[]]
+                        | map(select(
+                            ($desc | ascii_downcase | contains(. | ascii_downcase))
+                        ))
+                        | length * 3
+                    )
+                )
+            }
+        ]
+        | sort_by(.score)
+        | reverse
+        | .[0:3]
+        | map(.name)
+    ' "$registry_path"
+}
+
+# Score agents
+LOOP3_AGENTS=$(score_agents "$REGISTRY_PATH" "$DESCRIPTION" "specialist")
+LOOP2_AGENTS=$(score_agents "$REGISTRY_PATH" "$DESCRIPTION" "strategic")
+
+# Default fallback
+if [[ -z "$LOOP3_AGENTS" || "$LOOP3_AGENTS" == "[]" ]]; then
+    LOOP3_AGENTS='["product-owner"]'
+fi
+
+if [[ -z "$LOOP2_AGENTS" || "$LOOP2_AGENTS" == "[]" ]]; then
+    LOOP2_AGENTS='["product-owner"]'
+fi
+
+# Log the results
+{
+    echo "Task Description: $DESCRIPTION"
+    echo "Loop 3 Agents: $LOOP3_AGENTS"
+    echo "Loop 2 Agents: $LOOP2_AGENTS"
+} >> "$LOG_PATH"
+
+# Output JSON result with detailed reasoning
+jq -n \
+    --argjson loop3 "$LOOP3_AGENTS" \
+    --argjson loop2 "$LOOP2_AGENTS" \
+    --arg desc "$DESCRIPTION" \
+    '{
+        "loop3": $loop3,
+        "loop2": $loop2,
+        "loop4": "product-owner",
+        "reasoning": "Selected agents by scoring against task description: \($desc)",
+        "log_path": "'"$LOG_PATH"'"
+    }'

package/.claude/skills/agent-spawning/agent-selection-guide.md

@@ -135,7 +135,7 @@ Code Quality Focus → + code-analyzer
 **Complex (6-7 agents):**
 ```bash
 # Enterprise features, multi-component systems
---agents=analyst,system-architect,backend-dev,frontend-dev,security-specialist,tester,reviewer
+--agents=analyst,system-architect,backend-dev,react-frontend-engineer,security-specialist,tester,reviewer
 --agents=system-architect,architect,backend-dev,security-specialist,devops-engineer,production-validator
 ```
 

package/.claude/skills/agent-swap/SKILL.md

@@ -0,0 +1,36 @@
+# Agent Swap Mechanism Skill
+
+## Purpose
+Recommend agent replacement strategies when performance issues are detected in CFN Loops.
+
+## Replacement Rules
+1. Identify lowest-performing agent
+2. Match replacement based on feedback themes
+   - Security feedback → security-specialist
+   - Performance feedback → performance-engineer
+   - Testing feedback → tester
+   - Architecture feedback → architect
+
+## Replacement Strategies
+- Complete agent replacement
+- Adding specialist alongside existing agents
+- Prioritize maintaining existing team composition
+
+## Usage
+```bash
+./recommend-swap.sh \
+  --loop3-agents "backend-dev,coder" \
+  --loop3-confidences "0.82,0.70" \
+  --feedback-themes "security,error-handling"
+```
+
+## Output Details
+- Agent to remove
+- Reasoning for removal
+- Recommended replacement agent
+- Updated agent configuration
+
+## Implementation Considerations
+- Stateless design
+- Minimal side effects
+- Clear, reproducible recommendations

package/.claude/skills/agent-swap/recommend-swap.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --loop3-agents) IFS=',' read -ra AGENTS <<< "$2"; shift 2 ;;
+        --loop3-confidences) IFS=',' read -ra CONFIDENCES <<< "$2"; shift 2 ;;
+        --feedback-themes) IFS=',' read -ra THEMES <<< "$2"; shift 2 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+done
+
+# Agent Swap Rules
+get_specialist_for_theme() {
+    local theme="$1"
+    case "$theme" in
+        *security*) echo "security-specialist" ;;
+        *performance*) echo "performance-engineer" ;;
+        *test*|*coverage*) echo "testing-expert" ;;
+        *architecture*) echo "architecture-consultant" ;;
+        *) echo "generic-specialist" ;;
+    esac
+}
+
+# Find lowest confidence agent
+lowest_confidence_index=0
+lowest_confidence="${CONFIDENCES[0]}"
+
+for i in "${!CONFIDENCES[@]}"; do
+    if (( $(echo "${CONFIDENCES[i]} < $lowest_confidence" | bc -l) )); then
+        lowest_confidence="${CONFIDENCES[i]}"
+        lowest_confidence_index=$i
+    fi
+done
+
+# Recommend replacement specialist
+recommended_specialist=""
+for theme in "${THEMES[@]}"; do
+    specialist=$(get_specialist_for_theme "$theme")
+    if [[ -n "$specialist" ]]; then
+        recommended_specialist="$specialist"
+        break
+    fi
+done
+
+# Generate output
+jq -n \
+    --arg remove_agent "${AGENTS[lowest_confidence_index]}" \
+    --arg add_agent "$recommended_specialist" \
+    --argjson agents "$(printf '%s\n' "${AGENTS[@]}" | jq -R . | jq -s '.')" \
+    --arg lowest_confidence "$lowest_confidence" \
+    --argjson themes "$(printf '%s\n' "${THEMES[@]}" | jq -R . | jq -s '.')" \
+    '{
+        "remove_agent": $remove_agent,
+        "remove_reason": "Lowest confidence (\($lowest_confidence)), contributing to plateau",
+        "add_agent": $add_agent,
+        "add_reason": "Match to feedback themes: \(join(", ", $themes))",
+        "new_loop3_agents": [$agents | map(select(. != $remove_agent)), $add_agent]
+    }'

package/.claude/skills/api-validation/test-endpoints.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# API Endpoint Validation Script
+# Usage: ./test-endpoints.sh <base-url> <endpoint> [request-count]
+
+BASE_URL="${1:-http://localhost:8080}"
+ENDPOINT="$2"
+COUNT="${3:-10}"
+
+if [ -z "$ENDPOINT" ]; then
+  echo "Usage: $0 <base-url> <endpoint> [request-count]"
+  exit 1
+fi
+
+echo "Testing: $BASE_URL$ENDPOINT"
+echo "Requests: $COUNT"
+echo ""
+
+SUCCESS=0
+FAILED=0
+TOTAL_RESPONSE_TIME=0
+
+for i in $(seq 1 "$COUNT"); do
+  START_TIME=$(date +%s.%N)
+  RESPONSE=$(curl -s -w "\n%{http_code}\n%{time_total}" "$BASE_URL$ENDPOINT")
+
+  HTTP_STATUS=$(echo "$RESPONSE" | tail -1)
+  RESPONSE_TIME=$(echo "$RESPONSE" | tail -2 | head -1)
+  BODY=$(echo "$RESPONSE" | head -n -2)
+
+  if [ "$HTTP_STATUS" = "200" ]; then
+    echo "✅ Request $i: 200 OK (Response Time: ${RESPONSE_TIME}s)"
+    ((SUCCESS++))
+  else
+    echo "❌ Request $i: $HTTP_STATUS"
+    echo "   Response: $BODY"
+    ((FAILED++))
+  fi
+
+  TOTAL_RESPONSE_TIME=$(echo "$TOTAL_RESPONSE_TIME + $RESPONSE_TIME" | bc)
+
+  [ $i -lt "$COUNT" ] && sleep 2
+done
+
+AVG_RESPONSE_TIME=$(echo "scale=3; $TOTAL_RESPONSE_TIME / $COUNT" | bc)
+
+echo ""
+echo "Results:"
+echo "- Requests: $COUNT total"
+echo "- Succeeded: $SUCCESS"
+echo "- Failed: $FAILED"
+echo "- Average Response Time: ${AVG_RESPONSE_TIME}s"
+
+# Strict success criteria
+[ $FAILED -eq 0 ] && exit 0 || exit 1

package/.claude/skills/automatic-memory-persistence/SKILL.md

@@ -0,0 +1,73 @@
+# Automatic Memory Persistence Skill
+
+## Overview
+This skill provides automatic, structured persistence of agent outputs to a SQLite database, ensuring consistent memory tracking across CFN Loop workflows.
+
+## Key Components
+- `persist-agent-output.sh`: Primary script for saving agent outputs
+- `query-agent-history.sh`: Query and retrieve past agent outputs
+- `test-memory-persistence.sh`: Validation test suite
+
+## Memory Schema
+```json
+{
+  "agent/[agent-id]/output/[task-id]": {
+    "output": "Raw agent output text",
+    "confidence": 0.85,
+    "iteration": 1,
+    "timestamp": "2025-10-20T15:30:00Z",
+    "parsed_data": null
+  }
+}
+```
+
+## Integration Points
+- Loop 3 output processing
+- Loop 2 output processing
+- Product Owner decision parsing
+
+## Usage Examples
+
+### Persist Agent Output
+```bash
+./persist-agent-output.sh \
+  "task_authentication_v1" \  # Task ID
+  "backend-dev" \             # Agent ID
+  "Implemented JWT auth" \    # Output
+  0.85 \                      # Confidence
+  1                           # Iteration
+```
+
+### Query Agent History
+```bash
+# Get last 5 outputs for a specific agent
+./query-agent-history.sh "backend-dev" "" 5
+
+# Get outputs for a specific task
+./query-agent-history.sh "backend-dev" "task_authentication_v1"
+```
+
+## Security & Performance
+- ACL Level 1 (Read-only access)
+- Indexed by tags for fast retrieval
+- Minimal performance overhead
+- Escaped and normalized inputs
+
+## Testing
+Run comprehensive tests:
+```bash
+./test-memory-persistence.sh
+```
+
+## Sprint 7 Insights
+- **Confidence**: 0.95
+- **Priority**: 9
+- Provides robust, zero-configuration memory tracking
+- Eliminates manual output saving
+- Supports multi-iteration workflows
+
+## Best Practices
+- Always use script for output persistence
+- Do not modify SQLite database directly
+- Use query script for retrieval
+- Add structured parsing for complex outputs

package/.claude/skills/automatic-memory-persistence/persist-agent-output.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# Saves agent output to SQLite via TypeScript adapter
+
+# Enable strict error handling
+set -euo pipefail
+
+# Input validation
+if [[ $# -lt 5 ]]; then
+    echo "Usage: $0 <TASK_ID> <AGENT_ID> <AGENT_OUTPUT> <CONFIDENCE> <ITERATION>"
+    exit 1
+fi
+
+TASK_ID="$1"
+AGENT_ID="$2"
+AGENT_OUTPUT="$3"
+CONFIDENCE="$4"
+ITERATION="$5"
+
+# Normalize confidence to float
+NORMALIZED_CONFIDENCE=$(printf "%.2f" "$CONFIDENCE")
+
+# Ensure output is properly escaped for JSON
+ESCAPED_OUTPUT=$(echo "$AGENT_OUTPUT" | jq -R -s '.')
+
+# Call TypeScript persistence layer
+node -e "
+const { SQLiteAdapter } = require('./src/cli/sqlite-adapter');
+const adapter = new SQLiteAdapter();
+
+const memoryKey = \`agent/${AGENT_ID}/output/${TASK_ID}\`;
+const outputRecord = {
+  output: $ESCAPED_OUTPUT,
+  confidence: parseFloat('$NORMALIZED_CONFIDENCE'),
+  iteration: parseInt('$ITERATION'),
+  timestamp: new Date().toISOString(),
+  parsed_data: null  // Optional: Add structured parsing logic here
+};
+
+try {
+  adapter.set(memoryKey, outputRecord, {
+    aclLevel: 1,  // Read-only access
+    tags: ['agent-output', \`agent-${AGENT_ID}\`, \`task-${TASK_ID}\`]
+  });
+  console.log(\`Successfully persisted output for agent ${AGENT_ID} in task ${TASK_ID}\`);
+} catch (error) {
+  console.error('Memory persistence failed:', error);
+  process.exit(1);
+}
+"

package/.claude/skills/automatic-memory-persistence/query-agent-history.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Query agent output history from SQLite
+
+# Enable strict error handling
+set -euo pipefail
+
+# Input validation
+if [[ $# -lt 1 ]]; then
+    echo "Usage: $0 <AGENT_ID> [TASK_ID] [MAX_ENTRIES]"
+    exit 1
+fi
+
+AGENT_ID="$1"
+TASK_ID="${2:-}"
+MAX_ENTRIES="${3:-10}"
+
+# Call TypeScript query layer
+node -e "
+const { SQLiteAdapter } = require('./src/cli/sqlite-adapter');
+const adapter = new SQLiteAdapter();
+
+const queryPattern = '${AGENT_ID}' + (process.argv[2] ? '/output/${TASK_ID}' : '/output/*');
+
+try {
+  const results = adapter.query(queryPattern, {
+    limit: parseInt('${MAX_ENTRIES}'),
+    order: 'timestamp DESC'
+  });
+
+  console.log(JSON.stringify(results, null, 2));
+} catch (error) {
+  console.error('Query failed:', error);
+  process.exit(1);
+}
+" "${TASK_ID}"