claude-flow-novice 2.10.8 → 2.11.0

package/claude-assets/skills/cfn-backlog-management/SKILL.md

@@ -0,0 +1,199 @@
+---
+skill_id: cfn-backlog-management
+name: CFN Backlog Management
+version: 1.0.0
+category: coordination
+tags: [backlog, documentation, sprint-planning, technical-debt]
+dependencies: []
+---
+
+# CFN Backlog Management Skill
+
+## Purpose
+Systematically capture and track backlogged items during CFN sprints to prevent work from being forgotten. Provides centralized documentation of deferred tasks with context, rationale, and proposed solutions.
+
+## Problem Solved
+During CFN Loop execution, agents frequently identify improvements, optimizations, or edge cases that should be addressed but are out of scope for the current sprint. Without systematic capture, these items are lost in chat history or forgotten entirely.
+
+## When to Use
+- **During CFN sprints** when identifying work that should be deferred
+- **After consensus** when validators identify future improvements
+- **During retrospectives** when documenting technical debt
+- **Architecture reviews** when noting long-term refactoring needs
+
+## Interface
+
+### Primary Script: `add-backlog-item.sh`
+
+**Required Parameters:**
+- `--item`: Brief description of backlogged work (1-2 sentences)
+- `--why`: Rationale for deferring (why not now?)
+- `--solution`: Proposed implementation approach
+
+**Optional Parameters:**
+- `--sprint`: Sprint identifier (default: auto-detected from context)
+- `--priority`: P0-P3 (default: P2)
+- `--tags`: Comma-separated tags (e.g., "optimization,redis,testing")
+- `--category`: Feature/Bug/Technical-Debt/Optimization (default: Technical-Debt)
+
+**Usage:**
+```bash
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --sprint "Sprint 10" \
+  --item "Implement Redis connection pooling for multi-agent coordination" \
+  --why "Current single-connection model causes bottlenecks with 10+ agents, but Sprint 10 scope limited to 3-agent validation" \
+  --solution "Use ioredis library with configurable pool size (min: 5, max: 20). Add pool metrics to monitoring dashboard" \
+  --priority "P2" \
+  --tags "optimization,redis,performance" \
+  --category "Optimization"
+```
+
+### Output Location
+All backlog items are appended to: `readme/BACKLOG.md`
+
+## Backlog File Structure
+
+```markdown
+# Claude Flow Novice - Backlog
+
+Last Updated: 2025-10-31
+
+## Active Items
+
+### P0 - Critical
+[Items requiring immediate attention in next sprint]
+
+### P1 - High Priority
+[Items to address within 2-3 sprints]
+
+### P2 - Medium Priority
+[Items to address when capacity allows]
+
+### P3 - Low Priority / Nice-to-Have
+[Items for future consideration]
+
+## Completed Items
+[Moved here when implemented, with resolution sprint noted]
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged | In Progress | Completed
+- **Date Added**: YYYY-MM-DD
+```
+
+## Validation Rules
+
+The skill enforces:
+1. **All required fields present** (item, why, solution)
+2. **Item description clarity** (≥10 characters, ≤500 characters)
+3. **Rationale specificity** (must explain deferral reason, not just "out of scope")
+4. **Solution actionability** (must include concrete implementation approach)
+5. **No duplicates** (checks existing BACKLOG.md for similar items)
+
+## Integration with CFN Loops
+
+### Loop 2 Validators
+When validators identify improvements outside current scope:
+```bash
+# In validator agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Add integration tests for Redis failure scenarios" \
+  --why "Current sprint validates happy path only; failure testing requires additional test infrastructure" \
+  --solution "Create test-redis-failures.sh with Docker-based Redis crash simulation" \
+  --tags "testing,redis,edge-cases"
+```
+
+### Product Owner Decision
+When Product Owner defers work for future sprint:
+```bash
+# In product-owner agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Migrate coordination from Redis to etcd for production scale" \
+  --why "Redis sufficient for current 10-agent limit; etcd needed for 100+ agent deployments" \
+  --solution "Abstract coordination layer behind interface, implement etcd adapter" \
+  --priority "P3" \
+  --category "Technical-Debt"
+```
+
+### Coordinator Context
+Coordinators can query backlog for related items before spawning agents:
+```bash
+# Check if backlog contains relevant context
+grep -i "redis pooling" readme/BACKLOG.md
+# Use results to inform agent context injection
+```
+
+## Query Interface
+
+**Search by tag:**
+```bash
+grep -A 10 "Tags:.*redis" readme/BACKLOG.md
+```
+
+**Filter by priority:**
+```bash
+sed -n '/^### P1/,/^### P2/p' readme/BACKLOG.md
+```
+
+**List all optimization items:**
+```bash
+grep -B 2 "Category: Optimization" readme/BACKLOG.md
+```
+
+## Maintenance
+
+**Weekly Review**: Product Owner reviews P0-P1 items for sprint planning
+**Monthly Cleanup**: Archive completed items, reassess P3 priorities
+**Quarterly Audit**: Remove stale items (>6 months old, no activity)
+
+## Best Practices
+
+1. **Be specific**: "Add caching" → "Implement Redis LRU cache for agent context with 1h TTL"
+2. **Explain constraints**: "Not enough time" → "Requires 8h estimation work; current sprint has 2h budget"
+3. **Provide actionable solutions**: "Fix later" → "Refactor using Strategy pattern from planning/PATTERNS.md"
+4. **Tag appropriately**: Enables filtering and sprint planning
+5. **Update status**: Move to "Completed" when resolved, note resolution sprint
+
+## Anti-Patterns
+
+❌ **Vague items**: "Improve performance" (What component? How much improvement?)
+❌ **No rationale**: "Backlog this" (Why defer? What's the blocker?)
+❌ **Solution-less**: "Fix Redis issues" (What's the approach? What research is needed?)
+❌ **Duplicate entries**: Check BACKLOG.md before adding
+❌ **Scope creep**: Backlog is for deferred work, not scope expansion
+
+## Example Backlog Item
+
+```markdown
+**[P1] - Implement Adaptive Validator Scaling**
+- **Sprint Backlogged**: Sprint 9 - CFN v3 Implementation
+- **Category**: Optimization
+- **Description**: Dynamically adjust number of Loop 2 validators (2-5) based on task complexity. Currently fixed at 3-4 validators regardless of task size.
+- **Rationale**: Sprint 9 focused on dual-mode architecture validation. Adaptive scaling requires task complexity classifier (NLP or heuristic-based), estimated 12h implementation vs 4h sprint budget.
+- **Proposed Solution**: Create task-classifier skill that analyzes task description (file count, domain keywords, integration points) and returns complexity score (0.0-1.0). Map score to validator count: <0.3 → 2 validators, 0.3-0.7 → 3-4 validators, >0.7 → 5 validators. Reference: CFN_LOOP_TASK_MODE.md section on adaptive validator scaling.
+- **Tags**: `optimization`, `cfn-loop`, `validation`, `adaptive-scaling`
+- **Status**: Backlogged
+- **Date Added**: 2025-10-31
+```
+
+## Success Metrics
+
+- **Backlog utilization**: ≥30% of backlog items addressed within 3 sprints
+- **Item clarity**: 0 items missing required fields
+- **Discovery rate**: ≥50% of technical debt captured vs lost in chat
+- **Sprint planning efficiency**: Backlog queries reduce planning time by 20%
+
+## References
+
+- **STRAT-025**: Explicit Deliverable Tracking (adaptive context)
+- **CFN Loop Documentation**: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
+- **Sprint Execution**: CLAUDE.md Section 6 - Sprint Context Injection

package/claude-assets/skills/cfn-backlog-management/add-backlog-item.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+set -e
+
+# cfn-backlog-management/add-backlog-item.sh
+# Adds structured backlog items to readme/BACKLOG.md
+
+# Default values
+PRIORITY="P2"
+CATEGORY="Technical-Debt"
+SPRINT="Unknown"
+TAGS=""
+ITEM=""
+WHY=""
+SOLUTION=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --item)
+      ITEM="$2"
+      shift 2
+      ;;
+    --why)
+      WHY="$2"
+      shift 2
+      ;;
+    --solution)
+      SOLUTION="$2"
+      shift 2
+      ;;
+    --sprint)
+      SPRINT="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --tags)
+      TAGS="$2"
+      shift 2
+      ;;
+    --category)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [[ -z "$ITEM" ]]; then
+  echo "Error: --item is required" >&2
+  exit 1
+fi
+
+if [[ -z "$WHY" ]]; then
+  echo "Error: --why is required" >&2
+  exit 1
+fi
+
+if [[ -z "$SOLUTION" ]]; then
+  echo "Error: --solution is required" >&2
+  exit 1
+fi
+
+# Validate item length
+ITEM_LENGTH=${#ITEM}
+if (( ITEM_LENGTH < 10 )); then
+  echo "Error: --item must be at least 10 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+if (( ITEM_LENGTH > 500 )); then
+  echo "Error: --item must be at most 500 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+# Validate priority
+if [[ ! "$PRIORITY" =~ ^P[0-3]$ ]]; then
+  echo "Error: --priority must be P0, P1, P2, or P3 (got: $PRIORITY)" >&2
+  exit 1
+fi
+
+# Validate category
+VALID_CATEGORIES="Feature|Bug|Technical-Debt|Optimization"
+if [[ ! "$CATEGORY" =~ ^($VALID_CATEGORIES)$ ]]; then
+  echo "Error: --category must be one of: Feature, Bug, Technical-Debt, Optimization (got: $CATEGORY)" >&2
+  exit 1
+fi
+
+# Path to backlog file
+BACKLOG_FILE="readme/BACKLOG.md"
+PROJECT_ROOT="/mnt/c/Users/masha/Documents/claude-flow-novice"
+BACKLOG_PATH="$PROJECT_ROOT/$BACKLOG_FILE"
+
+# Create backlog file if it doesn't exist
+if [[ ! -f "$BACKLOG_PATH" ]]; then
+  echo "Creating $BACKLOG_FILE..."
+  mkdir -p "$(dirname "$BACKLOG_PATH")"
+  cat > "$BACKLOG_PATH" <<'EOF'
+# Claude Flow Novice - Backlog
+
+Last Updated: $(date +%Y-%m-%d)
+
+## Active Items
+
+### P0 - Critical
+
+### P1 - High Priority
+
+### P2 - Medium Priority
+
+### P3 - Low Priority / Nice-to-Have
+
+## Completed Items
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged
+- **Date Added**: YYYY-MM-DD
+EOF
+fi
+
+# Check for duplicates (simple substring match)
+if grep -qi "$ITEM" "$BACKLOG_PATH" 2>/dev/null; then
+  echo "Warning: Similar item may already exist in backlog" >&2
+  echo "Existing matches:" >&2
+  grep -i "$ITEM" "$BACKLOG_PATH" | head -3 >&2
+  read -p "Continue anyway? (y/n) " -n 1 -r
+  echo
+  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Aborted" >&2
+    exit 1
+  fi
+fi
+
+# Format tags
+FORMATTED_TAGS=""
+if [[ -n "$TAGS" ]]; then
+  IFS=',' read -ra TAG_ARRAY <<< "$TAGS"
+  for tag in "${TAG_ARRAY[@]}"; do
+    FORMATTED_TAGS="${FORMATTED_TAGS}\`${tag}\`, "
+  done
+  FORMATTED_TAGS="${FORMATTED_TAGS%, }"  # Remove trailing comma
+fi
+
+# Generate item title (first 60 chars of description)
+ITEM_TITLE="${ITEM:0:60}"
+if (( ${#ITEM} > 60 )); then
+  ITEM_TITLE="${ITEM_TITLE}..."
+fi
+
+# Current date
+CURRENT_DATE=$(date +%Y-%m-%d)
+
+# Create backlog entry
+BACKLOG_ENTRY=$(cat <<EOF
+
+**[$PRIORITY] - $ITEM_TITLE**
+- **Sprint Backlogged**: $SPRINT
+- **Category**: $CATEGORY
+- **Description**: $ITEM
+- **Rationale**: $WHY
+- **Proposed Solution**: $SOLUTION
+- **Tags**: $FORMATTED_TAGS
+- **Status**: Backlogged
+- **Date Added**: $CURRENT_DATE
+
+EOF
+)
+
+# Insert into appropriate priority section
+SECTION_MARKER="### $PRIORITY"
+
+# Use awk to insert after section marker
+awk -v section="$SECTION_MARKER" -v entry="$BACKLOG_ENTRY" '
+  $0 ~ section {
+    print
+    print entry
+    next
+  }
+  {print}
+' "$BACKLOG_PATH" > "${BACKLOG_PATH}.tmp"
+
+mv "${BACKLOG_PATH}.tmp" "$BACKLOG_PATH"
+
+# Update "Last Updated" timestamp
+sed -i "s/Last Updated: .*/Last Updated: $CURRENT_DATE/" "$BACKLOG_PATH"
+
+echo "✅ Backlog item added successfully"
+echo "   Priority: $PRIORITY"
+echo "   Category: $CATEGORY"
+echo "   Sprint: $SPRINT"
+echo "   Location: $BACKLOG_FILE"
+
+# Output path for scripting
+echo "$BACKLOG_PATH"

package/claude-assets/skills/pre-edit-backup/backup.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Pre-Edit Backup Script
+# Creates timestamped backup with SHA-256 hash and JSON metadata
+#
+# Usage: backup.sh FILE_PATH AGENT_ID
+#
+# Arguments:
+#   FILE_PATH  - Absolute path to file to backup
+#   AGENT_ID   - Unique identifier for the agent creating the backup
+#
+# Returns:
+#   Backup directory path on success
+#   Exit code 1 on failure
+#
+# Example:
+#   ./.claude/skills/pre-edit-backup/backup.sh "/path/to/file.txt" "backend-dev-1"
+
+set -euo pipefail
+
+# === Input Validation ===
+
+FILE_PATH="$1"
+AGENT_ID="$2"
+
+if [[ -z "$FILE_PATH" ]]; then
+    echo "Error: No file path provided" >&2
+    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ -z "$AGENT_ID" ]]; then
+    echo "Error: No agent ID provided" >&2
+    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ ! -f "$FILE_PATH" ]]; then
+    echo "Error: File does not exist: $FILE_PATH" >&2
+    exit 1
+fi
+
+# === Configuration ===
+
+BACKUP_BASE_DIR=".backups"
+DEFAULT_TTL=86400  # 24 hours in seconds
+
+# === Tool Availability Checks ===
+
+# Check for sha256sum (with fallback to shasum on macOS)
+if command -v sha256sum &>/dev/null; then
+    HASH_TOOL="sha256sum"
+elif command -v shasum &>/dev/null; then
+    HASH_TOOL="shasum -a 256"
+else
+    echo "Error: Neither sha256sum nor shasum found. Cannot generate file hash." >&2
+    exit 1
+fi
+
+# Check for jq (graceful degradation)
+if ! command -v jq &>/dev/null; then
+    echo "Warning: jq not found. Metadata will be created using basic shell." >&2
+    USE_JQ=false
+else
+    USE_JQ=true
+fi
+
+# === Generate Backup Metadata ===
+
+TIMESTAMP=$(date +%s%3N 2>/dev/null || date +%s)  # Milliseconds if supported, else seconds
+FILE_HASH=$($HASH_TOOL "$FILE_PATH" | cut -d' ' -f1)
+
+# === Create Backup Directory ===
+
+BACKUP_DIR="${BACKUP_BASE_DIR}/${AGENT_ID}/${TIMESTAMP}_${FILE_HASH}"
+
+if ! mkdir -p "$BACKUP_DIR" 2>/dev/null; then
+    echo "Error: Failed to create backup directory: $BACKUP_DIR" >&2
+    exit 1
+fi
+
+# Set secure permissions (owner read/write/execute only)
+chmod 700 "$BACKUP_DIR" 2>/dev/null || true
+
+# === Copy Original File ===
+
+if ! cp "$FILE_PATH" "${BACKUP_DIR}/original_file" 2>/dev/null; then
+    echo "Error: Failed to copy file to backup directory" >&2
+    rm -rf "$BACKUP_DIR"
+    exit 1
+fi
+
+# === Generate Metadata ===
+
+METADATA_FILE="${BACKUP_DIR}/backup_metadata.json"
+
+if [[ "$USE_JQ" == true ]]; then
+    # Use jq for structured JSON generation
+    jq -n \
+        --arg agent_id "$AGENT_ID" \
+        --arg original_path "$FILE_PATH" \
+        --arg timestamp "$TIMESTAMP" \
+        --arg file_hash "$FILE_HASH" \
+        --arg ttl "$DEFAULT_TTL" \
+        '{
+            agent_id: $agent_id,
+            original_path: $original_path,
+            backup_timestamp: ($timestamp | tonumber),
+            file_hash: $file_hash,
+            backup_ttl: ($ttl | tonumber),
+            backup_status: "active"
+        }' > "$METADATA_FILE"
+else
+    # Fallback: Manual JSON generation
+    cat > "$METADATA_FILE" <<EOF
+{
+    "agent_id": "$AGENT_ID",
+    "original_path": "$FILE_PATH",
+    "backup_timestamp": $TIMESTAMP,
+    "file_hash": "$FILE_HASH",
+    "backup_ttl": $DEFAULT_TTL,
+    "backup_status": "active"
+}
+EOF
+fi
+
+# === Return Backup Path ===
+
+echo "$BACKUP_DIR"
+exit 0

