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

package/bin/init.js

@@ -226,6 +226,11 @@ function installScripts() {
     'harness-eval-watcher.sh',
     'harness-tmux.sh',
     'harness-control.sh',
+    'harness-studio-v4.sh',
+    'harness-dashboard-v4.sh',
+    'harness-control-v4.sh',
+    'harness-queue-manager.sh',
+    'harness-team-worker.sh',
   ]);
 
   if (fs.existsSync(scriptsSrc)) {
@@ -568,8 +573,9 @@ function showHelp() {
 Usage:
   npx walwal-harness            Initialize project for harness engineering
   npx walwal-harness --force    Re-initialize (overwrites existing files)
-  npx walwal-harness studio     Launch Harness Studio (tmux 4-pane monitor)
-  npx walwal-harness studio --ai  Studio + AI eval summary (API cost)
+  npx walwal-harness studio     Launch Harness Studio v3 (tmux 5-pane)
+  npx walwal-harness studio --ai  Studio v3 + AI eval summary
+  npx walwal-harness v4          Launch Studio v4 (3 Parallel Agent Teams)
   npx walwal-harness --help     Show this help
 
 What it does:
@@ -619,6 +625,27 @@ function runStudio() {
   execSync(cmd, { stdio: 'inherit' });
 }
 
+function runStudioV4() {
+  const scriptsDir = path.join(PKG_ROOT, 'scripts');
+  const tmuxScript = path.join(scriptsDir, 'harness-studio-v4.sh');
+
+  if (!fs.existsSync(tmuxScript)) {
+    log('ERROR: harness-studio-v4.sh not found. Update @walwal-harness/cli to >= 4.0.0');
+    process.exit(1);
+  }
+
+  try {
+    execSync('which tmux', { stdio: 'ignore' });
+  } catch {
+    log('ERROR: tmux is required. Install with: brew install tmux');
+    process.exit(1);
+  }
+
+  const cmd = `bash "${tmuxScript}" "${PROJECT_ROOT}"`.trim();
+  log('Launching Harness Studio v4 (Parallel Agent Teams)...');
+  execSync(cmd, { stdio: 'inherit' });
+}
+
 function main() {
   if (isHelp) {
     showHelp();
@@ -630,6 +657,11 @@ function main() {
     return;
   }
 
+  if (subcommand === 'studio-v4' || subcommand === 'v4') {
+    runStudioV4();
+    return;
+  }
+
   const pkg = require(path.join(PKG_ROOT, 'package.json'));
   console.log('');
   console.log('╔══════════════════════════════════════╗');

package/package.json

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

@@ -0,0 +1,97 @@
+#!/bin/bash
+# harness-control-v4.sh — v4 Control Center
+#
+# Commands:
+#   init              Initialize feature queue
+#   start             Launch all idle team workers
+#   pause <team>      Pause team worker
+#   resume <team>     Resume team worker
+#   assign <fid> <t>  Force-assign feature to team
+#   requeue <fid>     Move failed feature back to ready
+#   concurrency <N>   Change parallel team count
+#   status / s        Show queue status
+#   log <message>     Add manual note
+#   help / h          Show help
+#   quit / q          Exit
+
+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 "[control] .harness/ not found."; exit 1; }
+fi
+
+QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+PROGRESS_LOG="$PROJECT_ROOT/.harness/progress.log"
+QUEUE_MGR="$SCRIPT_DIR/harness-queue-manager.sh"
+
+BOLD="\033[1m"
+DIM="\033[2m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+CYAN="\033[36m"
+RESET="\033[0m"
+
+cmd_init() {
+  bash "$QUEUE_MGR" init "$PROJECT_ROOT"
+}
+
+cmd_status() {
+  bash "$QUEUE_MGR" status "$PROJECT_ROOT"
+}
+
+cmd_requeue() {
+  local fid="${1:-}"
+  if [ -z "$fid" ]; then echo -e "  ${RED}Usage: requeue <feature_id>${RESET}"; return; fi
+  bash "$QUEUE_MGR" requeue "$fid" "$PROJECT_ROOT"
+}
+
+cmd_log() {
+  local msg="$1"
+  if [ -z "$msg" ]; then echo -e "  ${RED}Usage: log <message>${RESET}"; return; fi
+  local ts
+  ts=$(date +"%Y-%m-%d")
+  echo "${ts} | manual | note | ${msg}" >> "$PROGRESS_LOG"
+  echo -e "  ${GREEN}Logged:${RESET} ${msg}"
+}
+
+show_help() {
+  echo ""
+  echo -e "  ${BOLD}Harness v4 Control${RESET}"
+  echo -e "  ${CYAN}init${RESET}                Initialize feature queue from feature-list.json"
+  echo -e "  ${CYAN}status${RESET}  / ${CYAN}s${RESET}         Show queue + team status"
+  echo -e "  ${CYAN}requeue${RESET} <fid>       Move failed feature back to ready"
+  echo -e "  ${CYAN}log${RESET} <message>       Add manual note to progress.log"
+  echo -e "  ${CYAN}help${RESET}   / ${CYAN}h${RESET}         Show this help"
+  echo -e "  ${CYAN}quit${RESET}   / ${CYAN}q${RESET}         Exit control"
+  echo ""
+  echo -e "  ${DIM}Teams auto-start when studio launches.${RESET}"
+  echo -e "  ${DIM}Workers auto-dequeue from the ready queue.${RESET}"
+  echo ""
+}
+
+# ── Main ──
+echo ""
+echo -e "  ${BOLD}Harness v4 Control${RESET}  ${DIM}(type 'help' for commands)${RESET}"
+echo ""
+
+while true; do
+  echo -ne "  ${BOLD}v4>${RESET} "
+  read -r input || exit 0
+  input=$(echo "$input" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+  case "$input" in
+    init)           cmd_init ;;
+    status|s)       cmd_status ;;
+    requeue\ *)     cmd_requeue "${input#requeue }" ;;
+    log\ *)         cmd_log "${input#log }" ;;
+    help|h)         show_help ;;
+    quit|q)         echo -e "  ${DIM}Goodbye.${RESET}"; exit 0 ;;
+    "")             ;; # empty
+    *)              echo -e "  ${DIM}Unknown command. Type 'help'.${RESET}" ;;
+  esac
+done

