#!/usr/bin/env bash
# test-skill-injection.sh — Verify Dynamic Skill Injection System
# Tests: skill registry, issue type classification, retry context, two-stage review
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ORIGINAL_PATH="$PATH"
PASS=0
FAIL=0
ERRORS=""

# ─── Helpers ──────────────────────────────────────────────────────────────────

pass() { PASS=$((PASS + 1)); printf "  ✓ %s\n" "$1"; }
fail() { FAIL=$((FAIL + 1)); ERRORS="${ERRORS}\n  ✗ $1"; printf "  \033[31m✗ %s\033[0m\n" "$1"; }

assert_eq() {
    local actual="$1" expected="$2" msg="$3"
    if [[ "$actual" == "$expected" ]]; then
        pass "$msg"
    else
        fail "$msg (expected '$expected', got '$actual')"
    fi
}

assert_contains() {
    local haystack="$1" needle="$2" msg="$3"
    if echo "$haystack" | grep -q "$needle" 2>/dev/null; then
        pass "$msg"
    else
        fail "$msg (expected to contain '$needle')"
    fi
}

assert_not_empty() {
    local val="$1" msg="$2"
    if [[ -n "$val" ]]; then
        pass "$msg"
    else
        fail "$msg (was empty)"
    fi
}

assert_file_exists() {
    local path="$1" msg="$2"
    if [[ -f "$path" ]]; then
        pass "$msg"
    else
        fail "$msg (file not found: $path)"
    fi
}

assert_exit_zero() {
    local msg="$1"
    shift
    if "$@" >/dev/null 2>&1; then
        pass "$msg"
    else
        fail "$msg (exit code: $?)"
    fi
}

assert_exit_nonzero() {
    local msg="$1"
    shift
    if "$@" >/dev/null 2>&1; then
        fail "$msg (expected non-zero exit, got 0)"
    else
        pass "$msg"
    fi
}

assert_true() {
    local expr="$1" msg="$2"
    if eval "$expr" 2>/dev/null; then
        pass "$msg"
    else
        fail "$msg (expression was false)"
    fi
}

assert_not_contains() {
    local haystack="$1" needle="$2" msg="$3"
    if echo "$haystack" | grep -q "$needle" 2>/dev/null; then
        fail "$msg (should NOT contain '$needle')"
    else
        pass "$msg"
    fi
}

# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 1: Skill Registry
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 1: Skill Registry ═══"

source "$SCRIPT_DIR/lib/skill-registry.sh"

# --- skill_get_prompts: plan stage ---
echo ""
echo "  ── Plan stage mappings ──"

plan_frontend=$(skill_get_prompts "frontend" "plan")
assert_contains "$plan_frontend" "brainstorming.md" "frontend/plan includes brainstorming"
assert_contains "$plan_frontend" "frontend-design.md" "frontend/plan includes frontend-design"
assert_contains "$plan_frontend" "product-thinking.md" "frontend/plan includes product-thinking"

plan_api=$(skill_get_prompts "api" "plan")
assert_contains "$plan_api" "brainstorming.md" "api/plan includes brainstorming"
assert_contains "$plan_api" "api-design.md" "api/plan includes api-design"

plan_database=$(skill_get_prompts "database" "plan")
assert_contains "$plan_database" "brainstorming.md" "database/plan includes brainstorming"
assert_contains "$plan_database" "data-pipeline.md" "database/plan includes data-pipeline"

plan_security=$(skill_get_prompts "security" "plan")
assert_contains "$plan_security" "brainstorming.md" "security/plan includes brainstorming"
assert_contains "$plan_security" "security-audit.md" "security/plan includes security-audit"

plan_performance=$(skill_get_prompts "performance" "plan")
assert_contains "$plan_performance" "brainstorming.md" "performance/plan includes brainstorming"
assert_contains "$plan_performance" "performance.md" "performance/plan includes performance"

plan_testing=$(skill_get_prompts "testing" "plan")
assert_contains "$plan_testing" "testing-strategy.md" "testing/plan includes testing-strategy"

plan_docs=$(skill_get_prompts "documentation" "plan")
assert_contains "$plan_docs" "documentation.md" "documentation/plan includes documentation"

plan_backend=$(skill_get_prompts "backend" "plan")
assert_contains "$plan_backend" "brainstorming.md" "backend/plan includes brainstorming"

plan_refactor=$(skill_get_prompts "refactor" "plan")
assert_contains "$plan_refactor" "brainstorming.md" "refactor/plan includes brainstorming"

plan_infra=$(skill_get_prompts "infrastructure" "plan")
assert_contains "$plan_infra" "brainstorming.md" "infrastructure/plan includes brainstorming"

# --- skill_get_prompts: build stage ---
echo ""
echo "  ── Build stage mappings ──"

build_frontend=$(skill_get_prompts "frontend" "build")
assert_contains "$build_frontend" "frontend-design.md" "frontend/build includes frontend-design"

build_api=$(skill_get_prompts "api" "build")
assert_contains "$build_api" "api-design.md" "api/build includes api-design"

build_security=$(skill_get_prompts "security" "build")
assert_contains "$build_security" "security-audit.md" "security/build includes security-audit"

build_backend=$(skill_get_prompts "backend" "build")
assert_eq "$build_backend" "" "backend/build returns no skills (empty)"

build_refactor=$(skill_get_prompts "refactor" "build")
assert_eq "$build_refactor" "" "refactor/build returns no skills (empty)"

# --- skill_get_prompts: review stage ---
echo ""
echo "  ── Review stage mappings ──"

review_frontend=$(skill_get_prompts "frontend" "review")
assert_contains "$review_frontend" "two-stage-review.md" "frontend/review includes two-stage-review"

review_api=$(skill_get_prompts "api" "review")
assert_contains "$review_api" "two-stage-review.md" "api/review includes two-stage-review"
assert_contains "$review_api" "security-audit.md" "api/review includes security-audit"

review_security=$(skill_get_prompts "security" "review")
assert_contains "$review_security" "two-stage-review.md" "security/review includes two-stage-review"
assert_contains "$review_security" "security-audit.md" "security/review includes security-audit"

review_docs=$(skill_get_prompts "documentation" "review")
assert_eq "$review_docs" "" "documentation/review returns no skills (empty)"

# --- skill_get_prompts: unknown stage ---
echo ""
echo "  ── Edge cases ──"

unknown_stage=$(skill_get_prompts "frontend" "nonexistent_stage")
assert_eq "$unknown_stage" "" "unknown stage returns empty"

unknown_type=$(skill_get_prompts "aliens" "plan")
assert_contains "$unknown_type" "brainstorming.md" "unknown type defaults to brainstorming in plan"

# --- skill_load_prompts ---
echo ""
echo "  ── skill_load_prompts ──"

