claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/test-execution/test-concurrent-conflicts.sh

@@ -1,115 +0,0 @@
-#!/bin/bash
-set -e
-
-RESULTS_FILE=".artifacts/analytics/test-conflict-results.json"
-mkdir -p .artifacts/analytics
-
-echo "═══════════════════════════════════════════════════════════"
-echo "🧪 Testing Concurrent Test Execution (20 runs)"
-echo "Coordinator Pattern: Single test run, multiple workers read cache"
-echo "═══════════════════════════════════════════════════════════"
-echo ""
-
-# Track conflicts
-CONFLICTS=0
-SUCCESSFUL_RUNS=0
-
-test_concurrent_execution() {
-  local run_id=$1
-
-  echo "──────────────────────────────────────"
-  echo "Test Cycle $run_id/20"
-  echo "──────────────────────────────────────"
-
-  # Step 1: Terminate existing tests (coordinator responsibility)
-  echo "[Run $run_id] Coordinator: Terminating existing tests..."
-  pkill -f vitest 2>/dev/null || true
-  pkill -f "npm test" 2>/dev/null || true
-  sleep 0.5
-
-  # Step 2: Coordinator creates test results (simulated)
-  echo "[Run $run_id] Coordinator: Running tests (simulated)..."
-  cat > test-results-$run_id.json << 'EOF'
-{
-  "numTotalTests": 100,
-  "numPassedTests": 95,
-  "numFailedTests": 5,
-  "numPendingTests": 0,
-  "testResults": [],
-  "success": true
-}
-EOF
-
-  # Step 3: Simulate 3 workers spawning and trying to access results
-  echo "[Run $run_id] Workers: Spawning 3 workers..."
-
-  for worker in {1..3}; do
-    (
-      # Worker waits for coordinator to finish
-      timeout 5 bash -c "
-        while [ ! -f test-results-$run_id.json ]; do
-          sleep 0.1
-        done
-        sleep 0.2 # Simulate processing time
-        echo '  Worker $worker: Read test results successfully'
-      " 2>/dev/null || echo "  Worker $worker: Timeout waiting for results"
-    ) &
-  done
-
-  # Wait for all workers
-  wait
-
-  # Step 4: Check for conflicts (multiple test processes)
-  VITEST_COUNT=$(pgrep -f vitest 2>/dev/null | wc -l || echo "0")
-  NPM_TEST_COUNT=$(pgrep -f "npm test" 2>/dev/null | wc -l || echo "0")
-  TOTAL_TEST_PROCESSES=$((VITEST_COUNT + NPM_TEST_COUNT))
-
-  if [ "$TOTAL_TEST_PROCESSES" -gt 0 ]; then
-    echo "❌ [Run $run_id] CONFLICT: $TOTAL_TEST_PROCESSES concurrent test processes detected"
-    CONFLICTS=$((CONFLICTS + 1))
-  else
-    echo "✅ [Run $run_id] No conflicts detected - coordinator pattern working"
-    SUCCESSFUL_RUNS=$((SUCCESSFUL_RUNS + 1))
-  fi
-
-  # Cleanup
-  pkill -f vitest 2>/dev/null || true
-  pkill -f "npm test" 2>/dev/null || true
-  rm -f test-results-$run_id.json
-  echo ""
-}
-
-# Run 20 test cycles
-for i in {1..20}; do
-  test_concurrent_execution $i
-done
-
-# Generate report
-CONFLICT_RATE=$(echo "scale=2; ($CONFLICTS / 20) * 100" | bc)
-
-cat > $RESULTS_FILE << REPORT
-{
-  "total_runs": 20,
-  "successful_runs": $SUCCESSFUL_RUNS,
-  "conflicts_detected": $CONFLICTS,
-  "conflict_rate": $CONFLICT_RATE,
-  "passed": $([ $CONFLICTS -eq 0 ] && echo "true" || echo "false"),
-  "threshold": "zero_conflicts",
-  "coordinator_pattern": "implemented",
-  "test_date": "$(date -I)"
-}
-REPORT
-
-echo "═══════════════════════════════════════════════════════════"
-echo "TEST RESULTS"
-echo "═══════════════════════════════════════════════════════════"
-cat $RESULTS_FILE
-echo ""
-
-if [ $CONFLICTS -eq 0 ]; then
-  echo "✅ SUCCESS: Zero concurrent test execution conflicts in 20 runs"
-  exit 0
-else
-  echo "❌ FAILED: $CONFLICTS conflicts detected in 20 runs (${CONFLICT_RATE}% conflict rate)"
-  exit 1
-fi

