aiox-core 5.0.2 → 5.0.3

package/pro/squads/squad-creator-pro/scripts/validate-squad.sh

@@ -0,0 +1,944 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════════════════════════
+# VALIDATE-SQUAD.SH - Hybrid Squad Validation Script
+# ═══════════════════════════════════════════════════════════════════════════════
+# Version: 3.0.0 - Production Validation
+# Compatibility: bash 3.2+ (macOS compatible)
+# Purpose: Hybrid validation - bash for deterministic, Claude for qualitative
+# Usage: ./validate-squad.sh <squad-name> [--verbose] [--quick] [--json]
+#
+# HYBRID APPROACH:
+#   BASH (deterministic):
+#     - File/directory existence
+#     - Security scan (grep patterns)
+#     - Cross-reference validation
+#     - Metrics collection (counts, ratios)
+#
+#   CLAUDE CLI (qualitative):
+#     - Prompt quality analysis
+#     - Pipeline coherence evaluation
+#     - Voice consistency check
+#     - Overall assessment & recommendations
+#
+# Exit codes:
+#   0 = PASS (score >= 7.0, no blocking issues)
+#   1 = FAIL (score < 7.0 or blocking issues)
+#   2 = ERROR (script error, invalid input)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+set -uo pipefail
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SQUAD_CREATOR_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+SQUADS_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)/squads"
+
+# Model configuration
+MODEL_DEFAULT="opus"    # Best quality (default)
+MODEL_FAST="haiku"      # Quick & cheap
+MODEL_QUALITY="$MODEL_DEFAULT"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+NC='\033[0m'
+BOLD='\033[1m'
+
+# Counters
+PASS_COUNT=0
+FAIL_COUNT=0
+WARN_COUNT=0
+
+# Results arrays
+BLOCKING_ISSUES=""
+WARNINGS=""
+
+# Metrics (simple variables for bash 3.x compatibility)
+M_AGENT_COUNT=0
+M_TASK_COUNT=0
+M_CHECKLIST_COUNT=0
+M_TEMPLATE_COUNT=0
+M_DATA_COUNT=0
+M_TOTAL_LINES=0
+M_SECURITY_ISSUES=0
+M_XREF_ISSUES=0
+M_SQUAD_TYPE="unknown"
+M_TYPE_CONFIDENCE=0
+M_PROMPT_QUALITY=0
+M_STRUCTURE_COHERENCE=0
+M_COVERAGE_SCORE=0
+M_DOCUMENTATION=0
+M_QUALITY_SCORE="N/A"
+M_IMPROVEMENTS=""
+M_PROD_SCORE=0
+
+# Phase results
+TIER1_FAIL=0
+SEC_FAIL=0
+XREF_FAIL=0
+PROD_SCORE=0
+PROD_MAX=5
+FINAL_SCORE=0
+ENTRY_AGENT=""
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ARGUMENT PARSING
+# ═══════════════════════════════════════════════════════════════════════════════
+
+show_help() {
+  cat << 'EOF'
+╔══════════════════════════════════════════════════════════════╗
+║       🔍 VALIDATE-SQUAD v2.0 - Hybrid Validation Tool        ║
+╚══════════════════════════════════════════════════════════════╝
+
+Usage: ./validate-squad.sh <squad-name> [options]
+
+Arguments:
+  squad-name    Name of squad to validate (e.g., "my-squad", "new-squad")
+
+Options:
+  --verbose     Show all checks and Claude analysis details
+  --quick       Skip Claude analysis (deterministic only)
+  --fast        Use Haiku instead of Opus (cheaper, faster)
+  --json        Output results as JSON
+  --help        Show this help message
+
+Examples:
+  ./validate-squad.sh {squad-name}              # Full validation with Opus
+  ./validate-squad.sh {squad-name} --verbose    # Verbose output
+  ./validate-squad.sh {squad-name} --quick      # Deterministic only (no Claude)
+  ./validate-squad.sh {squad-name} --fast       # Quick validation with Haiku
+
+Exit Codes:
+  0  PASS     Score >= 7.0, no blocking issues
+  1  FAIL     Score < 7.0 or blocking issues found
+  2  ERROR    Invalid input or script error
+
+EOF
+  exit 0
+}
+
+SQUAD_NAME=""
+VERBOSE=false
+QUICK_MODE=false
+JSON_OUTPUT=false
+FAST_MODE=false
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --help|-h)
+      show_help
+      ;;
+    --verbose|-v)
+      VERBOSE=true
+      shift
+      ;;
+    --quick|-q)
+      QUICK_MODE=true
+      shift
+      ;;
+    --fast|-f)
+      FAST_MODE=true
+      MODEL_QUALITY="$MODEL_FAST"
+      shift
+      ;;
+    --json|-j)
+      JSON_OUTPUT=true
+      shift
+      ;;
+    -*)
+      echo "Unknown option: $1"
+      exit 2
+      ;;
+    *)
+      SQUAD_NAME="$1"
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$SQUAD_NAME" ]]; then
+  echo "Error: Squad name required"
+  echo "Usage: ./validate-squad.sh <squad-name>"
+  exit 2
+fi
+
+SQUAD_DIR="$SQUADS_DIR/$SQUAD_NAME"
+
+if [[ ! -d "$SQUAD_DIR" ]]; then
+  echo "Error: Squad not found: $SQUAD_DIR"
+  exit 2
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# LOGGING HELPERS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+log_pass() {
+  PASS_COUNT=$((PASS_COUNT + 1))
+  if [[ "$VERBOSE" == "true" ]]; then
+    echo -e "  ${GREEN}✓${NC} $1"
+  fi
+}
+
+log_fail() {
+  FAIL_COUNT=$((FAIL_COUNT + 1))
+  echo -e "  ${RED}✗${NC} $1"
+  BLOCKING_ISSUES="${BLOCKING_ISSUES}${1}\n"
+}
+
+log_warn() {
+  WARN_COUNT=$((WARN_COUNT + 1))
+  echo -e "  ${YELLOW}⚠${NC} $1"
+  WARNINGS="${WARNINGS}${1}\n"
+}
+
+log_info() {
+  if [[ "$VERBOSE" == "true" ]]; then
+    echo -e "  ${CYAN}ℹ${NC} $1"
+  fi
+}
+
+log_section() {
+  echo ""
+  echo -e "${BOLD}${BLUE}═══ $1 ═══${NC}"
+}
+
+log_subsection() {
+  echo -e "${CYAN}--- $1 ---${NC}"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 1: STRUCTURE (Deterministic - Bash)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+check_structure() {
+  log_section "PHASE 1: Structure Validation (Bash)"
+  local tier1_fail=0
+
+  # 1.1 Config file
+  log_subsection "1.1 Configuration"
+  if [[ -f "$SQUAD_DIR/config.yaml" ]]; then
+    log_pass "config.yaml exists"
+
+    # Check for name (top-level or under pack:)
+    if grep -qE "^name:|^[[:space:]]+name:" "$SQUAD_DIR/config.yaml" 2>/dev/null; then
+      log_pass "config.yaml has 'name' field"
+    else
+      log_fail "config.yaml missing 'name' field"
+      tier1_fail=$((tier1_fail + 1))
+    fi
+
+    # Check for version (top-level or under pack:)
+    if grep -qE "^version:|^[[:space:]]+version:" "$SQUAD_DIR/config.yaml" 2>/dev/null; then
+      log_pass "config.yaml has 'version' field"
+    else
+      log_fail "config.yaml missing 'version' field"
+      tier1_fail=$((tier1_fail + 1))
+    fi
+
+    # Check for entry_agent (top-level, under pack:, or in agents list)
+    if grep -q "entry_agent:" "$SQUAD_DIR/config.yaml" 2>/dev/null; then
+      log_pass "config.yaml has 'entry_agent' field"
+      ENTRY_AGENT=$(grep "entry_agent:" "$SQUAD_DIR/config.yaml" | head -1 | sed 's/.*entry_agent:[[:space:]]*//' | tr -d '"' | tr -d "'" | xargs)
+    elif grep -qE "^[[:space:]]+- id:" "$SQUAD_DIR/config.yaml" 2>/dev/null; then
+      # Has agents list, extract first agent as entry point
+      ENTRY_AGENT=$(grep -E "^[[:space:]]+- id:" "$SQUAD_DIR/config.yaml" | head -1 | sed 's/.*- id:[[:space:]]*//' | tr -d '"' | tr -d "'" | xargs)
+      log_warn "No entry_agent defined, using first agent: $ENTRY_AGENT"
+    else
+      log_warn "config.yaml missing 'entry_agent' field (non-blocking)"
+    fi
+  else
+    log_fail "config.yaml not found"
+    tier1_fail=$((tier1_fail + 1))
+  fi
+
+  # 1.2 Entry agent
+  log_subsection "1.2 Entry Point"
+  if [[ -n "${ENTRY_AGENT:-}" ]]; then
+    if [[ -f "$SQUAD_DIR/agents/${ENTRY_AGENT}.md" ]]; then
+      log_pass "Entry agent exists: agents/${ENTRY_AGENT}.md"
+    else
+      log_fail "Entry agent not found: agents/${ENTRY_AGENT}.md"
+      tier1_fail=$((tier1_fail + 1))
+    fi
+  fi
+
+  # 1.3 Directory structure
+  log_subsection "1.3 Directory Structure"
+  local found_dirs=0
+  for dir in agents tasks checklists templates data; do
+    if [[ -d "$SQUAD_DIR/$dir" ]]; then
+      local count=$(find "$SQUAD_DIR/$dir" -type f \( -name "*.md" -o -name "*.yaml" -o -name "*.yml" \) 2>/dev/null | wc -l | tr -d ' ')
+      log_pass "$dir/ exists ($count files)"
+      found_dirs=$((found_dirs + 1))
+    else
+      log_info "$dir/ not found (optional)"
+    fi
+  done
+
+  # 1.4 Collect metrics
+  log_subsection "1.4 Metrics Collection"
+  M_AGENT_COUNT=$(find "$SQUAD_DIR/agents" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+  M_TASK_COUNT=$(find "$SQUAD_DIR/tasks" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+  M_CHECKLIST_COUNT=$(find "$SQUAD_DIR/checklists" -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+  M_TEMPLATE_COUNT=$(find "$SQUAD_DIR/templates" -type f 2>/dev/null | wc -l | tr -d ' ')
+  M_DATA_COUNT=$(find "$SQUAD_DIR/data" -type f 2>/dev/null | wc -l | tr -d ' ')
+  M_TOTAL_LINES=$(find "$SQUAD_DIR" -type f \( -name "*.md" -o -name "*.yaml" \) -exec cat {} + 2>/dev/null | wc -l | tr -d ' ')
+
+  log_info "Agents: $M_AGENT_COUNT, Tasks: $M_TASK_COUNT, Checklists: $M_CHECKLIST_COUNT"
+  log_info "Total lines: $M_TOTAL_LINES"
+
+  TIER1_FAIL=$tier1_fail
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 2: SECURITY SCAN (Deterministic - Bash)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+check_security() {
+  log_section "PHASE 2: Security Scan (Bash)"
+  local sec_fail=0
+
+  log_subsection "2.1 API Keys & Tokens"
+
+  # API Keys (excluding placeholders, examples, documentation, fake values)
+  local api_keys=$(grep -rE "(api[_-]?key|apikey)[[:space:]]*[:=][[:space:]]*['\"][^'\"\$\{]{8,}" "$SQUAD_DIR" 2>/dev/null | grep -vE "(\{\{|\\\$\{|process\.env|[Ee]xample|placeholder|grep|pattern|EXAMPLE|sk-1234|your-key|#.*api)" || true)
+  if [[ -n "$api_keys" ]]; then
+    log_fail "SEC-001: Potential API keys found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-001: No hardcoded API keys"
+  fi
+
+  # Secrets (excluding examples, documentation, fake values, obvious test secrets)
+  local secrets=$(grep -rE "(secret|password)[[:space:]]*[:=][[:space:]]*['\"][^'\"\$\{]{8,}" "$SQUAD_DIR" 2>/dev/null | grep -vE "(\{\{|\\\$\{|process\.env|[Ee]xample|placeholder|grep|pattern|EXAMPLE|secret_key|your-secret|#.*secret|#.*password|mySecret|super-secret|-secret-|-here)" || true)
+  if [[ -n "$secrets" ]]; then
+    log_fail "SEC-002: Potential secrets found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-002: No hardcoded secrets"
+  fi
+
+  log_subsection "2.2 Cloud Credentials"
+
+  # AWS Access Key (excluding examples, grep patterns, documentation)
+  local aws_access=$(grep -rE "AKIA[A-Z0-9]{16}" "$SQUAD_DIR" 2>/dev/null | grep -vE "(EXAMPLE|grep|pattern|\.sh:|\.md:.*grep)" || true)
+  if [[ -n "$aws_access" ]]; then
+    log_fail "SEC-003: AWS Access Key found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-003: No AWS Access Keys"
+  fi
+
+  # GCP Service Account
+  local gcp_key=$(grep -rE '"type"[[:space:]]*:[[:space:]]*"service_account"' "$SQUAD_DIR" 2>/dev/null || true)
+  if [[ -n "$gcp_key" ]]; then
+    log_fail "SEC-004: GCP Service Account found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-004: No GCP Service Accounts"
+  fi
+
+  log_subsection "2.3 Private Keys"
+
+  local priv_key=$(grep -rE "-----BEGIN.*(PRIVATE|RSA|DSA|EC).*KEY-----" "$SQUAD_DIR" 2>/dev/null || true)
+  if [[ -n "$priv_key" ]]; then
+    log_fail "SEC-005: Private key content found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-005: No private key content"
+  fi
+
+  local key_files=$(find "$SQUAD_DIR" -name "*.pem" -o -name "*.key" -o -name "id_rsa*" 2>/dev/null || true)
+  if [[ -n "$key_files" ]]; then
+    log_fail "SEC-006: Private key files found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-006: No private key files"
+  fi
+
+  log_subsection "2.4 Database & Sensitive Files"
+
+  # Exclude: placeholders, examples, documentation, localhost, generic passwords
+  local db_urls=$(grep -rE "(postgres|mysql|mongodb|redis)://[^:]+:[^@]+@" "$SQUAD_DIR" 2>/dev/null | grep -vE "(\{\{|\[PASSWORD\]|[Ee]xample|localhost|user:pass|:password@|:secret@|grep|pattern)" || true)
+  if [[ -n "$db_urls" ]]; then
+    log_fail "SEC-007: Database URL with password found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-007: No database URLs with passwords"
+  fi
+
+  local env_files=$(find "$SQUAD_DIR" -name ".env*" -o -name "*.env" 2>/dev/null || true)
+  if [[ -n "$env_files" ]]; then
+    log_fail "SEC-008: .env files found"
+    sec_fail=$((sec_fail + 1))
+  else
+    log_pass "SEC-008: No .env files"
+  fi
+
+  SEC_FAIL=$sec_fail
+  M_SECURITY_ISSUES=$sec_fail
+
+  if [[ $sec_fail -gt 0 ]]; then
+    echo -e "\n${RED}⚠️  SECURITY: $sec_fail HIGH severity issues${NC}"
+  else
+    echo -e "\n${GREEN}✓ Security scan passed${NC}"
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 3: CROSS-REFERENCE (Deterministic - Bash)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+check_cross_references() {
+  log_section "PHASE 3: Cross-Reference Validation (Bash)"
+  local xref_fail=0
+
+  log_subsection "3.1 Handoff Targets"
+
+  if [[ -d "$SQUAD_DIR/agents" ]]; then
+    for agent_file in "$SQUAD_DIR/agents"/*.md; do
+      [[ -f "$agent_file" ]] || continue
+      local handoffs=$(grep -oE "handoff_to:[[:space:]]*@?[a-z0-9_-]+" "$agent_file" 2>/dev/null | sed 's/handoff_to:[[:space:]]*@*//' || true)
+      for handoff in $handoffs; do
+        if [[ ! -f "$SQUAD_DIR/agents/${handoff}.md" ]]; then
+          log_fail "XREF-001: Handoff target not found: $handoff (in $(basename "$agent_file"))"
+          xref_fail=$((xref_fail + 1))
+        else
+          log_pass "XREF-001: Handoff valid: $handoff"
+        fi
+      done
+    done
+  fi
+
+  log_subsection "3.2 Task References"
+  # Check if tasks referenced in agents exist
+  if [[ -d "$SQUAD_DIR/agents" ]]; then
+    for agent_file in "$SQUAD_DIR/agents"/*.md; do
+      [[ -f "$agent_file" ]] || continue
+      local task_refs=$(grep -oE "\*[a-z0-9_-]+" "$agent_file" 2>/dev/null | sed 's/\*//' || true)
+      for task_ref in $task_refs; do
+        if [[ -f "$SQUAD_DIR/tasks/${task_ref}.md" ]]; then
+          log_pass "XREF-002: Task exists: $task_ref"
+        fi
+      done
+    done
+  fi
+
+  XREF_FAIL=$xref_fail
+  M_XREF_ISSUES=$xref_fail
+
+  if [[ $xref_fail -gt 0 ]]; then
+    echo -e "\n${RED}⚠️  CROSS-REF: $xref_fail broken references${NC}"
+  else
+    echo -e "\n${GREEN}✓ Cross-references valid${NC}"
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 4: SQUAD TYPE DETECTION (Deterministic - Bash)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+detect_squad_type() {
+  log_section "PHASE 4: Squad Type Detection (Bash)"
+
+  local type="general"
+  local confidence=5
+
+  # Check for Expert indicators
+  local has_voice_dna=$(find "$SQUAD_DIR" -name "*voice*" -o -name "*dna*" 2>/dev/null | wc -l | tr -d ' ')
+  local has_clone=$(grep -ril "clone\|emulat\|mind\|persona" "$SQUAD_DIR/agents" 2>/dev/null | wc -l | tr -d ' ')
+
+  # Check for Pipeline indicators
+  local has_workflow=$(find "$SQUAD_DIR" -path "*/workflows/*.yaml" 2>/dev/null | wc -l | tr -d ' ')
+  local has_phases=$(grep -ril "phase\|stage\|step" "$SQUAD_DIR/tasks" 2>/dev/null | wc -l | tr -d ' ')
+
+  # Calculate task ratio
+  local agent_count=${M_AGENT_COUNT:-1}
+  [[ $agent_count -eq 0 ]] && agent_count=1
+  local task_ratio=$((M_TASK_COUNT / agent_count))
+
+  # Check for Hybrid indicators
+  local has_human_exec=$(grep -ril "human\|manual\|executor" "$SQUAD_DIR" 2>/dev/null | wc -l | tr -d ' ')
+
+  # Scoring
+  local expert_score=0
+  local pipeline_score=0
+  local hybrid_score=0
+
+  [[ $has_voice_dna -gt 0 ]] && expert_score=$((expert_score + 3))
+  [[ $has_clone -gt 2 ]] && expert_score=$((expert_score + 2))
+
+  [[ $has_workflow -gt 0 ]] && pipeline_score=$((pipeline_score + 3))
+  [[ $has_phases -gt 3 ]] && pipeline_score=$((pipeline_score + 2))
+  [[ $task_ratio -gt 3 ]] && pipeline_score=$((pipeline_score + 2))
+
+  [[ $has_human_exec -gt 2 ]] && hybrid_score=$((hybrid_score + 3))
+
+  # Determine type
+  if [[ $expert_score -ge 4 ]]; then
+    type="expert"
+    confidence=$expert_score
+  elif [[ $pipeline_score -ge 4 ]]; then
+    type="pipeline"
+    confidence=$pipeline_score
+  elif [[ $hybrid_score -ge 3 ]]; then
+    type="hybrid"
+    confidence=$hybrid_score
+  fi
+
+  M_SQUAD_TYPE="$type"
+  M_TYPE_CONFIDENCE="$confidence"
+
+  log_info "Detected type: $type (confidence: $confidence)"
+  log_info "Expert signals: voice_dna=$has_voice_dna, clone_refs=$has_clone"
+  log_info "Pipeline signals: workflows=$has_workflow, phases=$has_phases, task_ratio=$task_ratio"
+  log_info "Hybrid signals: human_exec=$has_human_exec"
+
+  echo -e "\n${CYAN}Squad Type: ${BOLD}$type${NC} (confidence: $confidence/7)"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 5: PRODUCTION VALIDATION (Deterministic - Bash)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+check_production() {
+  log_section "PHASE 5: Production Validation (Bash)"
+  local prod_score=0
+
+  log_subsection "5.1 Outputs Directory"
+  # Check for outputs/ in squad or in global outputs/
+  local has_outputs=false
+  if [ -d "$SQUAD_DIR/outputs" ]; then
+    local output_count=$(find "$SQUAD_DIR/outputs" -type f 2>/dev/null | wc -l | tr -d ' ')
+    if [ "$output_count" -gt 0 ]; then
+      log_pass "outputs/ exists with $output_count files"
+      has_outputs=true
+      prod_score=$((prod_score + 2))
+    else
+      log_warn "outputs/ exists but is empty"
+    fi
+  else
+    # Check global outputs directory for this squad (uses env var or relative path)
+    local global_outputs="${OUTPUTS_DIR:-./outputs}"
+    if [ -d "$global_outputs" ]; then
+      local squad_outputs=$(find "$global_outputs" -type d -name "*$SQUAD_NAME*" 2>/dev/null | head -1)
+      if [ -n "$squad_outputs" ] && [ -d "$squad_outputs" ]; then
+        local output_count=$(find "$squad_outputs" -type f 2>/dev/null | wc -l | tr -d ' ')
+        if [ "$output_count" -gt 0 ]; then
+          log_pass "Found outputs in global directory ($output_count files)"
+          has_outputs=true
+          prod_score=$((prod_score + 2))
+        fi
+      fi
+    fi
+
+    if [ "$has_outputs" = false ]; then
+      log_warn "No outputs/ directory found - squad not tested in production"
+    fi
+  fi
+
+  log_subsection "5.2 Tested Flag"
+  # Check for tested: true in config.yaml
+  if grep -qE "^tested:[[:space:]]*(true|yes)" "$SQUAD_DIR/config.yaml" 2>/dev/null; then
+    log_pass "config.yaml has tested: true"
+    prod_score=$((prod_score + 1))
+  else
+    log_warn "config.yaml missing 'tested: true' flag"
+  fi
+
+  log_subsection "5.3 Usage Evidence"
+  # Check for YOLO mode state files (real automation usage, not just creation logs)
+  local state_files=$(find "$SQUAD_DIR" -name "*-state.json" -o -name "progress.txt" -o -name "handoff.md" 2>/dev/null | wc -l | tr -d ' ')
+  if [ "$state_files" -gt 0 ]; then
+    # Verify it's real usage, not just template files
+    local real_state=$(find "$SQUAD_DIR" -name "*-state.json" -exec grep -l '"status"' {} \; 2>/dev/null | wc -l | tr -d ' ')
+    if [ "$real_state" -gt 0 ]; then
+      log_pass "Found $real_state state files with execution history (YOLO mode)"
+      prod_score=$((prod_score + 1))
+    else
+      log_warn "State files found but appear to be templates"
+    fi
+  else
+    log_warn "No YOLO mode state files found"
+  fi
+
+  # Check for user feedback or validation reports
+  local feedback_files=$(find "$SQUAD_DIR" -name "*feedback*" -o -name "*validation-report*" -o -name "*qa-report*" 2>/dev/null | wc -l | tr -d ' ')
+  if [ "$feedback_files" -gt 0 ]; then
+    log_pass "Found $feedback_files feedback/validation files"
+    prod_score=$((prod_score + 1))
+  fi
+
+  log_subsection "5.4 Sample Outputs"
+  # Check for example outputs in docs or templates
+  local has_examples=false
+  if [ -d "$SQUAD_DIR/examples" ] || [ -d "$SQUAD_DIR/samples" ]; then
+    log_pass "examples/ or samples/ directory exists"
+    has_examples=true
+    prod_score=$((prod_score + 1))
+  fi
+
+  # Check for output_examples in agents
+  local output_examples=$(grep -rl "output_examples\|example_output\|sample_output" "$SQUAD_DIR/agents" 2>/dev/null | wc -l | tr -d ' ')
+  if [ "$output_examples" -gt 0 ]; then
+    log_pass "Found output examples in $output_examples agent files"
+    if [ "$has_examples" = false ]; then
+      prod_score=$((prod_score + 1))
+    fi
+  fi
+
+  if [ "$has_examples" = false ] && [ "$output_examples" -eq 0 ]; then
+    log_warn "No sample outputs or examples found"
+  fi
+
+  # Cap at max
+  if [ $prod_score -gt $PROD_MAX ]; then
+    prod_score=$PROD_MAX
+  fi
+
+  PROD_SCORE=$prod_score
+  M_PROD_SCORE=$prod_score
+
+  echo ""
+  if [ $prod_score -eq 0 ]; then
+    echo -e "${RED}⚠️  PRODUCTION: 0/$PROD_MAX - No evidence of real usage${NC}"
+    echo -e "${YELLOW}   Max possible score without production evidence: 5/10${NC}"
+  elif [ $prod_score -lt 3 ]; then
+    echo -e "${YELLOW}⚠️  PRODUCTION: $prod_score/$PROD_MAX - Limited production evidence${NC}"
+  else
+    echo -e "${GREEN}✓ Production validation: $prod_score/$PROD_MAX${NC}"
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 6: QUALITY ANALYSIS (Claude CLI)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+analyze_with_claude() {
+  log_section "PHASE 6: Quality Analysis (Claude CLI)"
+
+  if [[ "$QUICK_MODE" == "true" ]]; then
+    echo -e "${YELLOW}Skipping Claude analysis (--quick mode)${NC}"
+    M_QUALITY_SCORE="N/A"
+    return 0
+  fi
+
+  echo -e "${MAGENTA}Running Claude analysis with $MODEL_QUALITY...${NC}"
+
+  # Collect sample files for analysis
+  local sample_agent=$(find "$SQUAD_DIR/agents" -name "*.md" 2>/dev/null | head -1)
+  local sample_task=$(find "$SQUAD_DIR/tasks" -name "*.md" 2>/dev/null | head -1)
+  local sample_checklist=$(find "$SQUAD_DIR/checklists" -name "*.md" 2>/dev/null | head -1)
+
+  local agent_content=""
+  local task_content=""
+  local checklist_content=""
+
+  [[ -f "$sample_agent" ]] && agent_content=$(head -100 "$sample_agent" 2>/dev/null || true)
+  [[ -f "$sample_task" ]] && task_content=$(head -100 "$sample_task" 2>/dev/null || true)
+  [[ -f "$sample_checklist" ]] && checklist_content=$(head -100 "$sample_checklist" 2>/dev/null || true)
+
+  # Build analysis prompt
+  local ANALYSIS_PROMPT="You are evaluating the quality of an AIOS squad. Analyze and provide a JSON response.
+
+## Squad: $SQUAD_NAME
+Type: $M_SQUAD_TYPE
+
+## Metrics
+- Agents: $M_AGENT_COUNT
+- Tasks: $M_TASK_COUNT
+- Checklists: $M_CHECKLIST_COUNT
+- Total lines: $M_TOTAL_LINES
+
+## Sample Agent (first 100 lines):
+\`\`\`
+$agent_content
+\`\`\`
+
+## Sample Task (first 100 lines):
+\`\`\`
+$task_content
+\`\`\`
+
+## Sample Checklist (first 100 lines):
+\`\`\`
+$checklist_content
+\`\`\`
+
+## Evaluation Criteria
+1. **Prompt Quality (0-10)**: Are prompts specific, actionable, with examples?
+2. **Structure Coherence (0-10)**: Do agents/tasks/checklists follow consistent patterns?
+3. **Coverage (0-10)**: Does the squad have appropriate agent:task ratios for its type?
+4. **Documentation (0-10)**: Are purposes, inputs, outputs clearly defined?
+
+## Required Response Format (JSON only):
+{
+  \"prompt_quality\": 8,
+  \"structure_coherence\": 7,
+  \"coverage\": 9,
+  \"documentation\": 6,
+  \"overall_score\": 7.5,
+  \"strengths\": [\"clear prompts\", \"good task coverage\"],
+  \"improvements\": [\"add more examples\", \"document edge cases\"],
+  \"recommendation\": \"PASS\"
+}
+
+Respond with ONLY the JSON, no other text."
+
+  # Run Claude
+  local claude_output
+  if claude_output=$(claude -p --model "$MODEL_QUALITY" --dangerously-skip-permissions "$ANALYSIS_PROMPT" 2>&1); then
+    # Extract JSON from response (handle multiline)
+    local json_result=$(echo "$claude_output" | tr '\n' ' ' | grep -oE '\{[^}]+\}' | head -1 || echo '{}')
+
+    if [[ "$VERBOSE" == "true" ]]; then
+      echo -e "\n${CYAN}Claude Analysis Result:${NC}"
+      echo "$json_result" | jq '.' 2>/dev/null || echo "$json_result"
+    fi
+
+    # Parse scores using jq
+    if command -v jq &> /dev/null; then
+      M_PROMPT_QUALITY=$(echo "$json_result" | jq -r '.prompt_quality // 0' 2>/dev/null || echo "0")
+      M_STRUCTURE_COHERENCE=$(echo "$json_result" | jq -r '.structure_coherence // 0' 2>/dev/null || echo "0")
+      M_COVERAGE_SCORE=$(echo "$json_result" | jq -r '.coverage // 0' 2>/dev/null || echo "0")
+      M_DOCUMENTATION=$(echo "$json_result" | jq -r '.documentation // 0' 2>/dev/null || echo "0")
+      M_QUALITY_SCORE=$(echo "$json_result" | jq -r '.overall_score // 0' 2>/dev/null || echo "0")
+      M_IMPROVEMENTS=$(echo "$json_result" | jq -r '.improvements | join("; ")' 2>/dev/null || echo "")
+    else
+      # Fallback without jq - basic parsing
+      M_QUALITY_SCORE=$(echo "$json_result" | grep -oE '"overall_score"[[:space:]]*:[[:space:]]*[0-9.]+' | grep -oE '[0-9.]+$' || echo "0")
+    fi
+
+    echo -e "\n${GREEN}✓ Claude analysis complete${NC}"
+    echo -e "  Quality Score: ${BOLD}${M_QUALITY_SCORE}/10${NC}"
+
+  else
+    echo -e "${YELLOW}⚠️  Claude analysis failed, using deterministic score only${NC}"
+    M_QUALITY_SCORE="N/A"
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# PHASE 6: FINAL SCORING & REPORT
+# ═══════════════════════════════════════════════════════════════════════════════
+
+calculate_final_score() {
+  log_section "PHASE 7: Final Scoring"
+
+  local base_score=10
+  local total_fails=$((TIER1_FAIL + SEC_FAIL + XREF_FAIL))
+
+  # Deduct for failures (1.5 per failure)
+  local fail_penalty=$((total_fails * 15 / 10))
+  # Deduct for warnings (0.3 per warning)
+  local warn_penalty=$((WARN_COUNT * 3 / 10))
+
+  # Calculate structure score (0-10)
+  local struct_score=$((base_score - fail_penalty - warn_penalty))
+  [ $struct_score -lt 0 ] && struct_score=0
+
+  # Get Claude quality score (0-10)
+  local quality_int=0
+  if [[ "$M_QUALITY_SCORE" != "N/A" && "$M_QUALITY_SCORE" != "0" && -n "$M_QUALITY_SCORE" ]]; then
+    quality_int=${M_QUALITY_SCORE%.*}
+    [[ -z "$quality_int" || "$quality_int" == "0" ]] && quality_int=7  # Default if parsing failed
+  else
+    quality_int=7  # Default assumption if Claude failed
+  fi
+
+  # Production score is 0-5, normalize to 0-10
+  local prod_normalized=$((PROD_SCORE * 2))
+
+  # SCORING FORMULA:
+  # - Structure/Security: 20%
+  # - Quality (Claude): 30%
+  # - Production: 50% (most important - real usage matters most)
+  FINAL_SCORE=$(( (struct_score * 20 + quality_int * 30 + prod_normalized * 50) / 100 ))
+
+  # CAPS based on production evidence:
+  # - No production (0/5): MAX 5/10
+  # - Minimal (1-2/5): MAX 7/10
+  # - Good (3-4/5): MAX 9/10
+  # - Full (5/5): MAX 10/10
+  if [ "$PROD_SCORE" -eq 0 ]; then
+    [ "$FINAL_SCORE" -gt 5 ] && FINAL_SCORE=5
+  elif [ "$PROD_SCORE" -lt 3 ]; then
+    [ "$FINAL_SCORE" -gt 7 ] && FINAL_SCORE=7
+  elif [ "$PROD_SCORE" -lt 5 ]; then
+    [ "$FINAL_SCORE" -gt 9 ] && FINAL_SCORE=9
+  fi
+
+  # Ensure score is in range 0-10
+  [ $FINAL_SCORE -lt 0 ] && FINAL_SCORE=0
+  [ $FINAL_SCORE -gt 10 ] && FINAL_SCORE=10
+}
+
+generate_report() {
+  local result="FAIL"
+  local result_color=$RED
+
+  if [[ $FINAL_SCORE -ge 7 ]] && [[ -z "$BLOCKING_ISSUES" ]]; then
+    result="PASS"
+    result_color=$GREEN
+  elif [[ $FINAL_SCORE -ge 5 ]]; then
+    result="CONDITIONAL"
+    result_color=$YELLOW
+  fi
+
+  if [[ "$JSON_OUTPUT" == "true" ]]; then
+    cat << EOF
+{
+  "squad": "$SQUAD_NAME",
+  "result": "$result",
+  "final_score": $FINAL_SCORE,
+  "type": "$M_SQUAD_TYPE",
+  "metrics": {
+    "agents": $M_AGENT_COUNT,
+    "tasks": $M_TASK_COUNT,
+    "checklists": $M_CHECKLIST_COUNT,
+    "total_lines": $M_TOTAL_LINES
+  },
+  "deterministic": {
+    "tier1_fail": $TIER1_FAIL,
+    "security_fail": $SEC_FAIL,
+    "xref_fail": $XREF_FAIL,
+    "warnings": $WARN_COUNT
+  },
+  "production": {
+    "score": $PROD_SCORE,
+    "max": $PROD_MAX
+  },
+  "claude_analysis": {
+    "prompt_quality": $M_PROMPT_QUALITY,
+    "structure_coherence": $M_STRUCTURE_COHERENCE,
+    "coverage": $M_COVERAGE_SCORE,
+    "documentation": $M_DOCUMENTATION,
+    "quality_score": "$M_QUALITY_SCORE"
+  },
+  "improvements": "$M_IMPROVEMENTS"
+}
+EOF
+  else
+    echo ""
+    echo -e "${BOLD}╔══════════════════════════════════════════════════════════════╗${NC}"
+    if [[ "$result" == "PASS" ]]; then
+      echo -e "${BOLD}║${result_color}                    ✅ VALIDATION PASSED                      ${NC}${BOLD}║${NC}"
+    elif [[ "$result" == "CONDITIONAL" ]]; then
+      echo -e "${BOLD}║${result_color}                   ⚠️  CONDITIONAL PASS                       ${NC}${BOLD}║${NC}"
+    else
+      echo -e "${BOLD}║${result_color}                    ❌ VALIDATION FAILED                      ${NC}${BOLD}║${NC}"
+    fi
+    echo -e "${BOLD}╚══════════════════════════════════════════════════════════════╝${NC}"
+    echo ""
+    echo -e "  Squad: ${BOLD}$SQUAD_NAME${NC}"
+    echo -e "  Type: ${CYAN}$M_SQUAD_TYPE${NC}"
+    echo -e "  Final Score: ${BOLD}${result_color}$FINAL_SCORE/10${NC}"
+    echo ""
+    echo "  ┌─────────────────────────────────────────┐"
+    echo "  │ Structure & Security (20%)              │"
+    printf "  │   Structure failures: %-17s│\n" "$TIER1_FAIL"
+    printf "  │   Security issues: %-19s│\n" "$SEC_FAIL"
+    printf "  │   Cross-ref broken: %-18s│\n" "$XREF_FAIL"
+    printf "  │   Warnings: %-26s│\n" "$WARN_COUNT"
+    echo "  └─────────────────────────────────────────┘"
+
+    echo "  ┌─────────────────────────────────────────┐"
+    echo "  │ Production Evidence (50%)               │"
+    if [ "$PROD_SCORE" -eq 0 ]; then
+      printf "  │   ${RED}Score: %-32s${NC}│\n" "$PROD_SCORE/$PROD_MAX ⚠️  NOT TESTED"
+    elif [ "$PROD_SCORE" -lt 3 ]; then
+      printf "  │   ${YELLOW}Score: %-32s${NC}│\n" "$PROD_SCORE/$PROD_MAX (limited)"
+    else
+      printf "  │   ${GREEN}Score: %-32s${NC}│\n" "$PROD_SCORE/$PROD_MAX ✓"
+    fi
+    echo "  └─────────────────────────────────────────┘"
+
+    if [[ "$M_QUALITY_SCORE" != "N/A" ]]; then
+      echo "  ┌─────────────────────────────────────────┐"
+      echo "  │ Claude Quality Analysis (30%)          │"
+      printf "  │   Prompt Quality: %-20s│\n" "$M_PROMPT_QUALITY/10"
+      printf "  │   Structure: %-25s│\n" "$M_STRUCTURE_COHERENCE/10"
+      printf "  │   Coverage: %-26s│\n" "$M_COVERAGE_SCORE/10"
+      printf "  │   Documentation: %-21s│\n" "$M_DOCUMENTATION/10"
+      echo "  └─────────────────────────────────────────┘"
+    fi
+
+    if [[ -n "$BLOCKING_ISSUES" ]]; then
+      echo ""
+      echo -e "  ${RED}Blocking Issues:${NC}"
+      echo -e "$BLOCKING_ISSUES" | while read -r issue; do
+        [[ -n "$issue" ]] && echo -e "    ${RED}•${NC} $issue"
+      done
+    fi
+
+    if [[ -n "$M_IMPROVEMENTS" ]]; then
+      echo ""
+      echo -e "  ${YELLOW}Improvements:${NC}"
+      echo "    $M_IMPROVEMENTS"
+    fi
+    echo ""
+  fi
+
+  # Return appropriate exit code
+  if [[ "$result" == "PASS" ]]; then
+    exit 0
+  else
+    exit 1
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MAIN EXECUTION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+main() {
+  echo ""
+  echo -e "${BOLD}╔══════════════════════════════════════════════════════════════╗${NC}"
+  echo -e "${BOLD}║         🔍 VALIDATE-SQUAD v2.0 - Hybrid Validation           ║${NC}"
+  echo -e "${BOLD}╚══════════════════════════════════════════════════════════════╝${NC}"
+  echo ""
+  echo -e "  Squad: ${CYAN}$SQUAD_NAME${NC}"
+  echo -e "  Path: $SQUAD_DIR"
+  if [[ "$QUICK_MODE" == "true" ]]; then
+    echo -e "  Mode: quick (no Claude)"
+  else
+    echo -e "  Mode: hybrid"
+  fi
+  echo -e "  Model: $MODEL_QUALITY"
+
+  # Phase 1: Structure (Bash)
+  check_structure
+
+  # Phase 2: Security (Bash)
+  check_security
+
+  # Phase 3: Cross-references (Bash)
+  check_cross_references
+
+  # Phase 4: Type detection (Bash)
+  detect_squad_type
+
+  # Phase 5: Production validation (Bash) - NEW
+  check_production
+
+  # Phase 6: Quality analysis (Claude CLI)
+  analyze_with_claude
+
+  # Phase 7: Final scoring
+  calculate_final_score
+
+  # Generate report
+  generate_report
+}
+
+# Run
+main