loaded_frontend=$(skill_load_prompts "frontend" "plan")
assert_contains "$loaded_frontend" "Socratic Design Refinement" "frontend/plan loads brainstorming content"
assert_contains "$loaded_frontend" "Accessibility" "frontend/plan loads frontend-design content"
assert_contains "$loaded_frontend" "User Stories" "frontend/plan loads product-thinking content"

loaded_backend_build=$(skill_load_prompts "backend" "build")
assert_eq "$loaded_backend_build" "" "backend/build loads no content (empty)"

loaded_api_review=$(skill_load_prompts "api" "review")
assert_contains "$loaded_api_review" "Two-Stage Code Review" "api/review loads two-stage-review content"
assert_contains "$loaded_api_review" "OWASP" "api/review loads security-audit content"

# --- skill_has_two_stage_review ---
echo ""
echo "  ── skill_has_two_stage_review ──"

assert_exit_zero "frontend has two-stage review" skill_has_two_stage_review "frontend"
assert_exit_zero "api has two-stage review" skill_has_two_stage_review "api"
assert_exit_zero "backend has two-stage review" skill_has_two_stage_review "backend"
assert_exit_zero "security has two-stage review" skill_has_two_stage_review "security"
assert_exit_nonzero "documentation has NO two-stage review" skill_has_two_stage_review "documentation"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 2: Issue Type Classification (Fallback Heuristic)
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 2: Issue Type Classification ═══"

# We need to source sw-intelligence.sh to get _intelligence_fallback_analyze.
# It requires some functions/vars — stub them out.
emit_event() { :; }
warn() { :; }
info() { :; }
error() { :; }
now_epoch() { date +%s; }
compute_md5() { echo "test"; }
export INTELLIGENCE_ENABLED="false"  # force fallback path
export -f emit_event warn info error now_epoch compute_md5

# Source intelligence (it checks for functions, so stub what's needed)
_intelligence_enabled() { return 1; }
_intelligence_cache_get() { return 1; }
_intelligence_cache_set() { :; }
intelligence_github_enrich() { echo "$1"; }
export -f _intelligence_enabled _intelligence_cache_get _intelligence_cache_set intelligence_github_enrich

source "$SCRIPT_DIR/sw-intelligence.sh" 2>/dev/null || true

echo ""
echo "  ── Label-based issue_type detection ──"

