claude-flow-novice 2.14.2 → 2.14.4

package/claude-assets/skills/cfn-redis-coordination/orchestrate-cfn-loop-v3.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Orchestration v3.0.0
-# Advanced multi-agent coordination with enhanced Redis context retrieval,
-# validation template support, intervention detection, and retrospective capabilities
-#
-# Key Enhancements:
-# - Redis-first context retrieval
-# - Domain-specific validation thresholds
-# - Real-time intervention detection
-# - Automatic playbook update
-# - Retrospective trigger
-# - Z.ai provider routing
-##############################################################################
-
-set -euo pipefail
-
-# V3 Specific Configuration
-TASK_ID=""
-MODE="standard"
-V3_VALIDATION_TEMPLATE=""
-INTERVENTION_THRESHOLD=0.75
-RETROSPECTIVE_ENABLED=1
-
-# Import common v2 functions
-# shellcheck source=./orchestrate-cfn-loop.sh
-source "$(dirname "$0")/orchestrate-cfn-loop.sh"
-
-# V3 Specific Configuration Loading
-function load_v3_configuration() {
-  # Load configuration from Redis using task context
-  V3_CONFIG=$(redis-cli HGETALL "cfn_loop:task:${TASK_ID}:v3_config" 2>/dev/null)
-
-  # Parse configuration
-  while read -r key value; do
-    case "$key" in
-      "validation_template")
-        V3_VALIDATION_TEMPLATE="$value"
-        ;;
-      "intervention_threshold")
-        INTERVENTION_THRESHOLD="$value"
-        ;;
-      "retrospective_enabled")
-        RETROSPECTIVE_ENABLED="$value"
-        ;;
-    esac
-  done <<< "$V3_CONFIG"
-}
-
-# Domain-Specific Validation Template Loader
-function load_validation_template() {
-  local template_path="$1"
-
-  if [ ! -f "$template_path" ]; then
-    echo "Error: Validation template not found at $template_path"
-    return 1
-  fi
-
-  # Load and parse validation template
-  VALIDATION_CONFIG=$(jq '.' "$template_path")
-
-  # Extract domain-specific thresholds
-  DOMAIN_GATE_THRESHOLD=$(echo "$VALIDATION_CONFIG" | jq -r '.gate_threshold // 0.75')
-  DOMAIN_CONSENSUS_THRESHOLD=$(echo "$VALIDATION_CONFIG" | jq -r '.consensus_threshold // 0.90')
-
-  # Override default thresholds
-  GATE=${DOMAIN_GATE_THRESHOLD}
-  CONSENSUS=${DOMAIN_CONSENSUS_THRESHOLD}
-}
-
-# Intervention Detection Function
-function detect_intervention_needed() {
-  local confidence_scores=("$@")
-  local intervention_triggered=0
-
-  for score in "${confidence_scores[@]}"; do
-    if (( $(echo "$score < $INTERVENTION_THRESHOLD" | bc -l) )); then
-      intervention_triggered=1
-      break
-    fi
-  done
-
-  return $intervention_triggered
-}
-
-# Trigger Retrospective Analysis
-function trigger_retrospective() {
-  if [ "$RETROSPECTIVE_ENABLED" -eq 1 ]; then
-    npx cfn-spawn agent retrospective-analyst \
-      --task-id "$TASK_ID" \
-      --mode "post_execution" \
-      --context "{\"task_id\": \"$TASK_ID\", \"mode\": \"$MODE\"}"
-  fi
-}
-
-# Automatic Playbook Update
-function update_playbook() {
-  ./.claude/skills/cfn-playbook-auto-update/update.sh \
-    --task-id "$TASK_ID" \
-    --mode "$MODE" \
-    --context "$CFN_METADATA"
-}
-
-# Override Main Iteration Logic
-function main_iteration_logic() {
-  # V3: Load Redis context first
-  load_v3_configuration
-
-  # Load domain-specific validation template if specified
-  if [ -n "$V3_VALIDATION_TEMPLATE" ]; then
-    load_validation_template "$V3_VALIDATION_TEMPLATE"
-  fi
-
-  # Original v2 iteration logic with V3 enhancements
-  for ITERATION in $(seq 1 $MAX_ITERATIONS); do
-    # Existing iteration loop logic here...
-
-    # V3: Intervention Detection
-    if detect_intervention_needed "${AGENT_CONFIDENCE_SCORES[@]}"; then
-      echo "[V3 Intervention] Confidence threshold not met. Spawning specialist agent..."
-      # Spawn specialist agent to address low-confidence areas
-      npx cfn-spawn agent specialist \
-        --task-id "$TASK_ID" \
-        --mode intervention \
-        --context "{\"iteration\": $ITERATION}"
-    fi
-
-    # Continue with existing iteration logic...
-  done
-
-  # Finalization: Trigger Retrospective and Update Playbook
-  trigger_retrospective
-  update_playbook
-}
-
-# Execute Main Logic
-main_iteration_logic
-
-# Existing cleanup and exit logic from v2 script
-cleanup_and_exit 0 "cfn_loop_v3_complete"

