get-shit-done-cc 1.10.0-experimental.0 → 1.10.0

package/get-shit-done/templates/autopilot-script.sh

@@ -1,1142 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════════
-# GSD Autopilot Script
-# Generated: {{timestamp}}
-# Project: {{project_name}}
-# ═══════════════════════════════════════════════════════════════════════════════
-#
-# Autonomous execution of all remaining phases in the milestone.
-# Each phase gets fresh 200k context via claude -p.
-# State persists in .planning/ - safe to interrupt and resume.
-#
-# Features:
-#   - Real-time activity display via hooks
-#   - Stage tracking (research -> planning -> building -> verifying)
-#   - Git safety checks (no uncommitted files left behind)
-#   - Phase context display (what we're building and why)
-#
-# Usage:
-#   bash .planning/autopilot.sh              # Run attached
-#   nohup bash .planning/autopilot.sh &      # Run in background
-#
-# ═══════════════════════════════════════════════════════════════════════════════
-
-set -euo pipefail
-
-# Signal to GSD commands that we're in autopilot mode
-export GSD_AUTOPILOT=1
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Configuration (filled by /gsd:autopilot)
-# ─────────────────────────────────────────────────────────────────────────────
-
-PROJECT_DIR="{{project_dir}}"
-PROJECT_NAME="{{project_name}}"
-PHASES=({{phases}})
-CHECKPOINT_MODE="{{checkpoint_mode}}"
-MAX_RETRIES={{max_retries}}
-BUDGET_LIMIT={{budget_limit}}
-WEBHOOK_URL="{{webhook_url}}"
-
-# Model selection (from config.json)
-AUTOPILOT_MODEL="default"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Derived paths
-# ─────────────────────────────────────────────────────────────────────────────
-
-LOG_DIR="$PROJECT_DIR/.planning/logs"
-CHECKPOINT_DIR="$PROJECT_DIR/.planning/checkpoints"
-STATE_FILE="$PROJECT_DIR/.planning/STATE.md"
-ACTIVITY_PIPE="$PROJECT_DIR/.planning/logs/activity.pipe"
-
-# Export for hooks
-export GSD_ACTIVITY_PIPE="$ACTIVITY_PIPE"
-export GSD_PROJECT_DIR="$PROJECT_DIR"
-export GSD_LOG_DIR="$LOG_DIR"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Setup
-# ─────────────────────────────────────────────────────────────────────────────
-
-cd "$PROJECT_DIR"
-mkdir -p "$LOG_DIR" "$CHECKPOINT_DIR/pending" "$CHECKPOINT_DIR/approved"
-
-# Create activity pipe for hook communication
-rm -f "$ACTIVITY_PIPE"
-mkfifo "$ACTIVITY_PIPE" 2>/dev/null || true
-
-# Try to start Ink TUI (fallback to bash TUI if not available)
-INK_TUI_AVAILABLE=false
-INK_TUI_PID=""
-INK_TUI_BIN=""
-
-if command -v node &> /dev/null; then
-  # Check for Ink TUI in the project
-  if [ -f "$PROJECT_DIR/node_modules/.bin/gsd-autopilot-tui" ]; then
-    INK_TUI_BIN="$PROJECT_DIR/node_modules/.bin/gsd-autopilot-tui"
-    INK_TUI_AVAILABLE=true
-  elif [ -f "$HOME/.npm-global/bin/gsd-autopilot-tui" ]; then
-    INK_TUI_BIN="$HOME/.npm-global/bin/gsd-autopilot-tui"
-    INK_TUI_AVAILABLE=true
-  elif command -v gsd-autopilot-tui &> /dev/null; then
-    INK_TUI_BIN="gsd-autopilot-tui"
-    INK_TUI_AVAILABLE=true
-  fi
-fi
-
-if [ "$INK_TUI_AVAILABLE" = true ]; then
-  log "INFO" "Starting Ink TUI: $INK_TUI_BIN"
-  export GSD_ACTIVITY_PIPE="$ACTIVITY_PIPE"
-  export GSD_PROJECT_DIR="$PROJECT_DIR"
-  export GSD_LOG_DIR="$LOG_DIR"
-  export GSD_PHASE="$CURRENT_PHASE"
-  export GSD_PHASE_NAME="$CURRENT_PHASE_NAME"
-  export GSD_TOTAL_PHASES="${#PHASES[@]}"
-
-  # Start TUI in background
-  if [ -n "$INK_TUI_BIN" ]; then
-    setsid "$INK_TUI_BIN" > "$LOG_DIR/tui.log" 2>&1 &
-    INK_TUI_PID=$!
-    log "INFO" "Ink TUI started (PID: $INK_TUI_PID)"
-
-    # Wait a moment for TUI to initialize
-    sleep 1
-
-    # Check if TUI is still running
-    if ! kill -0 $INK_TUI_PID 2>/dev/null; then
-      log "WARN" "Ink TUI failed to start, using bash fallback"
-      INK_TUI_AVAILABLE=false
-      INK_TUI_PID=""
-    fi
-  fi
-else
-  log "INFO" "Ink TUI not available, using bash TUI"
-fi
-
-# Lock directory (atomic creation prevents race condition)
-LOCK_DIR="$PROJECT_DIR/.planning/autopilot.lock.d"
-if ! mkdir "$LOCK_DIR" 2>/dev/null; then
-  echo "ERROR: Autopilot already running (lock exists: $LOCK_DIR)"
-  echo "If previous run crashed, remove manually: rmdir '$LOCK_DIR'"
-  exit 1
-fi
-
-cleanup() {
-  # Kill background processes
-  [ -n "${READER_PID:-}" ] && kill $READER_PID 2>/dev/null
-  [ -n "${DISPLAY_PID:-}" ] && kill $DISPLAY_PID 2>/dev/null
-
-  # Kill Ink TUI if running
-  [ -n "${INK_TUI_PID:-}" ] && kill $INK_TUI_PID 2>/dev/null || true
-
-  # Remove lock and pipe
-  rmdir "$LOCK_DIR" 2>/dev/null || true
-  rm -f "$ACTIVITY_PIPE" 2>/dev/null || true
-
-  # Restore cursor
-  printf "\033[?25h" 2>/dev/null
-}
-trap cleanup EXIT INT TERM
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Cross-platform helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-iso_timestamp() {
-  date '+%Y-%m-%dT%H:%M:%S%z'
-}
-
-elapsed_since() {
-  local start=$1
-  local now=$(date +%s)
-  local elapsed=$((now - start))
-  local min=$((elapsed / 60))
-  local sec=$((elapsed % 60))
-  printf "%d:%02d" $min $sec
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Terminal UI
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Colors and formatting (auto-disabled if not a terminal)
-if [ -t 1 ]; then
-  C_RESET='\033[0m'
-  C_BOLD='\033[1m'
-  C_DIM='\033[2m'
-  C_RED='\033[31m'
-  C_GREEN='\033[32m'
-  C_YELLOW='\033[33m'
-  C_BLUE='\033[34m'
-  C_CYAN='\033[36m'
-  C_WHITE='\033[37m'
-  CURSOR_HOME='\033[H'
-  CURSOR_CLEAR='\033[J'
-  CURSOR_LINE_CLEAR='\033[K'
-  CURSOR_HIDE='\033[?25l'
-  CURSOR_SHOW='\033[?25h'
-else
-  C_RESET='' C_BOLD='' C_DIM='' C_RED='' C_GREEN='' C_YELLOW=''
-  C_BLUE='' C_CYAN='' C_WHITE=''
-  CURSOR_HOME='' CURSOR_CLEAR='' CURSOR_LINE_CLEAR=''
-  CURSOR_HIDE='' CURSOR_SHOW=''
-fi
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Display State (shared via temp files for subprocess communication)
-# ─────────────────────────────────────────────────────────────────────────────
-
-DISPLAY_STATE_DIR="$LOG_DIR/.display"
-mkdir -p "$DISPLAY_STATE_DIR"
-
-# Initialize display state files
-echo "" > "$DISPLAY_STATE_DIR/current_stage"
-echo "" > "$DISPLAY_STATE_DIR/stage_desc"
-echo "0" > "$DISPLAY_STATE_DIR/stage_start"
-echo "" > "$DISPLAY_STATE_DIR/completed_stages"
-echo "" > "$DISPLAY_STATE_DIR/activity"
-
-MAX_ACTIVITY_LINES=8
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Stage Management
-# ─────────────────────────────────────────────────────────────────────────────
-
-stage_display_name() {
-  local subagent_type="$1"
-  case "$subagent_type" in
-    gsd-phase-researcher)    echo "RESEARCH" ;;
-    gsd-planner)             echo "PLANNING" ;;
-    gsd-plan-checker)        echo "CHECKING" ;;
-    gsd-executor)            echo "BUILDING" ;;
-    gsd-verifier)            echo "VERIFYING" ;;
-    gsd-integration-checker) echo "INTEGRATING" ;;
-    *)                       echo "WORKING" ;;
-  esac
-}
-
-set_stage() {
-  local subagent_type="$1"
-  local description="$2"
-
-  # Complete previous stage if exists
-  local prev_stage=$(cat "$DISPLAY_STATE_DIR/current_stage" 2>/dev/null)
-  if [ -n "$prev_stage" ]; then
-    local prev_start=$(cat "$DISPLAY_STATE_DIR/stage_start" 2>/dev/null)
-    local elapsed=$(elapsed_since "$prev_start")
-    echo "$prev_stage:$elapsed" >> "$DISPLAY_STATE_DIR/completed_stages"
-  fi
-
-  local stage_name=$(stage_display_name "$subagent_type")
-  echo "$stage_name" > "$DISPLAY_STATE_DIR/current_stage"
-  echo "$description" > "$DISPLAY_STATE_DIR/stage_desc"
-  echo "$(date +%s)" > "$DISPLAY_STATE_DIR/stage_start"
-
-  # Send to activity pipe for Ink TUI
-  if [ -p "$ACTIVITY_PIPE" ]; then
-    echo "STAGE:$subagent_type:$description" > "$ACTIVITY_PIPE"
-  fi
-}
-
-complete_current_stage() {
-  local curr_stage=$(cat "$DISPLAY_STATE_DIR/current_stage" 2>/dev/null)
-  if [ -n "$curr_stage" ]; then
-    local stage_start=$(cat "$DISPLAY_STATE_DIR/stage_start" 2>/dev/null)
-    local elapsed=$(elapsed_since "$stage_start")
-    echo "$curr_stage:$elapsed" >> "$DISPLAY_STATE_DIR/completed_stages"
-    echo "" > "$DISPLAY_STATE_DIR/current_stage"
-    echo "" > "$DISPLAY_STATE_DIR/stage_desc"
-  fi
-}
-
-reset_stages() {
-  echo "" > "$DISPLAY_STATE_DIR/current_stage"
-  echo "" > "$DISPLAY_STATE_DIR/stage_desc"
-  echo "0" > "$DISPLAY_STATE_DIR/stage_start"
-  echo "" > "$DISPLAY_STATE_DIR/completed_stages"
-  echo "" > "$DISPLAY_STATE_DIR/activity"
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Activity Feed
-# ─────────────────────────────────────────────────────────────────────────────
-
-add_activity() {
-  local type="$1"
-  local detail="$2"
-
-  local prefix=""
-  case "$type" in
-    read)   prefix="read   " ;;
-    write)  prefix="write  " ;;
-    edit)   prefix="edit   " ;;
-    commit) prefix="commit " ;;
-    test)   prefix="test   " ;;
-    *)      prefix="       " ;;
-  esac
-
-  # Truncate long paths/messages
-  if [ ${#detail} -gt 50 ]; then
-    detail="${detail:0:47}..."
-  fi
-
-  # Append to activity file, keep last N lines
-  echo "$prefix $detail" >> "$DISPLAY_STATE_DIR/activity"
-  tail -n $MAX_ACTIVITY_LINES "$DISPLAY_STATE_DIR/activity" > "$DISPLAY_STATE_DIR/activity.tmp"
-  mv "$DISPLAY_STATE_DIR/activity.tmp" "$DISPLAY_STATE_DIR/activity"
-
-  # Also write to activity pipe for Ink TUI
-  if [ -p "$ACTIVITY_PIPE" ]; then
-    case "$type" in
-      read)   echo "FILE:read:$detail" > "$ACTIVITY_PIPE" ;;
-      write)  echo "FILE:write:$detail" > "$ACTIVITY_PIPE" ;;
-      edit)   echo "FILE:edit:$detail" > "$ACTIVITY_PIPE" ;;
-      commit) echo "COMMIT:$detail" > "$ACTIVITY_PIPE" ;;
-      test)   echo "TEST:test" > "$ACTIVITY_PIPE" ;;
-      *)      echo "INFO:$detail" > "$ACTIVITY_PIPE" ;;
-    esac
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Phase Context
-# ─────────────────────────────────────────────────────────────────────────────
-
-CURRENT_PHASE=""
-CURRENT_PHASE_NAME=""
-CURRENT_PHASE_CONTEXT=""
-
-load_phase_context() {
-  local phase="$1"
-  local roadmap=".planning/ROADMAP.md"
-
-  [ ! -f "$roadmap" ] && return
-
-  # Extract phase name
-  CURRENT_PHASE_NAME=$(grep -E "Phase $phase:" "$roadmap" 2>/dev/null | head -1 | sed 's/.*Phase [0-9]*: //' | sed 's/ *$//' | sed 's/\*//g')
-  [ -z "$CURRENT_PHASE_NAME" ] && CURRENT_PHASE_NAME="Phase $phase"
-
-  # Extract goal and deliverables
-  local in_phase=0
-  local context=""
-  local line_count=0
-
-  while IFS= read -r line; do
-    if echo "$line" | grep -qE "Phase $phase:"; then
-      in_phase=1
-      continue
-    fi
-
-    if [ $in_phase -eq 1 ]; then
-      # Stop at next phase
-      if echo "$line" | grep -qE "^###.*Phase [0-9]"; then
-        break
-      fi
-
-      # Capture goal
-      if echo "$line" | grep -q "Goal:"; then
-        context=$(echo "$line" | sed 's/.*Goal:[[:space:]]*//' | sed 's/\*//g')
-      fi
-
-      # Capture must-haves (first few)
-      if echo "$line" | grep -qE "^[[:space:]]*-[[:space:]]" && [ $line_count -lt 4 ]; then
-        local item=$(echo "$line" | sed 's/^[[:space:]]*-[[:space:]]*//' | sed 's/\*//g')
-        if [ -n "$item" ]; then
-          context="$context
-  $item"
-          ((line_count++))
-        fi
-      fi
-    fi
-  done < "$roadmap"
-
-  CURRENT_PHASE_CONTEXT="$context"
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Display Rendering
-# ─────────────────────────────────────────────────────────────────────────────
-
-render_display() {
-  local total_phases=$1
-  local current_idx=$2
-
-  # Read current state from files
-  local current_stage=$(cat "$DISPLAY_STATE_DIR/current_stage" 2>/dev/null)
-  local stage_desc=$(cat "$DISPLAY_STATE_DIR/stage_desc" 2>/dev/null)
-  local stage_start=$(cat "$DISPLAY_STATE_DIR/stage_start" 2>/dev/null)
-
-  # Header
-  printf "${C_BOLD}${C_CYAN}"
-  printf "═══════════════════════════════════════════════════════════════\n"
-  printf " GSD AUTOPILOT"
-  printf "%*s" $((46 - ${#PROJECT_NAME})) ""
-  printf "Phase %s/%s\n" "$((current_idx + 1))" "$total_phases"
-  printf "═══════════════════════════════════════════════════════════════${C_RESET}\n"
-  printf "\n"
-
-  # Phase info
-  printf " ${C_BOLD}${C_WHITE}PHASE %s: %s${C_RESET}\n" "$CURRENT_PHASE" "$CURRENT_PHASE_NAME"
-  printf "\n"
-
-  # Phase context (if available)
-  if [ -n "$CURRENT_PHASE_CONTEXT" ]; then
-    echo "$CURRENT_PHASE_CONTEXT" | head -5 | while IFS= read -r line; do
-      printf "${C_DIM} %s${C_RESET}\n" "$line"
-    done
-    printf "\n"
-  fi
-
-  printf "${C_DIM}───────────────────────────────────────────────────────────────${C_RESET}\n"
-  printf "\n"
-
-  # Completed stages
-  if [ -f "$DISPLAY_STATE_DIR/completed_stages" ]; then
-    while IFS= read -r stage_entry; do
-      [ -z "$stage_entry" ] && continue
-      local stage_name="${stage_entry%%:*}"
-      local stage_time="${stage_entry##*:}"
-      printf " ${C_DIM}%-12s%47s${C_RESET}\n" "$stage_name" "done $stage_time"
-    done < "$DISPLAY_STATE_DIR/completed_stages"
-  fi
-
-  # Current stage
-  if [ -n "$current_stage" ]; then
-    local elapsed=""
-    if [ -n "$stage_start" ] && [ "$stage_start" != "0" ]; then
-      elapsed=$(elapsed_since "$stage_start")
-    fi
-    printf " ${C_WHITE}${C_BOLD}%-12s${C_RESET}%47s\n" "$current_stage" "$elapsed"
-
-    if [ -n "$stage_desc" ]; then
-      # Truncate description if needed
-      local desc="$stage_desc"
-      if [ ${#desc} -gt 55 ]; then
-        desc="${desc:0:52}..."
-      fi
-      printf "\n"
-      printf "${C_DIM}   %s${C_RESET}\n" "$desc"
-    fi
-  fi
-
-  printf "\n"
-  printf "${C_DIM}───────────────────────────────────────────────────────────────${C_RESET}\n"
-  printf "\n"
-
-  # Activity feed
-  printf " ${C_DIM}Activity:${C_RESET}\n"
-  printf "\n"
-
-  local activity_count=0
-  if [ -f "$DISPLAY_STATE_DIR/activity" ] && [ -s "$DISPLAY_STATE_DIR/activity" ]; then
-    while IFS= read -r line; do
-      [ -z "$line" ] && continue
-      printf "${C_DIM}   %s${C_RESET}\n" "$line"
-      ((activity_count++))
-    done < "$DISPLAY_STATE_DIR/activity"
-  fi
-
-  if [ $activity_count -eq 0 ]; then
-    printf "${C_DIM}   waiting...${C_RESET}\n"
-    activity_count=1
-  fi
-
-  # Pad to consistent height
-  local pad_lines=$((MAX_ACTIVITY_LINES - activity_count))
-  for ((i=0; i<pad_lines; i++)); do
-    printf "\n"
-  done
-
-  printf "\n"
-  printf "${C_DIM}───────────────────────────────────────────────────────────────${C_RESET}\n"
-  printf "\n"
-
-  # Progress bar
-  local completed=$current_idx
-  local bar_width=50
-  local filled=$((completed * bar_width / total_phases))
-  local empty=$((bar_width - filled))
-
-  printf " Progress ["
-  printf "${C_CYAN}"
-  for ((i=0; i<filled; i++)); do printf "="; done
-  for ((i=0; i<empty; i++)); do printf " "; done
-  printf "${C_RESET}"
-  printf "] %d/%d phases\n" "$completed" "$total_phases"
-
-  printf "\n"
-  printf "${C_DIM}───────────────────────────────────────────────────────────────${C_RESET}\n"
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Activity Pipe Reader (runs in background)
-# ─────────────────────────────────────────────────────────────────────────────
-
-READER_PID=""
-DISPLAY_PID=""
-
-start_activity_reader() {
-  local total_phases=$1
-  local phase_idx=$2
-
-  # Background process to read from pipe and update state
-  (
-    while true; do
-      if read -r line < "$ACTIVITY_PIPE" 2>/dev/null; then
-        case "$line" in
-          STAGE:*)
-            local type=$(echo "$line" | cut -d: -f2)
-            local desc=$(echo "$line" | cut -d: -f3-)
-            set_stage "$type" "$desc"
-            ;;
-          FILE:*)
-            local op=$(echo "$line" | cut -d: -f2)
-            local file=$(echo "$line" | cut -d: -f3-)
-            add_activity "$op" "$file"
-            ;;
-          COMMIT:*)
-            local msg=$(echo "$line" | cut -d: -f2-)
-            add_activity "commit" "$msg"
-            ;;
-          TEST:*)
-            add_activity "test" "running tests"
-            ;;
-          TODO:*)
-            local task=$(echo "$line" | cut -d: -f2-)
-            echo "$task" > "$DISPLAY_STATE_DIR/stage_desc"
-            ;;
-        esac
-      fi
-    done
-  ) &
-  READER_PID=$!
-
-  # Background process to refresh display (only if Ink TUI not available)
-  if [ -t 1 ] && [ "$INK_TUI_AVAILABLE" = false ]; then
-    (
-      while true; do
-        printf "${CURSOR_HOME}${CURSOR_CLEAR}"
-        render_display "$total_phases" "$phase_idx"
-        sleep 0.5
-      done
-    ) &
-    DISPLAY_PID=$!
-  fi
-}
-
-stop_activity_reader() {
-  if [ -n "$READER_PID" ]; then
-    kill $READER_PID 2>/dev/null || true
-    wait $READER_PID 2>/dev/null || true
-    READER_PID=""
-  fi
-  if [ -n "$DISPLAY_PID" ]; then
-    kill $DISPLAY_PID 2>/dev/null || true
-    wait $DISPLAY_PID 2>/dev/null || true
-    DISPLAY_PID=""
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Logging & Notifications
-# ─────────────────────────────────────────────────────────────────────────────
-
-log() {
-  local level="$1"
-  local message="$2"
-  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
-
-  # Always write to log file
-  echo "[$timestamp] [$level] $message" >> "$LOG_DIR/autopilot.log"
-}
-
-notify() {
-  local message="$1"
-  local status="${2:-info}"
-
-  log "NOTIFY" "$message"
-
-  # Terminal bell
-  printf "\a"
-
-  # Webhook if configured
-  if [ -n "$WEBHOOK_URL" ]; then
-    curl -s -X POST "$WEBHOOK_URL" \
-      -H "Content-Type: application/json" \
-      -d "{\"text\": \"GSD Autopilot [$PROJECT_NAME]: $message\", \"status\": \"$status\"}" \
-      > /dev/null 2>&1 || true
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Git Safety
-# ─────────────────────────────────────────────────────────────────────────────
-
-check_uncommitted_files() {
-  local context="$1"
-
-  # Check for uncommitted changes
-  if ! git diff --quiet HEAD 2>/dev/null || ! git diff --cached --quiet 2>/dev/null; then
-    local uncommitted=$(git status --short 2>/dev/null)
-
-    log "WARN" "Uncommitted files detected ($context)"
-    log "WARN" "$uncommitted"
-
-    # Create safety commit
-    git add -A 2>/dev/null
-    git commit -m "wip(autopilot): uncommitted files from $context
-
-Autopilot detected uncommitted files that would otherwise be lost.
-Review and squash/revert as appropriate.
-" 2>/dev/null || true
-
-    log "INFO" "Created safety commit for orphaned files"
-    add_activity "commit" "wip: safety commit"
-    return 1
-  fi
-  return 0
-}
-
-ensure_clean_working_tree() {
-  local context="$1"
-  check_uncommitted_files "$context" || true
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# State Management
-# ─────────────────────────────────────────────────────────────────────────────
-
-update_autopilot_state() {
-  local mode="$1"
-  local phase="$2"
-  local remaining="$3"
-  local error="${4:-none}"
-
-  if grep -q "## Autopilot" "$STATE_FILE" 2>/dev/null; then
-    awk -v mode="$mode" -v phase="$phase" -v remaining="$remaining" -v error="$error" -v ts="$(iso_timestamp)" '
-      /^## Autopilot/,/^## / {
-        if (/^- \*\*Mode:\*\*/) { print "- **Mode:** " mode; next }
-        if (/^- \*\*Current Phase:\*\*/) { print "- **Current Phase:** " phase; next }
-        if (/^- \*\*Phases Remaining:\*\*/) { print "- **Phases Remaining:** " remaining; next }
-        if (/^- \*\*Last Error:\*\*/) { print "- **Last Error:** " error; next }
-        if (/^- \*\*Updated:\*\*/) { print "- **Updated:** " ts; next }
-      }
-      { print }
-    ' "$STATE_FILE" > "$STATE_FILE.tmp" && mv "$STATE_FILE.tmp" "$STATE_FILE"
-  else
-    cat >> "$STATE_FILE" << EOF
-
-## Autopilot
-
-- **Mode:** $mode
-- **Started:** $(iso_timestamp)
-- **Current Phase:** $phase
-- **Phases Remaining:** $remaining
-- **Checkpoints Pending:** (none)
-- **Last Error:** $error
-- **Updated:** $(iso_timestamp)
-EOF
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Cost Tracking
-# ─────────────────────────────────────────────────────────────────────────────
-
-TOTAL_TOKENS=0
-TOTAL_COST_CENTS=0
-
-track_cost() {
-  local log_file="$1"
-  local phase="$2"
-
-  local tokens=$(grep -o 'tokens[: ]*[0-9,]*' "$log_file" 2>/dev/null | tail -1 | grep -o '[0-9]*' | tr -d ',' || echo "0")
-
-  if [ "$tokens" -gt 0 ]; then
-    TOTAL_TOKENS=$((TOTAL_TOKENS + tokens))
-
-    local cost_cents=$((tokens / 100))
-    TOTAL_COST_CENTS=$((TOTAL_COST_CENTS + cost_cents))
-
-    local total_dollars=$((TOTAL_COST_CENTS / 100))
-    local total_remainder=$((TOTAL_COST_CENTS % 100))
-    local total_cost=$(printf "%d.%02d" $total_dollars $total_remainder)
-
-    log "COST" "Phase $phase: ${tokens} tokens (~\$${total_cost} total)"
-  fi
-
-  # Budget check
-  if [ "$BUDGET_LIMIT" -gt 0 ]; then
-    local budget_cents=$((BUDGET_LIMIT * 100))
-    if [ "$TOTAL_COST_CENTS" -gt "$budget_cents" ]; then
-      local total_dollars=$((TOTAL_COST_CENTS / 100))
-      local total_remainder=$((TOTAL_COST_CENTS % 100))
-      local total_cost=$(printf "%d.%02d" $total_dollars $total_remainder)
-      notify "Budget exceeded: \$${total_cost} / \$${BUDGET_LIMIT}" "error"
-      update_autopilot_state "paused" "$phase" "${PHASES[*]}" "budget_exceeded"
-      exit 0
-    fi
-
-    local warning_threshold=$((budget_cents * 80 / 100))
-    if [ "$TOTAL_COST_CENTS" -gt "$warning_threshold" ]; then
-      notify "Budget warning: 80% used" "warning"
-    fi
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Model Selection & CCR Integration
-# ─────────────────────────────────────────────────────────────────────────────
-
-CLAUDE_CMD="claude"
-CCR_ACTIVATED=false
-
-# Load phase models configuration
-load_phase_models() {
-  if [ ! -f "$PHASE_MODELS_CONFIG" ]; then
-    log "INFO" "No phase models config found at $PHASE_MODELS_CONFIG"
-    return 1
-  fi
-
-  # Parse JSON to extract model for a phase
-  get_model_for_phase() {
-    local phase="$1"
-    local context="${2:-execution}"
-
-    # Try to get model from phases section
-    local model=$(grep -o "\"$phase\"[[:space:]]*:[[:space:]]*{" "$PHASE_MODELS_CONFIG" -A 5 2>/dev/null | grep -o '"model"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/' || echo "")
-
-    if [ -z "$model" ]; then
-      # Fall back to context-specific model
-      model=$(grep -o "\"$context\"[[:space:]]*:[[:space:]]*{" "$PHASE_MODELS_CONFIG" -A 5 2>/dev/null | grep -o '"model"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*: *"\([^"]*\)".*/\1/' || echo "")
-    fi
-
-    if [ -z "$model" ]; then
-      # Final fallback to default model
-      model=$(grep -o '"default_model"[[:space:]]*:[[:space:]]*"[^"]*"' "$PHASE_MODELS_CONFIG" | sed 's/.*: *"\([^"]*\)".*/\1/' || echo "claude-3-5-sonnet-latest")
-    fi
-
-    echo "$model"
-  }
-
-  # Setup CCR environment for a specific model
-  setup_model_for_phase() {
-    local model="$1"
-
-    # Check if CCR is available
-    if ! command -v ccr &> /dev/null; then
-      CLAUDE_CMD="claude"
-      log "WARN" "CCR not found, using default claude command"
-      return 1
-    fi
-
-    # Check if CCR is configured
-    if [ ! -f "$HOME/.claude-code-router/config.json" ]; then
-      CLAUDE_CMD="claude"
-      log "WARN" "CCR config not found at ~/.claude-code-router/config.json"
-      return 1
-    fi
-
-    # Parse provider routing from config
-    local provider_info=$(grep -A 20 "\"provider_routing\"" "$PHASE_MODELS_CONFIG" 2>/dev/null | grep -A 5 "\"$model\"" | head -6 || echo "")
-
-    if [ -n "$provider_info" ]; then
-      local provider=$(echo "$provider_info" | grep -o '"provider"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*: *"\([^"]*\)".*/\1/' || echo "anthropic")
-      local base_url=$(echo "$provider_info" | grep -o '"base_url"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*: *"\([^"]*\)".*/\1/' || echo "https://api.anthropic.com")
-
-      # Export CCR environment variables
-      export ANTHROPIC_BASE_URL="$base_url"
-      export NO_PROXY="127.0.0.1"
-
-      # Use ccr code wrapper
-      CLAUDE_CMD="ccr code --model $model"
-      CCR_ACTIVATED=true
-
-      log "INFO" "Configured CCR for model: $model via $provider"
-      return 0
-    else
-      # Model not in provider routing, try direct CCR routing
-      CLAUDE_CMD="ccr code --model $model"
-      CCR_ACTIVATED=true
-      log "INFO" "Using CCR for model: $model"
-      return 0
-    fi
-  }
-}
-
-# Execute claude command with model routing
-execute_claude() {
-  local model="$1"
-  local prompt="$2"
-  shift 2
-
-  # Setup model-specific environment
-  setup_model_for_phase "$model"
-
-  # Execute with appropriate command
-  if [ "$CCR_ACTIVATED" = true ]; then
-    echo "$prompt" | $CLAUDE_CMD -p "$@" 2>&1
-  else
-    echo "$prompt" | $CLAUDE_CMD -p --model "$model" "$@" 2>&1
-  fi
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Checkpoint Handling
-# ─────────────────────────────────────────────────────────────────────────────
-
-queue_checkpoint() {
-  local phase="$1"
-  local plan="$2"
-  local checkpoint_data="$3"
-
-  local checkpoint_file="$CHECKPOINT_DIR/pending/phase-${phase}-plan-${plan}.json"
-  echo "$checkpoint_data" > "$checkpoint_file"
-
-  log "CHECKPOINT" "Queued: $checkpoint_file"
-  notify "Checkpoint queued: Phase $phase, Plan $plan" "checkpoint"
-}
-
-process_approved_checkpoints() {
-  mkdir -p "$CHECKPOINT_DIR/processed"
-
-  for approval in "$CHECKPOINT_DIR/approved/"*.json; do
-    [ -f "$approval" ] || continue
-
-    if grep -q '"approved": false' "$approval" 2>/dev/null; then
-      log "INFO" "Checkpoint rejected, skipping: $approval"
-      mv "$approval" "$CHECKPOINT_DIR/processed/"
-      continue
-    fi
-
-    local basename=$(basename "$approval" .json)
-    local phase=$(echo "$basename" | sed -n 's/phase-\([0-9]*\)-.*/\1/p')
-    local plan=$(echo "$basename" | sed -n 's/.*plan-\([0-9]*\)/\1/p')
-
-    if [ -z "$phase" ] || [ -z "$plan" ]; then
-      log "WARN" "Could not parse phase/plan from: $approval"
-      mv "$approval" "$CHECKPOINT_DIR/processed/"
-      continue
-    fi
-
-    log "INFO" "Processing approved checkpoint: Phase $phase, Plan $plan"
-
-    local user_response=$(grep -o '"response"[[:space:]]*:[[:space:]]*"[^"]*"' "$approval" | sed 's/.*: *"//' | sed 's/"$//' || echo "")
-    local continuation_log="$LOG_DIR/continuation-phase${phase}-plan${plan}-$(date +%Y%m%d-%H%M%S).log"
-
-    add_activity "commit" "continuing from checkpoint"
-
-    # Get model for checkpoint continuation
-    local model=$(get_model_for_phase "$phase" "continuation")
-    load_phase_models 2>/dev/null || true
-
-    execute_claude "$model" "/gsd:execute-plan $phase $plan --continue --checkpoint-response \"$user_response\"" \
-        --allowedTools "Read,Write,Edit,Glob,Grep,Bash,Task,TodoWrite,AskUserQuestion" \
-        > "$continuation_log"
-
-    if [ ${PIPESTATUS[1]} -ne 0 ]; then
-      log "ERROR" "Continuation failed"
-    else
-      mv "$approval" "$CHECKPOINT_DIR/processed/"
-      track_cost "$continuation_log" "$phase"
-    fi
-  done
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Phase Execution
-# ─────────────────────────────────────────────────────────────────────────────
-
-is_phase_complete() {
-  local phase="$1"
-  grep -qE "^- \[x\] \*\*Phase $phase" .planning/ROADMAP.md 2>/dev/null
-}
-
-execute_phase() {
-  local phase="$1"
-  local phase_idx="$2"
-  local total_phases="$3"
-  local attempt=1
-  local phase_log="$LOG_DIR/phase-${phase}-$(date +%Y%m%d-%H%M%S).log"
-
-  # Safety check before starting
-  ensure_clean_working_tree "before phase $phase"
-
-  # Skip completed phases
-  if is_phase_complete "$phase"; then
-    log "INFO" "Phase $phase already complete, skipping"
-    return 0
-  fi
-
-  # Load phase context
-  CURRENT_PHASE="$phase"
-  load_phase_context "$phase"
-  reset_stages
-
-  # Start activity reader and display
-  start_activity_reader "$total_phases" "$phase_idx"
-
-  # Initial render (hide cursor for clean display)
-  if [ -t 1 ]; then
-    printf "${CURSOR_HIDE}${CURSOR_HOME}${CURSOR_CLEAR}"
-    render_display "$total_phases" "$phase_idx"
-  fi
-
-  while [ $attempt -le $MAX_RETRIES ]; do
-    if [ $attempt -gt 1 ]; then
-      log "INFO" "Retry $attempt/$MAX_RETRIES for phase $phase"
-      add_activity "retry" "attempt $attempt of $MAX_RETRIES"
-    fi
-
-    # Load phase models configuration
-    load_phase_models 2>/dev/null || true
-
-    # Check if phase needs planning
-    local phase_dir=$(ls -d .planning/phases/$(printf "%02d" "$phase" 2>/dev/null || echo "$phase")-* 2>/dev/null | head -1)
-
-    if [ -z "$phase_dir" ] || [ $(ls "$phase_dir"/*-PLAN.md 2>/dev/null | wc -l) -eq 0 ]; then
-      log "INFO" "Planning phase $phase"
-
-      # Get model for phase planning
-      local model=$(get_model_for_phase "$phase" "planning")
-
-      execute_claude "$model" "/gsd:plan-phase $phase" \
-          --allowedTools "Read,Write,Edit,Glob,Grep,Bash,Task,TodoWrite,AskUserQuestion" \
-          >> "$phase_log"
-
-      if [ ${PIPESTATUS[0]} -ne 0 ]; then
-        log "ERROR" "Planning failed for phase $phase"
-        ((attempt++))
-        sleep 5
-        continue
-      fi
-
-      phase_dir=$(ls -d .planning/phases/$(printf "%02d" "$phase" 2>/dev/null || echo "$phase")-* 2>/dev/null | head -1)
-    fi
-
-    # Execution
-    log "INFO" "Executing phase $phase"
-
-    # Get model for phase execution
-    local model=$(get_model_for_phase "$phase" "execution")
-
-    execute_claude "$model" "/gsd:execute-phase $phase" \
-        --allowedTools "Read,Write,Edit,Glob,Grep,Bash,Task,TodoWrite,AskUserQuestion" \
-        >> "$phase_log"
-
-    if [ ${PIPESTATUS[1]} -ne 0 ]; then
-      log "ERROR" "Execution failed for phase $phase"
-      ((attempt++))
-      sleep 5
-      continue
-    fi
-
-    track_cost "$phase_log" "$phase"
-
-    # Check verification status
-    local verification_file=$(ls "$phase_dir"/*-VERIFICATION.md 2>/dev/null | head -1)
-    local status="passed"
-
-    if [ -f "$verification_file" ]; then
-      status=$(grep "^status:" "$verification_file" | head -1 | cut -d: -f2 | tr -d ' ')
-    fi
-
-    case "$status" in
-      "passed")
-        complete_current_stage
-        stop_activity_reader
-        ensure_clean_working_tree "after phase $phase"
-        notify "Phase $phase complete" "success"
-        return 0
-        ;;
-
-      "gaps_found")
-        log "INFO" "Gaps found in phase $phase, planning closure"
-
-        # Get model for gap closure
-        local model=$(get_model_for_phase "$phase" "gaps")
-
-        execute_claude "$model" "/gsd:plan-phase $phase --gaps" \
-            --allowedTools "Read,Write,Edit,Glob,Grep,Bash,Task,TodoWrite,AskUserQuestion" \
-            >> "$phase_log"
-
-        if [ ${PIPESTATUS[0]} -ne 0 ]; then
-          ((attempt++))
-          continue
-        fi
-
-        execute_claude "$model" "/gsd:execute-phase $phase --gaps-only" \
-            --allowedTools "Read,Write,Edit,Glob,Grep,Bash,Task,TodoWrite,AskUserQuestion" \
-            >> "$phase_log"
-
-        if [ ${PIPESTATUS[1]} -ne 0 ]; then
-          ((attempt++))
-          continue
-        fi
-
-        track_cost "$phase_log" "$phase"
-
-        status=$(grep "^status:" "$verification_file" 2>/dev/null | tail -1 | cut -d: -f2 | tr -d ' ')
-
-        if [ "$status" = "passed" ]; then
-          complete_current_stage
-          stop_activity_reader
-          ensure_clean_working_tree "after phase $phase gap closure"
-          notify "Phase $phase complete (after gap closure)" "success"
-          return 0
-        else
-          ((attempt++))
-          continue
-        fi
-        ;;
-
-      "human_needed")
-        if [ "$CHECKPOINT_MODE" = "queue" ]; then
-          queue_checkpoint "$phase" "verification" "{\"type\": \"human_verification\", \"phase\": \"$phase\"}"
-        fi
-        complete_current_stage
-        stop_activity_reader
-        ensure_clean_working_tree "after phase $phase (human verification queued)"
-        return 0
-        ;;
-
-      *)
-        complete_current_stage
-        stop_activity_reader
-        ensure_clean_working_tree "after phase $phase"
-        return 0
-        ;;
-    esac
-  done
-
-  # All retries exhausted
-  stop_activity_reader
-  ensure_clean_working_tree "after phase $phase failure"
-  notify "Phase $phase FAILED after $MAX_RETRIES attempts" "error"
-  return 1
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Main
-# ─────────────────────────────────────────────────────────────────────────────
-
-main() {
-  local total_phases=${#PHASES[@]}
-  local start_time=$(date +%s)
-
-  # Startup banner
-  clear 2>/dev/null || true
-
-  printf "\n"
-  printf "${C_BOLD}${C_CYAN}"
-  printf "   ██████╗ ███████╗██████╗ \n"
-  printf "  ██╔════╝ ██╔════╝██╔══██╗\n"
-  printf "  ██║  ███╗███████╗██║  ██║\n"
-  printf "  ██║   ██║╚════██║██║  ██║\n"
-  printf "  ╚██████╔╝███████║██████╔╝\n"
-  printf "   ╚═════╝ ╚══════╝╚═════╝ \n"
-  printf "${C_RESET}\n"
-  printf "${C_BOLD}${C_WHITE}  AUTOPILOT${C_RESET}\n"
-  printf "${C_DIM}  %s${C_RESET}\n" "$PROJECT_NAME"
-  printf "\n"
-  printf "${C_DIM}  Phases:      %s${C_RESET}\n" "${PHASES[*]}"
-  printf "${C_DIM}  Retries:     %s per phase${C_RESET}\n" "$MAX_RETRIES"
-  printf "${C_DIM}  Budget:      \$%s${C_RESET}\n" "$BUDGET_LIMIT"
-  printf "${C_DIM}  Checkpoints: %s${C_RESET}\n" "$CHECKPOINT_MODE"
-  printf "\n"
-  printf "${C_DIM}  Starting in 3 seconds...${C_RESET}\n"
-
-  sleep 3
-
-  log "INFO" "Autopilot started for $PROJECT_NAME"
-  notify "Autopilot started" "info"
-
-  local remaining_phases=("${PHASES[@]}")
-  local phase_idx=0
-
-  for phase in "${PHASES[@]}"; do
-    process_approved_checkpoints
-
-    remaining_phases=("${remaining_phases[@]:1}")
-    local remaining_str="${remaining_phases[*]:-none}"
-
-    update_autopilot_state "running" "$phase" "$remaining_str"
-
-    if ! execute_phase "$phase" "$phase_idx" "$total_phases"; then
-      update_autopilot_state "failed" "$phase" "$remaining_str" "phase_${phase}_failed"
-
-      if [ -t 1 ]; then
-        printf "${CURSOR_SHOW}"
-        printf "\n${C_RED}${C_BOLD}Autopilot stopped at phase $phase${C_RESET}\n"
-      fi
-
-      notify "Autopilot STOPPED at phase $phase" "error"
-      exit 1
-    fi
-
-    ((phase_idx++))
-  done
-
-  # Final checkpoint processing
-  process_approved_checkpoints
-
-  # Final safety check
-  ensure_clean_working_tree "autopilot completion"
-
-  # Completion
-  local total_time=$(($(date +%s) - start_time))
-  local total_min=$((total_time / 60))
-  local total_sec=$((total_time % 60))
-
-  local total_dollars=$((TOTAL_COST_CENTS / 100))
-  local total_remainder=$((TOTAL_COST_CENTS % 100))
-  local total_cost=$(printf "%d.%02d" $total_dollars $total_remainder)
-
-  update_autopilot_state "completed" "all" "none"
-
-  if [ -t 1 ]; then
-    printf "${CURSOR_SHOW}"
-    clear
-
-    printf "\n"
-    printf "${C_BOLD}${C_GREEN}"
-    printf "  ╔═══════════════════════════════════════════════════╗\n"
-    printf "  ║              MILESTONE COMPLETE                   ║\n"
-    printf "  ╚═══════════════════════════════════════════════════╝\n"
-    printf "${C_RESET}\n"
-
-    printf "${C_WHITE}  Phases:${C_RESET}    %d completed\n" "$total_phases"
-    printf "${C_WHITE}  Time:${C_RESET}      %dm %ds\n" "$total_min" "$total_sec"
-    printf "${C_WHITE}  Tokens:${C_RESET}    %s\n" "$TOTAL_TOKENS"
-    printf "${C_WHITE}  Cost:${C_RESET}      \$%s\n" "$total_cost"
-    printf "\n"
-  fi
-
-  log "SUCCESS" "Milestone complete: $total_phases phases, ${total_min}m ${total_sec}s, \$$total_cost"
-
-  # Complete milestone
-  echo "/gsd:complete-milestone" | claude -p \
-    --allowedTools "Read,Write,Edit,Glob,Grep,Bash,AskUserQuestion" \
-    2>&1 | tee -a "$LOG_DIR/milestone-complete.log"
-
-  notify "Milestone COMPLETE! $total_phases phases, \$$total_cost" "success"
-
-  # Check for pending checkpoints
-  local pending_count=$(ls "$CHECKPOINT_DIR/pending/"*.json 2>/dev/null | wc -l | tr -d ' ')
-  if [ "$pending_count" -gt 0 ]; then
-    printf "\n"
-    printf "${C_YELLOW}  Pending checkpoints: %d${C_RESET}\n" "$pending_count"
-    printf "${C_DIM}  Run: /gsd:checkpoints${C_RESET}\n"
-  fi
-
-  printf "\n"
-  printf "${C_DIM}  Logs: %s/${C_RESET}\n" "$LOG_DIR"
-  printf "\n"
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Run
-# ─────────────────────────────────────────────────────────────────────────────
-
-main "$@"