package/scripts/harness-control.sh

@@ -38,8 +38,23 @@ RED="\033[31m"
 CYAN="\033[36m"
 RESET="\033[0m"
 
-# ── Agent Session pane target ──
-AGENT_PANE="harness-studio.2"
+# ── Agent Session pane target (find by title) ──
+find_agent_pane() {
+  tmux list-panes -t harness-studio -F '#{pane_id} #{pane_title}' 2>/dev/null \
+    | grep "Agent Session" | awk '{print $1}' | head -1
+}
+
+CONFIG="$PROJECT_ROOT/.harness/config.json"
+
+# Build claude command from config
+build_claude_cmd() {
+  local agent="$1"
+  local model="opus"
+  if [ -f "$CONFIG" ]; then
+    model=$(jq -r ".agents[\"${agent}\"].model // \"opus\"" "$CONFIG" 2>/dev/null)
+  fi
+  echo "claude --dangerously-skip-permissions --model ${model}"
+}
 
 cmd_log() {
   local msg="$1"
@@ -63,8 +78,10 @@ cmd_clear_fail() {
 }
 
 cmd_next() {
-  if ! tmux list-panes -t harness-studio 2>/dev/null | grep -q .; then
-    echo -e "  ${RED}tmux session not found.${RESET}"
+  local pane
+  pane=$(find_agent_pane)
+  if [ -z "$pane" ]; then
+    echo -e "  ${RED}Agent Session pane not found.${RESET}"
     return
   fi
 
@@ -75,16 +92,25 @@ cmd_next() {
     return
   fi
 
-  echo -e "  ${CYAN}Starting ${next_agent} in Agent Session...${RESET}"
+  local claude_cmd
+  claude_cmd=$(build_claude_cmd "$next_agent")
+
+  echo -e "  ${CYAN}Starting ${next_agent}...${RESET}"
+  echo -e "  ${DIM}${claude_cmd}${RESET}"
+
   local ts
   ts=$(date +"%Y-%m-%d")
   echo "${ts} | manual | start-agent | ${next_agent}" >> "$PROGRESS_LOG"
-  tmux send-keys -t "$AGENT_PANE" "/harness-${next_agent}" Enter
+
+  # Launch claude in Agent Session pane with the agent's prompt
+  tmux send-keys -t "$pane" "${claude_cmd} -p '하네스 엔지니어링 시작'" Enter
 }
 
 cmd_retry() {
-  if ! tmux list-panes -t harness-studio 2>/dev/null | grep -q .; then
-    echo -e "  ${RED}tmux session not found.${RESET}"
+  local pane
+  pane=$(find_agent_pane)
+  if [ -z "$pane" ]; then
+    echo -e "  ${RED}Agent Session pane not found.${RESET}"
     return
   fi
 
@@ -95,21 +121,26 @@ cmd_retry() {
     return
   fi
 
+  local claude_cmd
+  claude_cmd=$(build_claude_cmd "$current_agent")
+
   echo -e "  ${CYAN}Retrying ${current_agent}...${RESET}"
   local ts
   ts=$(date +"%Y-%m-%d")
   echo "${ts} | manual | retry | ${current_agent}" >> "$PROGRESS_LOG"
-  tmux send-keys -t "$AGENT_PANE" "/harness-${current_agent}" Enter
+  tmux send-keys -t "$pane" "${claude_cmd} -p '하네스 엔지니어링 시작'" Enter
 }
 
 cmd_stop() {
-  if ! tmux list-panes -t harness-studio 2>/dev/null | grep -q .; then
-    echo -e "  ${RED}tmux session not found.${RESET}"
+  local pane
+  pane=$(find_agent_pane)
+  if [ -z "$pane" ]; then
+    echo -e "  ${RED}Agent Session pane not found.${RESET}"
     return
   fi
 
   echo -e "  ${YELLOW}Sending Ctrl+C to Agent Session...${RESET}"
-  tmux send-keys -t "$AGENT_PANE" C-c
+  tmux send-keys -t "$pane" C-c
   local ts
   ts=$(date +"%Y-%m-%d")
   echo "${ts} | manual | stop | user-initiated" >> "$PROGRESS_LOG"

package/scripts/harness-dashboard-v4.sh

@@ -0,0 +1,178 @@
+#!/bin/bash
+# harness-dashboard-v4.sh — v4 Dashboard: Feature Queue + Team Status
+# Auto-refresh 3초 간격. feature-queue.json + feature-list.json 시각화.
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/harness-render-progress.sh"
+
+PROJECT_ROOT="${1:-}"
+if [ -z "$PROJECT_ROOT" ]; then
+  PROJECT_ROOT="$(resolve_harness_root ".")" || { echo "[dash] .harness/ not found."; exit 1; }
+fi
+
+QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
+PROGRESS="$PROJECT_ROOT/.harness/progress.json"
+
+BOLD="\033[1m"
+DIM="\033[2m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+CYAN="\033[36m"
+MAGENTA="\033[35m"
+RESET="\033[0m"
+
+render_header() {
+  local now project_name
+  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 ""
+}
+
+render_queue_summary() {
+  if [ ! -f "$QUEUE" ]; then
+    echo -e "  ${DIM}(queue not initialized — run 'init' in Control)${RESET}"
+    return
+  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)
+  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=""
+  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 ""
+}
+
+render_teams() {
+  if [ ! -f "$QUEUE" ]; then return; fi
+
+  local team_count
+  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="—"
+    fi
+
+    local icon color
+    case "$t_status" in
+      busy)   icon="▶" ; color="$GREEN" ;;
+      idle)   icon="○" ; color="$DIM" ;;
+      paused) icon="⏸" ; color="$YELLOW" ;;
+      *)      icon="?" ; color="$RESET" ;;
+    esac
+
+    local phase_display=""
+    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}" ;;
+    esac
+
+    printf "  %b %b Team %d  %-8s %b  attempt %s\n" "$color" "$icon" "$i" "$t_feature" "$phase_display" "$t_attempt"
+  done
+  echo ""
+}
+
+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
+
+    printf "  %b %-6s %-24s\n" "$status_icon" "$fid" "$fname"
+
+    i=$((i + 1))
+  done
+  echo ""
+}
+
+render_all() {
+  render_header
+  render_queue_summary
+  render_teams
+  render_feature_list
+  echo -e "  ${DIM}Refreshing every 3s${RESET}"
+}
+
+# ── Main loop ──
+tput civis 2>/dev/null
+trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
+
+clear
+
+while true; do
+  local buf
+  buf=$(render_all 2>/dev/null)
+  tput cup 0 0 2>/dev/null
+  echo "$buf"
+  tput ed 2>/dev/null
+  sleep 3
+done

