@walwal-harness/cli 4.0.0-alpha.1 → 4.0.0-alpha.10

package/assets/templates/config.json

@@ -209,6 +209,17 @@
       "frontend_cwd": "",
       "timeout_seconds": 120,
       "on_fail": "reroute_to_generator"
+    },
+    "parallel": {
+      "comment": "v4 Parallel Agent Teams 설정. npx walwal-harness v4 로 실행.",
+      "enabled": false,
+      "concurrency": 3,
+      "max_attempts_per_feature": 3,
+      "gen_model": "sonnet",
+      "eval_model": "opus",
+      "branch_strategy": "feature-branch",
+      "merge_on_pass": true,
+      "rebase_on_conflict": true
     }
   },
   "evaluation": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.10",
   "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

@@ -44,18 +44,21 @@ render_queue_summary() {
   fi
 
   local ready blocked in_prog passed failed total concurrency
-  ready=$(jq '.queue.ready | length' "$QUEUE" 2>/dev/null)
-  blocked=$(jq '.queue.blocked | length' "$QUEUE" 2>/dev/null)
-  in_prog=$(jq '.queue.in_progress | length' "$QUEUE" 2>/dev/null)
-  passed=$(jq '.queue.passed | length' "$QUEUE" 2>/dev/null)
-  failed=$(jq '.queue.failed | length' "$QUEUE" 2>/dev/null)
-  concurrency=$(jq '.concurrency // 3' "$QUEUE" 2>/dev/null)
+  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 filled=$(( pct * bar_w / 100 )) empty=$(( bar_w - filled ))
+  local bar_w=20
+  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
@@ -112,45 +115,106 @@ render_teams() {
 render_feature_list() {
   if [ ! -f "$QUEUE" ] || [ ! -f "$FEATURES" ]; then return; fi
 
-  local total
-  total=$(jq '.features | length' "$FEATURES" 2>/dev/null)
-  if [ "${total:-0}" -eq 0 ]; then return; fi
-
   echo -e "  ${BOLD}Features${RESET}"
 
-  local i=0
-  while [ "$i" -lt "$total" ]; do
-    local fid fname status_icon
-    fid=$(jq -r ".features[$i].id" "$FEATURES" 2>/dev/null)
-    fname=$(jq -r ".features[$i].name // .features[$i].description // \"\"" "$FEATURES" 2>/dev/null)
-    if [ ${#fname} -gt 22 ]; then fname="${fname:0:20}.."; fi
-
-    # Determine status from queue
-    local in_passed in_failed in_progress in_ready in_blocked
-    in_passed=$(jq -r --arg f "$fid" '.queue.passed // [] | map(select(. == $f)) | length' "$QUEUE" 2>/dev/null)
-    in_failed=$(jq -r --arg f "$fid" '.queue.failed // [] | map(select(. == $f)) | length' "$QUEUE" 2>/dev/null)
-    in_progress=$(jq -r --arg f "$fid" '.queue.in_progress[$f] // empty' "$QUEUE" 2>/dev/null)
-    in_ready=$(jq -r --arg f "$fid" '.queue.ready // [] | map(select(. == $f)) | length' "$QUEUE" 2>/dev/null)
-
-    if [ "${in_passed:-0}" -gt 0 ]; then
-      status_icon="${GREEN}●${RESET}"
-    elif [ -n "$in_progress" ] && [ "$in_progress" != "" ]; then
-      local team phase
-      team=$(echo "$in_progress" | jq -r '.team // "?"' 2>/dev/null)
-      phase=$(echo "$in_progress" | jq -r '.phase // "?"' 2>/dev/null)
-      status_icon="${CYAN}◐${RESET} T${team}:${phase}"
-    elif [ "${in_failed:-0}" -gt 0 ]; then
-      status_icon="${RED}✗${RESET}"
-    elif [ "${in_ready:-0}" -gt 0 ]; then
-      status_icon="${YELLOW}○${RESET}"
-    else
-      status_icon="${DIM}◌${RESET}"  # blocked
-    fi
+  # 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 |
+    ($q[0].queue.ready // []) as $ready |
+    ($q[0].queue.in_progress // {}) as $prog |
+    .features[] |
+    .id as $fid |
+    (.name // .description // "?" | if length > 22 then .[0:20] + ".." 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"
+     elif ($fid | IN($ready[])) then "R"
+     else "B" end) as $st |
+    "\($st)\t\($fid)\t\($fname)"
+  ' "$FEATURES" 2>/dev/null | while IFS=$'\t' read -r st fid fname; do
+    case "$st" in
+      P)    printf "  ${GREEN}●${RESET} %-6s %s\n" "$fid" "$fname" ;;
+      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)
+            phase=$(echo "$st" | cut -d'|' -f3)
+            printf "  ${CYAN}◐${RESET} %-6s %-18s 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}"
 
-    printf "  %b %-6s %-24s\n" "$status_icon" "$fid" "$fname"
+  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}')
 
-    i=$((i + 1))
+    # 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 ""
 }
 
@@ -158,6 +222,8 @@ 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}"
 }
@@ -169,8 +235,7 @@ trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
 clear
 
 while true; do
-  local buf
-  buf=$(render_all 2>/dev/null)
+  buf=$(render_all 2>&1)
   tput cup 0 0 2>/dev/null
   echo "$buf"
   tput ed 2>/dev/null

package/scripts/harness-queue-manager.sh

@@ -42,6 +42,25 @@ fi
 FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
 QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
 CONFIG="$PROJECT_ROOT/.harness/config.json"
+QUEUE_LOCK="$PROJECT_ROOT/.harness/.queue-lock"
+
+# ── Atomic queue lock — prevent race conditions between teams ──
+acquire_queue_lock() {
+  local max_wait=30 waited=0
+  while ! mkdir "$QUEUE_LOCK" 2>/dev/null; do
+    sleep 0.1
+    waited=$((waited + 1))
+    if [ "$waited" -ge $((max_wait * 10)) ]; then
+      rm -rf "$QUEUE_LOCK"
+      mkdir "$QUEUE_LOCK" 2>/dev/null || true
+      break
+    fi
+  done
+}
+
+release_queue_lock() {
+  rm -rf "$QUEUE_LOCK" 2>/dev/null || true
+}
 
 # ── Concurrency from config ──
 CONCURRENCY=3
@@ -122,12 +141,14 @@ cmd_dequeue() {
   if [ -z "$team_id" ]; then echo "[queue] Usage: dequeue <team_id>"; exit 1; fi
   if [ ! -f "$QUEUE" ]; then echo "[queue] Run 'init' first."; exit 1; fi
 
+  acquire_queue_lock
+
   local feature
   feature=$(jq -r '.queue.ready[0] // empty' "$QUEUE")
 
   if [ -z "$feature" ]; then
+    release_queue_lock
     echo "[queue] No features in ready queue."
-    # Check if all done
     local in_prog blocked
     in_prog=$(jq '.queue.in_progress | length' "$QUEUE")
     blocked=$(jq '.queue.blocked | length' "$QUEUE")
@@ -137,13 +158,13 @@ cmd_dequeue() {
     return 1
   fi
 
-  # Move feature from ready → in_progress, assign to team
   jq --arg fid "$feature" --arg tid "$team_id" '
     .queue.ready -= [$fid] |
     .queue.in_progress[$fid] = { team: ($tid | tonumber), phase: "gen", attempt: 1 } |
     .teams[$tid] = { status: "busy", feature: $fid, branch: ("feature/" + $fid), pid: null }
   ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
 
+  release_queue_lock
   echo "$feature"
 }
 
@@ -155,11 +176,11 @@ cmd_pass() {
   if [ -z "$fid" ]; then echo "[queue] Usage: pass <feature_id>"; exit 1; fi
   if [ ! -f "$QUEUE" ]; then echo "[queue] Run 'init' first."; exit 1; fi
 
-  # Get team that was working on this feature
+  acquire_queue_lock
+
   local team_id
   team_id=$(jq -r --arg fid "$fid" '.queue.in_progress[$fid].team // empty' "$QUEUE")
 
-  # Move from in_progress → passed, free team, unblock dependents
   jq --arg fid "$fid" --arg tid "${team_id:-0}" '
     # Remove from in_progress
     del(.queue.in_progress[$fid]) |
@@ -188,6 +209,7 @@ cmd_pass() {
 
   local newly_ready
   newly_ready=$(jq -r '.queue.ready | join(", ")' "$QUEUE")
+  release_queue_lock
   echo "[queue] $fid PASSED. Ready: [$newly_ready]"
 }
 
@@ -199,6 +221,8 @@ cmd_fail() {
   if [ -z "$fid" ]; then echo "[queue] Usage: fail <feature_id>"; exit 1; fi
   if [ ! -f "$QUEUE" ]; then exit 1; fi
 
+  acquire_queue_lock
+
   local team_id
   team_id=$(jq -r --arg fid "$fid" '.queue.in_progress[$fid].team // empty' "$QUEUE")
 
@@ -211,6 +235,7 @@ cmd_fail() {
     else . end)
   ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
 
+  release_queue_lock
   echo "[queue] $fid FAILED."
 }
 
@@ -239,6 +264,8 @@ cmd_update_phase() {
     exit 1
   fi
 
+  acquire_queue_lock
+
   local jq_expr
   jq_expr=".queue.in_progress[\"$fid\"].phase = \"$phase\""
   if [ -n "$attempt" ]; then
@@ -246,6 +273,7 @@ cmd_update_phase() {
   fi
 
   jq "$jq_expr" "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+  release_queue_lock
 }
 
 # ══════════════════════════════════════════
@@ -297,6 +325,31 @@ cmd_status() {
   fi
 }
 
+# ══════════════════════════════════════════
+# recover — Move stale in_progress back to ready (after studio restart)
+# ══════════════════════════════════════════
+cmd_recover() {
+  if [ ! -f "$QUEUE" ]; then echo "[queue] Not initialized."; return; fi
+
+  local stale_count
+  stale_count=$(jq '.queue.in_progress | length' "$QUEUE" 2>/dev/null)
+
+  if [ "${stale_count:-0}" -eq 0 ]; then
+    echo "[queue] No stale in_progress entries."
+    return
+  fi
+
+  # Move all in_progress → ready, reset all teams to idle
+  jq '
+    .queue.ready += [.queue.in_progress | keys[]] |
+    .queue.ready |= unique |
+    .queue.in_progress = {} |
+    .teams |= with_entries(.value = { status: "idle", feature: null, branch: null, pid: null })
+  ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+
+  echo "[queue] Recovered ${stale_count} stale features back to ready queue."
+}
+
 # ── Dispatch ──
 case "$CMD" in
   init)         cmd_init ;;
@@ -305,9 +358,10 @@ case "$CMD" in
   fail)         cmd_fail "$@" ;;
   requeue)      cmd_requeue "$@" ;;
   update_phase) cmd_update_phase "$@" ;;
