shipwright-cli 2.4.0 → 3.0.0

package/scripts/sw-intelligence.sh

@@ -6,7 +6,7 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="2.4.0"
+VERSION="3.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="${REPO_DIR:-$(cd "$SCRIPT_DIR/.." && pwd)}"
 
@@ -17,6 +17,8 @@ REPO_DIR="${REPO_DIR:-$(cd "$SCRIPT_DIR/.." && pwd)}"
 # Canonical helpers (colors, output, events)
 # shellcheck source=lib/helpers.sh
 [[ -f "$SCRIPT_DIR/lib/helpers.sh" ]] && source "$SCRIPT_DIR/lib/helpers.sh"
+[[ -f "$SCRIPT_DIR/lib/config.sh" ]] && source "$SCRIPT_DIR/lib/config.sh"
+[[ -f "$SCRIPT_DIR/sw-db.sh" ]] && source "$SCRIPT_DIR/sw-db.sh"
 # Fallbacks when helpers not loaded (e.g. test env with overridden SCRIPT_DIR)
 [[ "$(type -t info 2>/dev/null)" == "function" ]]    || info()    { echo -e "\033[38;2;0;212;255m\033[1m▸\033[0m $*"; }
 [[ "$(type -t success 2>/dev/null)" == "function" ]] || success() { echo -e "\033[38;2;74;222;128m\033[1m✓\033[0m $*"; }
@@ -34,22 +36,104 @@ if [[ "$(type -t emit_event 2>/dev/null)" != "function" ]]; then
     echo "${payload}}" >> "${HOME}/.shipwright/events.jsonl"
   }
 fi
-CYAN="${CYAN:-\033[38;2;0;212;255m}"
-PURPLE="${PURPLE:-\033[38;2;124;58;237m}"
-BLUE="${BLUE:-\033[38;2;0;102;255m}"
-GREEN="${GREEN:-\033[38;2;74;222;128m}"
-YELLOW="${YELLOW:-\033[38;2;250;204;21m}"
-RED="${RED:-\033[38;2;248;113;113m}"
-DIM="${DIM:-\033[2m}"
-BOLD="${BOLD:-\033[1m}"
-RESET="${RESET:-\033[0m}"
+# ─── Bootstrap (cold-start) ──────────────────────────────────────────────────
+# Ensure optimization data exists when intelligence is first used
+[[ -f "$SCRIPT_DIR/lib/bootstrap.sh" ]] && source "$SCRIPT_DIR/lib/bootstrap.sh"
+if type bootstrap_optimization &>/dev/null 2>&1; then
+    if [[ ! -f "$HOME/.shipwright/optimization/iteration-model.json" ]]; then
+        bootstrap_optimization 2>/dev/null || true
+    fi
+fi
 
 # ─── Intelligence Configuration ─────────────────────────────────────────────
 INTELLIGENCE_CACHE="${REPO_DIR}/.claude/intelligence-cache.json"
 INTELLIGENCE_CONFIG_DIR="${HOME}/.shipwright/optimization"
 CACHE_TTL_CONFIG="${INTELLIGENCE_CONFIG_DIR}/cache-ttl.json"
 CACHE_STATS_FILE="${INTELLIGENCE_CONFIG_DIR}/cache-stats.json"
