claude-flow-novice 2.8.1 → 2.9.0

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

@@ -1,364 +0,0 @@
-# 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/skills/ace-system/add-bullet.sh

@@ -1,145 +0,0 @@
-#!/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/skills/ace-system/invoke-context-curate.sh

@@ -1,192 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE Context Curation Wrapper
-# Merges and curates multiple contexts from different sources
-#
-# Usage:
-#   ./invoke-context-curate.sh --contexts <file1,file2,...> [OPTIONS]
-#
-# Arguments:
-#   --contexts         Comma-separated list of context files (required)
-#   --strategy         Curation strategy: simple, priority-weighted, consensus-weighted
-#   --output           Output file path (optional, default: stdout)
-#   --memory-path      SQLite memory path (optional)
-##############################################################################
-
-set -euo pipefail
-
-# Default values
-CONTEXTS=""
-STRATEGY="simple"
-OUTPUT=""
-MEMORY_PATH="${ACE_MEMORY_PATH:-./.artifacts/database/swarm-memory.db}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --contexts)
-      CONTEXTS="$2"
-      shift 2
-      ;;
-    --strategy)
-      STRATEGY="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT="$2"
-      shift 2
-      ;;
-    --memory-path)
-      MEMORY_PATH="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$CONTEXTS" ]; then
-  echo "Error: --contexts is required"
-  echo "Usage: $0 --contexts 'file1.json,file2.json' [OPTIONS]"
-  exit 1
-fi
-
-# Validate all context files exist
-IFS=',' read -ra CONTEXT_FILES <<< "$CONTEXTS"
-for file in "${CONTEXT_FILES[@]}"; do
-  if [ ! -f "$file" ]; then
-    echo "Error: Context file not found: $file"
-    exit 1
-  fi
-
-  # Validate JSON
-  if ! jq . "$file" > /dev/null 2>&1; then
-    echo "Error: Invalid JSON in file: $file"
-    exit 1
-  fi
-done
-
-# Get project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Create Node.js runner script
-RUNNER_SCRIPT=$(mktemp --suffix=.mjs)
-trap "rm -f $RUNNER_SCRIPT" EXIT
-
-cat > "$RUNNER_SCRIPT" << EOF
-import ACECurator from '${PROJECT_ROOT}/dist/ace/ace-curator.js';
-import { readFileSync } from 'fs';
-
-const contextFiles = process.argv[2].split(',');
-const strategy = process.argv[3];
-const memoryPath = process.argv[4];
-
-const curator = new ACECurator({}, memoryPath);
-
-// Load all contexts
-const contexts = contextFiles.map(file => JSON.parse(readFileSync(file.trim(), 'utf-8')));
-
-// Strategy implementations
-function simpleMerge(contexts) {
-  return contexts.reduce((merged, ctx) => ({ ...merged, ...ctx }), {});
-}
-
-function priorityWeightedMerge(contexts) {
-  // Sort by priority (if available) and merge
-  const sorted = contexts.sort((a, b) => {
-    const priorityA = a.priority ?? 0;
-    const priorityB = b.priority ?? 0;
-    return priorityB - priorityA;
-  });
-
-  return sorted.reduce((merged, ctx) => {
-    return deepMerge(merged, ctx);
-  }, {});
-}
-
-function consensusWeightedMerge(contexts) {
-  // Weight contexts by confidence scores
-  const weighted = contexts.map(ctx => {
-    const confidence = ctx.confidence ?? 1.0;
-
-    // Apply confidence weighting to all numeric values
-    return Object.entries(ctx).reduce((acc, [key, value]) => {
-      if (typeof value === 'number') {
-        acc[key] = value * confidence;
-      } else {
-        acc[key] = value;
-      }
-      return acc;
-    }, {});
-  });
-
-  // Merge weighted contexts
-  return weighted.reduce((merged, ctx) => deepMerge(merged, ctx), {});
-}
-
-function deepMerge(target, source) {
-  const result = { ...target };
-
-  for (const key in source) {
-    if (source.hasOwnProperty(key)) {
-      if (
-        typeof source[key] === 'object' &&
-        source[key] !== null &&
-        !Array.isArray(source[key])
-      ) {
-        result[key] = deepMerge(result[key] || {}, source[key]);
-      } else if (Array.isArray(source[key])) {
-        // Merge arrays by concatenating and deduplicating
-        result[key] = [...new Set([...(result[key] || []), ...source[key]])];
-      } else {
-        result[key] = source[key];
-      }
-    }
-  }
-
-  return result;
-}
-
-// Execute curation strategy
-let curatedContext;
-
-switch (strategy) {
-  case 'simple':
-    curatedContext = simpleMerge(contexts);
-    break;
-  case 'priority-weighted':
-    curatedContext = priorityWeightedMerge(contexts);
-    break;
-  case 'consensus-weighted':
-    curatedContext = consensusWeightedMerge(contexts);
-    break;
-  default:
-    throw new Error(`Unknown curation strategy: ${strategy}`);
-}
-
-// Add curation metadata
-const result = {
-  curated: true,
-  strategy,
-  sourceCount: contexts.length,
-  curatedAt: Date.now(),
-  context: curatedContext
-};
-
-console.log(JSON.stringify(result, null, 2));
-EOF
-
-# Execute curation
-cd "$PROJECT_ROOT"
-
-if [ -n "$OUTPUT" ]; then
-  node "$RUNNER_SCRIPT" "$CONTEXTS" "$STRATEGY" "$MEMORY_PATH" > "$OUTPUT"
-  echo "Curated context saved to: $OUTPUT" >&2
-else
-  node "$RUNNER_SCRIPT" "$CONTEXTS" "$STRATEGY" "$MEMORY_PATH"
-fi