shipwright-cli 1.7.1 → 1.9.0

package/scripts/{cct-loop.sh → sw-loop.sh}

@@ -8,10 +8,11 @@
 # ║  Inspired by Anthropic's autonomous 16-agent C compiler build.          ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-# ─── Colors (matches cct theme) ──────────────────────────────────────────────
+# ─── Colors (matches shipwright theme) ──────────────────────────────────────────────
 CYAN='\033[38;2;0;212;255m'
 PURPLE='\033[38;2;124;58;237m'
 BLUE='\033[38;2;0;102;255m'
@@ -22,6 +23,10 @@ DIM='\033[2m'
 BOLD='\033[1m'
 RESET='\033[0m'
 
+# ─── Cross-platform compatibility ──────────────────────────────────────────
+# shellcheck source=lib/compat.sh
+[[ -f "$SCRIPT_DIR/lib/compat.sh" ]] && source "$SCRIPT_DIR/lib/compat.sh"
+
 info()    { echo -e "${CYAN}${BOLD}▸${RESET} $*"; }
 success() { echo -e "${GREEN}${BOLD}✓${RESET} $*"; }
 warn()    { echo -e "${YELLOW}${BOLD}⚠${RESET} $*"; }
@@ -29,9 +34,9 @@ error()   { echo -e "${RED}${BOLD}✗${RESET} $*" >&2; }
 
 # ─── Defaults ─────────────────────────────────────────────────────────────────
 GOAL=""
-MAX_ITERATIONS=20
+MAX_ITERATIONS="${SW_MAX_ITERATIONS:-20}"
 TEST_CMD=""
-MODEL="opus"
+MODEL="${SW_MODEL:-opus}"
 AGENTS=1
 USE_WORKTREE=false
 SKIP_PERMISSIONS=false
@@ -39,7 +44,17 @@ MAX_TURNS=""
 RESUME=false
 VERBOSE=false
 MAX_ITERATIONS_EXPLICIT=false
-VERSION="1.7.1"
+VERSION="1.9.0"
+
+# ─── Flexible Iteration Defaults ────────────────────────────────────────────
+AUTO_EXTEND=true          # Auto-extend iterations when work is incomplete
+EXTENSION_SIZE=5          # Additional iterations per extension
+MAX_EXTENSIONS=3          # Max number of extensions (hard cap safety net)
+EXTENSION_COUNT=0         # Current number of extensions applied
+
+# ─── Circuit Breaker Defaults ──────────────────────────────────────────────
+CIRCUIT_BREAKER_THRESHOLD=3       # Consecutive low-progress iterations before stopping
+MIN_PROGRESS_LINES=5              # Minimum insertions to count as progress
 
 # ─── Audit & Quality Gate Defaults ───────────────────────────────────────────
 AUDIT_ENABLED=false
@@ -74,6 +89,9 @@ show_help() {
     echo -e "  ${CYAN}--audit-agent${RESET}             Run separate auditor agent (haiku) after each iteration"
     echo -e "  ${CYAN}--quality-gates${RESET}           Enable automated quality gates before accepting completion"
     echo -e "  ${CYAN}--definition-of-done${RESET} FILE DoD checklist file — evaluated by AI against git diff"
+    echo -e "  ${CYAN}--no-auto-extend${RESET}          Disable auto-extension when max iterations reached"
+    echo -e "  ${CYAN}--extension-size${RESET} N         Additional iterations per extension (default: 5)"
+    echo -e "  ${CYAN}--max-extensions${RESET} N         Max number of auto-extensions (default: 3)"
     echo ""
     echo -e "${BOLD}EXAMPLES${RESET}"
     echo -e "  ${DIM}shipwright loop \"Build user auth with JWT\"${RESET}"
@@ -83,11 +101,13 @@ show_help() {
     echo -e "  ${DIM}shipwright loop \"Add auth\" --audit --audit-agent --quality-gates${RESET}"
     echo -e "  ${DIM}shipwright loop \"Ship feature\" --quality-gates --definition-of-done dod.md${RESET}"
     echo ""
-    echo -e "${BOLD}CIRCUIT BREAKER${RESET}"
-    echo -e "  The loop automatically stops if:"
-    echo -e "  ${DIM}• 3 consecutive iterations with < 5 lines changed${RESET}"
-    echo -e "  ${DIM}• Claude outputs LOOP_COMPLETE (validated by quality gates if enabled)${RESET}"
-    echo -e "  ${DIM}• Max iterations reached${RESET}"
+    echo -e "${BOLD}COMPLETION & CIRCUIT BREAKER${RESET}"
+    echo -e "  The loop completes when:"
+    echo -e "  ${DIM}• Claude outputs LOOP_COMPLETE and all quality gates pass${RESET}"
+    echo -e "  ${DIM}• Max iterations reached (auto-extends if work is incomplete)${RESET}"
+    echo -e "  The loop stops (circuit breaker) if:"
+    echo -e "  ${DIM}• ${CIRCUIT_BREAKER_THRESHOLD} consecutive iterations with < ${MIN_PROGRESS_LINES} lines changed${RESET}"
+    echo -e "  ${DIM}• Hard cap reached (max_iterations + max_extensions * extension_size)${RESET}"
     echo -e "  ${DIM}• Ctrl-C (graceful shutdown with summary)${RESET}"
     echo ""
     echo -e "${BOLD}STATE & LOGS${RESET}"
@@ -142,6 +162,19 @@ while [[ $# -gt 0 ]]; do
             ;;
         --definition-of-done=*) DOD_FILE="${1#--definition-of-done=}"; shift ;;
         --quality-gates) QUALITY_GATES_ENABLED=true; shift ;;
+        --no-auto-extend) AUTO_EXTEND=false; shift ;;
+        --extension-size)
+            EXTENSION_SIZE="${2:-}"
+            [[ -z "$EXTENSION_SIZE" ]] && { error "Missing value for --extension-size"; exit 1; }
+            shift 2
+            ;;
+        --extension-size=*) EXTENSION_SIZE="${1#--extension-size=}"; shift ;;
+        --max-extensions)
+            MAX_EXTENSIONS="${2:-}"
+            [[ -z "$MAX_EXTENSIONS" ]] && { error "Missing value for --max-extensions"; exit 1; }
+            shift 2
+            ;;
+        --max-extensions=*) MAX_EXTENSIONS="${1#--max-extensions=}"; shift ;;
         --help|-h)
             show_help
             exit 0
