claude-flow-novice 2.15.3 → 2.15.5

package/scripts/verify-redis-cleanup.sh

@@ -0,0 +1,173 @@
+#!/bin/bash
+# Redis Cleanup Verification Script
+#
+# Quick health check for Redis cleanup mechanisms
+# Run this anytime to verify no process leaks or memory issues
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Configuration
+REDIS_HOST="${CFN_REDIS_HOST:-localhost}"
+REDIS_PORT="${CFN_REDIS_PORT:-6379}"
+
+# Counters
+ISSUES_FOUND=0
+
+echo "======================================"
+echo "Redis Cleanup Verification"
+echo "======================================"
+echo ""
+echo "Configuration:"
+echo "  Redis: $REDIS_HOST:$REDIS_PORT"
+echo "  Date: $(date)"
+echo ""
+
+# Test 1: Redis connectivity
+echo "1. Checking Redis connectivity..."
+if redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping >/dev/null 2>&1; then
+    echo -e "   ${GREEN}✓${NC} Redis is reachable"
+else
+    echo -e "   ${RED}✗${NC} Cannot connect to Redis"
+    ISSUES_FOUND=$((ISSUES_FOUND + 1))
+fi
+
+# Test 2: Process leak detection
+echo ""
+echo "2. Checking for redis-cli process leaks..."
+REDIS_CLI_COUNT=$(pgrep -f "redis-cli" | wc -l || echo "0")
+if [ "$REDIS_CLI_COUNT" -eq 0 ]; then
+    echo -e "   ${GREEN}✓${NC} No redis-cli processes found (expected)"
+else
+    echo -e "   ${YELLOW}⚠${NC}  Found $REDIS_CLI_COUNT redis-cli processes"
+    ps aux | grep "redis-cli" | grep -v grep
+    ISSUES_FOUND=$((ISSUES_FOUND + 1))
+fi
+
+# Test 3: Redis memory usage
+echo ""
+echo "3. Checking Redis memory usage..."
+REDIS_MEMORY=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" info memory 2>/dev/null | grep "used_memory_human:" | cut -d: -f2 | tr -d '\r\n' || echo "unknown")
+echo "   Memory used: $REDIS_MEMORY"
+
+# Extract numeric value (handle M/K/G suffixes)
+MEMORY_NUM=$(echo "$REDIS_MEMORY" | grep -oE '[0-9]+' | head -1)
+MEMORY_UNIT=$(echo "$REDIS_MEMORY" | grep -oE '[A-Z]' | head -1)
+
+if [ "$MEMORY_UNIT" = "G" ]; then
+    # Over 1 GB is concerning
+    echo -e "   ${RED}⚠${NC}  High memory usage (>1 GB)"
+    ISSUES_FOUND=$((ISSUES_FOUND + 1))
+elif [ "$MEMORY_UNIT" = "M" ] && [ "$MEMORY_NUM" -gt 500 ]; then
+    # Over 500 MB is a warning
+    echo -e "   ${YELLOW}⚠${NC}  Elevated memory usage (>500 MB)"
+else
+    echo -e "   ${GREEN}✓${NC} Memory usage is normal"
+fi
+
+# Test 4: Keys without TTL
+echo ""
+echo "4. Checking for keys without TTL..."
+NO_TTL_COUNT=0
+
+# Check message keys
+MESSAGE_KEYS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:messages" 2>/dev/null | wc -l || echo "0")
+if [ "$MESSAGE_KEYS" -gt 0 ]; then
+    while read -r key; do
+        if [ -z "$key" ]; then continue; fi
+        TTL=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ttl "$key" 2>/dev/null || echo "-2")
+        if [ "$TTL" -eq -1 ]; then
+            echo -e "   ${YELLOW}⚠${NC}  No TTL: $key"
+            NO_TTL_COUNT=$((NO_TTL_COUNT + 1))
+        fi
+    done < <(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:messages" 2>/dev/null)
+fi
+
+# Check fork keys
+FORK_KEYS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:fork:*:messages" 2>/dev/null | wc -l || echo "0")
+if [ "$FORK_KEYS" -gt 0 ]; then
+    while read -r key; do
+        if [ -z "$key" ]; then continue; fi
+        TTL=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ttl "$key" 2>/dev/null || echo "-2")
+        if [ "$TTL" -eq -1 ]; then
+            echo -e "   ${YELLOW}⚠${NC}  No TTL: $key"
+            NO_TTL_COUNT=$((NO_TTL_COUNT + 1))
+        fi
+    done < <(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:fork:*:messages" 2>/dev/null)
+fi
+
+if [ "$NO_TTL_COUNT" -eq 0 ]; then
+    echo -e "   ${GREEN}✓${NC} All keys have TTL"
+else
+    echo -e "   ${RED}✗${NC} $NO_TTL_COUNT keys without TTL"
+    ISSUES_FOUND=$((ISSUES_FOUND + 1))
+fi
+
+# Test 5: Key count
+echo ""
+echo "5. Checking key counts..."
+TOTAL_MESSAGE_KEYS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:messages" 2>/dev/null | wc -l || echo "0")
+TOTAL_FORK_KEYS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:fork:*" 2>/dev/null | wc -l || echo "0")
+TOTAL_RESULT_KEYS=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" keys "swarm:*:*:result:*" 2>/dev/null | wc -l || echo "0")
+
+echo "   Message keys: $TOTAL_MESSAGE_KEYS"
+echo "   Fork keys: $TOTAL_FORK_KEYS"
+echo "   Result keys: $TOTAL_RESULT_KEYS"
+
+if [ "$TOTAL_MESSAGE_KEYS" -gt 100 ]; then
+    echo -e "   ${YELLOW}⚠${NC}  High message key count (>100)"
+fi
+
+# Test 6: Node.js processes
+echo ""
+echo "6. Checking Node.js processes..."
+NODE_COUNT=$(pgrep -f "node" | wc -l || echo "0")
+echo "   Node.js processes: $NODE_COUNT"
+
+if [ "$NODE_COUNT" -gt 20 ]; then
+    echo -e "   ${YELLOW}⚠${NC}  High Node.js process count (>20)"
+    echo "   Top 5 by memory:"
+    ps aux | grep -E "node|ts-node" | grep -v grep | sort -k4 -rn | head -5
+fi
+
+# Summary
+echo ""
+echo "======================================"
+echo "Summary"
+echo "======================================"
+
+if [ "$ISSUES_FOUND" -eq 0 ]; then
+    echo -e "${GREEN}✓ All checks passed - No issues found${NC}"
+    echo ""
+    echo "Redis cleanup is working correctly."
+    exit 0
+else
+    echo -e "${RED}✗ Found $ISSUES_FOUND issue(s)${NC}"
+    echo ""
+    echo "Recommended actions:"
+
+    if [ "$REDIS_CLI_COUNT" -gt 0 ]; then
+        echo "  - Kill redis-cli processes: pkill -f redis-cli"
+    fi
+
+    if [ "$NO_TTL_COUNT" -gt 0 ]; then
+        echo "  - Set TTL on keys without expiration"
+        echo "    node -e \"const { setMessageListTTL } = require('./dist/cli/conversation-fork-cleanup.js'); setMessageListTTL('task-id', 'agent-id', 86400);\""
+    fi
+
+    if [ "$MEMORY_NUM" -gt 500 ] && [ "$MEMORY_UNIT" = "M" ]; then
+        echo "  - Consider emergency cleanup (WARNING: deletes all conversation history)"
+        echo "    node -e \"const { emergencyCleanupAll } = require('./dist/cli/conversation-fork-cleanup.js'); emergencyCleanupAll();\""
+    fi
+
+    echo ""
+    echo "For detailed analysis, run:"
+    echo "  ./tests/test-memory-leak-task-mode.sh"
+
+    exit 1
+fi

package/tests/README.md

@@ -0,0 +1,84 @@
+# Claude Flow Novice Test Suite
+
+## Overview
+
+This test suite validates the core functionality and resilience of the Claude Flow Novice system across multiple layers and scenarios.
+
+## Test Layers
+
+### Layer 0: Agent Tooling Validation
+- Verifies individual tool functionality
+- Ensures tools can be instantiated and used
+- Tests error handling and coordination
+
+### Layer 1: Mesh Coordination
+- Redis pub/sub integration tests
+- Validates agent communication patterns
+- Checks distributed messaging reliability
+
+### Layer 2: Review Handoff
+- Dynamic reviewer pool testing
+- Validates context transfer mechanisms
+- Ensures smooth agent transitions
+
+### Layer 3: Error Handling
+- 50% error injection scenarios
+- Circuit breaker and fallback mechanisms
+- Resilience and recovery validation
+
+## Running Tests
+
+### Prerequisites
+- Node.js 18+
+- Redis
+- Docker (optional, for containerized testing)
+
+### Commands
+```bash
+# Run all tests
+npm test
+
+# Run specific test layer
+npm test -- --testNamePattern="Layer 0"
+
+# Generate coverage report
+npm run test:coverage
+```
+
+## Coverage Requirements
+
+| Layer | Branches | Functions | Lines | Statements |
+|-------|----------|-----------|-------|------------|
+| Layer 0 | 90% | 85% | 95% | 90% |
+| Layer 1 | 85% | 80% | 90% | 85% |
+| Layer 2 | 80% | 75% | 85% | 80% |
+| Layer 3 | 75% | 70% | 80% | 75% |
+
+## Chaos Testing
+
+Includes resilience tests for:
+- Redis connection failures
+- SQLite data corruption
+- Coordinator process termination
+
+## Best Practices
+
+- All tests use TypeScript
+- Strict mode enforcement
+- Clear, descriptive assertions
+- Proper resource cleanup
+- Deterministic test environments
+
+## Troubleshooting
+
+1. Ensure Redis is running
+2. Check network configurations
+3. Verify dependency versions
+4. Run with increased verbosity: `npm test -- --verbose`
+
+## Contributing
+
+- Add new tests in respective layer directories
+- Follow existing patterns
+- Update coverage documentation
+- Write clear, concise test descriptions

package/tests/test-memory-leak-task-mode.sh

@@ -0,0 +1,435 @@
+#!/bin/bash
+# Memory Leak Test for Task Mode
+#
+# Tests memory accumulation patterns in Task Mode CFN Loop execution
+# Validates conversation fork cleanup and TTL enforcement
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# Redis connection
+REDIS_HOST="${CFN_REDIS_HOST:-localhost}"
+REDIS_PORT="${CFN_REDIS_PORT:-6379}"
+REDIS_PASSWORD="${CFN_REDIS_PASSWORD:-}"
+
+# Test configuration
+TEST_TASK_ID="test-memory-leak-$(date +%s)"
+TEST_AGENT_ID="test-agent-$$"
+MESSAGE_TTL=300  # 5 minutes for testing
+FORK_TTL=300     # 5 minutes for testing
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test counters
+TESTS_RUN=0
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Redis command builder
+redis_cmd() {
+    local cmd="redis-cli -h $REDIS_HOST -p $REDIS_PORT"
+    if [ -n "$REDIS_PASSWORD" ]; then
+        cmd="$cmd -a $REDIS_PASSWORD"
+    fi
+    echo "$cmd"
+}
+
+# Helper: Print test result
+print_result() {
+    local test_name="$1"
+    local result="$2"
+    local message="$3"
+
+    TESTS_RUN=$((TESTS_RUN + 1))
+
+    if [ "$result" = "PASS" ]; then
+        echo -e "${GREEN}✓${NC} $test_name: $message"
+        TESTS_PASSED=$((TESTS_PASSED + 1))
+    else
+        echo -e "${RED}✗${NC} $test_name: $message"
+        TESTS_FAILED=$((TESTS_FAILED + 1))
+    fi
+}
+
+# Helper: Store test message
+store_message() {
+    local task_id="$1"
+    local agent_id="$2"
+    local role="$3"
+    local iteration="$4"
+
+    local key="swarm:${task_id}:${agent_id}:messages"
+    local message="{\"role\":\"$role\",\"content\":\"Test message\",\"iteration\":$iteration,\"timestamp\":\"$(date -Iseconds)\"}"
+
+    $(redis_cmd) rpush "$key" "$message" >/dev/null
+    $(redis_cmd) expire "$key" "$MESSAGE_TTL" >/dev/null
+}
+
+# Helper: Create test fork
+create_fork() {
+    local task_id="$1"
+    local agent_id="$2"
+    local iteration="$3"
+
+    local fork_id="fork-${iteration}-testfork"
+    local fork_key="swarm:${task_id}:${agent_id}:fork:${fork_id}:messages"
+    local meta_key="swarm:${task_id}:${agent_id}:fork:${fork_id}:meta"
+
+    # Store fork messages
+    for i in $(seq 1 "$iteration"); do
+        local message="{\"role\":\"user\",\"content\":\"Fork message $i\",\"iteration\":$i,\"timestamp\":\"$(date -Iseconds)\"}"
+        $(redis_cmd) rpush "$fork_key" "$message" >/dev/null
+    done
+
+    # Set TTL on fork messages (CRITICAL for memory leak fix)
+    $(redis_cmd) expire "$fork_key" "$FORK_TTL" >/dev/null
+
+    # Store fork metadata with TTL
+    local metadata="{\"forkId\":\"$fork_id\",\"taskId\":\"$task_id\",\"agentId\":\"$agent_id\",\"createdAt\":\"$(date -Iseconds)\",\"parentIteration\":$iteration,\"messageCount\":$iteration}"
+    $(redis_cmd) setex "$meta_key" "$FORK_TTL" "$metadata" >/dev/null
+
+    echo "$fork_id"
+}
+
+# Helper: Get key count matching pattern
+count_keys() {
+    local pattern="$1"
+    local keys=$($(redis_cmd) keys "$pattern" 2>/dev/null | grep -v '^$' || true)
+    if [ -z "$keys" ]; then
+        echo "0"
+    else
+        echo "$keys" | wc -l
+    fi
+}
+
+# Helper: Get list length
+get_list_length() {
+    local key="$1"
+    local length=$($(redis_cmd) llen "$key" 2>/dev/null || echo "0")
+    echo "$length"
+}
+
+# Helper: Get TTL
+get_ttl() {
+    local key="$1"
+    local ttl=$($(redis_cmd) ttl "$key" 2>/dev/null || echo "-2")
+    echo "$ttl"
+}
+
+# Helper: Get memory usage (approximate)
+get_redis_memory() {
+    $(redis_cmd) info memory | grep "used_memory_human:" | cut -d: -f2 | tr -d '\r\n'
+}
+
+# Setup test environment
+setup() {
+    echo "========================================="
+    echo "Memory Leak Test - Task Mode"
+    echo "========================================="
+    echo ""
+    echo "Configuration:"
+    echo "  Task ID: $TEST_TASK_ID"
+    echo "  Agent ID: $TEST_AGENT_ID"
+    echo "  Message TTL: ${MESSAGE_TTL}s"
+    echo "  Fork TTL: ${FORK_TTL}s"
+    echo "  Redis: $REDIS_HOST:$REDIS_PORT"
+    echo ""
+
+    # Check Redis connection
+    if ! $(redis_cmd) ping >/dev/null 2>&1; then
+        echo -e "${RED}ERROR${NC}: Cannot connect to Redis at $REDIS_HOST:$REDIS_PORT"
+        exit 1
+    fi
+
+    echo -e "${GREEN}✓${NC} Redis connection successful"
+    echo ""
+}
+
+# Cleanup test data
+cleanup() {
+    echo ""
+    echo "Cleaning up test data..."
+
+    # Delete test keys
+    $(redis_cmd) del "swarm:${TEST_TASK_ID}:*" >/dev/null 2>&1 || true
+
+    # Pattern-based cleanup
+    local patterns=(
+        "swarm:${TEST_TASK_ID}:*:messages"
+        "swarm:${TEST_TASK_ID}:*:fork:*:messages"
+        "swarm:${TEST_TASK_ID}:*:fork:*:meta"
+        "swarm:${TEST_TASK_ID}:*:current-fork"
+    )
+
+    for pattern in "${patterns[@]}"; do
+        local keys=$($(redis_cmd) keys "$pattern" 2>/dev/null || true)
+        if [ -n "$keys" ]; then
+            echo "$keys" | xargs -r $(redis_cmd) del >/dev/null 2>&1 || true
+        fi
+    done
+
+    echo -e "${GREEN}✓${NC} Cleanup complete"
+}
+
+# Test 1: Message list has TTL
+test_message_ttl() {
+    echo "Test 1: Message List TTL"
+
+    store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "user" 1
+
+    local key="swarm:${TEST_TASK_ID}:${TEST_AGENT_ID}:messages"
+    local ttl=$(get_ttl "$key")
+
+    if [ "$ttl" -gt 0 ] && [ "$ttl" -le "$MESSAGE_TTL" ]; then
+        print_result "Message TTL" "PASS" "TTL set correctly ($ttl seconds)"
+    else
+        print_result "Message TTL" "FAIL" "TTL not set (got: $ttl, expected: >0 and <=$MESSAGE_TTL)"
+    fi
+}
+
+# Test 2: Fork messages have TTL
+test_fork_message_ttl() {
+    echo "Test 2: Fork Message TTL"
+
+    # Store some messages first
+    for i in {1..5}; do
+        store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "user" "$i"
+        store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "assistant" "$i"
+    done
+
+    # Create fork
+    local fork_id=$(create_fork "$TEST_TASK_ID" "$TEST_AGENT_ID" 3)
+    local fork_key="swarm:${TEST_TASK_ID}:${TEST_AGENT_ID}:fork:${fork_id}:messages"
+
+    local ttl=$(get_ttl "$fork_key")
+
+    if [ "$ttl" -gt 0 ] && [ "$ttl" -le "$FORK_TTL" ]; then
+        print_result "Fork Message TTL" "PASS" "TTL set correctly ($ttl seconds)"
+    else
+        print_result "Fork Message TTL" "FAIL" "TTL not set on fork messages (got: $ttl, expected: >0 and <=$FORK_TTL)"
+    fi
+}
+
+# Test 3: Memory accumulation with iterations
+test_memory_accumulation() {
+    echo "Test 3: Memory Accumulation (10 iterations)"
+
+    local initial_memory=$(get_redis_memory)
+    echo "  Initial memory: $initial_memory"
+
+    # Simulate 10 iterations with 3 agents each
+    for iter in {1..10}; do
+        for agent in {1..3}; do
+            local agent_id="${TEST_AGENT_ID}-agent${agent}"
+            store_message "$TEST_TASK_ID" "$agent_id" "user" "$iter"
+            store_message "$TEST_TASK_ID" "$agent_id" "assistant" "$iter"
+
+            # Create fork every 2 iterations
+            if [ $((iter % 2)) -eq 0 ]; then
+                create_fork "$TEST_TASK_ID" "$agent_id" "$iter" >/dev/null
+            fi
+        done
+    done
+
+    # Count keys
+    local message_count=$(count_keys "swarm:${TEST_TASK_ID}:*:messages")
+    local fork_count=$(count_keys "swarm:${TEST_TASK_ID}:*:fork:*:messages")
+
+    local final_memory=$(get_redis_memory)
+    echo "  Final memory: $final_memory"
+    echo "  Message keys: $message_count"
+    echo "  Fork keys: $fork_count"
+
+    # All keys should have TTL
+    local keys_without_ttl=0
+    for key in $($(redis_cmd) keys "swarm:${TEST_TASK_ID}:*" 2>/dev/null); do
+        local ttl=$(get_ttl "$key")
+        if [ "$ttl" -eq -1 ]; then
+            keys_without_ttl=$((keys_without_ttl + 1))
+        fi
+    done
+
+    if [ "$keys_without_ttl" -eq 0 ]; then
+        print_result "Memory Accumulation" "PASS" "All keys have TTL (no indefinite retention)"
+    else
+        print_result "Memory Accumulation" "FAIL" "$keys_without_ttl keys without TTL (memory leak risk)"
+    fi
+}
+
+# Test 4: Cleanup utility integration
+test_cleanup_utility() {
+    echo "Test 4: Cleanup Utility"
+
+    # Use a dedicated agent ID for this test
+    local cleanup_agent_id="${TEST_AGENT_ID}-cleanup"
+
+    # Store messages
+    for i in {1..20}; do
+        store_message "$TEST_TASK_ID" "$cleanup_agent_id" "user" "$i"
+    done
+
+    # Create multiple forks
+    for i in {2..10..2}; do
+        create_fork "$TEST_TASK_ID" "$cleanup_agent_id" "$i" >/dev/null
+    done
+
+    # Count before cleanup (only for this specific agent)
+    local before_count=$(count_keys "swarm:${TEST_TASK_ID}:${cleanup_agent_id}:*")
+
+    # Run cleanup utility (using Node.js with environment variables)
+    cd "$PROJECT_ROOT"
+    CFN_REDIS_HOST="$REDIS_HOST" CFN_REDIS_PORT="$REDIS_PORT" node -e "
+    const { cleanupTaskMessages } = require('./dist/cli/conversation-fork-cleanup.js');
+    cleanupTaskMessages('$TEST_TASK_ID', '$cleanup_agent_id');
+    " 2>/dev/null || {
+        print_result "Cleanup Utility" "SKIP" "Cleanup utility not built (run: npm run build)"
+        return
+    }
+
+    # Count after cleanup (only for this specific agent)
+    local after_count=$(count_keys "swarm:${TEST_TASK_ID}:${cleanup_agent_id}:*")
+
+    if [ "$after_count" -eq 0 ]; then
+        print_result "Cleanup Utility" "PASS" "All keys removed ($before_count → $after_count)"
+    else
+        print_result "Cleanup Utility" "FAIL" "Cleanup incomplete ($before_count → $after_count, expected: 0)"
+    fi
+}
+
+# Test 5: TTL enforcement (expiration test)
+test_ttl_enforcement() {
+    echo "Test 5: TTL Enforcement (5 second expiration)"
+
+    # Create key with very short TTL
+    local short_ttl=5
+    local key="swarm:${TEST_TASK_ID}:${TEST_AGENT_ID}:test-expiration"
+
+    $(redis_cmd) rpush "$key" "test-message" >/dev/null
+    $(redis_cmd) expire "$key" "$short_ttl" >/dev/null
+
+    echo "  Waiting ${short_ttl}s for expiration..."
+    sleep $((short_ttl + 1))
+
+    local exists=$($(redis_cmd) exists "$key")
+
+    if [ "$exists" -eq 0 ]; then
+        print_result "TTL Enforcement" "PASS" "Key expired after ${short_ttl}s"
+    else
+        print_result "TTL Enforcement" "FAIL" "Key still exists after TTL"
+    fi
+}
+
+# Test 6: Fork metadata and message consistency
+test_fork_consistency() {
+    echo "Test 6: Fork Metadata/Message Consistency"
+
+    # Store messages
+    for i in {1..5}; do
+        store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "user" "$i"
+    done
+
+    # Create fork
+    local fork_id=$(create_fork "$TEST_TASK_ID" "$TEST_AGENT_ID" 3)
+
+    # Check both have same TTL
+    local meta_key="swarm:${TEST_TASK_ID}:${TEST_AGENT_ID}:fork:${fork_id}:meta"
+    local msg_key="swarm:${TEST_TASK_ID}:${TEST_AGENT_ID}:fork:${fork_id}:messages"
+
+    local meta_ttl=$(get_ttl "$meta_key")
+    local msg_ttl=$(get_ttl "$msg_key")
+
+    # TTLs should be within 5 seconds of each other
+    local ttl_diff=$((meta_ttl - msg_ttl))
+    ttl_diff=${ttl_diff#-}  # Absolute value
+
+    if [ "$ttl_diff" -le 5 ]; then
+        print_result "Fork Consistency" "PASS" "Metadata and messages have consistent TTL (diff: ${ttl_diff}s)"
+    else
+        print_result "Fork Consistency" "FAIL" "TTL mismatch (meta: ${meta_ttl}s, msg: ${msg_ttl}s, diff: ${ttl_diff}s)"
+    fi
+}
+
+# Test 7: Memory statistics utility
+test_memory_statistics() {
+    echo "Test 7: Memory Statistics"
+
+    # Store messages
+    for i in {1..10}; do
+        store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "user" "$i"
+        store_message "$TEST_TASK_ID" "$TEST_AGENT_ID" "assistant" "$i"
+    done
+
+    # Create forks
+    create_fork "$TEST_TASK_ID" "$TEST_AGENT_ID" 5 >/dev/null
+
+    # Get statistics (using Node.js with environment variables)
+    cd "$PROJECT_ROOT"
+    local stats=$(CFN_REDIS_HOST="$REDIS_HOST" CFN_REDIS_PORT="$REDIS_PORT" node -e "
+    const { getTaskMemoryStats } = require('./dist/cli/conversation-fork-cleanup.js');
+    const stats = getTaskMemoryStats('$TEST_TASK_ID', '$TEST_AGENT_ID');
+    console.log(JSON.stringify(stats));
+    " 2>/dev/null || echo "{}")
+
+    if [ "$stats" != "{}" ]; then
+        local message_count=$(echo "$stats" | grep -o '"messageCount":[0-9]*' | cut -d: -f2)
+        local fork_count=$(echo "$stats" | grep -o '"forkCount":[0-9]*' | cut -d: -f2)
+
+        if [ "$message_count" -gt 0 ] && [ "$fork_count" -gt 0 ]; then
+            print_result "Memory Statistics" "PASS" "Stats collected (messages: $message_count, forks: $fork_count)"
+        else
+            print_result "Memory Statistics" "FAIL" "Stats invalid (messages: $message_count, forks: $fork_count)"
+        fi
+    else
+        print_result "Memory Statistics" "SKIP" "Statistics utility not built"
+    fi
+}
+
+# Main test execution
+main() {
+    setup
+
+    echo "Running memory leak tests..."
+    echo ""
+
+    test_message_ttl
+    test_fork_message_ttl
+    test_memory_accumulation
+    test_cleanup_utility
+    test_ttl_enforcement
+    test_fork_consistency
+    test_memory_statistics
+
+    cleanup
+
+    # Print summary
+    echo ""
+    echo "========================================="
+    echo "Test Summary"
+    echo "========================================="
+    echo -e "Total:  $TESTS_RUN"
+    echo -e "${GREEN}Passed: $TESTS_PASSED${NC}"
+    if [ "$TESTS_FAILED" -gt 0 ]; then
+        echo -e "${RED}Failed: $TESTS_FAILED${NC}"
+    else
+        echo -e "Failed: $TESTS_FAILED"
+    fi
+    echo ""
+
+    # Exit code
+    if [ "$TESTS_FAILED" -gt 0 ]; then
+        echo -e "${RED}TESTS FAILED${NC}"
+        exit 1
+    else
+        echo -e "${GREEN}ALL TESTS PASSED${NC}"
+        exit 0
+    fi
+}
+
+# Run tests
+main "$@"