package/scripts/harness-queue-manager.sh

@@ -0,0 +1,313 @@
+#!/bin/bash
+# harness-queue-manager.sh — Feature Queue Manager (v4.0)
+#
+# feature-list.json에서 depends_on 그래프를 읽어 topological sort 후
+# feature-queue.json을 생성/관리한다.
+#
+# Commands:
+#   init          feature-list.json → feature-queue.json 초기 생성
+#   dequeue <team> ready 큐에서 feature를 꺼내 team에 배정
+#   pass <fid>    feature를 passed로 이동, blocked→ready 전이
+#   fail <fid>    feature를 failed로 이동
+#   requeue <fid> failed feature를 ready로 복귀
+#   status        현재 큐 상태 출력
+#
+# Usage: bash scripts/harness-queue-manager.sh <command> [args...] [project-root]
+
+set -uo pipefail
+
+# ── Resolve project root ──
+resolve_root() {
+  local dir="${1:-.}"
+  dir="$(cd "$dir" 2>/dev/null && pwd || echo "$dir")"
+  while [ "$dir" != "/" ]; do
+    if [ -d "$dir/.harness" ]; then echo "$dir"; return 0; fi
+    dir="$(dirname "$dir")"
+  done
+  return 1
+}
+
+CMD="${1:-status}"
+shift || true
+
+# Last arg might be project root
+PROJECT_ROOT=""
+for arg in "$@"; do
+  if [ -d "$arg/.harness" ]; then PROJECT_ROOT="$arg"; fi
+done
+if [ -z "$PROJECT_ROOT" ]; then
+  PROJECT_ROOT="$(resolve_root ".")" || { echo "[queue] .harness/ not found."; exit 1; }
+fi
+
+FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
+QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+CONFIG="$PROJECT_ROOT/.harness/config.json"
+
+# ── Concurrency from config ──
+CONCURRENCY=3
+if [ -f "$CONFIG" ]; then
+  _c=$(jq -r '.flow.parallel.concurrency // 3' "$CONFIG" 2>/dev/null)
+  if [ "$_c" -gt 0 ] 2>/dev/null; then CONCURRENCY=$_c; fi
+fi
+
+# ══════════════════════════════════════════
+# init — Build queue from feature-list.json
+# ══════════════════════════════════════════
+cmd_init() {
+  if [ ! -f "$FEATURES" ]; then
+    echo "[queue] feature-list.json not found."
+    exit 1
+  fi
+
+  # Build dependency graph and topological sort
+  # Output: feature-queue.json with ready (no deps) and blocked (has deps)
+  jq --argjson concurrency "$CONCURRENCY" '
+    # Build passed set (features already passed by evaluator)
+    def passed_set:
+      [.features[] | select(
+        ((.passes // []) | length > 0) and
+        ((.passes // []) | any(. == "evaluator-functional"))
+      ) | .id] ;
+
+    # Separate ready vs blocked
+    def classify(passed):
+      reduce .features[] as $f (
+        { ready: [], blocked: {} };
+        ($f.depends_on // []) as $deps |
+        if ($f.id | IN(passed[])) then .  # already passed, skip
+        elif ($deps | length == 0) then
+          .ready += [$f.id]
+        elif (passed | length > 0) and ($deps | all(. as $d | $d | IN(passed[]))) then
+          .ready += [$f.id]  # all deps satisfied
+        else
+          .blocked[$f.id] = ($deps - passed)
+        end
+      ) ;
+
+    passed_set as $passed |
+    classify($passed) as $classified |
+    {
+      version: "4.0",
+      concurrency: $concurrency,
+      queue: {
+        ready: $classified.ready,
+        blocked: $classified.blocked,
+        in_progress: {},
+        passed: $passed,
+        failed: []
+      },
+      teams: (
+        [range(1; $concurrency + 1)] | map({
+          key: (. | tostring),
+          value: { status: "idle", feature: null, branch: null, pid: null }
+        }) | from_entries
+      )
+    }
+  ' "$FEATURES" > "$QUEUE"
+
+  local ready_count blocked_count passed_count
+  ready_count=$(jq '.queue.ready | length' "$QUEUE")
+  blocked_count=$(jq '.queue.blocked | length' "$QUEUE")
+  passed_count=$(jq '.queue.passed | length' "$QUEUE")
+
+  echo "[queue] Initialized: $ready_count ready, $blocked_count blocked, $passed_count already passed"
+  echo "[queue] Concurrency: $CONCURRENCY teams"
+}
+
+# ══════════════════════════════════════════
+# dequeue — Assign next ready feature to team
+# ══════════════════════════════════════════
+cmd_dequeue() {
+  local team_id="${1:-}"
+  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
+
+  local feature
+  feature=$(jq -r '.queue.ready[0] // empty' "$QUEUE")
+
+  if [ -z "$feature" ]; then
+    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")
+    if [ "$in_prog" -eq 0 ] && [ "$blocked" -eq 0 ]; then
+      echo "[queue] ALL FEATURES COMPLETE."
+    fi
+    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"
+
+  echo "$feature"
+}
+
+# ══════════════════════════════════════════
+# pass — Mark feature as passed, unblock dependents
+# ══════════════════════════════════════════
+cmd_pass() {
+  local fid="${1:-}"
+  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
+  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]) |
+
+    # Add to passed
+    .queue.passed += [$fid] |
+    .queue.passed |= unique |
+
+    # Free team
+    (if $tid != "0" then
+      .teams[$tid] = { status: "idle", feature: null, branch: null, pid: null }
+    else . end) |
+
+    # Unblock dependents: for each blocked feature, remove $fid from its deps
+    # If deps become empty, move to ready
+    .queue.blocked as $blocked |
+    reduce ($blocked | keys[]) as $blocked_fid (
+      .;
+      .queue.blocked[$blocked_fid] -= [$fid] |
+      if (.queue.blocked[$blocked_fid] | length) == 0 then
+        del(.queue.blocked[$blocked_fid]) |
+        .queue.ready += [$blocked_fid]
+      else . end
+    )
+  ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+
+  local newly_ready
+  newly_ready=$(jq -r '.queue.ready | join(", ")' "$QUEUE")
+  echo "[queue] $fid PASSED. Ready: [$newly_ready]"
+}
+
+# ══════════════════════════════════════════
+# fail — Mark feature as failed
+# ══════════════════════════════════════════
+cmd_fail() {
+  local fid="${1:-}"
+  if [ -z "$fid" ]; then echo "[queue] Usage: fail <feature_id>"; exit 1; fi
+  if [ ! -f "$QUEUE" ]; then exit 1; fi
+
+  local team_id
+  team_id=$(jq -r --arg fid "$fid" '.queue.in_progress[$fid].team // empty' "$QUEUE")
+
+  jq --arg fid "$fid" --arg tid "${team_id:-0}" '
+    del(.queue.in_progress[$fid]) |
+    .queue.failed += [$fid] |
+    .queue.failed |= unique |
+    (if $tid != "0" then
+      .teams[$tid] = { status: "idle", feature: null, branch: null, pid: null }
+    else . end)
+  ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+
+  echo "[queue] $fid FAILED."
+}
+
+# ══════════════════════════════════════════
+# requeue — Move failed feature back to ready
+# ══════════════════════════════════════════
+cmd_requeue() {
+  local fid="${1:-}"
+  if [ -z "$fid" ]; then echo "[queue] Usage: requeue <feature_id>"; exit 1; fi
+
+  jq --arg fid "$fid" '
+    .queue.failed -= [$fid] |
+    .queue.ready += [$fid]
+  ' "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+
+  echo "[queue] $fid requeued to ready."
+}
+
+# ══════════════════════════════════════════
+# update_phase — Update in_progress feature phase/attempt
+# ══════════════════════════════════════════
+cmd_update_phase() {
+  local fid="${1:-}" phase="${2:-}" attempt="${3:-}"
+  if [ -z "$fid" ] || [ -z "$phase" ]; then
+    echo "[queue] Usage: update_phase <feature_id> <phase> [attempt]"
+    exit 1
+  fi
+
+  local jq_expr
+  jq_expr=".queue.in_progress[\"$fid\"].phase = \"$phase\""
+  if [ -n "$attempt" ]; then
+    jq_expr="$jq_expr | .queue.in_progress[\"$fid\"].attempt = ($attempt | tonumber)"
+  fi
+
+  jq "$jq_expr" "$QUEUE" > "${QUEUE}.tmp" && mv "${QUEUE}.tmp" "$QUEUE"
+}
+
+# ══════════════════════════════════════════
+# status — Print queue state
+# ══════════════════════════════════════════
+cmd_status() {
+  if [ ! -f "$QUEUE" ]; then
+    echo "[queue] Not initialized. Run: bash scripts/harness-queue-manager.sh init"
+    return
+  fi
+
+  local ready blocked in_prog passed failed
+  ready=$(jq -r '.queue.ready | length' "$QUEUE")
+  blocked=$(jq -r '.queue.blocked | length' "$QUEUE")
+  in_prog=$(jq -r '.queue.in_progress | length' "$QUEUE")
+  passed=$(jq -r '.queue.passed | length' "$QUEUE")
+  failed=$(jq -r '.queue.failed | length' "$QUEUE")
+  local total=$((ready + blocked + in_prog + passed + failed))
+
+  echo ""
+  echo "  Feature Queue ($passed/$total done)"
+  echo "  ─────────────────────────────"
+  echo "  Ready:       $ready"
+  echo "  Blocked:     $blocked"
+  echo "  In Progress: $in_prog"
+  echo "  Passed:      $passed"
+  echo "  Failed:      $failed"
+  echo ""
+
+  # Team status
+  local team_count
+  team_count=$(jq '.teams | length' "$QUEUE")
+  echo "  Teams"
+  echo "  ─────────────────────────────"
+  for i in $(seq 1 "$team_count"); do
+    local t_status t_feature
+    t_status=$(jq -r ".teams[\"$i\"].status // \"idle\"" "$QUEUE")
+    t_feature=$(jq -r ".teams[\"$i\"].feature // \"—\"" "$QUEUE")
+    printf "  Team %d: %-6s %s\n" "$i" "$t_status" "$t_feature"
+  done
+  echo ""
+
+  # In-progress details
+  if [ "$in_prog" -gt 0 ]; then
+    echo "  In Progress"
+    echo "  ─────────────────────────────"
+    jq -r '.queue.in_progress | to_entries[] | "  \(.key): team \(.value.team) — \(.value.phase) (attempt \(.value.attempt))"' "$QUEUE"
+    echo ""
+  fi
+}
+
+# ── Dispatch ──
+case "$CMD" in
+  init)         cmd_init ;;
+  dequeue)      cmd_dequeue "$@" ;;
+  pass)         cmd_pass "$@" ;;
+  fail)         cmd_fail "$@" ;;
+  requeue)      cmd_requeue "$@" ;;
+  update_phase) cmd_update_phase "$@" ;;
+  status)       cmd_status ;;
+  *)
+    echo "Usage: harness-queue-manager.sh <init|dequeue|pass|fail|requeue|update_phase|status> [args]"
+    exit 1
+    ;;
+esac

