@walwal-harness/cli 4.0.0-alpha.12 → 4.0.0-alpha.14

package/assets/templates/gitignore-append.txt

@@ -0,0 +1 @@
+# For consumer projects, add .worktrees/ to .gitignore

package/bin/init.js

@@ -231,6 +231,7 @@ function installScripts() {
     'harness-control-v4.sh',
     'harness-queue-manager.sh',
     'harness-team-worker.sh',
+    'harness-prompts-v4.sh',
   ]);
 
   if (fs.existsSync(scriptsSrc)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "4.0.0-alpha.12",
+  "version": "4.0.0-alpha.14",
   "description": "Production harness for AI agent engineering — Planner, Generator(BE/FE), Evaluator(Func/Visual), optional Brainstormer (requirements refinement). Supports React and Flutter FE stacks.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/harness-dashboard-v4.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
-# harness-dashboard-v4.sh — v4 Dashboard: Feature Queue + Team Status
-# Auto-refresh 3초 간격. feature-queue.json + feature-list.json 시각화.
+# harness-dashboard-v4.sh — v4 Dashboard 상단: Planner Progress
+# Queue + Teams + Features 를 auto-refresh. 고정 영역, 스크롤 없음.
 
 set -uo pipefail
 
@@ -30,42 +30,34 @@ render_header() {
   now=$(date +"%H:%M:%S")
   project_name=$(jq -r '.project_name // "Unknown"' "$PROGRESS" 2>/dev/null)
 
-  echo -e "${BOLD}╔════════════════════════════════════════════════╗${RESET}"
-  echo -e "${BOLD}║  HARNESS v4 — Parallel Agent Teams             ║${RESET}"
-  echo -e "${BOLD}╚════════════════════════════════════════════════╝${RESET}"
-  echo -e "  ${DIM}${project_name}  |  ${now}${RESET}"
-  echo ""
+  echo -e "${BOLD}HARNESS v4${RESET} ${DIM}${project_name} | ${now}${RESET}"
 }
 
 render_queue_summary() {
   if [ ! -f "$QUEUE" ]; then
-    echo -e "  ${DIM}(queue not initialized — run 'init' in Control)${RESET}"
+    echo -e "  ${DIM}(queue not initialized)${RESET}"
     return
   fi
 
-  local ready blocked in_prog passed failed total concurrency
+  local ready blocked in_prog passed failed total
   ready=$(jq '.queue.ready | length' "$QUEUE" 2>/dev/null || echo 0)
   blocked=$(jq '.queue.blocked | length' "$QUEUE" 2>/dev/null || echo 0)
   in_prog=$(jq '.queue.in_progress | length' "$QUEUE" 2>/dev/null || echo 0)
   passed=$(jq '.queue.passed | length' "$QUEUE" 2>/dev/null || echo 0)
   failed=$(jq '.queue.failed | length' "$QUEUE" 2>/dev/null || echo 0)
-  concurrency=$(jq '.concurrency // 3' "$QUEUE" 2>/dev/null || echo 3)
   ready=${ready:-0}; blocked=${blocked:-0}; in_prog=${in_prog:-0}; passed=${passed:-0}; failed=${failed:-0}
   total=$((ready + blocked + in_prog + passed + failed))
 
-  # Progress bar
   local pct=0
   if [ "$total" -gt 0 ]; then pct=$(( passed * 100 / total )); fi
-  local bar_w=20
+  local bar_w=16
   local filled=$(( pct * bar_w / 100 ))
   local empty=$(( bar_w - filled ))
   local bar=""
   for ((i=0; i<filled; i++)); do bar+="█"; done
   for ((i=0; i<empty; i++)); do bar+="░"; done
 
-  echo -e "  ${BOLD}Queue${RESET}  ${bar}  ${passed}/${total} (${pct}%)  ${DIM}concurrency=${concurrency}${RESET}"
-  echo -e "  Ready:${GREEN}${ready}${RESET}  Blocked:${YELLOW}${blocked}${RESET}  Progress:${CYAN}${in_prog}${RESET}  Pass:${GREEN}${passed}${RESET}  Fail:${RED}${failed}${RESET}"
-  echo ""
+  echo -e "  ${bar} ${passed}/${total} (${pct}%)  R:${GREEN}${ready}${RESET} B:${YELLOW}${blocked}${RESET} P:${CYAN}${in_prog}${RESET} ${GREEN}✓${passed}${RESET} ${RED}✗${failed}${RESET}"
 }
 
 render_teams() {
@@ -75,49 +67,44 @@ render_teams() {
   team_count=$(jq '.teams | length' "$QUEUE" 2>/dev/null)
   if [ "${team_count:-0}" -eq 0 ]; then return; fi
 
-  echo -e "  ${BOLD}Teams${RESET}"
-
   for i in $(seq 1 "$team_count"); do
     local t_status t_feature t_phase t_attempt
     t_status=$(jq -r ".teams[\"$i\"].status // \"idle\"" "$QUEUE" 2>/dev/null)
     t_feature=$(jq -r ".teams[\"$i\"].feature // \"—\"" "$QUEUE" 2>/dev/null)
 
-    # Get phase from in_progress
     if [ "$t_feature" != "—" ] && [ "$t_feature" != "null" ]; then
       t_phase=$(jq -r --arg f "$t_feature" '.queue.in_progress[$f].phase // "?"' "$QUEUE" 2>/dev/null)
       t_attempt=$(jq -r --arg f "$t_feature" '.queue.in_progress[$f].attempt // 1' "$QUEUE" 2>/dev/null)
     else
-      t_phase="—"
-      t_attempt="—"
+      t_phase="—"; t_attempt=""
     fi
 
     local icon color
     case "$t_status" in
-      busy)   icon="▶" ; color="$GREEN" ;;
-      idle)   icon="○" ; color="$DIM" ;;
-      paused) icon="⏸" ; color="$YELLOW" ;;
-      *)      icon="?" ; color="$RESET" ;;
+      busy)   icon="▶"; color="$GREEN" ;;
+      idle)   icon="○"; color="$DIM" ;;
+      *)      icon="?"; color="$RESET" ;;
     esac
 
