claude-flow-novice 2.9.0 → 2.10.0

package/.claude/skills/cfn-redis-coordination/demos/test-bzpopmin-fix.sh

@@ -0,0 +1,274 @@
+#!/bin/bash
+#
+# Test script to verify BZPOPMIN implementation fixes
+#
+# Tests:
+# 1. Compact JSON storage (no newlines breaking Redis)
+# 2. Priority ordering (high priority messages processed first)
+# 3. JSON validation on retrieval
+# 4. Timeout handling
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+INVOKE_SCRIPT="${SCRIPT_DIR}/invoke-waiting-mode.sh"
+
+# Test counter
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Cleanup function
+cleanup() {
+    local task_id="$1"
+    echo ""
+    echo "Cleaning up Redis keys for task: $task_id"
+    redis-cli KEYS "swarm:${task_id}:*" | xargs -r redis-cli DEL >/dev/null 2>&1 || true
+}
+
+# Test function
+run_test() {
+    local test_name="$1"
+    local test_func="$2"
+
+    echo ""
+    echo "=========================================="
+    echo "TEST: $test_name"
+    echo "=========================================="
+
+    if $test_func; then
+        echo "✅ PASSED: $test_name"
+        ((TESTS_PASSED++))
+    else
+        echo "❌ FAILED: $test_name"
+        ((TESTS_FAILED++))
+    fi
+}
+
+# Test 1: Compact JSON storage (verify no newlines)
+test_compact_json() {
+    local task_id="test-compact-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Send wake message
+    "$INVOKE_SCRIPT" wake \
+        --task-id "$task_id" \
+        --agent-id "$agent_id" \
+        --reason "test_reason" \
+        --priority 50 >/dev/null
+
+    # Retrieve message directly from Redis
+    local queue_key="swarm:${task_id}:${agent_id}:wake-queue"
+    local stored_msg=$(redis-cli ZRANGE "$queue_key" 0 0 2>/dev/null | head -1)
+
+    cleanup "$task_id"
+
+    # Check if message is valid JSON
+    if echo "$stored_msg" | jq empty 2>/dev/null; then
+        # Check if message is compact (no newlines)
+        if [[ "$stored_msg" != *$'\n'* ]]; then
+            echo "  ✓ Message stored as compact JSON"
+            return 0
+        else
+            echo "  ✗ Message contains newlines"
+            return 1
+        fi
+    else
+        echo "  ✗ Message is not valid JSON"
+        return 1
+    fi
+}
+
+# Test 2: Priority ordering (high priority first)
+test_priority_ordering() {
+    local task_id="test-priority-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Send 3 messages with different priorities
+    "$INVOKE_SCRIPT" wake --task-id "$task_id" --agent-id "$agent_id" --reason "low" --priority 20 >/dev/null
+    sleep 0.1
+    "$INVOKE_SCRIPT" wake --task-id "$task_id" --agent-id "$agent_id" --reason "medium" --priority 50 >/dev/null
+    sleep 0.1
+    "$INVOKE_SCRIPT" wake --task-id "$task_id" --agent-id "$agent_id" --reason "high" --priority 90 >/dev/null
+
+    # Agent should receive in order: high (90), medium (50), low (20)
+    local queue_key="swarm:${task_id}:${agent_id}:wake-queue"
+
+    # Get all messages in priority order
+    local msg1=$(redis-cli ZPOPMIN "$queue_key" 2>/dev/null | sed -n '1p')
+    local msg2=$(redis-cli ZPOPMIN "$queue_key" 2>/dev/null | sed -n '1p')
+    local msg3=$(redis-cli ZPOPMIN "$queue_key" 2>/dev/null | sed -n '1p')
+
+    cleanup "$task_id"
+
+    # Verify order
+    local reason1=$(echo "$msg1" | jq -r '.reason' 2>/dev/null)
+    local reason2=$(echo "$msg2" | jq -r '.reason' 2>/dev/null)
+    local reason3=$(echo "$msg3" | jq -r '.reason' 2>/dev/null)
+
+    if [ "$reason1" = "high" ] && [ "$reason2" = "medium" ] && [ "$reason3" = "low" ]; then
+        echo "  ✓ Messages retrieved in correct priority order: $reason1 → $reason2 → $reason3"
+        return 0
+    else
+        echo "  ✗ Incorrect order: $reason1 → $reason2 → $reason3 (expected: high → medium → low)"
+        return 1
+    fi
+}
+
+# Test 3: JSON validation on retrieval
+test_json_validation() {
+    local task_id="test-validation-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Send valid message
+    "$INVOKE_SCRIPT" wake --task-id "$task_id" --agent-id "$agent_id" --reason "valid_test" --priority 50 >/dev/null
+
+    # Start agent in background
+    timeout 5 "$INVOKE_SCRIPT" enter --task-id "$task_id" --agent-id "$agent_id" --context "test" >test_output.txt 2>&1 &
+    local agent_pid=$!
+
+    # Wait for agent to process message
+    sleep 2
+
+    # Check if agent received valid JSON
+    if wait $agent_pid 2>/dev/null; then
+        if grep -q "✅ Woken up!" test_output.txt && grep -q "valid_test" test_output.txt; then
+            echo "  ✓ Agent validated and processed JSON message"
+            rm -f test_output.txt
+            cleanup "$task_id"
+            return 0
+        fi
+    fi
+
+    echo "  ✗ Agent failed to validate JSON message"
+    rm -f test_output.txt
+    cleanup "$task_id"
+    return 1
+}
+
+# Test 4: Timeout handling (no deadlock)
+test_timeout_handling() {
+    local task_id="test-timeout-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Start agent without sending wake message
+    # Should timeout after a few seconds
+    timeout 3 "$INVOKE_SCRIPT" enter --task-id "$task_id" --agent-id "$agent_id" --context "test" >/dev/null 2>&1 &
+    local agent_pid=$!
+
+    sleep 4
+
+    # Check if agent is still running (should have timed out)
+    if ! kill -0 $agent_pid 2>/dev/null; then
+        echo "  ✓ Agent handled timeout correctly"
+        cleanup "$task_id"
+        return 0
+    else
+        echo "  ✗ Agent did not timeout"
+        kill $agent_pid 2>/dev/null || true
+        cleanup "$task_id"
+        return 1
+    fi
+}
+
+# Test 5: End-to-end wake-up flow
+test_e2e_wakeup() {
+    local task_id="test-e2e-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Start agent in background
+    timeout 10 "$INVOKE_SCRIPT" enter --task-id "$task_id" --agent-id "$agent_id" --context "e2e-test" >test_e2e_output.txt 2>&1 &
+    local agent_pid=$!
+
+    # Give agent time to enter waiting mode
+    sleep 1
+
+    # Send wake message
+    "$INVOKE_SCRIPT" wake \
+        --task-id "$task_id" \
+        --agent-id "$agent_id" \
+        --reason "e2e_test" \
+        --priority 80 \
+        --iteration 1 >/dev/null
+
+    # Wait for agent to complete
+    sleep 2
+
+    # Check results
+    if grep -q "✅ Woken up!" test_e2e_output.txt && grep -q "e2e_test" test_e2e_output.txt; then
+        echo "  ✓ End-to-end wake-up flow successful"
+        rm -f test_e2e_output.txt
+        cleanup "$task_id"
+        return 0
+    else
+        echo "  ✗ End-to-end wake-up flow failed"
+        cat test_e2e_output.txt
+        rm -f test_e2e_output.txt
+        cleanup "$task_id"
+        return 1
+    fi
+}
+
+# Test 6: Debug mode functionality
+test_debug_mode() {
+    local task_id="test-debug-$(date +%s)"
+    local agent_id="agent-1"
+
+    # Send wake message with debug mode enabled
+    DEBUG=true "$INVOKE_SCRIPT" wake \
+        --task-id "$task_id" \
+        --agent-id "$agent_id" \
+        --reason "debug_test" \
+        --priority 75 >test_debug_output.txt 2>&1
+
+    cleanup "$task_id"
+
+    # Check if debug output is present
+    if grep -q "\[DEBUG\]" test_debug_output.txt; then
+        echo "  ✓ Debug mode produces verbose output"
+        rm -f test_debug_output.txt
+        return 0
+    else
+        echo "  ✗ Debug mode did not produce expected output"
+        rm -f test_debug_output.txt
+        return 1
+    fi
+}
+
+# Main execution
+echo "=========================================="
+echo "BZPOPMIN Implementation Fix Test Suite"
+echo "=========================================="
+echo ""
+echo "Testing fixes for:"
+echo "  1. Compact JSON storage (no newlines)"
+echo "  2. Priority ordering"
+echo "  3. JSON validation on retrieval"
+echo "  4. Timeout handling"
+echo "  5. End-to-end wake-up flow"
+echo "  6. Debug mode"
+
+# Run all tests
+run_test "Compact JSON Storage" test_compact_json
+run_test "Priority Ordering" test_priority_ordering
+run_test "JSON Validation" test_json_validation
+run_test "Timeout Handling" test_timeout_handling
+run_test "End-to-End Wake-Up Flow" test_e2e_wakeup
+run_test "Debug Mode" test_debug_mode
+
+# Summary
+echo ""
+echo "=========================================="
+echo "TEST SUMMARY"
+echo "=========================================="
+echo "Tests passed: $TESTS_PASSED"
+echo "Tests failed: $TESTS_FAILED"
+echo ""
+
+if [ $TESTS_FAILED -eq 0 ]; then
+    echo "✅ All tests passed!"
+    exit 0
+else
+    echo "❌ Some tests failed"
+    exit 1
+fi