package/claude-assets/skills/cfn-redis-coordination/orchestrate-cfn-loop.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-
-echo "=========================================="
-echo "⚠️  DEPRECATED: orchestrate-cfn-loop.sh"
-echo "=========================================="
-echo ""
-echo "This orchestrator has been replaced by the modular CFN v3 version."
-echo ""
-echo "New Location:"
-echo "  ./.claude/skills/cfn-cfn-loop-orchestration/orchestrate.sh"
-echo ""
-echo "Key Improvements in v3:"
-echo "  - 78% code reduction (70KB → 26KB)"
-echo "  - Modular helper scripts"
-echo "  - Stateless context injection"
-echo "  - Better agent ID tracking"
-echo "  - No BLPOP hangs"
-echo ""
-echo "Migration:"
-echo "  Replace: orchestrate-cfn-loop.sh"
-echo "  With:    cfn-loop-orchestration/orchestrate.sh"
-echo ""
-echo "Same parameters supported (backward compatible)"
-echo ""
-echo "=========================================="
-echo ""
-echo "Forwarding to new orchestrator..."
-echo ""
-
-# Forward to new version
-exec "$(dirname "$0")/.claude/skills/cfn-cfn-cfn-loop-orchestration/orchestrate.sh" "$@"

package/claude-assets/skills/cfn-redis-coordination/priority-wake-mechanism.md

@@ -1,75 +0,0 @@
-# Priority Queue Wake-Up Mechanism
-
-## Design Overview
-
-### Motivation
-Replace traditional LPUSH/BLPOP with ZADD/BZPOPMIN to enable priority-ordered wake-ups across distributed agent swarms.
-
-### Priority Scoring Algorithm
-
-#### Score Calculation
-```
-SCORE = TIMESTAMP + (PRIORITY * PRIORITY_MULTIPLIER)
-
-Where:
-- TIMESTAMP: Unix epoch seconds
-- PRIORITY: Assigned agent/task priority level
-- PRIORITY_MULTIPLIER: 1,000,000 (ensures timestamp remains primary sorting factor)
-```
-
-### Priority Levels
-
-| Level    | Range   | Example Agents                      |
-|----------|---------|-------------------------------------|
-| Critical | 0-10    | Product Owner, System Coordinators  |
-| High     | 11-30   | Loop 2 Validators                   |
-| Medium   | 31-60   | Loop 3 Implementers                 |
-| Low      | 61-100  | Background Tasks, Monitoring Agents |
-
-### Redis Command Translations
-
-#### Old Method (FIFO)
-```bash
-# LPUSH: Adds to end of list
-redis-cli lpush "swarm:{task}:{agent}:wake" "$WAKE_MSG"
-# BLPOP: Blocks and removes from start of list
-redis-cli blpop "swarm:{task}:{agent}:wake" 0
-```
-
-#### New Method (Priority Queue)
-```bash
-# ZADD: Adds to sorted set with score
-redis-cli zadd "swarm:{task}:wake-queue" $SCORE "$WAKE_MSG"
-# BZPOPMIN: Blocks and removes lowest-score item
-redis-cli bzpopmin "swarm:{task}:wake-queue" 0
-```
-
-### Configuration Flag
-```json
-{
-  "features": {
-    "enablePriorityWake": {
-      "default": false,
-      "description": "Enable priority-based wake mechanism",
-      "version": "4.0.0"
-    }
-  }
-}
-```
-
-## Migration Strategy
-
-1. Dual Support Phase
-   - Maintain both LPUSH and ZADD mechanisms
-   - Gradual rollout with feature flag
-   - Monitor performance and compatibility
-
-2. Transition Steps
-   - Update Redis Coordination skill
-   - Modify waiting mode invocation scripts
-   - Add compatibility layer
-   - Implement feature flag checks
-
-3. Rollback Capabilities
-   - Preserve original LPUSH mechanism
-   - Configurable fallback options

package/claude-assets/skills/cfn-redis-coordination/priority_wake.py