# Test the fallback analyzer directly
result_frontend=$(_intelligence_fallback_analyze "Fix CSS layout" "The sidebar is broken on mobile" "ui, bug")
type_frontend=$(echo "$result_frontend" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_frontend" "frontend" "labels 'ui, bug' → frontend"

result_api=$(_intelligence_fallback_analyze "Add REST endpoint" "New /api/users endpoint" "api, feature")
type_api=$(echo "$result_api" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_api" "api" "labels 'api, feature' → api"

result_db=$(_intelligence_fallback_analyze "Add migration" "Need new schema" "db, migration")
type_db=$(echo "$result_db" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_db" "database" "labels 'db, migration' → database"

result_sec=$(_intelligence_fallback_analyze "Fix auth bypass" "XSS vulnerability" "security")
type_sec=$(echo "$result_sec" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_sec" "security" "labels 'security' → security"

result_perf=$(_intelligence_fallback_analyze "Slow query" "latency is 5s" "perf, backend")
type_perf=$(echo "$result_perf" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_perf" "performance" "labels 'perf, backend' → performance"

result_test=$(_intelligence_fallback_analyze "Add tests" "Improve coverage" "test, quality")
type_test=$(echo "$result_test" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_test" "testing" "labels 'test, quality' → testing"

result_docs=$(_intelligence_fallback_analyze "Update README" "Outdated docs" "docs")
type_docs=$(echo "$result_docs" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_docs" "documentation" "labels 'docs' → documentation"

result_infra=$(_intelligence_fallback_analyze "Fix CI" "Pipeline broken" "ci, infra")
type_infra=$(echo "$result_infra" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_infra" "infrastructure" "labels 'ci, infra' → infrastructure"

result_refactor=$(_intelligence_fallback_analyze "Refactor auth" "Clean up module" "refactor")
type_refactor=$(echo "$result_refactor" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_refactor" "refactor" "labels 'refactor' → refactor"

result_default=$(_intelligence_fallback_analyze "Some task" "Do the thing" "enhancement")
type_default=$(echo "$result_default" | jq -r '.issue_type' 2>/dev/null)
assert_eq "$type_default" "backend" "labels 'enhancement' → backend (default)"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 3: Skill Files Integrity
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 3: Skill File Integrity ═══"

EXPECTED_SKILLS=(
    brainstorming
    systematic-debugging
    two-stage-review
    frontend-design
    api-design
    data-pipeline
    security-audit
    performance
    testing-strategy
    product-thinking
    documentation
)

for skill in "${EXPECTED_SKILLS[@]}"; do
    path="$SCRIPT_DIR/skills/${skill}.md"
    assert_file_exists "$path" "skill file exists: ${skill}.md"
done

# Verify content signatures (each file should have specific content)
echo ""
echo "  ── Content verification ──"

assert_contains "$(cat "$SCRIPT_DIR/skills/brainstorming.md")" "Socratic" "brainstorming.md mentions Socratic"
assert_contains "$(cat "$SCRIPT_DIR/skills/systematic-debugging.md")" "Root Cause" "systematic-debugging.md mentions Root Cause"
assert_contains "$(cat "$SCRIPT_DIR/skills/two-stage-review.md")" "Pass 1" "two-stage-review.md has Pass 1"
assert_contains "$(cat "$SCRIPT_DIR/skills/two-stage-review.md")" "Pass 2" "two-stage-review.md has Pass 2"
assert_contains "$(cat "$SCRIPT_DIR/skills/frontend-design.md")" "Accessibility" "frontend-design.md mentions Accessibility"
assert_contains "$(cat "$SCRIPT_DIR/skills/api-design.md")" "RESTful" "api-design.md mentions RESTful"
assert_contains "$(cat "$SCRIPT_DIR/skills/data-pipeline.md")" "Migration" "data-pipeline.md mentions Migration"
assert_contains "$(cat "$SCRIPT_DIR/skills/security-audit.md")" "OWASP" "security-audit.md mentions OWASP"
assert_contains "$(cat "$SCRIPT_DIR/skills/performance.md")" "Profiling" "performance.md mentions Profiling"
assert_contains "$(cat "$SCRIPT_DIR/skills/testing-strategy.md")" "Test Pyramid" "testing-strategy.md mentions Test Pyramid"
assert_contains "$(cat "$SCRIPT_DIR/skills/product-thinking.md")" "User Stories" "product-thinking.md mentions User Stories"
assert_contains "$(cat "$SCRIPT_DIR/skills/documentation.md")" "Skip Heavy Stages" "documentation.md mentions Skip Heavy Stages"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 4: Retry Context Mechanics
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 4: Retry Context Mechanics ═══"

TMPDIR_TEST=$(mktemp -d)
trap "rm -rf $TMPDIR_TEST" EXIT

# Test: retry context file format
echo ""
echo "  ── Retry context file creation ──"

# Simulate what sw-pipeline.sh writes
_retry_ctx_file="${TMPDIR_TEST}/.retry-context-build.md"
error_class="logic"
attempt=1
max_retries=2
_log_file="${TMPDIR_TEST}/build-log.txt"
echo "Error: Cannot find module './foo'" > "$_log_file"
echo "TypeError: undefined is not a function" >> "$_log_file"

ARTIFACTS_DIR="$TMPDIR_TEST"
# Create some fake artifacts
echo "# Plan" > "${ARTIFACTS_DIR}/plan.md"
for i in $(seq 1 15); do echo "- Task $i" >> "${ARTIFACTS_DIR}/plan.md"; done

{
    echo "## Previous Attempt Failed"
    echo ""
    echo "**Error classification:** ${error_class}"
    echo "**Attempt:** ${attempt} of $((max_retries + 1))"
    echo ""
    echo "### Error Output (last 30 lines)"
    echo '```'
    tail -30 "$_log_file" 2>/dev/null || echo "(no log available)"
    echo '```'
    echo ""
    local_existing_artifacts=""
    for _af in plan.md design.md test-results.log; do
        if [[ -s "${ARTIFACTS_DIR}/${_af}" ]]; then
            _af_lines=$(wc -l < "${ARTIFACTS_DIR}/${_af}" 2>/dev/null | xargs)
            local_existing_artifacts="${local_existing_artifacts}  - ${_af} (${_af_lines} lines)\n"
        fi
    done
    if [[ -n "$local_existing_artifacts" ]]; then
        echo "### Existing Artifacts (PRESERVE these)"
        echo -e "$local_existing_artifacts"
    fi
    echo "### Investigation Required"
    echo "1. Read the error output above carefully"
} > "$_retry_ctx_file" 2>/dev/null || true

assert_file_exists "$_retry_ctx_file" "retry context file created"
assert_contains "$(cat "$_retry_ctx_file")" "Previous Attempt Failed" "retry context has header"
assert_contains "$(cat "$_retry_ctx_file")" "logic" "retry context has error class"
assert_contains "$(cat "$_retry_ctx_file")" "Cannot find module" "retry context captures error output"
assert_contains "$(cat "$_retry_ctx_file")" "plan.md" "retry context lists existing artifacts"
assert_contains "$(cat "$_retry_ctx_file")" "Investigation Required" "retry context has investigation section"

# Test: plan artifact skip logic
echo ""
echo "  ── Plan artifact skip logic ──"

plan_artifact="${TMPDIR_TEST}/plan.md"
existing_lines=$(wc -l < "$plan_artifact" 2>/dev/null | xargs)
existing_lines="${existing_lines:-0}"
if [[ "$existing_lines" -gt 10 ]]; then
    plan_skip="yes"
else
    plan_skip="no"
fi
assert_eq "$plan_skip" "yes" "plan with ${existing_lines} lines skips retry (>10)"

# Test with short plan
echo "# Short plan" > "${TMPDIR_TEST}/short-plan.md"
short_lines=$(wc -l < "${TMPDIR_TEST}/short-plan.md" 2>/dev/null | xargs)
if [[ "$short_lines" -gt 10 ]]; then
    short_skip="yes"
else
    short_skip="no"
fi
assert_eq "$short_skip" "no" "plan with ${short_lines} lines does NOT skip retry (<=10)"

# Test: retry context consumption
echo ""
echo "  ── Retry context consumption ──"

echo "Debug info here" > "${TMPDIR_TEST}/.retry-context-plan.md"
_retry_ctx="${TMPDIR_TEST}/.retry-context-plan.md"
if [[ -s "$_retry_ctx" ]]; then
    _retry_hints=$(cat "$_retry_ctx" 2>/dev/null || true)
    rm -f "$_retry_ctx"
fi
assert_eq "$_retry_hints" "Debug info here" "retry context consumed correctly"
if [[ ! -f "$_retry_ctx" ]]; then
    pass "retry context file deleted after consumption"
else
    fail "retry context file should be deleted after consumption"
fi


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 5: Integration — End-to-End Skill Flow
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 5: Integration — End-to-End Skill Flow ═══"

echo ""
echo "  ── Frontend issue → full skill chain ──"

# Simulate: frontend issue classified, skills loaded for each stage
export INTELLIGENCE_ISSUE_TYPE="frontend"

plan_skills=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "plan")
assert_contains "$plan_skills" "Socratic" "frontend plan gets brainstorming"
assert_contains "$plan_skills" "Accessibility" "frontend plan gets frontend-design"
assert_contains "$plan_skills" "User Stories" "frontend plan gets product-thinking"

build_skills=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "build")
assert_contains "$build_skills" "Responsive Design" "frontend build gets frontend-design"

review_skills=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "review")
assert_contains "$review_skills" "Two-Stage" "frontend review gets two-stage-review"

echo ""
echo "  ── API issue → security in review ──"

export INTELLIGENCE_ISSUE_TYPE="api"
api_review=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "review")
assert_contains "$api_review" "Two-Stage" "api review gets two-stage-review"
assert_contains "$api_review" "OWASP" "api review gets security-audit"

echo ""
echo "  ── Documentation issue → lightweight ──"

export INTELLIGENCE_ISSUE_TYPE="documentation"
doc_plan=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "plan")
assert_contains "$doc_plan" "Skip Heavy Stages" "documentation plan gets lightweight guidance"

doc_review=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "review")
assert_eq "$doc_review" "" "documentation review gets NO review skills"

assert_exit_nonzero "documentation has no two-stage review" skill_has_two_stage_review "documentation"

echo ""
echo "  ── Security issue → double security ──"

export INTELLIGENCE_ISSUE_TYPE="security"
sec_plan=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "plan")
assert_contains "$sec_plan" "OWASP" "security plan gets security-audit"

sec_build=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "build")
assert_contains "$sec_build" "OWASP" "security build gets security-audit"

sec_review=$(skill_load_prompts "$INTELLIGENCE_ISSUE_TYPE" "review")
assert_contains "$sec_review" "OWASP" "security review gets security-audit"
assert_contains "$sec_review" "Two-Stage" "security review also gets two-stage-review"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 6: New Skill Files (PDLC Expansion)
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 6: New PDLC Skill Files ═══"

NEW_SKILLS=(
    architecture-design
    adversarial-quality
    pr-quality
    deploy-safety
    validation-thoroughness
    observability
)

for skill in "${NEW_SKILLS[@]}"; do
    path="$SCRIPT_DIR/skills/${skill}.md"
    assert_file_exists "$path" "new skill file exists: ${skill}.md"
done

echo ""
echo "  ── Content verification ──"

assert_contains "$(cat "$SCRIPT_DIR/skills/architecture-design.md")" "Component Decomposition" "architecture-design.md has component decomposition"
assert_contains "$(cat "$SCRIPT_DIR/skills/architecture-design.md")" "Interface Contracts" "architecture-design.md has interface contracts"
assert_contains "$(cat "$SCRIPT_DIR/skills/adversarial-quality.md")" "Failure Mode" "adversarial-quality.md has failure mode analysis"
assert_contains "$(cat "$SCRIPT_DIR/skills/adversarial-quality.md")" "Negative Testing" "adversarial-quality.md has negative testing"
assert_contains "$(cat "$SCRIPT_DIR/skills/pr-quality.md")" "Commit Hygiene" "pr-quality.md has commit hygiene"
assert_contains "$(cat "$SCRIPT_DIR/skills/pr-quality.md")" "Reviewer Empathy" "pr-quality.md has reviewer empathy"
assert_contains "$(cat "$SCRIPT_DIR/skills/deploy-safety.md")" "Rollback" "deploy-safety.md has rollback strategy"
assert_contains "$(cat "$SCRIPT_DIR/skills/deploy-safety.md")" "Blue-Green" "deploy-safety.md has blue-green strategy"
assert_contains "$(cat "$SCRIPT_DIR/skills/validation-thoroughness.md")" "Smoke Test" "validation-thoroughness.md has smoke test design"
assert_contains "$(cat "$SCRIPT_DIR/skills/validation-thoroughness.md")" "Health Check Layers" "validation-thoroughness.md has health check layers"
assert_contains "$(cat "$SCRIPT_DIR/skills/observability.md")" "Anomaly Detection" "observability.md has anomaly detection"
assert_contains "$(cat "$SCRIPT_DIR/skills/observability.md")" "Auto-Rollback Triggers" "observability.md has auto-rollback triggers"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 7: New Stage Mappings in Registry
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 7: New Stage Mappings ═══"

echo ""
echo "  ── Design stage ──"

design_frontend=$(skill_get_prompts "frontend" "design")
assert_contains "$design_frontend" "architecture-design.md" "frontend/design includes architecture-design"
assert_contains "$design_frontend" "frontend-design.md" "frontend/design includes frontend-design"

design_api=$(skill_get_prompts "api" "design")
assert_contains "$design_api" "architecture-design.md" "api/design includes architecture-design"
assert_contains "$design_api" "api-design.md" "api/design includes api-design"

design_security=$(skill_get_prompts "security" "design")
assert_contains "$design_security" "security-audit.md" "security/design includes security-audit"

design_docs=$(skill_get_prompts "documentation" "design")
assert_eq "$design_docs" "" "documentation/design returns empty"

design_backend=$(skill_get_prompts "backend" "design")
assert_contains "$design_backend" "architecture-design.md" "backend/design includes architecture-design"

echo ""
echo "  ── Compound quality stage ──"

cq_frontend=$(skill_get_prompts "frontend" "compound_quality")
assert_contains "$cq_frontend" "adversarial-quality.md" "frontend/compound_quality includes adversarial-quality"
assert_contains "$cq_frontend" "testing-strategy.md" "frontend/compound_quality includes testing-strategy"

cq_api=$(skill_get_prompts "api" "compound_quality")
assert_contains "$cq_api" "adversarial-quality.md" "api/compound_quality includes adversarial-quality"
assert_contains "$cq_api" "security-audit.md" "api/compound_quality includes security-audit"

cq_docs=$(skill_get_prompts "documentation" "compound_quality")
assert_eq "$cq_docs" "" "documentation/compound_quality returns empty"

echo ""
echo "  ── PR stage ──"

pr_any=$(skill_get_prompts "backend" "pr")
assert_contains "$pr_any" "pr-quality.md" "backend/pr includes pr-quality"

pr_docs=$(skill_get_prompts "documentation" "pr")
assert_contains "$pr_docs" "pr-quality.md" "documentation/pr includes pr-quality"

echo ""
echo "  ── Deploy stage ──"

deploy_api=$(skill_get_prompts "api" "deploy")
assert_contains "$deploy_api" "deploy-safety.md" "api/deploy includes deploy-safety"
assert_contains "$deploy_api" "security-audit.md" "api/deploy includes security-audit"

deploy_db=$(skill_get_prompts "database" "deploy")
assert_contains "$deploy_db" "deploy-safety.md" "database/deploy includes deploy-safety"
assert_contains "$deploy_db" "data-pipeline.md" "database/deploy includes data-pipeline"

deploy_docs=$(skill_get_prompts "documentation" "deploy")
assert_eq "$deploy_docs" "" "documentation/deploy returns empty"

echo ""
echo "  ── Validate stage ──"

validate_api=$(skill_get_prompts "api" "validate")
assert_contains "$validate_api" "validation-thoroughness.md" "api/validate includes validation-thoroughness"
assert_contains "$validate_api" "security-audit.md" "api/validate includes security-audit"

validate_docs=$(skill_get_prompts "documentation" "validate")
assert_eq "$validate_docs" "" "documentation/validate returns empty"

echo ""
echo "  ── Monitor stage ──"

monitor_perf=$(skill_get_prompts "performance" "monitor")
assert_contains "$monitor_perf" "observability.md" "performance/monitor includes observability"
assert_contains "$monitor_perf" "performance.md" "performance/monitor includes performance (double!)"

monitor_docs=$(skill_get_prompts "documentation" "monitor")
assert_eq "$monitor_docs" "" "documentation/monitor returns empty"

monitor_api=$(skill_get_prompts "api" "monitor")
assert_contains "$monitor_api" "observability.md" "api/monitor includes observability"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 8: Full PDLC Integration — Every Stage Covered
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 8: Full PDLC Integration ═══"

echo ""
echo "  ── API issue → all 9 stages ──"
export INTELLIGENCE_ISSUE_TYPE="api"

api_plan=$(skill_load_prompts "api" "plan")
assert_not_empty "$api_plan" "api/plan has skills"

api_design=$(skill_load_prompts "api" "design")
assert_contains "$api_design" "Architecture" "api/design has architecture guidance"
assert_contains "$api_design" "RESTful" "api/design has API patterns"

api_build=$(skill_load_prompts "api" "build")
assert_not_empty "$api_build" "api/build has skills"

api_review=$(skill_load_prompts "api" "review")
assert_not_empty "$api_review" "api/review has skills"

api_cq=$(skill_load_prompts "api" "compound_quality")
assert_contains "$api_cq" "Failure Mode" "api/compound_quality has adversarial thinking"

api_pr=$(skill_load_prompts "api" "pr")
assert_contains "$api_pr" "Commit Hygiene" "api/pr has PR quality"

api_deploy=$(skill_load_prompts "api" "deploy")
assert_contains "$api_deploy" "Rollback" "api/deploy has deploy safety"

api_validate=$(skill_load_prompts "api" "validate")
assert_contains "$api_validate" "Smoke Test" "api/validate has validation"

api_monitor=$(skill_load_prompts "api" "monitor")
assert_contains "$api_monitor" "Anomaly" "api/monitor has observability"

echo ""
echo "  ── Documentation issue → lightweight everywhere ──"
export INTELLIGENCE_ISSUE_TYPE="documentation"

ALL_STAGES=(plan design build review compound_quality pr deploy validate monitor)
doc_nonempty=0
doc_empty=0
for stage in "${ALL_STAGES[@]}"; do
    content=$(skill_load_prompts "documentation" "$stage")
    if [[ -n "$content" ]]; then
        doc_nonempty=$((doc_nonempty + 1))
    else
        doc_empty=$((doc_empty + 1))
    fi
done
# Documentation should have skills in plan, build, pr only (3 non-empty)
assert_eq "$doc_nonempty" "3" "documentation has exactly 3 stages with skills (plan, build, pr)"
assert_eq "$doc_empty" "6" "documentation skips 6 stages (design, review, compound_quality, deploy, validate, monitor)"

echo ""
echo "  ── Total skill file count ──"
total_skills=$(ls "$SCRIPT_DIR/skills/"*.md 2>/dev/null | wc -l | xargs)
assert_eq "$total_skills" "17" "17 total skill files (11 original + 6 new)"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 9: Adaptive Skill Selection (Level 2)
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 9: Adaptive Skill Selection ═══"

# Test: skill_detect_from_body — accessibility keywords
echo ""
echo "  ── Body analysis: accessibility ──"

body_accessibility="Fix WCAG compliance issues. The interface needs better keyboard navigation and ARIA labels for screen readers."
detected_a11y=$(skill_detect_from_body "$body_accessibility" "plan")
assert_contains "$detected_a11y" "frontend-design.md" "accessibility keywords detected"

# Test: skill_detect_from_body — API keywords
echo ""
echo "  ── Body analysis: API/endpoint ──"

body_api="Design new REST endpoint for user management. Need GraphQL mutation support."
detected_api=$(skill_detect_from_body "$body_api" "plan")
assert_contains "$detected_api" "api-design.md" "API keywords detected"

# Test: skill_detect_from_body — security keywords
echo ""
echo "  ── Body analysis: security ──"

body_security="Fix XSS vulnerability in user input. Implement OWASP Top 10 mitigations."
detected_sec=$(skill_detect_from_body "$body_security" "plan")
assert_contains "$detected_sec" "security-audit.md" "security keywords detected"

# Test: skill_detect_from_body — performance keywords
echo ""
echo "  ── Body analysis: performance ──"

body_perf="Query is too slow. P95 latency is 5 seconds. Need to optimize and add caching."
detected_perf=$(skill_detect_from_body "$body_perf" "plan")
assert_contains "$detected_perf" "performance.md" "performance keywords detected"

# Test: skill_detect_from_body — migration keywords
echo ""
echo "  ── Body analysis: database migration ──"

body_migration="Database schema refactor needed. Add new column and create migration."
detected_db=$(skill_detect_from_body "$body_migration" "plan")
assert_contains "$detected_db" "data-pipeline.md" "migration keywords detected"

# Test: skill_detect_from_body — empty body returns empty
echo ""
echo "  ── Body analysis: edge cases ──"

detected_empty=$(skill_detect_from_body "" "plan")
assert_eq "$detected_empty" "" "empty body returns empty (no extra skills)"

# Test: skill_detect_from_body — multiple patterns in one body
body_multi="Improve accessibility (ARIA labels) and add API endpoint (REST). Also need security audit for OWASP compliance."
detected_multi=$(skill_detect_from_body "$body_multi" "plan")
assert_contains "$detected_multi" "frontend-design.md" "multiple patterns: accessibility detected"
assert_contains "$detected_multi" "api-design.md" "multiple patterns: API detected"
assert_contains "$detected_multi" "security-audit.md" "multiple patterns: security detected"

# Test: skill_weight_by_complexity — simple issues (1-3) reduce to first skill
echo ""
echo "  ── Complexity weighting: simple (1-3) ──"

skills_sample="$(printf '%s\n%s\n%s' "$SCRIPT_DIR/skills/brainstorming.md" "$SCRIPT_DIR/skills/frontend-design.md" "$SCRIPT_DIR/skills/product-thinking.md")"
weighted_simple=$(skill_weight_by_complexity "1" "$skills_sample")
simple_count=$(echo "$weighted_simple" | grep -c "^.*\.md$" 2>/dev/null || echo "0")
assert_eq "$simple_count" "1" "complexity 1 keeps only 1 skill (essential)"

weighted_simple_3=$(skill_weight_by_complexity "3" "$skills_sample")
simple_3_count=$(echo "$weighted_simple_3" | grep -c "^.*\.md$" 2>/dev/null || echo "0")
assert_eq "$simple_3_count" "1" "complexity 3 keeps only 1 skill (essential)"

# Test: skill_weight_by_complexity — standard issues (4-7) keep all skills
echo ""
echo "  ── Complexity weighting: standard (4-7) ──"

weighted_std=$(skill_weight_by_complexity "5" "$skills_sample")
std_count=$(echo "$weighted_std" | grep -c "^.*\.md$" 2>/dev/null || echo "0")
assert_eq "$std_count" "3" "complexity 5 keeps all 3 skills (standard)"

weighted_std_7=$(skill_weight_by_complexity "7" "$skills_sample")
std_7_count=$(echo "$weighted_std_7" | grep -c "^.*\.md$" 2>/dev/null || echo "0")
assert_eq "$std_7_count" "3" "complexity 7 keeps all 3 skills (standard)"

# Test: skill_weight_by_complexity — complex issues (8-10) add cross-cutting concerns
echo ""
echo "  ── Complexity weighting: complex (8-10) ──"

weighted_complex=$(skill_weight_by_complexity "9" "$skills_sample")
# Should have original 3 + security-audit (if not present) + performance (if not present)
assert_contains "$weighted_complex" "brainstorming.md" "complexity 9: includes original skills"
assert_contains "$weighted_complex" "security-audit.md" "complexity 9: adds security-audit"
assert_contains "$weighted_complex" "performance.md" "complexity 9: adds performance"

# Test: skill_select_adaptive — combines all signals
echo ""
echo "  ── Adaptive selection: full integration ──"

export INTELLIGENCE_ISSUE_TYPE="api"
body_for_adaptive="Add new REST API endpoint. Need to ensure WCAG accessibility. Consider OWASP security."
complexity_level=6
adaptive_result=$(skill_select_adaptive "api" "plan" "$body_for_adaptive" "$complexity_level")
assert_contains "$adaptive_result" "brainstorming.md" "adaptive: base skills included"
assert_contains "$adaptive_result" "api-design.md" "adaptive: issue-type skill included"
assert_contains "$adaptive_result" "frontend-design.md" "adaptive: body analysis detects accessibility"
assert_contains "$adaptive_result" "security-audit.md" "adaptive: body analysis detects security"

# Test: deduplication in adaptive selection
echo ""
echo "  ── Adaptive selection: deduplication ──"

# If api-design is in base skills and body mentions API, should only appear once
adaptive_dup=$(skill_select_adaptive "api" "design" "Improve REST API design with GraphQL support" "5")
api_count=$(echo "$adaptive_dup" | grep -c "api-design.md" 2>/dev/null || echo "0")
assert_eq "$api_count" "1" "adaptive: duplicate skills deduplicated"

# Test: graceful degradation when adaptive unavailable
echo ""
echo "  ── Fallback behavior ──"

# This tests that pipeline-stages.sh correctly falls back to skill_load_prompts if skill_select_adaptive unavailable
# We simulate by checking that skill_load_prompts still works standalone
fallback_result=$(skill_load_prompts "frontend" "plan")
assert_contains "$fallback_result" "Accessibility" "fallback: skill_load_prompts still functional"

echo ""
echo "  ── Adaptive with zero complexity ──"

# Edge case: complexity 0 should be normalized to 1
weighted_zero=$(skill_weight_by_complexity "0" "$skills_sample")
zero_count=$(echo "$weighted_zero" | grep -c "^.*\.md$" 2>/dev/null || echo "0")
assert_eq "$zero_count" "1" "complexity 0 normalized to 1 (essential only)"

# Edge case: complexity > 10 should be capped
weighted_high=$(skill_weight_by_complexity "99" "$skills_sample")
assert_contains "$weighted_high" "security-audit.md" "complexity 99 capped to 10 (adds cross-cutting)"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 10: Skill Memory & Learning
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 10: Skill Memory & Learning ═══"

# Load skill memory module first (once)
source "$SCRIPT_DIR/lib/skill-memory.sh"

# --- Test 1: Recording a success outcome creates/updates JSON ---
echo ""
echo "  ── Recording outcomes ──"

# Use temporary file for testing (don't pollute real memory)
_TEST_MEMORY_FILE=$(mktemp)
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"

skill_memory_record "backend" "plan" "brainstorming,frontend-design" "success" "1" >/dev/null 2>&1 || true
assert_file_exists "$SKILL_MEMORY_FILE" "Memory file created on first write"

result=$(jq '.records | length' "$SKILL_MEMORY_FILE" 2>/dev/null || echo "0")
assert_eq "$result" "1" "First record written to memory"

# --- Test 2: Recording a failure outcome ---
skill_memory_record "frontend" "build" "frontend-design" "failure" "1" >/dev/null 2>&1 || true
result=$(jq '.records | length' "$SKILL_MEMORY_FILE" 2>/dev/null || echo "0")
assert_eq "$result" "2" "Second record (failure) appended"

# Clean up from test 1-2 before test 3
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"
# Re-initialize after cleanup
_skill_memory_ensure_file

# --- Test 3: Success rate calculation (2 success, 1 failure = 67%, rounded to 66) ---
skill_memory_record "api" "review" "two-stage-review,security-audit" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "api" "review" "two-stage-review,security-audit" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "api" "review" "two-stage-review,security-audit" "failure" "1" >/dev/null 2>&1 || true

rate=$(skill_memory_get_success_rate "api" "review" "two-stage-review" 2>/dev/null || echo "0")
assert_eq "$rate" "66" "Success rate: 2 success + 1 failure = 66%"

# --- Test 4: Recommendations return skills sorted by success rate ---
skill_memory_record "backend" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "backend" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "backend" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true

skill_memory_record "backend" "plan" "architecture-design" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "backend" "plan" "architecture-design" "failure" "1" >/dev/null 2>&1 || true

recommendations=$(skill_memory_get_recommendations "backend" "plan" 2>/dev/null || echo "")
# brainstorming should rank higher (100% success vs 50%)
if [[ "$recommendations" == *"brainstorming"* ]]; then
    pass "Recommendations returned for backend/plan"
else
    fail "Recommendations should not be empty for backend/plan"
fi

# Clean up from test 1-4
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"

# --- Test 5: Empty memory returns empty recommendations ---
_TEST_MEMORY_FILE=$(mktemp)
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"
recommendations=$(skill_memory_get_recommendations "frontend" "test" 2>/dev/null || echo "")
assert_eq "$recommendations" "" "Empty memory returns empty recommendations"
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"

# --- Test 6: Memory file created lazily ---
_TEST_MEMORY_FILE=$(mktemp)
rm -f "$_TEST_MEMORY_FILE"
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"
[[ ! -f "$SKILL_MEMORY_FILE" ]] && pass "Temp file doesn't exist initially"

skill_memory_record "testing" "plan" "testing-strategy" "success" "1" >/dev/null 2>&1 || true
assert_file_exists "$SKILL_MEMORY_FILE" "Memory file created lazily on first record"
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"

# --- Test 7: Graceful handling when jq is unavailable ---
export PATH="/nonexistent:$PATH"
if ! command -v jq &>/dev/null; then
    _TEST_MEMORY_FILE=$(mktemp)
    export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"
    skill_memory_record "database" "design" "data-pipeline" "success" "1" >/dev/null 2>&1 || true
    fail_code=$?
    if [[ $fail_code -ne 0 ]]; then
        pass "Graceful failure when jq unavailable"
    else
        fail "Should return error when jq unavailable"
    fi
    rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"
else
    pass "jq is available (can't fully test unavailable case)"
fi
export PATH="$ORIGINAL_PATH"

# --- Test 8: Max records limit (pruning) ---
_TEST_MEMORY_FILE=$(mktemp)
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"
for i in {1..250}; do
    skill_memory_record "refactor" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true
done
record_count=$(jq '.records | length' "$SKILL_MEMORY_FILE" 2>/dev/null || echo "0")
if [[ "$record_count" -le 200 ]]; then
    pass "Records pruned to max 200 (got $record_count)"
else
    fail "Records not pruned (expected ≤200, got $record_count)"
fi
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"

# --- Test 9: Skill stats function ---
_TEST_MEMORY_FILE=$(mktemp)
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"
skill_memory_record "performance" "compound_quality" "adversarial-quality,performance" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "performance" "compound_quality" "adversarial-quality,performance" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "performance" "compound_quality" "adversarial-quality,performance" "failure" "1" >/dev/null 2>&1 || true

stats=$(skill_memory_stats "performance" "compound_quality" "adversarial-quality" 2>/dev/null || echo "")
success_count=$(echo "$stats" | jq '.success_count' 2>/dev/null || echo "0")
failure_count=$(echo "$stats" | jq '.failure_count' 2>/dev/null || echo "0")

assert_eq "$success_count" "2" "Stats: 2 successes for adversarial-quality"
assert_eq "$failure_count" "1" "Stats: 1 failure for adversarial-quality"
rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock"

# --- Test 10: Export and import functionality ---
_TEST_MEMORY_FILE=$(mktemp)
_TEST_IMPORT_FILE=$(mktemp)
export SKILL_MEMORY_FILE="$_TEST_MEMORY_FILE"

skill_memory_record "documentation" "pr" "pr-quality" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "documentation" "pr" "pr-quality" "success" "1" >/dev/null 2>&1 || true

skill_memory_export > "$_TEST_IMPORT_FILE" 2>/dev/null || true
import_records=$(jq '.records | length' "$_TEST_IMPORT_FILE" 2>/dev/null || echo "0")
assert_eq "$import_records" "2" "Export has correct record count"

rm -f "$SKILL_MEMORY_FILE" "${SKILL_MEMORY_FILE}.lock" "$_TEST_IMPORT_FILE"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 11: Skill Catalog Builder
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 11: Skill Catalog Builder ═══"
echo ""

# Test: catalog includes curated skills
echo "  ── Curated skills in catalog ──"
_catalog=$(skill_build_catalog 2>/dev/null || true)
assert_contains "$_catalog" "brainstorming" "catalog includes brainstorming"
assert_contains "$_catalog" "frontend-design" "catalog includes frontend-design"
assert_contains "$_catalog" "security-audit" "catalog includes security-audit"

# Test: catalog includes one-line descriptions
assert_contains "$_catalog" "Socratic" "brainstorming has description"

# Test: catalog includes generated skills when they exist
_gen_dir="${SKILLS_DIR}/generated"
mkdir -p "$_gen_dir"
printf '%s\n%s\n' "## Test Generated Skill" "Test content for generated skill." > "$_gen_dir/test-gen-skill.md"
_catalog=$(skill_build_catalog 2>/dev/null || true)
assert_contains "$_catalog" "test-gen-skill" "catalog includes generated skill"
assert_contains "$_catalog" "[generated]" "generated skill is tagged"
rm -f "$_gen_dir/test-gen-skill.md"

# Test: catalog includes memory context when available
skill_memory_clear 2>/dev/null || true
skill_memory_record "frontend" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true
skill_memory_record "frontend" "plan" "brainstorming" "success" "1" >/dev/null 2>&1 || true
_catalog=$(skill_build_catalog "frontend" "plan" 2>/dev/null || true)
assert_contains "$_catalog" "success" "catalog includes memory context"
skill_memory_clear 2>/dev/null || true

echo ""
echo "  ── LLM skill analysis (mock) ──"

# We can't test real LLM calls in unit tests, so test the JSON parsing/artifact writing
# Mock: simulate skill_analyze_issue writing skill-plan.json
_test_artifacts=$(mktemp -d)

_mock_plan='{"issue_type":"frontend","confidence":0.92,"secondary_domains":["accessibility"],"complexity_assessment":{"score":6,"reasoning":"moderate"},"skill_plan":{"plan":["brainstorming","frontend-design"],"build":["frontend-design"],"review":["two-stage-review"]},"skill_rationale":{"frontend-design":"ARIA progressbar needed","brainstorming":"Task decomposition required"},"generated_skills":[],"review_focus":["accessibility"],"risk_areas":["ETA accuracy"]}'
echo "$_mock_plan" > "$_test_artifacts/skill-plan.json"

# Verify skill-plan.json is valid JSON
assert_true "jq '.' '$_test_artifacts/skill-plan.json' >/dev/null 2>&1" "skill-plan.json is valid JSON"

# Verify we can extract skills for a stage
_plan_skills=$(jq -r '.skill_plan.plan[]' "$_test_artifacts/skill-plan.json" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
assert_eq "$_plan_skills" "brainstorming,frontend-design" "plan stage skills extracted correctly"

# Verify rationale extraction
_rationale=$(jq -r '.skill_rationale["frontend-design"]' "$_test_artifacts/skill-plan.json" 2>/dev/null)
assert_contains "$_rationale" "ARIA" "rationale extracted correctly"

rm -rf "$_test_artifacts"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 12: Plan-Based Skill Loading
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 12: Plan-Based Skill Loading ═══"
echo ""

_test_artifacts=$(mktemp -d)

# Write a mock skill-plan.json
cat > "$_test_artifacts/skill-plan.json" << 'PLAN_EOF'
{
  "issue_type": "frontend",
  "skill_plan": {
    "plan": ["brainstorming", "frontend-design"],
    "build": ["frontend-design"],
    "review": ["two-stage-review"],
    "deploy": []
  },
  "skill_rationale": {
    "brainstorming": "Task decomposition for progress bar feature",
    "frontend-design": "ARIA progressbar role and responsive CSS needed",
    "two-stage-review": "Spec compliance check against plan.md"
  },
  "generated_skills": []
}
PLAN_EOF

echo "  ── Loading skills from plan ──"

# Test: load plan stage skills
plan_content=$(ARTIFACTS_DIR="$_test_artifacts" skill_load_from_plan "plan" 2>/dev/null || true)
assert_contains "$plan_content" "brainstorming" "plan stage loads brainstorming skill"
assert_contains "$plan_content" "frontend-design" "plan stage loads frontend-design skill content"
assert_contains "$plan_content" "ARIA progressbar" "plan stage includes rationale"
assert_contains "$plan_content" "Task decomposition" "plan stage includes brainstorming rationale"

# Test: load build stage skills
build_content=$(ARTIFACTS_DIR="$_test_artifacts" skill_load_from_plan "build" 2>/dev/null || true)
assert_contains "$build_content" "frontend-design" "build stage loads frontend-design"
assert_not_contains "$build_content" "brainstorming" "build stage does NOT load brainstorming"

# Test: empty stage returns empty
deploy_content=$(ARTIFACTS_DIR="$_test_artifacts" skill_load_from_plan "deploy" 2>/dev/null || true)
assert_eq "" "$(echo "$deploy_content" | tr -d '[:space:]')" "empty stage returns empty"

# Test: missing skill-plan.json falls back to skill_select_adaptive
_no_plan_dir=$(mktemp -d)
fallback_content=$(ARTIFACTS_DIR="$_no_plan_dir" INTELLIGENCE_ISSUE_TYPE="frontend" skill_load_from_plan "plan" 2>/dev/null || true)
assert_contains "$fallback_content" "brainstorming\|frontend\|Socratic" "fallback to adaptive when no plan"
rm -rf "$_no_plan_dir"

# Test: refinements are appended
mkdir -p "$SKILLS_DIR/generated/_refinements"
echo "REFINEMENT: Always check stat-bar CSS pattern reuse." > "$SKILLS_DIR/generated/_refinements/frontend-design.patch.md"
plan_content=$(ARTIFACTS_DIR="$_test_artifacts" skill_load_from_plan "plan" 2>/dev/null || true)
assert_contains "$plan_content" "REFINEMENT" "refinement patch appended to skill"
rm -f "$SKILLS_DIR/generated/_refinements/frontend-design.patch.md"

rm -rf "$_test_artifacts"


# ═══════════════════════════════════════════════════════════════════════════════
# TEST SUITE 13: Outcome Learning Loop
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 13: Outcome Learning Loop ═══"
echo ""

_test_artifacts=$(mktemp -d)

# Write a mock skill-plan.json
cat > "$_test_artifacts/skill-plan.json" << 'PLAN_EOF'
{
  "issue_type": "frontend",
  "skill_plan": {
    "plan": ["brainstorming", "frontend-design"],
    "build": ["frontend-design"],
    "review": ["two-stage-review"]
  },
  "skill_rationale": {
    "frontend-design": "ARIA progressbar needed"
  },
  "generated_skills": []
}
PLAN_EOF

echo "  ── Outcome JSON parsing ──"

# Test: parse a mock outcome response
_mock_outcome='{"skill_effectiveness":{"frontend-design":{"verdict":"effective","evidence":"ARIA section in plan","learning":"stat-bar reuse hint followed"}},"refinements":[{"skill":"frontend-design","addition":"For dashboard features, mention existing CSS patterns"}],"generated_skill_verdict":{}}'
echo "$_mock_outcome" > "$_test_artifacts/skill-outcome.json"

# Verify outcome JSON is valid
assert_true "jq '.' '$_test_artifacts/skill-outcome.json' >/dev/null 2>&1" "outcome JSON is valid"

# Verify verdict extraction
_verdict=$(jq -r '.skill_effectiveness["frontend-design"].verdict' "$_test_artifacts/skill-outcome.json" 2>/dev/null)
assert_eq "effective" "$_verdict" "verdict extracted correctly"

# Verify refinement extraction
_refinement_skill=$(jq -r '.refinements[0].skill' "$_test_artifacts/skill-outcome.json" 2>/dev/null)
assert_eq "frontend-design" "$_refinement_skill" "refinement skill extracted"

echo ""
echo "  ── Refinement file writing ──"

# Test: skill_apply_refinements writes patch files
_ref_dir="${SKILLS_DIR}/generated/_refinements"
mkdir -p "$_ref_dir"
skill_apply_refinements "$_test_artifacts/skill-outcome.json" 2>/dev/null || true
assert_true "[[ -f '$_ref_dir/frontend-design.patch.md' ]]" "refinement patch file created"
_ref_content=$(cat "$_ref_dir/frontend-design.patch.md" 2>/dev/null || true)
assert_contains "$_ref_content" "dashboard" "refinement content written"
rm -f "$_ref_dir/frontend-design.patch.md"

echo ""
echo "  ── Generated skill lifecycle ──"

# Test: prune verdict deletes generated skill
mkdir -p "${SKILLS_DIR}/generated"
echo "## Temp Skill" > "${SKILLS_DIR}/generated/temp-skill.md"
_prune_outcome='{"skill_effectiveness":{},"refinements":[],"generated_skill_verdict":{"temp-skill":"prune"}}'
echo "$_prune_outcome" > "$_test_artifacts/skill-outcome.json"
skill_apply_lifecycle_verdicts "$_test_artifacts/skill-outcome.json" 2>/dev/null || true
assert_true "[[ ! -f '${SKILLS_DIR}/generated/temp-skill.md' ]]" "pruned skill deleted"

rm -rf "$_test_artifacts"


# ═══════════════════════════════════════════════════════════════════════════════
# Suite 14: Full AI Integration
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══ Suite 14: Full AI Integration ═══"
echo ""

echo "  ── End-to-end skill flow ──"

# Test: catalog → plan → load → outcome cycle
_e2e_dir=$(mktemp -d)

# 1. Build catalog (should include all 17 curated skills)
_catalog=$(skill_build_catalog 2>/dev/null || true)
_catalog_lines=$(echo "$_catalog" | grep -c '^-' 2>/dev/null || echo "0")
assert_true "[[ $_catalog_lines -ge 17 ]]" "catalog has at least 17 skills (got $_catalog_lines)"

# 2. Write a skill plan (simulating what skill_analyze_issue would produce)
cat > "$_e2e_dir/skill-plan.json" << 'E2E_PLAN'
{
  "issue_type": "api",
  "confidence": 0.88,
  "skill_plan": {
    "plan": ["brainstorming", "api-design"],
    "build": ["api-design"],
    "review": ["two-stage-review", "security-audit"]
  },
  "skill_rationale": {
    "api-design": "REST endpoint versioning needed",
    "brainstorming": "Multiple valid API approaches",
    "two-stage-review": "Spec compliance for API contract",
    "security-audit": "Auth endpoint requires security review"
  },
  "generated_skills": []
}
E2E_PLAN

# 3. Load from plan for each stage
ARTIFACTS_DIR="$_e2e_dir" _plan_out=$(skill_load_from_plan "plan" 2>/dev/null || true)
ARTIFACTS_DIR="$_e2e_dir" _build_out=$(skill_load_from_plan "build" 2>/dev/null || true)
ARTIFACTS_DIR="$_e2e_dir" _review_out=$(skill_load_from_plan "review" 2>/dev/null || true)

assert_contains "$_plan_out" "api-design" "plan loads api-design skill"
assert_contains "$_plan_out" "REST endpoint" "plan includes rationale"
assert_contains "$_build_out" "api-design" "build loads api-design"
assert_not_contains "$_build_out" "brainstorming" "build doesn't load plan-only skills"
assert_contains "$_review_out" "two-stage-review" "review loads two-stage-review"
assert_contains "$_review_out" "security-audit" "review loads security-audit"

# 4. Test fallback chain (no plan → adaptive → static)
_no_plan_dir=$(mktemp -d)
_fallback_out=$(ARTIFACTS_DIR="$_no_plan_dir" INTELLIGENCE_ISSUE_TYPE="frontend" skill_load_from_plan "plan" 2>/dev/null || true)
assert_contains "$_fallback_out" "brainstorming\|frontend\|Socratic" "fallback produces output when no plan exists"

# 5. Verify generated skill directory structure
assert_true "[[ -d '$SKILLS_DIR/generated' ]]" "generated skills directory exists"
assert_true "[[ -d '$SKILLS_DIR/generated/_refinements' ]]" "refinements directory exists"

rm -rf "$_e2e_dir" "$_no_plan_dir"


# ═══════════════════════════════════════════════════════════════════════════════
# RESULTS
# ═══════════════════════════════════════════════════════════════════════════════

echo ""
echo "═══════════════════════════════════════════"
TOTAL=$((PASS + FAIL))
if [[ "$FAIL" -eq 0 ]]; then
    printf "\033[32m  ALL %d TESTS PASSED ✓\033[0m\n" "$TOTAL"
else
    printf "\033[31m  %d/%d PASSED, %d FAILED\033[0m\n" "$PASS" "$TOTAL" "$FAIL"
    echo ""
    echo "  Failures:"
    echo -e "$ERRORS"
fi
echo "═══════════════════════════════════════════"
echo ""

exit "$FAIL"