package/.claude/skills/test-execution/test-coordinator-pattern.sh

@@ -1,109 +0,0 @@
-#!/usr/bin/env bash
-# test-coordinator-pattern.sh
-# Coordinator-pattern test execution: Run tests ONCE, cache results for workers
-
-set -euo pipefail
-
-SWARM_ID="${1:-swarm-default}"
-REDIS_CHANNEL="swarm:${SWARM_ID}:tests"
-RESULTS_FILE="test-results.json"
-
-echo "[COORDINATOR] Starting test execution for swarm: ${SWARM_ID}"
-
-# 1. Terminate existing test runs to prevent conflicts
-echo "[COORDINATOR] Terminating existing test processes..."
-pkill -f vitest 2>/dev/null || true
-pkill -f "npm test" 2>/dev/null || true
-pkill -f "node.*test" 2>/dev/null || true
-sleep 1
-
-# Verify no test processes remain
-REMAINING=$(pgrep -f "vitest|npm test" | wc -l || echo "0")
-if [ "${REMAINING}" -gt 0 ]; then
-  echo "[COORDINATOR] WARNING: ${REMAINING} test processes still running. Force killing..."
-  pkill -9 -f vitest 2>/dev/null || true
-  pkill -9 -f "npm test" 2>/dev/null || true
-  sleep 1
-fi
-
-# 2. Execute tests once and cache results
-echo "[COORDINATOR] Running tests (single execution)..."
-START_TIME=$(date +%s)
-
-# Run tests with JSON reporter for parsing
-if npm test -- --run --reporter=json > "${RESULTS_FILE}" 2>&1; then
-  TEST_EXIT_CODE=0
-else
-  TEST_EXIT_CODE=$?
-fi
-
-END_TIME=$(date +%s)
-DURATION=$((END_TIME - START_TIME))
-
-echo "[COORDINATOR] Test execution complete in ${DURATION}s (exit code: ${TEST_EXIT_CODE})"
-
-# 3. Parse test results
-if [ -f "${RESULTS_FILE}" ]; then
-  TESTS_PASSED=$(jq -r '.numPassedTests // 0' "${RESULTS_FILE}" 2>/dev/null || echo "0")
-  TESTS_FAILED=$(jq -r '.numFailedTests // 0' "${RESULTS_FILE}" 2>/dev/null || echo "0")
-  TESTS_TOTAL=$(jq -r '.numTotalTests // 0' "${RESULTS_FILE}" 2>/dev/null || echo "0")
-  COVERAGE_LINES=$(jq -r '.coverageMap.total.lines.pct // 0' "${RESULTS_FILE}" 2>/dev/null || echo "0")
-  COVERAGE_BRANCHES=$(jq -r '.coverageMap.total.branches.pct // 0' "${RESULTS_FILE}" 2>/dev/null || echo "0")
-
-  echo "[COORDINATOR] Results: ${TESTS_PASSED}/${TESTS_TOTAL} passed, ${TESTS_FAILED} failed"
-  echo "[COORDINATOR] Coverage: ${COVERAGE_LINES}% lines, ${COVERAGE_BRANCHES}% branches"
-else
-  echo "[COORDINATOR] WARNING: ${RESULTS_FILE} not found. Using default values."
-  TESTS_PASSED=0
-  TESTS_FAILED=0
-  TESTS_TOTAL=0
-  COVERAGE_LINES=0
-  COVERAGE_BRANCHES=0
-fi
-
-# 4. Signal completion via Redis pub/sub
-COMPLETION_MESSAGE=$(cat <<JSON
-{
-  "event": "tests_complete",
-  "swarmId": "${SWARM_ID}",
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "duration": ${DURATION},
-  "exitCode": ${TEST_EXIT_CODE},
-  "tests": {
-    "passed": ${TESTS_PASSED},
-    "failed": ${TESTS_FAILED},
-    "total": ${TESTS_TOTAL}
-  },
-  "coverage": {
-    "lines": ${COVERAGE_LINES},
-    "branches": ${COVERAGE_BRANCHES}
-  },
-  "resultsFile": "${RESULTS_FILE}"
-}
-JSON
-)
-
-echo "[COORDINATOR] Publishing completion signal to Redis..."
-redis-cli PUBLISH "${REDIS_CHANNEL}:complete" "${COMPLETION_MESSAGE}" >/dev/null 2>&1 || {
-  echo "[COORDINATOR] WARNING: Redis publish failed. Workers must rely on file cache."
-}
-
-# 5. Cache results in Redis (1-hour TTL)
-if [ -f "${RESULTS_FILE}" ]; then
-  echo "[COORDINATOR] Caching results in Redis (TTL: 3600s)..."
-  redis-cli SETEX "${REDIS_CHANNEL}:results" 3600 "$(cat "${RESULTS_FILE}")" >/dev/null 2>&1 || {
-    echo "[COORDINATOR] WARNING: Redis cache failed. Workers will use file cache."
-  }
-
-  # Store metadata separately for quick access
-  redis-cli SETEX "${REDIS_CHANNEL}:metadata" 3600 "${COMPLETION_MESSAGE}" >/dev/null 2>&1 || true
-fi
-
-# 6. Create worker-ready signal file (fallback for no Redis)
-touch ".test-results-ready"
-
-echo "[COORDINATOR] Test execution complete. Results cached for workers."
-echo "[COORDINATOR] Workers can now safely read results without running tests."
-
-# Return original test exit code
-exit ${TEST_EXIT_CODE}

