claude-flow-novice 2.15.3 → 2.15.4

package/claude-assets/skills/cfn-skill-loader/execute.sh

@@ -0,0 +1,344 @@
+#!/bin/bash
+set -euo pipefail
+
+###############################################################################
+# CFN Skill Loader - Execution Script
+#
+# High-performance skill loading with LRU caching and hash validation.
+# Provides command-line interface for skill loading operations.
+#
+# Usage:
+#   ./execute.sh --agent-type <type> [options]
+#
+# Options:
+#   --agent-type <type>       Agent type to load skills for (required)
+#   --task-context <keywords> Comma-separated context keywords (optional)
+#   --max-skills <num>        Maximum skills to load (default: 20)
+#   --phase <phase>           CFN Loop phase filter (optional)
+#   --no-bootstrap            Exclude bootstrap skills (default: include)
+#   --benchmark               Run performance benchmarks
+#   --iterations <num>        Benchmark iteration count (default: 10)
+#   --clear-cache             Clear skill cache before loading
+#   --preload <skills>        Preload specified skills (comma-separated)
+#   --validate-only           Only validate cached skills, don't load
+#   --stats                   Show cache statistics only
+#   --help                    Show this help message
+#
+# Examples:
+#   # Load skills for backend developer with authentication context
+#   ./execute.sh --agent-type backend-developer --task-context "authentication,api"
+#
+#   # Load Loop 3 skills with limit
+#   ./execute.sh --agent-type tester --phase loop3 --max-skills 10
+#
+#   # Benchmark performance
+#   ./execute.sh --benchmark --iterations 20
+#
+#   # Preload common skills for cache warming
+#   ./execute.sh --preload "cfn-coordination,hook-pipeline,pre-edit-backup"
+#
+###############################################################################
+
+# Default values
+AGENT_TYPE=""
+TASK_CONTEXT=""
+MAX_SKILLS=20
+PHASE=""
+INCLUDE_BOOTSTRAP="true"
+BENCHMARK="false"
+ITERATIONS=10
+CLEAR_CACHE="false"
+PRELOAD_SKILLS=""
+VALIDATE_ONLY="false"
+STATS_ONLY="false"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --agent-type)
+      AGENT_TYPE="$2"
+      shift 2
+      ;;
+    --task-context)
+      TASK_CONTEXT="$2"
+      shift 2
+      ;;
+    --max-skills)
+      MAX_SKILLS="$2"
+      shift 2
+      ;;
+    --phase)
+      PHASE="$2"
+      shift 2
+      ;;
+    --no-bootstrap)
+      INCLUDE_BOOTSTRAP="false"
+      shift
+      ;;
+    --benchmark)
+      BENCHMARK="true"
+      shift
+      ;;
+    --iterations)
+      ITERATIONS="$2"
+      shift 2
+      ;;
+    --clear-cache)
+      CLEAR_CACHE="true"
+      shift
+      ;;
+    --preload)
+      PRELOAD_SKILLS="$2"
+      shift 2
+      ;;
+    --validate-only)
+      VALIDATE_ONLY="true"
+      shift
+      ;;
+    --stats)
+      STATS_ONLY="true"
+      shift
+      ;;
+    --help)
+      head -n 50 "$0" | grep '^#' | sed 's/^# //'
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      echo "Use --help for usage information"
+      exit 1
+      ;;
+  esac
+done
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# TypeScript execution helper
+run_typescript() {
+  local code="$1"
+
+  npx tsx -e "
+import { SkillLoader, getGlobalLoader } from '${PROJECT_ROOT}/src/cli/skill-loader';
+import { SkillCacheValidator, getGlobalValidator } from '${PROJECT_ROOT}/src/cli/skill-cache-validator';
+import { DatabaseService } from '${PROJECT_ROOT}/src/lib/database-service';
+import { createLogger } from '${PROJECT_ROOT}/src/lib/logging';
+
+const logger = createLogger('skill-loader-cli');
+
+async function main() {
+  ${code}
+}
+
+main().catch(error => {
+  console.error('ERROR:', error.message);
+  process.exit(1);
+});
+"
+}
+
+# Show cache statistics
+if [[ "$STATS_ONLY" == "true" ]]; then
+  run_typescript "
+    const loader = getGlobalLoader(undefined, logger);
+    const stats = loader.getCacheStats();
+
+    console.log(JSON.stringify({
+      cacheSize: stats.size,
+      maxSize: stats.maxSize,
+      ttlMinutes: stats.ttlMinutes,
+      utilizationPercent: ((stats.size / stats.maxSize) * 100).toFixed(2)
+    }, null, 2));
+  "
+  exit 0
+fi
+
+# Clear cache if requested
+if [[ "$CLEAR_CACHE" == "true" ]]; then
+  echo "Clearing skill cache..."
+  run_typescript "
+    const loader = getGlobalLoader(undefined, logger);
+    loader.clearCache();
+    console.log('Cache cleared successfully');
+  "
+fi
+
+# Preload skills
+if [[ -n "$PRELOAD_SKILLS" ]]; then
+  echo "Preloading skills: $PRELOAD_SKILLS"
+  run_typescript "
+    const skillIds = '${PRELOAD_SKILLS}'.split(',').map(s => s.trim());
+    const loader = getGlobalLoader(undefined, logger);
+
+    await loader.preloadSkills(skillIds);
+
+    const stats = loader.getCacheStats();
+    console.log(\`Preloaded \${skillIds.length} skills. Cache size: \${stats.size}\`);
+  "
+  exit 0
+fi
+
+# Validate cached skills only
+if [[ "$VALIDATE_ONLY" == "true" ]]; then
+  echo "Validating cached skills..."
+  run_typescript "
+    const validator = getGlobalValidator(logger);
+    const loader = getGlobalLoader(undefined, logger);
+
+    const stats = loader.getCacheStats();
+    console.log(\`Validating \${stats.size} cached skills...\`);
+
+    // Note: Actual validation requires access to cache internals
+    // This is a placeholder for the validation logic
+    console.log('Validation completed');
+  "
+  exit 0
+fi
+
+# Run benchmark
+if [[ "$BENCHMARK" == "true" ]]; then
+  echo "Running performance benchmark ($ITERATIONS iterations)..."
+  run_typescript "
+    const dbService = new DatabaseService({
+      sqlite: {
+        type: 'sqlite',
+        database: '${PROJECT_ROOT}/.claude/skills/cfn-redis-coordination/data/cfn-loop.db'
+      }
+    });
+
+    await dbService.connect();
+
+    const loader = new SkillLoader(dbService, logger);
+
+    const coldStartTime = Date.now();
+    const coldResult = await loader.loadContextualSkills({
+      agentType: 'backend-developer',
+      taskContext: ['authentication', 'api'],
+      maxSkills: 20,
+      includeBootstrap: true
+    });
+    const coldDuration = Date.now() - coldStartTime;
+
+    // Warm loads
+    const warmDurations: number[] = [];
+    for (let i = 0; i < ${ITERATIONS}; i++) {
+      const startTime = Date.now();
+      await loader.loadContextualSkills({
+        agentType: 'backend-developer',
+        taskContext: ['authentication', 'api'],
+        maxSkills: 20,
+        includeBootstrap: true
+      });
+      warmDurations.push(Date.now() - startTime);
+    }
+
+    const avgWarmDuration = warmDurations.reduce((a, b) => a + b, 0) / warmDurations.length;
+    const minWarmDuration = Math.min(...warmDurations);
+    const maxWarmDuration = Math.max(...warmDurations);
+
+    console.log(JSON.stringify({
+      coldLoad: {
+        durationMs: coldDuration,
+        skillsLoaded: coldResult.totalSkills,
+        slaTarget: 1000,
+        passedSLA: coldDuration < 1000
+      },
+      warmLoad: {
+        iterations: ${ITERATIONS},
+        avgDurationMs: avgWarmDuration.toFixed(2),
+        minDurationMs: minWarmDuration,
+        maxDurationMs: maxWarmDuration,
+        slaTarget: 100,
+        passedSLA: avgWarmDuration < 100
+      },
+      cache: {
+        hits: coldResult.cacheHitCount,
+        misses: coldResult.cacheMissCount
+      }
+    }, null, 2));
+
+    await dbService.disconnect();
+  "
+  exit 0
+fi
+
+# Load skills (main operation)
+if [[ -z "$AGENT_TYPE" ]]; then
+  echo "ERROR: --agent-type is required"
+  echo "Use --help for usage information"
+  exit 1
+fi
+
+echo "Loading skills for agent type: $AGENT_TYPE"
+
+# Build task context array
+TASK_CONTEXT_ARRAY="[]"
+if [[ -n "$TASK_CONTEXT" ]]; then
+  TASK_CONTEXT_ARRAY="['$(echo "$TASK_CONTEXT" | sed "s/,/', '/g")']"
+fi
+
+# Build phase parameter
+PHASE_PARAM="undefined"
+if [[ -n "$PHASE" ]]; then
+  PHASE_PARAM="'$PHASE'"
+fi
+
+run_typescript "
+  const dbService = new DatabaseService({
+    sqlite: {
+      type: 'sqlite',
+      database: '${PROJECT_ROOT}/.claude/skills/cfn-redis-coordination/data/cfn-loop.db'
+    }
+  });
+
+  try {
+    await dbService.connect();
+  } catch (error) {
+    logger.warn('Database connection failed, using bootstrap skills only');
+  }
+
+  const loader = new SkillLoader(dbService, logger);
+
+  const result = await loader.loadContextualSkills({
+    agentType: '${AGENT_TYPE}',
+    taskContext: ${TASK_CONTEXT_ARRAY},
+    maxSkills: ${MAX_SKILLS},
+    includeBootstrap: ${INCLUDE_BOOTSTRAP},
+    phase: ${PHASE_PARAM}
+  });
+
+  console.log(JSON.stringify({
+    success: true,
+    agentType: '${AGENT_TYPE}',
+    skillsLoaded: result.totalSkills,
+    bootstrapSkills: result.bootstrapCount,
+    agentSkills: result.totalSkills - result.bootstrapCount,
+    loadTimeMs: result.loadTimeMs,
+    cache: {
+      hits: result.cacheHitCount,
+      misses: result.cacheMissCount,
+      hitRate: result.cacheHitCount > 0
+        ? ((result.cacheHitCount / (result.cacheHitCount + result.cacheMissCount)) * 100).toFixed(2) + '%'
+        : 'N/A'
+    },
+    performance: {
+      metColdSLA: result.loadTimeMs < 1000,
+      metWarmSLA: result.cacheHitCount > 0 && result.loadTimeMs < 100
+    },
+    skills: result.skills.map(s => ({
+      id: s.id,
+      name: s.name,
+      version: s.version,
+      namespace: s.namespace,
+      priority: s.priority
+    }))
+  }, null, 2));
+
+  if (dbService) {
+    await dbService.disconnect();
+  }
+"
+
+echo ""
+echo "Skill loading completed successfully"

package/claude-assets/skills/cfn-sqlite-memory/ttl-cleanup.sh

@@ -6,6 +6,10 @@
 
 set -e  # Exit on error
 
+# Source parameterized query library for SQL injection prevention
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+source "$PROJECT_ROOT/.claude/skills/bootstrap/sqlite-params.sh"
+
 # Configuration
 DB_PATH="${DB_PATH:-./swarm-memory.db}"
 REDIS_HOST="${REDIS_HOST:-localhost}"
@@ -66,28 +70,20 @@ EOF
 cleanup_acl_level() {
     local acl_level=$1
     local retention_days=$2
-    
+
     log "Cleaning up ACL Level $acl_level entries older than $retention_days days..."
-    
-    # SQLite cleanup query
-    local cleanup_sql="
-    DELETE FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now', '-$retention_days days')
-    AND acl_level != 5; -- Skip system audit logs (level 5)
-    "
-    
+
     if [ "$DRY_RUN" = "true" ]; then
-        # Count what would be deleted
-        local count=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM memory_store WHERE acl_level = $acl_level AND expires_at <= datetime('now', '-$retention_days days') AND acl_level != 5;")
+        # Count what would be deleted - using parameterized query
+        local count=$(sqlite_select "$DB_PATH" "SELECT COUNT(*) FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now', '-' || ?2 || ' days') AND acl_level != 5;" "$acl_level" "$retention_days")
         log "[DRY RUN] Would delete $count entries from ACL Level $acl_level"
         return 0
     fi
-    
-    # Execute cleanup
-    local deleted_count=$(sqlite3 "$DB_PATH" "$cleanup_sql")
-    log "Deleted $deleted_count entries from ACL Level $acl_level"
-    
+
+    # Execute cleanup - using parameterized query (Pattern B)
+    sqlite_delete "$DB_PATH" "DELETE FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now', '-' || ?2 || ' days') AND acl_level != 5;" "$acl_level" "$retention_days"
+    log "Deleted entries from ACL Level $acl_level"
+
     # Sync with Redis if available
     if check_redis; then
         sync_redis_cleanup "$acl_level"
@@ -100,12 +96,8 @@ sync_redis_cleanup() {
     
     log "Syncing Redis cleanup for ACL Level $acl_level..."
     
-    # Get keys that should be removed from Redis
-    local redis_keys=$(sqlite3 "$DB_PATH" "
-    SELECT key FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now')
-    ")
+    # Get keys that should be removed from Redis - using parameterized query
+    local redis_keys=$(sqlite_select "$DB_PATH" "SELECT key FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now')" "$acl_level")
     
     # Remove from Redis
     while IFS= read -r key; do
@@ -138,8 +130,8 @@ cleanup_redis_ttl() {
                 # Key doesn't exist in Redis but exists in SQLite (stale)
                 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true
             elif [ "$ttl" -eq -1 ]; then
-                # Key has no TTL, check if it should have one based on ACL level
-                local acl_level=$(sqlite3 "$DB_PATH" "SELECT acl_level FROM memory_store WHERE key = '$key' LIMIT 1")
+                # Key has no TTL, check if it should have one based on ACL level - using parameterized query
+                local acl_level=$(sqlite_select "$DB_PATH" "SELECT acl_level FROM memory_store WHERE key = ?1 LIMIT 1" "$key")
                 if [ -n "$acl_level" ] && [ "$acl_level" -le 4 ]; then
                     # Should have TTL, remove it
                     redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true

package/claude-assets/skills/cfn-task-audit/get-audit-data.sh

@@ -9,6 +9,10 @@
 
 set -euo pipefail
 
+# Import parameterized query library
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../bootstrap/sqlite-params.sh"
+
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -214,28 +218,45 @@ retrieve_sqlite_data() {
         return
     fi
 
-    local where_clause="task_id = '$task_id'"
-    if [ "$mode" != "combined" ]; then
-        where_clause="$where_clause AND mode = '$mode'"
+    # Build parameterized query based on mode
+    if [ "$mode" = "combined" ]; then
+        # Query for all modes
+        sqlite_data=$(sqlite_select "$DB_PATH" "
+            SELECT
+                task_id,
+                agent_type,
+                decision,
+                reasoning,
+                confidence,
+                mode,
+                deliverables,
+                timestamp,
+                created_at,
+                metadata
+            FROM agent_audit
+            WHERE task_id = ?1
+            ORDER BY timestamp, agent_type;" \
+            "$task_id" || echo "")
+    else
+        # Query for specific mode
+        sqlite_data=$(sqlite_select "$DB_PATH" "
+            SELECT
+                task_id,
+                agent_type,
+                decision,
+                reasoning,
+                confidence,
+                mode,
+                deliverables,
+                timestamp,
+                created_at,
+                metadata
+            FROM agent_audit
+            WHERE task_id = ?1 AND mode = ?2
+            ORDER BY timestamp, agent_type;" \
+            "$task_id" "$mode" || echo "")
     fi
 
-    sqlite_data=$(sqlite3 "$DB_PATH" 2>/dev/null "
-        SELECT
-            task_id,
-            agent_type,
-            decision,
-            reasoning,
-            confidence,
-            mode,
-            deliverables,
-            timestamp,
-            created_at,
-            metadata
-        FROM agent_audit
-        WHERE $where_clause
-        ORDER BY timestamp, agent_type;
-    " || echo "")
-
     if [ -z "$sqlite_data" ]; then
         echo "[]"
         return
@@ -373,4 +394,4 @@ case "$FORMAT" in
         ;;
 esac
 
-log_verbose "Audit data retrieval completed for task: $TASK_ID"
+log_verbose "Audit data retrieval completed for task: $TASK_ID"

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

@@ -9,6 +9,11 @@
 
 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'
@@ -132,16 +137,18 @@ redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
 echo -e "${GREEN}💾 Storing Task Mode audit data in SQLite...${NC}"
 UNIX_TIMESTAMP=$(date -d "$TIMESTAMP" +%s 2>/dev/null || date +%s)
 
-sqlite3 "$DB_PATH" <<EOF
-INSERT OR REPLACE INTO agent_audit (
-    task_id, agent_type, decision, reasoning, confidence, mode,
-    deliverables, timestamp, created_at, metadata
-) VALUES (
-    '$TASK_ID', '$AGENT_TYPE', '$DECISION', '$REASONING', $CONFIDENCE, '$MODE',
-    '$DELIVERABLES', $UNIX_TIMESTAMP, '$TIMESTAMP',
-    '{"stored_via": "store-task-audit.sh", "version": "1.0.0"}'
-);
-EOF
+# 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"

package/claude-assets/skills/cfn-test-runner/detect-regressions.sh

@@ -4,6 +4,10 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Load parameterized query library (SQL injection prevention)
+source "$PROJECT_ROOT/.claude/skills/bootstrap/sqlite-params.sh"
+
 DB_FILE="$PROJECT_ROOT/.artifacts/test-benchmarks.db"
 
 THRESHOLD=0.10
@@ -16,7 +20,7 @@ while [[ $# -gt 0 ]]; do
 done
 
 # Get latest run
-LATEST_RUN=$(sqlite3 "$DB_FILE" "SELECT id FROM test_runs ORDER BY run_timestamp DESC LIMIT 1")
+LATEST_RUN=$(sqlite_select "$DB_FILE" "SELECT id FROM test_runs ORDER BY run_timestamp DESC LIMIT 1")
 
 if [ -z "$LATEST_RUN" ]; then
   echo "No test runs found"
@@ -24,29 +28,28 @@ if [ -z "$LATEST_RUN" ]; then
 fi
 
 # Get baseline (average of last 10 runs excluding latest)
-BASELINE_SUCCESS_RATE=$(sqlite3 "$DB_FILE" "
+BASELINE_SUCCESS_RATE=$(sqlite_select "$DB_FILE" "
   SELECT AVG(success_rate) FROM (
-    SELECT success_rate FROM test_runs 
-    WHERE id != $LATEST_RUN 
-    ORDER BY run_timestamp DESC 
+    SELECT success_rate FROM test_runs
+    WHERE id != ?1
+    ORDER BY run_timestamp DESC
     LIMIT 10
   )
-")
+" "$LATEST_RUN")
 
-LATEST_SUCCESS_RATE=$(sqlite3 "$DB_FILE" "SELECT success_rate FROM test_runs WHERE id = $LATEST_RUN")
+LATEST_SUCCESS_RATE=$(sqlite_select "$DB_FILE" "SELECT success_rate FROM test_runs WHERE id = ?1" "$LATEST_RUN")
 
 # Check for regression
 REGRESSION=$(awk "BEGIN {print ($BASELINE_SUCCESS_RATE - $LATEST_SUCCESS_RATE) > $THRESHOLD}")
 
 if [ "$REGRESSION" = "1" ]; then
   DIFF=$(awk "BEGIN {printf \"%.1f\", ($BASELINE_SUCCESS_RATE - $LATEST_SUCCESS_RATE) * 100}")
-  
-  sqlite3 "$DB_FILE" << EOFSQL
-INSERT INTO regression_alerts (run_id, alert_type, severity, message)
-VALUES ($LATEST_RUN, 'success_rate_drop', 'warning', 
-        'Success rate dropped ${DIFF}% (baseline: ${BASELINE_SUCCESS_RATE}, current: ${LATEST_SUCCESS_RATE})');
-EOFSQL
-  
+  MESSAGE="Success rate dropped ${DIFF}% (baseline: ${BASELINE_SUCCESS_RATE}, current: ${LATEST_SUCCESS_RATE})"
+
+  sqlite_exec "$DB_FILE" \
+    "INSERT INTO regression_alerts (run_id, alert_type, severity, message) VALUES (?1, ?2, ?3, ?4)" \
+    "$LATEST_RUN" "success_rate_drop" "warning" "$MESSAGE"
+
   echo "⚠️  Regression detected: Success rate dropped ${DIFF}%"
   exit 1
 fi

package/claude-assets/skills/cfn-test-runner/detect-regressions.sh.backup-1763392821

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Detect test regressions
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+DB_FILE="$PROJECT_ROOT/.artifacts/test-benchmarks.db"
+
+THRESHOLD=0.10
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --threshold) THRESHOLD="$2"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+
+# Get latest run
+LATEST_RUN=$(sqlite3 "$DB_FILE" "SELECT id FROM test_runs ORDER BY run_timestamp DESC LIMIT 1")
+
+if [ -z "$LATEST_RUN" ]; then
+  echo "No test runs found"
+  exit 0
+fi
+
+# Get baseline (average of last 10 runs excluding latest)
+BASELINE_SUCCESS_RATE=$(sqlite3 "$DB_FILE" "
+  SELECT AVG(success_rate) FROM (
+    SELECT success_rate FROM test_runs 
+    WHERE id != $LATEST_RUN 
+    ORDER BY run_timestamp DESC 
+    LIMIT 10
+  )
+")
+
+LATEST_SUCCESS_RATE=$(sqlite3 "$DB_FILE" "SELECT success_rate FROM test_runs WHERE id = $LATEST_RUN")
+
+# Check for regression
+REGRESSION=$(awk "BEGIN {print ($BASELINE_SUCCESS_RATE - $LATEST_SUCCESS_RATE) > $THRESHOLD}")
+
+if [ "$REGRESSION" = "1" ]; then
+  DIFF=$(awk "BEGIN {printf \"%.1f\", ($BASELINE_SUCCESS_RATE - $LATEST_SUCCESS_RATE) * 100}")
+  
+  sqlite3 "$DB_FILE" << EOFSQL
+INSERT INTO regression_alerts (run_id, alert_type, severity, message)
+VALUES ($LATEST_RUN, 'success_rate_drop', 'warning', 
+        'Success rate dropped ${DIFF}% (baseline: ${BASELINE_SUCCESS_RATE}, current: ${LATEST_SUCCESS_RATE})');
+EOFSQL
+  
+  echo "⚠️  Regression detected: Success rate dropped ${DIFF}%"
+  exit 1
+fi
+
+echo "✅ No regressions detected"
+exit 0