-    local phase_display=""
+    local phase_short=""
     case "$t_phase" in
-      gen)  phase_display="${CYAN}GEN${RESET}" ;;
-      gate) phase_display="${YELLOW}GATE${RESET}" ;;
-      eval) phase_display="${MAGENTA}EVAL${RESET}" ;;
-      *)    phase_display="${DIM}${t_phase}${RESET}" ;;
+      gen)  phase_short="${CYAN}G${RESET}" ;;
+      gate) phase_short="${YELLOW}K${RESET}" ;;
+      eval) phase_short="${MAGENTA}E${RESET}" ;;
+      *)    phase_short="${DIM}-${RESET}" ;;
     esac
 
-    printf "  %b %b Team %d  %-8s %b  attempt %s\n" "$color" "$icon" "$i" "$t_feature" "$phase_display" "$t_attempt"
+    printf "  %b%b T%d %-7s %b" "$color" "$icon" "$i" "$t_feature" "$phase_short"
+    if [ -n "$t_attempt" ] && [ "$t_attempt" != "—" ]; then
+      printf " #%s" "$t_attempt"
+    fi
+    echo ""
   done
-  echo ""
 }
 
-render_feature_list() {
+render_features() {
   if [ ! -f "$QUEUE" ] || [ ! -f "$FEATURES" ]; then return; fi
 
-  echo -e "  ${BOLD}Features${RESET}"
-
-  # Single jq call: merge feature-list + queue state → pre-formatted lines
   jq -r --slurpfile q "$QUEUE" '
     ($q[0].queue.passed // []) as $passed |
     ($q[0].queue.failed // []) as $failed |
@@ -125,7 +112,7 @@ render_feature_list() {
     ($q[0].queue.in_progress // {}) as $prog |
     .features[] |
     .id as $fid |
-    (.name // .description // "?" | if length > 22 then .[0:20] + ".." else . end) as $fname |
+    (.name // .description // "?" | if length > 18 then .[0:16] + ".." else . end) as $fname |
     (if ($fid | IN($passed[])) then "P"
      elif $prog[$fid] then "I|\($prog[$fid].team)|\($prog[$fid].phase)"
      elif ($fid | IN($failed[])) then "F"
@@ -138,100 +125,25 @@ render_feature_list() {
       F)    printf "  ${RED}✗${RESET} %-6s %s\n" "$fid" "$fname" ;;
       R)    printf "  ${YELLOW}○${RESET} %-6s %s\n" "$fid" "$fname" ;;
       B)    printf "  ${DIM}◌${RESET} %-6s %s\n" "$fid" "$fname" ;;
-      I\|*) # in_progress: extract team and phase
-            team=$(echo "$st" | cut -d'|' -f2)
+      I\|*) team=$(echo "$st" | cut -d'|' -f2)
             phase=$(echo "$st" | cut -d'|' -f3)
-            printf "  ${CYAN}◐${RESET} %-6s %-18s T%s:%s\n" "$fid" "$fname" "$team" "$phase" ;;
+            printf "  ${CYAN}◐${RESET} %-6s %-14s T%s:%s\n" "$fid" "$fname" "$team" "$phase" ;;
       *)    printf "  ? %-6s %s\n" "$fid" "$fname" ;;
     esac
   done
-
-  echo ""
-}
-
-render_user_prompts() {
-  local log_file="$PROJECT_ROOT/.harness/progress.log"
-  if [ ! -f "$log_file" ]; then return; fi
-
-  # Extract user-prompt entries (newest first, max 5)
-  local user_lines
-  user_lines=$(grep 'user-prompt' "$log_file" 2>/dev/null | tail -r 2>/dev/null | head -5)
-
-  if [ -z "$user_lines" ]; then return; fi
-
-  echo -e "  ${BOLD}Manual Prompts${RESET} ${DIM}(newest first)${RESET}"
-
-  echo "$user_lines" | while IFS= read -r line; do
-    local ts detail
-    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
-    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
-
-    # Short timestamp (HH:MM or MM-DD HH:MM)
-    local short_ts
-    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
-
-    if [ ${#detail} -gt 55 ]; then detail="${detail:0:53}.."; fi
-
-    echo -e "  ${BOLD}★${RESET} ${DIM}${short_ts}${RESET} ${detail}"
-  done
-
-  echo ""
-}
-
-render_team_activity() {
-  local log_file="$PROJECT_ROOT/.harness/progress.log"
-  if [ ! -f "$log_file" ]; then return; fi
-
-  local max_lines=8
-
-  echo -e "  ${BOLD}Activity${RESET} ${DIM}(newest first)${RESET}"
-
-  # All non-user-prompt entries, newest first
-  grep -v '^#' "$log_file" 2>/dev/null | grep -v '^$' | grep -v 'user-prompt' | \
-  tail -r 2>/dev/null | head -"$max_lines" | \
-  while IFS= read -r line; do
-    local ts agent action detail
-    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
-    agent=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$2); print $2}')
-    action=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$3); print $3}')
-    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
-
-    local short_ts icon color
-    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
-
-    case "$agent" in
-      dispatcher*) icon="▸"; color="$MAGENTA" ;;
-      team-*)      icon="⚡"; color="$CYAN" ;;
-      manual)      icon="★"; color="$BOLD" ;;
-      planner*)    icon="□"; color="$YELLOW" ;;
-      gen*)        icon="▶"; color="$GREEN" ;;
-      eval*)       icon="✦"; color="$RED" ;;
-      system)      icon="⚙"; color="$DIM" ;;
-      *)           icon="·"; color="$DIM" ;;
-    esac
-
-    if [ ${#detail} -gt 45 ]; then detail="${detail:0:43}.."; fi
-
-    echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
-  done
-
-  echo ""
 }
 
 render_all() {
   render_header
   render_queue_summary
   render_teams
-  render_user_prompts
-  render_team_activity
-  render_feature_list
-  echo -e "  ${DIM}Refreshing every 3s${RESET}"
+  echo ""
+  render_features
 }
 
 # ── Main loop ──
 tput civis 2>/dev/null
 trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
-
 clear
 
 while true; do

package/scripts/harness-prompts-v4.sh

@@ -0,0 +1,106 @@
+#!/bin/bash
+# harness-prompts-v4.sh — v4 Dashboard 하단: Manual Prompts + Activity
+# progress.log에서 user-prompt와 team 활동을 newest-first로 표시.
+# 스크롤 가능 영역 — 프롬프트가 많아져도 상단 Progress를 가리지 않음.
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+PROJECT_ROOT="${1:-}"
+if [ -z "$PROJECT_ROOT" ]; then
+  source "$SCRIPT_DIR/lib/harness-render-progress.sh"
+  PROJECT_ROOT="$(resolve_harness_root ".")" || { echo "[prompts] .harness/ not found."; exit 1; }
+fi
+
+LOG_FILE="$PROJECT_ROOT/.harness/progress.log"
+
+BOLD="\033[1m"
+DIM="\033[2m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+CYAN="\033[36m"
+MAGENTA="\033[35m"
+RESET="\033[0m"
+
+LAST_LINE_COUNT=0
+
+render_prompts() {
+  if [ ! -f "$LOG_FILE" ]; then
+    echo -e "  ${DIM}(progress.log not found)${RESET}"
+    return
+  fi
+
+  local term_h
+  term_h=$(tput lines 2>/dev/null || echo 20)
+  local max_lines=$((term_h - 3))  # Leave room for header
+  if [ "$max_lines" -lt 5 ]; then max_lines=5; fi
+
+  echo -e "${BOLD}Prompts & Activity${RESET} ${DIM}(newest first)${RESET}"
+  echo ""
+
+  # Read all entries, reverse, limit to terminal height
+  grep -v '^#' "$LOG_FILE" 2>/dev/null | grep -v '^$' | \
+  tail -r 2>/dev/null | head -"$max_lines" | \
+  while IFS= read -r line; do
+    local ts agent action detail
+    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
+    agent=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$2); print $2}')
+    action=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$3); print $3}')
+    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
+
+    local short_ts icon color
+    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
+
+    case "$agent" in
+      user-prompt)
+        icon="★"; color="$BOLD"
+        # User prompts get full width, highlighted
+        if [ ${#detail} -gt 60 ]; then detail="${detail:0:58}.."; fi
+        echo -e "  ${color}${icon} ${short_ts}${RESET} ${detail}"
+        ;;
+      dispatcher*)
+        icon="▸"; color="$MAGENTA"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+      team-*)
+        icon="⚡"; color="$CYAN"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        # Color by action type
+        case "$action" in
+          *pass*)  color="$GREEN"; icon="✓" ;;
+          *fail*)  color="$RED";   icon="✗" ;;
+          *eval*)  color="$MAGENTA"; icon="✦" ;;
+          *gen*)   color="$CYAN";  icon="▶" ;;
+          *merge*) color="$GREEN"; icon="⊕" ;;
+        esac
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+      manual)
+        icon="★"; color="$YELLOW"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${detail}"
+        ;;
+      *)
+        icon="·"; color="$DIM"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+    esac
+  done
+}
+
+# ── Main loop ──
+tput civis 2>/dev/null
+trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
+clear
+
+while true; do
+  buf=$(render_prompts 2>&1)
+  tput cup 0 0 2>/dev/null
+  echo "$buf"
+  tput ed 2>/dev/null
+  sleep 3
+done

