shipwright-cli 2.4.0 → 3.0.0

package/scripts/lib/daemon-poll.sh

@@ -53,7 +53,7 @@ daemon_poll_issues() {
             --owner "$ORG" \
             --state open \
             --json repository,number,title,labels,body,createdAt \
-            --limit 20 2>/dev/null) || {
+            --limit "${ISSUE_LIMIT:-100}" 2>/dev/null) || {
             # Handle rate limiting with exponential backoff
             if [[ $BACKOFF_SECS -eq 0 ]]; then
                 BACKOFF_SECS=30
@@ -80,7 +80,7 @@ daemon_poll_issues() {
             --label "$WATCH_LABEL" \
             --state open \
             --json number,title,labels,body,createdAt \
-            --limit 20 2>/dev/null) || {
+            --limit 100 2>/dev/null) || {
             # Handle rate limiting with exponential backoff
             if [[ $BACKOFF_SECS -eq 0 ]]; then
                 BACKOFF_SECS=30
@@ -212,18 +212,22 @@ daemon_poll_issues() {
     while IFS='|' read -r score issue_num repo_name; do
         [[ -z "$issue_num" ]] && continue
 
+        local issue_key
+        issue_key="$issue_num"
+        [[ -n "$repo_name" ]] && issue_key="${repo_name}:${issue_num}"
+
         local issue_title labels_csv
-        issue_title=$(echo "$issues_json" | jq -r --argjson n "$issue_num" '.[] | select(.number == $n) | .title')
-        labels_csv=$(echo "$issues_json" | jq -r --argjson n "$issue_num" '.[] | select(.number == $n) | [.labels[].name] | join(",")')
+        issue_title=$(echo "$issues_json" | jq -r --argjson n "$issue_num" --arg repo "$repo_name" '.[] | select(.number == $n) | select($repo == "" or (.repository.nameWithOwner // "") == $repo) | .title')
+        labels_csv=$(echo "$issues_json" | jq -r --argjson n "$issue_num" --arg repo "$repo_name" '.[] | select(.number == $n) | select($repo == "" or (.repository.nameWithOwner // "") == $repo) | [.labels[].name] | join(",")')
 
-        # Cache title in state for dashboard visibility
+        # Cache title in state for dashboard visibility (use issue_key for org mode)
         if [[ -n "$issue_title" ]]; then
-            locked_state_update --arg num "$issue_num" --arg title "$issue_title" \
+            locked_state_update --arg num "$issue_key" --arg title "$issue_title" \
                 '.titles[$num] = $title'
         fi
 
         # Skip if already inflight
-        if daemon_is_inflight "$issue_num"; then
+        if daemon_is_inflight "$issue_key"; then
             continue
         fi
 
@@ -263,7 +267,7 @@ daemon_poll_issues() {
         # Check capacity
         active_count=$(locked_get_active_count)
         if [[ "$active_count" -ge "$MAX_PARALLEL" ]]; then
-            enqueue_issue "$issue_num"
+            enqueue_issue "$issue_key"
             continue
         fi
 
@@ -308,24 +312,26 @@ daemon_poll_issues() {
     local drain_active
     drain_active=$(locked_get_active_count)
     while [[ "$drain_active" -lt "$MAX_PARALLEL" ]]; do
-        local drain_issue
-        drain_issue=$(dequeue_next)
-        [[ -z "$drain_issue" ]] && break
+        local drain_issue_key
+        drain_issue_key=$(dequeue_next)
+        [[ -z "$drain_issue_key" ]] && break
+        local drain_issue_num="$drain_issue_key" drain_repo=""
+        [[ "$drain_issue_key" == *:* ]] && drain_repo="${drain_issue_key%%:*}" && drain_issue_num="${drain_issue_key##*:}"
         local drain_title
-        drain_title=$(jq -r --arg n "$drain_issue" '.titles[$n] // ""' "$STATE_FILE" 2>/dev/null || true)
+        drain_title=$(jq -r --arg n "$drain_issue_key" '.titles[$n] // ""' "$STATE_FILE" 2>/dev/null || true)
 
         local drain_labels drain_score drain_template
-        drain_labels=$(echo "$issues_json" | jq -r --argjson n "$drain_issue" \
-            '.[] | select(.number == $n) | [.labels[].name] | join(",")' 2>/dev/null || echo "")
-        drain_score=$(echo "$sorted_order" | grep "|${drain_issue}|" | cut -d'|' -f1 || echo "50")
+        drain_labels=$(echo "$issues_json" | jq -r --argjson n "$drain_issue_num" --arg repo "$drain_repo" \
+            '.[] | select(.number == $n) | select($repo == "" or (.repository.nameWithOwner // "") == $repo) | [.labels[].name] | join(",")' 2>/dev/null || echo "")
+        drain_score=$(echo "$sorted_order" | grep "|${drain_issue_num}|" | cut -d'|' -f1 || echo "50")
         drain_template=$(select_pipeline_template "$drain_labels" "${drain_score:-50}" 2>/dev/null | tail -1)
         drain_template=$(printf '%s' "$drain_template" | sed $'s/\x1b\\[[0-9;]*m//g' | tr -cd '[:alnum:]-_')
         [[ -z "$drain_template" ]] && drain_template="$PIPELINE_TEMPLATE"
 
-        daemon_log INFO "Draining queue: issue #${drain_issue}, template=${drain_template}"
+        daemon_log INFO "Draining queue: issue #${drain_issue_num}${drain_repo:+, repo=${drain_repo}}, template=${drain_template}"
         local orig_template="$PIPELINE_TEMPLATE"
         PIPELINE_TEMPLATE="$drain_template"
-        daemon_spawn_pipeline "$drain_issue" "$drain_title"
+        daemon_spawn_pipeline "$drain_issue_num" "$drain_title" "$drain_repo"
         PIPELINE_TEMPLATE="$orig_template"
         drain_active=$(locked_get_active_count)
     done
@@ -692,7 +698,7 @@ daemon_auto_scale() {
 
     # ── Vitals-driven scaling factor ──
     local max_by_vitals="$MAX_WORKERS"
-    if type pipeline_compute_vitals &>/dev/null 2>&1 && [[ -f "$STATE_FILE" ]]; then
+    if type pipeline_compute_vitals >/dev/null 2>&1 && [[ -f "$STATE_FILE" ]]; then
         local _total_health=0 _health_count=0
         while IFS= read -r _job; do
             local _job_issue _job_worktree
@@ -813,7 +819,7 @@ daemon_self_optimize() {
     fi
 
     # ── Intelligence-powered optimization (if enabled) ──
-    if [[ "${OPTIMIZATION_ENABLED:-false}" == "true" ]] && type optimize_full_analysis &>/dev/null 2>&1; then
+    if [[ "${OPTIMIZATION_ENABLED:-false}" == "true" ]] && type optimize_full_analysis >/dev/null 2>&1; then
         daemon_log INFO "Running intelligence-powered optimization"
         optimize_full_analysis 2>/dev/null || {
             daemon_log WARN "Intelligence optimization failed — falling back to DORA-based tuning"
@@ -968,7 +974,7 @@ daemon_cleanup_stale() {
     now_e=$(now_epoch)
 
     # ── 1. Clean old git worktrees ──
-    if command -v git &>/dev/null; then
+    if command -v git >/dev/null 2>&1; then
         while IFS= read -r line; do
             local wt_path
             wt_path=$(echo "$line" | awk '{print $1}')
@@ -976,7 +982,7 @@ daemon_cleanup_stale() {
             [[ "$wt_path" == *"daemon-issue-"* ]] || continue
             # Check worktree age via directory mtime
             local mtime
-            mtime=$(stat -f '%m' "$wt_path" 2>/dev/null || stat -c '%Y' "$wt_path" 2>/dev/null || echo "0")
+            mtime=$(file_mtime "$wt_path")
             if [[ $((now_e - mtime)) -gt $age_secs ]]; then
                 daemon_log INFO "Removing stale worktree: ${wt_path}"
                 git worktree remove "$wt_path" --force 2>/dev/null || true
@@ -1003,7 +1009,7 @@ daemon_cleanup_stale() {
         while IFS= read -r artifact_dir; do
             [[ -d "$artifact_dir" ]] || continue
             local mtime
-            mtime=$(stat -f '%m' "$artifact_dir" 2>/dev/null || stat -c '%Y' "$artifact_dir" 2>/dev/null || echo "0")
+            mtime=$(file_mtime "$artifact_dir")
             if [[ $((now_e - mtime)) -gt $age_secs ]]; then
                 daemon_log INFO "Removing stale artifact: ${artifact_dir}"
                 rm -rf "$artifact_dir"
@@ -1013,7 +1019,7 @@ daemon_cleanup_stale() {
     fi
 
     # ── 3. Clean orphaned daemon/* branches (no matching worktree or active job) ──
-    if command -v git &>/dev/null; then
+    if command -v git >/dev/null 2>&1; then
         while IFS= read -r branch; do
             [[ -z "$branch" ]] && continue
             branch="${branch## }"  # trim leading spaces
@@ -1075,7 +1081,7 @@ daemon_cleanup_stale() {
         ps_status=$(sed -n 's/^status: *//p' "$pipeline_state" 2>/dev/null | head -1 | tr -d ' ')
         if [[ "$ps_status" == "running" ]]; then
             local ps_mtime
-            ps_mtime=$(stat -f '%m' "$pipeline_state" 2>/dev/null || stat -c '%Y' "$pipeline_state" 2>/dev/null || echo "0")
+            ps_mtime=$(file_mtime "$pipeline_state")
             local ps_age=$((now_e - ps_mtime))
             # If pipeline-state.md has been "running" for more than 2 hours and no active job
             if [[ "$ps_age" -gt 7200 ]]; then
@@ -1098,7 +1104,7 @@ daemon_cleanup_stale() {
     fi
 
     # ── 7. Clean remote branches for merged pipeline/* branches ──
-    if command -v git &>/dev/null && [[ "${NO_GITHUB:-}" != "true" ]]; then
+    if command -v git >/dev/null 2>&1 && [[ "${NO_GITHUB:-}" != "true" ]]; then
         while IFS= read -r branch; do
             [[ -z "$branch" ]] && continue
             branch="${branch## }"
@@ -1138,6 +1144,12 @@ daemon_poll_loop() {
         daemon_reap_completed || daemon_log WARN "daemon_reap_completed failed — continuing"
         daemon_health_check || daemon_log WARN "daemon_health_check failed — continuing"
 
+        # Fleet failover: re-queue work from offline machines
+        if [[ -f "$HOME/.shipwright/machines.json" ]]; then
+            [[ -f "$SCRIPT_DIR/lib/fleet-failover.sh" ]] && source "$SCRIPT_DIR/lib/fleet-failover.sh" 2>/dev/null || true
+            fleet_failover_check 2>/dev/null || true
+        fi
+
         # Increment cycle counter (must be before all modulo checks)
         POLL_CYCLE_COUNT=$((POLL_CYCLE_COUNT + 1))
 

package/scripts/lib/daemon-state.sh

@@ -3,6 +3,10 @@
 [[ -n "${_DAEMON_STATE_LOADED:-}" ]] && return 0
 _DAEMON_STATE_LOADED=1
 
+# SQLite persistence (DB as primary read path)
+_DAEMON_STATE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+[[ -f "${_DAEMON_STATE_DIR}/../sw-db.sh" ]] && source "${_DAEMON_STATE_DIR}/../sw-db.sh"
+
 daemon_log() {
     local level="$1"
     shift
@@ -58,8 +62,8 @@ notify() {
             -d "$payload" "$SLACK_WEBHOOK" >/dev/null 2>&1 || true
     fi
 
-    # Custom webhook (env var SHIPWRIGHT_WEBHOOK_URL, with CCT_WEBHOOK_URL fallback)
-    local _webhook_url="${SHIPWRIGHT_WEBHOOK_URL:-${CCT_WEBHOOK_URL:-}}"
+    # Custom webhook (env var SHIPWRIGHT_WEBHOOK_URL)
+    local _webhook_url="${SHIPWRIGHT_WEBHOOK_URL:-}"
     if [[ -n "$_webhook_url" ]]; then
         local payload
         payload=$(jq -n \
@@ -123,7 +127,7 @@ daemon_preflight_auth_check() {
 
     # gh auth check
     if [[ "${NO_GITHUB:-false}" != "true" ]]; then
-        if ! gh auth status &>/dev/null 2>&1; 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)" \
@@ -189,7 +193,7 @@ preflight_checks() {
     local optional_tools=("tmux" "curl")
 
     for tool in "${required_tools[@]}"; do
-        if command -v "$tool" &>/dev/null; then
+        if command -v "$tool" >/dev/null 2>&1; then
             echo -e "  ${GREEN}✓${RESET} $tool"
         else
             echo -e "  ${RED}✗${RESET} $tool ${RED}(required)${RESET}"
@@ -198,7 +202,7 @@ preflight_checks() {
     done
 
     for tool in "${optional_tools[@]}"; do
-        if command -v "$tool" &>/dev/null; then
+        if command -v "$tool" >/dev/null 2>&1; then
             echo -e "  ${GREEN}✓${RESET} $tool"
         else
             echo -e "  ${DIM}○${RESET} $tool ${DIM}(optional — some features disabled)${RESET}"
@@ -207,7 +211,7 @@ preflight_checks() {
 
     # 2. Git state
     echo ""
-    if git rev-parse --is-inside-work-tree &>/dev/null; then
+    if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
         echo -e "  ${GREEN}✓${RESET} Inside git repo"
     else
         echo -e "  ${RED}✗${RESET} Not inside a git repository"
@@ -215,7 +219,7 @@ preflight_checks() {
     fi
 
     # Check base branch exists
-    if git rev-parse --verify "$BASE_BRANCH" &>/dev/null; then
+    if git rev-parse --verify "$BASE_BRANCH" >/dev/null 2>&1; then
         echo -e "  ${GREEN}✓${RESET} Base branch: $BASE_BRANCH"
     else
         echo -e "  ${RED}✗${RESET} Base branch not found: $BASE_BRANCH"
@@ -224,7 +228,7 @@ preflight_checks() {
 
     # 3. GitHub auth (required for daemon — it needs to poll issues)
     if [[ "$NO_GITHUB" != "true" ]]; then
-        if gh auth status &>/dev/null 2>&1; then
+        if gh auth status >/dev/null 2>&1; then
             echo -e "  ${GREEN}✓${RESET} GitHub authenticated"
         else
             echo -e "  ${RED}✗${RESET} GitHub not authenticated (required for daemon)"
@@ -286,15 +290,48 @@ atomic_write_state() {
     }
 }
 
+# Sync active_jobs from state JSON to DB (dual-write, best-effort)
+_sync_state_to_db() {
+    local state_json="$1"
+    [[ -z "$state_json" ]] && return 0
+    if ! type db_save_job >/dev/null 2>&1 || ! db_available 2>/dev/null; then
+        return 0
+    fi
+    local start_epoch job_id
+    while IFS= read -r job; do
+        [[ -z "$job" || "$job" == "null" ]] && continue
+        local issue title pid worktree branch template goal started_at
+        issue=$(echo "$job" | jq -r '.issue // 0' 2>/dev/null)
+        title=$(echo "$job" | jq -r '.title // ""' 2>/dev/null)
+        pid=$(echo "$job" | jq -r '.pid // 0' 2>/dev/null)
+        worktree=$(echo "$job" | jq -r '.worktree // ""' 2>/dev/null)
+        branch=$(echo "$job" | jq -r '.branch // ""' 2>/dev/null)
+        template=$(echo "$job" | jq -r '.template // "autonomous"' 2>/dev/null)
+        goal=$(echo "$job" | jq -r '.goal // ""' 2>/dev/null)
+        started_at=$(echo "$job" | jq -r '.started_at // ""' 2>/dev/null)
+        if [[ -z "$issue" || "$issue" == "0" ]] || [[ ! "$issue" =~ ^[0-9]+$ ]]; then
+            continue
+        fi
+        start_epoch=0
+        if [[ -n "$started_at" ]]; then
+            start_epoch=$(TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%SZ" "$started_at" +%s 2>/dev/null || date -d "$started_at" +%s 2>/dev/null || echo "0")
+        fi
+        [[ -z "$start_epoch" ]] && start_epoch=0
+        job_id="daemon-${issue}-${start_epoch}"
+        db_save_job "$job_id" "$issue" "$title" "$pid" "$worktree" "$branch" "$template" "$goal" 2>/dev/null || true
+    done < <(echo "$state_json" | jq -c '.active_jobs[]? // empty' 2>/dev/null || true)
+}
+
 # Locked read-modify-write: prevents TOCTOU race on state file.
 # Usage: locked_state_update '.queued += [42]'
 # The jq expression is applied to the current state file atomically.
+# Dual-write: also syncs active_jobs to DB when available.
 locked_state_update() {
     local jq_expr="$1"
     shift
     local lock_file="${STATE_FILE}.lock"
     (
-        if command -v flock &>/dev/null; then
+        if command -v flock >/dev/null 2>&1; then
             flock -w 5 200 2>/dev/null || {
                 daemon_log ERROR "locked_state_update: lock acquisition timed out — aborting"
                 return 1
@@ -309,6 +346,7 @@ locked_state_update() {
             daemon_log ERROR "locked_state_update: atomic_write_state failed"
             return 1
         }
+        _sync_state_to_db "$tmp" 2>/dev/null || true
     ) 200>"$lock_file"
 }
 
@@ -343,7 +381,7 @@ init_state() {
             }')
         local lock_file="${STATE_FILE}.lock"
         (
-            if command -v flock &>/dev/null; then
+            if command -v flock >/dev/null 2>&1; then
                 flock -w 5 200 2>/dev/null || {
                     daemon_log ERROR "init_state: lock acquisition timed out"
                     return 1
@@ -358,6 +396,11 @@ init_state() {
             --arg started "$(now_iso)" \
             '.pid = ($pid | tonumber) | .started_at = $started'
     fi
+
+    # Ensure DB schema is initialized when available
+    if type migrate_schema >/dev/null 2>&1 && db_available 2>/dev/null; then
+        migrate_schema 2>/dev/null || true
+    fi
 }
 
 update_state_field() {
@@ -369,13 +412,15 @@ update_state_field() {
 # ─── Inflight Check ─────────────────────────────────────────────────────────
 
 daemon_is_inflight() {
-    local issue_num="$1"
+    local issue_key="$1"
+    local issue_num="$issue_key"
+    [[ "$issue_key" == *:* ]] && issue_num="${issue_key##*:}"
 
     if [[ ! -f "$STATE_FILE" ]]; then
         return 1
     fi
 
-    # Check active_jobs
+    # Check active_jobs (stored with numeric .issue)
     local active_match
     active_match=$(jq -r --argjson num "$issue_num" \
         '.active_jobs[] | select(.issue == $num) | .issue' \
@@ -384,10 +429,10 @@ daemon_is_inflight() {
         return 0
     fi
 
-    # Check queued
+    # Check queued (stores full key e.g. "owner/repo:42" or "42")
     local queued_match
-    queued_match=$(jq -r --argjson num "$issue_num" \
-        '.queued[] | select(. == $num)' \
+    queued_match=$(jq -r --arg key "$issue_key" \
+        '.queued[] | select(. == $key)' \
         "$STATE_FILE" 2>/dev/null || true)
     if [[ -n "$queued_match" ]]; then
         return 0
@@ -417,7 +462,7 @@ locked_get_active_count() {
     local count
     count=$(
         (
-            if command -v flock &>/dev/null; then
+            if command -v flock >/dev/null 2>&1; then
                 flock -w 5 200 2>/dev/null || {
                     daemon_log WARN "locked_get_active_count: lock timeout — returning MAX_PARALLEL as safe default" >&2
                     echo "$MAX_PARALLEL"
@@ -433,13 +478,30 @@ locked_get_active_count() {
 # ─── Queue Management ───────────────────────────────────────────────────────
 
 enqueue_issue() {
-    local issue_num="$1"
-    locked_state_update --argjson num "$issue_num" \
-        '.queued += [$num] | .queued |= unique'
-    daemon_log INFO "Queued issue #${issue_num} (at capacity)"
+    local issue_key="$1"
+    locked_state_update --arg key "$issue_key" \
+        '.queued += [$key] | .queued |= unique'
+    if type db_enqueue_issue >/dev/null 2>&1; then
+        db_enqueue_issue "$issue_key" 2>/dev/null || true
+    fi
+    daemon_log INFO "Queued issue ${issue_key} (at capacity)"
 }
 
 dequeue_next() {
+    # Try DB first when available
+    if type db_dequeue_next >/dev/null 2>&1 && db_available 2>/dev/null; then
+        local next
+        next=$(db_dequeue_next 2>/dev/null || true)
+        if [[ -n "$next" ]]; then
+            # Also update JSON file for backward compat
+            if [[ -f "$STATE_FILE" ]]; then
+                locked_state_update --arg key "$next" '.queued = [.queued[] | select(. != $key)]'
+            fi
+            echo "$next"
+            return
+        fi
+    fi
+
     if [[ ! -f "$STATE_FILE" ]]; then
         return
     fi
@@ -447,8 +509,10 @@ dequeue_next() {
     local next
     next=$(jq -r '.queued[0] // empty' "$STATE_FILE" 2>/dev/null || true)
     if [[ -n "$next" ]]; then
-        # Remove from queue (locked to prevent race with enqueue)
         locked_state_update '.queued = .queued[1:]'
+        if type db_remove_from_queue >/dev/null 2>&1; then
+            db_remove_from_queue "$next" 2>/dev/null || true
+        fi
         echo "$next"
     fi
 }
@@ -496,6 +560,22 @@ untrack_priority_job() {
 
 # ─── Distributed Issue Claiming ───────────────────────────────────────────
 
+# Verify we have exclusive claim: exactly one claimed:* label matching our machine
+_verify_claim_exclusive() {
+    local issue_num="$1" machine_name="$2"
+    local claimed_labels
+    claimed_labels=$(gh issue view "$issue_num" --json labels --jq \
+        '[.labels[].name | select(startswith("claimed:"))]' 2>/dev/null || echo "[]")
+    local count
+    count=$(echo "$claimed_labels" | jq 'length' 2>/dev/null || echo "0")
+    if [[ "$count" != "1" ]]; then
+        return 1  # Competing claims (multiple or none)
+    fi
+    local sole_claim
+    sole_claim=$(echo "$claimed_labels" | jq -r '.[0]' 2>/dev/null || echo "")
+    [[ "$sole_claim" == "claimed:${machine_name}" ]]
+}
+
 claim_issue() {
     local issue_num="$1"
     local machine_name="$2"
@@ -509,9 +589,15 @@ claim_issue() {
         -d "$(jq -n --argjson issue "$issue_num" --arg machine "$machine_name" \
             '{issue: $issue, machine: $machine}')" 2>/dev/null || echo "")
 
-    if [[ -n "$resp" ]] && echo "$resp" | jq -e '.approved == true' &>/dev/null; then
+    if [[ -n "$resp" ]] && echo "$resp" | jq -e '.approved == true' >/dev/null 2>&1; then
+        # VERIFY: re-read labels, ensure only our claim exists
+        if ! _verify_claim_exclusive "$issue_num" "$machine_name"; then
+            daemon_log INFO "Issue #${issue_num} claim race lost (competing claim) — removing our label"
+            gh issue edit "$issue_num" --remove-label "claimed:${machine_name}" 2>/dev/null || true
+            return 1
+        fi
         return 0
-    elif [[ -n "$resp" ]] && echo "$resp" | jq -e '.approved == false' &>/dev/null; then
+    elif [[ -n "$resp" ]] && echo "$resp" | jq -e '.approved == false' >/dev/null 2>&1; then
         local claimed_by
         claimed_by=$(echo "$resp" | jq -r '.claimed_by // "another machine"')
         daemon_log INFO "Issue #${issue_num} claimed by ${claimed_by} (via dashboard)"
@@ -530,6 +616,12 @@ claim_issue() {
     fi
 
     gh issue edit "$issue_num" --add-label "claimed:${machine_name}" 2>/dev/null || return 1
+    # VERIFY: re-read labels, ensure only our claim exists
+    if ! _verify_claim_exclusive "$issue_num" "$machine_name"; then
+        daemon_log INFO "Issue #${issue_num} claim race lost (competing claim) — removing our label"
+        gh issue edit "$issue_num" --remove-label "claimed:${machine_name}" 2>/dev/null || true
+        return 1
+    fi
     return 0
 }
 

package/scripts/lib/daemon-triage.sh

@@ -21,7 +21,7 @@ triage_score_issue() {
     issue_body=$(echo "$issue_json" | jq -r '.body // ""')
 
     # ── Intelligence-powered triage (if enabled) ──
-    if [[ "${INTELLIGENCE_ENABLED:-false}" == "true" ]] && type intelligence_analyze_issue &>/dev/null 2>&1; then
+    if [[ "${INTELLIGENCE_ENABLED:-false}" == "true" ]] && type intelligence_analyze_issue >/dev/null 2>&1; then
         daemon_log INFO "Intelligence: using AI triage (intelligence enabled)" >&2
         local analysis
         analysis=$(intelligence_analyze_issue "$issue_json" 2>/dev/null || echo "")
@@ -143,10 +143,14 @@ triage_score_issue() {
     # Check if this issue blocks others (search issue references)
     if [[ "$NO_GITHUB" != "true" ]]; then
         local mentions
-        mentions=$(gh api "repos/{owner}/{repo}/issues/${issue_num}/timeline" --paginate -q '
-            [.[] | select(.event == "cross-referenced") | .source.issue.body // ""] |
-            map(select(test("blocked by #'"${issue_num}"'|depends on #'"${issue_num}"'"; "i"))) | length
-        ' 2>/dev/null || echo "0")
+        local repo_nwo
+        repo_nwo=$(gh repo view --json nameWithOwner --jq '.nameWithOwner' 2>/dev/null || echo "")
+        if [[ -n "$repo_nwo" ]]; then
+            mentions=$(gh api "repos/${repo_nwo}/issues/${issue_num}/timeline" --paginate -q '
+                [.[] | select(.event == "cross-referenced") | .source.issue.body // ""] |
+                map(select(test("blocked by #'"${issue_num}"'|depends on #'"${issue_num}"'"; "i"))) | length
+            ' 2>/dev/null || echo "0")
+        fi
         mentions=${mentions:-0}
         if [[ "$mentions" -gt 0 ]]; then
             dep_score=15
@@ -212,7 +216,7 @@ select_pipeline_template() {
     fi
 
     # ── Intelligence-composed pipeline (if enabled) ──
-    if [[ "${COMPOSER_ENABLED:-false}" == "true" ]] && type composer_create_pipeline &>/dev/null 2>&1; then
+    if [[ "${COMPOSER_ENABLED:-false}" == "true" ]] && type composer_create_pipeline >/dev/null 2>&1; then
         daemon_log INFO "Intelligence: using AI pipeline composition (composer enabled)" >&2
         local analysis="${INTELLIGENCE_ANALYSIS:-{}}"
         local repo_context=""
@@ -301,8 +305,8 @@ select_pipeline_template() {
     fi
 
     # ── Branch protection escalation (highest priority) ──
-    if type gh_branch_protection &>/dev/null 2>&1 && [[ "${NO_GITHUB:-false}" != "true" ]]; then
-        if type _gh_detect_repo &>/dev/null 2>&1; then
+    if type gh_branch_protection >/dev/null 2>&1 && [[ "${NO_GITHUB:-false}" != "true" ]]; then
+        if type _gh_detect_repo >/dev/null 2>&1; then
             _gh_detect_repo 2>/dev/null || true
         fi
         local gh_owner="${GH_OWNER:-}" gh_repo="${GH_REPO:-}"
@@ -386,6 +390,24 @@ select_pipeline_template() {
         fi
     fi
 
+    # ── Thompson sampling (outcome-based learning, when DB available) ──
+    if type thompson_select_template >/dev/null 2>&1; then
+        local _complexity="medium"
+        [[ "$score" -ge 70 ]] && _complexity="low"
+        [[ "$score" -lt 40 ]] && _complexity="high"
+        local _thompson_result
+        _thompson_result=$(thompson_select_template "$_complexity" 2>/dev/null || echo "")
+        if [[ -n "${_thompson_result:-}" && "${_thompson_result:-}" != "standard" ]]; then
+            daemon_log INFO "Thompson sampling: $_thompson_result (complexity=$_complexity)" >&2
+            echo "$_thompson_result"
+            return
+        fi
+        if [[ -n "${_thompson_result:-}" ]]; then
+            echo "$_thompson_result"
+            return
+        fi
+    fi
+
     # ── Learned template weights ──
     local _tw_file="${HOME}/.shipwright/optimization/template-weights.json"
     if [[ -f "$_tw_file" ]]; then

package/scripts/lib/fleet-failover.sh

@@ -0,0 +1,63 @@
+# fleet-failover.sh — Re-queue work from offline fleet machines
+# When a machine goes offline, release its claimed issues so they can be picked up again.
+# Source from daemon-poll or sw-fleet. Works standalone with gh + jq.
+[[ -n "${_FLEET_FAILOVER_LOADED:-}" ]] && return 0
+_FLEET_FAILOVER_LOADED=1
+
+fleet_failover_check() {
+    local health_file="$HOME/.shipwright/machine-health.json"
+    [[ ! -f "$health_file" ]] && return 0
+
+    [[ "${NO_GITHUB:-false}" == "true" ]] && return 0
+    command -v gh >/dev/null 2>&1 || return 0
+    command -v jq >/dev/null 2>&1 || return 0
+
+    # Find offline machines (health file: .[machine_name] = {status, checked_at})
+    local offline_machines
+    offline_machines=$(jq -r 'to_entries[] | select(.value.status == "offline") | .key' "$health_file" 2>/dev/null)
+    [[ -z "$offline_machines" ]] && return 0
+
+    while IFS= read -r machine; do
+        [[ -z "$machine" ]] && continue
+
+        # Find issues claimed by this offline machine via GitHub label
+        local orphaned_issues
+        orphaned_issues=$(gh search issues \
+            "label:claimed:${machine}" \
+            is:open \
+            --json number,repository \
+            --limit 100 2>/dev/null | jq -r '.[] | "\(.repository.nameWithOwner):\(.number)"' 2>/dev/null)
+        [[ -z "$orphaned_issues" ]] && continue
+
+        while IFS= read -r issue_key; do
+            [[ -z "$issue_key" ]] && continue
+
+            local issue_num="${issue_key##*:}"
+            local repo="${issue_key%:*}"
+            [[ "$repo" == "$issue_key" ]] && repo=""
+
+            # Log and emit
+            if [[ "$(type -t info 2>/dev/null)" == "function" ]]; then
+                info "Failover: re-queuing issue #${issue_num} from offline machine ${machine}"
+            fi
+            if [[ "$(type -t emit_event 2>/dev/null)" == "function" ]]; then
+                emit_event "fleet.failover" "{\"issue\":\"$issue_num\",\"from_machine\":\"$machine\"}"
+            fi
+
+            # Release the claim (remove label) — idempotent
+            if [[ -n "$repo" ]]; then
+                gh issue edit "$issue_num" --repo "$repo" --remove-label "claimed:${machine}" 2>/dev/null || true
+            else
+                gh issue edit "$issue_num" --remove-label "claimed:${machine}" 2>/dev/null || true
+            fi
+
+            # When running in daemon context: enqueue so we pick it up if we watch this repo
+            # In org mode WATCH_MODE=org, enqueue uses owner/repo:num; in repo mode just num
+            if [[ -f "${STATE_FILE:-$HOME/.shipwright/daemon-state.json}" ]] && type enqueue_issue >/dev/null 2>&1; then
+                local queue_key="$issue_num"
+                [[ -n "$repo" ]] && queue_key="${repo}:${issue_num}"
+                enqueue_issue "$queue_key" 2>/dev/null || true
+            fi
+        done <<< "$orphaned_issues"
+    done <<< "$offline_machines"
+}