shipwright-cli 1.10.0 → 2.1.0

package/scripts/sw-daemon.sh

@@ -6,7 +6,10 @@
 set -euo pipefail
 trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="1.10.0"
+# Allow spawning Claude CLI from within a Claude Code session (daemon, fleet, etc.)
+unset CLAUDECODE 2>/dev/null || true
+
+VERSION="2.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -37,6 +40,10 @@ RESET='\033[0m'
 # shellcheck source=sw-pipeline-vitals.sh
 [[ -f "$SCRIPT_DIR/sw-pipeline-vitals.sh" ]] && source "$SCRIPT_DIR/sw-pipeline-vitals.sh"
 
+# ─── SQLite Persistence (optional) ──────────────────────────────────────────
+# shellcheck source=sw-db.sh
+[[ -f "$SCRIPT_DIR/sw-db.sh" ]] && source "$SCRIPT_DIR/sw-db.sh"
+
 # ─── GitHub API Modules (optional) ────────────────────────────────────────
 # shellcheck source=sw-github-graphql.sh
 [[ -f "$SCRIPT_DIR/sw-github-graphql.sh" ]] && source "$SCRIPT_DIR/sw-github-graphql.sh"
@@ -478,9 +485,11 @@ load_config() {
 
     # progress-based health monitoring (replaces static timeouts)
     PROGRESS_MONITORING=$(jq -r '.health.progress_based // true' "$config_file")
-    PROGRESS_CHECKS_BEFORE_WARN=$(jq -r '.health.stale_checks_before_warn // 3' "$config_file")
-    PROGRESS_CHECKS_BEFORE_KILL=$(jq -r '.health.stale_checks_before_kill // 6' "$config_file")
-    PROGRESS_HARD_LIMIT_S=$(jq -r '.health.hard_limit_s // 10800' "$config_file")  # 3hr absolute max
+    PROGRESS_CHECKS_BEFORE_WARN=$(jq -r '.health.stale_checks_before_warn // 20' "$config_file")
+    PROGRESS_CHECKS_BEFORE_KILL=$(jq -r '.health.stale_checks_before_kill // 120' "$config_file")
+    PROGRESS_HARD_LIMIT_S=$(jq -r '.health.hard_limit_s // 0' "$config_file")  # 0 = disabled (no hard kill)
+    NUDGE_ENABLED=$(jq -r '.health.nudge_enabled // true' "$config_file")
+    NUDGE_AFTER_CHECKS=$(jq -r '.health.nudge_after_checks // 40' "$config_file")
 
     # team dashboard URL (for coordinated claiming)
     local cfg_dashboard_url
@@ -502,11 +511,13 @@ load_config() {
 
 setup_dirs() {
     mkdir -p "$DAEMON_DIR"
+    mkdir -p "$HOME/.shipwright"
 
     STATE_FILE="$DAEMON_DIR/daemon-state.json"
     LOG_FILE="$DAEMON_DIR/daemon.log"
     LOG_DIR="$DAEMON_DIR/logs"
     WORKTREE_DIR=".worktrees"
+    PAUSE_FLAG="${HOME}/.shipwright/daemon-pause.flag"
 
     mkdir -p "$LOG_DIR"
     mkdir -p "$HOME/.shipwright/progress"
@@ -836,6 +847,31 @@ daemon_assess_progress() {
         has_progress=true
     fi
 
+    # Claude subprocess is alive and consuming CPU — agent is thinking/working
+    # During build stage, Claude can spend 10+ minutes thinking before any
+    # visible git changes appear.  Detect this as progress.
+    if [[ "$has_progress" != "true" ]]; then
+        local _pid_for_check
+        _pid_for_check=$(echo "$current_snapshot" | jq -r '.pid // empty' 2>/dev/null || true)
+        if [[ -z "$_pid_for_check" ]]; then
+            # Fallback: get PID from active_jobs
+            _pid_for_check=$(jq -r --argjson num "$issue_num" \
+                '.active_jobs[] | select(.issue == ($num | tonumber)) | .pid' "$STATE_FILE" 2>/dev/null | head -1 || true)
+        fi
+        if [[ -n "$_pid_for_check" ]]; then
+            # Check if any child process (claude) is alive and using CPU
+            local child_cpu=0
+            child_cpu=$(ps -o pid=,pcpu= -p "$_pid_for_check" 2>/dev/null | awk '{sum+=$2} END{printf "%d", sum+0}' || echo "0")
+            if [[ "$child_cpu" -eq 0 ]]; then
+                # Check children of the pipeline process
+                child_cpu=$(pgrep -P "$_pid_for_check" 2>/dev/null | xargs -I{} ps -o pcpu= -p {} 2>/dev/null | awk '{sum+=$1} END{printf "%d", sum+0}' || echo "0")
+            fi
+            if [[ "${child_cpu:-0}" -gt 0 ]]; then
+                has_progress=true
+            fi
+        fi
+    fi
+
     # Detect repeated errors (same error signature hitting again)
     local repeated_errors="$prev_repeated_errors"
     if [[ -n "$cur_error" && "$cur_error" == "$prev_error" ]]; then
@@ -1208,6 +1244,74 @@ gh_record_failure() {
     fi
 }
 
+# ─── Runtime Auth Check ──────────────────────────────────────────────────────
+
+LAST_AUTH_CHECK_EPOCH=0
+AUTH_CHECK_INTERVAL=300  # 5 minutes
+
+daemon_preflight_auth_check() {
+    local now_e
+    now_e=$(now_epoch)
+    if [[ $((now_e - LAST_AUTH_CHECK_EPOCH)) -lt "$AUTH_CHECK_INTERVAL" ]]; then
+        return 0
+    fi
+    LAST_AUTH_CHECK_EPOCH="$now_e"
+
+    # gh auth check
+    if [[ "${NO_GITHUB:-false}" != "true" ]]; then
+        if ! gh auth status &>/dev/null 2>&1; then
+            daemon_log ERROR "GitHub auth check failed — auto-pausing daemon"
+            local pause_json
+            pause_json=$(jq -n --arg reason "gh_auth_failure" --arg ts "$(now_iso)" \
+                '{reason: $reason, timestamp: $ts}')
+            local _tmp_pause
+            _tmp_pause=$(mktemp "${TMPDIR:-/tmp}/sw-pause.XXXXXX")
+            echo "$pause_json" > "$_tmp_pause"
+            mv "$_tmp_pause" "$PAUSE_FLAG"
+            emit_event "daemon.auto_pause" "reason=gh_auth_failure"
+            return 1
+        fi
+    fi
+
+    # claude auth check with 15s timeout (macOS has no timeout command)
+    local claude_auth_ok=false
+    local _auth_tmp
+    _auth_tmp=$(mktemp "${TMPDIR:-/tmp}/sw-auth.XXXXXX")
+    ( claude --print -p "ok" --max-turns 1 > "$_auth_tmp" 2>/dev/null ) &
+    local _auth_pid=$!
+    local _auth_waited=0
+    while kill -0 "$_auth_pid" 2>/dev/null && [[ "$_auth_waited" -lt 15 ]]; do
+        sleep 1
+        _auth_waited=$((_auth_waited + 1))
+    done
+    if kill -0 "$_auth_pid" 2>/dev/null; then
+        kill "$_auth_pid" 2>/dev/null || true
+        wait "$_auth_pid" 2>/dev/null || true
+    else
+        wait "$_auth_pid" 2>/dev/null || true
+    fi
+
+    if [[ -s "$_auth_tmp" ]]; then
+        claude_auth_ok=true
+    fi
+    rm -f "$_auth_tmp"
+
+    if [[ "$claude_auth_ok" != "true" ]]; then
+        daemon_log ERROR "Claude auth check failed — auto-pausing daemon"
+        local pause_json
+        pause_json=$(jq -n --arg reason "claude_auth_failure" --arg ts "$(now_iso)" \
+            '{reason: $reason, timestamp: $ts}')
+        local _tmp_pause
+        _tmp_pause=$(mktemp "${TMPDIR:-/tmp}/sw-pause.XXXXXX")
+        echo "$pause_json" > "$_tmp_pause"
+        mv "$_tmp_pause" "$PAUSE_FLAG"
+        emit_event "daemon.auto_pause" "reason=claude_auth_failure"
+        return 1
+    fi
+
+    return 0
+}
+
 # ─── Pre-flight Checks ──────────────────────────────────────────────────────
 
 preflight_checks() {
@@ -1369,6 +1473,7 @@ init_state() {
                 queued: [],
                 completed: [],
                 retry_counts: {},
+                failure_history: [],
                 priority_lane_active: [],
                 titles: {}
             }')
@@ -1609,9 +1714,24 @@ daemon_spawn_pipeline() {
     local issue_num="$1"
     local issue_title="${2:-}"
     local repo_full_name="${3:-}"  # owner/repo (org mode only)
+    shift 3 2>/dev/null || true
+    local extra_pipeline_args=("$@")  # Optional extra args passed to sw-pipeline.sh
 
     daemon_log INFO "Spawning pipeline for issue #${issue_num}: ${issue_title}"
 
+    # ── Issue decomposition (if decomposer available) ──
+    local decompose_script="${SCRIPT_DIR}/sw-decompose.sh"
+    if [[ -x "$decompose_script" && "$NO_GITHUB" != "true" ]]; then
+        local decompose_result=""
+        decompose_result=$("$decompose_script" auto "$issue_num" 2>/dev/null) || true
+        if [[ "$decompose_result" == *"decomposed"* ]]; then
+            daemon_log INFO "Issue #${issue_num} decomposed into subtasks — skipping pipeline"
+            # Remove the shipwright label so decomposed parent doesn't re-queue
+            gh issue edit "$issue_num" --remove-label "shipwright" 2>/dev/null || true
+            return 0
+        fi
+    fi
+
     # Extract goal text from issue (title + first line of body)
     local issue_goal="$issue_title"
     if [[ "$NO_GITHUB" != "true" ]]; then
@@ -1727,11 +1847,18 @@ daemon_spawn_pipeline() {
         pipeline_args+=("--fast-test-cmd" "$FAST_TEST_CMD_CFG")
     fi
 
+    # Append any extra pipeline args (from retry escalation, etc.)
+    if [[ ${#extra_pipeline_args[@]} -gt 0 ]]; then
+        pipeline_args+=("${extra_pipeline_args[@]}")
+    fi
+
     # Run pipeline in work directory (background)
+    # Ignore SIGHUP so tmux attach/detach and process group changes don't kill the pipeline
     echo -e "\n\n===== Pipeline run $(date -u +%Y-%m-%dT%H:%M:%SZ) =====" >> "$LOG_DIR/issue-${issue_num}.log" 2>/dev/null || true
     (
+        trap '' HUP
         cd "$work_dir"
-        "$SCRIPT_DIR/sw-pipeline.sh" "${pipeline_args[@]}"
+        exec "$SCRIPT_DIR/sw-pipeline.sh" "${pipeline_args[@]}"
     ) >> "$LOG_DIR/issue-${issue_num}.log" 2>&1 200>&- &
     local pid=$!
 
@@ -1767,6 +1894,14 @@ _Progress updates will appear below as the pipeline advances through each stage.
 
 daemon_track_job() {
     local issue_num="$1" pid="$2" worktree="$3" title="${4:-}" repo="${5:-}" goal="${6:-}"
+
+    # Write to SQLite (non-blocking, best-effort)
+    if type db_save_job &>/dev/null; then
+        local job_id="daemon-${issue_num}-$(now_epoch)"
+        db_save_job "$job_id" "$issue_num" "$title" "$pid" "$worktree" "" "${PIPELINE_TEMPLATE:-autonomous}" "$goal" 2>/dev/null || true
+    fi
+
+    # Always write to JSON state file (primary for now)
     locked_state_update \
         --argjson num "$issue_num" \
         --argjson pid "$pid" \
@@ -1855,6 +1990,16 @@ daemon_reap_completed() {
         [[ "$start_epoch" -gt 0 ]] && dur_s=$((end_epoch - start_epoch))
         emit_event "daemon.reap" "issue=$issue_num" "result=$result_str" "duration_s=$dur_s"
 
+        # Update SQLite (mark job complete/failed)
+        if type db_complete_job &>/dev/null && type db_fail_job &>/dev/null; then
+            local _db_job_id="daemon-${issue_num}-${start_epoch}"
+            if [[ "$exit_code" -eq 0 ]]; then
+                db_complete_job "$_db_job_id" "$result_str" 2>/dev/null || true
+            else
+                db_fail_job "$_db_job_id" "$result_str" 2>/dev/null || true
+            fi
+        fi
+
         if [[ "$exit_code" -eq 0 ]]; then
             daemon_on_success "$issue_num" "$duration_str"
         else
@@ -1904,15 +2049,18 @@ daemon_reap_completed() {
         reap_machine_name=$(jq -r '.machines[] | select(.role == "primary") | .name' "$HOME/.shipwright/machines.json" 2>/dev/null || hostname -s)
         release_claim "$issue_num" "$reap_machine_name"
 
-        # Skip cleanup if a retry was just spawned for this issue
+        # Always remove the OLD job entry from active_jobs to prevent
+        # re-reaping of the dead PID on the next cycle.  When a retry was
+        # spawned, daemon_spawn_pipeline already added a fresh entry with
+        # the new PID — we must not leave the stale one behind.
+        locked_state_update --argjson num "$issue_num" \
+            --argjson old_pid "${pid:-0}" \
+            '.active_jobs = [.active_jobs[] | select(.issue != $num or .pid != $old_pid)]'
+        untrack_priority_job "$issue_num"
+
         if [[ "$_retry_spawned_for" == "$issue_num" ]]; then
             daemon_log INFO "Retry spawned for issue #${issue_num} — skipping worktree cleanup"
         else
-            # Remove from active_jobs and priority lane tracking (locked)
-            locked_state_update --argjson num "$issue_num" \
-                '.active_jobs = [.active_jobs[] | select(.issue != $num)]'
-            untrack_priority_job "$issue_num"
-
             # Clean up worktree (skip for org-mode clones — they persist)
             local job_repo
             job_repo=$(echo "$job" | jq -r '.repo // ""')
@@ -1951,6 +2099,9 @@ daemon_reap_completed() {
 daemon_on_success() {
     local issue_num="$1" duration="${2:-}"
 
+    # Reset consecutive failure tracking on any success
+    reset_failure_tracking
+
     daemon_log SUCCESS "Pipeline completed for issue #${issue_num} (${duration:-unknown})"
 
     # Record pipeline duration for adaptive threshold learning
@@ -2009,6 +2160,149 @@ Check the associated PR for the implementation." 2>/dev/null || true
     notify "Pipeline Complete — Issue #${issue_num}" \
         "Duration: ${duration:-unknown}" "success"
     "$SCRIPT_DIR/sw-tracker.sh" notify "completed" "$issue_num" 2>/dev/null || true
+
+    # PM agent: record success for learning
+    if [[ -x "$SCRIPT_DIR/sw-pm.sh" ]]; then
+        bash "$SCRIPT_DIR/sw-pm.sh" learn "$issue_num" success 2>/dev/null || true
+    fi
+}
+
+# ─── Failure Classification ─────────────────────────────────────────────────
+
+classify_failure() {
+    local issue_num="$1"
+    if [[ -z "${LOG_DIR:-}" ]]; then
+        echo "unknown"
+        return
+    fi
+    local log_path="$LOG_DIR/issue-${issue_num}.log"
+    if [[ ! -f "$log_path" ]]; then
+        echo "unknown"
+        return
+    fi
+    local tail_content
+    tail_content=$(tail -200 "$log_path" 2>/dev/null || true)
+
+    # Auth errors
+    if echo "$tail_content" | grep -qiE 'not logged in|unauthorized|auth.*fail|401 |invalid.*token|CLAUDE_CODE_OAUTH_TOKEN|api key.*invalid|authentication required'; then
+        echo "auth_error"
+        return
+    fi
+    # API errors (rate limits, timeouts, server errors)
+    if echo "$tail_content" | grep -qiE 'rate limit|429 |503 |502 |overloaded|timeout|ETIMEDOUT|ECONNRESET|socket hang up|service unavailable'; then
+        echo "api_error"
+        return
+    fi
+    # Invalid issue (not found, empty body)
+    if echo "$tail_content" | grep -qiE 'issue not found|404 |no body|could not resolve|GraphQL.*not found|issue.*does not exist'; then
+        echo "invalid_issue"
+        return
+    fi
+    # Context exhaustion — check progress file
+    local issue_worktree_path="${WORKTREE_DIR:-${REPO_DIR}/.worktrees}/daemon-issue-${issue_num}"
+    local progress_file="${issue_worktree_path}/.claude/loop-logs/progress.md"
+    if [[ -f "$progress_file" ]]; then
+        local cf_iter
+        cf_iter=$(grep -oE 'Iteration: [0-9]+' "$progress_file" 2>/dev/null | tail -1 | grep -oE '[0-9]+' || echo "0")
+        if ! [[ "${cf_iter:-0}" =~ ^[0-9]+$ ]]; then cf_iter="0"; fi
+        local cf_tests
+        cf_tests=$(grep -oE 'Tests passing: (true|false)' "$progress_file" 2>/dev/null | awk '{print $NF}' || echo "unknown")
+        if [[ "${cf_iter:-0}" -gt 0 ]] && { [[ "$cf_tests" == "false" ]] || [[ "$cf_tests" == "unknown" ]]; }; then
+            echo "context_exhaustion"
+            return
+        fi
+    fi
+    # Build failure (test errors, compile errors)
+    if echo "$tail_content" | grep -qiE 'test.*fail|FAIL|build.*error|compile.*error|lint.*fail|npm ERR|exit code [1-9]'; then
+        echo "build_failure"
+        return
+    fi
+    echo "unknown"
+}
+
+# ─── Consecutive Failure Tracking (persisted + adaptive) ─────────────────────
+
+DAEMON_CONSECUTIVE_FAILURE_CLASS=""
+DAEMON_CONSECUTIVE_FAILURE_COUNT=0
+
+# Max retries per failure class (adaptive retry strategy)
+get_max_retries_for_class() {
+    local class="${1:-unknown}"
+    case "$class" in
+        auth_error|invalid_issue) echo 0 ;;
+        api_error)                echo "${MAX_RETRIES_API_ERROR:-4}" ;;
+        context_exhaustion)       echo "${MAX_RETRIES_CONTEXT_EXHAUSTION:-2}" ;;
+        build_failure)           echo "${MAX_RETRIES_BUILD:-2}" ;;
+        *)                       echo "${MAX_RETRIES:-2}" ;;
+    esac
+}
+
+# Append failure to persisted history and compute consecutive count; smart pause with exponential backoff
+record_failure_class() {
+    local failure_class="$1"
+    # In-memory consecutive (for backward compat)
+    if [[ "$failure_class" == "$DAEMON_CONSECUTIVE_FAILURE_CLASS" ]]; then
+        DAEMON_CONSECUTIVE_FAILURE_COUNT=$((DAEMON_CONSECUTIVE_FAILURE_COUNT + 1))
+    else
+        DAEMON_CONSECUTIVE_FAILURE_CLASS="$failure_class"
+        DAEMON_CONSECUTIVE_FAILURE_COUNT=1
+    fi
+
+    # Persist failure to state (failure_history) for pattern tracking
+    if [[ -f "${STATE_FILE:-}" ]]; then
+        local entry
+        entry=$(jq -n --arg ts "$(now_iso)" --arg class "$failure_class" '{ts: $ts, class: $class}')
+        locked_state_update --argjson entry "$entry" \
+            '.failure_history = ((.failure_history // []) + [$entry] | .[-100:])' 2>/dev/null || true
+    fi
+
+    # Consecutive count from persisted tail: count only the unbroken run of $failure_class
+    # from the newest entry backwards (not total occurrences)
+    local consecutive="$DAEMON_CONSECUTIVE_FAILURE_COUNT"
+    if [[ -f "${STATE_FILE:-}" ]]; then
+        local from_state
+        from_state=$(jq -r --arg c "$failure_class" '
+            (.failure_history // []) | [.[].class] | reverse |
+            if length == 0 then 0
+            elif .[0] != $c then 0
+            else
+                reduce .[] as $x (
+                    {count: 0, done: false};
+                    if .done then . elif $x == $c then .count += 1 else .done = true end
+                ) | .count
+            end
+        ' "$STATE_FILE" 2>/dev/null || echo "1")
+        consecutive="${from_state:-1}"
+        [[ "$consecutive" -eq 0 ]] && consecutive="$DAEMON_CONSECUTIVE_FAILURE_COUNT"
+        DAEMON_CONSECUTIVE_FAILURE_COUNT="$consecutive"
+    fi
+
+    # Smart pause: exponential backoff instead of hard stop (resume_after so daemon can auto-resume)
+    if [[ "$consecutive" -ge 3 ]]; then
+        local pause_mins=$((5 * (1 << (consecutive - 3))))
+        [[ "$pause_mins" -gt 480 ]] && pause_mins=480
+        local resume_ts resume_after
+        resume_ts=$(($(date +%s) + pause_mins * 60))
+        resume_after=$(epoch_to_iso "$resume_ts")
+        daemon_log ERROR "${consecutive} consecutive failures (class: ${failure_class}) — auto-pausing until ${resume_after} (${pause_mins}m backoff)"
+        local pause_json
+        pause_json=$(jq -n \
+            --arg reason "consecutive_${failure_class}" \
+            --arg ts "$(now_iso)" \
+            --arg resume "$resume_after" \
+            --argjson count "$consecutive" \
+            '{reason: $reason, timestamp: $ts, resume_after: $resume, consecutive_count: $count}')
+        local _tmp_pause
+        _tmp_pause=$(mktemp "${TMPDIR:-/tmp}/sw-pause.XXXXXX")
+        echo "$pause_json" > "$_tmp_pause"
+        mv "$_tmp_pause" "$PAUSE_FLAG"
+        emit_event "daemon.auto_pause" "reason=consecutive_failures" "class=$failure_class" "count=$consecutive" "resume_after=$resume_after"
+    fi
+}
+
+reset_failure_tracking() {
+    DAEMON_CONSECUTIVE_FAILURE_CLASS=""
+    DAEMON_CONSECUTIVE_FAILURE_COUNT=0
 }
 
 # ─── Failure Handler ────────────────────────────────────────────────────────
@@ -2047,126 +2341,152 @@ daemon_on_failure() {
             completed_at: $completed_at
         }] | .completed = .completed[-500:]'
 
+    # ── Classify failure and decide retry strategy ──
+    local failure_class
+    failure_class=$(classify_failure "$issue_num")
+    daemon_log INFO "Failure classified as: ${failure_class} for issue #${issue_num}"
+    emit_event "daemon.failure_classified" "issue=$issue_num" "class=$failure_class"
+    record_failure_class "$failure_class"
+
     # ── Auto-retry with strategy escalation ──
     if [[ "${RETRY_ESCALATION:-true}" == "true" ]]; then
         local retry_count
         retry_count=$(jq -r --arg num "$issue_num" \
             '.retry_counts[$num] // 0' "$STATE_FILE" 2>/dev/null || echo "0")
 
-        if [[ "$retry_count" -lt "${MAX_RETRIES:-2}" ]]; then
-            retry_count=$((retry_count + 1))
-
-            # Update retry count in state (locked to prevent race)
-            locked_state_update \
-                --arg num "$issue_num" --argjson count "$retry_count" \
-                '.retry_counts[$num] = $count'
-
-            daemon_log WARN "Auto-retry #${retry_count}/${MAX_RETRIES:-2} for issue #${issue_num}"
-            emit_event "daemon.retry" "issue=$issue_num" "retry=$retry_count" "max=${MAX_RETRIES:-2}"
-
-            # Check for checkpoint to enable resume-from-checkpoint
-            local checkpoint_args=()
-            if [[ "${CHECKPOINT_ENABLED:-true}" == "true" ]]; then
-                # Try to find worktree for this issue to check for checkpoints
-                local issue_worktree="${REPO_DIR}/.worktrees/daemon-issue-${issue_num}"
-                if [[ -d "$issue_worktree/.claude/pipeline-artifacts/checkpoints" ]]; then
-                    local latest_checkpoint=""
-                    for cp_file in "$issue_worktree/.claude/pipeline-artifacts/checkpoints"/*-checkpoint.json; do
-                        [[ -f "$cp_file" ]] && latest_checkpoint="$cp_file"
-                    done
-                    if [[ -n "$latest_checkpoint" ]]; then
-                        daemon_log INFO "Found checkpoint: $latest_checkpoint"
-                        emit_event "daemon.recovery" "issue=$issue_num" "checkpoint=$latest_checkpoint"
-                        checkpoint_args+=("--resume")
-                    fi
-                fi
-            fi
-
-            # Detect context exhaustion from progress file
-            local failure_reason="unknown"
-            local issue_worktree_path="${WORKTREE_DIR:-${REPO_DIR}/.worktrees}/daemon-issue-${issue_num}"
-            local progress_file="${issue_worktree_path}/.claude/loop-logs/progress.md"
-            if [[ -f "$progress_file" ]]; then
-                local progress_iter
-                progress_iter=$(grep -oE 'Iteration: [0-9]+' "$progress_file" 2>/dev/null | tail -1 | grep -oE '[0-9]+' || echo "0")
-                if ! [[ "${progress_iter:-0}" =~ ^[0-9]+$ ]]; then
-                    progress_iter="0"
+        # Non-retryable failures — skip retry entirely
+        case "$failure_class" in
+            auth_error)
+                daemon_log ERROR "Auth error for issue #${issue_num} — skipping retry"
+                emit_event "daemon.skip_retry" "issue=$issue_num" "reason=auth_error"
+                if [[ "$NO_GITHUB" != "true" ]]; then
+                    gh issue edit "$issue_num" --add-label "pipeline/auth-error" 2>/dev/null || true
                 fi
-                local progress_tests
-                progress_tests=$(grep -oE 'Tests passing: (true|false)' "$progress_file" 2>/dev/null | awk '{print $NF}' || echo "unknown")
-                if [[ "${progress_iter:-0}" -gt 0 ]] && { [[ "$progress_tests" == "false" ]] || [[ "$progress_tests" == "unknown" ]]; }; then
-                    failure_reason="context_exhaustion"
-                    emit_event "daemon.context_exhaustion" "issue=$issue_num" "iterations=$progress_iter"
-                    daemon_log WARN "Context exhaustion detected for issue #${issue_num} (iterations: ${progress_iter})"
+                ;;
+            invalid_issue)
+                daemon_log ERROR "Invalid issue #${issue_num} — skipping retry"
+                emit_event "daemon.skip_retry" "issue=$issue_num" "reason=invalid_issue"
+                if [[ "$NO_GITHUB" != "true" ]]; then
+                    gh issue comment "$issue_num" --body "Pipeline skipped retry: issue appears invalid or has no body." 2>/dev/null || true
                 fi
-            fi
+                ;;
+            *)
+                # Retryable failures — per-class max retries and escalation
+                local effective_max
+                effective_max=$(get_max_retries_for_class "$failure_class")
+                if [[ "$retry_count" -lt "$effective_max" ]]; then
+                    retry_count=$((retry_count + 1))
+
+                    # Update retry count in state (locked to prevent race)
+                    locked_state_update \
+                        --arg num "$issue_num" --argjson count "$retry_count" \
+                        '.retry_counts[$num] = $count'
+
+                    daemon_log WARN "Auto-retry #${retry_count}/${effective_max} for issue #${issue_num} (class: ${failure_class})"
+                    emit_event "daemon.retry" "issue=$issue_num" "retry=$retry_count" "max=$effective_max" "class=$failure_class"
+
+                    # Check for checkpoint to enable resume-from-checkpoint
+                    local checkpoint_args=()
+                    if [[ "${CHECKPOINT_ENABLED:-true}" == "true" ]]; then
+                        local issue_worktree="${REPO_DIR}/.worktrees/daemon-issue-${issue_num}"
+                        if [[ -d "$issue_worktree/.claude/pipeline-artifacts/checkpoints" ]]; then
+                            local latest_checkpoint=""
+                            for cp_file in "$issue_worktree/.claude/pipeline-artifacts/checkpoints"/*-checkpoint.json; do
+                                [[ -f "$cp_file" ]] && latest_checkpoint="$cp_file"
+                            done
+                            if [[ -n "$latest_checkpoint" ]]; then
+                                daemon_log INFO "Found checkpoint: $latest_checkpoint"
+                                emit_event "daemon.recovery" "issue=$issue_num" "checkpoint=$latest_checkpoint"
+                                checkpoint_args+=("--resume")
+                            fi
+                        fi
+                    fi
 
-            # Build escalated pipeline args
-            local retry_template="$PIPELINE_TEMPLATE"
-            local retry_model="${MODEL:-opus}"
-            local extra_args=()
-
-            if [[ "$retry_count" -eq 1 ]]; then
-                # Retry 1: same template, upgrade model, more iterations
-                retry_model="opus"
-                extra_args+=("--max-iterations" "30")
-                daemon_log INFO "Escalation: model=opus, max_iterations=30"
-            elif [[ "$retry_count" -ge 2 ]]; then
-                # Retry 2: full template, compound quality max cycles
-                retry_template="full"
-                retry_model="opus"
-                extra_args+=("--max-iterations" "30" "--compound-cycles" "5")
-                daemon_log INFO "Escalation: template=full, compound_cycles=5"
-            fi
+                    # Build escalated pipeline args
+                    local retry_template="$PIPELINE_TEMPLATE"
+                    local retry_model="${MODEL:-opus}"
+                    local extra_args=()
+
+                    if [[ "$retry_count" -eq 1 ]]; then
+                        retry_model="opus"
+                        extra_args+=("--max-iterations" "30")
+                        daemon_log INFO "Escalation: model=opus, max_iterations=30"
+                    elif [[ "$retry_count" -ge 2 ]]; then
+                        retry_template="full"
+                        retry_model="opus"
+                        extra_args+=("--max-iterations" "30" "--compound-cycles" "5")
+                        daemon_log INFO "Escalation: template=full, compound_cycles=5"
+                    fi
 
-            # Increase restarts on context exhaustion
-            if [[ "$failure_reason" == "context_exhaustion" ]]; then
-                local boosted_restarts=$(( ${MAX_RESTARTS_CFG:-3} + retry_count ))
-                # Cap at sw-loop's hard limit of 5
-                if [[ "$boosted_restarts" -gt 5 ]]; then
-                    boosted_restarts=5
-                fi
-                extra_args+=("--max-restarts" "$boosted_restarts")
-                daemon_log INFO "Boosting max-restarts to $boosted_restarts (context exhaustion)"
-            fi
+                    # Increase restarts on context exhaustion
+                    if [[ "$failure_class" == "context_exhaustion" ]]; then
+                        local boosted_restarts=$(( ${MAX_RESTARTS_CFG:-3} + retry_count ))
+                        if [[ "$boosted_restarts" -gt 5 ]]; then
+                            boosted_restarts=5
+                        fi
+                        extra_args+=("--max-restarts" "$boosted_restarts")
+                        daemon_log INFO "Boosting max-restarts to $boosted_restarts (context exhaustion)"
+                    fi
+
+                    # Exponential backoff (per-class base); cap at 1h
+                    local base_secs=30
+                    [[ "$failure_class" == "api_error" ]] && base_secs=300
+                    local backoff_secs=$((base_secs * (1 << (retry_count - 1))))
+                    [[ "$backoff_secs" -gt 3600 ]] && backoff_secs=3600
+                    [[ "$failure_class" == "api_error" ]] && daemon_log INFO "API error — exponential backoff ${backoff_secs}s"
 
-            if [[ "$NO_GITHUB" != "true" ]]; then
-                gh issue comment "$issue_num" --body "## 🔄 Auto-Retry #${retry_count}
+                    if [[ "$NO_GITHUB" != "true" ]]; then
+                        gh issue comment "$issue_num" --body "## 🔄 Auto-Retry #${retry_count}
 
-Pipeline failed — retrying with escalated strategy.
+Pipeline failed (${failure_class}) — retrying with escalated strategy.
 
 | Field | Value |
 |-------|-------|
 | Retry | ${retry_count} / ${MAX_RETRIES:-2} |
+| Failure | \`${failure_class}\` |
 | Template | \`${retry_template}\` |
 | Model | \`${retry_model}\` |
 | Started | $(now_iso) |
 
 _Escalation: $(if [[ "$retry_count" -eq 1 ]]; then echo "upgraded model + increased iterations"; else echo "full template + compound quality"; fi)_" 2>/dev/null || true
-            fi
+                    fi
 
-            # Backoff before retry: 30s * retry_count (30s, 60s, ...)
-            local backoff_secs=$((30 * retry_count))
-            daemon_log INFO "Waiting ${backoff_secs}s before retry #${retry_count}"
-            sleep "$backoff_secs"
-
-            # Re-spawn with escalated strategy
-            local orig_template="$PIPELINE_TEMPLATE"
-            local orig_model="$MODEL"
-            PIPELINE_TEMPLATE="$retry_template"
-            MODEL="$retry_model"
-            daemon_spawn_pipeline "$issue_num" "retry-${retry_count}"
-            _retry_spawned_for="$issue_num"
-            PIPELINE_TEMPLATE="$orig_template"
-            MODEL="$orig_model"
-            return
-        fi
+                    daemon_log INFO "Waiting ${backoff_secs}s before retry #${retry_count}"
+                    sleep "$backoff_secs"
 
-        daemon_log WARN "Max retries (${MAX_RETRIES:-2}) exhausted for issue #${issue_num}"
-        emit_event "daemon.retry_exhausted" "issue=$issue_num" "retries=$retry_count"
+                    # Merge checkpoint args + extra args for passthrough
+                    local all_extra_args=()
+                    if [[ ${#checkpoint_args[@]} -gt 0 ]]; then
+                        all_extra_args+=("${checkpoint_args[@]}")
+                    fi
+                    if [[ ${#extra_args[@]} -gt 0 ]]; then
+                        all_extra_args+=("${extra_args[@]}")
+                    fi
+
+                    # Re-spawn with escalated strategy
+                    local orig_template="$PIPELINE_TEMPLATE"
+                    local orig_model="$MODEL"
+                    PIPELINE_TEMPLATE="$retry_template"
+                    MODEL="$retry_model"
+                    daemon_spawn_pipeline "$issue_num" "retry-${retry_count}" "" "${all_extra_args[@]}"
+                    _retry_spawned_for="$issue_num"
+                    PIPELINE_TEMPLATE="$orig_template"
+                    MODEL="$orig_model"
+                    return
+                fi
+
+                daemon_log WARN "Max retries (${effective_max}) exhausted for issue #${issue_num}"
+                emit_event "daemon.retry_exhausted" "issue=$issue_num" "retries=$retry_count"
+                ;;
+        esac
     fi
 
     # ── No retry — report final failure ──
+    # PM agent: record failure for learning (only when we're done with this issue)
+    if [[ -x "$SCRIPT_DIR/sw-pm.sh" ]]; then
+        bash "$SCRIPT_DIR/sw-pm.sh" learn "$issue_num" failure 2>/dev/null || true
+    fi
+
     if [[ "$NO_GITHUB" != "true" ]]; then
         # Add failure label and remove watch label (prevent re-processing)
         gh issue edit "$issue_num" \
@@ -2191,10 +2511,11 @@ _Escalation: $(if [[ "$retry_count" -eq 1 ]]; then echo "upgraded model + increa
 
         local retry_info=""
         if [[ "${RETRY_ESCALATION:-true}" == "true" ]]; then
-            local final_count
+            local final_count final_max
             final_count=$(jq -r --arg num "$issue_num" \
                 '.retry_counts[$num] // 0' "$STATE_FILE" 2>/dev/null || echo "0")
-            retry_info="| Retries | ${final_count} / ${MAX_RETRIES:-2} (exhausted) |"
+            final_max=$(get_max_retries_for_class "$failure_class")
+            retry_info="| Retries | ${final_count} / ${final_max} (exhausted) |"
         fi
 
         gh issue comment "$issue_num" --body "## ❌ Pipeline Failed
@@ -3770,6 +4091,13 @@ Patrol pre-filter findings to confirm: ${patrol_findings_summary}"
         patrol_meta_run
     fi
 
+    # ── Strategic Intelligence Patrol (requires CLAUDE_CODE_OAUTH_TOKEN) ──
+    if [[ -f "$SCRIPT_DIR/sw-strategic.sh" ]] && [[ -n "${CLAUDE_CODE_OAUTH_TOKEN:-}" ]]; then
+        # shellcheck source=sw-strategic.sh
+        source "$SCRIPT_DIR/sw-strategic.sh"
+        strategic_patrol_run || true
+    fi
+
     # ── Summary ──
     emit_event "patrol.completed" "findings=$total_findings" "issues_created=$issues_created" "dry_run=$dry_run"
 
@@ -3795,10 +4123,27 @@ daemon_poll_issues() {
         return
     fi
 
-    # Check for pause flag (set by dashboard or disk_low alert)
-    if [[ -f "$HOME/.shipwright/daemon-pause.flag" ]]; then
-        daemon_log INFO "Daemon paused — skipping poll"
-        return
+    # Check for pause flag (set by dashboard, disk_low, or consecutive-failure backoff)
+    local pause_file="${PAUSE_FLAG:-$HOME/.shipwright/daemon-pause.flag}"
+    if [[ -f "$pause_file" ]]; then
+        local resume_after
+        resume_after=$(jq -r '.resume_after // empty' "$pause_file" 2>/dev/null || true)
+        if [[ -n "$resume_after" ]]; then
+            local now_epoch resume_epoch
+            now_epoch=$(date +%s)
+            resume_epoch=$(TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%SZ" "$resume_after" +%s 2>/dev/null || \
+                date -d "$resume_after" +%s 2>/dev/null || echo 0)
+            if [[ "$resume_epoch" -gt 0 ]] && [[ "$now_epoch" -ge "$resume_epoch" ]]; then
+                rm -f "$pause_file"
+                daemon_log INFO "Auto-resuming after backoff (resume_after passed)"
+            else
+                daemon_log INFO "Daemon paused until ${resume_after} — skipping poll"
+                return
+            fi
+        else
+            daemon_log INFO "Daemon paused — skipping poll"
+            return
+        fi
     fi
 
     # Circuit breaker: skip poll if in backoff window
@@ -4036,9 +4381,25 @@ daemon_poll_issues() {
             continue
         fi
 
-        # Auto-select pipeline template based on labels + triage score
+        # Auto-select pipeline template: PM recommendation (if available) else labels + triage score
         local template
-        template=$(select_pipeline_template "$labels_csv" "$score" 2>/dev/null | tail -1)
+        if [[ "$NO_GITHUB" != "true" ]] && [[ -x "$SCRIPT_DIR/sw-pm.sh" ]]; then
+            local pm_rec
+            pm_rec=$(bash "$SCRIPT_DIR/sw-pm.sh" recommend --json "$issue_num" 2>/dev/null) || true
+            if [[ -n "$pm_rec" ]]; then
+                template=$(echo "$pm_rec" | jq -r '.team_composition.template // empty' 2>/dev/null) || true
+                # Capability self-assessment: low confidence → upgrade to full template
+                local confidence
+                confidence=$(echo "$pm_rec" | jq -r '.team_composition.confidence_percent // 100' 2>/dev/null) || true
+                if [[ -n "$confidence" && "$confidence" != "null" && "$confidence" -lt 60 ]]; then
+                    daemon_log INFO "Low PM confidence (${confidence}%) — upgrading to full template"
+                    template="full"
+                fi
+            fi
+        fi
+        if [[ -z "$template" ]]; then
+            template=$(select_pipeline_template "$labels_csv" "$score" 2>/dev/null | tail -1)
+        fi
         template=$(printf '%s' "$template" | sed $'s/\x1b\\[[0-9;]*m//g' | tr -cd '[:alnum:]-_')
         [[ -z "$template" ]] && template="$PIPELINE_TEMPLATE"
         daemon_log INFO "Triage: issue #${issue_num} scored ${score}, template=${template}"
@@ -4095,13 +4456,15 @@ daemon_health_check() {
     now_e=$(now_epoch)
 
     if [[ -f "$STATE_FILE" ]]; then
-        # ── Progress-Based Health Monitoring ──
-        # Instead of killing after a static timeout, check for forward progress.
-        # Only kill when the agent is truly stuck (no stage change, no new code,
-        # same error repeating). A hard wall-clock limit remains as absolute safety net.
+        # ── Intelligent Health Monitoring ──
+        # Instead of killing after a countdown, sense what the agent is doing.
+        # Agents think for long stretches — that's normal and expected.
+        # Strategy: sense → understand → be patient → nudge → only kill as last resort.
 
-        local hard_limit="${PROGRESS_HARD_LIMIT_S:-10800}"
+        local hard_limit="${PROGRESS_HARD_LIMIT_S:-0}"
         local use_progress="${PROGRESS_MONITORING:-true}"
+        local nudge_enabled="${NUDGE_ENABLED:-true}"
+        local nudge_after="${NUDGE_AFTER_CHECKS:-40}"
 
         while IFS= read -r job; do
             local pid started_at issue_num worktree
@@ -4122,8 +4485,8 @@ daemon_health_check() {
                 elapsed=$(( now_e - start_e ))
             fi
 
-            # Hard wall-clock limit — absolute safety net (default 3h)
-            if [[ "$elapsed" -gt "$hard_limit" ]]; then
+            # Hard wall-clock limit — disabled by default (0 = off)
+            if [[ "$hard_limit" -gt 0 && "$elapsed" -gt "$hard_limit" ]]; then
                 daemon_log WARN "Hard limit exceeded: issue #${issue_num} (${elapsed}s > ${hard_limit}s, PID $pid) — killing"
                 emit_event "daemon.hard_limit" "issue=$issue_num" "elapsed_s=$elapsed" "limit_s=$hard_limit" "pid=$pid"
                 kill "$pid" 2>/dev/null || true
@@ -4132,7 +4495,7 @@ daemon_health_check() {
                 continue
             fi
 
-            # Progress-based detection (when enabled)
+            # ── Intelligent Progress Sensing ──
             if [[ "$use_progress" == "true" && -n "$worktree" ]]; then
                 local snapshot verdict
                 snapshot=$(daemon_collect_snapshot "$issue_num" "$worktree" "$pid" 2>/dev/null || echo '{}')
@@ -4140,29 +4503,87 @@ daemon_health_check() {
                 if [[ "$snapshot" != "{}" ]]; then
                     verdict=$(daemon_assess_progress "$issue_num" "$snapshot" 2>/dev/null || echo "healthy")
 
+                    local no_progress_count=0
+                    no_progress_count=$(jq -r '.no_progress_count // 0' "$PROGRESS_DIR/issue-${issue_num}.json" 2>/dev/null || echo 0)
+                    local cur_stage
+                    cur_stage=$(echo "$snapshot" | jq -r '.stage // "unknown"')
+
                     case "$verdict" in
                         healthy)
                             # All good — agent is making progress
                             ;;
                         slowing)
-                            daemon_log INFO "Issue #${issue_num} slowing (no progress for 1-2 checks, ${elapsed}s elapsed)"
+                            daemon_log INFO "Issue #${issue_num} slowing (no visible changes for ${no_progress_count} checks, ${elapsed}s elapsed, stage=${cur_stage})"
                             ;;
                         stalled)
-                            local no_progress_count
-                            no_progress_count=$(jq -r '.no_progress_count // 0' "$PROGRESS_DIR/issue-${issue_num}.json" 2>/dev/null || echo 0)
-                            daemon_log WARN "Issue #${issue_num} stalled: no progress for ${no_progress_count} checks (${elapsed}s elapsed, PID $pid)"
-                            emit_event "daemon.stalled" "issue=$issue_num" "no_progress=$no_progress_count" "elapsed_s=$elapsed" "pid=$pid"
+                            # Check if agent subprocess is alive and consuming CPU
+                            local agent_alive=false
+                            local child_cpu=0
+                            child_cpu=$(pgrep -P "$pid" 2>/dev/null | xargs -I{} ps -o pcpu= -p {} 2>/dev/null | awk '{sum+=$1} END{printf "%d", sum+0}' || echo "0")
+                            if [[ "${child_cpu:-0}" -gt 0 ]]; then
+                                agent_alive=true
+                            fi
+
+                            if [[ "$agent_alive" == "true" ]]; then
+                                daemon_log INFO "Issue #${issue_num} no visible progress (${no_progress_count} checks) but agent is alive (CPU: ${child_cpu}%, stage=${cur_stage}, ${elapsed}s) — being patient"
+                            else
+                                daemon_log WARN "Issue #${issue_num} stalled: no progress for ${no_progress_count} checks, no CPU activity (${elapsed}s elapsed, PID $pid)"
+                                emit_event "daemon.stalled" "issue=$issue_num" "no_progress=$no_progress_count" "elapsed_s=$elapsed" "pid=$pid"
+                            fi
                             ;;
                         stuck)
-                            local no_progress_count repeated_errors cur_stage
-                            no_progress_count=$(jq -r '.no_progress_count // 0' "$PROGRESS_DIR/issue-${issue_num}.json" 2>/dev/null || echo 0)
+                            local repeated_errors
                             repeated_errors=$(jq -r '.repeated_error_count // 0' "$PROGRESS_DIR/issue-${issue_num}.json" 2>/dev/null || echo 0)
-                            cur_stage=$(echo "$snapshot" | jq -r '.stage // "unknown"')
-                            daemon_log WARN "Issue #${issue_num} STUCK: no progress for ${no_progress_count} checks, ${repeated_errors} repeated errors (stage=${cur_stage}, ${elapsed}s, PID $pid) — killing"
-                            emit_event "daemon.stuck_kill" "issue=$issue_num" "no_progress=$no_progress_count" "repeated_errors=$repeated_errors" "stage=$cur_stage" "elapsed_s=$elapsed" "pid=$pid"
-                            kill "$pid" 2>/dev/null || true
-                            daemon_clear_progress "$issue_num"
-                            findings=$((findings + 1))
+
+                            # Even "stuck" — check if the process tree is alive first
+                            local agent_alive=false
+                            local child_cpu=0
+                            child_cpu=$(pgrep -P "$pid" 2>/dev/null | xargs -I{} ps -o pcpu= -p {} 2>/dev/null | awk '{sum+=$1} END{printf "%d", sum+0}' || echo "0")
+                            if [[ "${child_cpu:-0}" -gt 0 ]]; then
+                                agent_alive=true
+                            fi
+
+                            if [[ "$agent_alive" == "true" && "$repeated_errors" -lt 3 ]]; then
+                                # Agent is alive — nudge instead of kill
+                                if [[ "$nudge_enabled" == "true" && "$no_progress_count" -ge "$nudge_after" ]]; then
+                                    local nudge_file="${worktree}/.claude/nudge.md"
+                                    if [[ ! -f "$nudge_file" ]]; then
+                                        cat > "$nudge_file" <<NUDGE_EOF
+# Nudge from Daemon Health Monitor
+
+The daemon has noticed no visible progress for $(( no_progress_count * 30 / 60 )) minutes.
+Current stage: ${cur_stage}
+
+If you're stuck, consider:
+- Breaking the task into smaller steps
+- Committing partial progress
+- Running tests to validate current state
+
+This is just a gentle check-in — take your time if you're working through a complex problem.
+NUDGE_EOF
+                                        daemon_log INFO "Issue #${issue_num} nudged (${no_progress_count} checks, stage=${cur_stage}, CPU=${child_cpu}%) — file written to worktree"
+                                        emit_event "daemon.nudge" "issue=$issue_num" "no_progress=$no_progress_count" "stage=$cur_stage" "elapsed_s=$elapsed"
+                                    fi
+                                else
+                                    daemon_log INFO "Issue #${issue_num} no visible progress (${no_progress_count} checks) but agent is alive (CPU: ${child_cpu}%, stage=${cur_stage}) — waiting"
+                                fi
+                            elif [[ "$repeated_errors" -ge 5 ]]; then
+                                # Truly stuck in an error loop — kill as last resort
+                                daemon_log WARN "Issue #${issue_num} in error loop: ${repeated_errors} repeated errors (stage=${cur_stage}, ${elapsed}s, PID $pid) — killing"
+                                emit_event "daemon.stuck_kill" "issue=$issue_num" "no_progress=$no_progress_count" "repeated_errors=$repeated_errors" "stage=$cur_stage" "elapsed_s=$elapsed" "pid=$pid" "reason=error_loop"
+                                kill "$pid" 2>/dev/null || true
+                                daemon_clear_progress "$issue_num"
+                                findings=$((findings + 1))
+                            elif [[ "$agent_alive" != "true" && "$no_progress_count" -ge "$((PROGRESS_CHECKS_BEFORE_KILL * 2))" ]]; then
+                                # Process tree is dead AND no progress for very long time
+                                daemon_log WARN "Issue #${issue_num} appears dead: no CPU, no progress for ${no_progress_count} checks (${elapsed}s, PID $pid) — killing"
+                                emit_event "daemon.stuck_kill" "issue=$issue_num" "no_progress=$no_progress_count" "repeated_errors=$repeated_errors" "stage=$cur_stage" "elapsed_s=$elapsed" "pid=$pid" "reason=dead_process"
+                                kill "$pid" 2>/dev/null || true
+                                daemon_clear_progress "$issue_num"
+                                findings=$((findings + 1))
+                            else
+                                daemon_log WARN "Issue #${issue_num} struggling (${no_progress_count} checks, ${repeated_errors} errors, CPU=${child_cpu}%, stage=${cur_stage}) — monitoring"
+                            fi
                             ;;
                     esac
                 fi
@@ -4171,8 +4592,9 @@ daemon_health_check() {
                 local stale_timeout
                 stale_timeout=$(get_adaptive_stale_timeout "$PIPELINE_TEMPLATE")
                 if [[ "$elapsed" -gt "$stale_timeout" ]]; then
-                    daemon_log WARN "Stale job (legacy): issue #${issue_num} (${elapsed}s > ${stale_timeout}s, PID $pid) — killing"
-                    kill "$pid" 2>/dev/null || true
+                    daemon_log WARN "Stale job (legacy): issue #${issue_num} (${elapsed}s > ${stale_timeout}s, PID $pid)"
+                    # Don't kill — just log. Let the process run.
+                    emit_event "daemon.stale_warning" "issue=$issue_num" "elapsed_s=$elapsed" "pid=$pid"
                     findings=$((findings + 1))
                 fi
             fi
@@ -4765,6 +5187,7 @@ daemon_poll_loop() {
         # All poll loop calls are error-guarded to prevent set -e from killing the daemon.
         # The || operator disables set -e for the entire call chain, so transient failures
         # (GitHub API timeouts, jq errors, intelligence failures) are logged and skipped.
+        daemon_preflight_auth_check || daemon_log WARN "Auth check failed — daemon may be paused"
         daemon_poll_issues || daemon_log WARN "daemon_poll_issues failed — continuing"
         daemon_reap_completed || daemon_log WARN "daemon_reap_completed failed — continuing"
         daemon_health_check || daemon_log WARN "daemon_health_check failed — continuing"
@@ -4848,7 +5271,8 @@ cleanup_on_exit() {
             while IFS= read -r cpid; do
                 [[ -z "$cpid" ]] && continue
                 if kill -0 "$cpid" 2>/dev/null; then
-                    daemon_log INFO "Killing pipeline process PID ${cpid}"
+                    daemon_log INFO "Killing pipeline process tree PID ${cpid}"
+                    pkill -TERM -P "$cpid" 2>/dev/null || true
                     kill "$cpid" 2>/dev/null || true
                     killed=$((killed + 1))
                 fi
@@ -4860,7 +5284,8 @@ cleanup_on_exit() {
                 while IFS= read -r cpid; do
                     [[ -z "$cpid" ]] && continue
                     if kill -0 "$cpid" 2>/dev/null; then
-                        daemon_log WARN "Force-killing pipeline PID ${cpid}"
+                        daemon_log WARN "Force-killing pipeline tree PID ${cpid}"
+                        pkill -9 -P "$cpid" 2>/dev/null || true
                         kill -9 "$cpid" 2>/dev/null || true
                     fi
                 done <<< "$child_pids"
@@ -4951,6 +5376,11 @@ daemon_start() {
     # Remove stale shutdown flag
     rm -f "$SHUTDOWN_FLAG"
 
+    # Initialize SQLite database (if available)
+    if type init_schema &>/dev/null; then
+        init_schema 2>/dev/null || true
+    fi
+
     # Initialize state
     init_state