claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/redis-coordination/phase4-wake-queue-test-report.md

@@ -1,82 +0,0 @@
-# Redis Priority Wake-Up Queue Test Report
-## Task ID: redis-phase4-1760896217
-## Date: 2025-10-19
-
-### Test Objective
-Validate the implementation of a priority-based wake-up queue using Redis BZPOPMIN, focusing on:
-1. Priority ordering
-2. FIFO behavior within same priority
-3. Timeout handling
-4. Shutdown grace
-
-### Test Environment
-- Redis Version: 7.0.15
-- Platform: Linux 6.6.87.2-microsoft-standard-WSL2
-- Test Agent: tester-4
-
-### Test Results Summary
-
-| Test                   | Status      | Confidence | Notes                                   |
-|------------------------|-------------|------------|------------------------------------------|
-| Priority Ordering     | ❌ FAILED   | 0.00       | Unable to verify BZPOPMIN order         |
-| FIFO Same Priority    | ❌ FAILED   | 0.00       | Blocking pop did not return expected values |
-| Timeout Handling      | ❌ FAILED   | 0.00       | Timeout duration inconsistent           |
-| Shutdown Handling     | 🟡 SKIPPED  | N/A        | Requires specialized mock                |
-
-### Detailed Findings
-
-#### 1. Priority Ordering
-**Expected:** Highest priority message should be retrieved first
-**Actual:** No messages retrieved from queue
-**Potential Issues:**
-- Redis configuration blocking mechanism
-- Synchronization between ZADD and BZPOPMIN
-- Timestamp or score calculation
-
-#### 2. FIFO Same Priority
-**Expected:** Messages with same priority returned in order of insertion
-**Actual:** No messages retrieved
-**Potential Issues:**
-- Microsecond timestamp precision
-- Redis sorted set behavior
-
-#### 3. Timeout Handling
-**Expected:** Consistent 1-second timeout
-**Actual:** Timeout exceeded 3.4 seconds
-**Potential Issues:**
-- System load
-- Redis blocking mechanism configuration
-- Potential system-level timing discrepancies
-
-### Recommendations
-
-1. **Configuration Validation**
-   - Verify Redis server configuration
-   - Check blocking primitives implementation
-   - Validate network and system timing
-
-2. **Alternative Testing Strategies**
-   - Use non-blocking Redis commands for initial validation
-   - Implement mock Redis server for precise control
-   - Write comprehensive unit tests with controlled environment
-
-3. **Fallback Mechanisms**
-   - Implement retry logic
-   - Add detailed logging
-   - Create graceful degradation path
-
-### Next Steps
-- Conduct low-level Redis configuration review
-- Develop specialized test harness
-- Implement comprehensive mocking framework
-
-### Confidence Level: LOW (0.10)
-
-**Additional Notes:**
-- Requires in-depth investigation
-- May need collaboration with Redis core team
-- Potential platform-specific quirk
-
----
-
-Logged by: Claude Tester Agent (Claude 3.5 Haiku)

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