shipwright-cli 2.4.0 → 3.1.0

package/scripts/sw-loop.sh

@@ -23,6 +23,13 @@ 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"
+# Source DB for dual-write (emit_event → JSONL + SQLite).
+# Note: do NOT call init_schema here — the pipeline (sw-pipeline.sh) owns schema
+# initialization. Calling it here would create an empty DB that shadows JSON cost data.
+if [[ -f "$SCRIPT_DIR/sw-db.sh" ]]; then
+    source "$SCRIPT_DIR/sw-db.sh" 2>/dev/null || true
+fi
 # 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 +47,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 +65,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.4.0"
+VERSION="3.1.0"
 
 # ─── Token Tracking ─────────────────────────────────────────────────────────
 LOOP_INPUT_TOKENS=0
@@ -335,13 +333,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 +349,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 +391,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 +401,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 +420,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 +440,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 +456,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 +503,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 +554,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 +572,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 +583,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 +631,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 ))
@@ -652,6 +661,9 @@ initialize_state() {
     STATUS="running"
     LOG_ENTRIES=""
 
+    # Record starting commit for cumulative diff in quality gates
+    LOOP_START_COMMIT="$(git -C "$PROJECT_ROOT" rev-parse HEAD 2>/dev/null || echo "")"
+
     write_state
 }
 
@@ -723,6 +735,11 @@ resume_state() {
     START_EPOCH="$(now_epoch)"
     STATUS="running"
 
+    # Set starting commit for cumulative diff (approximate: use earliest tracked commit)
+    if [[ -z "${LOOP_START_COMMIT:-}" ]]; then
+        LOOP_START_COMMIT="$(git -C "$PROJECT_ROOT" rev-list --max-parents=0 HEAD 2>/dev/null | tail -1 || echo "")"
+    fi
+
     # If we hit max iterations before, warn user to extend
     if [[ "$ITERATION" -ge "$MAX_ITERATIONS" ]] && ! $MAX_ITERATIONS_EXPLICIT; then
         warn "Previous run stopped at iteration $ITERATION/$MAX_ITERATIONS."
@@ -730,6 +747,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 +839,86 @@ ${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 || true)
+    total_changed="${total_changed:-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 +946,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
 }
@@ -861,7 +981,8 @@ check_fatal_error() {
     # Non-zero exit + tiny output = likely CLI crash
     if [[ "$cli_exit_code" -ne 0 ]]; then
         local line_count
-        line_count=$(grep -cv '^$' "$log_file" 2>/dev/null || echo 0)
+        line_count=$(grep -cv '^$' "$log_file" 2>/dev/null || true)
+        line_count="${line_count:-0}"
         if [[ "$line_count" -lt 3 ]]; then
             local content
             content=$(head -3 "$log_file" 2>/dev/null | cut -c1-120)
@@ -897,7 +1018,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 +1110,114 @@ 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 || true)
+        repeat_count="${repeat_count:-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 +1247,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 +1301,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")" \
@@ -1105,33 +1334,60 @@ run_audit_agent() {
     local log_file="$LOG_DIR/iteration-${ITERATION}.log"
     local audit_log="$LOG_DIR/audit-iter-${ITERATION}.log"
 
-    # Gather context: tail of implementer output + git diff
+    # Gather context: tail of implementer output + cumulative diff
     local impl_tail
     impl_tail="$(tail -100 "$log_file" 2>/dev/null || echo "(no output)")"
