claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/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/skills/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/skills/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/skills/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}/../../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