shipwright-cli 2.3.1 → 3.0.0

package/scripts/sw-loop.sh

@@ -23,6 +23,7 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && 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"
 # 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 $*"; }
@@ -40,15 +41,6 @@ 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}"
 
 # ─── Defaults ─────────────────────────────────────────────────────────────────
 GOAL=""
@@ -67,11 +59,11 @@ MAX_TURNS=""
 RESUME=false
 VERBOSE=false
 MAX_ITERATIONS_EXPLICIT=false
-MAX_RESTARTS=0
+MAX_RESTARTS=$(_config_get_int "loop.max_restarts" 0 2>/dev/null || echo 0)
 SESSION_RESTART=false
 RESTART_COUNT=0
 REPO_OVERRIDE=""
-VERSION="2.3.1"
+VERSION="3.0.0"
 
 # ─── Token Tracking ─────────────────────────────────────────────────────────
 LOOP_INPUT_TOKENS=0
@@ -335,13 +327,13 @@ if [[ -n "$REPO_OVERRIDE" ]]; then
     info "Using repository: $(pwd)"
 fi
 
-if ! command -v claude &>/dev/null; then
+if ! command -v claude >/dev/null 2>&1; then
     error "Claude Code CLI not found. Install it first:"
     echo -e "  ${DIM}npm install -g @anthropic-ai/claude-code${RESET}"
     exit 1
 fi
 
-if ! git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
     error "Not inside a git repository. The loop requires git for progress tracking."
     exit 1
 fi
@@ -351,15 +343,15 @@ ORIGINAL_GOAL="$GOAL"
 
 # ─── Timeout Detection ────────────────────────────────────────────────────────
 TIMEOUT_CMD=""
-if command -v timeout &>/dev/null; then
+if command -v timeout >/dev/null 2>&1; then
     TIMEOUT_CMD="timeout"
-elif command -v gtimeout &>/dev/null; then
+elif command -v gtimeout >/dev/null 2>&1; then
     TIMEOUT_CMD="gtimeout"
 fi
-CLAUDE_TIMEOUT="${CLAUDE_TIMEOUT:-1800}"  # 30 min default
+CLAUDE_TIMEOUT="${CLAUDE_TIMEOUT:-$(_config_get_int "loop.claude_timeout" 1800 2>/dev/null || echo 1800)}"  # 30 min default
 
 if [[ "$AGENTS" -gt 1 ]]; then
-    if ! command -v tmux &>/dev/null; then
+    if ! command -v tmux >/dev/null 2>&1; then
         error "tmux is required for multi-agent mode."
         echo -e "  ${DIM}brew install tmux${RESET}  (macOS)"
         exit 1