+  recover)      cmd_recover ;;
   status)       cmd_status ;;
   *)
-    echo "Usage: harness-queue-manager.sh <init|dequeue|pass|fail|requeue|update_phase|status> [args]"
+    echo "Usage: harness-queue-manager.sh <init|dequeue|pass|fail|requeue|recover|update_phase|status> [args]"
     exit 1
     ;;
 esac

package/scripts/harness-session-start.sh

@@ -26,6 +26,24 @@ current_agent=$(jq -r '.current_agent // "none"' "$PROGRESS" 2>/dev/null)
 next_agent=$(jq -r '.next_agent // "none"' "$PROGRESS" 2>/dev/null)
 agent_status=$(jq -r '.agent_status // "pending"' "$PROGRESS" 2>/dev/null)
 
+# ─────────────────────────────────────────
+# v4 Parallel Mode — feature-queue.json이 존재하면 v4 안내
+# ─────────────────────────────────────────
+FEATURE_QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+if [ -f "$FEATURE_QUEUE" ]; then
+  passed=$(jq '.queue.passed | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+  total=$(jq '[.queue.ready, (.queue.blocked | keys), (.queue.in_progress | keys), .queue.passed, .queue.failed] | flatten | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+  in_prog=$(jq '.queue.in_progress | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+  failed=$(jq '.queue.failed | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+
+  echo "# Harness v4 — Parallel Agent Teams active"
+  echo "# Queue: ${passed}/${total} passed, ${in_prog} in progress, ${failed} failed"
+  echo "# Teams are running autonomously. You are the orchestrator."
+  echo "# Role: Monitor dashboard, resolve failures, manual interventions only."
+  echo "# Do NOT run /harness-generator-* or /harness-evaluator-* — Teams handle Gen+Eval."
+  exit 0
+fi
+
 # ─────────────────────────────────────────
 # init 상태: 첫 안내
 # ─────────────────────────────────────────

package/scripts/harness-studio-v4.sh

@@ -1,14 +1,17 @@
 #!/bin/bash
-# harness-studio-v4.sh — Harness Studio v4: Parallel Agent Teams
+# harness-studio-v4.sh — Harness Studio v4: 3-Column Layout
 #
-# ┌──────────────────────┬─────────────────────────┐
-# │  Dashboard            │ Team 1 (worker log)     │
-# │  (Queue + Teams +     ├─────────────────────────┤
-# │   Feature status)     │ Team 2 (worker log)     │
-# ├──────────────────────┤                          │
-# │  Control              ├─────────────────────────┤
-# │  harness> _           │ Team 3 (worker log)     │
-# └──────────────────────┴─────────────────────────┘
+# ┌──────────────┬──────────────┬──────────────┐
+# │              │              │  Team 1      │
+# │              │              ├──────────────┤
+# │  Main        │  Dashboard   │  Team 2      │
+# │  (Claude)    │  (read-only) ├──────────────┤
+# │              │              │  Team 3      │
+# └──────────────┴──────────────┴──────────────┘
+#
+# Main: 사용자가 직접 Claude Code를 실행하는 대화형 세션
+# Dashboard: feature-queue + team status 자동 갱신 (입력 불가)
+# Team 1~3: claude -p headless worker (입력 불가, 로그만 표시)
 #
 # Usage:
 #   bash scripts/harness-studio-v4.sh [project-root]
@@ -20,7 +23,6 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 SESSION_NAME="harness-v4"
 
 PROJECT_ROOT=""
-KILL=false
 
 for arg in "$@"; do
   case "$arg" in
@@ -52,45 +54,50 @@ echo "Session: $SESSION_NAME"
 
 tmux kill-session -t "$SESSION_NAME" 2>/dev/null || true
 
-# ── Initialize queue if not exists ──
+# ── Initialize or recover queue ──
 QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
 if [ ! -f "$QUEUE" ]; then
   echo "Initializing feature queue..."
   bash "$SCRIPT_DIR/harness-queue-manager.sh" init "$PROJECT_ROOT"
+else
+  echo "Recovering stale queue state..."
+  bash "$SCRIPT_DIR/harness-queue-manager.sh" recover "$PROJECT_ROOT"
 fi
 
 # ══════════════════════════════════════════
-# Build 5-pane layout using explicit pane IDs
+# 3-Column Layout (Main | Dashboard | Teams)
 # ══════════════════════════════════════════
 
-# 1. Dashboard (top-left)
-PANE_DASH=$(tmux new-session -d -s "$SESSION_NAME" -c "$PROJECT_ROOT" -x 200 -y 50 \
+# Column 1: Main (interactive shell — user runs claude here)
+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)
+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}\"'")
 