package/.claude/skills/test-execution-coordinator-pattern.md

@@ -1,228 +0,0 @@
----
-skill: test-execution-coordinator-pattern
-name: Test Execution Coordination
-description: Centralized test execution pattern for distributed agent workflows
-version: 1.0.0
-category: coordination
-allowed-tools:
-  - Bash
-  - Read
-  - Grep
-complexity: moderate
-dependencies:
-  - redis-cli
-  - npm
-  - bash
----
-
-# Test Execution Coordinator Pattern
-
-## Overview
-
-The Test Execution Coordinator Pattern provides a robust, centralized mechanism for managing test execution in distributed agent workflows. By implementing a single-source test run approach, this pattern ensures:
-
-- Consistent test execution
-- Prevention of concurrent test runs
-- Efficient result caching and distribution
-- Minimal resource consumption
-
-## Coordinator Pattern
-
-### Core Principles
-
-1. **Single Source of Truth**: Coordinator runs tests ONCE
-2. **Cache-Based Distribution**: Workers read cached test results
-3. **Minimal Overhead**: Prevent redundant test executions
-4. **Atomic Test Management**: Terminate previous runs before new execution
-
-### Execution Architecture
-
-```
-Coordinator (Test Runner)
-│
-├─ Terminate Existing Tests
-├─ Execute Test Suite
-├─ Cache Test Results
-│
-└─> Workers (Result Consumers)
-    ├─ Read Cached Results
-    ├─ Proceed/Halt Based on Results
-```
-
-## Execution Steps
-
-### 1. Terminate Existing Test Processes
-
-```bash
-# Forcefully terminate any running test processes
-pkill -f vitest
-pkill -f "npm test"
-pkill -f jest
-```
-
-### 2. Run Tests (Coordinator-Only)
-
-```bash
-# Execute test suite with comprehensive reporting
-npm test -- \
-  --run \
-  --reporter=json \
-  --coverage \
-  > test-results.json 2>&1
-```
-
-### 3. Workers Read Test Results
-
-```bash
-# Worker-side test result parsing
-test_status=$(jq '.success' test-results.json)
-test_coverage=$(jq '.coverage.lines.pct' test-results.json)
-
-if [[ "$test_status" == "true" && "$test_coverage" -ge 80 ]]; then
-  # Proceed with next workflow stage
-  echo "Tests passed. Continuing workflow."
-else
-  # Signal test failure
-  redis-cli lpush "swarm:test:failures" "$test_status"
-  exit 1
-fi
-```
-
-### 4. Post-Test Cleanup
-
-```bash
-# Clean up test artifacts and reset environment
-rm test-results.json
-pkill -f vitest
-pkill -f "npm test"
-```
-
-## Redis Coordination
-
-### Test Completion Signaling
-
-```bash
-# Coordinator signals test completion
-redis-cli publish "swarm:test:status" '{"status":"complete","timestamp":1697644800}'
-
-# Workers subscribe to test status
-redis-cli subscribe "swarm:test:status"
-```
-
-## Anti-Patterns to Avoid
-
-1. **Multiple Concurrent Test Runs**
-   - Never allow workers to independently run tests
-   - Do NOT use parallel test execution
-
-2. **Stateless Test Execution**
-   - Always cache test results
-   - Ensure deterministic test environment
-
-3. **Unconstrained Test Processes**
-   - Always terminate previous test runs
-   - Use strict process management
-
-## Script Templates
-
-### test-coordinator-pattern.sh
-
-```bash
-#!/bin/bash
-# Centralized Test Coordination Script
-
-COORDINATOR_ID=$(uuidgen)
-TEST_RESULTS_FILE="test-results.json"
-
-function terminate_tests() {
-    pkill -f vitest
-    pkill -f "npm test"
-}
-
-function run_tests() {
-    npm test -- \
-        --run \
-        --reporter=json \
-        --coverage > "$TEST_RESULTS_FILE" 2>&1
-}
-
-function signal_completion() {
-    redis-cli publish "swarm:test:status" "{
-        \"coordinator_id\": \"$COORDINATOR_ID\",
-        \"status\": \"complete\",
-        \"timestamp\": $(date +%s)
-    }"
-}
-
-main() {
-    terminate_tests
-    run_tests
-    signal_completion
-}
-
-main
-```
-
-### test-cache-reader.sh
-
-```bash
-#!/bin/bash
-# Worker-Side Test Result Consumer
-
-function parse_test_results() {
-    local test_status=$(jq -r '.success' test-results.json)
-    local test_coverage=$(jq -r '.coverage.lines.pct' test-results.json)
-
-    if [[ "$test_status" == "true" && "$test_coverage" -ge 80 ]]; then
-        echo "Proceeding with workflow"
-        exit 0
-    else
-        echo "Test requirements not met"
-        exit 1
-    fi
-}
-
-parse_test_results
-```
-
-## Confidence Scoring
-
-```bash
-# Confidence calculation pseudo-code
-confidence_score=$(
-  awk 'BEGIN {
-    test_isolation = 0.4   # Prevent concurrent tests
-    result_caching = 0.3   # Efficient result distribution
-    cleanup_rigor = 0.2    # Process management
-    signaling_mechanism = 0.1  # Redis coordination
-
-    print test_isolation + result_caching + cleanup_rigor + signaling_mechanism
-  }'
-)
-```
-
-## Performance Metrics
-
-- **Execution Time**: <500ms
-- **Memory Footprint**: <50MB
-- **Test Reliability**: >95%
-
-## Logging & Monitoring
-
-```bash
-# Log test coordination events
-logger -t test-coordinator "Test execution started: $COORDINATOR_ID"
-```
-
-## Security Considerations
-
-- Restrict test execution to authorized coordinators
-- Implement read-only access for workers
-- Use ephemeral test result files
-
-## Integration Hooks
-
-```bash
-# Post-test validation hook
-node config/hooks/post-test-validation.js "$TEST_RESULTS_FILE"
-```