@@ -393,7 +385,7 @@ select_adaptive_model() {
     fi
     # Read learned model routing
     local _routing_file="${HOME}/.shipwright/optimization/model-routing.json"
-    if [[ -f "$_routing_file" ]] && command -v jq &>/dev/null; then
+    if [[ -f "$_routing_file" ]] && command -v jq >/dev/null 2>&1; then
         local _routed_model
         _routed_model=$(jq -r --arg r "$role" '.routes[$r].model // ""' "$_routing_file" 2>/dev/null) || true
         if [[ -n "${_routed_model:-}" && "${_routed_model:-}" != "null" ]]; then
@@ -403,7 +395,7 @@ select_adaptive_model() {
     fi
 
     # Try intelligence-based recommendation
-    if type intelligence_recommend_model &>/dev/null 2>&1; then
+    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
@@ -422,7 +414,7 @@ select_adaptive_model() {
 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
+    if [[ -f "$opt_file" ]] && command -v jq >/dev/null 2>&1; 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
@@ -442,7 +434,7 @@ accumulate_loop_tokens() {
     [[ ! -f "$log_file" ]] && return 0
 
     # If jq is available and the file looks like JSON, parse structured output
-    if command -v jq &>/dev/null && head -c1 "$log_file" 2>/dev/null | grep -q '\['; then
+    if command -v jq >/dev/null 2>&1 && head -c1 "$log_file" 2>/dev/null | grep -q '\['; then
         local input_tok output_tok cache_read cache_create cost_usd
         # The result object is the last element in the JSON array
         input_tok=$(jq -r '.[-1].usage.input_tokens // 0' "$log_file" 2>/dev/null || echo "0")
@@ -458,6 +450,20 @@ accumulate_loop_tokens() {
             local cost_millicents
             cost_millicents=$(echo "$cost_usd" | awk '{printf "%.0f", $1 * 100000}' 2>/dev/null || echo "0")
             LOOP_COST_MILLICENTS=$(( ${LOOP_COST_MILLICENTS:-0} + ${cost_millicents:-0} ))
+        else
+            # Estimate cost from tokens when Claude doesn't provide it (rates per million tokens)
+            local total_in total_out
+            total_in=$(( ${input_tok:-0} + ${cache_read:-0} + ${cache_create:-0} ))
+            total_out=${output_tok:-0}
+            local cost=0
+            case "${MODEL:-${CLAUDE_MODEL:-sonnet}}" in
+                *opus*)   cost=$(awk -v i="$total_in" -v o="$total_out" 'BEGIN{printf "%.6f", (i * 15 + o * 75) / 1000000}') ;;
+                *sonnet*) cost=$(awk -v i="$total_in" -v o="$total_out" 'BEGIN{printf "%.6f", (i * 3 + o * 15) / 1000000}') ;;
+                *haiku*)  cost=$(awk -v i="$total_in" -v o="$total_out" 'BEGIN{printf "%.6f", (i * 0.25 + o * 1.25) / 1000000}') ;;
+                *)       cost=$(awk -v i="$total_in" -v o="$total_out" 'BEGIN{printf "%.6f", (i * 3 + o * 15) / 1000000}') ;;
+            esac
+            cost_millicents=$(echo "$cost" | awk '{printf "%.0f", $1 * 100000}' 2>/dev/null || echo "0")
+            LOOP_COST_MILLICENTS=$(( ${LOOP_COST_MILLICENTS:-0} + ${cost_millicents:-0} ))
         fi
     else
         # Fallback: regex-based parsing for non-JSON output
@@ -491,7 +497,7 @@ _extract_text_from_json() {
     first_char=$(head -c1 "$json_file" 2>/dev/null || true)
 
     # Case 2: Valid JSON array — extract .result from last element
-    if [[ "$first_char" == "[" ]] && command -v jq &>/dev/null; then
+    if [[ "$first_char" == "[" ]] && command -v jq >/dev/null 2>&1; then
         local extracted
         extracted=$(jq -r '.[-1].result // empty' "$json_file" 2>/dev/null) || true
         if [[ -n "$extracted" ]]; then
@@ -542,7 +548,7 @@ TOKJSON
 # 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
+    if [[ -f "$tuning_file" ]] && command -v jq >/dev/null 2>&1; 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 "")
@@ -560,7 +566,7 @@ apply_adaptive_budget() {
 
     # Read learned iteration model
     local _iter_model="${HOME}/.shipwright/optimization/iteration-model.json"
-    if [[ -f "$_iter_model" ]] && ! $MAX_ITERATIONS_EXPLICIT && command -v jq &>/dev/null; then
+    if [[ -f "$_iter_model" ]] && ! $MAX_ITERATIONS_EXPLICIT && command -v jq >/dev/null 2>&1; then
         local _complexity="${ISSUE_COMPLEXITY:-${COMPLEXITY:-medium}}"
         local _predicted_max
         _predicted_max=$(jq -r --arg c "$_complexity" '.predictions[$c].max_iterations // ""' "$_iter_model" 2>/dev/null) || true
@@ -571,7 +577,7 @@ apply_adaptive_budget() {
     fi
 
     # Try intelligence-based iteration estimate
-    if type intelligence_estimate_iterations &>/dev/null 2>&1 && ! $MAX_ITERATIONS_EXPLICIT; then
+    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
@@ -619,9 +625,6 @@ compute_velocity_avg() {
 
 # ─── Timing Helpers ───────────────────────────────────────────────────────────
 
-now_iso()   { date -u +%Y-%m-%dT%H:%M:%SZ; }
-now_epoch() { date +%s; }
-
 format_duration() {
     local secs="$1"
     local mins=$(( secs / 60 ))
@@ -730,6 +733,21 @@ resume_state() {
         exit 0
     fi
 
+    # Restore Claude context for meaningful resume (source so exports persist to this shell)
+    if [[ -f "$SCRIPT_DIR/sw-checkpoint.sh" ]] && [[ -d "${PROJECT_ROOT:-}" ]]; then
+        source "$SCRIPT_DIR/sw-checkpoint.sh"
+        local _orig_pwd="$PWD"
+        cd "$PROJECT_ROOT" 2>/dev/null || true
+        if checkpoint_restore_context "build" 2>/dev/null; then
+            RESUMED_FROM_ITERATION="${RESTORED_ITERATION:-}"
+            RESUMED_MODIFIED="${RESTORED_MODIFIED:-}"
+            RESUMED_FINDINGS="${RESTORED_FINDINGS:-}"
+            RESUMED_TEST_OUTPUT="${RESTORED_TEST_OUTPUT:-}"
+            [[ -n "${RESTORED_ITERATION:-}" && "${RESTORED_ITERATION:-0}" -gt 0 ]] && info "Restored context from iteration ${RESTORED_ITERATION}"
+        fi
+        cd "$_orig_pwd" 2>/dev/null || true
+    fi
+
     success "Resumed: iteration $ITERATION/$MAX_ITERATIONS"
 }
 
@@ -807,6 +825,85 @@ ${entry}"
     fi
 }
 
+# ─── Semantic Validation for Claude Output ─────────────────────────────────────
+# Validates changed files before commit to catch syntax errors and API error leakage.
+validate_claude_output() {
+    local workdir="${1:-.}"
+    local issues=0
+
+    # Check for syntax errors in changed files
+    local changed_files
+    changed_files=$(git -C "$workdir" diff --cached --name-only 2>/dev/null || git -C "$workdir" diff --name-only 2>/dev/null)
+
+    while IFS= read -r file; do
+        [[ -z "$file" ]] && continue
+        [[ ! -f "$workdir/$file" ]] && continue
+
+        case "$file" in
+            *.sh)
+                if ! bash -n "$workdir/$file" 2>/dev/null; then
+                    warn "Syntax error in shell script: $file"
+                    issues=$((issues + 1))
+                fi
+                ;;
+            *.py)
+                if command -v python3 >/dev/null 2>&1; then
+                    if ! python3 -c "import ast, sys; ast.parse(open(sys.argv[1]).read())" "$workdir/$file" 2>/dev/null; then
+                        warn "Syntax error in Python file: $file"
+                        issues=$((issues + 1))
+                    fi
+                fi
+                ;;
+            *.json)
+                if command -v jq >/dev/null 2>&1 && ! jq empty "$workdir/$file" 2>/dev/null; then
+                    warn "Invalid JSON: $file"
+                    issues=$((issues + 1))
+                fi
+                ;;
+            *.ts|*.js|*.tsx|*.jsx)
+                # Check for obvious corruption: API error text leaked into source
+                if grep -qE '(CLAUDE_CODE_OAUTH_TOKEN|api key|rate limit|503 Service|DOCTYPE html)' "$workdir/$file" 2>/dev/null; then
+                    warn "Claude API error leaked into source file: $file"
+                    issues=$((issues + 1))
+                fi
+                ;;
+        esac
+    done <<< "$changed_files"
+
+    # Check for obviously corrupt output (API errors dumped as code)
+    local total_changed
+    total_changed=$(echo "$changed_files" | grep -c '.' 2>/dev/null || echo "0")
+    if [[ "$total_changed" -eq 0 ]]; then
+        warn "Claude iteration produced no file changes"
+        issues=$((issues + 1))
+    fi
+
+    return "$issues"
+}
+
+# ─── Budget Gate (hard stop when exhausted) ───────────────────────────────────
+check_budget_gate() {
+    [[ ! -x "$SCRIPT_DIR/sw-cost.sh" ]] && return 0
+    local remaining
+    remaining=$(bash "$SCRIPT_DIR/sw-cost.sh" remaining-budget 2>/dev/null || echo "")
+    [[ -z "$remaining" ]] && return 0
+    [[ "$remaining" == "unlimited" ]] && return 0
+
+    # Parse remaining as float, check if <= 0
+    if awk -v r="$remaining" 'BEGIN { exit !(r <= 0) }' 2>/dev/null; then
+        error "Budget exhausted (remaining: \$${remaining}) — stopping pipeline"
+        emit_event "pipeline.budget_exhausted" "remaining=$remaining"
+        return 1
+    fi
+
+    # Warn at 10% threshold (remaining < 1.0 when typical job ~$5+)
+    if awk -v r="$remaining" 'BEGIN { exit !(r < 1.0) }' 2>/dev/null; then
+        warn "Budget low: \$${remaining} remaining"
+    fi
+
+    return 0
+}
+
 # ─── Git Helpers ──────────────────────────────────────────────────────────────
 
 git_commit_count() {
@@ -834,6 +931,14 @@ git_auto_commit() {
     fi
 
     git -C "$work_dir" add -A 2>/dev/null || true
+
+    # Semantic validation before commit — skip commit if validation fails
+    if ! validate_claude_output "$work_dir"; then
+        warn "Validation failed — skipping commit for this iteration"
+        git -C "$work_dir" reset --hard HEAD 2>/dev/null || true
+        return 1
+    fi
+
     git -C "$work_dir" commit -m "loop: iteration $ITERATION — autonomous progress" --no-verify 2>/dev/null || return 1
     return 0
 }
@@ -897,7 +1002,7 @@ check_completion() {
 
 check_circuit_breaker() {
     # Vitals-driven circuit breaker (preferred over static threshold)
-    if type pipeline_compute_vitals &>/dev/null 2>&1 && type pipeline_health_verdict &>/dev/null 2>&1; then
+    if type pipeline_compute_vitals >/dev/null 2>&1 && type pipeline_health_verdict >/dev/null 2>&1; then
         local _vitals_json _verdict
         local _loop_state="${STATE_FILE:-}"
         local _loop_artifacts="${ARTIFACTS_DIR:-}"
@@ -989,6 +1094,113 @@ check_max_iterations() {
     return 1
 }
 
+# ─── Failure Diagnosis ─────────────────────────────────────────────────────────
+# Pattern-based root-cause classification for smarter retries (no Claude needed).
+# Returns markdown context to inject into the next iteration's goal.
+
+diagnose_failure() {
+    local error_output="$1"
+    local changed_files="$2"
+    local iteration="$3"
+
+    local diagnosis=""
+    local strategy="retry_with_context"  # default
+
+    # Pattern-based classification (fast, no Claude needed)
+    if echo "$error_output" | grep -qiE 'import.*not found|cannot find module|no module named'; then
+        diagnosis="missing_import"
+        strategy="fix_imports"
+    elif echo "$error_output" | grep -qiE 'syntax error|unexpected token|parse error'; then
+        diagnosis="syntax_error"
+        strategy="fix_syntax"
+    elif echo "$error_output" | grep -qiE 'type.*not assignable|type error|TypeError'; then
+        diagnosis="type_error"
+        strategy="fix_types"
+    elif echo "$error_output" | grep -qiE 'undefined.*variable|not defined|ReferenceError'; then
+        diagnosis="undefined_reference"
+        strategy="fix_references"
+    elif echo "$error_output" | grep -qiE 'timeout|timed out|ETIMEDOUT'; then
+        diagnosis="timeout"
+        strategy="optimize_performance"
+    elif echo "$error_output" | grep -qiE 'assertion.*fail|expect.*to|AssertionError'; then
+        diagnosis="test_assertion"
+        strategy="fix_logic"
+    elif echo "$error_output" | grep -qiE 'permission denied|EACCES|forbidden'; then
+        diagnosis="permission_error"
+        strategy="fix_permissions"
+    elif echo "$error_output" | grep -qiE 'out of memory|heap|OOM|ENOMEM'; then
+        diagnosis="resource_error"
+        strategy="reduce_resource_usage"
+    else
+        diagnosis="unknown"
+        strategy="retry_with_context"
+    fi
+
+    # Check if we've seen this diagnosis before in this session
+    local diagnosis_file="${LOG_DIR:-/tmp}/diagnoses.txt"
+    local repeat_count=0
+    if [[ -f "$diagnosis_file" ]]; then
+        repeat_count=$(grep -c "^${diagnosis}$" "$diagnosis_file" 2>/dev/null || echo "0")
+    fi
+    echo "$diagnosis" >> "$diagnosis_file"
+
+    # Escalate strategy if same diagnosis repeats
+    if [[ "$repeat_count" -ge 2 ]]; then
+        strategy="alternative_approach"
+    fi
+
+    # Try memory-based fix lookup
+    local known_fix=""
+    if type memory_query_fix_for_error &>/dev/null; then
+        local fix_json
+        fix_json=$(memory_query_fix_for_error "$error_output" 2>/dev/null || true)
+        if [[ -n "$fix_json" && "$fix_json" != "null" ]]; then
+            known_fix=$(echo "$fix_json" | jq -r '.fix // ""' 2>/dev/null | head -5)
+        fi
+    fi
+
+    # Build diagnosis context for Claude
+    local diagnosis_context="## Failure Diagnosis (Iteration $iteration)
+Classification: $diagnosis
+Strategy: $strategy
+Repeat count: $repeat_count"
+
+    if [[ -n "$known_fix" ]]; then
+        diagnosis_context+="
+Known fix from memory: $known_fix"
+    fi
+
+    # Strategy-specific guidance
+    case "$strategy" in
+        fix_imports)
+            diagnosis_context+="
+INSTRUCTION: The error is about missing imports/modules. Check that all imports are correct, packages are installed, and paths are right. Do NOT change the logic - just fix the imports."
+            ;;
+        fix_syntax)
+            diagnosis_context+="
+INSTRUCTION: This is a syntax error. Carefully check the exact line mentioned in the error. Look for missing brackets, semicolons, commas, or mismatched quotes."
+            ;;
+        fix_types)
+            diagnosis_context+="
+INSTRUCTION: Type mismatch error. Check the types at the error location. Ensure function signatures match their usage."
+            ;;
+        fix_logic)
+            diagnosis_context+="
+INSTRUCTION: Test assertion failure. The code logic is wrong, not the syntax. Re-read the test expectations and fix the implementation to match."
+            ;;
+        alternative_approach)
+            diagnosis_context+="
+INSTRUCTION: This error has occurred $repeat_count times. The previous approach is not working. Try a FUNDAMENTALLY DIFFERENT approach:
+- If you were modifying existing code, try rewriting the function from scratch
+- If you were using one library, try a different one
+- If you were adding to a file, try creating a new file instead
+- Step back and reconsider the requirements"
+            ;;
+    esac
+
+    echo "$diagnosis_context"
+}
+
 # ─── Test Gate ────────────────────────────────────────────────────────────────
 
 run_test_gate() {
@@ -1018,9 +1230,9 @@ run_test_gate() {
     # Wrap test command with timeout (5 min default) to prevent hanging
     local test_timeout="${SW_TEST_TIMEOUT:-300}"
     local test_wrapper="$active_test_cmd"
-    if command -v timeout &>/dev/null; then
+    if command -v timeout >/dev/null 2>&1; then
         test_wrapper="timeout ${test_timeout} bash -c $(printf '%q' "$active_test_cmd")"
-    elif command -v gtimeout &>/dev/null; then
+    elif command -v gtimeout >/dev/null 2>&1; then
         test_wrapper="gtimeout ${test_timeout} bash -c $(printf '%q' "$active_test_cmd")"
     fi
     if bash -c "$test_wrapper" > "$test_log" 2>&1; then
@@ -1072,7 +1284,7 @@ write_error_summary() {
     local tmp_json="${error_json}.tmp.$$"
 
     # Build JSON with jq (preferred) or plain-text fallback
-    if command -v jq &>/dev/null; then
+    if command -v jq >/dev/null 2>&1; then
         jq -n \
             --argjson iteration "${ITERATION:-0}" \
             --arg timestamp "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" \
@@ -1298,6 +1510,79 @@ guard_completion() {
     return 0
 }
 
+# ─── Context Window Management ───────────────────────────────────────────────
+# Prevents prompt from exceeding Claude's context limit (~200K tokens).
+# Trims least-critical sections first when over budget.
+
+CONTEXT_BUDGET_CHARS="${CONTEXT_BUDGET_CHARS:-180000}"  # ~45K tokens at 4 chars/token
+
+manage_context_window() {
+    local prompt="$1"
+    local budget="${CONTEXT_BUDGET_CHARS}"
+    local current_len=${#prompt}
+
+    if [[ "$current_len" -le "$budget" ]]; then
+        echo "$prompt"
+        return
+    fi
+
+    # Over budget — progressively trim sections (least important first)
+    local trimmed="$prompt"
+
+    # 1. Trim DORA/Performance baselines (least critical for code generation)
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed=$(echo "$trimmed" | awk '/^## Performance Baselines/{skip=1; next} skip && /^## [^#]/{skip=0} !skip{print}')
+    fi
+
+    # 2. Trim file hotspots to top 5
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed=$(echo "$trimmed" | awk '/## File Hotspots/{p=1; c=0} p && /^- /{c++; if(c>5) next} {print}')
+    fi
+
+    # 3. Trim git log to last 10 entries
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed=$(echo "$trimmed" | awk '/## Recent Git Activity/{p=1; c=0} p && /^[a-f0-9]/{c++; if(c>10) next} {print}')
+    fi
+
+    # 4. Truncate memory context to first 20K chars
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed=$(echo "$trimmed" | awk -v max=20000 '
+            /## Memory Context/{mem=1; skip_rest=0; chars=0; print; next}
+            mem && /^## [^#]/{mem=0; print; next}
+            mem{chars+=length($0)+1; if(chars>max){print "... (memory truncated for context budget)"; skip_rest=1; mem=0; next}}
+            skip_rest && /^## [^#]/{skip_rest=0; print; next}
+            skip_rest{next}
+            {print}
+        ')
+    fi
+
+    # 5. Truncate test output to last 50 lines
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed=$(echo "$trimmed" | awk '
+            /## Test Results/{found=1; buf=""; print; next}
+            found && /^## [^#]/{found=0; n=split(buf,arr,"\n"); start=(n>50)?(n-49):1; for(i=start;i<=n;i++) if(arr[i]!="") print arr[i]; print; next}
+            found{buf=buf $0 "\n"; next}
+            {print}
+        ')
+    fi
+
+    # 6. Last resort: hard truncate with notice
+    if [[ "${#trimmed}" -gt "$budget" ]]; then
+        trimmed="${trimmed:0:$budget}
+
+... [CONTEXT TRUNCATED: prompt exceeded ${budget} char budget. Focus on the goal and most recent errors.]"
+    fi
+
+    # Log the trimming
+    local final_len=${#trimmed}
+    if [[ "$final_len" -lt "$current_len" ]]; then
+        warn "Context trimmed from ${current_len} to ${final_len} chars (budget: ${budget})"
+        emit_event "loop.context_trimmed" "original=$current_len" "trimmed=$final_len" "budget=$budget" 2>/dev/null || true
+    fi
+
+    echo "$trimmed"
+}
+
 # ─── Prompt Composition ──────────────────────────────────────────────────────
 
 compose_prompt() {
@@ -1348,7 +1633,7 @@ Fix these specific errors. Each line above is one distinct error from the test o
 
     # Memory context injection (failure patterns + past learnings)
     local memory_section=""
-    if type memory_inject_context &>/dev/null 2>&1; then
+    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)"
@@ -1356,7 +1641,7 @@ Fix these specific errors. Each line above is one distinct error from the test o
 
     # DORA baselines for context
     local dora_section=""
-    if type memory_get_dora_baseline &>/dev/null 2>&1; then
+    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
@@ -1385,7 +1670,7 @@ $(cat "$memory_refresh_file")"
     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
+        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
@@ -1396,7 +1681,7 @@ ${hotspots}"
         fi
 
         # CODEOWNERS context
-        if type gh_codeowners &>/dev/null 2>&1; then
+        if type gh_codeowners >/dev/null 2>&1; then
             local owners
             owners=$(gh_codeowners 2>/dev/null | head -10 || true)
             if [[ -n "$owners" ]]; then
@@ -1407,7 +1692,7 @@ ${owners}"
         fi
 
         # Active security alerts
-        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 2>/dev/null | head -5 || true)
             if [[ -n "$alerts" ]]; then
@@ -1459,6 +1744,34 @@ ${last_error}"
     # Stuckness detection — compare last 3 iteration outputs
     local stuckness_section=""
     stuckness_section="$(detect_stuckness)"
+    local _stuck_ret=$?
+    local stuckness_detected=false
+    [[ "$_stuck_ret" -eq 0 ]] && stuckness_detected=true
+
+    # Strategy exploration when stuck — append alternative strategy to GOAL
+    if [[ "$stuckness_detected" == "true" ]]; then
+        local last_error diagnosis
+        last_error=$(tail -1 "${ARTIFACTS_DIR:-${PROJECT_ROOT:-.}/.claude/pipeline-artifacts}/error-log.jsonl" 2>/dev/null | jq -r '"Type: \(.type), Exit: \(.exit_code), Error: \(.error | split("\n") | first)"' 2>/dev/null || true)
+        [[ -z "$last_error" || "$last_error" == "null" ]] && last_error="unknown"
+        diagnosis="${STUCKNESS_DIAGNOSIS:-}"
+        local alt_strategy
+        alt_strategy=$(explore_alternative_strategy "$last_error" "${ITERATION:-0}" "$diagnosis")
+        GOAL="${GOAL}
+
+${alt_strategy}"
+
+        # Handle model escalation
+        if [[ "${ESCALATE_MODEL:-}" == "true" ]]; then
+            if [[ -f "$SCRIPT_DIR/sw-model-router.sh" ]]; then
+                source "$SCRIPT_DIR/sw-model-router.sh" 2>/dev/null || true
+            fi
+            if type escalate_model &>/dev/null; then
+                MODEL=$(escalate_model "${MODEL:-sonnet}")
+                info "Escalated to model: $MODEL"
+            fi
+            unset ESCALATE_MODEL
+        fi
+    fi
 
     # Session restart context — inject previous session progress
     local restart_section=""
@@ -1470,9 +1783,36 @@ You are starting a FRESH session after the previous one exhausted its iterations
 Read the progress above and continue from where it left off. Do NOT repeat work already done."
     fi
 
+    # Resume-from-checkpoint context — reconstruct Claude context for meaningful resume
+    local resume_section=""
+    if [[ -n "${RESUMED_FROM_ITERATION:-}" && "${RESUMED_FROM_ITERATION:-0}" -gt 0 ]]; then
+        local _test_tail="  (none recorded)"
+        [[ -n "${RESUMED_TEST_OUTPUT:-}" ]] && _test_tail="$(echo "$RESUMED_TEST_OUTPUT" | tail -20)"
+        resume_section="## RESUMING FROM ITERATION ${RESUMED_FROM_ITERATION}
+
+Continue from where you left off. Do NOT repeat work already done.
+
+Previous work modified these files:
+${RESUMED_MODIFIED:-  (none recorded)}
+
+Previous findings/errors from earlier iterations:
+${RESUMED_FINDINGS:-  (none recorded)}
+
+Last test output (fix any failures, tail):
+${_test_tail}
+
+---
+"
+        # Clear after first use so we don't keep injecting on every iteration
+        RESUMED_FROM_ITERATION=""
+        RESUMED_MODIFIED=""
+        RESUMED_FINDINGS=""
+        RESUMED_TEST_OUTPUT=""
+    fi
+
     cat <<PROMPT
 You are an autonomous coding agent on iteration ${ITERATION}/${MAX_ITERATIONS} of a continuous loop.
-
+${resume_section}
 ## Your Goal
 ${GOAL}
 
@@ -1522,55 +1862,163 @@ PROMPT
 }
 
 # ─── Stuckness Detection ─────────────────────────────────────────────────────
-# Compares last 3 iteration log outputs for high overlap (>90% similar lines).
+# Multi-signal detection: text overlap, git diff hash, error repetition, exit code pattern, iteration budget.
+# Returns 0 when stuck, 1 when not. Outputs stuckness section and sets STUCKNESS_HINT when stuck.
+# When stuck: increments STUCKNESS_COUNT, emits event; if STUCKNESS_COUNT >= 3, caller triggers session restart.
+STUCKNESS_COUNT=0
+STUCKNESS_TRACKING_FILE=""
+
+record_iteration_stuckness_data() {
+    local exit_code="${1:-0}"
+    [[ -z "$LOG_DIR" ]] && return 0
+    local tracking_file="${STUCKNESS_TRACKING_FILE:-$LOG_DIR/stuckness-tracking.txt}"
+    local diff_hash error_hash
+    diff_hash=$(git -C "${PROJECT_ROOT:-.}" diff HEAD 2>/dev/null | (md5 -q 2>/dev/null || md5sum 2>/dev/null | cut -d' ' -f1) || echo "none")
+    local error_log="${ARTIFACTS_DIR:-${STATE_DIR:-${PROJECT_ROOT:-.}/.claude}/pipeline-artifacts}/error-log.jsonl"
+    if [[ -f "$error_log" ]]; then
+        error_hash=$(tail -5 "$error_log" 2>/dev/null | sort -u | (md5 -q 2>/dev/null || md5sum 2>/dev/null | cut -d' ' -f1) || echo "none")
+    else
+        error_hash="none"
+    fi
+    echo "${diff_hash}|${error_hash}|${exit_code}" >> "$tracking_file"
+}
+
 detect_stuckness() {
-    if [[ "$ITERATION" -lt 3 ]]; then
-        return 0
+    STUCKNESS_HINT=""
+    local iteration="${ITERATION:-0}"
+    local stuckness_signals=0
+    local stuckness_reasons=()
+    local tracking_file="${STUCKNESS_TRACKING_FILE:-$LOG_DIR/stuckness-tracking.txt}"
+    local tracking_lines
+    tracking_lines=$(wc -l < "$tracking_file" 2>/dev/null || echo "0")
+
+    # Signal 1: Text overlap (existing logic) — compare last 2 iteration logs
+    if [[ "$iteration" -ge 3 ]]; then
+        local log1="$LOG_DIR/iteration-$(( iteration - 1 )).log"
+        local log2="$LOG_DIR/iteration-$(( iteration - 2 )).log"
+        local log3="$LOG_DIR/iteration-$(( iteration - 3 )).log"
+
+        if [[ -f "$log1" && -f "$log2" ]]; then
+            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 [[ -n "$lines1" && -n "$lines2" ]]; then
+                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:-0}" -ge 90 ]]; then
+                    stuckness_signals=$((stuckness_signals + 1))
+                    stuckness_reasons+=("high text overlap (${overlap_pct}%) between iterations")
+                fi
+            fi
+        fi
     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"
+    # Signal 2: Git diff hash — last 3 iterations produced zero or identical diffs
+    if [[ -f "$tracking_file" ]] && [[ "$tracking_lines" -ge 3 ]]; then
+        local last_three
+        last_three=$(tail -3 "$tracking_file" 2>/dev/null | cut -d'|' -f1 || true)
+        local unique_hashes
+        unique_hashes=$(echo "$last_three" | sort -u | grep -v '^$' | wc -l | tr -d ' ')
+        if [[ "$unique_hashes" -le 1 ]] && [[ -n "$last_three" ]]; then
+            stuckness_signals=$((stuckness_signals + 1))
+            stuckness_reasons+=("identical or zero git diffs in last 3 iterations")
+        fi
+    fi
 
-    # Need at least 2 previous logs
-    if [[ ! -f "$log1" || ! -f "$log2" ]]; then
-        return 0
+    # Signal 3: Error repetition — same error hash in last 3 iterations
+    if [[ -f "$tracking_file" ]] && [[ "$tracking_lines" -ge 3 ]]; then
+        local last_three_errors
+        last_three_errors=$(tail -3 "$tracking_file" 2>/dev/null | cut -d'|' -f2 || true)
+        local unique_error_hashes
+        unique_error_hashes=$(echo "$last_three_errors" | sort -u | grep -v '^none$' | grep -v '^$' | wc -l | tr -d ' ')
+        if [[ "$unique_error_hashes" -eq 1 ]] && [[ -n "$(echo "$last_three_errors" | grep -v '^none$')" ]]; then
+            stuckness_signals=$((stuckness_signals + 1))
+            stuckness_reasons+=("same error in last 3 iterations")
+        fi
     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)
+    # Signal 4: Same error repeating 3+ times (legacy check on error-log content)
+    local error_log
+    error_log="${ARTIFACTS_DIR:-$PROJECT_ROOT/.claude/pipeline-artifacts}/error-log.jsonl"
+    if [[ -f "$error_log" ]]; then
+        local last_errors
+        last_errors=$(tail -5 "$error_log" 2>/dev/null | jq -r '.error // .message // .error_hash // empty' 2>/dev/null | sort | uniq -c | sort -rn | head -1 || true)
+        local repeat_count
+        repeat_count=$(echo "$last_errors" | awk '{print $1}' 2>/dev/null || echo "0")
+        if [[ "${repeat_count:-0}" -ge 3 ]]; then
+            stuckness_signals=$((stuckness_signals + 1))
+            stuckness_reasons+=("same error repeated ${repeat_count} times")
+        fi
+    fi
 
-    if [[ -z "$lines1" || -z "$lines2" ]]; then
-        return 0
+    # Signal 5: Exit code pattern — last 3 iterations had same non-zero exit code
+    if [[ -f "$tracking_file" ]] && [[ "$tracking_lines" -ge 3 ]]; then
+        local last_three_exits
+        last_three_exits=$(tail -3 "$tracking_file" 2>/dev/null | cut -d'|' -f3 || true)
+        local first_exit
+        first_exit=$(echo "$last_three_exits" | head -1)
+        if [[ "$first_exit" =~ ^[0-9]+$ ]] && [[ "$first_exit" -ne 0 ]]; then
+            local all_same=true
+            while IFS= read -r ex; do
+                [[ "$ex" != "$first_exit" ]] && all_same=false
+            done <<< "$last_three_exits"
+            if [[ "$all_same" == true ]]; then
+                stuckness_signals=$((stuckness_signals + 1))
+                stuckness_reasons+=("same non-zero exit code (${first_exit}) in last 3 iterations")
+            fi
+        fi
     fi
 
-    total=$(echo "$lines1" | wc -l | tr -d ' ')
-    common=$(comm -12 <(echo "$lines1") <(echo "$lines2") 2>/dev/null | wc -l | tr -d ' ' || echo "0")
+    # Signal 6: Git diff size — no or minimal code changes (existing)
+    local diff_lines
+    diff_lines=$(git -C "${PROJECT_ROOT:-.}" diff HEAD 2>/dev/null | wc -l | tr -d ' ' || echo "0")
+    if [[ "${diff_lines:-0}" -lt 5 ]] && [[ "$iteration" -gt 2 ]]; then
+        stuckness_signals=$((stuckness_signals + 1))
+        stuckness_reasons+=("no code changes in last iteration")
+    fi
 
-    if [[ "$total" -gt 0 ]]; then
-        overlap_pct=$(( common * 100 / total ))
-    else
-        overlap_pct=0
+    # Signal 7: Iteration budget — used >70% without passing tests
+    local max_iter="${MAX_ITERATIONS:-20}"
+    local progress_pct=0
+    if [[ "$max_iter" -gt 0 ]]; then
+        progress_pct=$(( iteration * 100 / max_iter ))
     fi
+    if [[ "$progress_pct" -gt 70 ]] && [[ "${TEST_PASSED:-false}" != "true" ]]; then
+        stuckness_signals=$((stuckness_signals + 1))
+        stuckness_reasons+=("used ${progress_pct}% of iteration budget without passing tests")
+    fi
+
+    # Decision: 2+ signals = stuck
+    if [[ "$stuckness_signals" -ge 2 ]]; then
+        STUCKNESS_COUNT=$(( STUCKNESS_COUNT + 1 ))
+        STUCKNESS_DIAGNOSIS="${stuckness_reasons[*]}"
+        if type emit_event >/dev/null 2>&1; then
+            emit_event "loop.stuckness_detected" "signals=$stuckness_signals" "count=$STUCKNESS_COUNT" "iteration=$iteration" "reasons=${stuckness_reasons[*]}"
+        fi
+        STUCKNESS_HINT="IMPORTANT: The loop appears stuck. Previous approaches have not worked. You MUST try a fundamentally different strategy. Reasons: ${stuckness_reasons[*]}"
+        warn "Stuckness detected (${stuckness_signals} signals, count ${STUCKNESS_COUNT}): ${stuckness_reasons[*]}"
 
-    if [[ "$overlap_pct" -ge 90 ]]; then
         local diff_summary=""
-        if [[ -f "$log3" ]]; then
+        local log1="$LOG_DIR/iteration-$(( iteration - 1 )).log"
+        local log3="$LOG_DIR/iteration-$(( iteration - 3 )).log"
+        if [[ -f "$log3" && -f "$log1" ]]; 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
+        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.
+${STUCKNESS_HINT}
 
 ${diff_summary:+Changes between recent iterations:
 $diff_summary
@@ -1584,7 +2032,10 @@ Try a fundamentally different approach:
 - 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
+        return 0
     fi
+
+    return 1
 }
 
 compose_audit_section() {
@@ -1675,7 +2126,7 @@ compose_worker_prompt() {
             local role_desc=""
             # Try to pull description from recruit's roles DB first
             local recruit_roles_db="${HOME}/.shipwright/recruitment/roles.json"
-            if [[ -f "$recruit_roles_db" ]] && command -v jq &>/dev/null; then
+            if [[ -f "$recruit_roles_db" ]] && command -v jq >/dev/null 2>&1; then
                 local recruit_desc
                 recruit_desc=$(jq -r --arg r "$role" '.[$r].description // ""' "$recruit_roles_db" 2>/dev/null) || true
                 if [[ -n "$recruit_desc" && "$recruit_desc" != "null" ]]; then
@@ -1735,6 +2186,12 @@ run_claude_iteration() {
     local json_file="$LOG_DIR/iteration-${ITERATION}.json"
     local prompt
     prompt="$(compose_prompt)"
+    local final_prompt
+    final_prompt=$(manage_context_window "$prompt")
+
+    local prompt_chars=${#final_prompt}
+    local approx_tokens=$((prompt_chars / 4))
+    info "Prompt: ~${approx_tokens} tokens (${prompt_chars} chars)"
 
     local flags
     flags="$(build_claude_flags)"
@@ -1750,9 +2207,9 @@ run_claude_iteration() {
     # shellcheck disable=SC2086
     local err_file="${json_file%.json}.stderr"
     if [[ -n "$TIMEOUT_CMD" ]]; then
-        $TIMEOUT_CMD "$CLAUDE_TIMEOUT" claude -p "$prompt" $flags > "$json_file" 2>"$err_file" &
+        $TIMEOUT_CMD "$CLAUDE_TIMEOUT" claude -p "$final_prompt" $flags > "$json_file" 2>"$err_file" &
     else
-        claude -p "$prompt" $flags > "$json_file" 2>"$err_file" &
+        claude -p "$final_prompt" $flags > "$json_file" 2>"$err_file" &
     fi
     CHILD_PID=$!
     wait "$CHILD_PID" 2>/dev/null || exit_code=$?
@@ -1835,12 +2292,13 @@ show_summary() {
 
     local status_display
     case "$STATUS" in
-        complete)        status_display="${GREEN}✓ Complete (LOOP_COMPLETE detected)${RESET}" ;;
-        circuit_breaker) status_display="${RED}✗ Circuit breaker tripped${RESET}" ;;
-        max_iterations)  status_display="${YELLOW}⚠ Max iterations reached${RESET}" ;;
-        interrupted)     status_display="${YELLOW}⚠ Interrupted by user${RESET}" ;;
-        error)           status_display="${RED}✗ Error${RESET}" ;;
-        *)               status_display="${DIM}$STATUS${RESET}" ;;
+        complete)         status_display="${GREEN}✓ Complete (LOOP_COMPLETE detected)${RESET}" ;;
+        circuit_breaker)  status_display="${RED}✗ Circuit breaker tripped${RESET}" ;;
+        max_iterations)   status_display="${YELLOW}⚠ Max iterations reached${RESET}" ;;
+        budget_exhausted) status_display="${RED}✗ Budget exhausted${RESET}" ;;
+        interrupted)      status_display="${YELLOW}⚠ Interrupted by user${RESET}" ;;
+        error)            status_display="${RED}✗ Error${RESET}" ;;
+        *)                status_display="${DIM}$STATUS${RESET}" ;;
     esac
 
     local test_display