package/claude-assets/skills/pre-edit-backup/cleanup.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# Pre-Edit Backup Cleanup Script
+# Removes expired backups based on TTL configuration
+# Runs as background process or cron-style with flock for concurrency control
+#
+# Usage: cleanup.sh [--dry-run] [--log-file FILE]
+#
+# Options:
+#   --dry-run    - Show what would be deleted without actually deleting
+#   --log-file   - Path to log file (default: none, outputs to stdout)
+#
+# Returns:
+#   Exit code 0 on success
+#   Exit code 1 if cleanup already in progress
+#
+# Example:
+#   ./.claude/skills/pre-edit-backup/cleanup.sh
+#   ./.claude/skills/pre-edit-backup/cleanup.sh --dry-run
+#   ./.claude/skills/pre-edit-backup/cleanup.sh --log-file /tmp/backup-cleanup.log
+
+set -euo pipefail
+
+# === Configuration ===
+
+BACKUP_BASE_DIR=".backups"
+CURRENT_TIME=$(date +%s)
+DRY_RUN=false
+LOG_FILE=""
+
+# === Parse Options ===
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        --log-file)
+            LOG_FILE="$2"
+            shift 2
+            ;;
+        *)
+            echo "Error: Unknown option: $1" >&2
+            echo "Usage: cleanup.sh [--dry-run] [--log-file FILE]" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# === Logging Function ===
+
+log() {
+    local message="$1"
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    local log_line="[$timestamp] $message"
+
+    if [[ -n "$LOG_FILE" ]]; then
+        echo "$log_line" >> "$LOG_FILE"
+    else
+        echo "$log_line"
+    fi
+}
+
+# === Prevent Concurrent Cleanup ===
+
+if [[ ! -d "$BACKUP_BASE_DIR" ]]; then
+    log "Backup directory does not exist: $BACKUP_BASE_DIR"
+    exit 0
+fi
+
+LOCKFILE="${BACKUP_BASE_DIR}/cleanup.lock"
+
+# Ensure lock file directory exists
+mkdir -p "$(dirname "$LOCKFILE")" 2>/dev/null || true
+
+# Acquire lock (non-blocking)
+exec 9>"$LOCKFILE"
+if ! flock -n 9; then
+    log "Cleanup already in progress (lock held)"
+    exit 1
+fi
+
+log "Cleanup started (dry-run: $DRY_RUN)"
+
+# === Cleanup Logic ===
+
+REMOVED_COUNT=0
+SKIPPED_COUNT=0
+ERROR_COUNT=0
+
+# Check for jq availability
+if ! command -v jq &>/dev/null; then
+    log "Error: jq is required for cleanup operations"
+    exit 1
+fi
+
+# Iterate through agent directories
+for agent_dir in "$BACKUP_BASE_DIR"/*; do
+    # Skip if not a directory or if it's the lockfile
+    [[ -d "$agent_dir" ]] || continue
+    [[ "$(basename "$agent_dir")" == "cleanup.lock" ]] && continue
+
+    # Iterate through backup directories for this agent
+    for backup_dir in "$agent_dir"/*; do
+        [[ -d "$backup_dir" ]] || continue
+
+        metadata_file="${backup_dir}/backup_metadata.json"
+
+        if [[ ! -f "$metadata_file" ]]; then
+            log "Warning: Metadata missing for backup: ${backup_dir}"
+            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+            continue
+        fi
+
+        # Extract backup timestamp and TTL
+        backup_timestamp=$(jq -r '.backup_timestamp' "$metadata_file" 2>/dev/null || echo "")
+        backup_ttl=$(jq -r '.backup_ttl' "$metadata_file" 2>/dev/null || echo "")
+
+        if [[ -z "$backup_timestamp" ]] || [[ "$backup_timestamp" == "null" ]] || \
+           [[ -z "$backup_ttl" ]] || [[ "$backup_ttl" == "null" ]]; then
+            log "Warning: Invalid metadata in: ${metadata_file}"
+            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+            continue
+        fi
+
+        # Convert milliseconds to seconds if needed (timestamp > 10 digits = milliseconds)
+        if [[ ${#backup_timestamp} -gt 10 ]]; then
+            backup_timestamp=$((backup_timestamp / 1000))
+        fi
+
+        # Check if backup has expired
+        age=$((CURRENT_TIME - backup_timestamp))
+        if (( age > backup_ttl )); then
+            if [[ "$DRY_RUN" == true ]]; then
+                log "Would remove expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
+                REMOVED_COUNT=$((REMOVED_COUNT + 1))
+            else
+                if rm -rf "$backup_dir" 2>/dev/null; then
+                    log "Removed expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
+                    REMOVED_COUNT=$((REMOVED_COUNT + 1))
+                else
+                    log "Error: Failed to remove backup: ${backup_dir}"
+                    ERROR_COUNT=$((ERROR_COUNT + 1))
+                fi
+            fi
+        fi
+    done
+done
+
+# === Summary ===
+
+log "Cleanup completed: removed=$REMOVED_COUNT, skipped=$SKIPPED_COUNT, errors=$ERROR_COUNT"
+
+exit 0