package/scripts/harness-studio-v4.sh

@@ -72,11 +72,16 @@ fi
 PANE_MAIN=$(tmux new-session -d -s "$SESSION_NAME" -c "$PROJECT_ROOT" -x 220 -y 55 \
   -P -F '#{pane_id}')
 
-# Column 2: Dashboard (split right from Main, 66% remaining → 33% each of 3 cols)
+# Column 2: Dashboard Progress (split right from Main, 66% remaining)
 PANE_DASH=$(tmux split-window -h -p 66 -t "$PANE_MAIN" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-dashboard-v4.sh\" \"${PROJECT_ROOT}\"'")
 
+# Dashboard bottom: Prompts & Activity (split below Dashboard, 40% bottom)
+PANE_PROMPTS=$(tmux split-window -v -p 40 -t "$PANE_DASH" -c "$PROJECT_ROOT" \
+  -P -F '#{pane_id}' \
+  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-prompts-v4.sh\" \"${PROJECT_ROOT}\"'")
+
 # Column 3: Team 1 (split right from Dashboard, 50% of remaining = 33% total)
 PANE_T1=$(tmux split-window -h -p 50 -t "$PANE_DASH" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
@@ -96,11 +101,12 @@ PANE_T3=$(tmux split-window -v -p 50 -t "$PANE_T2" -c "$PROJECT_ROOT" \
 tmux send-keys -t "$PANE_MAIN" "unset npm_config_prefix 2>/dev/null; clear && claude --dangerously-skip-permissions" Enter
 
 # ── Pane titles ──
-tmux select-pane -t "$PANE_MAIN" -T "Main"
-tmux select-pane -t "$PANE_DASH" -T "Dashboard"
-tmux select-pane -t "$PANE_T1"   -T "Team 1"
-tmux select-pane -t "$PANE_T2"   -T "Team 2"
-tmux select-pane -t "$PANE_T3"   -T "Team 3"
+tmux select-pane -t "$PANE_MAIN"    -T "Main"
+tmux select-pane -t "$PANE_DASH"    -T "Progress"
+tmux select-pane -t "$PANE_PROMPTS" -T "Prompts"
+tmux select-pane -t "$PANE_T1"      -T "Team 1"
+tmux select-pane -t "$PANE_T2"      -T "Team 2"
+tmux select-pane -t "$PANE_T3"      -T "Team 3"
 
 tmux set-option -t "$SESSION_NAME" pane-border-status top 2>/dev/null || true
 tmux set-option -t "$SESSION_NAME" pane-border-format " #{pane_title} " 2>/dev/null || true

package/scripts/harness-team-worker.sh

@@ -1,16 +1,10 @@
 #!/bin/bash
-# harness-team-worker.sh — Team Worker: Feature-level Gen→Eval loop (v4.0)
+# harness-team-worker.sh — Team Worker v4: git worktree 격리 실행
 #
-# 1 Team = 1 프로세스. Feature Queue에서 feature를 꺼내
-# Gen→Gate→Eval 루프를 claude -p 헤드리스로 자율 실행한다.
+# 각 Team이 독립 worktree에서 작업하여 git 충돌 없이 병렬 실행.
+# Feature PASS → main merge → worktree 정리.
 #
-# Usage:
-#   bash scripts/harness-team-worker.sh <team_id> [project-root]
-#
-# Environment:
-#   MAX_ATTEMPTS=3  Feature당 최대 Gen→Eval 시도 횟수
-#   GEN_MODEL=sonnet  Generator 모델
-#   EVAL_MODEL=opus   Evaluator 모델
+# Usage: bash scripts/harness-team-worker.sh <team_id> [project-root]
 
 set -uo pipefail
 
@@ -39,10 +33,11 @@ FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
 CONFIG="$PROJECT_ROOT/.harness/config.json"
 PROGRESS_LOG="$PROJECT_ROOT/.harness/progress.log"
 QUEUE_MGR="$SCRIPT_DIR/harness-queue-manager.sh"
-
-# ── Lock file for git operations (prevent race conditions between teams) ──
 GIT_LOCK="$PROJECT_ROOT/.harness/.git-lock"
 
+# Worktree base directory
+WORKTREE_DIR="$PROJECT_ROOT/.worktrees/team-${TEAM_ID}"
+
 MAX_ATTEMPTS="${MAX_ATTEMPTS:-3}"
 GEN_MODEL="${GEN_MODEL:-sonnet}"
 EVAL_MODEL="${EVAL_MODEL:-opus}"
@@ -54,7 +49,6 @@ if [ -f "$CONFIG" ]; then
   if [ -n "$_em" ]; then EVAL_MODEL="$_em"; fi
 fi
 
-# ── ANSI helpers ──
 BOLD="\033[1m"
 DIM="\033[2m"
 GREEN="\033[32m"
@@ -64,42 +58,101 @@ CYAN="\033[36m"
 RESET="\033[0m"
 
 ts() { date +"%H:%M:%S"; }
+log() { echo -e "[$(ts)] ${BOLD}T${TEAM_ID}${RESET} $*"; }
+log_progress() { echo "$(date +"%Y-%m-%d %H:%M") | team-${TEAM_ID} | ${1} | ${2}" >> "$PROGRESS_LOG"; }
 
-log() {
-  echo -e "[$(ts)] ${BOLD}T${TEAM_ID}${RESET} $*"
+# ── Git lock ──
+acquire_git_lock() {
+  local waited=0
+  while ! mkdir "$GIT_LOCK" 2>/dev/null; do
+    sleep 0.2
+    waited=$((waited + 1))
+    if [ "$waited" -ge 150 ]; then rm -rf "$GIT_LOCK"; mkdir "$GIT_LOCK" 2>/dev/null || true; break; fi
+  done
 }
+release_git_lock() { rm -rf "$GIT_LOCK" 2>/dev/null || true; }
+
+# ── Worktree management ──
+setup_worktree() {
+  local branch="$1"
+
+  acquire_git_lock
+
+  # Clean previous worktree if exists
+  if [ -d "$WORKTREE_DIR" ]; then
+    (cd "$PROJECT_ROOT" && git worktree remove "$WORKTREE_DIR" --force 2>/dev/null) || rm -rf "$WORKTREE_DIR"
+  fi
+
+  # Create fresh worktree from main
+  (cd "$PROJECT_ROOT" && git worktree add "$WORKTREE_DIR" -b "$branch" main 2>/dev/null) || \
+  (cd "$PROJECT_ROOT" && git worktree add "$WORKTREE_DIR" "$branch" 2>/dev/null) || {
+    release_git_lock
+    log "${RED}Failed to create worktree${RESET}"
+    return 1
+  }
+
+  release_git_lock
 
-log_progress() {
-  echo "$(date +"%Y-%m-%d") | team-${TEAM_ID} | ${1} | ${2}" >> "$PROGRESS_LOG"
+  # Copy .harness to worktree (symlink for shared state)
+  ln -sf "$PROJECT_ROOT/.harness" "$WORKTREE_DIR/.harness" 2>/dev/null || true
+
+  log "Worktree: ${WORKTREE_DIR}"
+  return 0
 }
 
-# ── Git lock — serialize git checkout/merge across teams ──
-acquire_git_lock() {
-  local max_wait=60 waited=0
-  while [ -f "$GIT_LOCK" ]; do
-    sleep 1
-    waited=$((waited + 1))
-    if [ "$waited" -ge "$max_wait" ]; then
-      log "${RED}Git lock timeout (${max_wait}s). Removing stale lock.${RESET}"
-      rm -f "$GIT_LOCK"
-      break
-    fi
-  done
-  echo "T${TEAM_ID}" > "$GIT_LOCK"
+cleanup_worktree() {
+  acquire_git_lock
+  if [ -d "$WORKTREE_DIR" ]; then
+    (cd "$PROJECT_ROOT" && git worktree remove "$WORKTREE_DIR" --force 2>/dev/null) || rm -rf "$WORKTREE_DIR"
+  fi
+  release_git_lock
 }
 
-release_git_lock() {
-  rm -f "$GIT_LOCK"
+merge_to_main() {
+  local branch="$1"
+
+  acquire_git_lock
+
+  local merge_ok=false
+
+  # Try merge
+  if (cd "$PROJECT_ROOT" && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS" 2>/dev/null); then
+    merge_ok=true
+  else
+    # Conflict → abort, then try rebase in worktree
+    (cd "$PROJECT_ROOT" && git merge --abort 2>/dev/null) || true
+
+    log "${YELLOW}Merge conflict — rebasing in worktree...${RESET}"
+    if (cd "$WORKTREE_DIR" && git rebase main 2>/dev/null); then
+      # Retry merge after rebase
+      if (cd "$PROJECT_ROOT" && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS (rebased)" 2>/dev/null); then
+        merge_ok=true
+      fi
+    else
+      (cd "$WORKTREE_DIR" && git rebase --abort 2>/dev/null) || true
+      log "${RED}Rebase failed${RESET}"
+    fi
+  fi
+
+  # Clean up branch after merge
+  if [ "$merge_ok" = true ]; then
+    (cd "$PROJECT_ROOT" && git branch -d "$branch" 2>/dev/null) || true
+  fi
+
+  release_git_lock
+
+  [ "$merge_ok" = true ]
 }
 
-# ── Pre-eval gate ──
+# ── Pre-eval gate (runs in worktree) ──
 run_pre_eval_gate() {
-  local cwd="$PROJECT_ROOT"
+  local work_dir="$WORKTREE_DIR"
 
+  # Resolve cwd within worktree
   if [ -f "$CONFIG" ]; then
     _cwd=$(jq -r '.flow.pre_eval_gate.frontend_cwd // empty' "$CONFIG" 2>/dev/null)
     if [ -n "$_cwd" ] && [ "$_cwd" != "null" ]; then
-      cwd="$PROJECT_ROOT/$_cwd"
+      work_dir="$WORKTREE_DIR/$_cwd"
     fi
   fi
 
@@ -107,26 +160,24 @@ run_pre_eval_gate() {
   if [ -f "$CONFIG" ]; then
     mapfile -t checks < <(jq -r '.flow.pre_eval_gate.frontend_checks[]' "$CONFIG" 2>/dev/null)
   fi
-
   if [ ${#checks[@]} -eq 0 ]; then
     checks=("npx tsc --noEmit" "npx eslint src/")
   fi
 
-  local all_pass=true fail_cmds=""
+  local all_pass=true
   for cmd in "${checks[@]}"; do
-    if (cd "$cwd" && timeout 120s bash -c "$cmd" >/dev/null 2>&1); then
+    if (cd "$work_dir" && timeout 120s bash -c "$cmd" >/dev/null 2>&1); then
       log "  ${GREEN}✓${RESET} $cmd"
     else
       log "  ${RED}✗${RESET} $cmd"
       all_pass=false
-      fail_cmds+="$cmd; "
     fi
   done
 
   [ "$all_pass" = true ]
 }
 
-# ── Build generator prompt ──
+# ── Build prompts ──
 build_gen_prompt() {
   local fid="$1" attempt="$2" feedback="${3:-}"
 
@@ -161,7 +212,7 @@ RULES:
 - Implement ONLY this single feature
 - Do NOT modify code belonging to other features
 - Follow existing code patterns and CONVENTIONS.md
-- When done, stage and commit with: git add -A && git commit -m 'feat(${fid}): ${fname}'
+- When done, stage and commit: git add -A && git commit -m 'feat(${fid}): ${fname}'
 PROMPT
 
   if [ "$attempt" -gt 1 ] && [ -n "$feedback" ]; then
@@ -175,7 +226,6 @@ RETRY
   fi
 }
 
-# ── Build evaluator prompt ──
 build_eval_prompt() {
   local fid="$1"
 
@@ -218,15 +268,12 @@ FEEDBACK: one paragraph summary
 PROMPT
 }
 
-# ── Parse eval result (macOS-compatible, no grep -P) ──
 parse_eval_result() {
   local output="$1"
-
   local verdict score feedback
   verdict=$(echo "$output" | grep -E '^VERDICT:' | sed 's/VERDICT:[[:space:]]*//' | head -1)
   score=$(echo "$output" | grep -E '^SCORE:' | sed 's/SCORE:[[:space:]]*//' | head -1)
   feedback=$(echo "$output" | grep -E '^FEEDBACK:' | sed 's/FEEDBACK:[[:space:]]*//' | head -1)
-
   echo "${verdict:-UNKNOWN}|${score:-0.00}|${feedback:-no feedback}"
 }
 
@@ -237,14 +284,12 @@ log "${CYAN}Team ${TEAM_ID} started${RESET} (gen=${GEN_MODEL}, eval=${EVAL_MODEL
 log_progress "start" "Team ${TEAM_ID} worker started"
 
 while true; do
-  # ── Dequeue next feature ──
+  # ── Dequeue ──
   feature_id=$(bash "$QUEUE_MGR" dequeue "$TEAM_ID" "$PROJECT_ROOT" 2>/dev/null)
 
   if [ -z "$feature_id" ] || [[ "$feature_id" == "["* ]]; then
     log "${DIM}No features ready. Waiting 10s...${RESET}"
     sleep 10
-
-    # Check if completely done
     remaining=$(jq '(.queue.ready | length) + (.queue.blocked | length) + (.queue.in_progress | length)' "$QUEUE" 2>/dev/null || echo "1")
     if [ "${remaining}" -eq 0 ] 2>/dev/null; then
       log "${GREEN}${BOLD}ALL FEATURES COMPLETE. Team ${TEAM_ID} exiting.${RESET}"
@@ -254,16 +299,16 @@ while true; do
     continue
   fi
 
-  log "${CYAN}▶ Dequeued ${feature_id}${RESET}"
+  log "${CYAN}▶ ${feature_id}${RESET}"
   log_progress "dequeue" "${feature_id}"
 
-  # ── Create feature branch (with lock) ──
+  # ── Setup worktree ──
   branch="feature/${feature_id}"
-  acquire_git_lock
-  (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null && git checkout -b "$branch" 2>/dev/null) || \
-  (cd "$PROJECT_ROOT" && git checkout "$branch" 2>/dev/null) || true
-  release_git_lock
-  log "Branch: ${branch}"
+  if ! setup_worktree "$branch"; then
+    bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
+    log_progress "fail" "${feature_id} worktree setup failed"
+    continue
+  fi
 
   # ── Gen→Eval Loop ──
   attempt=1
@@ -271,119 +316,82 @@ while true; do
   passed=false
 
   while [ "$attempt" -le "$MAX_ATTEMPTS" ]; do
-    log "${BOLD}── Attempt ${attempt}/${MAX_ATTEMPTS} ──${RESET}"
+    log "${BOLD}── ${feature_id} attempt ${attempt}/${MAX_ATTEMPTS} ──${RESET}"
 
-    # ── Generate ──
-    log "Gen ${feature_id} (${GEN_MODEL})..."
+    # ── Generate (in worktree) ──
+    log "Gen (${GEN_MODEL})..."
     bash "$QUEUE_MGR" update_phase "$feature_id" "gen" "$attempt" "$PROJECT_ROOT" 2>/dev/null
 
     gen_prompt=$(build_gen_prompt "$feature_id" "$attempt" "$eval_feedback")
 
     gen_start=$(date +%s)
-    log "${DIM}  claude -p --dangerously-skip-permissions --model ${GEN_MODEL}${RESET}"
-    gen_output=$(cd "$PROJECT_ROOT" && claude -p "$gen_prompt" \
+    gen_output=$(cd "$WORKTREE_DIR" && claude -p "$gen_prompt" \
       --dangerously-skip-permissions \
       --model "$GEN_MODEL" \
       --output-format text 2>&1 | tee /dev/stderr) 2>&1 || true
     gen_elapsed=$(( $(date +%s) - gen_start ))
 
-    files_changed=$(cd "$PROJECT_ROOT" && git diff --name-only 2>/dev/null | wc -l | tr -d ' ')
+    files_changed=$(cd "$WORKTREE_DIR" && git diff --name-only 2>/dev/null | wc -l | tr -d ' ')
     log "Gen done (${gen_elapsed}s) — ${files_changed} files"
-    log_progress "gen" "${feature_id} attempt ${attempt}: ${files_changed} files, ${gen_elapsed}s"
+    log_progress "gen" "${feature_id} #${attempt}: ${files_changed} files, ${gen_elapsed}s"
 
-    # Auto-commit
-    (cd "$PROJECT_ROOT" && git add -A && git commit -m "feat(${feature_id}): gen attempt ${attempt}" --no-verify 2>/dev/null) || true
+    # Auto-commit in worktree
+    (cd "$WORKTREE_DIR" && git add -A && git commit -m "feat(${feature_id}): attempt ${attempt}" --no-verify 2>/dev/null) || true
 
-    # ── Pre-eval gate ──
-    log "Pre-eval gate..."
+    # ── Pre-eval gate (in worktree) ──
+    log "Gate..."
     bash "$QUEUE_MGR" update_phase "$feature_id" "gate" "$attempt" "$PROJECT_ROOT" 2>/dev/null
 
-    if ! run_pre_eval_gate "$feature_id"; then
-      log "${RED}Gate FAIL — retrying gen${RESET}"
-      eval_feedback="Pre-eval gate failed: type check or lint errors. Fix compilation and lint issues."
+    if ! run_pre_eval_gate; then
+      log "${RED}Gate FAIL${RESET}"
+      eval_feedback="Pre-eval gate failed: type check or lint errors."
       attempt=$((attempt + 1))
       continue
     fi
 
-    # ── Evaluate ──
-    log "Eval ${feature_id} (${EVAL_MODEL})..."
+    # ── Evaluate (in worktree) ──
+    log "Eval (${EVAL_MODEL})..."
     bash "$QUEUE_MGR" update_phase "$feature_id" "eval" "$attempt" "$PROJECT_ROOT" 2>/dev/null
 
     eval_prompt=$(build_eval_prompt "$feature_id")
 
     eval_start=$(date +%s)
-    log "${DIM}  claude -p --dangerously-skip-permissions --model ${EVAL_MODEL}${RESET}"
-    eval_output=$(cd "$PROJECT_ROOT" && claude -p "$eval_prompt" \
+    eval_output=$(cd "$WORKTREE_DIR" && claude -p "$eval_prompt" \
       --dangerously-skip-permissions \
       --model "$EVAL_MODEL" \
       --output-format text 2>&1 | tee /dev/stderr) 2>&1 || true
     eval_elapsed=$(( $(date +%s) - eval_start ))
 
-    # Parse result
     result_line=$(parse_eval_result "$eval_output")
     verdict=$(echo "$result_line" | cut -d'|' -f1)
     score=$(echo "$result_line" | cut -d'|' -f2)
     feedback=$(echo "$result_line" | cut -d'|' -f3-)
 
-    log_progress "eval" "${feature_id} attempt ${attempt}: ${verdict} (${score}) ${eval_elapsed}s"
+    log_progress "eval" "${feature_id} #${attempt}: ${verdict} (${score}) ${eval_elapsed}s"
 
     if [ "$verdict" = "PASS" ]; then
-      log "${GREEN}${BOLD}✓ PASS${RESET} ${feature_id} — ${score}/3.00 (${eval_elapsed}s)"
+      log "${GREEN}${BOLD}✓ PASS ${score}/3.00${RESET} (${eval_elapsed}s)"
       passed=true
       break
     else
-      log "${RED}✗ FAIL${RESET} ${feature_id} — ${score}/3.00 (${eval_elapsed}s)"
+      log "${RED}✗ FAIL ${score}/3.00${RESET} (${eval_elapsed}s)"
       log "${DIM}  ${feedback}${RESET}"
       eval_feedback="$feedback"
       attempt=$((attempt + 1))
     fi
   done
 
-  # ══════════════════════════════════════════
-  # Phase 3: Branch merge with conflict handling
-  # ══════════════════════════════════════════
+  # ── Result ──
   if [ "$passed" = true ]; then
-    log "Merging ${branch} → main..."
-    acquire_git_lock
-
-    merge_ok=false
-
-    # Attempt 1: straight merge
-    if (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS" 2>/dev/null); then
-      merge_ok=true
-    else
-      # Attempt 2: abort failed merge, rebase, re-eval gate, then merge
-      log "${YELLOW}Conflict detected — rebasing ${branch} onto main...${RESET}"
-      (cd "$PROJECT_ROOT" && git merge --abort 2>/dev/null) || true
-      (cd "$PROJECT_ROOT" && git checkout "$branch" 2>/dev/null) || true
-
-      if (cd "$PROJECT_ROOT" && git rebase main 2>/dev/null); then
-        log "Rebase OK. Re-running gate..."
-
-        if run_pre_eval_gate "$feature_id"; then
-          log "Gate still PASS after rebase."
-          if (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS (rebased)" 2>/dev/null); then
-            merge_ok=true
-          fi
-        else
-          log "${RED}Gate FAIL after rebase — needs re-gen${RESET}"
-        fi
-      else
-        log "${RED}Rebase failed — conflicts too complex${RESET}"
-        (cd "$PROJECT_ROOT" && git rebase --abort 2>/dev/null) || true
-      fi
-    fi
-
-    release_git_lock
-
-    if [ "$merge_ok" = true ]; then
-      # Clean up feature branch
-      (cd "$PROJECT_ROOT" && git branch -d "$branch" 2>/dev/null) || true
+    log "Merging → main..."
 
+    if merge_to_main "$branch"; then
+      # Cleanup worktree after successful merge
+      cleanup_worktree
       bash "$QUEUE_MGR" pass "$feature_id" "$PROJECT_ROOT" 2>/dev/null
-      log_progress "pass" "${feature_id} merged to main"
+      log_progress "pass" "${feature_id} merged & cleaned"
 
-      # Update feature-list.json passes
+      # Update feature-list.json
       if [ -f "$FEATURES" ]; then
         jq --arg fid "$feature_id" '
           .features |= map(
@@ -396,18 +404,15 @@ while true; do
 
       log "${GREEN}${BOLD}✓ ${feature_id} DONE${RESET}"
     else
-      log "${RED}${BOLD}Merge failed — ${feature_id} marked as failed${RESET}"
-      (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null) || true
+      cleanup_worktree
       bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
+      log "${RED}Merge failed → ${feature_id} FAILED${RESET}"
       log_progress "merge-fail" "${feature_id}"
     fi
-
   else
-    log "${RED}${BOLD}✗ ${feature_id} FAILED after ${MAX_ATTEMPTS} attempts${RESET}"
-    acquire_git_lock
-    (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null) || true
-    release_git_lock
+    cleanup_worktree
     bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
+    log "${RED}${BOLD}✗ ${feature_id} FAILED (${MAX_ATTEMPTS} attempts)${RESET}"
     log_progress "fail" "${feature_id} after ${MAX_ATTEMPTS} attempts"
   fi