@@ -1,134 +0,0 @@
-import redis
-import time
-import json
-from typing import Optional, Union, Dict
-
-class PriorityWakeMechanism:
-    """
-    Implements priority-based wake-up mechanism using Redis Sorted Sets
-    Supports both legacy and new wake-up strategies
-    """
-
-    PRIORITY_MULTIPLIER = 1_000_000
-    PRIORITY_LEVELS = {
-        "critical": (0, 10),
-        "high": (11, 30),
-        "medium": (31, 60),
-        "low": (61, 100)
-    }
-
-    def __init__(self,
-                 redis_client: redis.Redis,
-                 config_path: str = '/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/redis-coordination/config.json'):
-        self.redis = redis_client
-        self.config = self._load_config(config_path)
-
-    def _load_config(self, config_path: str) -> Dict:
-        try:
-            with open(config_path, 'r') as f:
-                return json.load(f)
-        except FileNotFoundError:
-            return {"features": {"enablePriorityWake": {"default": False}}}
-
-    def calculate_score(self, priority_level: str) -> float:
-        """
-        Calculate wake-up score based on timestamp and priority
-
-        Args:
-            priority_level (str): Priority of the wake-up message
-
-        Returns:
-            float: Calculated score for sorted set insertion
-        """
-        now = time.time()
-        priority_range = self.PRIORITY_LEVELS.get(priority_level, (50, 70))
-        priority_midpoint = sum(priority_range) / 2
-
-        return now + (priority_midpoint * self.PRIORITY_MULTIPLIER)
-
-    def enqueue_wake_message(
-        self,
-        task_id: str,
-        agent_id: str,
-        wake_message: str,
-        priority_level: str = "medium"
-    ) -> bool:
-        """
-        Enqueue a wake message with priority
-
-        Args:
-            task_id (str): Unique task identifier
-            agent_id (str): Agent identifier
-            wake_message (str): Message to be processed
-            priority_level (str, optional): Priority of message. Defaults to "medium".
-
-        Returns:
-            bool: Whether message was successfully enqueued
-        """
-        if not self._is_priority_wake_enabled():
-            # Fallback to traditional LPUSH
-            self.redis.lpush(f"swarm:{task_id}:{agent_id}:wake", wake_message)
-            return True
-
-        score = self.calculate_score(priority_level)
-        key = f"swarm:{task_id}:wake-queue"
-
-        try:
-            self.redis.zadd(key, {wake_message: score})
-            return True
-        except Exception as e:
-            print(f"Wake message enqueue failed: {e}")
-            return False
-
-    def dequeue_wake_message(
-        self,
-        task_id: str,
-        timeout: int = 0
-    ) -> Optional[Union[str, tuple]]:
-        """
-        Dequeue highest priority wake message
-
-        Args:
-            task_id (str): Unique task identifier
-            timeout (int, optional): Blocking timeout. Defaults to 0 (indefinite wait).
-
-        Returns:
-            Optional message or None if no message available
-        """
-        if not self._is_priority_wake_enabled():
-            # Fallback to traditional BLPOP
-            return self.redis.blpop(f"swarm:{task_id}:*:wake", timeout)
-
-        key = f"swarm:{task_id}:wake-queue"
-
-        try:
-            result = self.redis.bzpopmin(key, timeout)
-            return result[1] if result else None
-        except Exception as e:
-            print(f"Wake message dequeue failed: {e}")
-            return None
-
-    def _is_priority_wake_enabled(self) -> bool:
-        """
-        Check if priority wake mechanism is enabled in configuration
-
-        Returns:
-            bool: Whether priority wake is enabled
-        """
-        return self.config.get('features', {}).get('enablePriorityWake', {}).get('default', False)
-
-def main():
-    # Example usage
-    redis_client = redis.Redis(host='localhost', port=6379, db=0)
-    pwm = PriorityWakeMechanism(redis_client)
-
-    # Enqueue messages with different priorities
-    pwm.enqueue_wake_message("task123", "agent-1", "Critical update", "critical")
-    pwm.enqueue_wake_message("task123", "agent-2", "Standard update", "medium")
-
-    # Dequeue messages (will return critical message first)
-    message = pwm.dequeue_wake_message("task123")
-    print(f"Received message: {message}")
-
-if __name__ == "__main__":
-    main()

package/claude-assets/skills/cfn-redis-coordination/query-dlq.sh