@@ -1909,6 +2367,15 @@ cleanup() {
         --iteration "$ITERATION" \
         --git-sha "$(git rev-parse HEAD 2>/dev/null || echo unknown)" 2>/dev/null || true
 
+    # Save Claude context for meaningful resume (goal, findings, test output)
+    export SW_LOOP_GOAL="$GOAL"
+    export SW_LOOP_ITERATION="$ITERATION"
+    export SW_LOOP_STATUS="$STATUS"
+    export SW_LOOP_TEST_OUTPUT="${TEST_OUTPUT:-}"
+    export SW_LOOP_FINDINGS="${LOG_ENTRIES:-}"
+    export SW_LOOP_MODIFIED="$(git diff --name-only HEAD 2>/dev/null | head -50 | tr '\n' ',' | sed 's/,$//')"
+    "$SCRIPT_DIR/sw-checkpoint.sh" save-context --stage build 2>/dev/null || true
+
     # Clear heartbeat
     "$SCRIPT_DIR/sw-heartbeat.sh" clear "${PIPELINE_JOB_ID:-loop-$$}" 2>/dev/null || true
 
@@ -1934,7 +2401,7 @@ setup_worktrees() {
         fi
 
         # Create branch if it doesn't exist
-        if ! git -C "$PROJECT_ROOT" rev-parse --verify "$branch_name" &>/dev/null; then
+        if ! git -C "$PROJECT_ROOT" rev-parse --verify "$branch_name" >/dev/null 2>&1; then
             git -C "$PROJECT_ROOT" branch "$branch_name" HEAD 2>/dev/null || true
         fi
 
@@ -1996,6 +2463,17 @@ CONSECUTIVE_FAILURES=0
 echo -e "${CYAN}${BOLD}▸${RESET} Agent ${AGENT_NUM}/${TOTAL_AGENTS} starting in ${WORK_DIR}"
 
 while [[ "$ITERATION" -lt "$MAX_ITERATIONS" ]]; do
+    # Budget gate: stop if daily budget exhausted
+    if [[ -x "$SCRIPT_DIR/sw-cost.sh" ]]; then
+        budget_remaining=$("$SCRIPT_DIR/sw-cost.sh" remaining-budget 2>/dev/null || echo "")
+        if [[ -n "$budget_remaining" && "$budget_remaining" != "unlimited" ]]; then
+            if awk -v r="$budget_remaining" 'BEGIN { exit !(r <= 0) }' 2>/dev/null; then
+                echo -e "  ${RED}✗${RESET} Budget exhausted (\$${budget_remaining}) — stopping agent ${AGENT_NUM}"
+                break
+            fi
+        fi
+    fi
+
     ITERATION=$(( ITERATION + 1 ))
     echo -e "\n${CYAN}${BOLD}▸${RESET} Agent ${AGENT_NUM} — Iteration ${ITERATION}/${MAX_ITERATIONS}"
 
@@ -2064,8 +2542,12 @@ PROMPT
     # Auto-commit
     git add -A 2>/dev/null || true
     if git commit -m "agent-${AGENT_NUM}: iteration ${ITERATION}" --no-verify 2>/dev/null; then
-        git push origin "loop/agent-${AGENT_NUM}" 2>/dev/null || true
-        echo -e "  ${GREEN}✓${RESET} Committed and pushed"
+        if ! git push origin "loop/agent-${AGENT_NUM}" 2>/dev/null; then
+            echo -e "  ${YELLOW}⚠${RESET} git push failed for loop/agent-${AGENT_NUM} — remote may be out of sync"
+            type emit_event >/dev/null 2>&1 && emit_event "loop.push_failed" "branch=loop/agent-${AGENT_NUM}"
+        else
+            echo -e "  ${GREEN}✓${RESET} Committed and pushed"
+        fi
     fi
 
     # Circuit breaker: check for progress
@@ -2083,7 +2565,7 @@ PROMPT
         break
     fi
 
-    sleep 2
+    sleep __SLEEP_BETWEEN_ITERATIONS__
 done
 
 echo -e "\n${DIM}Agent ${AGENT_NUM} finished after ${ITERATION} iterations${RESET}"
@@ -2094,11 +2576,14 @@ WORKEREOF
     sed_i "s|__AGENT_NUM__|${agent_num}|g" "$worker_script"
     sed_i "s|__TOTAL_AGENTS__|${total_agents}|g" "$worker_script"
     sed_i "s|__MAX_ITERATIONS__|${MAX_ITERATIONS}|g" "$worker_script"
+    sed_i "s|__SLEEP_BETWEEN_ITERATIONS__|$(_config_get_int "loop.sleep_between_iterations" 2 2>/dev/null || echo 2)|g" "$worker_script"
     # Paths and commands may contain sed-special chars — use awk
     awk -v val="$wt_path" '{gsub(/__WORK_DIR__/, val); print}' "$worker_script" > "${worker_script}.tmp" \
         && mv "${worker_script}.tmp" "$worker_script"
     awk -v val="$LOG_DIR" '{gsub(/__LOG_DIR__/, val); print}' "$worker_script" > "${worker_script}.tmp" \
         && mv "${worker_script}.tmp" "$worker_script"
+    awk -v val="$SCRIPT_DIR" '{gsub(/__SCRIPT_DIR__/, val); print}' "$worker_script" > "${worker_script}.tmp" \
+        && mv "${worker_script}.tmp" "$worker_script"
     awk -v val="$TEST_CMD" '{gsub(/__TEST_CMD__/, val); print}' "$worker_script" > "${worker_script}.tmp" \
         && mv "${worker_script}.tmp" "$worker_script"
     awk -v val="$claude_flags" '{gsub(/__CLAUDE_FLAGS__/, val); print}' "$worker_script" > "${worker_script}.tmp" \
@@ -2137,11 +2622,12 @@ launch_multi_agent() {
         local worker_script
         worker_script="$(generate_worker_script "$i" "$AGENTS")"
 
-        tmux split-window -t "$MULTI_WINDOW_NAME" -c "$PROJECT_ROOT"
+        local worker_pane_id
+        worker_pane_id="$(tmux split-window -t "$MULTI_WINDOW_NAME" -c "$PROJECT_ROOT" -P -F '#{pane_id}')"
         sleep 0.1
-        tmux send-keys -t "$MULTI_WINDOW_NAME" "printf '\\033]2;agent-${i}\\033\\\\'" Enter
+        tmux send-keys -t "$worker_pane_id" "printf '\\033]2;agent-${i}\\033\\\\'" Enter
         sleep 0.1
-        tmux send-keys -t "$MULTI_WINDOW_NAME" "bash '$worker_script'" Enter
+        tmux send-keys -t "$worker_pane_id" "bash '$worker_script'" Enter
     done
 
     # Layout: monitor pane on top (35%), worker agents tile below
@@ -2181,7 +2667,7 @@ wait_for_multi_completion() {
             latest_log="$(ls -t "$LOG_DIR"/agent-"${i}"-iter-*.log 2>/dev/null | head -1)"
             if [[ -n "$latest_log" ]]; then
                 local age
-                age=$(( $(now_epoch) - $(stat -f %m "$latest_log" 2>/dev/null || echo 0) ))
+                age=$(( $(now_epoch) - $(file_mtime "$latest_log") ))
                 if [[ $age -lt 300 ]]; then  # Active within 5 minutes
                     running=$(( running + 1 ))
                 fi
@@ -2200,7 +2686,7 @@ wait_for_multi_completion() {
             fi
         fi
 
-        sleep 5
+        sleep "$(_config_get_int "loop.multi_agent_sleep" 5 2>/dev/null || echo 5)"
     done
 }
 
@@ -2239,6 +2725,10 @@ run_single_agent_loop() {
 
     # Track applied memory fix patterns for outcome recording
     _applied_fix_pattern=""
+    STUCKNESS_COUNT=0
+    STUCKNESS_TRACKING_FILE="$LOG_DIR/stuckness-tracking.txt"
+    : > "$STUCKNESS_TRACKING_FILE" 2>/dev/null || true
+    : > "${LOG_DIR:-/tmp}/strategy-attempts.txt" 2>/dev/null || true
 
     show_banner
 
@@ -2246,17 +2736,48 @@ run_single_agent_loop() {
         # Pre-checks (before incrementing — ITERATION tracks completed count)
         check_circuit_breaker || break
         check_max_iterations || break
+        check_budget_gate || {
+            STATUS="budget_exhausted"
+            write_state
+            write_progress
+            error "Budget exhausted — stopping pipeline"
+            show_summary
+            return 1
+        }
         ITERATION=$(( ITERATION + 1 ))
 
-        # Try memory-based fix suggestion on retry after test failure
+        # Root-cause diagnosis and memory-based fix on retry after test failure
         if [[ "${TEST_PASSED:-}" == "false" ]]; then
+            # Source memory module for diagnosis and fix lookup
+            [[ -f "$SCRIPT_DIR/sw-memory.sh" ]] && source "$SCRIPT_DIR/sw-memory.sh" 2>/dev/null || true
+
+            # Capture failure for memory (enables memory_analyze_failure and future fix lookup)
+            if type memory_capture_failure &>/dev/null && [[ -n "${TEST_OUTPUT:-}" ]]; then
+                memory_capture_failure "test" "$TEST_OUTPUT" 2>/dev/null || true
+            fi
+
+            # Pattern-based diagnosis (no Claude needed) — inject into goal for smarter retry
+            local _changed_files=""
+            _changed_files=$(git diff --name-only HEAD 2>/dev/null | head -50 | tr '\n' ',' | sed 's/,$//')
+            local _diagnosis
+            _diagnosis=$(diagnose_failure "${TEST_OUTPUT:-}" "$_changed_files" "$ITERATION" 2>/dev/null || true)
+
+            if [[ -n "$_diagnosis" ]]; then
+                GOAL="${GOAL}
+
+${_diagnosis}"
+                info "Failure diagnosis injected (classification from error pattern)"
+            fi
+
+            # Memory-based fix suggestion (from past successful fixes)
             local _last_error=""
             local _prev_log="$LOG_DIR/iteration-$(( ITERATION - 1 )).log"
             if [[ -f "$_prev_log" ]]; then
                 _last_error=$(tail -20 "$_prev_log" 2>/dev/null | grep -iE '(error|fail|exception)' | head -1 || true)
             fi
+            [[ -z "$_last_error" ]] && _last_error=$(echo "${TEST_OUTPUT:-}" | head -3 | tr '\n' ' ')
             local _fix_suggestion=""
-            if type memory_closed_loop_inject &>/dev/null 2>&1 && [[ -n "${_last_error:-}" ]]; then
+            if type memory_closed_loop_inject >/dev/null 2>&1 && [[ -n "${_last_error:-}" ]]; then
                 _fix_suggestion=$(memory_closed_loop_inject "$_last_error" 2>/dev/null) || true
             fi
             if [[ -n "${_fix_suggestion:-}" ]]; then
@@ -2266,6 +2787,14 @@ run_single_agent_loop() {
 ${GOAL}"
                 info "Memory fix injected: ${_fix_suggestion:0:80}"
             fi
+
+            # Analyze failure via Claude (background, non-blocking) for richer root_cause/fix in memory
+            if type memory_analyze_failure &>/dev/null && [[ "${INTELLIGENCE_ENABLED:-auto}" != "false" ]]; then
+                local _test_log="${TEST_LOG_FILE:-$LOG_DIR/tests-iter-$(( ITERATION - 1 )).log}"
+                if [[ -f "$_test_log" ]]; then
+                    memory_analyze_failure "$_test_log" "test" 2>/dev/null &
+                fi
+            fi
         fi
 
         # Run Claude
@@ -2274,6 +2803,9 @@ ${GOAL}"
 
         local log_file="$LOG_DIR/iteration-${ITERATION}.log"
 
+        # Record iteration data for stuckness detection (diff hash, error hash, exit code)
+        record_iteration_stuckness_data "$exit_code"
+
         # Detect fatal CLI errors (API key, auth, network) — abort immediately
         if check_fatal_error "$log_file" "$exit_code"; then
             STATUS="error"
@@ -2285,7 +2817,7 @@ ${GOAL}"
         fi
 
         # 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
+        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
@@ -2331,7 +2863,7 @@ ${GOAL}"
 
         # Track fix outcome for memory effectiveness
         if [[ -n "${_applied_fix_pattern:-}" ]]; then
-            if type memory_record_fix_outcome &>/dev/null 2>&1; then
+            if type memory_record_fix_outcome >/dev/null 2>&1; then
                 if [[ "${TEST_PASSED:-}" == "true" ]]; then
                     memory_record_fix_outcome "$_applied_fix_pattern" "true" "true" 2>/dev/null || true
                 else
@@ -2341,6 +2873,15 @@ ${GOAL}"
             _applied_fix_pattern=""
         fi
 
+        # Save Claude context for checkpoint resume (goal, findings, test output)
+        export SW_LOOP_GOAL="$GOAL"
+        export SW_LOOP_ITERATION="$ITERATION"
+        export SW_LOOP_STATUS="${STATUS:-running}"
+        export SW_LOOP_TEST_OUTPUT="${TEST_OUTPUT:-}"
+        export SW_LOOP_FINDINGS="${LOG_ENTRIES:-}"
+        export SW_LOOP_MODIFIED="$(git diff --name-only HEAD 2>/dev/null | head -50 | tr '\n' ',' | sed 's/,$//')"
+        "$SCRIPT_DIR/sw-checkpoint.sh" save-context --stage build 2>/dev/null || true
+
         # Audit agent (reviews implementer's work)
         run_audit_agent
 
@@ -2396,7 +2937,16 @@ HUMAN FEEDBACK (received after iteration $ITERATION): $human_msg"
             fi
         fi
 
-        sleep 2
+        # Stuckness-triggered restart: if detected 3+ times, break to allow session restart
+        if [[ "${STUCKNESS_COUNT:-0}" -ge 3 ]]; then
+            STATUS="stuck_restart"
+            write_state
+            write_progress
+            warn "Stuckness detected 3+ times — triggering session restart"
+            break
+        fi
+
+        sleep "$(_config_get_int "loop.sleep_between_iterations" 2 2>/dev/null || echo 2)"
     done
 
     # Write final state after loop exits
@@ -2437,7 +2987,7 @@ run_loop_with_restarts() {
         fi
 
         RESTART_COUNT=$(( RESTART_COUNT + 1 ))
-        if type emit_event &>/dev/null 2>&1; then
+        if type emit_event >/dev/null 2>&1; then
             emit_event "loop.restart" "restart=$RESTART_COUNT" "max=$MAX_RESTARTS" "iteration=$ITERATION"
         fi
         info "Session restart ${RESTART_COUNT}/${MAX_RESTARTS} — resetting iteration counter"
@@ -2448,6 +2998,7 @@ run_loop_with_restarts() {
         ITERATION=0
         CONSECUTIVE_FAILURES=0
         EXTENSION_COUNT=0
+        STUCKNESS_COUNT=0
         STATUS="running"
         LOG_ENTRIES=""
         TEST_PASSED=""
@@ -2469,7 +3020,7 @@ run_loop_with_restarts() {
 
         write_state
 
-        sleep 2
+        sleep "$(_config_get_int "loop.sleep_between_iterations" 2 2>/dev/null || echo 2)"
     done
 }