@zachjxyz/moxie 0.2.4 → 0.3.0

package/lib/phases.sh

@@ -52,13 +52,13 @@ _discover_context_docs() {
         echo "$rp"
     done < "$tmpfile" | sort -u > "$dedup_file"
 
-    # Sort by mtime (most recent first) — macOS stat
+    # Sort by mtime (most recent first)
     local sorted_file
     sorted_file=$(mktemp)
 
     while IFS= read -r rp; do
         local mtime
-        mtime=$(stat -f "%m" "$rp" 2>/dev/null || echo "0")
+        mtime=$(stat_mtime "$rp")
         echo "$mtime $rp"
     done < "$dedup_file" | sort -rn | head -10 | while IFS= read -r line; do
         echo "${line#* }"
@@ -97,7 +97,7 @@ _select_context_docs() {
         else
             sz="${sz} B"
         fi
-        mdate=$(stat -f "%Sm" -t "%b %d" "$f" 2>/dev/null || echo "unknown")
+        mdate=$(stat_date "$f")
         meta+=("${sz}, ${mdate}")
         local len=${#f}
         [ "$len" -gt "$max_label_len" ] && max_label_len=$len
@@ -209,6 +209,272 @@ _select_context_docs() {
     done
 }
 
+# ---- Agent selection TUI ----
+# Populates SELECTED_AGENT_INDICES (CLI) and SELECTED_GATEWAY_INDICES (gateway).
+# Shows CLI agents found on PATH + gateway models. Requires minimum 2 total.
+
+_select_agents() {
+    SELECTED_AGENT_INDICES=()
+    SELECTED_GATEWAY_INDICES=()
+
+    # Build unified item list: CLI agents, separator, gateway models
+    local item_labels=()
+    local item_meta=()
+    local item_types=()    # "cli", "separator", "gateway"
+    local item_sources=()  # index into KNOWN_AGENT_* or KNOWN_GATEWAY_*
+    local max_label_len=0
+
+    # CLI agents header
+    item_labels+=("--- Detected CLI agents ---")
+    item_meta+=("")
+    item_types+=("separator")
+    item_sources+=("-1")
+
+    # CLI agents on PATH
+    for idx in "${AVAILABLE_AGENT_INDICES[@]}"; do
+        local label="${KNOWN_AGENT_LABELS[$idx]}"
+        local binary="${KNOWN_AGENT_BINARIES[$idx]}"
+        item_labels+=("$label")
+        local ver
+        ver=$("$binary" --version 2>&1 | head -1 | grep -oE '[0-9]+\.[0-9]+[0-9.]*' | head -1) || ver=""
+        [ -z "$ver" ] && ver="installed"
+        item_meta+=("$ver")
+        item_types+=("cli")
+        item_sources+=("$idx")
+        local len=${#name}
+        [ "$len" -gt "$max_label_len" ] && max_label_len=$len
+    done
+
+    # Separator
+    item_labels+=("--- Vercel AI Gateway ---")
+    item_meta+=("")
+    item_types+=("separator")
+    item_sources+=("-1")
+
+    # Gateway models (always shown)
+    for idx in "${!KNOWN_GATEWAY_NAMES[@]}"; do
+        local label="${KNOWN_GATEWAY_LABELS[$idx]}"
+        item_labels+=("$label")
+        item_meta+=("${KNOWN_GATEWAY_MODELS[$idx]}")
+        item_types+=("gateway")
+        item_sources+=("$idx")
+        local len=${#label}
+        [ "$len" -gt "$max_label_len" ] && max_label_len=$len
+    done
+
+    local count=${#item_labels[@]}
+
+    # State: pre-select CLI agents, gateway unselected
+    local cursor=0
+    local selected=()
+    for (( i = 0; i < count; i++ )); do
+        if [ "${item_types[$i]}" = "cli" ]; then
+            selected+=(1)
+        else
+            selected+=(0)
+        fi
+    done
+
+    # Skip separators for initial cursor position
+    while [ "$cursor" -lt "$count" ] && [ "${item_types[$cursor]}" = "separator" ]; do
+        cursor=$((cursor + 1))
+    done
+
+    local sep=""
+    for (( i = 0; i < max_label_len + 40; i++ )); do sep="${sep}-"; done
+
+    # submit row is at index $count
+    local jump_back=$(( count + 3 ))
+
+    _agent_render() {
+        local sel_count=0
+        for (( i = 0; i < count; i++ )); do
+            [ "${selected[$i]}" = "1" ] && sel_count=$(( sel_count + 1 ))
+        done
+
+        for (( i = 0; i < count; i++ )); do
+            if [ "${item_types[$i]}" = "separator" ]; then
+                printf "\\r\\033[K  \\033[2m%s\\033[0m\\n" "${item_labels[$i]}" >&2
+                continue
+            fi
+            local marker="  "
+            [ "$cursor" -eq "$i" ] && marker="> "
+            local check="[ ]"
+            [ "${selected[$i]}" = "1" ] && check="[x]"
+            if [ -n "${item_meta[$i]}" ]; then
+                printf "\\r\\033[K  %s%s %-${max_label_len}s  (%s)\\n" "$marker" "$check" "${item_labels[$i]}" "${item_meta[$i]}" >&2
+            else
+                printf "\\r\\033[K  %s%s %s\\n" "$marker" "$check" "${item_labels[$i]}" >&2
+            fi
+        done
+
+        printf "\\r\\033[K  %s\\n" "$sep" >&2
+
+        local submit_marker="  "
+        [ "$cursor" -eq "$count" ] && submit_marker="> "
+        if [ "$sel_count" -ge 2 ]; then
+            printf "\\r\\033[K  %s%s\\n" "$submit_marker" "Submit ($sel_count selected)" >&2
+        else
+            printf "\\r\\033[K  %s\\033[2m%s\\033[0m\\n" "$submit_marker" "Submit (need at least 2)" >&2
+        fi
+
+        printf "\\r\\033[K\\n\\033[K  \\033[2m↑↓ navigate · space/enter toggle · enter submit (min 2)\\033[0m" >&2
+    }
+
+    printf "Select agents (at least 2). CLI agents pre-selected, gateway models available below:\\n\\n" >&2
+    printf "\\033[?25l" >&2
+    _agent_render
+
+    local old_stty
+    old_stty=$(stty -g < /dev/tty 2>/dev/null)
+    _agent_cleanup() {
+        printf "\\033[?25h" >&2
+        stty "$old_stty" < /dev/tty 2>/dev/null
+    }
+    trap '_agent_cleanup' INT TERM
+    stty -echo -icanon min 1 < /dev/tty 2>/dev/null
+
+    while true; do
+        local key
+        key=$(dd bs=1 count=1 2>/dev/null < /dev/tty) || break
+
+        if [ "$key" = $'\033' ]; then
+            local bracket dir
+            bracket=$(dd bs=1 count=1 2>/dev/null < /dev/tty) || true
+            dir=$(dd bs=1 count=1 2>/dev/null < /dev/tty) || true
+            if [ "$bracket" = "[" ]; then
+                case "$dir" in
+                    A)  # Up: skip separators
+                        local new_cursor=$((cursor - 1))
+                        while [ "$new_cursor" -ge 0 ] && [ "${item_types[$new_cursor]}" = "separator" ]; do
+                            new_cursor=$((new_cursor - 1))
+                        done
+                        [ "$new_cursor" -ge 0 ] && cursor=$new_cursor
+                        ;;
+                    B)  # Down: skip separators
+                        local new_cursor=$((cursor + 1))
+                        while [ "$new_cursor" -lt "$count" ] && [ "${item_types[$new_cursor]}" = "separator" ]; do
+                            new_cursor=$((new_cursor + 1))
+                        done
+                        [ "$new_cursor" -le "$count" ] && cursor=$new_cursor
+                        ;;
+                esac
+            fi
+        elif [ "$key" = " " ]; then
+            if [ "$cursor" -lt "$count" ] && [ "${item_types[$cursor]}" != "separator" ]; then
+                [ "${selected[$cursor]}" = "0" ] && selected[$cursor]=1 || selected[$cursor]=0
+            fi
+        elif [ "$key" = "" ]; then
+            if [ "$cursor" -eq "$count" ]; then
+                local sel_count=0
+                for (( i = 0; i < count; i++ )); do
+                    [ "${selected[$i]}" = "1" ] && sel_count=$(( sel_count + 1 ))
+                done
+                [ "$sel_count" -ge 2 ] && break
+            elif [ "${item_types[$cursor]}" != "separator" ]; then
+                [ "${selected[$cursor]}" = "0" ] && selected[$cursor]=1 || selected[$cursor]=0
+            fi
+        elif [ "$key" = "q" ]; then
+            for (( i = 0; i < count; i++ )); do selected[$i]=0; done
+            break
+        fi
+
+        printf "\\033[%dA" "$jump_back" >&2
+        _agent_render
+    done
+
+    _agent_cleanup
+    trap - INT TERM
+    printf "\\n\\n" >&2
+
+    # Collect selections by type
+    local has_gateway=0
+    for (( i = 0; i < count; i++ )); do
+        [ "${selected[$i]}" != "1" ] && continue
+        case "${item_types[$i]}" in
+            cli) SELECTED_AGENT_INDICES+=("${item_sources[$i]}") ;;
+            gateway)
+                SELECTED_GATEWAY_INDICES+=("${item_sources[$i]}")
+                has_gateway=1
+                ;;
+        esac
+    done
+
+    # If gateway models selected, ensure API key is stored
+    if [ "$has_gateway" = "1" ] && ! gateway_has_key "vercel-ai-gateway"; then
+        printf "Gateway models selected. Setting up API key...\\n\\n" >&2
+        gateway_store_key "vercel-ai-gateway" || {
+            echo "ERROR: Failed to store gateway key. Gateway models will not work." >&2
+            SELECTED_GATEWAY_INDICES=()
+        }
+    fi
+}
+
+# ---- Write config.toml from selected agents ----
+
+_write_config_toml() {
+    local config_file="$1"
+    cat > "$config_file" <<'HEADER'
+# moxie configuration
+# Generated by: moxie init
+
+[spec]
+path = "spec.md"
+
+HEADER
+
+    # Gateway section (if any gateway models selected)
+    if [ ${#SELECTED_GATEWAY_INDICES[@]} -gt 0 ]; then
+        cat >> "$config_file" <<'GATEWAY'
+[gateway]
+endpoint = "https://ai-gateway.vercel.sh"
+
+GATEWAY
+    fi
+
+    cat >> "$config_file" <<'AGENTHEAD'
+# Agent definitions — order is the default rotation sequence.
+# Rotation is randomized per phase at runtime, so order only
+# determines fallback ordering.
+AGENTHEAD
+
+    local order=1
+
+    # CLI agents
+    for idx in "${SELECTED_AGENT_INDICES[@]}"; do
+        local name="${KNOWN_AGENT_NAMES[$idx]}"
+        local cmd="${KNOWN_AGENT_CMDS[$idx]}"
+        cat >> "$config_file" <<AGENT
+[agents.${name}]
+command = '${cmd}'
+order = ${order}
+
+AGENT
+        order=$((order + 1))
+    done
+
+    # Gateway agents
+    for idx in "${SELECTED_GATEWAY_INDICES[@]}"; do
+        local name="${KNOWN_GATEWAY_NAMES[$idx]}"
+        local model="${KNOWN_GATEWAY_MODELS[$idx]}"
+        cat >> "$config_file" <<GWAGENT
+[agents.${name}]
+type = "gateway"
+model = "${model}"
+order = ${order}
+
+GWAGENT
+        order=$((order + 1))
+    done
+
+    cat >> "$config_file" <<'SETTINGS'
+[settings]
+max_rounds = 15
+max_rounds_build = 50
+turn_timeout = 900
+SETTINGS
+}
+
 _copy_context_docs() {
     if [ ${#CONTEXT_SELECTED[@]} -eq 0 ]; then
         return
@@ -273,7 +539,44 @@ cmd_init() {
         echo "WARNING: $MOXIE_DIR already exists. Reinitializing." >&2
     fi
 
-    # If no --spec provided, RFC phase will generate one
+    # ---- Detect and select agents ----
+    detect_available_agents
+
+    if [ "$AVAILABLE_AGENT_COUNT" -lt 2 ]; then
+        echo "ERROR: moxie requires at least 2 agent CLIs installed." >&2
+        echo "" >&2
+        echo "Found $AVAILABLE_AGENT_COUNT agent(s) on PATH. Install at least 2 of:" >&2
+        for i in "${!KNOWN_AGENT_NAMES[@]}"; do
+            local binary="${KNOWN_AGENT_BINARIES[$i]}"
+            if command -v "$binary" &>/dev/null; then
+                echo "  [OK] ${KNOWN_AGENT_NAMES[$i]}" >&2
+            else
+                echo "  [ ] ${KNOWN_AGENT_NAMES[$i]}  (not found)" >&2
+            fi
+        done
+        echo "" >&2
+        echo "moxie requires at least 2 agents for cross-model verification." >&2
+        echo "Single-agent mode is not supported." >&2
+        exit 1
+    fi
+
+    if [ -t 0 ]; then
+        _select_agents
+    else
+        # Non-interactive: auto-select all available CLI agents
+        SELECTED_AGENT_INDICES=("${AVAILABLE_AGENT_INDICES[@]}")
+        SELECTED_GATEWAY_INDICES=()
+    fi
+
+    local total_selected=$(( ${#SELECTED_AGENT_INDICES[@]} + ${#SELECTED_GATEWAY_INDICES[@]} ))
+    if [ "$total_selected" -lt 2 ]; then
+        echo "ERROR: At least 2 agents must be selected." >&2
+        echo "moxie requires at least 2 agents for cross-model verification." >&2
+        echo "Single-agent mode is not supported." >&2
+        exit 1
+    fi
+
+    # ---- Spec handling ----
     if [ -z "$spec_path" ]; then
         generate_rfc=1
         echo "Initializing moxie project (RFC will be generated by agents)..."
@@ -285,6 +588,15 @@ cmd_init() {
         echo "Initializing moxie project..."
         echo "  Spec: $spec_path"
     fi
+
+    # List selected agents
+    echo "  Agents:"
+    for idx in "${SELECTED_AGENT_INDICES[@]}"; do
+        echo "    - ${KNOWN_AGENT_LABELS[$idx]} (CLI)"
+    done
+    for idx in "${SELECTED_GATEWAY_INDICES[@]}"; do
+        echo "    - ${KNOWN_GATEWAY_LABELS[$idx]} (${KNOWN_GATEWAY_MODELS[$idx]}, AI Gateway)"
+    done
     echo ""
 
     # Create directory structure
@@ -307,35 +619,8 @@ SEED
         cp "$spec_path" "$MOXIE_DIR/spec.md"
     fi
 
-    # Generate config
-    cat > "$MOXIE_CONFIG" <<'TOML'
-# moxie configuration
-# Generated by: moxie init
-
-[spec]
-path = "spec.md"
-
-# Agent definitions — order is the default rotation sequence.
-# Rotation is randomized per phase at runtime, so order only
-# determines fallback ordering.
-# command is passed the prompt as the final argument.
-[agents.codex]
-command = 'codex exec -c model_reasoning_effort="xhigh" --dangerously-bypass-approvals-and-sandbox -c model_reasoning_summary="detailed" -c model_supports_reasoning_summaries=true'
-order = 1
-
-[agents.claude]
-command = "claude --dangerously-skip-permissions --effort max -p"
-order = 2
-
-[agents.qwen]
-command = "qwen --yolo"
-order = 3
-
-[settings]
-max_rounds = 15
-max_rounds_build = 50
-turn_timeout = 900
-TOML
+    # Generate config from selected agents
+    _write_config_toml "$MOXIE_CONFIG"
 
     # Generate prompt templates from bundled templates
     for phase in "${PHASES[@]}"; do
@@ -383,8 +668,8 @@ TOML
     if [ ! -d "$MOXIE_DIR/context" ] || [ -z "$(ls -A "$MOXIE_DIR/context" 2>/dev/null)" ]; then
         echo "     Tip: add context docs to .moxie/context/ (roadmaps, PRDs, etc.)"
     fi
-    echo "  3. Run: moxie start    (background, caffeinated)"
-    echo "     Or:  moxie run      (foreground, caffeinated)"
+    echo "  3. Run: moxie start    (background)"
+    echo "     Or:  moxie run      (foreground)"
 }
 
 _init_ledger() {
@@ -467,6 +752,39 @@ sys.exit(0)
 " 2>/dev/null
 }
 
+# Like _all_agents_reached but excludes degraded agents.
+# Quorum requires all HEALTHY agents to have reached: true.
+_healthy_agents_reached() {
+    local ledger="$1"
+
+    # Build space-separated list of healthy agent names
+    local healthy_names=""
+    for i in "${!AGENT_NAMES[@]}"; do
+        if [ "${AGENT_DEGRADED[$i]}" = "0" ]; then
+            healthy_names="${healthy_names}${AGENT_NAMES[$i]} "
+        fi
+    done
+    healthy_names="${healthy_names% }"  # trim trailing space
+
+    local healthy_count
+    healthy_count=$(count_healthy_agents)
+
+    python3 -c "
+import json, sys
+with open('$ledger') as f:
+    d = json.load(f)
+agents = d.get('agents', {})
+required = set('$healthy_names'.split())
+if len(required) < 2:
+    sys.exit(1)
+for name in required:
+    info = agents.get(name, {})
+    if not info.get('reached', False):
+        sys.exit(1)
+sys.exit(0)
+" 2>/dev/null
+}
+
 # ---- Phase completion detection (for resume) ----
 
 _phase_is_complete() {
@@ -496,6 +814,7 @@ _shuffle_agents() {
 cmd_run() {
     require_moxie_project
     load_agents
+    check_minimum_agents || exit 1
 
     local target_phase=""
     local dry_run="${DRY_RUN:-0}"
@@ -527,19 +846,34 @@ cmd_run() {
         echo $$ > "$MOXIE_DIR/moxie.pid"
         trap 'rm -f "$MOXIE_DIR/moxie.pid"' EXIT
 
-        caffeinate -d -i -s bash -c "
-            set -euo pipefail
-            cd '$(pwd)'
-            export DRY_RUN=0
-            export MOXIE_ROOT='$MOXIE_ROOT'
-            export MOXIE_LIB='$MOXIE_LIB'
-            source '$MOXIE_LIB/core.sh'
-            source '$MOXIE_LIB/agents.sh'
-            source '$MOXIE_LIB/phases.sh'
-            source '$MOXIE_LIB/tokens.sh'
-            load_agents
-            _run_pipeline ${run_phases[*]}
-        "
+        if [ "$MOXIE_PLATFORM" = "darwin" ]; then
+            caffeinate -d -i -s bash -c "
+                set -euo pipefail; cd '$(pwd)'
+                export DRY_RUN=0 MOXIE_ROOT='$MOXIE_ROOT' MOXIE_LIB='$MOXIE_LIB'
+                source '$MOXIE_LIB/platform.sh'; source '$MOXIE_LIB/core.sh'
+                source '$MOXIE_LIB/agents.sh'; source '$MOXIE_LIB/phases.sh'
+                source '$MOXIE_LIB/tokens.sh'
+                load_agents; _run_pipeline ${run_phases[*]}
+            "
+        elif [ "$MOXIE_PLATFORM" = "linux" ] && command -v systemd-inhibit &>/dev/null; then
+            systemd-inhibit --what=idle:sleep --who=moxie --why="moxie pipeline" bash -c "
+                set -euo pipefail; cd '$(pwd)'
+                export DRY_RUN=0 MOXIE_ROOT='$MOXIE_ROOT' MOXIE_LIB='$MOXIE_LIB'
+                source '$MOXIE_LIB/platform.sh'; source '$MOXIE_LIB/core.sh'
+                source '$MOXIE_LIB/agents.sh'; source '$MOXIE_LIB/phases.sh'
+                source '$MOXIE_LIB/tokens.sh'
+                load_agents; _run_pipeline ${run_phases[*]}
+            "
+        else
+            bash -c "
+                set -euo pipefail; cd '$(pwd)'
+                export DRY_RUN=0 MOXIE_ROOT='$MOXIE_ROOT' MOXIE_LIB='$MOXIE_LIB'
+                source '$MOXIE_LIB/platform.sh'; source '$MOXIE_LIB/core.sh'
+                source '$MOXIE_LIB/agents.sh'; source '$MOXIE_LIB/phases.sh'
+                source '$MOXIE_LIB/tokens.sh'
+                load_agents; _run_pipeline ${run_phases[*]}
+            "
+        fi
     fi
 }
 
@@ -547,6 +881,8 @@ cmd_run() {
 
 cmd_start() {
     require_moxie_project
+    load_agents
+    check_minimum_agents || exit 1
 
     local target_phase=""
     while [[ $# -gt 0 ]]; do
@@ -582,28 +918,30 @@ cmd_start() {
     echo "  Stop: moxie stop"
     echo ""
 
-    # Launch in background, caffeinated
-    nohup caffeinate -d -i -s bash -c "
-        set -euo pipefail
-        cd '$(pwd)'
-        export DRY_RUN=0
-        export MOXIE_ROOT='$MOXIE_ROOT'
-        export MOXIE_LIB='$MOXIE_LIB'
-        source '$MOXIE_LIB/core.sh'
-        source '$MOXIE_LIB/agents.sh'
-        source '$MOXIE_LIB/phases.sh'
+    # Launch in background with platform-appropriate sleep inhibitor
+    local _bg_script="
+        set -euo pipefail; cd '$(pwd)'
+        export DRY_RUN=0 MOXIE_ROOT='$MOXIE_ROOT' MOXIE_LIB='$MOXIE_LIB'
+        source '$MOXIE_LIB/platform.sh'; source '$MOXIE_LIB/core.sh'
+        source '$MOXIE_LIB/agents.sh'; source '$MOXIE_LIB/phases.sh'
         source '$MOXIE_LIB/tokens.sh'
         load_agents
-
-        # Determine phases
         if [ -n '$target_phase' ]; then
             phases=('$target_phase')
         else
             phases=(\${PHASES[@]})
         fi
-
         _run_pipeline \${phases[*]}
-    " > "$log_file" 2>&1 &
+    "
+
+    if [ "$MOXIE_PLATFORM" = "darwin" ]; then
+        nohup caffeinate -d -i -s bash -c "$_bg_script" > "$log_file" 2>&1 &
+    elif [ "$MOXIE_PLATFORM" = "linux" ] && command -v systemd-inhibit &>/dev/null; then
+        nohup systemd-inhibit --what=idle:sleep --who=moxie --why="moxie pipeline" \
+            bash -c "$_bg_script" > "$log_file" 2>&1 &
+    else
+        nohup bash -c "$_bg_script" > "$log_file" 2>&1 &
+    fi
 
     local bg_pid=$!
     echo "$bg_pid" > "$MOXIE_DIR/moxie.pid"
@@ -667,7 +1005,11 @@ _print_run_banner() {
     echo ""
     echo "Started: $(date)"
     if [ "${DRY_RUN:-0}" = "0" ]; then
-        echo "Machine will stay awake (caffeinate)."
+        local _inhibitor
+        _inhibitor=$(sleep_inhibit_name)
+        if [ "$_inhibitor" != "(none)" ]; then
+            echo "Machine will stay awake ($_inhibitor)."
+        fi
     else
         echo "Mode: DRY RUN"
     fi
@@ -759,6 +1101,90 @@ print(f'  {grand:,} tokens')
 " 2>/dev/null || echo "  (unknown)"
 }
 
+# ---- Convergence helpers ----
+
+# Returns a stable fingerprint of the current findings in a ledger.
+# Extracts all INCOMPLETE/INACCURATE section labels, sorts them, and hashes.
+# If findings are identical across rotations, the hash won't change.
+_findings_fingerprint() {
+    local ledger="$1"
+    python3 -c "
+import json, hashlib
+with open('$ledger') as f:
+    d = json.load(f)
+# Collect all finding descriptions from agent outputs
+findings = set()
+for name, info in d.get('agents', {}).items():
+    out = info.get('output_file', '')
+    note = info.get('notes', '')
+    # Use notes field as findings summary (agents write their review status here)
+    if note:
+        findings.add(note[:200])
+# Also check the top-level findings array if present
+for f in d.get('findings', []):
+    if isinstance(f, str):
+        findings.add(f[:200])
+    elif isinstance(f, dict):
+        findings.add(str(f.get('section', '')) + ':' + str(f.get('status', '')))
+# Stable fingerprint: sorted findings hashed
+key = '|'.join(sorted(findings))
+print(hashlib.md5(key.encode()).hexdigest() if key else '')
+" 2>/dev/null
+}
+
+# Force-accept the best available draft as FINAL for a phase.
+# Picks the most recent .md file (by filename timestamp) from any agent.
+_force_accept_best_draft() {
+    local phase_dir="$1"
+    local final_prefix="$2"
+    local ledger="$3"
+
+    # Find the most recent agent draft (not a FINAL file)
+    local best=""
+    for f in "$phase_dir"/*.md; do
+        [ ! -f "$f" ] && continue
+        case "$(basename "$f")" in
+            ${final_prefix}-*) continue ;;  # skip existing FINAL files
+        esac
+        # Pick the one with the latest filename (timestamps sort lexically)
+        if [ -z "$best" ] || [[ "$(basename "$f")" > "$(basename "$best")" ]]; then
+            best="$f"
+        fi
+    done
+
+    if [ -z "$best" ]; then
+        echo "  No draft files found to accept." >&2
+        return 1
+    fi
+
+    local ts
+    ts=$(date +"%m%d%y-%H%M%S")
+    local final_file="$phase_dir/${final_prefix}-${ts}.md"
+
+    cp "$best" "$final_file"
+
+    # Also copy to spec.md if this is the RFC phase
+    if [ "$final_prefix" = "RFC-FINAL" ]; then
+        cp "$final_file" "$MOXIE_DIR/spec.md"
+    fi
+
+    # Mark all healthy agents as reached in the ledger
+    python3 -c "
+import json
+with open('$ledger') as f:
+    d = json.load(f)
+for name in d.get('agents', {}):
+    d['agents'][name]['reached'] = True
+d['status'] = '$(echo "$final_prefix" | tr '[:upper:]' '[:lower:]' | tr '-' '_')'
+with open('$ledger', 'w') as f:
+    json.dump(d, f, indent=2)
+" 2>/dev/null
+
+    echo "  Accepted: $(basename "$best") → $(basename "$final_file")"
+    echo ""
+    _show_quorum "$ledger"
+}
+
 # ---- Phase execution ----
 
 _run_phase() {
@@ -778,11 +1204,19 @@ _run_phase() {
 
     # Randomize rotation order for this phase
     _shuffle_agents
+    _init_agent_health
     echo "Rotation order for $(phase_label "$phase"): ${AGENT_NAMES[*]}"
     echo ""
 
     banner "moxie: $(phase_label "$phase") phase" "$max_rounds" "$turn_timeout" "${DRY_RUN:-0}"
 
+    # Convergence detection: track findings fingerprints across rounds.
+    # If the same findings repeat for STALE_THRESHOLD consecutive full rotations
+    # (each agent gets a turn), force-accept the best draft.
+    local STALE_THRESHOLD=3
+    local stale_count=0
+    local prev_fingerprint=""
+
     # Show initial ledger
     echo "Quorum status:"
     _show_quorum "$ledger"
@@ -791,27 +1225,43 @@ _run_phase() {
     local current="${AGENT_NAMES[0]}"
 
     for round in $(seq 1 "$max_rounds"); do
+        # Skip degraded agents
+        local skipped=0
+        while is_agent_degraded "$current"; do
+            current=$(next_agent "$current")
+            skipped=$((skipped + 1))
+            # Safety: don't infinite-loop if all agents are degraded
+            if [ "$skipped" -ge "$AGENT_COUNT" ]; then
+                echo ""
+                echo "FATAL: All agents are degraded. Pipeline cannot continue."
+                _show_quorum "$ledger"
+                return 1
+            fi
+        done
+
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
         echo "  Turn $round/$max_rounds — $current"
         echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-        # Check if FINAL already exists (another agent wrote it) AND all agents reached
+        # Check if FINAL already exists AND healthy agents have all reached quorum
         if ls "$phase_dir"/${final_prefix}-*.md &>/dev/null; then
-            if _all_agents_reached "$ledger"; then
+            if _healthy_agents_reached "$ledger"; then
                 local final
                 final=$(ls -1 "$phase_dir"/${final_prefix}-*.md | tail -1)
+                local healthy
+                healthy=$(count_healthy_agents)
                 echo ""
                 echo "╔════════════════════════════════════════════════════════════╗"
-                printf "║  %-58s║\n" "$(phase_label "$phase") phase complete — unanimous quorum"
+                printf "║  %-58s║\n" "$(phase_label "$phase") phase complete — quorum reached"
                 printf "║  Final: %-52s║\n" "$(basename "$final")"
-                printf "║  All %d agents signed off                                  ║\n" "$AGENT_COUNT"
+                printf "║  %d/%d agents signed off                                   ║\n" "$healthy" "$AGENT_COUNT"
                 echo "╚════════════════════════════════════════════════════════════╝"
                 echo ""
                 show_phase_tokens "$csv"
                 return 0
             else
-                # FINAL file exists but not all agents reached — keep going
-                echo "  FINAL file exists but not all agents have signed off yet."
+                # FINAL file exists but not all healthy agents reached — keep going
+                echo "  FINAL file exists but not all healthy agents have signed off yet."
                 echo ""
             fi
         fi
@@ -825,39 +1275,83 @@ _run_phase() {
 
         # Run
         dispatch_logged "$current" "$prompt_file" "$turn_timeout" "$log_dir" "$round" "$csv" "$phase"
+        local dispatch_rc=$?
         rm -f "$prompt_file"
 
+        # If _record_turn_health returned 2 (fatal: < 2 agents remaining), stop
+        if [ "$dispatch_rc" = "2" ] || [ "$(count_healthy_agents)" -lt 2 ]; then
+            echo ""
+            echo "FATAL: Fewer than 2 healthy agents remaining. Pipeline cannot continue."
+            _show_quorum "$ledger"
+            return 1
+        fi
+
         echo ""
         echo "Quorum after $current's turn:"
         _show_quorum "$ledger"
 
-        # Check unanimous quorum after this turn
-        if _all_agents_reached "$ledger"; then
+        # Check quorum among healthy agents after this turn
+        if _healthy_agents_reached "$ledger"; then
             # Verify FINAL file was actually written by the agent
             if ls "$phase_dir"/${final_prefix}-*.md &>/dev/null; then
                 local final
                 final=$(ls -1 "$phase_dir"/${final_prefix}-*.md | tail -1)
+                local healthy
+                healthy=$(count_healthy_agents)
                 echo ""
                 echo "╔════════════════════════════════════════════════════════════╗"
-                printf "║  %-58s║\n" "$(phase_label "$phase") phase complete — unanimous quorum"
+                printf "║  %-58s║\n" "$(phase_label "$phase") phase complete — quorum reached"
                 printf "║  Final: %-52s║\n" "$(basename "$final")"
-                printf "║  All %d agents signed off                                  ║\n" "$AGENT_COUNT"
+                printf "║  %d/%d agents signed off                                   ║\n" "$healthy" "$AGENT_COUNT"
                 echo "╚════════════════════════════════════════════════════════════╝"
                 echo ""
                 show_phase_tokens "$csv"
                 return 0
             else
-                echo "  All agents reached quorum but FINAL file not yet written."
+                echo "  All healthy agents reached quorum but FINAL file not yet written."
                 echo "  Next agent will write it."
             fi
         fi
 
+        # ---- Convergence detection ----
+        # After each full rotation (every AGENT_COUNT turns), fingerprint the
+        # findings. If findings stabilize for STALE_THRESHOLD rotations, the
+        # agents are in a perfectionist loop — force-accept the best draft.
+        if [ $(( round % $(count_healthy_agents) )) -eq 0 ]; then
+            local fingerprint
+            fingerprint=$(_findings_fingerprint "$ledger")
+
+            if [ "$fingerprint" = "$prev_fingerprint" ] && [ -n "$fingerprint" ]; then
+                stale_count=$((stale_count + 1))
+                echo "  [convergence] Findings unchanged for $stale_count rotation(s) ($STALE_THRESHOLD triggers force-accept)"
+            else
+                stale_count=0
+                prev_fingerprint="$fingerprint"
+            fi
+
+            if [ "$stale_count" -ge "$STALE_THRESHOLD" ]; then
+                echo ""
+                echo "╔════════════════════════════════════════════════════════════╗"
+                printf "║  %-58s║\n" "$(phase_label "$phase") — force-accepting (convergence stall)"
+                echo "║  Findings stabilized for $STALE_THRESHOLD rotations.                        ║"
+                echo "║  Accepting best available draft as FINAL.                  ║"
+                echo "╚════════════════════════════════════════════════════════════╝"
+                echo ""
+                _force_accept_best_draft "$phase_dir" "$final_prefix" "$ledger"
+                show_phase_tokens "$csv"
+                return 0
+            fi
+        fi
+
         echo ""
         current=$(next_agent "$current")
     done
 
+    # If max rounds exhausted, force-accept rather than failing
     echo ""
-    echo "WARNING: $(phase_label "$phase") phase reached max rounds ($max_rounds) without unanimous quorum."
+    echo "WARNING: $(phase_label "$phase") phase reached max rounds ($max_rounds) without quorum."
+    echo "Force-accepting best available draft."
+    _force_accept_best_draft "$phase_dir" "$final_prefix" "$ledger"
     _show_quorum "$ledger"
     echo ""
     show_phase_tokens "$csv"