claude-flow-novice 2.8.1 → 2.9.0

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

@@ -1,73 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-#!/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

@@ -1,35 +0,0 @@
-#!/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}"

package/.claude/skills/automatic-memory-persistence/test-memory-persistence.sh

@@ -1,235 +0,0 @@
-#!/bin/bash
-# Comprehensive Test Suite for Automatic Memory Persistence Skill
-
-set -e
-
-# Temporary test database
-TEST_DB="/tmp/test_memory_persistence_$(date +%s).sqlite"
-
-# Mock SQLite database creation for testing
-setup_mock_database() {
-    sqlite3 "$TEST_DB" << EOF
-CREATE TABLE agent_outputs (
-    task_id TEXT NOT NULL,
-    agent_id TEXT NOT NULL,
-    output TEXT NOT NULL,
-    confidence REAL NOT NULL,
-    iteration INTEGER NOT NULL,
-    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (task_id, agent_id, iteration)
-);
-CREATE INDEX idx_agent_task ON agent_outputs(agent_id, task_id);
-EOF
-}
-
-# Mock persist-agent-output.sh for testing
-mock_persist_agent_output() {
-    local task_id="$1"
-    local agent_id="$2"
-    local output="$3"
-    local confidence="$4"
-    local iteration="$5"
-
-    sqlite3 "$TEST_DB" << EOF
-INSERT OR REPLACE INTO agent_outputs
-(task_id, agent_id, output, confidence, iteration)
-VALUES
-('$task_id', '$agent_id', '$output', $confidence, $iteration);
-EOF
-}
-
-# Mock query-agent-history.sh for testing
-mock_query_agent_history() {
-    local agent_id="$1"
-    local task_id="$2"
-
-    sqlite3 "$TEST_DB" << EOF
-SELECT task_id, agent_id, output, confidence, iteration
-FROM agent_outputs
-WHERE agent_id = '$agent_id' AND task_id = '$task_id';
-EOF
-}
-
-# Test 1: Successful output persistence with complete fields
-test_output_persistence() {
-    local task_id="test_task_complete_$(date +%s)"
-    local agent_id="test_agent_complete"
-    local test_output="Comprehensive agent output with complete details"
-    local confidence=0.95
-    local iteration=1
-
-    # Persist output
-    mock_persist_agent_output "$task_id" "$agent_id" "$test_output" "$confidence" "$iteration"
-
-    # Query and validate
-    local query_result
-    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
-
-    if [ -z "$query_result" ]; then
-        echo "Test 1 failed: No output retrieved for complete fields"
-        return 1
-    fi
-
-    # Validate specific fields (using different field splitting)
-    local retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration
-    IFS='|' read -r retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration <<< "$query_result"
-
-    if [ "$retrieved_task_id" != "$task_id" ] ||
-       [ "$retrieved_agent_id" != "$agent_id" ] ||
-       [ "$retrieved_output" != "$test_output" ] ||
-       [ "$(echo "$retrieved_confidence != $confidence" | bc)" -eq 1 ] ||
-       [ "$retrieved_iteration" != "$iteration" ]; then
-        echo "Test 1 failed: Retrieved data does not match persisted data"
-        return 1
-    fi
-
-    echo "Test 1: Complete output persistence passed"
-    return 0
-}
-
-# Test 2: Multiple agent outputs for same task
-test_multiple_agent_outputs() {
-    local task_id="test_task_multiple_$(date +%s)"
-    local agent_id_1="test_agent_1"
-    local agent_id_2="test_agent_2"
-    local test_output_1="First agent output"
-    local test_output_2="Second agent output"
-    local confidence_1=0.85
-    local confidence_2=0.90
-    local iteration_1=1
-    local iteration_2=2
-
-    # Persist outputs for multiple agents
-    mock_persist_agent_output "$task_id" "$agent_id_1" "$test_output_1" "$confidence_1" "$iteration_1"
-    mock_persist_agent_output "$task_id" "$agent_id_2" "$test_output_2" "$confidence_2" "$iteration_2"
-
-    # Query and validate multiple agent outputs
-    local query_result_1 query_result_2
-    query_result_1=$(mock_query_agent_history "$agent_id_1" "$task_id")
-    query_result_2=$(mock_query_agent_history "$agent_id_2" "$task_id")
-
-    if [ -z "$query_result_1" ] || [ -z "$query_result_2" ]; then
-        echo "Test 2 failed: Missing outputs for multiple agents"
-        return 1
-    fi
-
-    echo "Test 2: Multiple agent outputs for same task passed"
-    return 0
-}
-
-# Test 3: Error handling for invalid/missing data
-test_invalid_data_handling() {
-    local task_id="test_task_invalid_$(date +%s)"
-    local agent_id="test_agent_invalid"
-
-    # Attempt to query non-existent data
-    local query_result
-    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
-
-    if [ -n "$query_result" ]; then
-        echo "Test 3 failed: Non-empty result for non-existent data"
-        return 1
-    fi
-
-    echo "Test 3: Invalid data handling passed"
-    return 0
-}
-
-# Test 4: Iteration and confidence tracking
-test_iteration_confidence_tracking() {
-    local task_id="test_task_iterations_$(date +%s)"
-    local agent_id="test_agent_iterations"
-    local outputs=("Initial output" "Improved output" "Final output")
-    local confidences=(0.70 0.85 0.95)
-    local iterations=(1 2 3)
-
-    # Persist multiple iterations with increasing confidence
-    for i in "${!outputs[@]}"; do
-        mock_persist_agent_output "$task_id" "$agent_id" "${outputs[i]}" "${confidences[i]}" "${iterations[i]}"
-    done
-
-    # Verify iterations are tracked
-    local iteration_count
-    iteration_count=$(sqlite3 "$TEST_DB" "SELECT COUNT(DISTINCT iteration) FROM agent_outputs WHERE task_id = '$task_id' AND agent_id = '$agent_id';")
-
-    if [ "$iteration_count" -ne 3 ]; then
-        echo "Test 4 failed: Incorrect iteration tracking"
-        return 1
-    fi
-
-    echo "Test 4: Iteration and confidence tracking passed"
-    return 0
-}
-
-# Test 5: ACL-level validation simulation
-test_acl_simulation() {
-    local task_id="test_task_acl_$(date +%s)"
-    local authorized_agent="authorized_agent"
-    local unauthorized_agent="unauthorized_agent"
-    local output="Confidential agent output"
-    local confidence=0.90
-    local iteration=1
-
-    # Simulate persisting output
-    mock_persist_agent_output "$task_id" "$authorized_agent" "$output" "$confidence" "$iteration"
-
-    # Verify authorized agent can access
-    local auth_query_result
-    auth_query_result=$(mock_query_agent_history "$authorized_agent" "$task_id")
-
-    if [ -z "$auth_query_result" ]; then
-        echo "Test 5 (Part A) failed: Authorized agent cannot access output"
-        return 1
-    fi
-
-    # Simulate unauthorized access attempt
-    local unauth_query_result
-    unauth_query_result=$(mock_query_agent_history "$unauthorized_agent" "$task_id")
-
-    if [ -n "$unauth_query_result" ]; then
-        echo "Test 5 (Part B) failed: Unauthorized agent could access output"
-        return 1
-    fi
-
-    echo "Test 5: ACL-level validation simulation passed"
-    return 0
-}
-
-# Main test runner
-main() {
-    echo "Running Comprehensive Memory Persistence Tests..."
-
-    # Setup test database
-    setup_mock_database
-
-    # Run tests
-    local total_tests=5
-    local passed_tests=0
-
-    # Execute each test
-    test_output_persistence && passed_tests=$((passed_tests+1))
-    test_multiple_agent_outputs && passed_tests=$((passed_tests+1))
-    test_invalid_data_handling && passed_tests=$((passed_tests+1))
-    test_iteration_confidence_tracking && passed_tests=$((passed_tests+1))
-    test_acl_simulation && passed_tests=$((passed_tests+1))
-
-    # Calculate confidence
-    local confidence=$(echo "scale=2; $passed_tests / $total_tests" | bc)
-
-    # Cleanup test database
-    rm -f "$TEST_DB"
-
-    # Report results
-    if [ "$passed_tests" -eq "$total_tests" ]; then
-        echo "All Memory Persistence Tests Passed!"
-        echo "Test Confidence: $confidence"
-        exit 0
-    else
-        echo "Memory Persistence Test Suite Failed: $passed_tests/$total_tests tests passed"
-        echo "Test Confidence: $confidence"
-        exit 1
-    fi
-}
-
-# Execute main test runner
-main