-    local diff_stat
-    diff_stat="$(git -C "$PROJECT_ROOT" diff --stat HEAD~1 2>/dev/null || echo "(no changes)")"
+
+    # Use cumulative diff from loop start so auditor sees ALL work, not just latest commit
+    local diff_stat cumulative_note=""
+    if [[ -n "${LOOP_START_COMMIT:-}" ]]; then
+        diff_stat="$(git -C "$PROJECT_ROOT" diff --stat "${LOOP_START_COMMIT}..HEAD" 2>/dev/null || echo "(no changes)")"
+        cumulative_note="Note: This diff shows ALL changes since the loop started (iteration 1 through ${ITERATION}), not just the latest commit."
+    else
+        diff_stat="$(git -C "$PROJECT_ROOT" diff --stat HEAD~1 2>/dev/null || echo "(no changes)")"
+    fi
+
+    # Include verified test status so auditor doesn't have to guess
+    local test_context=""
+    if [[ -n "$TEST_CMD" ]]; then
+        if [[ "${TEST_PASSED:-}" == "true" ]]; then
+            test_context="## Verified Test Status (from harness, not from agent)
+Tests: ALL PASSING (command: ${TEST_CMD})"
+        else
+            test_context="## Verified Test Status (from harness)
+Tests: FAILING (command: ${TEST_CMD})
+$(echo "${TEST_OUTPUT:-}" | tail -10)"
+        fi
+    fi
 
     local audit_prompt
     read -r -d '' audit_prompt <<AUDIT_PROMPT || true
-You are an independent code auditor reviewing an autonomous coding agent.
+You are an independent code auditor reviewing an autonomous coding agent's CUMULATIVE work.
+This is iteration ${ITERATION}. The agent may have done most of the work in earlier iterations.
 
 ## Goal the agent was working toward
 ${GOAL}
 
-## Agent Output (last 100 lines)
+## Agent Output This Iteration (last 100 lines)
 ${impl_tail}
 
-## Changes Made (git diff --stat)
+## Cumulative Changes Made (git diff --stat)
+${cumulative_note}
 ${diff_stat}
 
+${test_context}
+
 ## Your Task
-Critically review the work:
-1. Did the agent make meaningful progress toward the goal?
-2. Are there obvious bugs, logic errors, or security issues?
+Critically review the CUMULATIVE work (not just the latest iteration):
+1. Has the agent made meaningful progress toward the goal across all iterations?
+2. Are there obvious bugs, logic errors, or security issues in the current codebase?
 3. Did the agent leave incomplete work (TODOs, placeholder code)?
 4. Are there any regressions or broken patterns?
 5. Is the code quality acceptable?
 
+IMPORTANT: If the current iteration made small or no code changes, that may be acceptable
+if earlier iterations already completed the substantive work. Judge the whole body of work.
+
 If the work is acceptable and moves toward the goal, output exactly: AUDIT_PASS
 Otherwise, list the specific issues that need fixing.
 AUDIT_PROMPT