package/.claude/skills/transparency-middleware/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "transparency-middleware"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sqlx = { version = "0.7", features = ["runtime-tokio", "sqlite", "chrono"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-anyhow = "1.0"
-chrono = { version = "0.4", features = ["serde"] }
-tokio = { version = "1.0", features = ["full"] }
-tracing = "0.1"
-tracing-subscriber = "0.3"
-
-[dev-dependencies]
-tempfile = "3.2"
-mockall = "0.11"

package/.claude/skills/transparency-middleware/SECURITY.md

@@ -1,41 +0,0 @@
-# Interaction Tester - Security Considerations
-
-## Input Validation Strategy
-
-### Core Principles
-- Strict input validation for all parameters
-- Regex-based input matching
-- Parameterized database queries
-- Extensive logging and audit trails
-
-### Validation Mechanisms
-1. **Input Format Validation**
-   - Whitelist approach using strict regex patterns
-   - Allowed characters: `a-zA-Z0-9_-`
-   - Length restrictions enforced
-   - Immediate rejection of non-compliant inputs
-
-2. **Query Preparation**
-   - Use SQLite parameterized queries
-   - Separate input from SQL syntax
-   - Prevent SQL injection through parameter binding
-
-3. **Logging and Monitoring**
-   - Comprehensive audit trail via syslog
-   - Detailed error logging
-   - Redis-based diagnostic signaling
-
-### Threat Mitigation
-- Prevent command injection
-- Block potential database manipulation
-- Ensure predictable input processing
-
-## Security Rating
-- Input Validation: High (99%)
-- Query Safety: High (98%)
-- Logging Comprehensiveness: High (95%)
-
-## Continuous Improvement
-- Regular security reviews
-- Periodic penetration testing
-- Adaptive validation rules

package/.claude/skills/transparency-middleware/SKILL.md

@@ -1,91 +0,0 @@
-## Transparency Middleware
-
-### Overview
-The Transparency Middleware is a critical component of our agent orchestration system, designed to capture, log, and analyze agent interactions with comprehensive memory tracking and security features.
-
-## Testing
-
-### Unit Tests
-Run the comprehensive unit test suite:
-```bash
-npm test src/middleware/transparency-middleware.test.ts
-```
-
-**Coverage:** 95%+ on all core methods
-
-### Integration Tests
-Test middleware with CFN Loop orchestrator:
-```bash
-./.claude/skills/transparency-middleware/test-integration.sh
-```
-
-### End-to-End Tests
-Full lifecycle test with sample agent:
-```bash
-./.claude/skills/transparency-middleware/test-e2e.sh
-```
-
-## Usage Examples
-
-### Basic Usage
-```typescript
-import TransparencyMiddleware from './src/middleware/transparency-middleware.js';
-
-const config = TransparencyMiddleware.loadConfig('./.claude/skills/transparency-middleware/config.json');
-const middleware = new TransparencyMiddleware(config);
-
-await middleware.initialize();
-
-// Capture agent execution
-await middleware.captureAgentExecution('backend-dev', agentOutput, 'task-123');
-
-await middleware.cleanup();
-```
-
-### Wrapper Script Usage
-```bash
-# Wrap any agent execution with automatic memory capture
-./.claude/skills/transparency-middleware/wrap-agent.sh \
-  "backend-dev" \
-  "agent-1" \
-  "task-auth-impl" \
-  "implement authentication"
-```
-
-### Query Stored Memories
-```bash
-# Query all memories for a task
-./.claude/skills/transparency-middleware/query-memory.sh "task-auth-impl" "*" 100
-
-# Query specific agent's memories
-./.claude/skills/transparency-middleware/query-memory.sh "task-auth-impl" "backend-dev" 50
-```
-
-## Configuration Guide
-
-See `config.json` for all options. Key settings:
-
-- `capture.edit_operations` - Capture Edit/Write/MultiEdit tools
-- `capture.bash_commands` - Capture Bash commands
-- `capture.task_spawning` - Capture Task spawning
-- `security.anonymize_sensitive_data` - Redact secrets
-- `security.max_payload_size_bytes` - Limit event size
-
-## Troubleshooting
-
-**Issue:** Memory not being captured
-- Check `config.capture.*` filters
-- Verify SQLite database permissions
-- Enable debug logging
-
-**Issue:** Redis events not emitted
-- Check Redis connection (`redis-cli ping`)
-- Verify `config.events.emit_*` flags
-- Check channel name in config
-
-## Performance
-
-- **Memory overhead:** <50MB for 1000 events
-- **Storage:** ~1KB per high-value event
-- **Latency:** <5ms per event capture
-- **Throughput:** 1000+ events/sec