claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/skills/cfn-ace-system/SKILL.md

@@ -0,0 +1,364 @@
+# ACE System Skill
+
+## Version
+**Version:** 1.0.0
+**Status:** OPERATIONAL
+
+## Overview
+The ACE (Adaptive Context Extension) System skill provides agents with access to advanced context management capabilities including reflection, curation, generation, and injection. This skill wraps the core ACE implementation from `src/ace/` and exposes it through simple shell command interfaces.
+
+## Features
+- Context Reflection (Cognitive complexity analysis)
+- Context Curation (Merge and prioritize contexts)
+- Context Generation (Adaptive context creation)
+- Context Injection (Dynamic context augmentation)
+- Context Statistics (Query and analyze stored contexts)
+
+## Core Components
+
+### 1. ACE Reflector
+Performs cognitive reflection on context data, calculating complexity and generating insights.
+
+**Methods:**
+- `reflect()` - Analyze context and generate reflection
+- `retrieveReflection()` - Query stored reflections
+
+### 2. ACE Curator
+Manages context merging and prioritization for multi-agent scenarios.
+
+**Methods:**
+- `mergeContexts()` - Merge multiple contexts with conflict resolution
+- `prioritizeReflections()` - Rank reflections by relevance
+
+### 3. ACE Generator
+Generates adaptive context based on task requirements and historical data.
+
+**Methods:**
+- `generateContext()` - Create new context from specifications
+
+### 4. Context Injector
+Dynamically injects context into execution environments.
+
+**Methods:**
+- `injectContext()` - Augment execution with additional context
+- `executeWithContext()` - Run operations with injected context
+
+## Agent Integration Examples
+
+### 1. Context Reflection
+
+#### Reflect on Current Context
+```bash
+# Agent analyzes current task context
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"task": "feature-implementation", "complexity": "high"}' \
+  --output /tmp/reflection.json
+```
+
+**Returns:** Cognitive reflection with insights and complexity metrics
+
+### 2. Context Statistics
+
+#### Query Context Database
+```bash
+# Retrieve reflection statistics
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query "reflections" \
+  --filter '{"complexity": {"$gt": 0.7}}' \
+  --limit 10
+```
+
+**Returns:** JSON array of matching reflections
+
+### 3. Context Query
+
+#### Search Similar Contexts
+```bash
+# Find similar past contexts
+./.claude/skills/ace-system/invoke-context-query.sh \
+  --keywords "authentication,security" \
+  --similarity-threshold 0.8 \
+  --max-results 5
+```
+
+**Returns:** Ranked list of similar contexts
+
+### 4. Context Injection
+
+#### Inject Context into Execution
+```bash
+# Augment current execution with historical context
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file /tmp/reflection.json \
+  --target-task "implement-auth" \
+  --merge-strategy "deep"
+```
+
+**Returns:** Execution context augmented with injected data
+
+### 5. Context Curation
+
+#### Merge Multiple Contexts
+```bash
+# Curator merges contexts from multiple agents
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "agent1-context.json,agent2-context.json,agent3-context.json" \
+  --strategy "priority-weighted" \
+  --output curated-context.json
+```
+
+**Returns:** Single merged context with conflict resolution
+
+## Integration with CFN Loop
+
+### Loop 3 Integration (Primary Swarm)
+Agents in Loop 3 use ACE for context generation and reflection:
+
+```bash
+# Agent completes implementation and reflects
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"phase": "implementation", "changes": [...]}' \
+  --output /tmp/loop3-reflection.json
+
+# Report confidence based on reflection complexity
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Loop 2 Integration (Consensus Validation)
+Validators use ACE curator to merge perspectives:
+
+```bash
+# Collect reflections from Loop 3 agents
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "loop3-agent1.json,loop3-agent2.json,loop3-agent3.json" \
+  --strategy "consensus-weighted" \
+  --output /tmp/loop2-merged.json
+
+# Validate merged context
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query "validation" \
+  --input /tmp/loop2-merged.json
+```
+
+### Product Owner Integration
+Product Owner uses ACE for final context injection:
+
+```bash
+# Inject business context into technical implementation
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file /tmp/loop2-merged.json \
+  --business-rules /config/product-requirements.json \
+  --output /tmp/final-context.json
+```
+
+## Configuration
+
+### Memory Path
+ACE uses SQLite for persistence. Default path: `./.artifacts/database/swarm-memory.db`
+
+Override with environment variable:
+```bash
+export ACE_MEMORY_PATH="/custom/path/swarm-memory.db"
+```
+
+### Complexity Thresholds
+
+| Threshold | Value | Description |
+|-----------|-------|-------------|
+| Low | < 0.3 | Simple, straightforward contexts |
+| Medium | 0.3-0.7 | Moderate complexity |
+| High | > 0.7 | High complexity requiring deep reflection |
+
+### Merge Strategies
+
+| Strategy | Use Case |
+|----------|----------|
+| `simple` | Basic context merge, last-write-wins |
+| `deep` | Recursive merge with nested conflict resolution |
+| `priority-weighted` | Merge based on agent priority levels |
+| `consensus-weighted` | Weight by consensus confidence scores |
+
+## Command Reference
+
+### invoke-context-reflect.sh
+**Purpose:** Generate cognitive reflection on context
+
+**Arguments:**
+- `--context` - JSON context object
+- `--complexity` - Override complexity calculation (optional)
+- `--output` - Output file path (optional)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-reflect.sh \
+  --context '{"task": "deploy"}' \
+  --output reflection.json
+```
+
+### invoke-context-stats.sh
+**Purpose:** Query reflection database
+
+**Arguments:**
+- `--query` - Query type (reflections, insights, summary)
+- `--filter` - MongoDB-style filter JSON (optional)
+- `--limit` - Maximum results (default: 100)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-stats.sh \
+  --query reflections \
+  --filter '{"timestamp": {"$gt": 1697000000}}' \
+  --limit 20
+```
+
+### invoke-context-query.sh
+**Purpose:** Search for similar contexts
+
+**Arguments:**
+- `--keywords` - Comma-separated keywords
+- `--similarity-threshold` - Minimum similarity (0.0-1.0, default: 0.7)
+- `--max-results` - Maximum results (default: 10)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-query.sh \
+  --keywords "authentication,JWT,OAuth" \
+  --similarity-threshold 0.8 \
+  --max-results 5
+```
+
+### invoke-context-inject.sh
+**Purpose:** Inject context into execution environment
+
+**Arguments:**
+- `--context-file` - Source context JSON file
+- `--target-task` - Task ID to inject into
+- `--merge-strategy` - Merge strategy (simple, deep, priority-weighted, consensus-weighted)
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-inject.sh \
+  --context-file historical-context.json \
+  --target-task "sprint-3-auth" \
+  --merge-strategy deep
+```
+
+### invoke-context-curate.sh
+**Purpose:** Merge and curate multiple contexts
+
+**Arguments:**
+- `--contexts` - Comma-separated list of context files
+- `--strategy` - Curation strategy
+- `--output` - Output file path
+
+**Example:**
+```bash
+./.claude/skills/ace-system/invoke-context-curate.sh \
+  --contexts "ctx1.json,ctx2.json,ctx3.json" \
+  --strategy consensus-weighted \
+  --output merged.json
+```
+
+## Use Cases
+
+### 1. Multi-Agent Consensus Building
+Use ACE curator to merge insights from multiple agents and reach consensus on complex decisions.
+
+### 2. Historical Context Reuse
+Query similar past contexts to inform current task execution and avoid repeating mistakes.
+
+### 3. Complexity-Driven Validation
+Use reflection complexity scores to determine appropriate validation depth and gate thresholds.
+
+### 4. Adaptive Resource Allocation
+Generate context dynamically based on task requirements to optimize resource usage.
+
+### 5. Cross-Sprint Learning
+Inject curated context from previous sprints into new iterations for continuous improvement.
+
+## Dependencies
+- Node.js runtime (for TypeScript ACE modules)
+- SQLite3 (for persistent context storage)
+- Redis (for cross-agent context sharing)
+- jq (for JSON processing in shell scripts)
+
+## Error Handling
+
+All ACE skill wrappers follow a consistent error handling pattern:
+
+```bash
+if ! result=$(invoke-command.sh --args); then
+  echo "ERROR: ACE operation failed"
+  exit 1
+fi
+
+# Validate JSON output
+if ! echo "$result" | jq . > /dev/null 2>&1; then
+  echo "ERROR: Invalid JSON response"
+  exit 1
+fi
+```
+
+## Performance Considerations
+
+### Reflection Complexity
+High-complexity reflections (> 0.8) may require additional processing time. Consider:
+- Batching reflection operations
+- Using async reflection for non-blocking execution
+- Caching frequently accessed reflections
+
+### Context Curation
+Merging large numbers of contexts (> 10) can be resource-intensive:
+- Use progressive merging for large agent swarms
+- Apply early filtering to reduce context set size
+- Leverage Redis for intermediate result caching
+
+### Database Queries
+Optimize context queries by:
+- Creating appropriate SQLite indexes
+- Limiting query result sets
+- Using filters to reduce full table scans
+
+## Testing
+
+Test suite location: `.claude/skills/ace-system/test-ace-skill.sh`
+
+**Run tests:**
+```bash
+./.claude/skills/ace-system/test-ace-skill.sh
+```
+
+**Expected output:**
+```
+[PASS] Context reflection generates valid output
+[PASS] Context stats returns filtered results
+[PASS] Context query finds similar contexts
+[PASS] Context injection merges successfully
+[PASS] Context curation handles conflicts
+```
+
+## Version History
+
+### v1.0.0 (2025-10-19)
+- Initial release
+- Wrapper for all 5 ACE slash commands
+- Integration with CFN Loop coordination
+- Complete test coverage
+
+## Maintenance
+
+**Last Updated:** 2025-10-19
+**Next Review:** 2025-11-19
+**Owner:** System Architecture Team
+
+## Related Skills
+- Redis Coordination (`redis-coordination`)
+- SQLite Memory (`sqlite-memory`)
+- CFN Loop Validation (`cfn-loop-validation`)
+
+## Support
+
+For issues or questions about the ACE System skill:
+1. Check test suite for usage examples
+2. Review ACE implementation docs in `src/ace/`
+3. Consult Redis Coordination skill for integration patterns

package/claude-assets/skills/cfn-ace-system/add-bullet.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# Add new bullet to adaptive_context table
+# Usage: ./add-bullet.sh --bullet-id STRAT-007 --category strategy --content "..." --confidence 0.85
+
+set -e
+
+# Default values
+DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
+BULLET_ID=""
+CATEGORY=""
+CONTENT=""
+CONFIDENCE=0.5
+PRIORITY=5
+TAGS="[]"
+SOURCE_CONTEXT=""
+SOURCE_TASK_ID=""
+ACL_LEVEL=4
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --bullet-id)
+      BULLET_ID="$2"
+      shift 2
+      ;;
+    --category)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    --content)
+      CONTENT="$2"
+      shift 2
+      ;;
+    --confidence)
+      CONFIDENCE="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --tags)
+      TAGS="$2"
+      shift 2
+      ;;
+    --source-context)
+      SOURCE_CONTEXT="$2"
+      shift 2
+      ;;
+    --source-task-id)
+      SOURCE_TASK_ID="$2"
+      shift 2
+      ;;
+    --acl-level)
+      ACL_LEVEL="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required parameters
+if [ -z "$BULLET_ID" ] || [ -z "$CATEGORY" ] || [ -z "$CONTENT" ]; then
+  echo "Error: Missing required parameters"
+  echo "Usage: $0 --bullet-id <id> --category <cat> --content <text>"
+  exit 1
+fi
+
+# Validate category
+case $CATEGORY in
+  strategy|pattern|edge_case|domain_insight|anti_pattern|optimization)
+    ;;
+  *)
+    echo "Error: Invalid category. Must be: strategy, pattern, edge_case, domain_insight, anti_pattern, or optimization"
+    exit 1
+    ;;
+esac
+
+# Generate unique ID
+UNIQUE_ID="$(echo -n "$BULLET_ID" | md5sum | cut -d' ' -f1)"
+
+# Insert bullet into database
+sqlite3 "$DB_PATH" <<EOF
+-- Ensure table exists
+CREATE TABLE IF NOT EXISTS adaptive_context (
+    id TEXT PRIMARY KEY,
+    bullet_id TEXT NOT NULL UNIQUE,
+    category TEXT NOT NULL CHECK (category IN ('strategy', 'pattern', 'edge_case', 'domain_insight', 'anti_pattern', 'optimization')),
+    content TEXT NOT NULL,
+    helpful_count INTEGER DEFAULT 0,
+    harmful_count INTEGER DEFAULT 0,
+    confidence_score REAL DEFAULT 0.5 CHECK (confidence_score BETWEEN 0.0 AND 1.0),
+    source_context TEXT NOT NULL,
+    source_task_id TEXT,
+    source_agent_id TEXT,
+    tags TEXT,
+    embedding_vector TEXT,
+    parent_bullet_id TEXT,
+    version INTEGER DEFAULT 1,
+    acl_level INTEGER NOT NULL DEFAULT 4 CHECK (acl_level BETWEEN 1 AND 6),
+    swarm_id TEXT,
+    project_id TEXT,
+    is_active BOOLEAN DEFAULT 1,
+    is_validated BOOLEAN DEFAULT 0,
+    validation_metadata TEXT,
+    priority INTEGER DEFAULT 5 CHECK (priority BETWEEN 1 AND 10),
+    last_used_at DATETIME,
+    usage_count INTEGER DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    archived_at DATETIME
+);
+
+-- Insert bullet
+INSERT INTO adaptive_context (
+  id, bullet_id, category, content, confidence_score, priority, tags,
+  source_context, source_task_id, acl_level, is_active
+) VALUES (
+  '${UNIQUE_ID}',
+  '${BULLET_ID}',
+  '${CATEGORY}',
+  '${CONTENT}',
+  ${CONFIDENCE},
+  ${PRIORITY},
+  '${TAGS}',
+  '${SOURCE_CONTEXT:-Unknown source}',
+  $([ -n "$SOURCE_TASK_ID" ] && echo "'$SOURCE_TASK_ID'" || echo "NULL"),
+  ${ACL_LEVEL},
+  1
+);
+EOF
+
+# Verify insertion
+COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM adaptive_context WHERE bullet_id = '${BULLET_ID}';")
+
+if [ "$COUNT" -eq 1 ]; then
+  echo "{\"status\":\"success\",\"bullet_id\":\"${BULLET_ID}\",\"category\":\"${CATEGORY}\",\"confidence\":${CONFIDENCE}}"
+  exit 0
+else
+  echo "{\"status\":\"error\",\"message\":\"Bullet insertion failed\"}"
+  exit 1
+fi

package/claude-assets/skills/cfn-ace-system/analyze-anti-pattern-effectiveness.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# Extended ACE System Anti-Pattern Effectiveness Analysis
+
+set -euo pipefail
+
+analyze_ab_test_results() {
+    local task_id="${1:?Task ID required}"
+
+    # Retrieve A/B test results from Redis
+    local ab_results=$(redis-cli KEYS "ace:ab_test:${task_id}:*")
+
+    # SQLite query to calculate metrics
+    sqlite3 ace_system.db <<EOF
+    WITH ab_test_data AS (
+        SELECT
+            json_extract(data, '$.agent_id') as agent_id,
+            json_extract(data, '$.ace_enabled') as ace_enabled,
+            json_extract(data, '$.first_confidence') as first_confidence,
+            json_extract(data, '$.final_confidence') as final_confidence,
+            json_extract(data, '$.iterations') as iterations
+        FROM ace_effectiveness
+        WHERE task_id = '$task_id'
+    )
+    SELECT
+        CASE WHEN ace_enabled THEN 'ACE' ELSE 'Control' END AS group_name,
+        AVG(first_confidence) AS avg_first_confidence,
+        AVG(final_confidence) AS avg_final_confidence,
+        AVG(iterations) AS avg_iterations,
+        COUNT(*) AS sample_size
+    FROM ab_test_data
+    GROUP BY group_name;
+EOF
+}
+
+calculate_roi() {
+    local task_id="${1:?Task ID required}"
+
+    sqlite3 ace_system.db <<EOF
+    WITH timing_data AS (
+        SELECT
+            json_extract(data, '$.context_injection_time') as injection_time,
+            json_extract(data, '$.iteration_time') as iteration_time
+        FROM ace_performance
+        WHERE task_id = '$task_id'
+    )
+    SELECT
+        AVG(injection_time) as avg_injection_time,
+        AVG(iteration_time) as avg_iteration_time,
+        AVG(iteration_time - injection_time) as time_saved
+    FROM timing_data;
+EOF
+}
+
+# Main execution
+analyze_ab_test_results "$@"
+calculate_roi "$@"

package/claude-assets/skills/cfn-ace-system/classify-task.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# ACE System - Task Classifier Wrapper
+# Delegates to cfn-task-classifier skill for domain classification
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLASSIFIER_PATH="${SCRIPT_DIR}/../cfn-task-classifier/classify-task.sh"
+
+# Validate classifier exists
+if [[ ! -f "$CLASSIFIER_PATH" ]]; then
+  echo "ERROR: Task classifier not found at: $CLASSIFIER_PATH" >&2
+  exit 1
+fi
+
+# Delegate to task classifier with all arguments
+exec "$CLASSIFIER_PATH" "$@"

package/claude-assets/skills/cfn-ace-system/export-ace-metrics.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# ACE System Metrics Dashboard Export
+
+set -euo pipefail
+
+EXPORT_DIR="${1:?Export directory required}"
+TIMEFRAME="${2:-7d}"
+
+# Function to generate JSON metrics
+generate_metrics_json() {
+    local task_id="$1"
+
+    # A/B Test Results
+    local ab_results=$(sqlite3 ace_system.db \
+        "SELECT json_group_array(
+            json_object(
+                'group', CASE WHEN ace_enabled THEN 'ACE' ELSE 'Control' END,
+                'avg_first_confidence', AVG(first_confidence),
+                'avg_final_confidence', AVG(final_confidence),
+                'avg_iterations', AVG(iterations)
+            )
+        ) FROM ace_effectiveness WHERE timestamp >= datetime('now', '-$TIMEFRAME')")
+
+    # Performance Metrics
+    local perf_metrics=$(sqlite3 ace_system.db \
+        "SELECT json_group_array(
+            json_object(
+                'injection_time', AVG(context_injection_time),
+                'iteration_time', AVG(iteration_time),
+                'time_saved', AVG(iteration_time - context_injection_time)
+            )
+        ) FROM ace_performance WHERE timestamp >= datetime('now', '-$TIMEFRAME')")
+
+    # Combine metrics
+    jq -n \
+        --argjson ab_results "$ab_results" \
+        --argjson perf_metrics "$perf_metrics" \
+        '{
+            "ab_test_results": $ab_results,
+            "performance_metrics": $perf_metrics,
+            "timestamp": now
+        }' > "${EXPORT_DIR}/ace_metrics_$(date +%Y%m%d_%H%M%S).json"
+}
+
+# Export metrics for each tracked task
+for task_id in $(sqlite3 ace_system.db "SELECT DISTINCT task_id FROM ace_effectiveness"); do
+    generate_metrics_json "$task_id"
+done