shipwright-cli 1.7.0 → 1.9.0

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

@@ -4,8 +4,9 @@
 # ║  Spawns daemons across repos · Fleet dashboard · Aggregate metrics     ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="1.7.0"
+VERSION="1.9.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 
@@ -20,6 +21,9 @@ DIM='\033[2m'
 BOLD='\033[1m'
 RESET='\033[0m'
 
+# ─── Cross-platform compatibility ──────────────────────────────────────────
+# shellcheck source=lib/compat.sh
+[[ -f "$SCRIPT_DIR/lib/compat.sh" ]] && source "$SCRIPT_DIR/lib/compat.sh"
 # ─── Output Helpers ─────────────────────────────────────────────────────────
 info()    { echo -e "${CYAN}${BOLD}▸${RESET} $*"; }
 success() { echo -e "${GREEN}${BOLD}✓${RESET} $*"; }
@@ -48,7 +52,7 @@ format_duration() {
 }
 
 # ─── Structured Event Log ──────────────────────────────────────────────────
-EVENTS_FILE="${HOME}/.claude-teams/events.jsonl"
+EVENTS_FILE="${HOME}/.shipwright/events.jsonl"
 
 emit_event() {
     local event_type="$1"
@@ -64,12 +68,12 @@ emit_event() {
             json_fields="${json_fields},\"${key}\":\"${val}\""
         fi
     done
-    mkdir -p "${HOME}/.claude-teams"
+    mkdir -p "${HOME}/.shipwright"
     echo "{\"ts\":\"$(now_iso)\",\"ts_epoch\":$(now_epoch),\"type\":\"${event_type}\"${json_fields}}" >> "$EVENTS_FILE"
 }
 
 # ─── Defaults ───────────────────────────────────────────────────────────────
-FLEET_DIR="$HOME/.claude-teams"
+FLEET_DIR="$HOME/.shipwright"
 FLEET_STATE="$FLEET_DIR/fleet-state.json"
 CONFIG_PATH=""
 
@@ -196,6 +200,52 @@ session_name_for_repo() {
     echo "shipwright-fleet-${basename}"
 }
 
+# ─── GitHub-Aware Repo Priority ──────────────────────────────────────────
+# Returns a priority score (default 50) for a repo based on GitHub data.
+# Used when intelligence.fleet_weighting is enabled.
+
+_fleet_repo_priority() {
+    local repo_path="$1"
+    local priority=50  # default neutral priority
+
+    type _gh_detect_repo &>/dev/null 2>&1 || { echo "$priority"; return 0; }
+
+    # Detect repo from the repo path (run in subshell to avoid cd side-effects)
+    local gh_priority
+    gh_priority=$(
+        cd "$repo_path" 2>/dev/null || exit 1
+        _gh_detect_repo 2>/dev/null || exit 1
+        local owner="${GH_OWNER:-}" repo="${GH_REPO:-}"
+        [[ -z "$owner" || -z "$repo" ]] && exit 1
+
+        local p=50
+
+        # Factor: security alerts (urgent work)
+        if type gh_security_alerts &>/dev/null 2>&1; then
+            local alerts
+            alerts=$(gh_security_alerts "$owner" "$repo" 2>/dev/null | jq 'length' 2>/dev/null || echo "0")
+            if [[ "${alerts:-0}" -gt 5 ]]; then
+                p=$((p + 20))
+            elif [[ "${alerts:-0}" -gt 0 ]]; then
+                p=$((p + 10))
+            fi
+        fi
+
+        # Factor: contributor count (more contributors = more active = higher priority)
+        if type gh_contributors &>/dev/null 2>&1; then
+            local contribs
+            contribs=$(gh_contributors "$owner" "$repo" 2>/dev/null | jq 'length' 2>/dev/null || echo "0")
+            if [[ "${contribs:-0}" -gt 10 ]]; then
+                p=$((p + 10))
+            fi
+        fi
+
+        echo "$p"
+    ) || echo "$priority"
+
+    echo "${gh_priority:-$priority}"
+}
+
 # ─── Worker Pool Rebalancer ───────────────────────────────────────────────
 # Runs in background, redistributes MAX_PARALLEL across repos based on demand
 
@@ -206,7 +256,7 @@ fleet_rebalance() {
     local total_workers
     total_workers=$(jq -r '.worker_pool.total_workers // 12' "$config_file")
 
-    local shutdown_flag="$HOME/.claude-teams/fleet-rebalancer.shutdown"
+    local shutdown_flag="$HOME/.shipwright/fleet-rebalancer.shutdown"
     rm -f "$shutdown_flag"
 
     while true; do
@@ -224,11 +274,22 @@ fleet_rebalance() {
         fi
 
         # Collect demand per repo using indexed arrays (bash 3.2 compatible)
+        # When intelligence is available, weight by complexity × urgency
         local repo_list=()
         local demand_list=()
+        local weight_list=()
         local total_demand=0
+        local total_weight=0
         local repo_count=0
 
+        # Check if intelligence weighting is enabled
+        local intel_weighting=false
+        local fleet_intel_enabled
+        fleet_intel_enabled=$(jq -r '.intelligence.fleet_weighting // false' "$config_file" 2>/dev/null || echo "false")
+        if [[ "$fleet_intel_enabled" == "true" ]]; then
+            intel_weighting=true
+        fi
+
         while IFS= read -r repo_name; do
             local repo_path
             repo_path=$(jq -r --arg r "$repo_name" '.repos[$r].path' "$FLEET_STATE" 2>/dev/null || true)
@@ -236,10 +297,10 @@ fleet_rebalance() {
 
             # Read daemon state — try repo-local state first
             local active=0 queued=0
-            local daemon_state="$repo_path/.claude-teams/daemon-state.json"
+            local daemon_state="$repo_path/.shipwright/daemon-state.json"
             if [[ ! -f "$daemon_state" ]]; then
                 # Fall back to shared state, filtered by repo
-                daemon_state="$HOME/.claude-teams/daemon-state.json"
+                daemon_state="$HOME/.shipwright/daemon-state.json"
             fi
             if [[ -f "$daemon_state" ]]; then
                 active=$(jq -r '.active_jobs | length // 0' "$daemon_state" 2>/dev/null || echo 0)
@@ -250,9 +311,59 @@ fleet_rebalance() {
             fi
 
             local demand=$((active + queued))
+
+            # Compute intelligence weight: complexity × urgency
+            # Falls back to raw demand when no intelligence data exists
+            local weight="$demand"
+            if [[ "$intel_weighting" == "true" && "$demand" -gt 0 ]]; then
+                local intel_cache="$repo_path/.claude/intelligence-cache.json"
+                local avg_complexity=50
+                local urgency_factor=1
+
+                # Read average issue complexity from intelligence cache
+                if [[ -f "$intel_cache" ]]; then
+                    local cached_complexity
+                    cached_complexity=$(jq -r '.analysis.avg_issue_complexity // 50' "$intel_cache" 2>/dev/null || echo "50")
+                    [[ "$cached_complexity" =~ ^[0-9]+$ ]] && avg_complexity="$cached_complexity"
+                fi
+
+                # Check for deadline urgency in queued issues
+                if [[ -f "$daemon_state" ]]; then
+                    local urgent_count=0
+                    local urgent_raw
+                    urgent_raw=$(jq -r '[.queued[]? | select(.labels[]? == "priority" or .labels[]? == "urgent" or .labels[]? == "hotfix")] | length' "$daemon_state" 2>/dev/null || echo "0")
+                    [[ "$urgent_raw" =~ ^[0-9]+$ ]] && urgent_count="$urgent_raw"
+
+                    if [[ "$queued" -gt 0 && "$urgent_count" -gt 0 ]]; then
+                        # Urgency boost: 1.0 base + 0.5 per urgent ratio
+                        urgency_factor=$(awk -v uc="$urgent_count" -v q="$queued" \
+                            'BEGIN { r = uc / q; f = 1.0 + (r * 0.5); printf "%.0f", f * 100 }')
+                        # urgency_factor is now scaled by 100 (e.g. 150 = 1.5x)
+                    else
+                        urgency_factor=100
+                    fi
+                else
+                    urgency_factor=100
+                fi
+
+                # GitHub priority factor (normalized: priority / 50, so 50 = 1.0x)
+                local gh_priority_factor=100  # 100 = 1.0x (neutral)
+                if [[ -n "$repo_path" && "$repo_path" != "null" ]]; then
+                    local gh_prio
+                    gh_prio=$(_fleet_repo_priority "$repo_path" 2>/dev/null || echo "50")
+                    [[ "$gh_prio" =~ ^[0-9]+$ ]] && gh_priority_factor=$((gh_prio * 2))
+                fi
+
+                # Weight = demand × (complexity / 50) × (urgency / 100) × (gh_priority / 100)
+                weight=$(awk -v d="$demand" -v c="$avg_complexity" -v u="$urgency_factor" -v g="$gh_priority_factor" \
+                    'BEGIN { w = d * (c / 50.0) * (u / 100.0) * (g / 100.0); if (w < 1) w = 1; printf "%.0f", w }')
+            fi
+
             repo_list+=("$repo_name")
             demand_list+=("$demand")
+            weight_list+=("$weight")
             total_demand=$((total_demand + demand))
+            total_weight=$((total_weight + weight))
             repo_count=$((repo_count + 1))
         done <<< "$repo_names"
 
@@ -261,17 +372,28 @@ fleet_rebalance() {
         fi
 
         # Distribute workers proportionally with budget enforcement
+        # When intelligence weighting is active, use weighted demand
         local allocated_total=0
         local alloc_list=()
+        local use_weight="$total_weight"
+        local effective_total="$total_demand"
+        if [[ "$intel_weighting" == "true" && "$total_weight" -gt 0 ]]; then
+            effective_total="$total_weight"
+        fi
 
         local i
         for i in $(seq 0 $((repo_count - 1))); do
             local new_max
-            if [[ "$total_demand" -eq 0 ]]; then
+            if [[ "$effective_total" -eq 0 ]]; then
                 new_max=$(( total_workers / repo_count ))
             else
-                local repo_demand="${demand_list[$i]}"
-                new_max=$(awk -v d="$repo_demand" -v td="$total_demand" -v tw="$total_workers" \
+                local repo_score
+                if [[ "$intel_weighting" == "true" && "$total_weight" -gt 0 ]]; then
+                    repo_score="${weight_list[$i]}"
+                else
+                    repo_score="${demand_list[$i]}"
+                fi
+                new_max=$(awk -v d="$repo_score" -v td="$effective_total" -v tw="$total_workers" \
                     'BEGIN { v = (d / td) * tw; if (v < 1) v = 1; printf "%.0f", v }')
             fi
             [[ "$new_max" -lt 1 ]] && new_max=1
@@ -317,16 +439,318 @@ fleet_rebalance() {
 
         # Signal daemons to reload
         if [[ "$reload_needed" == "true" ]]; then
-            touch "$HOME/.claude-teams/fleet-reload.flag"
+            touch "$HOME/.shipwright/fleet-reload.flag"
             emit_event "fleet.rebalance" \
                 "total_workers=$total_workers" \
                 "total_demand=$total_demand" \
+                "total_weight=$total_weight" \
+                "intel_weighting=$intel_weighting" \
                 "repo_count=$repo_count" \
                 "allocated=$allocated_total"
         fi
     done
 }
 
+# ─── Distributed Worker Rebalancer ───────────────────────────────────────
+# Extends fleet rebalancing across registered remote machines
+
+fleet_rebalance_distributed() {
+    local machines_file="$HOME/.shipwright/machines.json"
+    [[ ! -f "$machines_file" ]] && return 0
+
+    local machine_count
+    machine_count=$(jq '.machines | length' "$machines_file" 2>/dev/null || echo 0)
+    [[ "$machine_count" -eq 0 ]] && return 0
+
+    local ssh_opts="-o ConnectTimeout=5 -o BatchMode=yes -o StrictHostKeyChecking=accept-new"
+
+    # Collect demand and capacity from all machines
+    local machine_names=()
+    local machine_hosts=()
+    local machine_users=()
+    local machine_paths=()
+    local machine_max_workers=()
+    local machine_demands=()
+    local machine_actives=()
+    local total_demand=0
+    local total_capacity=0
+    local reachable_count=0
+
+    local i
+    for i in $(seq 0 $((machine_count - 1))); do
+        local name host ssh_user sw_path max_w
+        name=$(jq -r --argjson i "$i" '.machines[$i].name' "$machines_file")
+        host=$(jq -r --argjson i "$i" '.machines[$i].host' "$machines_file")
+        ssh_user=$(jq -r --argjson i "$i" '.machines[$i].ssh_user // ""' "$machines_file")
+        sw_path=$(jq -r --argjson i "$i" '.machines[$i].shipwright_path' "$machines_file")
+        max_w=$(jq -r --argjson i "$i" '.machines[$i].max_workers // 4' "$machines_file")
+
+        # Query machine for active/queued jobs
+        local query_cmd="active=0; queued=0; if [ -f \"\$HOME/.shipwright/daemon-state.json\" ]; then active=\$(python3 -c \"import json; d=json.load(open('\$HOME/.shipwright/daemon-state.json')); print(len(d.get('active_jobs',{})))\" 2>/dev/null || echo 0); queued=\$(python3 -c \"import json; d=json.load(open('\$HOME/.shipwright/daemon-state.json')); print(len(d.get('queued',[])))\" 2>/dev/null || echo 0); fi; echo \"\${active}|\${queued}\""
+
+        local result=""
+        if [[ "$host" == "localhost" || "$host" == "127.0.0.1" || "$host" == "::1" ]]; then
+            result=$(bash -c "$query_cmd" 2>/dev/null || echo "0|0")
+        else
+            local target="$host"
+            if [[ -n "$ssh_user" && "$ssh_user" != "null" ]]; then
+                target="${ssh_user}@${host}"
+            fi
+            # shellcheck disable=SC2086
+            result=$(ssh $ssh_opts "$target" "$query_cmd" 2>/dev/null || echo "")
+        fi
+
+        if [[ -z "$result" ]]; then
+            # Machine unreachable — skip
+            continue
+        fi
+
+        local active_val queued_val
+        active_val=$(echo "$result" | cut -d'|' -f1)
+        queued_val=$(echo "$result" | cut -d'|' -f2)
+        [[ ! "$active_val" =~ ^[0-9]+$ ]] && active_val=0
+        [[ ! "$queued_val" =~ ^[0-9]+$ ]] && queued_val=0
+
+        local demand=$((active_val + queued_val))
+
+        machine_names+=("$name")
+        machine_hosts+=("$host")
+        machine_users+=("$ssh_user")
+        machine_paths+=("$sw_path")
+        machine_max_workers+=("$max_w")
+        machine_demands+=("$demand")
+        machine_actives+=("$active_val")
+        total_demand=$((total_demand + demand))
+        total_capacity=$((total_capacity + max_w))
+        reachable_count=$((reachable_count + 1))
+    done
+
+    [[ "$reachable_count" -eq 0 ]] && return 0
+
+    # Proportional allocation: distribute total capacity by demand
+    local alloc_list=()
+    local allocated_total=0
+
+    for i in $(seq 0 $((reachable_count - 1))); do
+        local new_max
+        local cap="${machine_max_workers[$i]}"
+        if [[ "$total_demand" -eq 0 ]]; then
+            # No demand anywhere — give each machine its max
+            new_max="$cap"
+        else
+            local d="${machine_demands[$i]}"
+            new_max=$(awk -v d="$d" -v td="$total_demand" -v cap="$cap" \
+                'BEGIN { v = (d / td) * cap; if (v < 1) v = 1; if (v > cap) v = cap; printf "%.0f", v }')
+        fi
+        [[ "$new_max" -lt 1 ]] && new_max=1
+        [[ "$new_max" -gt "$cap" ]] && new_max="$cap"
+        alloc_list+=("$new_max")
+        allocated_total=$((allocated_total + new_max))
+    done
+
+    # Write allocation to each machine's daemon config
+    for i in $(seq 0 $((reachable_count - 1))); do
+        local name="${machine_names[$i]}"
+        local host="${machine_hosts[$i]}"
+        local ssh_user="${machine_users[$i]}"
+        local sw_path="${machine_paths[$i]}"
+        local new_max="${alloc_list[$i]}"
+
+        local update_cmd="if [ -f '${sw_path}/.claude/daemon-config.json' ]; then tmp=\"${sw_path}/.claude/daemon-config.json.tmp.\$\$\"; jq --argjson mp ${new_max} '.max_parallel = \$mp' '${sw_path}/.claude/daemon-config.json' > \"\$tmp\" && mv \"\$tmp\" '${sw_path}/.claude/daemon-config.json'; fi"
+
+        if [[ "$host" == "localhost" || "$host" == "127.0.0.1" || "$host" == "::1" ]]; then
+            bash -c "$update_cmd" 2>/dev/null || true
+        else
+            local target="$host"
+            if [[ -n "$ssh_user" && "$ssh_user" != "null" ]]; then
+                target="${ssh_user}@${host}"
+            fi
+            # shellcheck disable=SC2086
+            ssh $ssh_opts "$target" "$update_cmd" 2>/dev/null || true
+        fi
+    done
+
+    emit_event "fleet.distributed_rebalance" \
+        "machines=$reachable_count" \
+        "total_workers=$allocated_total" \
+        "total_demand=$total_demand"
+}
+
+# ─── Machine Health Monitor ─────────────────────────────────────────────
+# Checks machine heartbeats and marks unreachable machines
+
+check_machine_health() {
+    local machines_file="$HOME/.shipwright/machines.json"
+    [[ ! -f "$machines_file" ]] && return 0
+
+    local machine_count
+    machine_count=$(jq '.machines | length' "$machines_file" 2>/dev/null || echo 0)
+    [[ "$machine_count" -eq 0 ]] && return 0
+
+    local ssh_opts="-o ConnectTimeout=5 -o BatchMode=yes -o StrictHostKeyChecking=accept-new"
+    local health_file="$HOME/.shipwright/machine-health.json"
+    local now
+    now=$(date +%s)
+
+    # Initialize health file if needed
+    if [[ ! -f "$health_file" ]]; then
+        echo '{}' > "$health_file"
+    fi
+
+    local i
+    for i in $(seq 0 $((machine_count - 1))); do
+        local name host ssh_user
+        name=$(jq -r --argjson i "$i" '.machines[$i].name' "$machines_file")
+        host=$(jq -r --argjson i "$i" '.machines[$i].host' "$machines_file")
+        ssh_user=$(jq -r --argjson i "$i" '.machines[$i].ssh_user // ""' "$machines_file")
+
+        local status="online"
+        local hb_cmd="if [ -f \"\$HOME/.shipwright/machine-heartbeat.json\" ]; then cat \"\$HOME/.shipwright/machine-heartbeat.json\"; else echo '{\"ts_epoch\":0}'; fi"
+
+        local hb_result=""
+        if [[ "$host" == "localhost" || "$host" == "127.0.0.1" || "$host" == "::1" ]]; then
+            hb_result=$(bash -c "$hb_cmd" 2>/dev/null || echo '{"ts_epoch":0}')
+        else
+            local target="$host"
+            if [[ -n "$ssh_user" && "$ssh_user" != "null" ]]; then
+                target="${ssh_user}@${host}"
+            fi
+            # shellcheck disable=SC2086
+            hb_result=$(ssh $ssh_opts "$target" "$hb_cmd" 2>/dev/null || echo "")
+        fi
+
+        if [[ -z "$hb_result" ]]; then
+            status="offline"
+        else
+            local hb_epoch
+            hb_epoch=$(echo "$hb_result" | jq -r '.ts_epoch // 0' 2>/dev/null || echo 0)
+            [[ ! "$hb_epoch" =~ ^[0-9]+$ ]] && hb_epoch=0
+
+            local age=$((now - hb_epoch))
+            if [[ "$hb_epoch" -eq 0 ]]; then
+                # No heartbeat file yet — treat as degraded if not localhost
+                if [[ "$host" == "localhost" || "$host" == "127.0.0.1" || "$host" == "::1" ]]; then
+                    status="online"
+                else
+                    status="degraded"
+                fi
+            elif [[ "$age" -gt 120 ]]; then
+                status="offline"
+            elif [[ "$age" -gt 60 ]]; then
+                status="degraded"
+            fi
+        fi
+
+        # Update health file atomically
+        local tmp_health="${health_file}.tmp.$$"
+        jq --arg name "$name" --arg status "$status" --argjson ts "$now" \
+            '.[$name] = {status: $status, checked_at: $ts}' "$health_file" > "$tmp_health" \
+            && mv "$tmp_health" "$health_file"
+
+        if [[ "$status" == "offline" ]]; then
+            emit_event "fleet.machine_offline" "machine=$name" "host=$host"
+        fi
+    done
+}
+
+# ─── Cross-Machine Event Aggregation ───────────────────────────────────
+
+aggregate_remote_events() {
+    local machines_file="$HOME/.shipwright/machines.json"
+    [[ ! -f "$machines_file" ]] && return 0
+
+    local machine_count
+    machine_count=$(jq '.machines | length' "$machines_file" 2>/dev/null || echo 0)
+    [[ "$machine_count" -eq 0 ]] && return 0
+
+    local ssh_opts="-o ConnectTimeout=5 -o BatchMode=yes -o StrictHostKeyChecking=accept-new"
+    local offsets_file="$HOME/.shipwright/remote-offsets.json"
+
+    # Initialize offsets file if needed
+    if [[ ! -f "$offsets_file" ]]; then
+        echo '{}' > "$offsets_file"
+    fi
+
+    local i
+    for i in $(seq 0 $((machine_count - 1))); do
+        local name host ssh_user
+        name=$(jq -r --argjson i "$i" '.machines[$i].name' "$machines_file")
+        host=$(jq -r --argjson i "$i" '.machines[$i].host' "$machines_file")
+        ssh_user=$(jq -r --argjson i "$i" '.machines[$i].ssh_user // ""' "$machines_file")
+
+        # Skip localhost — we already have local events
+        if [[ "$host" == "localhost" || "$host" == "127.0.0.1" || "$host" == "::1" ]]; then
+            continue
+        fi
+
+        # Get last offset for this machine
+        local last_offset
+        last_offset=$(jq -r --arg n "$name" '.[$n] // 0' "$offsets_file" 2>/dev/null || echo 0)
+        [[ ! "$last_offset" =~ ^[0-9]+$ ]] && last_offset=0
+
+        local target="$host"
+        if [[ -n "$ssh_user" && "$ssh_user" != "null" ]]; then
+            target="${ssh_user}@${host}"
+        fi
+
+        # Fetch new events from remote (tail from offset)
+        local next_line=$((last_offset + 1))
+        local fetch_cmd="tail -n +${next_line} \"\$HOME/.shipwright/events.jsonl\" 2>/dev/null || true"
+        local new_events
+        # shellcheck disable=SC2086
+        new_events=$(ssh $ssh_opts "$target" "$fetch_cmd" 2>/dev/null || echo "")
+
+        if [[ -z "$new_events" ]]; then
+            continue
+        fi
+
+        # Count new lines
+        local new_lines
+        new_lines=$(echo "$new_events" | wc -l | tr -d ' ')
+
+        # Add machine= field to each event and append to local events
+        while IFS= read -r line; do
+            [[ -z "$line" ]] && continue
+            # Add machine field via jq
+            local enriched
+            enriched=$(echo "$line" | jq -c --arg m "$name" '. + {machine: $m}' 2>/dev/null || true)
+            if [[ -n "$enriched" ]]; then
+                echo "$enriched" >> "$EVENTS_FILE"
+            fi
+        done <<< "$new_events"
+
+        # Update offset
+        local new_offset=$((last_offset + new_lines))
+        local tmp_offsets="${offsets_file}.tmp.$$"
+        jq --arg n "$name" --argjson o "$new_offset" '.[$n] = $o' "$offsets_file" > "$tmp_offsets" \
+            && mv "$tmp_offsets" "$offsets_file"
+
+    done
+}
+
+# ─── Distributed Fleet Loop ────────────────────────────────────────────
+# Background loop that runs distributed rebalancing + health checks + event aggregation
+
+fleet_distributed_loop() {
+    local interval="${1:-30}"
+    local shutdown_flag="$HOME/.shipwright/fleet-distributed.shutdown"
+    rm -f "$shutdown_flag"
+
+    while true; do
+        sleep "$interval"
+
+        # Check for shutdown signal
+        if [[ -f "$shutdown_flag" ]]; then
+            break
+        fi
+
+        # Run distributed tasks
+        check_machine_health 2>/dev/null || true
+        fleet_rebalance_distributed 2>/dev/null || true
+        aggregate_remote_events 2>/dev/null || true
+    done
+}
+
 # ─── Fleet Start ────────────────────────────────────────────────────────────
 
 fleet_start() {
@@ -435,7 +859,7 @@ fleet_start() {
 
         # Spawn daemon in detached tmux session
         tmux new-session -d -s "$session_name" \
-            "cd '$repo_path' && '$SCRIPT_DIR/cct-daemon.sh' start $daemon_config_flag"
+            "cd '$repo_path' && '$SCRIPT_DIR/sw-daemon.sh' start $daemon_config_flag"
 
         # Record in fleet state
         local tmp2="${fleet_state_tmp}.2"
@@ -468,13 +892,35 @@ fleet_start() {
         pool_total=$(jq -r '.worker_pool.total_workers // 12' "$config_file")
         fleet_rebalance "$config_file" &
         local rebalancer_pid=$!
+        sleep 1
+        if ! kill -0 "$rebalancer_pid" 2>/dev/null; then
+            fleet_log ERROR "Rebalancer process exited immediately (PID: $rebalancer_pid)"
+        else
+            # Record rebalancer PID in fleet state
+            local tmp_rs="${FLEET_STATE}.tmp.$$"
+            jq --argjson pid "$rebalancer_pid" '.rebalancer_pid = $pid' "$FLEET_STATE" > "$tmp_rs" \
+                && mv "$tmp_rs" "$FLEET_STATE"
 
-        # Record rebalancer PID in fleet state
-        local tmp_rs="${FLEET_STATE}.tmp.$$"
-        jq --argjson pid "$rebalancer_pid" '.rebalancer_pid = $pid' "$FLEET_STATE" > "$tmp_rs" \
-            && mv "$tmp_rs" "$FLEET_STATE"
+            success "Worker pool: ${CYAN}${pool_total} total workers${RESET} (rebalancer PID: ${rebalancer_pid})"
+        fi
+    fi
 
-        success "Worker pool: ${CYAN}${pool_total} total workers${RESET} (rebalancer PID: ${rebalancer_pid})"
+    # Start distributed worker loop if machines are registered
+    local machines_file="$HOME/.shipwright/machines.json"
+    if [[ -f "$machines_file" ]]; then
+        local dist_machine_count
+        dist_machine_count=$(jq '.machines | length' "$machines_file" 2>/dev/null || echo 0)
+        if [[ "$dist_machine_count" -gt 0 ]]; then
+            fleet_distributed_loop 30 &
+            local dist_pid=$!
+
+            # Record distributed loop PID in fleet state
+            local tmp_dist="${FLEET_STATE}.tmp.$$"
+            jq --argjson pid "$dist_pid" '.distributed_loop_pid = $pid' "$FLEET_STATE" > "$tmp_dist" \
+                && mv "$tmp_dist" "$FLEET_STATE"
+
+            success "Distributed workers: ${CYAN}${dist_machine_count} machines${RESET} (loop PID: ${dist_pid})"
+        fi
     fi
 
     echo ""
@@ -512,7 +958,10 @@ fleet_stop() {
     fi
 
     # Signal rebalancer to stop
-    touch "$HOME/.claude-teams/fleet-rebalancer.shutdown"
+    touch "$HOME/.shipwright/fleet-rebalancer.shutdown"
+
+    # Signal distributed loop to stop
+    touch "$HOME/.shipwright/fleet-distributed.shutdown"
 
     # Kill rebalancer if running
     local rebalancer_pid
@@ -523,9 +972,19 @@ fleet_stop() {
         success "Stopped worker pool rebalancer (PID: ${rebalancer_pid})"
     fi
 
+    # Kill distributed loop if running
+    local dist_pid
+    dist_pid=$(jq -r '.distributed_loop_pid // empty' "$FLEET_STATE" 2>/dev/null || true)
+    if [[ -n "$dist_pid" ]]; then
+        kill "$dist_pid" 2>/dev/null || true
+        wait "$dist_pid" 2>/dev/null || true
+        success "Stopped distributed worker loop (PID: ${dist_pid})"
+    fi
+
     # Clean up flags
-    rm -f "$HOME/.claude-teams/fleet-reload.flag"
-    rm -f "$HOME/.claude-teams/fleet-rebalancer.shutdown"
+    rm -f "$HOME/.shipwright/fleet-reload.flag"
+    rm -f "$HOME/.shipwright/fleet-rebalancer.shutdown"
+    rm -f "$HOME/.shipwright/fleet-distributed.shutdown"
 
     local stopped=0
     while IFS= read -r repo_name; do
@@ -535,7 +994,7 @@ fleet_stop() {
         repo_path=$(jq -r --arg r "$repo_name" '.repos[$r].path' "$FLEET_STATE")
 
         # Try graceful shutdown via the daemon's shutdown flag
-        local daemon_dir="$HOME/.claude-teams"
+        local daemon_dir="$HOME/.shipwright"
         local shutdown_flag="$daemon_dir/daemon.shutdown"
 
         # Send shutdown signal to the daemon process inside the tmux session
@@ -606,6 +1065,23 @@ fleet_status() {
         echo ""
     fi
 
+    # Show distributed machine summary if available
+    local machines_file="$HOME/.shipwright/machines.json"
+    if [[ -f "$machines_file" ]]; then
+        local dist_count
+        dist_count=$(jq '.machines | length' "$machines_file" 2>/dev/null || echo 0)
+        if [[ "$dist_count" -gt 0 ]]; then
+            local health_file="$HOME/.shipwright/machine-health.json"
+            local m_online=0 m_offline=0
+            if [[ -f "$health_file" ]]; then
+                m_online=$(jq '[to_entries[] | select(.value.status == "online")] | length' "$health_file" 2>/dev/null || echo 0)
+                m_offline=$(jq '[to_entries[] | select(.value.status == "offline")] | length' "$health_file" 2>/dev/null || echo 0)
+            fi
+            echo -e "  ${BOLD}Machines:${RESET} ${dist_count} registered  ${GREEN}${m_online} online${RESET}  ${RED}${m_offline} offline${RESET}"
+            echo ""
+        fi
+    fi
+
     # Header
     printf "  ${BOLD}%-20s %-10s %-10s %-10s %-10s %-20s${RESET}\n" \
         "REPO" "STATUS" "ACTIVE" "QUEUED" "DONE" "LAST POLL"
@@ -628,7 +1104,7 @@ fleet_status() {
 
         # Try to read daemon state from the repo's daemon state file
         local active="-" queued="-" done="-" last_poll="-"
-        local daemon_state="$HOME/.claude-teams/daemon-state.json"
+        local daemon_state="$HOME/.shipwright/daemon-state.json"
         if [[ -f "$daemon_state" ]]; then
             active=$(jq -r '.active_jobs // 0' "$daemon_state" 2>/dev/null || echo "-")
             queued=$(jq -r '.queued // 0' "$daemon_state" 2>/dev/null || echo "-")