package/scripts/harness-studio-v4.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+# harness-studio-v4.sh — Harness Studio v4: Parallel Agent Teams
+#
+# ┌──────────────────────┬─────────────────────────┐
+# │  Dashboard            │ Team 1 (worker log)     │
+# │  (Queue + Teams +     ├─────────────────────────┤
+# │   Feature status)     │ Team 2 (worker log)     │
+# ├──────────────────────┤                          │
+# │  Control              ├─────────────────────────┤
+# │  harness> _           │ Team 3 (worker log)     │
+# └──────────────────────┴─────────────────────────┘
+#
+# Usage:
+#   bash scripts/harness-studio-v4.sh [project-root]
+#   bash scripts/harness-studio-v4.sh --kill
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SESSION_NAME="harness-v4"
+
+PROJECT_ROOT=""
+KILL=false
+
+for arg in "$@"; do
+  case "$arg" in
+    --kill)
+      tmux kill-session -t "$SESSION_NAME" 2>/dev/null && echo "Killed." || echo "No session."
+      exit 0
+      ;;
+    *)
+      if [ -d "$arg" ]; then PROJECT_ROOT="$arg"; fi
+      ;;
+  esac
+done
+
+if [ -z "$PROJECT_ROOT" ]; then
+  dir="$(pwd)"
+  while [ "$dir" != "/" ]; do
+    if [ -d "$dir/.harness" ]; then PROJECT_ROOT="$dir"; break; fi
+    dir="$(dirname "$dir")"
+  done
+fi
+
+if [ -z "$PROJECT_ROOT" ] || [ ! -d "$PROJECT_ROOT/.harness" ]; then
+  echo "Error: .harness/ not found."
+  exit 1
+fi
+
+echo "Project: $PROJECT_ROOT"
+echo "Session: $SESSION_NAME"
+
+tmux kill-session -t "$SESSION_NAME" 2>/dev/null || true
+
+# ── Initialize queue if not exists ──
+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"
+fi
+
+# ══════════════════════════════════════════
+# Build 5-pane layout using explicit pane IDs
+# ══════════════════════════════════════════
+
+# 1. Dashboard (top-left)
+PANE_DASH=$(tmux new-session -d -s "$SESSION_NAME" -c "$PROJECT_ROOT" -x 200 -y 50 \
+  -P -F '#{pane_id}' \
+  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-dashboard-v4.sh\" \"${PROJECT_ROOT}\"'")
+
+# 2. Team 1 (top-right)
+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)
+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)
+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}\"'")
+
+# ── Pane titles ──
+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"
+
+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"
+
+# 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 ""
+  tmux attach -t "$SESSION_NAME"
+fi