@@ -1,162 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Query Dead Letter Queue (DLQ)
-# Retrieves and displays failed agent signals from DLQ
-#
-# Usage:
-#   ./query-dlq.sh --task-id <id> [--agent-id <id>]
-#
-# Examples:
-#   # List all DLQ entries for a task
-#   ./query-dlq.sh --task-id redis-phase1-1760875302
-#
-#   # List DLQ entries for specific agent
-#   ./query-dlq.sh --task-id redis-phase1-1760875302 --agent-id backend-dev-2
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_ID=""
-AGENT_ID=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --agent-id)
-      AGENT_ID="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ]; then
-  echo "Error: --task-id is required"
-  echo "Usage: $0 --task-id <id> [--agent-id <id>]"
-  exit 1
-fi
-
-##############################################################################
-# Query DLQ Entries
-##############################################################################
-
-if [ -n "$AGENT_ID" ]; then
-  # Query specific agent's DLQ
-  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
-
-  echo "=== DLQ Entries for Agent: $AGENT_ID ==="
-  echo "Task ID: $TASK_ID"
-  echo ""
-
-  # Check if DLQ exists
-  EXISTS=$(redis-cli EXISTS "$DLQ_KEY")
-
-  if [ "$EXISTS" = "0" ]; then
-    echo "No DLQ entries found for agent: $AGENT_ID"
-    exit 0
-  fi
-
-  # Get entry count
-  ENTRY_COUNT=$(redis-cli LLEN "$DLQ_KEY")
-
-  if [ "$ENTRY_COUNT" = "0" ]; then
-    echo "No DLQ entries found for agent: $AGENT_ID"
-    exit 0
-  fi
-
-  # Parse and display entries
-  for i in $(seq 0 $((ENTRY_COUNT - 1))); do
-    ENTRY=$(redis-cli LINDEX "$DLQ_KEY" "$i")
-
-    if [ -n "$ENTRY" ]; then
-      REASON=$(echo "$ENTRY" | jq -r '.reason')
-      RETRIES=$(echo "$ENTRY" | jq -r '.retry_count')
-      TIMESTAMP=$(echo "$ENTRY" | jq -r '.timestamp')
-      HUMAN_TIME=$(date -d "@$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC" 2>/dev/null || date -r "$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC")
-
-      echo "Entry #$((i + 1)):"
-      echo "  Agent: $AGENT_ID"
-      echo "  Reason: $REASON"
-      echo "  Retries: $RETRIES"
-      echo "  Timestamp: $HUMAN_TIME ($TIMESTAMP)"
-      echo ""
-    fi
-  done
-
-else
-  # Query all agents' DLQs for this task
-  echo "=== DLQ Entries for Task: $TASK_ID ==="
-  echo ""
-
-  # Find all DLQ keys for this task
-  DLQ_PATTERN="swarm:${TASK_ID}:dlq:*"
-  DLQ_KEYS=$(redis-cli KEYS "$DLQ_PATTERN")
-
-  if [ -z "$DLQ_KEYS" ]; then
-    echo "No DLQ entries found for task: $TASK_ID"
-    exit 0
-  fi
-
-  # Process each DLQ key
-  echo "$DLQ_KEYS" | while IFS= read -r DLQ_KEY; do
-    if [ -n "$DLQ_KEY" ]; then
-      # Extract agent ID from key (format: swarm:task-id:dlq:agent-id)
-      AGENT=$(echo "$DLQ_KEY" | awk -F':' '{print $NF}')
-
-      # Get entry count for this agent
-      ENTRY_COUNT=$(redis-cli LLEN "$DLQ_KEY")
-
-      if [ "$ENTRY_COUNT" -gt 0 ]; then
-        for i in $(seq 0 $((ENTRY_COUNT - 1))); do
-          ENTRY=$(redis-cli LINDEX "$DLQ_KEY" "$i")
-
-          if [ -n "$ENTRY" ]; then
-            REASON=$(echo "$ENTRY" | jq -r '.reason')
-            RETRIES=$(echo "$ENTRY" | jq -r '.retry_count')
-            TIMESTAMP=$(echo "$ENTRY" | jq -r '.timestamp')
-            HUMAN_TIME=$(date -d "@$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC" 2>/dev/null || date -r "$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC")
-
-            echo "Agent: $AGENT (Entry #$((i + 1))/$ENTRY_COUNT)"
-            echo "  Reason: $REASON"
-            echo "  Retries: $RETRIES"
-            echo "  Timestamp: $HUMAN_TIME ($TIMESTAMP)"
-            echo ""
-          fi
-        done
-      fi
-    fi
-  done
-fi
-
-# Display summary
-echo "=== Summary ==="
-if [ -n "$AGENT_ID" ]; then
-  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
-  TOTAL=$(redis-cli LLEN "$DLQ_KEY")
-  echo "Total DLQ entries for $AGENT_ID: $TOTAL"
-else
-  DLQ_PATTERN="swarm:${TASK_ID}:dlq:*"
-  TOTAL_KEYS=$(redis-cli KEYS "$DLQ_PATTERN" | wc -l)
-  echo "Total agents with DLQ entries: $TOTAL_KEYS"
-fi
-
-# Check TTL
-if [ -n "$AGENT_ID" ]; then
-  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
-  TTL=$(redis-cli TTL "$DLQ_KEY")
-  if [ "$TTL" -gt 0 ]; then
-    DAYS=$((TTL / 86400))
-    HOURS=$(((TTL % 86400) / 3600))
-    echo "TTL remaining: ${DAYS}d ${HOURS}h"
-  fi
-fi