package/.claude/skills/cfn-redis-coordination/demos/test-cancel-swarm.sh

@@ -0,0 +1,276 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Test Cancel Swarm - Validates graceful shutdown functionality
+#
+# Tests:
+#   1. Cancel active swarm (success path)
+#   2. Cancel with custom reason and initiator
+#   3. Cancel non-existent swarm (error handling)
+#   4. Verify shutdown signals delivered to all agents
+#   5. Verify swarm metadata updated correctly
+#   6. Test force flag (skip confirmation)
+##############################################################################
+
+# Disable strict error handling for tests
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEST_TASK_ID="test-cancel-$(date +%s)"
+FAILED_TESTS=0
+PASSED_TESTS=0
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+log_test() {
+  echo ""
+  echo "========================================="
+  echo "TEST: $1"
+  echo "========================================="
+}
+
+log_pass() {
+  echo -e "${GREEN}✓ PASS:${NC} $1"
+  ((PASSED_TESTS++))
+}
+
+log_fail() {
+  echo -e "${RED}✗ FAIL:${NC} $1"
+  ((FAILED_TESTS++))
+}
+
+log_info() {
+  echo -e "${YELLOW}ℹ INFO:${NC} $1"
+}
+
+cleanup() {
+  log_info "Cleaning up test data..."
+
+  # Delete test keys matching patterns
+  KEYS=$(redis-cli --scan --pattern "swarm:${TEST_TASK_ID}*" 2>/dev/null || true)
+  if [ -n "$KEYS" ]; then
+    echo "$KEYS" | while read -r KEY; do
+      redis-cli del "$KEY" > /dev/null 2>&1 || true
+    done
+  fi
+
+  KEYS=$(redis-cli --scan --pattern "swarm:test-cancel-*" 2>/dev/null || true)
+  if [ -n "$KEYS" ]; then
+    echo "$KEYS" | while read -r KEY; do
+      redis-cli del "$KEY" > /dev/null 2>&1 || true
+    done
+  fi
+}
+
+# Cleanup on exit
+trap cleanup EXIT
+
+echo "========================================="
+echo "Cancel Swarm Test Suite"
+echo "========================================="
+echo "Test Task ID: $TEST_TASK_ID"
+echo ""
+
+# =============================================================================
+# Test 1: Cancel active swarm (success path)
+# =============================================================================
+log_test "Cancel Active Swarm"
+
+# Initialize test swarm
+SWARM_ID="${TEST_TASK_ID}-swarm1"
+AGENTS="coder-1,reviewer-1,tester-1"
+
+"$SCRIPT_DIR/init-swarm.sh" \
+  --swarm-id "$SWARM_ID" \
+  --task-id "$TEST_TASK_ID" \
+  --agents "$AGENTS" > /dev/null
+
+log_info "Swarm initialized: $SWARM_ID"
+
+# Cancel swarm with force flag (skip confirmation)
+OUTPUT=$("$SCRIPT_DIR/cancel-swarm.sh" \
+  --task-id "$TEST_TASK_ID" \
+  --force 2>&1 || true)
+
+# Verify status updated
+STATUS=$(redis-cli hget "swarm:${SWARM_ID}:metadata" status)
+if [ "$STATUS" = "cancelled" ]; then
+  log_pass "Swarm status updated to 'cancelled'"
+else
+  log_fail "Expected status 'cancelled', got: $STATUS"
+fi
+
+# Verify agents_notified count
+NOTIFIED=$(redis-cli hget "swarm:${SWARM_ID}:metadata" agents_notified)
+if [ "$NOTIFIED" = "3" ]; then
+  log_pass "All 3 agents notified"
+else
+  log_fail "Expected 3 agents notified, got: $NOTIFIED"
+fi
+
+# Verify shutdown signal broadcasted
+SHUTDOWN_KEY="swarm:${TEST_TASK_ID}:shutdown"
+SHUTDOWN_MSG=$(redis-cli --raw lindex "$SHUTDOWN_KEY" 0 2>/dev/null || echo "{}")
+
+if [ -n "$SHUTDOWN_MSG" ] && [ "$SHUTDOWN_MSG" != "(nil)" ]; then
+  log_pass "Shutdown signal broadcasted to $SHUTDOWN_KEY"
+
+  # Verify message content
+  REASON=$(echo "$SHUTDOWN_MSG" | jq -r '.reason // empty')
+  INITIATOR=$(echo "$SHUTDOWN_MSG" | jq -r '.initiator // empty')
+
+  if [ "$REASON" = "user_requested_cancellation" ]; then
+    log_pass "Shutdown signal has correct reason"
+  else
+    log_fail "Expected reason 'user_requested_cancellation', got: $REASON"
+  fi
+
+  if [ "$INITIATOR" = "main-chat" ]; then
+    log_pass "Shutdown signal has correct initiator"
+  else
+    log_fail "Expected initiator 'main-chat', got: $INITIATOR"
+  fi
+else
+  log_fail "No shutdown signal found"
+fi
+
+# =============================================================================
+# Test 2: Cancel with custom reason and initiator
+# =============================================================================
+log_test "Cancel with Custom Reason and Initiator"
+
+SWARM_ID2="${TEST_TASK_ID}-swarm2"
+"$SCRIPT_DIR/init-swarm.sh" \
+  --swarm-id "$SWARM_ID2" \
+  --task-id "${TEST_TASK_ID}-custom" \
+  --agents "backend-dev-1" > /dev/null
+
+OUTPUT=$("$SCRIPT_DIR/cancel-swarm.sh" \
+  --task-id "${TEST_TASK_ID}-custom" \
+  --reason "integration_test_timeout" \
+  --initiator "test-runner" \
+  --force 2>&1 || true)
+
+CANCEL_REASON=$(redis-cli hget "swarm:${SWARM_ID2}:metadata" cancellation_reason)
+CANCEL_INIT=$(redis-cli hget "swarm:${SWARM_ID2}:metadata" cancellation_initiator)
+
+if [ "$CANCEL_REASON" = "integration_test_timeout" ]; then
+  log_pass "Custom cancellation reason recorded"
+else
+  log_fail "Expected reason 'integration_test_timeout', got: $CANCEL_REASON"
+fi
+
+if [ "$CANCEL_INIT" = "test-runner" ]; then
+  log_pass "Custom initiator recorded"
+else
+  log_fail "Expected initiator 'test-runner', got: $CANCEL_INIT"
+fi
+
+# =============================================================================
+# Test 3: Cancel non-existent swarm (error handling)
+# =============================================================================
+log_test "Cancel Non-Existent Swarm (Error Handling)"
+
+OUTPUT=$("$SCRIPT_DIR/cancel-swarm.sh" \
+  --task-id "non-existent-task-id-12345" \
+  --force 2>&1 || true)
+
+if echo "$OUTPUT" | grep -q "No swarm found"; then
+  log_pass "Error message displayed for non-existent swarm"
+else
+  log_fail "Expected error message, got: $OUTPUT"
+fi
+
+# =============================================================================
+# Test 4: Verify shutdown message format
+# =============================================================================
+log_test "Verify Shutdown Message Format"
+
+SWARM_ID3="${TEST_TASK_ID}-swarm3"
+"$SCRIPT_DIR/init-swarm.sh" \
+  --swarm-id "$SWARM_ID3" \
+  --task-id "${TEST_TASK_ID}-format" \
+  --agents "security-1" > /dev/null
+
+"$SCRIPT_DIR/cancel-swarm.sh" \
+  --task-id "${TEST_TASK_ID}-format" \
+  --reason "test_message_format" \
+  --initiator "validator" \
+  --force > /dev/null 2>&1
+
+SHUTDOWN_KEY="swarm:${TEST_TASK_ID}-format:shutdown"
+MSG=$(redis-cli --raw lindex "$SHUTDOWN_KEY" 0 2>/dev/null || echo "{}")
+
+# Validate JSON structure
+REASON=$(echo "$MSG" | jq -r '.reason // empty')
+TIMESTAMP=$(echo "$MSG" | jq -r '.timestamp // empty')
+INITIATOR=$(echo "$MSG" | jq -r '.initiator // empty')
+
+if [ "$REASON" = "test_message_format" ] && \
+   [ -n "$TIMESTAMP" ] && \
+   [ "$INITIATOR" = "validator" ]; then
+  log_pass "Shutdown message has correct format"
+else
+  log_fail "Shutdown message format incorrect: $MSG"
+fi
+
+# =============================================================================
+# Test 5: Verify cancelled_at timestamp
+# =============================================================================
+log_test "Verify Cancelled Timestamp"
+
+CANCELLED_AT=$(redis-cli hget "swarm:${SWARM_ID3}:metadata" cancelled_at)
+
+if [[ "$CANCELLED_AT" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$ ]]; then
+  log_pass "Cancelled timestamp in ISO 8601 format: $CANCELLED_AT"
+else
+  log_fail "Invalid timestamp format: $CANCELLED_AT"
+fi
+
+# =============================================================================
+# Test 6: Empty agent list handling
+# =============================================================================
+log_test "Handle Swarm with Empty Agent List"
+
+SWARM_ID4="${TEST_TASK_ID}-swarm4"
+redis-cli hset "swarm:${SWARM_ID4}:metadata" \
+  swarm_id "$SWARM_ID4" \
+  task_id "${TEST_TASK_ID}-empty" \
+  agents "" \
+  status "in_progress" > /dev/null
+
+OUTPUT=$("$SCRIPT_DIR/cancel-swarm.sh" \
+  --task-id "${TEST_TASK_ID}-empty" \
+  --force 2>&1 || true)
+
+STATUS=$(redis-cli hget "swarm:${SWARM_ID4}:metadata" status)
+NOTIFIED=$(redis-cli hget "swarm:${SWARM_ID4}:metadata" agents_notified)
+
+if [ "$STATUS" = "cancelled" ] && [ "$NOTIFIED" = "0" ]; then
+  log_pass "Empty agent list handled correctly"
+else
+  log_fail "Empty agent list handling failed (status: $STATUS, notified: $NOTIFIED)"
+fi
+
+# =============================================================================
+# Summary
+# =============================================================================
+echo ""
+echo "========================================="
+echo "Test Summary"
+echo "========================================="
+echo -e "${GREEN}Passed:${NC} $PASSED_TESTS"
+echo -e "${RED}Failed:${NC} $FAILED_TESTS"
+echo "========================================="
+
+if [ $FAILED_TESTS -eq 0 ]; then
+  echo -e "${GREEN}✓ All tests passed!${NC}"
+  exit 0
+else
+  echo -e "${RED}✗ Some tests failed${NC}"
+  exit 1
+fi