-# 2. Team 1 (top-right)
+# 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}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 1 \"${PROJECT_ROOT}\"'")
 
-# 3. Control (bottom-left, 25% of left)
-PANE_CTRL=$(tmux split-window -v -p 25 -t "$PANE_DASH" -c "$PROJECT_ROOT" \
-  -P -F '#{pane_id}' \
-  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-control-v4.sh\" \"${PROJECT_ROOT}\"'")
-
-# 4. Team 2 (middle-right, split from Team 1)
+# Team 2 (split below Team 1)
 PANE_T2=$(tmux split-window -v -p 66 -t "$PANE_T1" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 2 \"${PROJECT_ROOT}\"'")
 
-# 5. Team 3 (bottom-right, split from Team 2)
+# Team 3 (split below Team 2)
 PANE_T3=$(tmux split-window -v -p 50 -t "$PANE_T2" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 3 \"${PROJECT_ROOT}\"'")
 
+# ── Launch Claude in Main pane ──
+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_CTRL" -T "Control"
 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"
@@ -98,18 +105,18 @@ 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
 
-# Focus Control
-tmux select-pane -t "$PANE_CTRL"
+# ── Focus Main pane ──
+tmux select-pane -t "$PANE_MAIN"
 
-# Attach
+# ── Attach ──
 if [ -n "${TMUX:-}" ]; then
   tmux switch-client -t "$SESSION_NAME"
 else
   echo ""
   echo "Launching Harness Studio v4..."