@@ -191,6 +224,15 @@ if ! git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then
     exit 1
 fi
 
+# ─── Timeout Detection ────────────────────────────────────────────────────────
+TIMEOUT_CMD=""
+if command -v timeout &>/dev/null; then
+    TIMEOUT_CMD="timeout"
+elif command -v gtimeout &>/dev/null; then
+    TIMEOUT_CMD="gtimeout"
+fi
+CLAUDE_TIMEOUT="${CLAUDE_TIMEOUT:-1800}"  # 30 min default
+
 if [[ "$AGENTS" -gt 1 ]]; then
     if ! command -v tmux &>/dev/null; then
         error "tmux is required for multi-agent mode."
@@ -214,6 +256,114 @@ WORKTREE_DIR="$PROJECT_ROOT/.worktrees"
 
 mkdir -p "$STATE_DIR" "$LOG_DIR"
 
+# ─── Adaptive Model Selection ────────────────────────────────────────────────
+# Uses intelligence engine when available, falls back to defaults.
+select_adaptive_model() {
+    local role="${1:-build}"
+    local default_model="${2:-opus}"
+    # If user explicitly set --model, respect it
+    if [[ "$default_model" != "${SW_MODEL:-opus}" ]]; then
+        echo "$default_model"
+        return 0
+    fi
+    # Try intelligence-based recommendation
+    if type intelligence_recommend_model &>/dev/null 2>&1; then
+        local rec
+        rec=$(intelligence_recommend_model "$role" "${COMPLEXITY:-5}" "${BUDGET:-0}" 2>/dev/null || echo "")
+        if [[ -n "$rec" ]]; then
+            local recommended
+            recommended=$(echo "$rec" | jq -r '.model // ""' 2>/dev/null || echo "")
+            if [[ -n "$recommended" && "$recommended" != "null" ]]; then
+                echo "$recommended"
+                return 0
+            fi
+        fi
+    fi
+    echo "$default_model"
+}
+
+# Select audit/DoD model — uses haiku if success rate is high enough, else sonnet
+select_audit_model() {
+    local default_model="haiku"
+    local opt_file="$HOME/.shipwright/optimization/audit-tuning.json"
+    if [[ -f "$opt_file" ]] && command -v jq &>/dev/null; then
+        local success_rate
+        success_rate=$(jq -r '.haiku_success_rate // 100' "$opt_file" 2>/dev/null || echo "100")
+        if [[ "${success_rate%%.*}" -lt 90 ]]; then
+            echo "sonnet"
+            return 0
+        fi
+    fi
+    echo "$default_model"
+}
+
+# ─── Adaptive Iteration Budget ──────────────────────────────────────────────
+# Reads tuning config for smarter iteration/circuit-breaker thresholds.
+apply_adaptive_budget() {
+    local tuning_file="$HOME/.shipwright/optimization/loop-tuning.json"
+    if [[ -f "$tuning_file" ]] && command -v jq &>/dev/null; then
+        local tuned_max tuned_ext tuned_ext_count tuned_cb
+        tuned_max=$(jq -r '.max_iterations // ""' "$tuning_file" 2>/dev/null || echo "")
+        tuned_ext=$(jq -r '.extension_size // ""' "$tuning_file" 2>/dev/null || echo "")
+        tuned_ext_count=$(jq -r '.max_extensions // ""' "$tuning_file" 2>/dev/null || echo "")
+        tuned_cb=$(jq -r '.circuit_breaker_threshold // ""' "$tuning_file" 2>/dev/null || echo "")
+
+        # Only apply tuned values if user didn't explicitly set them
+        if ! $MAX_ITERATIONS_EXPLICIT && [[ -n "$tuned_max" && "$tuned_max" != "null" ]]; then
+            MAX_ITERATIONS="$tuned_max"
+        fi
+        [[ -n "$tuned_ext" && "$tuned_ext" != "null" ]] && EXTENSION_SIZE="$tuned_ext"
+        [[ -n "$tuned_ext_count" && "$tuned_ext_count" != "null" ]] && MAX_EXTENSIONS="$tuned_ext_count"
+        [[ -n "$tuned_cb" && "$tuned_cb" != "null" ]] && CIRCUIT_BREAKER_THRESHOLD="$tuned_cb"
+    fi
+
+    # Try intelligence-based iteration estimate
+    if type intelligence_estimate_iterations &>/dev/null 2>&1 && ! $MAX_ITERATIONS_EXPLICIT; then
+        local est
+        est=$(intelligence_estimate_iterations "${GOAL:-}" "${COMPLEXITY:-5}" 2>/dev/null || echo "")
+        if [[ -n "$est" && "$est" =~ ^[0-9]+$ ]]; then
+            MAX_ITERATIONS="$est"
+        fi
+    fi
+}
+
+# ─── Progress Velocity Tracking ─────────────────────────────────────────────
+ITERATION_LINES_CHANGED=""
+VELOCITY_HISTORY=""
+
+track_iteration_velocity() {
+    local changes
+    changes="$(git -C "$PROJECT_ROOT" diff --stat HEAD~1 2>/dev/null | tail -1 || echo "")"
+    local insertions
+    insertions="$(echo "$changes" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' || echo 0)"
+    ITERATION_LINES_CHANGED="${insertions:-0}"
+    if [[ -n "$VELOCITY_HISTORY" ]]; then
+        VELOCITY_HISTORY="${VELOCITY_HISTORY},${ITERATION_LINES_CHANGED}"
+    else
+        VELOCITY_HISTORY="${ITERATION_LINES_CHANGED}"
+    fi
+}
+
+# Compute average lines/iteration from recent history
+compute_velocity_avg() {
+    if [[ -z "$VELOCITY_HISTORY" ]]; then
+        echo "0"
+        return 0
+    fi
+    local total=0 count=0
+    local IFS=','
+    local val
+    for val in $VELOCITY_HISTORY; do
+        total=$((total + val))
+        count=$((count + 1))
+    done
+    if [[ "$count" -gt 0 ]]; then
+        echo $((total / count))
+    else
+        echo "0"
+    fi
+}
+
 # ─── Timing Helpers ───────────────────────────────────────────────────────────
 
 now_iso()   { date -u +%Y-%m-%dT%H:%M:%SZ; }