package/.claude/skills/cfn-loop-orchestration/SKILL.md

@@ -1,299 +0,0 @@
-# CFN Loop Orchestration Skill
-
-## Metadata
-- **Skill ID:** cfn-loop-orchestration
-- **Version:** 1.0.0
-- **Category:** Workflow Orchestration
-- **Dependencies:** redis-coordination, product-owner-decision, agent-output-processing
-- **Maturity:** Production
-- **Last Updated:** 2025-10-23
-
-## Purpose
-Orchestrates the Complete Fail Never (CFN) Loop workflow, managing the three-loop structure:
-- Loop 3 (Primary Swarm - Implementation)
-- Loop 2 (Consensus Validators - Review)
-- Product Owner Decision (Strategic Approval)
-
-## Responsibilities
-1. Coordinate multi-agent CFN Loop execution
-2. Manage gate checks and consensus validation
-3. Handle iteration cycles with feedback injection
-4. Interface with Redis Coordination for agent synchronization
-5. Execute Product Owner decision flow
-6. Enforce dependency ordering (Loop 3 → Loop 2 → PO)
-
-## Interface
-
-### Main Entry Point
-```bash
-./.claude/skills/cfn-loop-orchestration/orchestrate.sh \
-  --task-id <unique-id> \
-  --mode <mvp|standard|enterprise> \
-  --loop3-agents <agent1,agent2,...> \
-  --loop2-agents <agent1,agent2,...> \
-  --product-owner <agent-id> \
-  [--max-iterations <n>] \
-  [--min-quorum-loop3 <n|n%|0.n>] \
-  [--min-quorum-loop2 <n|n%|0.n>] \
-  [--epic-context <json>] \
-  [--phase-context <json>] \
-  [--success-criteria <json>] \
-  [--expected-files <file1,file2,...>] \
-  [--phase-id <phase-identifier>]
-```
-
-### Parameters
-- `task-id`: Unique identifier for this CFN Loop execution
-- `mode`: Workflow mode (mvp, standard, enterprise) - determines thresholds
-- `loop3-agents`: Comma-separated list of implementer agent IDs
-- `loop2-agents`: Comma-separated list of validator agent IDs
-- `product-owner`: Agent ID for strategic decision-making
-- `max-iterations`: Maximum iteration cycles (default: 10)
-- `min-quorum-loop3`: Minimum Loop 3 agents required (default: 0.66)
-- `min-quorum-loop2`: Minimum Loop 2 agents required (default: 0.66)
-- `epic-context`: JSON string with epic-level context
-- `phase-context`: JSON string with phase-level context
-- `success-criteria`: JSON string with acceptance criteria
-- `expected-files`: Comma-separated list of expected deliverable files
-- `phase-id`: Phase identifier for timeout configuration
-
-### Return Values
-- Exit Code 0: CFN Loop completed successfully (PROCEED decision)
-- Exit Code 1: CFN Loop failed (ABORT decision or max iterations)
-- Exit Code 130: User interrupt (graceful shutdown)
-
-### Output Format (JSON)
-```json
-{
-  "status": "success|failed|aborted",
-  "iterations_completed": 2,
-  "final_decision": "PROCEED|ITERATE|ABORT",
-  "loop3_confidence": 0.92,
-  "loop2_consensus": 0.94,
-  "deliverables_verified": true,
-  "execution_time_seconds": 1847
-}
-```
-
-## Helper Scripts
-
-### 1. gate-check.sh
-Validates Loop 3 self-assessment against gate threshold.
-
-**Usage:**
-```bash
-./.claude/skills/cfn-loop-orchestration/helpers/gate-check.sh \
-  --task-id <id> \
-  --agents <agent1,agent2,...> \
-  --threshold <0.0-1.0> \
-  --min-quorum <n|n%|0.n>
-```
-
-**Returns:**
-- Exit 0: Gate passed (broadcast signal to Loop 2)
-- Exit 1: Gate failed (prepare Loop 3 iteration)
-
-### 2. consensus.sh
-Collects and validates Loop 2 consensus scores.
-
-**Usage:**
-```bash
-./.claude/skills/cfn-loop-orchestration/helpers/consensus.sh \
-  --task-id <id> \
-  --agents <agent1,agent2,...> \
-  --threshold <0.0-1.0> \
-  --min-quorum <n|n%|0.n>
-```
-
-**Returns:**
-- Exit 0: Consensus reached
-- Exit 1: Consensus failed
-
-### 3. iteration-manager.sh
-Manages iteration cycles and feedback injection.
-
-**Usage:**
-```bash
-./.claude/skills/cfn-loop-orchestration/helpers/iteration-manager.sh \
-  --task-id <id> \
-  --iteration <n> \
-  --agents <agent1,agent2,...> \
-  --feedback-source <redis-key>
-```
-
-**Returns:**
-- Exit 0: Agents awakened for next iteration
-- Exit 1: Iteration limit exceeded
-
-### 4. deliverable-verifier.sh
-Verifies expected deliverables were created.
-
-**Usage:**
-```bash
-./.claude/skills/cfn-loop-orchestration/helpers/deliverable-verifier.sh \
-  --expected-files <file1,file2,...> \
-  --task-type <keyword-detection>
-```
-
-**Returns:**
-- Exit 0: Deliverables verified
-- Exit 1: Missing deliverables (forced iteration)
-
-### 5. timeout-calculator.sh
-Calculates phase-specific timeouts.
-
-**Usage:**
-```bash
-./.claude/skills/cfn-loop-orchestration/helpers/timeout-calculator.sh \
-  --phase-id <phase-identifier>
-```
-
-**Returns:**
-- Timeout value in seconds (stdout)
-
-## CFN Loop Flow
-
-```
-1. Initialize Swarm Context (Redis)
-   ↓
-2. Spawn Loop 3 Agents (CLI)
-   ↓
-3. Collect Loop 3 Confidence Scores
-   ↓
-4. Gate Check (helpers/gate-check.sh)
-   ├─ PASS → Signal Loop 2 to start
-   └─ FAIL → Wake Loop 3 for iteration N+1 (goto step 2)
-   ↓
-5. Loop 2 Validates Loop 3 Work
-   ↓
-6. Collect Loop 2 Consensus Scores
-   ↓
-7. Verify Deliverables (helpers/deliverable-verifier.sh)
-   ↓
-8. Spawn Product Owner for Decision
-   ↓
-9. Parse Product Owner Decision
-   ├─ PROCEED → Exit success
-   ├─ ITERATE → Wake all agents (goto step 2)
-   └─ ABORT → Exit failure
-```
-
-## Redis Coordination Interface
-
-This skill consumes the following Redis Coordination primitives:
-
-### Context Storage
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence <0.0-1.0> \
-  --iteration <n>
-```
-
-### Signal Broadcasting
-```bash
-redis-cli lpush "swarm:${TASK_ID}:gate-passed" "1"
-```
-
-### Agent Waiting/Waking
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh wake \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --reason <reason> \
-  --iteration <n> \
-  --feedback <feedback-string>
-```
-
-### Result Collection
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh collect \
-  --task-id "$TASK_ID" \
-  --agent-ids <comma-separated>
-```
-
-## Mode-Specific Thresholds
-
-| Mode | Gate Threshold | Consensus Threshold | Max Iterations | Validators |
-|------|----------------|---------------------|----------------|------------|
-| MVP | 0.70 | 0.80 | 5 | 2 |
-| Standard | 0.75 | 0.90 | 10 | 3-4 |
-| Enterprise | 0.75 | 0.95 | 15 | 5 |
-
-## Error Handling
-
-### Critical Failures
-- Redis unavailable: Exit immediately with error
-- Agent spawn failure: Retry with exponential backoff
-- Timeout exceeded: Log state, attempt graceful shutdown
-
-### Recoverable Failures
-- Gate check failure: Iterate Loop 3
-- Consensus failure: Iterate all agents
-- Missing deliverables: Force iteration with explicit feedback
-
-## Configuration
-
-### Environment Variables
-- `REDIS_HOST`: Redis server host (default: localhost)
-- `REDIS_PORT`: Redis server port (default: 6379)
-- `CFN_DEBUG`: Enable debug logging (default: 0)
-
-### Redis Keys Used
-- `swarm:{task-id}:epic-context`: Epic-level context
-- `swarm:{task-id}:phase-context`: Phase-level context
-- `swarm:{task-id}:success-criteria`: Acceptance criteria
-- `swarm:{task-id}:agent:{agent-id}:confidence`: Agent confidence score
-- `swarm:{task-id}:agent:{agent-id}:feedback`: Agent-specific feedback
-- `swarm:{task-id}:gate-passed`: Gate pass signal for Loop 2
-- `swarm:{task-id}:{agent-id}:done`: Agent completion signal
-
-## Testing
-
-Run comprehensive test suite:
-```bash
-./.claude/skills/cfn-loop-orchestration/test-cfn-orchestration.sh
-```
-
-Test scenarios:
-1. Gate pass → Consensus pass → PROCEED
-2. Gate fail → Loop 3 iteration
-3. Consensus fail → Full iteration
-4. Missing deliverables → Forced iteration
-5. Max iterations → ABORT
-6. User interrupt → Graceful shutdown
-
-## Migration Notes
-
-This skill replaces the monolithic `.claude/skills/redis-coordination/orchestrate-cfn-loop.sh` by:
-1. Extracting CFN-specific workflow logic
-2. Delegating Redis operations to redis-coordination skill
-3. Modularizing helper functions into standalone scripts
-4. Simplifying testing and maintenance
-
-**Backward Compatibility:**
-Existing slash commands will be updated to call this skill instead of the monolithic orchestrator.
-
-## Performance Characteristics
-
-- Average execution time: 15-45 minutes (phase-dependent)
-- Zero-token waiting between iterations (Redis BLPOP)
-- Agent spawn time: 5-15 seconds per agent
-- Context storage/retrieval: <100ms per operation
-
-## Success Criteria
-
-This skill is considered successful when:
-1. All existing CFN Loop slash commands work without modification
-2. Test suite achieves 100% pass rate
-3. No regression in iteration management or consensus collection
-4. Clear separation from Redis Coordination primitives
-5. Helper scripts are reusable across different workflow types
-
-## Confidence Score: 0.92
-
-- Architecture: 0.95 (clear separation, modular design)
-- Implementation Risk: 0.88 (complex logic extraction)
-- Testing Coverage: 0.93 (comprehensive test scenarios)
-- Backward Compatibility: 0.92 (existing workflows preserved)