package/claude-assets/skills/cfn-redis-coordination/query-logs.sh

@@ -1,103 +0,0 @@
-#!/bin/bash
-##############################################################################
-# CFN Loop Log Query Tool
-#
-# Usage:
-#   ./query-logs.sh --task-id <id> [options]
-#
-# Parameters:
-#   --task-id       Task/swarm identifier (required)
-#   --event-type    Filter by event type (optional)
-#   --level         Filter by log level: DEBUG, INFO, WARN, ERROR (optional)
-#   --loop          Filter by loop: loop3, loop2, product_owner, coordinator (optional)
-#   --agent-id      Filter by agent ID (optional)
-#   --iteration     Filter by iteration number (optional)
-#   --limit         Maximum number of results (default: 100)
-#   --format        Output format: json, csv, table (default: json)
-#
-# Examples:
-#   # Get all logs for a task
-#   ./query-logs.sh --task-id "cfn-task-123"
-#
-#   # Get errors only
-#   ./query-logs.sh --task-id "cfn-task-123" --level ERROR
-#
-#   # Get Loop 3 agent spawns
-#   ./query-logs.sh --task-id "cfn-task-123" --event-type agent_spawn --loop loop3
-#
-#   # Get latest 10 events in table format
-#   ./query-logs.sh --task-id "cfn-task-123" --limit 10 --format table
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-DB_PATH="${DB_PATH:-${SCRIPT_DIR}/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-data/cfn-loop.db}"
-
-# Parameters
-TASK_ID=""
-EVENT_TYPE=""
-LEVEL=""
-LOOP=""
-AGENT_ID=""
-ITERATION=""
-LIMIT=100
-FORMAT="json"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id) TASK_ID="$2"; shift 2 ;;
-    --event-type) EVENT_TYPE="$2"; shift 2 ;;
-    --level) LEVEL="$2"; shift 2 ;;
-    --loop) LOOP="$2"; shift 2 ;;
-    --agent-id) AGENT_ID="$2"; shift 2 ;;
-    --iteration) ITERATION="$2"; shift 2 ;;
-    --limit) LIMIT="$2"; shift 2 ;;
-    --format) FORMAT="$2"; shift 2 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Validate required parameters
-if [ -z "$TASK_ID" ]; then
-  echo "Error: --task-id is required" >&2
-  echo "Usage: $0 --task-id <id> [--event-type <type>] [--level <level>] [--limit <n>] [--format json|csv|table]" >&2
-  exit 1
-fi
-
-# Check if database exists
-if [ ! -f "$DB_PATH" ]; then
-  echo "Error: Database not found at $DB_PATH" >&2
-  echo "No logs have been written yet." >&2
-  exit 1
-fi
-
-# Build query
-QUERY="SELECT * FROM cfn_loop_logs WHERE task_id = '$TASK_ID'"
-
-[ -n "$EVENT_TYPE" ] && QUERY="$QUERY AND event_type = '$EVENT_TYPE'"
-[ -n "$LEVEL" ] && QUERY="$QUERY AND level = '$LEVEL'"
-[ -n "$LOOP" ] && QUERY="$QUERY AND loop = '$LOOP'"
-[ -n "$AGENT_ID" ] && QUERY="$QUERY AND agent_id = '$AGENT_ID'"
-[ -n "$ITERATION" ] && QUERY="$QUERY AND iteration = $ITERATION"
-
-QUERY="$QUERY ORDER BY timestamp DESC LIMIT $LIMIT"
-
-# Execute query with selected format
-case "$FORMAT" in
-  json)
-    sqlite3 -json "$DB_PATH" "$QUERY"
-    ;;
-  csv)
-    sqlite3 -csv "$DB_PATH" "$QUERY"
-    ;;
-  table)
-    sqlite3 -column -header "$DB_PATH" "$QUERY"
-    ;;
-  *)
-    echo "Error: Invalid format '$FORMAT'. Use: json, csv, or table" >&2
-    exit 1
-    ;;
-esac