-  echo "  Dashboard (left↑)  : Feature Queue + Team status"
-  echo "  Control (left↓)    : start/pause/assign/requeue"
-  echo "  Team 1-3 (right)   : Parallel worker logs"
+  echo "  Main (left)      : Interactive — run 'claude' here"
+  echo "  Dashboard (mid)  : Feature Queue + Team status (auto-refresh)"
+  echo "  Team 1-3 (right) : Parallel workers (headless, log only)"
   echo ""
   tmux attach -t "$SESSION_NAME"
 fi

package/scripts/harness-team-worker.sh

@@ -40,11 +40,13 @@ 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"
+
 MAX_ATTEMPTS="${MAX_ATTEMPTS:-3}"
 GEN_MODEL="${GEN_MODEL:-sonnet}"
 EVAL_MODEL="${EVAL_MODEL:-opus}"
 
-# Read models from config if available
 if [ -f "$CONFIG" ]; then
   _gm=$(jq -r '.agents["generator-frontend"].model // empty' "$CONFIG" 2>/dev/null)
   _em=$(jq -r '.agents["evaluator-functional"].model // empty' "$CONFIG" 2>/dev/null)
@@ -68,20 +70,33 @@ log() {
 }
 
 log_progress() {
-  local action="$1" detail="$2"
-  local now
-  now=$(date +"%Y-%m-%d")
-  echo "${now} | team-${TEAM_ID} | ${action} | ${detail}" >> "$PROGRESS_LOG"
+  echo "$(date +"%Y-%m-%d") | team-${TEAM_ID} | ${1} | ${2}" >> "$PROGRESS_LOG"
+}
+
+# ── 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"
+}
+
+release_git_lock() {
+  rm -f "$GIT_LOCK"
 }
 
 # ── Pre-eval gate ──
 run_pre_eval_gate() {
-  local feature_id="$1"
   local cwd="$PROJECT_ROOT"
 
-  # Read frontend_cwd from config
   if [ -f "$CONFIG" ]; then
-    local _cwd
     _cwd=$(jq -r '.flow.pre_eval_gate.frontend_cwd // empty' "$CONFIG" 2>/dev/null)
     if [ -n "$_cwd" ] && [ "$_cwd" != "null" ]; then
       cwd="$PROJECT_ROOT/$_cwd"
@@ -97,85 +112,86 @@ run_pre_eval_gate() {
     checks=("npx tsc --noEmit" "npx eslint src/")
   fi
 
-  local all_pass=true
+  local all_pass=true fail_cmds=""
   for cmd in "${checks[@]}"; do
-    if ! (cd "$cwd" && timeout 120s bash -c "$cmd" >/dev/null 2>&1); then
-      log "${RED}Gate FAIL:${RESET} $cmd"
+    if (cd "$cwd" && 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
 
-  if [ "$all_pass" = true ]; then
-    log "${GREEN}Gate: tsc ✓ eslint ✓${RESET}"
-    return 0
-  else
-    return 1
-  fi
+  [ "$all_pass" = true ]
 }
 
 # ── Build generator prompt ──
 build_gen_prompt() {
-  local feature_id="$1"
-  local attempt="$2"
-  local eval_feedback="${3:-}"
+  local fid="$1" attempt="$2" feedback="${3:-}"
 
-  local feature_json
-  feature_json=$(jq --arg fid "$feature_id" '.features[] | select(.id == $fid)' "$FEATURES" 2>/dev/null)
+  local fobj
+  fobj=$(jq --arg fid "$fid" '.features[] | select(.id == $fid)' "$FEATURES" 2>/dev/null)
+  local fname fdesc ac_json deps_json
+  fname=$(echo "$fobj" | jq -r '.name // .description // ""')
+  fdesc=$(echo "$fobj" | jq -r '.description // ""')
+  ac_json=$(echo "$fobj" | jq -c '.ac // []')
+  deps_json=$(echo "$fobj" | jq -c '.depends_on // []')
 
-  local feature_name feature_desc ac_json
-  feature_name=$(echo "$feature_json" | jq -r '.name // .description // ""')
-  feature_desc=$(echo "$feature_json" | jq -r '.description // ""')
-  ac_json=$(echo "$feature_json" | jq -c '.ac // []')
+  local project_name
+  project_name=$(jq -r '.project_name // ""' "$PROJECT_ROOT/.harness/progress.json" 2>/dev/null)
 
-  local prompt="You are Generator-Frontend for a harness engineering project.
+  cat <<PROMPT
+You are Generator-Frontend for a harness engineering project.
 
-PROJECT: $(jq -r '.project_name // ""' "$PROJECT_ROOT/.harness/progress.json" 2>/dev/null)
+PROJECT: ${project_name}
 CONVENTIONS: Read CONVENTIONS.md if it exists.
 
-YOUR TASK: Implement ONLY feature ${feature_id}: ${feature_name}
-Description: ${feature_desc}
+YOUR TASK: Implement ONLY feature ${fid}: ${fname}
+Description: ${fdesc}
+Dependencies (already implemented): ${deps_json}
 Acceptance Criteria: ${ac_json}
 
 Read these files for context:
-- .harness/actions/feature-list.json (filter to ${feature_id})
+- .harness/actions/feature-list.json (filter to ${fid})
 - .harness/actions/api-contract.json (relevant endpoints)
 - .harness/actions/plan.md (overall design)
 
 RULES:
-- Implement ONLY this feature, do not touch other features' code
+- Implement ONLY this single feature
+- Do NOT modify code belonging to other features
 - Follow existing code patterns and CONVENTIONS.md
-- Commit your changes with message: 'feat(${feature_id}): ${feature_name}'
-- Do NOT create tests (evaluator will handle that)"
+- When done, stage and commit with: git add -A && git commit -m 'feat(${fid}): ${fname}'
+PROMPT
 
-  if [ "$attempt" -gt 1 ] && [ -n "$eval_feedback" ]; then
-    prompt="$prompt
+  if [ "$attempt" -gt 1 ] && [ -n "$feedback" ]; then
+    cat <<RETRY
 
 PREVIOUS EVAL FEEDBACK (attempt ${attempt}):
-${eval_feedback}
+${feedback}
 
-Fix the issues from the feedback above. Focus specifically on the failed criteria."
+Fix the issues above. Focus specifically on the failed criteria.
+RETRY
   fi
-
-  echo "$prompt"
 }
 
 # ── Build evaluator prompt ──
 build_eval_prompt() {
-  local feature_id="$1"
-
-  local feature_json
-  feature_json=$(jq --arg fid "$feature_id" '.features[] | select(.id == $fid)' "$FEATURES" 2>/dev/null)
+  local fid="$1"
 
-  local feature_name ac_json
-  feature_name=$(echo "$feature_json" | jq -r '.name // .description // ""')
-  ac_json=$(echo "$feature_json" | jq -c '.ac // []')
+  local fobj
+  fobj=$(jq --arg fid "$fid" '.features[] | select(.id == $fid)' "$FEATURES" 2>/dev/null)
+  local fname ac_json
+  fname=$(echo "$fobj" | jq -r '.name // .description // ""')
+  ac_json=$(echo "$fobj" | jq -c '.ac // []')
 
   local passed_list
   passed_list=$(jq -r '.queue.passed // [] | join(", ")' "$QUEUE" 2>/dev/null)
 
-  echo "You are Evaluator-Functional for a harness engineering project.
+  cat <<PROMPT
+You are Evaluator-Functional for a harness engineering project.
 
-TASK: Evaluate feature ${feature_id}: ${feature_name}
+TASK: Evaluate feature ${fid}: ${fname}
 
 Acceptance Criteria to verify:
 ${ac_json}
@@ -192,23 +208,24 @@ R5: Error handling & edge cases (15%)
 PASS threshold: 2.80 / 3.00
 FAIL: any AC not met, any regression failure
 
-OUTPUT FORMAT (must be parseable):
+You MUST output this exact block (parseable by automation):
 ---EVAL-RESULT---
-FEATURE: ${feature_id}
+FEATURE: ${fid}
 VERDICT: PASS or FAIL
 SCORE: X.XX
-FEEDBACK: <one paragraph summary of issues or confirmation>
----END-EVAL-RESULT---"
+FEEDBACK: one paragraph summary
+---END-EVAL-RESULT---
+PROMPT
 }
 
-# ── Parse eval result ──
+# ── Parse eval result (macOS-compatible, no grep -P) ──
 parse_eval_result() {
   local output="$1"
 
   local verdict score feedback
-  verdict=$(echo "$output" | grep -oP 'VERDICT:\s*\K\w+' | head -1)
-  score=$(echo "$output" | grep -oP 'SCORE:\s*\K[0-9.]+' | head -1)
-  feedback=$(echo "$output" | sed -n 's/^FEEDBACK:\s*//p' | head -1)
+  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}"
 }
@@ -223,14 +240,13 @@ while true; do
   # ── Dequeue next feature ──
   feature_id=$(bash "$QUEUE_MGR" dequeue "$TEAM_ID" "$PROJECT_ROOT" 2>/dev/null)
 
-  if [ -z "$feature_id" ] || [[ "$feature_id" == "[queue]"* ]]; then
-    log "${DIM}No features in queue. Waiting 10s...${RESET}"
+  if [ -z "$feature_id" ] || [[ "$feature_id" == "["* ]]; then
+    log "${DIM}No features ready. Waiting 10s...${RESET}"
     sleep 10
 
     # Check if completely done
-    local remaining
-    remaining=$(jq '(.queue.ready | length) + (.queue.blocked | length) + (.queue.in_progress | length)' "$QUEUE" 2>/dev/null)
-    if [ "${remaining:-1}" -eq 0 ]; then
+    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}"
       log_progress "complete" "All features done"
       exit 0