package/.claude/skills/cfn-redis-coordination/demos/test-dlq.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Test Dead Letter Queue (DLQ) Functionality
+# Validates DLQ write and query operations with simulated failures
+##############################################################################
+
+set -euo pipefail
+
+TASK_ID="test-dlq-$(date +%s)"
+TEST_AGENT="test-agent-1"
+
+echo "=== DLQ Functionality Test ==="
+echo "Task ID: $TASK_ID"
+echo "Test Agent: $TEST_AGENT"
+echo ""
+
+##############################################################################
+# Test 1: Simulate DLQ Write
+##############################################################################
+echo "[Test 1] Simulating DLQ write for failed agent..."
+
+DLQ_KEY="swarm:${TASK_ID}:dlq:${TEST_AGENT}"
+DLQ_ENTRY=$(jq -n \
+  --arg reason "timeout_after_retries" \
+  --arg retries "3" \
+  --arg ts "$(date +%s)" \
+  '{reason: $reason, retry_count: ($retries | tonumber), timestamp: ($ts | tonumber)}')
+
+echo "$DLQ_ENTRY" | redis-cli -x LPUSH "$DLQ_KEY" >/dev/null
+redis-cli EXPIRE "$DLQ_KEY" 604800 >/dev/null  # 7 days TTL
+
+echo "  ✓ DLQ entry written"
+echo ""
+
+##############################################################################
+# Test 2: Query Specific Agent DLQ
+##############################################################################
+echo "[Test 2] Querying DLQ for specific agent..."
+./.claude/skills/cfn-redis-coordination/query-dlq.sh \
+  --task-id "$TASK_ID" \
+  --agent-id "$TEST_AGENT"
+echo ""
+
+##############################################################################
+# Test 3: Add Multiple Failures
+##############################################################################
+echo "[Test 3] Adding multiple failure entries..."
+
+TEST_AGENT_2="test-agent-2"
+DLQ_KEY_2="swarm:${TASK_ID}:dlq:${TEST_AGENT_2}"
+
+for i in {1..3}; do
+  DLQ_ENTRY=$(jq -n \
+    --arg reason "timeout_after_retries" \
+    --arg retries "$i" \
+    --arg ts "$(date +%s)" \
+    '{reason: $reason, retry_count: ($retries | tonumber), timestamp: ($ts | tonumber)}')
+
+  echo "$DLQ_ENTRY" | redis-cli -x LPUSH "$DLQ_KEY_2" >/dev/null
+  sleep 1
+done
+
+redis-cli EXPIRE "$DLQ_KEY_2" 604800 >/dev/null
+
+echo "  ✓ Added 3 failure entries for $TEST_AGENT_2"
+echo ""
+
+##############################################################################
+# Test 4: Query All DLQ Entries for Task
+##############################################################################
+echo "[Test 4] Querying all DLQ entries for task..."
+./.claude/skills/cfn-redis-coordination/query-dlq.sh --task-id "$TASK_ID"
+echo ""
+
+##############################################################################
+# Test 5: Verify TTL
+##############################################################################
+echo "[Test 5] Verifying TTL..."
+TTL=$(redis-cli TTL "$DLQ_KEY")
+EXPECTED_TTL=604800  # 7 days
+
+if [ "$TTL" -gt 0 ] && [ "$TTL" -le "$EXPECTED_TTL" ]; then
+  echo "  ✓ TTL correctly set: ${TTL}s (~7 days)"
+else
+  echo "  ✗ TTL verification failed: ${TTL}s"
+  exit 1
+fi
+echo ""
+
+##############################################################################
+# Test 6: Verify Entry Count
+##############################################################################
+echo "[Test 6] Verifying entry counts..."
+
+COUNT_1=$(redis-cli LLEN "$DLQ_KEY")
+COUNT_2=$(redis-cli LLEN "$DLQ_KEY_2")
+
+echo "  Agent 1 entries: $COUNT_1 (expected: 1)"
+echo "  Agent 2 entries: $COUNT_2 (expected: 3)"
+
+if [ "$COUNT_1" = "1" ] && [ "$COUNT_2" = "3" ]; then
+  echo "  ✓ Entry counts correct"
+else
+  echo "  ✗ Entry count mismatch"
+  exit 1
+fi
+echo ""
+
+##############################################################################
+# Cleanup
+##############################################################################
+echo "[Cleanup] Removing test DLQ entries..."
+redis-cli DEL "$DLQ_KEY" "$DLQ_KEY_2" >/dev/null
+echo "  ✓ Cleanup complete"
+echo ""
+
+##############################################################################
+# Summary
+##############################################################################
+echo "=== Test Summary ==="
+echo "✅ All DLQ tests passed!"
+echo ""
+echo "Validated:"
+echo "  - DLQ write functionality"
+echo "  - Single agent query"
+echo "  - Multi-agent query"
+echo "  - TTL expiration (7 days)"
+echo "  - Entry counting"