@@ -1217,21 +1473,52 @@ check_definition_of_done() {
 
     local dod_content
     dod_content="$(cat "$DOD_FILE")"
+
+    # Use cumulative diff from loop start (not just HEAD~1) so the evaluator
+    # can see ALL work done across every iteration, not just the latest commit.
     local diff_content
-    diff_content="$(git -C "$PROJECT_ROOT" diff HEAD~1 2>/dev/null || echo "(no diff)")"
+    if [[ -n "${LOOP_START_COMMIT:-}" ]]; then
+        diff_content="$(git -C "$PROJECT_ROOT" diff --stat "${LOOP_START_COMMIT}..HEAD" 2>/dev/null || echo "(no diff)")"
+        diff_content="${diff_content}
+
+## Detailed Changes (cumulative diff, truncated to 200 lines)
+$(git -C "$PROJECT_ROOT" diff "${LOOP_START_COMMIT}..HEAD" 2>/dev/null | head -200 || echo "(no diff)")"
+    else
+        diff_content="$(git -C "$PROJECT_ROOT" diff HEAD~1 2>/dev/null || echo "(no diff)")"
+    fi
+
+    # Inject verified runtime facts so the evaluator doesn't have to guess
+    local runtime_facts=""
+    if [[ -n "$TEST_CMD" ]]; then
+        if [[ "${TEST_PASSED:-}" == "true" ]]; then
+            runtime_facts="## Verified Runtime Facts (from the loop harness, not from the agent)
+- Tests: ALL PASSING (verified by running '${TEST_CMD}' after this iteration)
+- Test output (last 10 lines):
+$(echo "${TEST_OUTPUT:-}" | tail -10)"
+        else
+            runtime_facts="## Verified Runtime Facts
+- Tests: FAILING (verified by running '${TEST_CMD}')
+- Test output (last 10 lines):
+$(echo "${TEST_OUTPUT:-}" | tail -10)"
+        fi
+    fi
 
     local dod_prompt
     read -r -d '' dod_prompt <<DOD_PROMPT || true
-You are evaluating whether code changes satisfy a Definition of Done checklist.
+You are evaluating whether a project satisfies a Definition of Done checklist.
+You are reviewing the CUMULATIVE work across all iterations, not just the latest commit.
 
 ## Definition of Done
 ${dod_content}
 
-## Changes Made (git diff)
+${runtime_facts}
+
+## Cumulative Changes Made (git diff from start of loop to now)
 ${diff_content}
 
 ## Your Task
-For each item in the Definition of Done, determine if the changes satisfy it.
+For each item in the Definition of Done, determine if the project satisfies it.
+The runtime facts above are verified by the harness — trust them as ground truth.
 If ALL items are satisfied, output exactly: DOD_PASS
 Otherwise, list which items are NOT satisfied and why.
 DOD_PROMPT
@@ -1285,6 +1572,14 @@ guard_completion() {
         rejection_reasons+=("tests failing")
     fi
 
+    # Holistic final gate: when all other gates pass, run a project-level assessment
+    # that evaluates the entire codebase against the goal (not just the latest diff)
+    if [[ ${#rejection_reasons[@]} -eq 0 ]]; then
+        if ! run_holistic_gate; then
+            rejection_reasons+=("holistic project assessment found gaps")
+        fi
+    fi
+
     if [[ ${#rejection_reasons[@]} -gt 0 ]]; then
         local reasons_str
         reasons_str="$(printf ', %s' "${rejection_reasons[@]}")"
@@ -1298,6 +1593,143 @@ guard_completion() {
     return 0
 }
 
+# Holistic gate: evaluates the full project against the original goal.
+# Only runs when all other gates pass (final checkpoint before acceptance).
+run_holistic_gate() {
+    # Skip if no starting commit (can't compute cumulative diff)
+    [[ -z "${LOOP_START_COMMIT:-}" ]] && return 0
+
+    local holistic_log="$LOG_DIR/holistic-iter-${ITERATION}.log"
+
+    # Build a project summary: file tree, test count, cumulative diff stats
+    local file_count
+    file_count=$(git -C "$PROJECT_ROOT" ls-files | wc -l | tr -d ' ')
+    local cumulative_stat
+    cumulative_stat="$(git -C "$PROJECT_ROOT" diff --stat "${LOOP_START_COMMIT}..HEAD" 2>/dev/null | tail -1 || echo "(no changes)")"
+    local test_summary=""
+    if [[ -n "${TEST_OUTPUT:-}" ]]; then
+        test_summary="$(echo "$TEST_OUTPUT" | tail -5)"
+    fi
+
+    local holistic_prompt
+    read -r -d '' holistic_prompt <<HOLISTIC_PROMPT || true
+You are a final quality gate evaluating whether an autonomous coding agent has FULLY achieved its goal.
+
+## Original Goal
+${GOAL}
+
+## Project Stats
+- Files in repo: ${file_count}
+- Iterations completed: ${ITERATION}
+- Cumulative changes: ${cumulative_stat}
+- Tests: ${TEST_PASSED:-unknown} (command: ${TEST_CMD:-none})
+${test_summary:+- Test output: ${test_summary}}
+
+## Cumulative Git Changes (diff --stat from start)
+$(git -C "$PROJECT_ROOT" diff --stat "${LOOP_START_COMMIT}..HEAD" 2>/dev/null | head -40 || echo "(none)")
+
+## Your Task
+Based on the goal and the cumulative work done:
+1. Has the goal been FULLY achieved (not partially)?
+2. Is there any critical gap that would make this unacceptable for production?
+
+If the goal is fully achieved, output exactly: HOLISTIC_PASS
+Otherwise, list the specific gaps remaining.
+HOLISTIC_PROMPT
+
+    echo -e "  ${PURPLE}▸${RESET} Running holistic project assessment..."
+
+    local hol_model
+    hol_model="$(select_audit_model)"
+    local hol_flags=("--model" "$hol_model")
+    if $SKIP_PERMISSIONS; then
+        hol_flags+=("--dangerously-skip-permissions")
+    fi
+
+    claude -p "$holistic_prompt" "${hol_flags[@]}" > "$holistic_log" 2>&1 || true
+
+    if grep -q "HOLISTIC_PASS" "$holistic_log" 2>/dev/null; then
+        echo -e "  ${GREEN}✓${RESET} Holistic assessment: passed"
+        return 0
+    else
+        echo -e "  ${YELLOW}⚠${RESET} Holistic assessment: gaps found"
+        return 1
+    fi
+}
+
+# ─── 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 +1780,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 +1788,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 +1817,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 +1828,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 +1839,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 +1891,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,12 +1930,52 @@ 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
+
+    # Build cumulative progress summary showing all iterations' work
+    local cumulative_section=""
+    if [[ -n "${LOOP_START_COMMIT:-}" ]] && [[ "$ITERATION" -gt 1 ]]; then
+        local cum_stat
+        cum_stat="$(git -C "$PROJECT_ROOT" diff --stat "${LOOP_START_COMMIT}..HEAD" 2>/dev/null | tail -1 || true)"
+        if [[ -n "$cum_stat" ]]; then
+            cumulative_section="## Cumulative Progress (all iterations combined)
+${cum_stat}
+"
+        fi
+    fi
+
     cat <<PROMPT
 You are an autonomous coding agent on iteration ${ITERATION}/${MAX_ITERATIONS} of a continuous loop.
-
+${resume_section}
 ## Your Goal
 ${GOAL}
 
+${cumulative_section}
 ## Current Progress
 ${recent_log}
 
@@ -1521,56 +2021,227 @@ ${stuckness_section}
 PROMPT
 }
 
+# ─── Alternative Strategy Exploration ─────────────────────────────────────────
+# When stuckness is detected, generate a context-aware alternative strategy.
+# Uses pattern matching on error type + iteration count to suggest different approaches.
+
+explore_alternative_strategy() {
+    local last_error="${1:-unknown}"
+    local iteration="${2:-0}"
+    local diagnosis="${3:-}"
+
+    # Track attempted strategies to avoid repeating them
+    local strategy_file="${LOG_DIR:-/tmp}/strategy-attempts.txt"
+    local attempted
+    attempted=$(cat "$strategy_file" 2>/dev/null || true)
+
+    local strategy=""
+
+    # If quality gates are passing but evaluators disagree, suggest focusing on evaluator alignment
+    if [[ "${TEST_PASSED:-}" == "true" ]] && [[ "${QUALITY_GATE_PASSED:-}" == "true" || "${AUDIT_RESULT:-}" == "pass" ]]; then
+        if ! echo "$attempted" | grep -q "evaluator_alignment"; then
+            echo "evaluator_alignment" >> "$strategy_file"
+            strategy="## Alternative Strategy: Evaluator Alignment
+The code appears functionally complete (tests pass). Focus on satisfying the remaining
+quality gate evaluators. Check the DoD log and audit log for specific complaints, then
+address those exact points rather than adding new features."
+        fi
+    fi
+
+    # If no code changes in last iteration, suggest verifying existing work
+    if echo "$last_error" | grep -qi "no code changes" || [[ "$diagnosis" == *"no code"* ]]; then
+        if ! echo "$attempted" | grep -q "verify_existing"; then
+            echo "verify_existing" >> "$strategy_file"
+            strategy="## Alternative Strategy: Verify Existing Work
+Recent iterations made no code changes. The work may already be complete.
+Run the full test suite, verify all features work, and if everything passes,
+commit a verification message and declare LOOP_COMPLETE with evidence."
+        fi
+    fi
+
+    # Generic fallback: break the problem down
+    if [[ -z "$strategy" ]]; then
+        if ! echo "$attempted" | grep -q "decompose"; then
+            echo "decompose" >> "$strategy_file"
+            strategy="## Alternative Strategy: Decompose
+Break the remaining work into smaller, independent steps. Focus on one specific
+file or function at a time. Read error messages literally — the root cause may
+differ from your assumption."
+        fi
+    fi
+
+    echo "$strategy"
+}
+
 # ─── 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
+
+    # Gate-aware dampening: if tests pass and the agent has made progress overall,
+    # reduce stuckness signal count. The "no code changes" and "identical diffs" signals
+    # fire when code is already complete and the agent is fighting evaluator quirks —
+    # that's not genuine stuckness, it's "done but gates disagree."
+    if [[ "${TEST_PASSED:-}" == "true" ]] && [[ "$stuckness_signals" -ge 2 ]]; then
+        # If at least one quality signal is positive, dampen by 1
+        if [[ "${AUDIT_RESULT:-}" == "pass" ]] || $QUALITY_GATE_PASSED 2>/dev/null; then
+            stuckness_signals=$((stuckness_signals - 1))
+        fi
+    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 +2255,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 +2349,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 +2409,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 +2430,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 +2515,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 +2590,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 +2624,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 +2686,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 +2765,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 +2788,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 +2799,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 +2845,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 +2890,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 +2909,7 @@ wait_for_multi_completion() {
             fi
         fi
 
-        sleep 5
+        sleep "$(_config_get_int "loop.multi_agent_sleep" 5 2>/dev/null || echo 5)"
     done
 }
 
@@ -2233,12 +2942,21 @@ run_single_agent_loop() {
         initialize_state
     fi
 
+    # Ensure LOOP_START_COMMIT is set (may not be on resume/restart)
+    if [[ -z "${LOOP_START_COMMIT:-}" ]]; then
+        LOOP_START_COMMIT="$(git -C "$PROJECT_ROOT" rev-parse HEAD 2>/dev/null || echo "")"
+    fi
+
     # Apply adaptive budget/model before showing banner
     apply_adaptive_budget
     MODEL="$(select_adaptive_model "build" "$MODEL")"
 
     # 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 +2964,58 @@ 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
+        # Emit iteration start event for pipeline visibility
+        if type emit_event >/dev/null 2>&1; then
+            emit_event "loop.iteration_start" \
+                "iteration=$ITERATION" \
+                "max=$MAX_ITERATIONS" \
+                "job_id=${PIPELINE_JOB_ID:-loop-$$}" \
+                "agent=${AGENT_NUM:-1}" \
+                "test_passed=${TEST_PASSED:-unknown}"
+        fi
+
+        # 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 +3025,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 +3041,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 +3055,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 +3101,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 +3111,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
 
@@ -2374,6 +3153,18 @@ $summary
         write_state
         write_progress
 
+        # Emit iteration complete event for pipeline visibility
+        if type emit_event >/dev/null 2>&1; then
+            emit_event "loop.iteration_complete" \
+                "iteration=$ITERATION" \
+                "max=$MAX_ITERATIONS" \
+                "job_id=${PIPELINE_JOB_ID:-loop-$$}" \
+                "agent=${AGENT_NUM:-1}" \
+                "test_passed=${TEST_PASSED:-unknown}" \
+                "commits=$TOTAL_COMMITS" \
+                "status=${STATUS:-running}"
+        fi
+
         # Update heartbeat
         "$SCRIPT_DIR/sw-heartbeat.sh" write "${PIPELINE_JOB_ID:-loop-$$}" \
             --pid $$ \
@@ -2396,7 +3187,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 +3237,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 +3248,7 @@ run_loop_with_restarts() {
         ITERATION=0
         CONSECUTIVE_FAILURES=0
         EXTENSION_COUNT=0
+        STUCKNESS_COUNT=0
         STATUS="running"
         LOG_ENTRIES=""
         TEST_PASSED=""
@@ -2469,7 +3270,7 @@ run_loop_with_restarts() {
 
         write_state
 
-        sleep 2
+        sleep "$(_config_get_int "loop.sleep_between_iterations" 2 2>/dev/null || echo 2)"
     done
 }