@@ -241,16 +257,18 @@ while true; do
   log "${CYAN}▶ Dequeued ${feature_id}${RESET}"
   log_progress "dequeue" "${feature_id}"
 
-  # ── Create feature branch ──
-  local branch="feature/${feature_id}"
-  (cd "$PROJECT_ROOT" && git checkout -b "$branch" main 2>/dev/null) || \
+  # ── Create feature branch (with lock) ──
+  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}"
 
   # ── Gen→Eval Loop ──
-  local attempt=1
-  local eval_feedback=""
-  local passed=false
+  attempt=1
+  eval_feedback=""
+  passed=false
 
   while [ "$attempt" -le "$MAX_ATTEMPTS" ]; do
     log "${BOLD}── Attempt ${attempt}/${MAX_ATTEMPTS} ──${RESET}"
@@ -259,18 +277,21 @@ while true; do
     log "Gen ${feature_id} (${GEN_MODEL})..."
     bash "$QUEUE_MGR" update_phase "$feature_id" "gen" "$attempt" "$PROJECT_ROOT" 2>/dev/null
 
-    local gen_prompt
     gen_prompt=$(build_gen_prompt "$feature_id" "$attempt" "$eval_feedback")
 
-    local gen_output
-    gen_output=$(cd "$PROJECT_ROOT" && claude -p "$gen_prompt" --model "$GEN_MODEL" --output-format text 2>&1) || true
+    gen_start=$(date +%s)
+    log "${DIM}  claude -p --dangerously-skip-permissions --model ${GEN_MODEL}${RESET}"
+    gen_output=$(cd "$PROJECT_ROOT" && 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 ))
 