package/scripts/harness-team-worker.sh

@@ -0,0 +1,359 @@
+#!/bin/bash
+# harness-team-worker.sh — Team Worker: Feature-level Gen→Eval loop (v4.0)
+#
+# 1 Team = 1 프로세스. Feature Queue에서 feature를 꺼내
+# Gen→Gate→Eval 루프를 claude -p 헤드리스로 자율 실행한다.
+#
+# 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 모델
+
+set -uo pipefail
+
+TEAM_ID="${1:?Usage: harness-team-worker.sh <team_id> [project-root]}"
+shift || true
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# ── Resolve project root ──
+PROJECT_ROOT="${1:-}"
+if [ -z "$PROJECT_ROOT" ]; then
+  dir="$(pwd)"
+  while [ "$dir" != "/" ]; do
+    if [ -d "$dir/.harness" ]; then PROJECT_ROOT="$dir"; break; fi
+    dir="$(dirname "$dir")"
+  done
+fi
+
+if [ -z "$PROJECT_ROOT" ] || [ ! -d "$PROJECT_ROOT/.harness" ]; then
+  echo "[T${TEAM_ID}] .harness/ not found."
+  exit 1
+fi
+
+QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+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"
+
+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)
+  if [ -n "$_gm" ]; then GEN_MODEL="$_gm"; fi
+  if [ -n "$_em" ]; then EVAL_MODEL="$_em"; fi
+fi
+
+# ── ANSI helpers ──
+BOLD="\033[1m"
+DIM="\033[2m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+CYAN="\033[36m"
+RESET="\033[0m"
+
+ts() { date +"%H:%M:%S"; }
+
+log() {
+  echo -e "[$(ts)] ${BOLD}T${TEAM_ID}${RESET} $*"
+}
+
+log_progress() {
+  local action="$1" detail="$2"
+  local now
+  now=$(date +"%Y-%m-%d")
+  echo "${now} | team-${TEAM_ID} | ${action} | ${detail}" >> "$PROGRESS_LOG"
+}
+
+# ── 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"
+    fi
+  fi
+
+  local checks=()
+  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
+  for cmd in "${checks[@]}"; do
+    if ! (cd "$cwd" && timeout 120s bash -c "$cmd" >/dev/null 2>&1); then
+      log "${RED}Gate FAIL:${RESET} $cmd"
+      all_pass=false
+    fi
+  done
+
+  if [ "$all_pass" = true ]; then
+    log "${GREEN}Gate: tsc ✓ eslint ✓${RESET}"
+    return 0
+  else
+    return 1
+  fi
+}
+
+# ── Build generator prompt ──
+build_gen_prompt() {
+  local feature_id="$1"
+  local attempt="$2"
+  local eval_feedback="${3:-}"
+
+  local feature_json
+  feature_json=$(jq --arg fid "$feature_id" '.features[] | select(.id == $fid)' "$FEATURES" 2>/dev/null)
+
+  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 prompt="You are Generator-Frontend for a harness engineering project.
+
+PROJECT: $(jq -r '.project_name // ""' "$PROJECT_ROOT/.harness/progress.json" 2>/dev/null)
+CONVENTIONS: Read CONVENTIONS.md if it exists.
+
+YOUR TASK: Implement ONLY feature ${feature_id}: ${feature_name}
+Description: ${feature_desc}
+Acceptance Criteria: ${ac_json}
+
+Read these files for context:
+- .harness/actions/feature-list.json (filter to ${feature_id})
+- .harness/actions/api-contract.json (relevant endpoints)
+- .harness/actions/plan.md (overall design)
+
+RULES:
+- Implement ONLY this feature, do not touch other features' code
+- 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)"
+
+  if [ "$attempt" -gt 1 ] && [ -n "$eval_feedback" ]; then
+    prompt="$prompt
+
+PREVIOUS EVAL FEEDBACK (attempt ${attempt}):
+${eval_feedback}
+
+Fix the issues from the feedback above. Focus specifically on the failed criteria."
+  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 feature_name ac_json
+  feature_name=$(echo "$feature_json" | jq -r '.name // .description // ""')
+  ac_json=$(echo "$feature_json" | 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.
+
+TASK: Evaluate feature ${feature_id}: ${feature_name}
+
+Acceptance Criteria to verify:
+${ac_json}
+
+Previously passed features (regression check): [${passed_list}]
+
+SCORING RUBRIC (R1-R5):
+R1: API Contract compliance (25%)
+R2: Acceptance Criteria full pass (25%)
+R3: Negative tests (20%)
+R4: E2E scenario (15%)
+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):
+---EVAL-RESULT---
+FEATURE: ${feature_id}
+VERDICT: PASS or FAIL
+SCORE: X.XX
+FEEDBACK: <one paragraph summary of issues or confirmation>
+---END-EVAL-RESULT---"
+}
+
+# ── Parse eval result ──
+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)
+
+  echo "${verdict:-UNKNOWN}|${score:-0.00}|${feedback:-no feedback}"
+}
+
+# ══════════════════════════════════════════
+# Main Worker Loop
+# ══════════════════════════════════════════
+log "${CYAN}Team ${TEAM_ID} started${RESET} (gen=${GEN_MODEL}, eval=${EVAL_MODEL}, max=${MAX_ATTEMPTS})"
+log_progress "start" "Team ${TEAM_ID} worker started"
+
+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}"
+    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
+      log "${GREEN}${BOLD}ALL FEATURES COMPLETE. Team ${TEAM_ID} exiting.${RESET}"
+      log_progress "complete" "All features done"
+      exit 0
+    fi
+    continue
+  fi
+
+  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) || \
+  (cd "$PROJECT_ROOT" && git checkout "$branch" 2>/dev/null) || true
+  log "Branch: ${branch}"
+
+  # ── Gen→Eval Loop ──
+  local attempt=1
+  local eval_feedback=""
+  local passed=false
+
+  while [ "$attempt" -le "$MAX_ATTEMPTS" ]; do
+    log "${BOLD}── Attempt ${attempt}/${MAX_ATTEMPTS} ──${RESET}"
+
+    # ── Generate ──
+    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
+
+    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"
+
+    # Auto-commit gen output
+    (cd "$PROJECT_ROOT" && git add -A && git commit -m "feat(${feature_id}): gen attempt ${attempt}" --no-verify 2>/dev/null) || true
+
+    # ── Pre-eval gate ──
+    log "Pre-eval 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."
+      attempt=$((attempt + 1))
+      continue
+    fi
+
+    # ── Evaluate ──
+    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
+
+    # 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})"
+
+    if [ "$verdict" = "PASS" ]; then
+      log "${GREEN}${BOLD}✓ PASS${RESET} ${feature_id} — ${score}/3.00"
+      passed=true
+      break
+    else
+      log "${RED}✗ FAIL${RESET} ${feature_id} — ${score}/3.00"
+      log "${DIM}  ${feedback}${RESET}"
+      eval_feedback="$feedback"
+      attempt=$((attempt + 1))
+    fi
+  done
+
+  # ── Result processing ──
+  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"
+    fi
+
+  else
+    log "${RED}${BOLD}✗ ${feature_id} FAILED after ${MAX_ATTEMPTS} attempts${RESET}"
+    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-tmux.sh

@@ -98,9 +98,10 @@ PANE_EVAL=$(tmux split-window -v -p 45 -t "$PANE_AGENT" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-eval-watcher.sh\" \"${PROJECT_ROOT}\" ${USE_AI}'")
 
-# 6. Launch Claude in Agent Session (needs interactive shell, so use send-keys)
-#    Prefix with unset to avoid nvm warnings
-tmux send-keys -t "$PANE_AGENT" "unset npm_config_prefix 2>/dev/null; $CLAUDE_CMD" Enter
+# 6. Agent Session — leave as empty shell, ready for Control to launch claude
+#    Pre-unset nvm conflict variable
+tmux send-keys -t "$PANE_AGENT" "unset npm_config_prefix 2>/dev/null" Enter
+tmux send-keys -t "$PANE_AGENT" "clear" Enter
 
 # ── Pane titles ──
 tmux select-pane -t "$PANE_DASHBOARD" -T "Dashboard"