claude-flow-novice 2.18.5 → 2.18.7

package/claude-assets/skills/cfn-task-planning/lib/audit/store-task-audit.sh

@@ -1,191 +0,0 @@
-#!/bin/bash
-# Task Mode Audit Storage Script
-# Stores Task Mode agent output in Redis/SQLite for complete audit trail
-#
-# Usage: store-task-audit.sh --task-id <id> --agent-type <type> --output <json>
-#
-# This script provides audit storage for Task Mode agents while maintaining
-# ANTI-023 memory leak protection by keeping agents out of Redis coordination
-
-set -euo pipefail
-
-# Import SQLite parameterized query library for SQL injection prevention
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-source "${SCRIPT_DIR}/../bootstrap/sqlite-params.sh"
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-# Initialize variables
-TASK_ID=""
-AGENT_TYPE=""
-OUTPUT=""
-MODE="Task"
-TIMESTAMP=""
-DB_PATH="${HOME}/.claude/memory/cfn-loop.db"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --agent-type)
-      AGENT_TYPE="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [ -z "$TASK_ID" ] || [ -z "$AGENT_TYPE" ] || [ -z "$OUTPUT" ]; then
-    echo "Error: Missing required parameters" >&2
-    echo "Usage: $0 --task-id <id> --agent-type <type> --output <json> [--mode <mode>]" >&2
-    exit 1
-fi
-
-# Generate timestamp
-TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-# Ensure database directory exists
-mkdir -p "$(dirname "$DB_PATH")"
-
-# Initialize SQLite database if needed
-if [ ! -f "$DB_PATH" ]; then
-    echo "Initializing audit database..." >&2
-    sqlite3 "$DB_PATH" <<'EOF'
-CREATE TABLE IF NOT EXISTS agent_audit (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    task_id TEXT NOT NULL,
-    agent_type TEXT NOT NULL,
-    decision TEXT,
-    reasoning TEXT,
-    confidence REAL,
-    mode TEXT NOT NULL,
-    deliverables TEXT,  -- JSON array
-    timestamp INTEGER NOT NULL,
-    created_at TEXT NOT NULL,
-    metadata TEXT  -- JSON
-);
-
-CREATE INDEX IF NOT EXISTS idx_audit_task ON agent_audit(task_id);
-CREATE INDEX IF NOT EXISTS idx_audit_agent ON agent_audit(agent_type);
-CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON agent_audit(timestamp);
-CREATE INDEX IF NOT EXISTS idx_audit_mode ON agent_audit(mode);
-EOF
-fi
-
-# Parse JSON output using jq (fallback to basic parsing if jq unavailable)
-DECISION=""
-REASONING=""
-CONFIDENCE=""
-DELIVERABLES="[]"
-
-if command -v jq &> /dev/null; then
-    # Use jq for robust JSON parsing
-    DECISION=$(echo "$OUTPUT" | jq -r '.decision // "UNKNOWN"')
-    REASONING=$(echo "$OUTPUT" | jq -r '.reasoning // ""')
-    CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence // 0.0')
-    DELIVERABLES=$(echo "$OUTPUT" | jq -r '(.deliverables // []) | tostring')
-else
-    # Fallback: basic string parsing
-    DECISION=$(echo "$OUTPUT" | grep -o '"decision":"[^"]*"' | cut -d'"' -f4 || echo "UNKNOWN")
-    REASONING=$(echo "$OUTPUT" | grep -o '"reasoning":"[^"]*"' | cut -d'"' -f4 || echo "")
-    CONFIDENCE=$(echo "$OUTPUT" | grep -o '"confidence":[0-9.]*' | cut -d: -f2 || echo "0.0")
-    DELIVERABLES=$(echo "$OUTPUT" | grep -o '"deliverables":\[[^]]*\]' | sed 's/"deliverables":\[//g' | sed 's/\]//g' || echo "[]")
-fi
-
-# Validate confidence is a number
-if ! [[ "$CONFIDENCE" =~ ^[0-9]*\.?[0-9]*$ ]]; then
-    CONFIDENCE="0.0"
-fi
-
-# Store in Redis (fast access for Main Chat coordination)
-echo -e "${YELLOW}💾 Storing Task Mode audit data in Redis...${NC}"
-REDIS_KEY="swarm:${TASK_ID}:${AGENT_TYPE}:audit"
-
-redis-cli HSET "$REDIS_KEY" \
-    "decision" "$DECISION" \
-    "reasoning" "$REASONING" \
-    "confidence" "$CONFIDENCE" \
-    "mode" "$MODE" \
-    "deliverables" "$DELIVERABLES" \
-    "timestamp" "$TIMESTAMP" \
-    "agent_output" "$OUTPUT" > /dev/null
-
-# Set TTL for Redis (24 hours)
-redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
-
-# Store in SQLite (permanent audit trail)
-echo -e "${GREEN}💾 Storing Task Mode audit data in SQLite...${NC}"
-UNIX_TIMESTAMP=$(date -d "$TIMESTAMP" +%s 2>/dev/null || date +%s)
-
-# Use parameterized query to prevent SQL injection
-sqlite_insert "$DB_PATH" \
-    "INSERT OR REPLACE INTO agent_audit (
-        task_id, agent_type, decision, reasoning, confidence, mode,
-        deliverables, timestamp, created_at, metadata
-    ) VALUES (
-        ?1, ?2, ?3, ?4, $CONFIDENCE, ?5,
-        ?6, $UNIX_TIMESTAMP, ?7,
-        '{\"stored_via\": \"store-task-audit.sh\", \"version\": \"1.0.0\"}'
-    )" \
-    "$TASK_ID" "$AGENT_TYPE" "$DECISION" "$REASONING" "$MODE" \
-    "$DELIVERABLES" "$TIMESTAMP"
-
-# Store metadata in Redis for quick access
-METADATA_KEY="swarm:${TASK_ID}:metadata"
-redis-cli HSET "$METADATA_KEY" \
-    "task_mode_audit" "true" \
-    "last_agent" "$AGENT_TYPE" \
-    "last_decision" "$DECISION" \
-    "last_confidence" "$CONFIDENCE" \
-    "last_updated" "$TIMESTAMP" > /dev/null
-
-redis-cli EXPIRE "$METADATA_KEY" 86400 > /dev/null
-
-# Output success information
-echo -e "${GREEN}✅ Task Mode audit stored successfully${NC}"
-echo -e "   Task ID: $TASK_ID"
-echo -e "   Agent Type: $AGENT_TYPE"
-echo -e "   Decision: $DECISION"
-echo -e "   Confidence: $CONFIDENCE"
-echo -e "   Mode: $MODE"
-echo -e "   Deliverables: $DELIVERABLES"
-echo -e "   Timestamp: $TIMESTAMP"
-
-# Store agent output for debugging (optional, size-limited)
-if [ ${#OUTPUT} -le 1000 ]; then
-    OUTPUT_KEY="swarm:${TASK_ID}:${AGENT_TYPE}:output"
-    redis-cli HSET "$OUTPUT_KEY" "data" "$OUTPUT" "timestamp" "$TIMESTAMP" > /dev/null
-    redis-cli EXPIRE "$OUTPUT_KEY" 3600 > /dev/null
-    echo -e "   Output: ${#OUTPUT} characters stored in Redis"
-else
-    echo -e "   Output: ${#OUTPUT} characters (too large for Redis, logged in SQLite only)"
-fi
-
-# Log to file for debugging
-LOG_DIR="${HOME}/.claude/logs/task-audit"
-mkdir -p "$LOG_DIR"
-LOG_FILE="$LOG_DIR/task-audit-$(date +%Y%m%d).log"
-
-echo "[$TIMESTAMP] TASK_MODE_AUDIT: task_id=$TASK_ID agent_type=$AGENT_TYPE decision=$DECISION confidence=$CONFIDENCE mode=$MODE" >> "$LOG_FILE"
-
-exit 0

package/claude-assets/skills/cfn-task-planning/lib/decomposition/task-decomposer.sh

@@ -1,279 +0,0 @@
-#!/bin/bash
-# Task Decomposition for Complex Operations
-# Breaks down complex tasks into smaller, tool-budget-efficient subtasks
-
-set -euo pipefail
-
-# Configuration
-TASK_ID="${1}"
-TASK_DESCRIPTION="${2}"
-TOOL_BUDGET="${3:-10}"  # Default 10 tool budget per agent
-COMPLEXITY_THRESHOLD="${4:-medium}"  # low, medium, high
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-echo -e "${BLUE}🔧 CFN Loop Task Decomposition${NC}"
-echo "Task ID: $TASK_ID"
-echo "Tool Budget: $TOOL_BUDGET per agent"
-echo "Complexity: $COMPLEXITY_THRESHOLD"
-echo ""
-
-# Function to analyze task complexity
-analyze_task_complexity() {
-    local description="$1"
-    local complexity_score=0
-
-    # File operation indicators
-    if echo "$description" | grep -qiE "(fix|create|modify|update|delete|write).*file"; then
-        ((complexity_score += 3))
-    fi
-
-    # Directory exploration indicators
-    if echo "$description" | grep -qiE "(explore|find|search|scan|directory|folder)"; then
-        ((complexity_score += 2))
-    fi
-
-    # Multiple component indicators
-    if echo "$description" | grep -qiE "(multiple|batch|all|every|comprehensive)"; then
-        ((complexity_score += 4))
-    fi
-
-    # TypeScript/Complex file indicators
-    if echo "$description" | grep -qiE "(typescript|tsx|interface|type|complex)"; then
-        ((complexity_score += 2))
-    fi
-
-    # Dependency analysis indicators
-    if echo "$description" | grep -qiE "(dependency|import|require|module)"; then
-        ((complexity_score += 2))
-    fi
-
-    echo "$complexity_score"
-}
-
-# Function to decompose TypeScript error fixing tasks
-decompose_typescript_task() {
-    local task_id="$1"
-    local description="$2"
-    local output_file=".claude/skills/cfn-task-decomposition/${task_id}-subtasks.json"
-
-    echo -e "${YELLOW}Decomposing TypeScript task...${NC}"
-
-    # Create subtasks
-    cat > "$output_file" << EOF
-{
-  "task_id": "$task_id",
-  "original_task": "$description",
-  "decomposition_strategy": "typescript-error-fixing",
-  "subtasks": [
-    {
-      "subtask_id": "${task_id}-recon",
-      "title": "Directory Reconnaissance",
-      "description": "Explore project structure and identify TypeScript files needing fixes",
-      "agent_type": "researcher",
-      "tool_budget": 5,
-      "expected_tools": ["find", "grep", "Read", "Glob"],
-      "deliverables": ["file-list.txt", "error-classification.json"],
-      "estimated_duration": "5-10 minutes"
-    },
-    {
-      "subtask_id": "${task_id}-pattern",
-      "title": "Error Pattern Analysis",
-      "description": "Analyze TypeScript errors and identify common patterns",
-      "agent_type": "analyst",
-      "tool_budget": 8,
-      "expected_tools": ["Read", "Grep", "Bash"],
-      "deliverables": ["error-patterns.json", "fix-strategy.md"],
-      "estimated_duration": "10-15 minutes"
-    },
-    {
-      "subtask_id": "${task_id}-fix",
-      "title": "File-by-File Fixes",
-      "description": "Fix TypeScript errors in identified files using patterns",
-      "agent_type": "backend-developer",
-      "tool_budget": 15,
-      "expected_tools": ["Read", "Edit", "Write", "Bash"],
-      "deliverables": ["fixed-files/", "fix-summary.json"],
-      "estimated_duration": "20-30 minutes",
-      "batch_processing": {
-        "max_files_per_batch": 3,
-        "batches_total": 5
-      }
-    },
-    {
-      "subtask_id": "${task_id}-validate",
-      "title": "Validation and Testing",
-      "description": "Validate fixes and run TypeScript compilation",
-      "agent_type": "tester",
-      "tool_budget": 10,
-      "expected_tools": ["Bash", "Read", "Write"],
-      "deliverables": ["validation-report.json", "compilation-results.txt"],
-      "estimated_duration": "10-15 minutes"
-    }
-  ],
-  "coordination": {
-    "dependency_order": ["recon", "pattern", "fix", "validate"],
-    "redis_context_keys": {
-      "recon": "${task_id}:recon:results",
-      "pattern": "${task_id}:pattern:results",
-      "fix": "${task_id}:fix:results",
-      "validate": "${task_id}:validate:results"
-    }
-  }
-}
-EOF
-
-    echo -e "${GREEN}✓ Task decomposition created: $output_file${NC}"
-    echo "$output_file"
-}
-
-# Function to decompose file exploration tasks
-decompose_exploration_task() {
-    local task_id="$1"
-    local description="$2"
-    local output_file=".claude/skills/cfn-task-decomposition/${task_id}-subtasks.json"
-
-    echo -e "${YELLOW}Decomposing exploration task...${NC}"
-
-    cat > "$output_file" << EOF
-{
-  "task_id": "$task_id",
-  "original_task": "$description",
-  "decomposition_strategy": "directory-exploration",
-  "subtasks": [
-    {
-      "subtask_id": "${task_id}-scan",
-      "title": "Targeted Directory Scan",
-      "description": "Scan specific directories for target files using ripgrep",
-      "agent_type": "researcher",
-      "tool_budget": 6,
-      "expected_tools": ["Bash", "rg", "Glob", "Read"],
-      "deliverables": ["target-files.txt", "directory-map.json"],
-      "estimated_duration": "5-8 minutes"
-    },
-    {
-      "subtask_id": "${task_id}-analyze",
-      "title": "File Content Analysis",
-      "description": "Analyze found files to understand structure and patterns",
-      "agent_type": "analyst",
-      "tool_budget": 8,
-      "expected_tools": ["Read", "Grep", "Write"],
-      "deliverables": ["file-analysis.json", "content-summary.md"],
-      "estimated_duration": "8-12 minutes"
-    }
-  ]
-}
-EOF
-
-    echo -e "${GREEN}✓ Task decomposition created: $output_file${NC}"
-    echo "$output_file"
-}
-
-# Function to create task-specific agent prompts
-create_agent_prompts() {
-    local subtasks_file="$1"
-    local prompts_dir=".claude/skills/cfn-task-decomposition/prompts"
-
-    mkdir -p "$prompts_dir"
-
-    # Extract subtask information
-    local task_id=$(jq -r '.task_id' "$subtasks_file")
-    local strategy=$(jq -r '.decomposition_strategy' "$subtasks_file")
-
-    # Generate prompts for each subtask
-    jq -r '.subtasks[] | @base64' "$subtasks_file" | while read -r subtask_b64; do
-        local subtask=$(echo "$subtask_b64" | base64 -d)
-        local subtask_id=$(echo "$subtask" | jq -r '.subtask_id')
-        local title=$(echo "$subtask" | jq -r '.title')
-        local description=$(echo "$subtask" | jq -r '.description')
-        local tool_budget=$(echo "$subtask" | jq -r '.tool_budget')
-        local deliverables=$(echo "$subtask" | jq -r '.deliverables[]')
-
-        cat > "$prompts_dir/${subtask_id}-prompt.md" << EOF
-# Task: $title
-
-## Context
-You are working on subtask "${subtask_id}" of the larger task "${task_id}".
-
-## Your Mission
-$description
-
-## Tool Budget Optimization
-You have **$tool_budget tool uses** available. Use them efficiently:
-
-### Recommended Tool Sequence:
-1. **Exploration tools** (Read, Glob, Bash) - 2-3 uses
-2. **Analysis tools** (Grep, Read) - 2-3 uses
-3. **Implementation tools** (Edit, Write) - 3-5 uses
-4. **Validation tools** (Bash, Read) - 1-2 uses
-
-### Efficiency Tips:
-- **Batch operations**: Read multiple files in one tool use when possible
-- **Targeted searches**: Use specific patterns instead of broad scans
-- **Early validation**: Check results after each major step
-- **Combine tool uses**: Use compound commands to reduce tool count
-
-## Expected Deliverables
-$deliverables
-
-## Success Criteria
-- All deliverables created with high quality
-- Tool budget not exceeded
-- Results passed to next subtask via Redis
-
-## Redis Context
-- Store results in: \`${task_id}:${subtask_id}:results\`
-- Use confidence scoring based on deliverable completion
-- Signal completion via Redis LPUSH to \`${task_id}:${subtask_id}:done\`
-EOF
-
-        echo -e "${GREEN}✓ Created prompt for $subtask_id${NC}"
-    done
-}
-
-# Main execution
-main() {
-    local complexity_score=$(analyze_task_complexity "$TASK_DESCRIPTION")
-    echo -e "${YELLOW}Task Complexity Score: $complexity_score${NC}"
-
-    local decomposition_file=""
-
-    # Determine decomposition strategy based on task type
-    if echo "$TASK_DESCRIPTION" | grep -qiE "(typescript|tsx|ts27|ts23|error|fix)"; then
-        decomposition_file=$(decompose_typescript_task "$TASK_ID" "$TASK_DESCRIPTION")
-    elif echo "$TASK_DESCRIPTION" | grep -qiE "(explore|find|search|scan)"; then
-        decomposition_file=$(decompose_exploration_task "$TASK_ID" "$TASK_DESCRIPTION")
-    else
-        echo -e "${YELLOW}Using general task decomposition...${NC}"
-        decomposition_file=$(decompose_typescript_task "$TASK_ID" "$TASK_DESCRIPTION")
-    fi
-
-    # Create agent prompts
-    if [ -n "$decomposition_file" ] && [ -f "$decomposition_file" ]; then
-        create_agent_prompts "$decomposition_file"
-
-        echo -e "\n${GREEN}=== Task Decomposition Complete ===${NC}"
-        echo -e "📄 ${BLUE}Decomposition file:${NC} $decomposition_file"
-        echo -e "🤖 ${BLUE}Agent prompts:${NC} .claude/skills/cfn-task-decomposition/prompts/"
-        echo -e "💡 ${BLUE}Strategy:${NC} Break complex task into tool-budget-efficient subtasks"
-
-        # Store decomposition info in Redis for coordinator
-        if command -v redis-cli >/dev/null 2>&1; then
-            redis-cli set "${TASK_ID}:decomposition" "$(cat "$decomposition_file")" >/dev/null
-            echo -e "📦 ${BLUE}Redis context stored:${NC} ${TASK_ID}:decomposition"
-        fi
-
-        return 0
-    else
-        echo -e "${RED}❌ Task decomposition failed${NC}"
-        return 1
-    fi
-}
-
-# Execute main function
-main "$@"

package/claude-assets/skills/cfn-transparency-middleware/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "transparency-middleware"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sqlx = { version = "0.7", features = ["runtime-tokio", "sqlite", "chrono"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-anyhow = "1.0"
-chrono = { version = "0.4", features = ["serde"] }
-tokio = { version = "1.0", features = ["full"] }
-tracing = "0.1"
-tracing-subscriber = "0.3"
-
-[dev-dependencies]
-tempfile = "3.2"
-mockall = "0.11"

package/claude-assets/skills/cfn-transparency-middleware/README.md

@@ -1,74 +0,0 @@
-# Transparency Middleware
-
-## Overview
-
-The Transparency Middleware is a sophisticated agent interaction tracking system designed to capture, log, and analyze agent activities with comprehensive memory tracking and advanced security features.
-
-## Key Features
-
-- **Memory Capture:** Comprehensive logging of agent interactions
-- **Security:** Built-in data anonymization and payload filtering
-- **Performance:** Low-overhead, high-throughput event tracking
-- **Flexibility:** Configurable capture and logging strategies
-
-## Quick Start
-
-### Installation
-
-```bash
-npm install @claude-flow/transparency-middleware
-```
-
-### Basic Configuration
-
-Create a `config.json` in your project:
-
-```json
-{
-  "capture": {
-    "edit_operations": true,
-    "bash_commands": true,
-    "task_spawning": true
-  },
-  "security": {
-    "anonymize_sensitive_data": true,
-    "max_payload_size_bytes": 10240
-  },
-  "events": {
-    "emit_to_redis": true,
-    "emit_to_sqlite": true
-  }
-}
-```
-
-### Basic Usage
-
-```typescript
-import TransparencyMiddleware from '@claude-flow/transparency-middleware';
-
-const config = TransparencyMiddleware.loadConfig('./config.json');
-const middleware = new TransparencyMiddleware(config);
-
-await middleware.initialize();
-await middleware.captureAgentExecution('agent-id', agentOutput, 'task-id');
-await middleware.cleanup();
-```
-
-## Documentation
-
-For detailed usage, configuration, and troubleshooting, see [SKILL.md](SKILL.md).
-
-## Performance Characteristics
-
-- **Memory Overhead:** <50MB for 1000 events
-- **Storage:** ~1KB per high-value event
-- **Latency:** <5ms per event capture
-- **Throughput:** 1000+ events/sec
-
-## Contributing
-
-Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

package/claude-assets/skills/cfn-transparency-middleware/SKILL.md

@@ -1,99 +0,0 @@
----
-name: cfn-transparency-middleware
-description: Agent interaction capture, logging, and analysis with memory tracking and security
-version: 1.0.0
-tags: [middleware, logging, security, transparency, memory]
-status: production
----
-
-## Transparency Middleware
-
-### Overview
-The Transparency Middleware is a critical component of our agent orchestration system, designed to capture, log, and analyze agent interactions with comprehensive memory tracking and security features.
-
-## Testing
-
-### Unit Tests
-Run the comprehensive unit test suite:
-```bash
-npm test src/middleware/transparency-middleware.test.ts
-```
-
-**Coverage:** 95%+ on all core methods
-
-### Integration Tests
-Test middleware with CFN Loop orchestrator:
-```bash
-./.claude/skills/transparency-middleware/test-integration.sh
-```
-
-### End-to-End Tests
-Full lifecycle test with sample agent:
-```bash
-./.claude/skills/transparency-middleware/test-e2e.sh
-```
-
-## Usage Examples
-
-### Basic Usage
-```typescript
-import TransparencyMiddleware from './src/middleware/transparency-middleware.js';
-
-const config = TransparencyMiddleware.loadConfig('./.claude/skills/transparency-middleware/config.json');
-const middleware = new TransparencyMiddleware(config);
-
-await middleware.initialize();
-
-// Capture agent execution
-await middleware.captureAgentExecution('backend-dev', agentOutput, 'task-123');
-
-await middleware.cleanup();
-```
-
-### Wrapper Script Usage
-```bash
-# Wrap any agent execution with automatic memory capture
-./.claude/skills/transparency-middleware/wrap-agent.sh \
-  "backend-dev" \
-  "agent-1" \
-  "task-auth-impl" \
-  "implement authentication"
-```
-
-### Query Stored Memories
-```bash
-# Query all memories for a task
-./.claude/skills/transparency-middleware/query-memory.sh "task-auth-impl" "*" 100
-
-# Query specific agent's memories
-./.claude/skills/transparency-middleware/query-memory.sh "task-auth-impl" "backend-dev" 50
-```
-
-## Configuration Guide
-
-See `config.json` for all options. Key settings:
-
-- `capture.edit_operations` - Capture Edit/Write/MultiEdit tools
-- `capture.bash_commands` - Capture Bash commands
-- `capture.task_spawning` - Capture Task spawning
-- `security.anonymize_sensitive_data` - Redact secrets
-- `security.max_payload_size_bytes` - Limit event size
-
-## Troubleshooting
-
-**Issue:** Memory not being captured
-- Check `config.capture.*` filters
-- Verify SQLite database permissions
-- Enable debug logging
-
-**Issue:** Redis events not emitted
-- Check Redis connection (`redis-cli ping`)
-- Verify `config.events.emit_*` flags
-- Check channel name in config
-
-## Performance
-
-- **Memory overhead:** <50MB for 1000 events
-- **Storage:** ~1KB per high-value event
-- **Latency:** <5ms per event capture
-- **Throughput:** 1000+ events/sec

package/claude-assets/skills/cfn-transparency-middleware/config.json

@@ -1,31 +0,0 @@
-{
-  "redis": {
-    "host": "localhost",
-    "port": 6379,
-    "channel": "agent:transparency"
-  },
-  "storage": {
-    "database": ".claude/swarm-memory.db",
-    "table": "agent_memory"
-  },
-  "logging": {
-    "level": "info",
-    "format": "json",
-    "destination": "console"
-  },
-  "events": {
-    "emit_memory_store": true,
-    "emit_agent_lifecycle": true,
-    "emit_high_value_actions": true
-  },
-  "capture": {
-    "edit_operations": true,
-    "bash_commands": true,
-    "task_spawning": true,
-    "read_operations": false
-  },
-  "security": {
-    "anonymize_sensitive_data": true,
-    "max_payload_size_bytes": 1048576
-  }
-}