-    local files_changed
-    files_changed=$(cd "$PROJECT_ROOT" && git diff --name-only | wc -l | tr -d ' ')
-    log "Gen complete — ${files_changed} files changed"
-    log_progress "gen" "${feature_id} attempt ${attempt}: ${files_changed} files"
+    files_changed=$(cd "$PROJECT_ROOT" && 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"
 
-    # Auto-commit gen output
+    # Auto-commit
     (cd "$PROJECT_ROOT" && git add -A && git commit -m "feat(${feature_id}): gen attempt ${attempt}" --no-verify 2>/dev/null) || true
 
     # ── Pre-eval gate ──
@@ -288,72 +309,107 @@ while true; do
     log "Eval ${feature_id} (${EVAL_MODEL})..."
     bash "$QUEUE_MGR" update_phase "$feature_id" "eval" "$attempt" "$PROJECT_ROOT" 2>/dev/null
 
-    local eval_prompt
     eval_prompt=$(build_eval_prompt "$feature_id")
 
-    local eval_output
-    eval_output=$(cd "$PROJECT_ROOT" && claude -p "$eval_prompt" --model "$EVAL_MODEL" --output-format text 2>&1) || true
+    eval_start=$(date +%s)
+    log "${DIM}  claude -p --dangerously-skip-permissions --model ${EVAL_MODEL}${RESET}"
+    eval_output=$(cd "$PROJECT_ROOT" && 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
-    local result_line verdict score feedback
     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})"