-DEFAULT_CACHE_TTL=3600  # 1 hour (fallback)
+DEFAULT_CACHE_TTL=$(_config_get_int "intelligence.cache_ttl" 3600 2>/dev/null || echo 3600)  # 1 hour (fallback)
+
+# ─── Adaptive Thresholds ─────────────────────────────────────────────────────
+# Compute thresholds from historical metrics distribution (mean + N*stddev when DB available)
+
+adaptive_threshold() {
+    local metric_name="$1" default_value="${2:-3.0}" sigma_multiplier="${3:-2.0}"
+
+    if ! db_available 2>/dev/null; then
+        echo "$default_value"
+        return
+    fi
+
+    local stats
+    stats=$(_db_query "SELECT AVG(value) as mean,
+        CASE WHEN COUNT(*) > 1 THEN
+            SQRT(SUM((value - (SELECT AVG(value) FROM metrics WHERE metric_name = '$metric_name')) *
+                     (value - (SELECT AVG(value) FROM metrics WHERE metric_name = '$metric_name'))) / (COUNT(*) - 1))
+        ELSE 0 END as stddev,
+        COUNT(*) as n
+        FROM metrics WHERE metric_name = '$metric_name' AND created_at > datetime('now', '-30 days');" 2>/dev/null || echo "")
+
+    if [[ -z "$stats" ]]; then
+        echo "$default_value"
+        return
+    fi
+
+    local mean stddev n
+    IFS='|' read -r mean stddev n <<< "$stats"
+
+    # Need minimum sample size
+    if [[ "${n:-0}" -lt 10 ]]; then
+        echo "$default_value"
+        return
+    fi
+
+    # Adaptive: mean + sigma_multiplier * stddev
+    awk "BEGIN { printf \"%.2f\", $mean + ($sigma_multiplier * $stddev) }"
+}
+
+# Get adaptive anomaly threshold
+get_anomaly_threshold() {
+    adaptive_threshold "anomaly_score" "$(_config_get "intelligence.anomaly_threshold" 3.0)" 2.0
+}
+
+# Get adaptive quality threshold
+get_quality_threshold() {
+    local base
+    base=$(_config_get "quality.gate_score_threshold" 70)
+    # For quality, use percentile-based approach: mean - 1*stddev as minimum
+    if ! db_available 2>/dev/null; then
+        echo "$base"
+        return
+    fi
+
+    local mean_score
+    mean_score=$(_db_query "SELECT AVG(value) FROM metrics WHERE metric_name = 'quality_score' AND created_at > datetime('now', '-30 days');" 2>/dev/null || echo "")
+
+    if [[ -z "$mean_score" || "$mean_score" == "" ]]; then
+        echo "$base"
+        return
+    fi
+
+    # Use the higher of: base threshold or historical mean - 10%
+    local adaptive_min
+    adaptive_min=$(awk "BEGIN { printf \"%d\", $mean_score * 0.9 }")
+    if [[ "$adaptive_min" -gt "$base" ]]; then
+        echo "$adaptive_min"
+    else
+        echo "$base"
+    fi
+}
+
+# Store threshold values for debugging
+persist_thresholds() {
+    if db_available 2>/dev/null; then
+        local anomaly_t quality_t
+        anomaly_t=$(get_anomaly_threshold)
+        quality_t=$(get_quality_threshold)
+        _db_exec "INSERT OR REPLACE INTO _sync_metadata (key, value, updated_at) VALUES
+            ('threshold.anomaly', '$anomaly_t', '$(now_iso)'),
+            ('threshold.quality', '$quality_t', '$(now_iso)');" 2>/dev/null || true
+    fi
+}
 
 # Load adaptive cache TTL from config or use default
 _intelligence_get_cache_ttl() {
@@ -146,8 +230,15 @@ _intelligence_enabled() {
     local config="${REPO_DIR}/.claude/daemon-config.json"
     if [[ -f "$config" ]]; then
         local enabled
-        enabled=$(jq -r '.intelligence.enabled // false' "$config" 2>/dev/null || echo "false")
-        [[ "$enabled" == "true" ]]
+        enabled=$(jq -r '.intelligence.enabled // "auto"' "$config" 2>/dev/null || echo "auto")
+        if [[ "$enabled" == "true" ]]; then
+            return 0
+        elif [[ "$enabled" == "auto" ]]; then
+            # Auto: enabled when Claude CLI is available
+            command -v claude &>/dev/null
+        else
+            return 1
+        fi
     else
         return 1
     fi
@@ -248,9 +339,11 @@ _intelligence_call_claude() {
 
     # Call Claude (--print mode returns raw text response)
     # Use timeout (gtimeout on macOS via coreutils, timeout on Linux) to prevent hangs
+    local _claude_timeout
+    _claude_timeout=$(_config_get_int "intelligence.claude_timeout" 60 2>/dev/null || echo 60)
     local _timeout_cmd=""
-    if command -v gtimeout &>/dev/null; then _timeout_cmd="gtimeout 60"
-    elif command -v timeout &>/dev/null; then _timeout_cmd="timeout 60"
+    if command -v gtimeout >/dev/null 2>&1; then _timeout_cmd="gtimeout $_claude_timeout"
+    elif command -v timeout >/dev/null 2>&1; then _timeout_cmd="timeout $_claude_timeout"
     fi
 
     local response
@@ -291,6 +384,86 @@ _intelligence_call_claude() {
     return 0
 }
 
+# ─── Data-Driven Fallbacks (when Claude unavailable) ─────────────────────────
+
+_intelligence_fallback_analyze() {
+    local title="$1" body="$2" labels="$3"
+
+    local complexity=5 risk="medium" probability=50 template="standard"
+
+    # Try historical data first
+    local outcomes_file="$HOME/.shipwright/optimization/outcomes.jsonl"
+    if [[ -f "$outcomes_file" ]] && command -v jq &>/dev/null; then
+        local sample_count
+        sample_count=$(wc -l < "$outcomes_file" 2>/dev/null || echo "0")
+
+        if [[ "$sample_count" -gt 5 ]]; then
+            # Compute average complexity from past outcomes
+            local avg_complexity
+            avg_complexity=$(tail -100 "$outcomes_file" | jq -s '[.[].complexity // 5 | tonumber] | add / length | floor' 2>/dev/null || echo "5")
+            [[ "$avg_complexity" -gt 0 && "$avg_complexity" -le 10 ]] && complexity=$avg_complexity
+
+            # Compute success probability from past outcomes (result: success|failure)
+            local success_rate
+            success_rate=$(tail -100 "$outcomes_file" | jq -s '[.[] | select(has("result")) | .result // "failure"] | (map(select(. == "success" or . == "completed")) | length) as $s | length as $t | if $t > 0 then ($s * 100 / $t | floor) else 50 end' 2>/dev/null || echo "50")
+            [[ "$success_rate" -gt 0 ]] && probability=$success_rate
+        fi
+    fi
+
+    # Label-based heuristics (better than nothing)
+    if echo "$labels" | grep -qiE 'bug|fix|hotfix' 2>/dev/null; then
+        complexity=$((complexity > 3 ? complexity - 2 : complexity))
+        risk="low"
+        template="hotfix"
+    elif echo "$labels" | grep -qiE 'feature|enhancement' 2>/dev/null; then
+        complexity=$((complexity + 1 > 10 ? 10 : complexity + 1))
+        template="standard"
+    elif echo "$labels" | grep -qiE 'refactor|cleanup' 2>/dev/null; then
+        risk="low"
+        template="standard"
+    elif echo "$labels" | grep -qiE 'security|vulnerability' 2>/dev/null; then
+        risk="high"
+        template="standard"
+    fi
+
+    # Title-based heuristics — use awk (no wc/tr dependency)
+    local word_count
+    word_count=$(echo "$title $body" | awk '{print NF}' 2>/dev/null || echo "5")
+    if [[ "$word_count" -lt 10 ]]; then
+        complexity=$((complexity > 2 ? complexity - 1 : complexity))
+    elif [[ "$word_count" -gt 100 ]]; then
+        complexity=$((complexity + 2 > 10 ? 10 : complexity + 2))
+    fi
+
+    echo "{\"complexity\":$complexity,\"risk_level\":\"$risk\",\"success_probability\":$probability,\"recommended_template\":\"$template\"}"
+}
+
+_intelligence_fallback_cost() {
+    local events_file="$HOME/.shipwright/events.jsonl"
+    local avg_cost=0
+    if [[ -f "$events_file" ]]; then
+        avg_cost=$(grep '"pipeline.completed"' "$events_file" | tail -20 | jq -r '.cost_usd // .total_cost // 0' 2>/dev/null | awk '{s+=$1; n++} END{if(n>0) printf "%.2f", s/n; else print "0"}')
+    fi
+    echo "{\"estimated_cost_usd\":$avg_cost,\"confidence\":\"historical\"}"
+}
+
+_intelligence_fallback_compose() {
+    local issue_analysis="${1:-"{}"}"
+    local complexity risk_level
+    complexity=$(echo "$issue_analysis" | jq -r '.complexity // 5' 2>/dev/null || echo "5")
+    risk_level=$(echo "$issue_analysis" | jq -r '.risk_level // "medium"' 2>/dev/null || echo "medium")
+    # Build sensible default stages from complexity: low=minimal, high=full
+    local stages_json
+    if [[ "$complexity" -le 3 ]]; then
+        stages_json='[{"id":"intake","enabled":true,"model":"sonnet","config":{}},{"id":"build","enabled":true,"model":"sonnet","config":{}},{"id":"test","enabled":true,"model":"sonnet","config":{}},{"id":"pr","enabled":true,"model":"sonnet","config":{}}]'
+    elif [[ "$complexity" -ge 8 ]]; then
+        stages_json='[{"id":"intake","enabled":true,"model":"opus","config":{}},{"id":"plan","enabled":true,"model":"opus","config":{}},{"id":"design","enabled":true,"model":"opus","config":{}},{"id":"build","enabled":true,"model":"sonnet","config":{}},{"id":"test","enabled":true,"model":"sonnet","config":{}},{"id":"review","enabled":true,"model":"sonnet","config":{}},{"id":"pr","enabled":true,"model":"sonnet","config":{}}]'
+    else
+        stages_json='[{"id":"intake","enabled":true,"model":"sonnet","config":{}},{"id":"build","enabled":true,"model":"sonnet","config":{}},{"id":"test","enabled":true,"model":"sonnet","config":{}},{"id":"pr","enabled":true,"model":"sonnet","config":{}}]'
+    fi
+    echo "{\"stages\":$stages_json,\"rationale\":\"data-driven fallback from complexity=$complexity risk=$risk_level\"}"
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # PUBLIC FUNCTIONS
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -300,16 +473,25 @@ _intelligence_call_claude() {
 intelligence_analyze_issue() {
     local issue_json="${1:-"{}"}"
 
-    if ! _intelligence_enabled; then
-        echo '{"error":"intelligence_disabled","complexity":5,"risk_level":"medium","success_probability":50,"recommended_template":"standard","key_risks":[],"implementation_hints":[]}'
-        return 0
-    fi
-
     local title body labels
     title=$(echo "$issue_json" | jq -r '.title // "untitled"' 2>/dev/null || echo "untitled")
     body=$(echo "$issue_json" | jq -r '.body // ""' 2>/dev/null || echo "")
     labels=$(echo "$issue_json" | jq -r '(.labels // []) | join(", ")' 2>/dev/null || echo "")
 
+    if ! _intelligence_enabled; then
+        local fallback merged
+        fallback=$(_intelligence_fallback_analyze "$title" "$body" "$labels" 2>/dev/null) || true
+        if [[ -n "$fallback" ]]; then
+            merged=$(printf '%s' "$fallback" | jq -c '. + {error: "intelligence_disabled", key_risks: [], implementation_hints: []}' 2>/dev/null)
+        fi
+        if [[ -n "${merged:-}" ]]; then
+            echo "$merged"
+        else
+            echo '{"error":"intelligence_disabled","complexity":5,"risk_level":"medium","success_probability":50,"recommended_template":"standard","key_risks":[],"implementation_hints":[]}'
+        fi
+        return 0
+    fi
+
     local prompt
     prompt="Analyze this GitHub issue for a software project and return ONLY a JSON object (no markdown, no explanation).
 
@@ -337,8 +519,8 @@ Return JSON with exactly these fields:
         valid=$(echo "$result" | jq 'has("complexity") and has("risk_level") and has("success_probability") and has("recommended_template")' 2>/dev/null || echo "false")
 
         if [[ "$valid" != "true" ]]; then
-            warn "Intelligence response missing required fields, using fallback"
-            result='{"complexity":5,"risk_level":"medium","success_probability":50,"recommended_template":"standard","key_risks":["analysis_incomplete"],"implementation_hints":[]}'
+            warn "Intelligence response missing required fields, using data-driven fallback"
+            result=$(_intelligence_fallback_analyze "$title" "$body" "$labels" | jq -c '. + {key_risks: ["analysis_incomplete"], implementation_hints: []}')
         fi
 
         emit_event "intelligence.analysis" \
@@ -353,7 +535,9 @@ Return JSON with exactly these fields:
         echo "$result"
         return 0
     else
-        echo '{"error":"analysis_failed","complexity":5,"risk_level":"medium","success_probability":50,"recommended_template":"standard","key_risks":["analysis_failed"],"implementation_hints":[]}'
+        local fallback
+        fallback=$(_intelligence_fallback_analyze "$title" "$body" "$labels")
+        echo "$fallback" | jq -c '. + {error: "analysis_failed", key_risks: ["analysis_failed"], implementation_hints: []}' 2>/dev/null || echo '{"error":"analysis_failed","complexity":5,"risk_level":"medium","success_probability":50,"recommended_template":"standard","key_risks":["analysis_failed"],"implementation_hints":[]}'
         return 0
     fi
 }
@@ -366,7 +550,9 @@ intelligence_compose_pipeline() {
     local budget="${3:-0}"
 
     if ! _intelligence_enabled; then
-        echo '{"error":"intelligence_disabled","stages":[]}'
+        local fallback
+        fallback=$(_intelligence_fallback_compose "$issue_analysis")
+        echo "$fallback" | jq -c '. + {error: "intelligence_disabled"}' 2>/dev/null || echo '{"error":"intelligence_disabled","stages":[]}'
         return 0
     fi
 
@@ -402,8 +588,8 @@ Return ONLY a JSON object (no markdown):
         has_stages=$(echo "$result" | jq 'has("stages") and (.stages | type == "array")' 2>/dev/null || echo "false")
 
         if [[ "$has_stages" != "true" ]]; then
-            warn "Pipeline composition missing stages array, using fallback"
-            result='{"stages":[{"id":"intake","enabled":true,"model":"sonnet","config":{}},{"id":"build","enabled":true,"model":"sonnet","config":{}},{"id":"test","enabled":true,"model":"sonnet","config":{}},{"id":"pr","enabled":true,"model":"sonnet","config":{}}],"rationale":"fallback pipeline"}'
+            warn "Pipeline composition missing stages array, using data-driven fallback"
+            result=$(_intelligence_fallback_compose "$issue_analysis")
         fi
 
         emit_event "intelligence.compose" \
@@ -413,7 +599,9 @@ Return ONLY a JSON object (no markdown):
         echo "$result"
         return 0
     else
-        echo '{"error":"composition_failed","stages":[]}'
+        local fallback
+        fallback=$(_intelligence_fallback_compose "$issue_analysis")
+        echo "$fallback" | jq -c '. + {error: "composition_failed"}' 2>/dev/null || echo '{"error":"composition_failed","stages":[]}'
         return 0
     fi
 }
@@ -425,7 +613,9 @@ intelligence_predict_cost() {
     local historical_data="${2:-"{}"}"
 
     if ! _intelligence_enabled; then
-        echo '{"error":"intelligence_disabled","estimated_cost_usd":0,"estimated_iterations":0,"likely_failure_stage":"unknown"}'
+        local fallback
+        fallback=$(_intelligence_fallback_cost)
+        echo "$fallback" | jq -c '. + {error: "intelligence_disabled", estimated_iterations: 0, likely_failure_stage: "unknown"}' 2>/dev/null || echo '{"error":"intelligence_disabled","estimated_cost_usd":0,"estimated_iterations":0,"likely_failure_stage":"unknown"}'
         return 0
     fi
 
@@ -456,8 +646,8 @@ Based on similar complexity (${complexity}/10) issues, estimate:
         valid=$(echo "$result" | jq 'has("estimated_cost_usd") and has("estimated_iterations")' 2>/dev/null || echo "false")
 
         if [[ "$valid" != "true" ]]; then
-            warn "Cost prediction missing required fields, using fallback"
-            result='{"estimated_cost_usd":5.0,"estimated_iterations":3,"estimated_tokens":500000,"likely_failure_stage":"test","confidence":30}'
+            warn "Cost prediction missing required fields, using data-driven fallback"
+            result=$(_intelligence_fallback_cost | jq -c '. + {estimated_iterations: 3, estimated_tokens: 500000, likely_failure_stage: "test", confidence: 30}')
         fi
 
         emit_event "intelligence.prediction" \
@@ -468,7 +658,9 @@ Based on similar complexity (${complexity}/10) issues, estimate:
         echo "$result"
         return 0
     else
-        echo '{"error":"prediction_failed","estimated_cost_usd":0,"estimated_iterations":0,"likely_failure_stage":"unknown"}'
+        local fallback
+        fallback=$(_intelligence_fallback_cost)
+        echo "$fallback" | jq -c '. + {error: "prediction_failed", estimated_iterations: 0, likely_failure_stage: "unknown"}' 2>/dev/null || echo '{"error":"prediction_failed","estimated_cost_usd":0,"estimated_iterations":0,"likely_failure_stage":"unknown"}'
         return 0
     fi
 }
@@ -712,11 +904,24 @@ intelligence_recommend_model() {
     local model="sonnet"
     local reason="default balanced choice"
 
+    # Budget-constrained: always use haiku regardless of routing (highest priority)
+    if [[ "$budget_remaining" != "" ]] && [[ "$(awk -v b="$budget_remaining" 'BEGIN{print (b+0<5)?1:0}')" == "1" ]]; then
+        model="haiku"
+        reason="budget constrained (< \$5 remaining)"
+        local result
+        result=$(jq -n --arg model "$model" --arg reason "$reason" --arg stage "$stage" --argjson complexity "$complexity" \
+            '{"model": $model, "reason": $reason, "stage": $stage, "complexity": $complexity, "source": "heuristic"}')
+        emit_event "intelligence.model" "stage=$stage" "complexity=$complexity" "model=$model" "source=heuristic"
+        echo "$result"
+        return 0
+    fi
+
     # Strategy 1: Check historical model routing data
     local routing_file="${HOME}/.shipwright/optimization/model-routing.json"
     if [[ -f "$routing_file" ]]; then
+        # Support both formats: .routes.stage (self-optimize) and .stage (legacy)
         local stage_data
-        stage_data=$(jq -r --arg s "$stage" '.[$s] // empty' "$routing_file" 2>/dev/null || true)
+        stage_data=$(jq -r --arg s "$stage" '.routes[$s] // .[$s] // empty' "$routing_file" 2>/dev/null || true)
 
         if [[ -n "$stage_data" && "$stage_data" != "null" ]]; then
             local recommended sonnet_rate sonnet_samples opus_rate opus_samples
@@ -769,7 +974,7 @@ intelligence_recommend_model() {
             fi
 
             if [[ "$use_sonnet" == "true" ]]; then
-                if [[ "$budget_remaining" != "" ]] && [[ "$(echo "$budget_remaining < 5" | bc 2>/dev/null || echo "0")" == "1" ]]; then
+                if [[ "$budget_remaining" != "" ]] && [[ "$(awk -v b="$budget_remaining" 'BEGIN{print (b+0<5)?1:0}')" == "1" ]]; then
                     model="haiku"
                     reason="sonnet viable (${sonnet_rate}% success) but budget constrained"
                 else
@@ -786,7 +991,7 @@ intelligence_recommend_model() {
                 case "$stage" in
                     plan|design|review|compound_quality)
                         if [[ "$model" != "opus" ]]; then
-                            if [[ "$budget_remaining" == "" ]] || [[ "$(echo "$budget_remaining >= 10" | bc 2>/dev/null || echo "1")" == "1" ]]; then
+                            if [[ "$budget_remaining" == "" ]] || [[ "$(awk -v b="$budget_remaining" 'BEGIN{print (b+0>=10)?1:0}')" == "1" ]]; then
                                 model="opus"
                                 reason="high complexity (${complexity}/10) overrides historical for critical stage (${stage})"
                             fi
@@ -812,7 +1017,7 @@ intelligence_recommend_model() {
 
     # Strategy 2: Heuristic fallback (no historical data available)
     # Budget-constrained: use haiku
-    if [[ "$budget_remaining" != "" ]] && [[ "$(echo "$budget_remaining < 5" | bc 2>/dev/null || echo "0")" == "1" ]]; then
+    if [[ "$budget_remaining" != "" ]] && [[ "$(awk -v b="$budget_remaining" 'BEGIN{print (b+0<5)?1:0}')" == "1" ]]; then
         model="haiku"
         reason="budget constrained (< \$5 remaining)"
     # High complexity + critical stages: use opus
@@ -865,13 +1070,46 @@ intelligence_recommend_model() {
 
 # ─── Prediction Validation ─────────────────────────────────────────────────
 
-# intelligence_validate_prediction <issue_id> <predicted_complexity> <actual_iterations> <actual_success>
-# Compares predicted complexity to actual outcome for feedback learning.
+# intelligence_validate_prediction [<metric>|<issue_id>] <predicted> <actual> [<actual_success>]
+# Compares predicted vs actual for feedback learning.
+# Form 1 (complexity): intelligence_validate_prediction <issue_id> <predicted_complexity> <actual_iterations> <actual_success>
+# Form 2 (iterations): intelligence_validate_prediction "iterations" <predicted> <actual>
+# Form 3 (cost):       intelligence_validate_prediction "cost" <predicted> <actual>
 intelligence_validate_prediction() {
-    local issue_id="${1:-}"
-    local predicted_complexity="${2:-0}"
-    local actual_iterations="${3:-0}"
-    local actual_success="${4:-false}"
+    local arg1="${1:-}"
+    local arg2="${2:-0}"
+    local arg3="${3:-0}"
+    local arg4="${4:-false}"
+
+    # Form 2 & 3: metric-based validation (iterations, cost)
+    if [[ "$arg1" == "iterations" || "$arg1" == "cost" ]]; then
+        local metric="$arg1"
+        local predicted="$arg2"
+        local actual="$arg3"
+        [[ -z "$predicted" || "$predicted" == "null" ]] && return 0
+        local validation_file="${HOME}/.shipwright/optimization/prediction-validation.jsonl"
+        mkdir -p "${HOME}/.shipwright/optimization"
+        local delta
+        delta=$(awk -v p="$predicted" -v a="$actual" 'BEGIN { printf "%.2f", p - a }' 2>/dev/null || echo "0")
+        local record
+        record=$(jq -c -n \
+            --arg ts "$(now_iso)" \
+            --arg issue "${ISSUE_NUMBER:-unknown}" \
+            --arg m "$metric" \
+            --arg pred "$predicted" \
+            --arg act "$actual" \
+            --arg d "$delta" \
+            '{ts: $ts, issue: $issue, metric: $m, predicted: ($pred | tonumber? // 0), actual: ($act | tonumber? // 0), delta: ($d | tonumber? // 0)}')
+        echo "$record" >> "$validation_file"
+        emit_event "intelligence.prediction_validated" "metric=$metric" "predicted=$predicted" "actual=$actual" "delta=$delta"
+        return 0
+    fi
+
+    # Form 1: complexity validation (original)
+    local issue_id="$arg1"
+    local predicted_complexity="$arg2"
+    local actual_iterations="$arg3"
+    local actual_success="$arg4"
 
     if [[ -z "$issue_id" ]]; then
         error "Usage: intelligence_validate_prediction <issue_id> <predicted> <actual_iterations> <actual_success>"
@@ -968,7 +1206,7 @@ intelligence_github_enrich() {
     local analysis_json="$1"
 
     # Skip if GraphQL not available
-    type _gh_detect_repo &>/dev/null 2>&1 || { echo "$analysis_json"; return 0; }
+    type _gh_detect_repo >/dev/null 2>&1 || { echo "$analysis_json"; return 0; }
     _gh_detect_repo 2>/dev/null || { echo "$analysis_json"; return 0; }
 
     local owner="${GH_OWNER:-}" repo="${GH_REPO:-}"
@@ -976,13 +1214,13 @@ intelligence_github_enrich() {
 
     # Get repo context
     local repo_context="{}"
-    if type gh_repo_context &>/dev/null 2>&1; then
+    if type gh_repo_context >/dev/null 2>&1; then
         repo_context=$(gh_repo_context "$owner" "$repo" 2>/dev/null || echo "{}")
     fi
 
     # Get security alerts count
     local security_count=0
-    if type gh_security_alerts &>/dev/null 2>&1; then
+    if type gh_security_alerts >/dev/null 2>&1; then
         local alerts
         alerts=$(gh_security_alerts "$owner" "$repo" 2>/dev/null || echo "[]")
         security_count=$(echo "$alerts" | jq 'length' 2>/dev/null || echo "0")
@@ -990,7 +1228,7 @@ intelligence_github_enrich() {
 
     # Get dependabot alerts count
     local dependabot_count=0
-    if type gh_dependabot_alerts &>/dev/null 2>&1; then
+    if type gh_dependabot_alerts >/dev/null 2>&1; then
         local deps
         deps=$(gh_dependabot_alerts "$owner" "$repo" 2>/dev/null || echo "[]")
         dependabot_count=$(echo "$deps" | jq 'length' 2>/dev/null || echo "0")
@@ -1011,7 +1249,7 @@ intelligence_file_risk_score() {
     local file_path="$1"
     local risk_score=0
 
-    type _gh_detect_repo &>/dev/null 2>&1 || { echo "0"; return 0; }
+    type _gh_detect_repo >/dev/null 2>&1 || { echo "0"; return 0; }
     _gh_detect_repo 2>/dev/null || { echo "0"; return 0; }
 
     local owner="${GH_OWNER:-}" repo="${GH_REPO:-}"
@@ -1019,7 +1257,7 @@ intelligence_file_risk_score() {
 
     # Factor 1: File churn (high change frequency = higher risk)
     local changes=0
-    if type gh_file_change_frequency &>/dev/null 2>&1; then
+    if type gh_file_change_frequency >/dev/null 2>&1; then
         changes=$(gh_file_change_frequency "$owner" "$repo" "$file_path" 30 2>/dev/null || echo "0")
     fi
     if [[ "${changes:-0}" -gt 20 ]]; then
@@ -1031,7 +1269,7 @@ intelligence_file_risk_score() {
     fi
 
     # Factor 2: Security alerts on this file
-    if type gh_security_alerts &>/dev/null 2>&1; then
+    if type gh_security_alerts >/dev/null 2>&1; then
         local file_alerts
         file_alerts=$(gh_security_alerts "$owner" "$repo" 2>/dev/null | \
             jq --arg path "$file_path" '[.[] | select(.most_recent_instance.location.path == $path)] | length' 2>/dev/null || echo "0")
@@ -1039,7 +1277,7 @@ intelligence_file_risk_score() {
     fi
 
     # Factor 3: Many contributors = higher coordination risk
-    if type gh_blame_data &>/dev/null 2>&1; then
+    if type gh_blame_data >/dev/null 2>&1; then
         local author_count
         author_count=$(gh_blame_data "$owner" "$repo" "$file_path" 2>/dev/null | jq 'length' 2>/dev/null || echo "0")
         [[ "${author_count:-0}" -gt 5 ]] && risk_score=$((risk_score + 10))
@@ -1053,13 +1291,13 @@ intelligence_file_risk_score() {
 intelligence_contributor_expertise() {
     local file_path="$1"
 
-    type _gh_detect_repo &>/dev/null 2>&1 || { echo "[]"; return 0; }
+    type _gh_detect_repo >/dev/null 2>&1 || { echo "[]"; return 0; }
     _gh_detect_repo 2>/dev/null || { echo "[]"; return 0; }
 
     local owner="${GH_OWNER:-}" repo="${GH_REPO:-}"
     [[ -z "$owner" || -z "$repo" ]] && { echo "[]"; return 0; }
 
-    if type gh_blame_data &>/dev/null 2>&1; then
+    if type gh_blame_data >/dev/null 2>&1; then
         gh_blame_data "$owner" "$repo" "$file_path" 2>/dev/null || echo "[]"
     else
         echo "[]"
@@ -1085,6 +1323,7 @@ show_help() {
     echo -e "  ${CYAN}search-memory${RESET} <context> [dir]  Search memory by relevance"
     echo -e "  ${CYAN}estimate-iterations${RESET} <analysis>  Estimate build iterations"
     echo -e "  ${CYAN}recommend-model${RESET} <stage> [cplx] Recommend model for stage"
+    echo -e "  ${CYAN}status${RESET}                         Show intelligence status and config"
     echo -e "  ${CYAN}cache-stats${RESET}                    Show cache statistics"
     echo -e "  ${CYAN}validate-prediction${RESET} <id> <pred> <iters> <success>  Validate prediction accuracy"
     echo -e "  ${CYAN}cache-clear${RESET}                    Clear intelligence cache"
@@ -1097,6 +1336,75 @@ show_help() {
     echo -e "${DIM}Version ${VERSION}${RESET}"
 }
 
+cmd_status() {
+    # Find daemon-config (project root, cwd, or shipwright install)
+    local config=""
+    for cfg in "$(git rev-parse --show-toplevel 2>/dev/null)/.claude/daemon-config.json" "$(pwd)/.claude/daemon-config.json" "${REPO_DIR}/.claude/daemon-config.json"; do
+        [[ -n "$cfg" && -f "$cfg" ]] && config="$cfg" && break
+    done
+    local intel_enabled="auto"
+    if [[ -n "$config" && -f "$config" ]]; then
+        intel_enabled=$(jq -r '.intelligence.enabled // "auto"' "$config" 2>/dev/null || echo "auto")
+    fi
+
+    # Resolved: is intelligence actually enabled?
+    local resolved="disabled"
+    if [[ "$intel_enabled" == "true" ]]; then
+        resolved="enabled"
+    elif [[ "$intel_enabled" == "auto" ]]; then
+        if command -v claude &>/dev/null; then
+            resolved="enabled (auto)"
+        else
+            resolved="disabled (auto)"
+        fi
+    fi
+
+    # Cached analyses count (use same .claude as config when found)
+    local cache_file="$INTELLIGENCE_CACHE"
+    local cached_count=0
+    if [[ -n "$config" ]]; then
+        cache_file="$(dirname "$config")/intelligence-cache.json"
+    fi
+    if [[ -f "$cache_file" ]]; then
+        cached_count=$(jq '.entries | length' "$cache_file" 2>/dev/null || echo "0")
+    fi
+
+    # Memory entries count
+    local memory_dir="${HOME}/.shipwright/memory"
+    local memory_count=0
+    if [[ -d "$memory_dir" ]]; then
+        memory_count=$(find "$memory_dir" -name "*.json" -o -name "*.md" 2>/dev/null | wc -l | tr -d ' ')
+    fi
+
+    # Claude authenticated
+    local claude_ok="no"
+    if command -v claude &>/dev/null; then
+        if claude --version &>/dev/null; then
+            claude_ok="yes"
+        fi
+    fi
+
+    # Last intelligence call timestamp
+    local last_ts="never"
+    local events_file="${HOME}/.shipwright/events.jsonl"
+    if [[ -f "$events_file" ]]; then
+        local last_event
+        last_event=$(grep -E '"type":"intelligence\.' "$events_file" 2>/dev/null | tail -1)
+        if [[ -n "$last_event" ]]; then
+            last_ts=$(echo "$last_event" | jq -r '.ts // .ts_epoch // "unknown"' 2>/dev/null || echo "unknown")
+        fi
+    fi
+
+    echo ""
+    echo -e "${BOLD}Intelligence Status${RESET}"
+    echo -e "  Config:           ${CYAN}${intel_enabled}${RESET} — resolved: ${resolved}"
+    echo -e "  Cached analyses:  ${CYAN}${cached_count}${RESET}"
+    echo -e "  Memory entries:   ${CYAN}${memory_count}${RESET}"
+    echo -e "  Claude auth:      ${claude_ok}"
+    echo -e "  Last call:       ${DIM}${last_ts}${RESET}"
+    echo ""
+}
+
 cmd_cache_stats() {
     _intelligence_cache_init
 
@@ -1172,6 +1480,9 @@ main() {
         validate-prediction)
             intelligence_validate_prediction "$@"
             ;;
+        status)
+            cmd_status
+            ;;
         cache-stats)
             cmd_cache_stats
             ;;