@@ -290,6 +440,9 @@ resume_state() {
                 audit_agent_enabled:*)   AUDIT_AGENT_ENABLED="$(echo "${line#audit_agent_enabled:}" | tr -d ' ')" ;;
                 quality_gates_enabled:*) QUALITY_GATES_ENABLED="$(echo "${line#quality_gates_enabled:}" | tr -d ' ')" ;;
                 dod_file:*)              DOD_FILE="$(echo "${line#dod_file:}" | sed 's/^ *"//;s/" *$//')" ;;
+                auto_extend:*)           AUTO_EXTEND="$(echo "${line#auto_extend:}" | tr -d ' ')" ;;
+                extension_count:*)       EXTENSION_COUNT="$(echo "${line#extension_count:}" | tr -d ' ')" ;;
+                max_extensions:*)        MAX_EXTENSIONS="$(echo "${line#max_extensions:}" | tr -d ' ')" ;;
             esac
         fi
     done < "$STATE_FILE"
@@ -345,6 +498,9 @@ audit_enabled: $AUDIT_ENABLED
 audit_agent_enabled: $AUDIT_AGENT_ENABLED
 quality_gates_enabled: $QUALITY_GATES_ENABLED
 dod_file: "$DOD_FILE"
+auto_extend: $AUTO_EXTEND
+extension_count: $EXTENSION_COUNT
+max_extensions: $MAX_EXTENSIONS
 ---
 
 ## Log
@@ -400,7 +556,7 @@ check_progress() {
     changes="$(git -C "$PROJECT_ROOT" diff --stat HEAD~1 2>/dev/null | tail -1 || echo "")"
     local insertions
     insertions="$(echo "$changes" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' || echo 0)"
-    if [[ "${insertions:-0}" -lt 5 ]]; then
+    if [[ "${insertions:-0}" -lt "$MIN_PROGRESS_LINES" ]]; then
         return 1  # No meaningful progress
     fi
     return 0
@@ -412,8 +568,8 @@ check_completion() {
 }
 
 check_circuit_breaker() {
-    if [[ "$CONSECUTIVE_FAILURES" -ge 3 ]]; then
-        error "Circuit breaker tripped: 3 consecutive iterations with no meaningful progress."
+    if [[ "$CONSECUTIVE_FAILURES" -ge "$CIRCUIT_BREAKER_THRESHOLD" ]]; then
+        error "Circuit breaker tripped: ${CIRCUIT_BREAKER_THRESHOLD} consecutive iterations with no meaningful progress."
         STATUS="circuit_breaker"
         return 1
     fi
@@ -421,12 +577,64 @@ check_circuit_breaker() {
 }
 
 check_max_iterations() {
-    if [[ "$ITERATION" -gt "$MAX_ITERATIONS" ]]; then
+    if [[ "$ITERATION" -le "$MAX_ITERATIONS" ]]; then
+        return 0
+    fi
+
+    # Hit the cap — check if we should auto-extend
+    if ! $AUTO_EXTEND || [[ "$EXTENSION_COUNT" -ge "$MAX_EXTENSIONS" ]]; then
+        if [[ "$EXTENSION_COUNT" -ge "$MAX_EXTENSIONS" ]]; then
+            warn "Hard cap reached: ${EXTENSION_COUNT} extensions applied (max ${MAX_EXTENSIONS})."
+        fi
         warn "Max iterations ($MAX_ITERATIONS) reached."
         STATUS="max_iterations"
         return 1
     fi
-    return 0
+
+    # Checkpoint audit: is there meaningful progress worth extending for?
+    echo -e "\n  ${CYAN}${BOLD}▸ Checkpoint${RESET} — max iterations ($MAX_ITERATIONS) reached, evaluating progress..."
+
+    local should_extend=false
+    local extension_reason=""
+
+    # Check 1: recent meaningful progress (not stuck)
+    if [[ "${CONSECUTIVE_FAILURES:-0}" -lt 2 ]]; then
+        # Check 2: agent hasn't signaled completion (if it did, guard_completion handles it)
+        local last_log="$LOG_DIR/iteration-$(( ITERATION - 1 )).log"
+        if [[ -f "$last_log" ]] && ! grep -q "LOOP_COMPLETE" "$last_log" 2>/dev/null; then
+            should_extend=true
+            extension_reason="work in progress with recent progress"
+        fi
+    fi
+
+    # Check 3: if quality gates or tests are failing, extend to let agent fix them
+    if [[ "$TEST_PASSED" == "false" ]] || ! $QUALITY_GATE_PASSED; then
+        should_extend=true
+        extension_reason="quality gates or tests not yet passing"
+    fi
+
+    if $should_extend; then
+        # Scale extension size by velocity — good progress earns more iterations
+        local velocity_avg
+        velocity_avg="$(compute_velocity_avg)"
+        local effective_extension="$EXTENSION_SIZE"
+        if [[ "$velocity_avg" -gt 20 ]]; then
+            # High velocity: grant more iterations
+            effective_extension=$(( EXTENSION_SIZE + 3 ))
+        elif [[ "$velocity_avg" -lt 5 ]]; then
+            # Low velocity: grant fewer iterations
+            effective_extension=$(( EXTENSION_SIZE > 2 ? EXTENSION_SIZE - 2 : 1 ))
+        fi
+        EXTENSION_COUNT=$(( EXTENSION_COUNT + 1 ))
+        MAX_ITERATIONS=$(( MAX_ITERATIONS + effective_extension ))
+        echo -e "  ${GREEN}✓${RESET} Auto-extending: +${effective_extension} iterations (now ${MAX_ITERATIONS} max, extension ${EXTENSION_COUNT}/${MAX_EXTENSIONS})"
+        echo -e "  ${DIM}Reason: ${extension_reason} | velocity: ~${velocity_avg} lines/iter${RESET}"
+        return 0
+    fi
+
+    warn "Max iterations reached — no recent progress detected."
+    STATUS="max_iterations"
+    return 1
 }
 
 # ─── Test Gate ────────────────────────────────────────────────────────────────
@@ -439,7 +647,7 @@ run_test_gate() {
     fi
 
     local test_log="$LOG_DIR/tests-iter-${ITERATION}.log"
-    if eval "$TEST_CMD" > "$test_log" 2>&1; then
+    if bash -c "$TEST_CMD" > "$test_log" 2>&1; then
         TEST_PASSED=true
         TEST_OUTPUT="All tests passed."
     else
@@ -491,9 +699,11 @@ AUDIT_PROMPT
 
     echo -e "  ${PURPLE}▸${RESET} Running audit agent..."
 
-    # Build flags with haiku model override for fast/cheap audit
+    # Select audit model adaptively (haiku if success rate high, else sonnet)
+    local audit_model
+    audit_model="$(select_audit_model)"
     local audit_flags=()
-    audit_flags+=("--model" "haiku")
+    audit_flags+=("--model" "$audit_model")
     if $SKIP_PERMISSIONS; then
         audit_flags+=("--dangerously-skip-permissions")
     fi
@@ -588,8 +798,10 @@ Otherwise, list which items are NOT satisfied and why.
 DOD_PROMPT
 
     local dod_log="$LOG_DIR/dod-iter-${ITERATION}.log"
+    local dod_model
+    dod_model="$(select_audit_model)"
     local dod_flags=()
-    dod_flags+=("--model" "haiku")
+    dod_flags+=("--model" "$dod_model")
     if $SKIP_PERMISSIONS; then
         dod_flags+=("--dangerously-skip-permissions")
     fi
@@ -680,6 +892,120 @@ $TEST_OUTPUT"
     local rejection_notice_section
     rejection_notice_section="$(compose_rejection_notice_section)"
 
+    # Memory context injection (failure patterns + past learnings)
+    local memory_section=""
+    if type memory_inject_context &>/dev/null 2>&1; then
+        memory_section="$(memory_inject_context "build" 2>/dev/null || true)"
+    elif [[ -f "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        memory_section="$("$SCRIPT_DIR/sw-memory.sh" inject build 2>/dev/null || true)"
+    fi
+
+    # DORA baselines for context
+    local dora_section=""
+    if type memory_get_dora_baseline &>/dev/null 2>&1; then
+        local dora_json
+        dora_json="$(memory_get_dora_baseline 7 2>/dev/null || echo "{}")"
+        local dora_total
+        dora_total=$(echo "$dora_json" | jq -r '.total // 0' 2>/dev/null || echo "0")
+        if [[ "$dora_total" -gt 0 ]]; then
+            local dora_df dora_cfr
+            dora_df=$(echo "$dora_json" | jq -r '.deploy_freq // 0' 2>/dev/null || echo "0")
+            dora_cfr=$(echo "$dora_json" | jq -r '.cfr // 0' 2>/dev/null || echo "0")
+            dora_section="## Performance Baselines (Last 7 Days)
+- Deploy frequency: ${dora_df}/week
+- Change failure rate: ${dora_cfr}%
+- Total pipeline runs: ${dora_total}"
+        fi
+    fi
+
+    # Append mid-loop memory refresh if available
+    local memory_refresh_file="$LOG_DIR/memory-refresh-$(( ITERATION - 1 )).txt"
+    if [[ -f "$memory_refresh_file" ]]; then
+        memory_section="${memory_section}
+
+## Fresh Context (from iteration $(( ITERATION - 1 )) analysis)
+$(cat "$memory_refresh_file")"
+    fi
+
+    # GitHub intelligence context (gated by availability)
+    local intelligence_section=""
+    if [[ "${NO_GITHUB:-}" != "true" ]]; then
+        # File hotspots — top 5 most-changed files
+        if type gh_file_change_frequency &>/dev/null 2>&1; then
+            local hotspots
+            hotspots=$(gh_file_change_frequency 2>/dev/null | head -5 || true)
+            if [[ -n "$hotspots" ]]; then
+                intelligence_section="${intelligence_section}
+## File Hotspots (most frequently changed)
+${hotspots}"
+            fi
+        fi
+
+        # CODEOWNERS context
+        if type gh_codeowners &>/dev/null 2>&1; then
+            local owners
+            owners=$(gh_codeowners 2>/dev/null | head -10 || true)
+            if [[ -n "$owners" ]]; then
+                intelligence_section="${intelligence_section}
+## Code Owners
+${owners}"
+            fi
+        fi
+
+        # Active security alerts
+        if type gh_security_alerts &>/dev/null 2>&1; then
+            local alerts
+            alerts=$(gh_security_alerts 2>/dev/null | head -5 || true)
+            if [[ -n "$alerts" ]]; then
+                intelligence_section="${intelligence_section}
+## Active Security Alerts
+${alerts}"
+            fi
+        fi
+    fi
+
+    # Architecture rules (from intelligence layer)
+    local repo_hash
+    repo_hash=$(echo -n "$(pwd)" | shasum -a 256 2>/dev/null | cut -c1-12 || echo "unknown")
+    local arch_file="${HOME}/.shipwright/memory/${repo_hash}/architecture.json"
+    if [[ -f "$arch_file" ]]; then
+        local arch_rules
+        arch_rules=$(jq -r '.rules[]? // empty' "$arch_file" 2>/dev/null | head -10 || true)
+        if [[ -n "$arch_rules" ]]; then
+            intelligence_section="${intelligence_section}
+## Architecture Rules
+${arch_rules}"
+        fi
+    fi
+
+    # Coverage baseline
+    local coverage_file="${HOME}/.shipwright/baselines/${repo_hash}/coverage.json"
+    if [[ -f "$coverage_file" ]]; then
+        local coverage_pct
+        coverage_pct=$(jq -r '.coverage_percent // empty' "$coverage_file" 2>/dev/null || true)
+        if [[ -n "$coverage_pct" ]]; then
+            intelligence_section="${intelligence_section}
+## Coverage Baseline
+Current coverage: ${coverage_pct}% — do not decrease this."
+        fi
+    fi
+
+    # Error classification from last failure
+    local error_log=".claude/pipeline-artifacts/error-log.jsonl"
+    if [[ -f "$error_log" ]]; then
+        local last_error
+        last_error=$(tail -1 "$error_log" 2>/dev/null | jq -r '"Type: \(.type), Exit: \(.exit_code), Error: \(.error | split("\n") | first)"' 2>/dev/null || true)
+        if [[ -n "$last_error" ]]; then
+            intelligence_section="${intelligence_section}
+## Last Error Context
+${last_error}"
+        fi
+    fi
+
+    # Stuckness detection — compare last 3 iteration outputs
+    local stuckness_section=""
+    stuckness_section="$(detect_stuckness)"
+
     cat <<PROMPT
 You are an autonomous coding agent on iteration ${ITERATION}/${MAX_ITERATIONS} of a continuous loop.
 
@@ -695,6 +1021,13 @@ ${git_log}
 ## Test Results (Previous Iteration)
 ${test_section}
 
+${memory_section:+## Memory Context
+$memory_section
+}
+${dora_section:+$dora_section
+}
+${intelligence_section:+$intelligence_section
+}
 ## Instructions
 1. Read the codebase and understand the current state
 2. Identify the highest-priority remaining work toward the goal
@@ -709,6 +1042,8 @@ ${audit_feedback_section}
 
 ${rejection_notice_section}
 
+${stuckness_section}
+
 ## Rules
 - Focus on ONE task per iteration — do it well
 - Always commit with descriptive messages
@@ -718,22 +1053,107 @@ ${rejection_notice_section}
 PROMPT
 }
 
+# ─── Stuckness Detection ─────────────────────────────────────────────────────
+# Compares last 3 iteration log outputs for high overlap (>90% similar lines).
+detect_stuckness() {
+    if [[ "$ITERATION" -lt 3 ]]; then
+        return 0
+    fi
+
+    local log1="$LOG_DIR/iteration-$(( ITERATION - 1 )).log"
+    local log2="$LOG_DIR/iteration-$(( ITERATION - 2 )).log"
+    local log3="$LOG_DIR/iteration-$(( ITERATION - 3 )).log"
+
+    # Need at least 2 previous logs
+    if [[ ! -f "$log1" || ! -f "$log2" ]]; then
+        return 0
+    fi
+
+    # Compare last 50 lines of each (ignoring timestamps and blank lines)
+    local lines1 lines2 common total overlap_pct
+    lines1=$(tail -50 "$log1" 2>/dev/null | grep -v '^$' | sort || true)
+    lines2=$(tail -50 "$log2" 2>/dev/null | grep -v '^$' | sort || true)
+
+    if [[ -z "$lines1" || -z "$lines2" ]]; then
+        return 0
+    fi
+
+    total=$(echo "$lines1" | wc -l | tr -d ' ')
+    common=$(comm -12 <(echo "$lines1") <(echo "$lines2") 2>/dev/null | wc -l | tr -d ' ' || echo "0")
+
+    if [[ "$total" -gt 0 ]]; then
+        overlap_pct=$(( common * 100 / total ))
+    else
+        overlap_pct=0
+    fi
+
+    if [[ "$overlap_pct" -ge 90 ]]; then
+        local diff_summary=""
+        if [[ -f "$log3" ]]; then
+            diff_summary=$(diff <(tail -30 "$log3" 2>/dev/null) <(tail -30 "$log1" 2>/dev/null) 2>/dev/null | head -10 || true)
+        fi
+
+        # Gather memory-based alternative approaches
+        local alternatives=""
+        if type memory_inject_context &>/dev/null 2>&1; then
+            alternatives=$(memory_inject_context "build" 2>/dev/null | grep -i "fix:" | head -3 || true)
+        fi
+
+        cat <<STUCK_SECTION
+## Stuckness Detected
+Your last ${CONSECUTIVE_FAILURES:-2}+ iterations produced very similar output (${overlap_pct}% overlap).
+You appear to be stuck on the same approach.
+
+${diff_summary:+Changes between recent iterations:
+$diff_summary
+}
+${alternatives:+Consider these alternative approaches from past fixes:
+$alternatives
+}
+Try a fundamentally different approach:
+- Break the problem into smaller steps
+- Look for an entirely different implementation strategy
+- Check if there's a dependency or configuration issue blocking progress
+- Read error messages more carefully — the root cause may differ from your assumption
+STUCK_SECTION
+    fi
+}
+
 compose_audit_section() {
     if ! $AUDIT_ENABLED; then
         return
     fi
-    cat <<'AUDIT_SECTION'
-## Self-Audit Checklist
-Before declaring LOOP_COMPLETE, critically evaluate your own work:
-1. Does the implementation FULLY satisfy the goal, not just partially?
-2. Are there any edge cases you haven't handled?
-3. Did you leave any TODO, FIXME, HACK, or XXX comments in new code?
-4. Are all new functions/modules tested (if a test command exists)?
-5. Would a code reviewer approve this, or would they request changes?
-6. Is the code clean, well-structured, and following project conventions?
-
-If ANY answer is "no", do NOT output LOOP_COMPLETE. Instead, fix the issues first.
-AUDIT_SECTION
+
+    # Try to inject audit items from past review feedback in memory
+    local memory_audit_items=""
+    if [[ -f "$SCRIPT_DIR/sw-memory.sh" ]]; then
+        local mem_dir_path
+        mem_dir_path="$HOME/.shipwright/memory"
+        # Look for review feedback in any repo memory
+        local repo_hash_val
+        repo_hash_val=$(git config --get remote.origin.url 2>/dev/null | shasum -a 256 2>/dev/null | cut -c1-12 || echo "")
+        if [[ -n "$repo_hash_val" && -f "$mem_dir_path/$repo_hash_val/failures.json" ]]; then
+            memory_audit_items=$(jq -r '.failures[] | select(.stage == "review" and .pattern != "") |
+                "- Check for: \(.pattern[:100])"' \
+                "$mem_dir_path/$repo_hash_val/failures.json" 2>/dev/null | head -5 || true)
+        fi
+    fi
+
+    echo "## Self-Audit Checklist"
+    echo "Before declaring LOOP_COMPLETE, critically evaluate your own work:"
+    echo "1. Does the implementation FULLY satisfy the goal, not just partially?"
+    echo "2. Are there any edge cases you haven't handled?"
+    echo "3. Did you leave any TODO, FIXME, HACK, or XXX comments in new code?"
+    echo "4. Are all new functions/modules tested (if a test command exists)?"
+    echo "5. Would a code reviewer approve this, or would they request changes?"
+    echo "6. Is the code clean, well-structured, and following project conventions?"
+    if [[ -n "$memory_audit_items" ]]; then
+        echo ""
+        echo "Common review findings from this repo's history:"
+        echo "$memory_audit_items"
+    fi
+    echo ""
+    echo "If ANY answer is \"no\", do NOT output LOOP_COMPLETE. Instead, fix the issues first."
 }
 
 compose_audit_feedback_section() {
@@ -809,10 +1229,20 @@ run_claude_iteration() {
 
     echo -e "\n${CYAN}${BOLD}▸${RESET} ${BOLD}Iteration ${ITERATION}/${MAX_ITERATIONS}${RESET} — Starting..."
 
-    # Run Claude headless
+    # Run Claude headless (with timeout + PID capture for signal handling)
     local exit_code=0
     # shellcheck disable=SC2086
-    claude -p "$prompt" $flags > "$log_file" 2>&1 || exit_code=$?
+    if [[ -n "$TIMEOUT_CMD" ]]; then
+        $TIMEOUT_CMD "$CLAUDE_TIMEOUT" claude -p "$prompt" $flags > "$log_file" 2>&1 &
+    else
+        claude -p "$prompt" $flags > "$log_file" 2>&1 &
+    fi
+    CHILD_PID=$!
+    wait "$CHILD_PID" 2>/dev/null || exit_code=$?
+    CHILD_PID=""
+    if [[ "$exit_code" -eq 124 ]]; then
+        warn "Claude CLI timed out after ${CLAUDE_TIMEOUT}s"
+    fi
 
     local iter_end
     iter_end="$(now_epoch)"
@@ -849,7 +1279,11 @@ show_banner() {
     echo -e "${CYAN}═══════════════════════════════════════════════${RESET}"
     echo ""
     echo -e "  ${BOLD}Goal:${RESET}  $GOAL"
-    echo -e "  ${BOLD}Model:${RESET} $MODEL ${DIM}|${RESET} ${BOLD}Max:${RESET} $MAX_ITERATIONS iterations ${DIM}|${RESET} ${BOLD}Test:${RESET} ${TEST_CMD:-"(none)"}"
+    local extend_info=""
+    if $AUTO_EXTEND; then
+        extend_info=" ${DIM}(auto-extend: +${EXTENSION_SIZE} x${MAX_EXTENSIONS})${RESET}"
+    fi
+    echo -e "  ${BOLD}Model:${RESET} $MODEL ${DIM}|${RESET} ${BOLD}Max:${RESET} $MAX_ITERATIONS iterations${extend_info} ${DIM}|${RESET} ${BOLD}Test:${RESET} ${TEST_CMD:-"(none)"}"
     if [[ "$AGENTS" -gt 1 ]]; then
         echo -e "  ${BOLD}Agents:${RESET} $AGENTS ${DIM}(parallel worktree mode)${RESET}"
     fi
@@ -898,7 +1332,9 @@ show_summary() {
     echo ""
     echo -e "  ${BOLD}Goal:${RESET}        $GOAL"
     echo -e "  ${BOLD}Status:${RESET}      $status_display"
-    echo -e "  ${BOLD}Iterations:${RESET}  $ITERATION/$MAX_ITERATIONS"
+    local ext_suffix=""
+    [[ "$EXTENSION_COUNT" -gt 0 ]] && ext_suffix=" ${DIM}(${EXTENSION_COUNT} extensions)${RESET}"
+    echo -e "  ${BOLD}Iterations:${RESET}  $ITERATION/$MAX_ITERATIONS${ext_suffix}"
     echo -e "  ${BOLD}Duration:${RESET}    $(format_duration "$duration")"
     echo -e "  ${BOLD}Commits:${RESET}     $TOTAL_COMMITS"
     echo -e "  ${BOLD}Tests:${RESET}       $test_display"
@@ -929,6 +1365,16 @@ cleanup() {
 
     STATUS="interrupted"
     write_state
+
+    # Save checkpoint on interruption
+    "$SCRIPT_DIR/sw-checkpoint.sh" save \
+        --stage "build" \
+        --iteration "$ITERATION" \
+        --git-sha "$(git rev-parse HEAD 2>/dev/null || echo unknown)" 2>/dev/null || true
+
+    # Clear heartbeat
+    "$SCRIPT_DIR/sw-heartbeat.sh" clear "${PIPELINE_JOB_ID:-loop-$$}" 2>/dev/null || true
+
     show_summary
     exit 130
 }
@@ -1102,13 +1548,13 @@ echo -e "\n${DIM}Agent ${AGENT_NUM} finished after ${ITERATION} iterations${RESE
 WORKEREOF
 
     # Replace placeholders
-    sed -i '' "s|__AGENT_NUM__|${agent_num}|g" "$worker_script"
-    sed -i '' "s|__TOTAL_AGENTS__|${total_agents}|g" "$worker_script"
-    sed -i '' "s|__WORK_DIR__|${wt_path}|g" "$worker_script"
-    sed -i '' "s|__LOG_DIR__|${LOG_DIR}|g" "$worker_script"
-    sed -i '' "s|__MAX_ITERATIONS__|${MAX_ITERATIONS}|g" "$worker_script"
-    sed -i '' "s|__TEST_CMD__|${TEST_CMD}|g" "$worker_script"
-    sed -i '' "s|__CLAUDE_FLAGS__|${claude_flags}|g" "$worker_script"
+    sed_i "s|__AGENT_NUM__|${agent_num}|g" "$worker_script"
+    sed_i "s|__TOTAL_AGENTS__|${total_agents}|g" "$worker_script"
+    sed_i "s|__WORK_DIR__|${wt_path}|g" "$worker_script"
+    sed_i "s|__LOG_DIR__|${LOG_DIR}|g" "$worker_script"
+    sed_i "s|__MAX_ITERATIONS__|${MAX_ITERATIONS}|g" "$worker_script"
+    sed_i "s|__TEST_CMD__|${TEST_CMD}|g" "$worker_script"
+    sed_i "s|__CLAUDE_FLAGS__|${claude_flags}|g" "$worker_script"
     # Goal needs special handling for sed (may contain special chars)
     # Use awk for safe string replacement without python
     awk -v goal="$GOAL" '{gsub(/__GOAL__/, goal); print}' "$worker_script" > "${worker_script}.tmp" \
@@ -1128,7 +1574,7 @@ launch_multi_agent() {
     setup_worktrees || { error "Failed to setup worktrees"; exit 1; }
 
     # Create tmux window for workers
-    MULTI_WINDOW_NAME="cct-loop-$(date +%s)"
+    MULTI_WINDOW_NAME="sw-loop-$(date +%s)"
     tmux new-window -n "$MULTI_WINDOW_NAME" -c "$PROJECT_ROOT"
 
     # First pane becomes monitor
@@ -1233,13 +1679,17 @@ run_single_agent_loop() {
         initialize_state
     fi
 
+    # Apply adaptive budget/model before showing banner
+    apply_adaptive_budget
+    MODEL="$(select_adaptive_model "build" "$MODEL")"
+
     show_banner
 
     while true; do
         # Pre-checks (before incrementing — ITERATION tracks completed count)
         check_circuit_breaker || break
+        check_max_iterations || break
         ITERATION=$(( ITERATION + 1 ))
-        check_max_iterations || { ITERATION=$(( ITERATION - 1 )); break; }
 
         # Run Claude
         local exit_code=0
@@ -1247,6 +1697,21 @@ run_single_agent_loop() {
 
         local log_file="$LOG_DIR/iteration-${ITERATION}.log"
 
+        # Mid-loop memory refresh — re-query with current error context after iteration 3
+        if [[ "$ITERATION" -ge 3 ]] && type memory_inject_context &>/dev/null 2>&1; then
+            local refresh_ctx
+            refresh_ctx=$(tail -20 "$log_file" 2>/dev/null || true)
+            if [[ -n "$refresh_ctx" ]]; then
+                local refreshed_memory
+                refreshed_memory=$(memory_inject_context "build" "$refresh_ctx" 2>/dev/null | head -5 || true)
+                if [[ -n "$refreshed_memory" ]]; then
+                    # Append to next iteration's memory context
+                    local memory_refresh_file="$LOG_DIR/memory-refresh-${ITERATION}.txt"
+                    echo "$refreshed_memory" > "$memory_refresh_file"
+                fi
+            fi
+        fi
+
         # Auto-commit if Claude didn't
         local commits_before
         commits_before="$(git_commit_count)"
@@ -1263,6 +1728,9 @@ run_single_agent_loop() {
             echo -e "  ${GREEN}✓${RESET} Git: $diff_stat"
         fi
 
+        # Track velocity for adaptive extension budget
+        track_iteration_velocity
+
         # Test gate
         run_test_gate
         if [[ -n "$TEST_CMD" ]]; then
@@ -1293,7 +1761,7 @@ run_single_agent_loop() {
             echo -e "  ${GREEN}✓${RESET} Progress detected — continuing"
         else
             CONSECUTIVE_FAILURES=$(( CONSECUTIVE_FAILURES + 1 ))
-            echo -e "  ${YELLOW}⚠${RESET} Low progress (${CONSECUTIVE_FAILURES}/3 before circuit breaker)"
+            echo -e "  ${YELLOW}⚠${RESET} Low progress (${CONSECUTIVE_FAILURES}/${CIRCUIT_BREAKER_THRESHOLD} before circuit breaker)"
         fi
 
         # Extract summary and update state
@@ -1304,6 +1772,28 @@ $summary
 "
         write_state
 
+        # Update heartbeat
+        "$SCRIPT_DIR/sw-heartbeat.sh" write "${PIPELINE_JOB_ID:-loop-$$}" \
+            --pid $$ \
+            --stage "build" \
+            --iteration "$ITERATION" \
+            --activity "Loop iteration $ITERATION" 2>/dev/null || true
+
+        # Human intervention: check for human message between iterations
+        local human_msg_file="$STATE_DIR/pipeline-artifacts/human-message.txt"
+        if [[ -f "$human_msg_file" ]]; then
+            local human_msg
+            human_msg="$(cat "$human_msg_file" 2>/dev/null || true)"
+            if [[ -n "$human_msg" ]]; then
+                echo -e "  ${PURPLE}${BOLD}💬 Human message:${RESET} $human_msg"
+                # Inject human message as additional context for next iteration
+                GOAL="${GOAL}
+
+HUMAN FEEDBACK (received after iteration $ITERATION): $human_msg"
+                rm -f "$human_msg_file"
+            fi
+        fi
+
         sleep 2
     done