+    log_progress "eval" "${feature_id} attempt ${attempt}: ${verdict} (${score}) ${eval_elapsed}s"
 
     if [ "$verdict" = "PASS" ]; then
-      log "${GREEN}${BOLD}✓ PASS${RESET} ${feature_id} — ${score}/3.00"
+      log "${GREEN}${BOLD}✓ PASS${RESET} ${feature_id} — ${score}/3.00 (${eval_elapsed}s)"
       passed=true
       break
     else
-      log "${RED}✗ FAIL${RESET} ${feature_id} — ${score}/3.00"
+      log "${RED}✗ FAIL${RESET} ${feature_id} — ${score}/3.00 (${eval_elapsed}s)"
       log "${DIM}  ${feedback}${RESET}"
       eval_feedback="$feedback"
       attempt=$((attempt + 1))
     fi
   done
 
-  # ── Result processing ──
+  # ══════════════════════════════════════════
+  # Phase 3: Branch merge with conflict handling
+  # ══════════════════════════════════════════
   if [ "$passed" = true ]; then
-    # Merge to main
     log "Merging ${branch} → main..."
-    (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS" 2>/dev/null) || {
-      log "${YELLOW}Merge conflict — rebasing...${RESET}"
-      (cd "$PROJECT_ROOT" && git checkout "$branch" && git rebase main 2>/dev/null && \
-       git checkout main && git merge --no-ff "$branch" -m "merge: ${feature_id} PASS (rebased)" 2>/dev/null) || {
-        log "${RED}Merge failed after rebase. Manual intervention needed.${RESET}"
-        bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
-        log_progress "merge-fail" "${feature_id}"
-        continue
-      }
-    }
-
-    # Mark passed in queue
-    bash "$QUEUE_MGR" pass "$feature_id" "$PROJECT_ROOT" 2>/dev/null
-    log_progress "pass" "${feature_id} merged to main"
-
-    # Update feature-list.json passes
-    if [ -f "$FEATURES" ]; then
-      jq --arg fid "$feature_id" '
-        .features |= map(
-          if .id == $fid then
-            .passes = ((.passes // []) + ["generator-frontend", "evaluator-functional"] | unique)
-          else . end
-        )
-      ' "$FEATURES" > "${FEATURES}.tmp" && mv "${FEATURES}.tmp" "$FEATURES"
+    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
+
+      bash "$QUEUE_MGR" pass "$feature_id" "$PROJECT_ROOT" 2>/dev/null
+      log_progress "pass" "${feature_id} merged to main"
+
+      # Update feature-list.json passes
+      if [ -f "$FEATURES" ]; then
+        jq --arg fid "$feature_id" '
+          .features |= map(
+            if .id == $fid then
+              .passes = ((.passes // []) + ["generator-frontend", "evaluator-functional"] | unique)
+            else . end
+          )
+        ' "$FEATURES" > "${FEATURES}.tmp" && mv "${FEATURES}.tmp" "$FEATURES"
+      fi
+
+      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
+      bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
+      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
     bash "$QUEUE_MGR" fail "$feature_id" "$PROJECT_ROOT" 2>/dev/null
     log_progress "fail" "${feature_id} after ${MAX_ATTEMPTS} attempts"
-
-    # Return to main
-    (cd "$PROJECT_ROOT" && git checkout main 2>/dev/null) || true
   fi
 
-  # Brief pause before next feature
   sleep 2
 done

package/scripts/harness-user-prompt-submit.sh

@@ -51,7 +51,37 @@ current_agent=${CURRENT_AGENT} (running) 인데 /harness-${REQUESTED_SKILL} 호
   fi
 fi
 
-# ── Compact context 주입 ──
+# ── v4 Parallel Mode 감지 ──
+FEATURE_QUEUE="$CWD/.harness/actions/feature-queue.json"
+if [ -f "$FEATURE_QUEUE" ]; then
+  V4_PASSED=$(jq '.queue.passed | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+  V4_TOTAL=$(jq '[.queue.ready, (.queue.blocked | keys), (.queue.in_progress | keys), .queue.passed, .queue.failed] | flatten | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+  V4_FAILED=$(jq '.queue.failed | length' "$FEATURE_QUEUE" 2>/dev/null || echo 0)
+
+  # Log user prompt to progress.log (truncated to 80 chars)
+  PROGRESS_LOG="$CWD/.harness/progress.log"
+  if [ -n "$PROMPT" ] && [ -f "$PROGRESS_LOG" ]; then
+    PROMPT_SHORT=$(echo "$PROMPT" | tr '\n' ' ' | sed 's/  */ /g' | cut -c1-80)
+    # Skip logging for empty or very short prompts
+    if [ ${#PROMPT_SHORT} -gt 2 ]; then
+      echo "$(date +"%Y-%m-%d %H:%M") | user-prompt | input | ${PROMPT_SHORT}" >> "$PROGRESS_LOG"
+    fi
+  fi
+
+  cat <<EOF
+[harness-v4] ${V4_PASSED}/${V4_TOTAL} features passed | ${V4_FAILED} failed
+
+## v4 Parallel Mode Active
+- 3 Agent Teams이 feature-queue에서 자율적으로 Gen→Eval 루프 실행 중
+- 당신은 **오케스트레이터** 역할: 대시보드 모니터링, 실패 대응, 수동 개입
+- /harness-generator-*, /harness-evaluator-* 스킬 호출 금지 (Teams가 처리)
+- 할 수 있는 것: 코드 리뷰, 아키텍처 결정, failed feature 분석, requeue 판단
+- skip: "harness skip" 시 일반 대화
+EOF
+  exit 0
+fi
+
+# ── Compact context 주입 (v3 mode) ──
 cat <<EOF
 [harness] S${SPRINT_NUM} | ${PIPELINE} | agent=${CURRENT_AGENT} (${AGENT_STATUS}) | next=${NEXT_AGENT}
 ${CONTEXT_WARNING}

package/skills/evaluator-functional/SKILL.md

@@ -60,6 +60,32 @@ disable-model-invocation: true
 5. `actions/api-contract.json` — 기대 API 동작
 6. `.harness/progress.json`
 
+## v4 Feature-Level Mode (Parallel Agent Teams)
+
+v4에서 Team Worker가 `claude -p`로 호출할 때, 프롬프트에 `FEATURE_ID`가 지정된다.
+
+### Feature-Level Rules
+- `feature-list.json`에서 **지정된 FEATURE_ID의 AC만** 검증
+- Regression: `feature-queue.json`의 `passed` 목록에 있는 Feature들의 AC 재검증
+- Cross-Validation: Feature 단위에서는 skip (Sprint-End에서 수행)
+- Visual Evaluation: Feature 단위에서는 skip (Sprint-End에서 수행)
+- 출력 형식: `---EVAL-RESULT---` 블록 (Worker가 파싱 가능)
+
+### Feature-Level Scoring
+- 동일한 R1-R5 루브릭 적용
+- PASS 기준: 2.80/3.00 (변경 없음)
+- 1건이라도 Regression 실패 시 FAIL (변경 없음)
+
+### Output Format (Machine-Parseable)
+```
+---EVAL-RESULT---
+FEATURE: F-XXX
+VERDICT: PASS or FAIL
+SCORE: X.XX
+FEEDBACK: one paragraph summary
+---END-EVAL-RESULT---
+```
+
 ## Evaluation Steps
 
 ### Step 0: IA Structure Compliance (GATE)

package/skills/generator-frontend/SKILL.md

@@ -43,6 +43,23 @@ disable-model-invocation: true
 
 **Backend 통합 러너가 동작 중이어야 함.** Gateway 미응답 시 → STOP.
 
+## v4 Feature-Level Mode (Parallel Agent Teams)
+
+v4에서 Team Worker가 `claude -p`로 호출할 때, 프롬프트에 `FEATURE_ID`가 지정된다.
+
+### Feature-Level Rules
+- `feature-list.json`에서 **지정된 FEATURE_ID만** 필터하여 구현
+- 다른 Feature의 코드를 수정하지 않음
+- `depends_on`에 명시된 Feature는 이미 구현/머지 완료된 상태
+- Feature branch (`feature/F-XXX`)에서 작업, 완료 시 commit
+- Sprint Contract는 작성하지 않음 (v4에서는 Feature 단위로 관리)
+
+### Feature-Level Prompt Template
+Worker가 전달하는 프롬프트에는 다음이 포함됨:
+- `FEATURE_ID`, `feature_name`, `description`, `ac` (Acceptance Criteria)
+- `depends_on` (이미 완료된 의존 Feature 목록)
+- Eval 재시도 시: 이전 Eval의 피드백
+
 ## Sprint Workflow
 
 1. **Sprint Contract FE 섹션 추가** — 컴포넌트, API 연동, 성공 기준