@walwal-harness/cli 6.1.4 → 6.1.6

package/scripts/harness-wake.sh

@@ -0,0 +1,350 @@
+#!/bin/bash
+# harness-wake.sh — hourly safety wake (v6.2)
+#
+# launchd 가 1시간 주기로 호출. 등록된 모든 walwal-harness 프로젝트에 대해:
+#   1) idle 한 시간이 임계치 이상이면 (.harness/progress.json mtime 기준, review 실행 전 캡처)
+#   2) deterministic hourly review 를 디스크에 남김
+#   3) 기본값으로 기존 tmux 세션에 긴 prompt 를 주입하지 않고 headless 1-tick Claude 를 실행
+#
+# 등록 방식: ~/.walwal-harness/projects.list 에 한 줄에 하나씩 절대경로 기재.
+# 또는 환경변수 WALWAL_HARNESS_PROJECTS 에 콜론(:)으로 구분된 절대경로 목록.
+
+set -uo pipefail
+
+export PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:${PATH:-}"
+
+LOG_DIR="${HOME}/.walwal-harness/logs"
+mkdir -p "$LOG_DIR"
+LOG="$LOG_DIR/wake.log"
+
+ts() { date "+%Y-%m-%d %H:%M:%S"; }
+say() { echo "[$(ts)] $*" >> "$LOG"; }
+
+stat_mtime() {
+  local path="$1"
+  stat -f "%m" "$path" 2>/dev/null || stat -c "%Y" "$path" 2>/dev/null
+}
+
+in_force_wake_window() {
+  local hhmm start end
+  hhmm="$(date "+%H%M")"
+  start="${HARNESS_WAKE_FORCE_START_HHMM:-0555}"
+  end="${HARNESS_WAKE_FORCE_END_HHMM:-0615}"
+
+  # 기본값은 Anthropic 5-hour reset 이 자주 걸리는 06:00 KST 주변.
+  # StartInterval=3600 이 몇 분 밀려 실행돼도 복구되도록 20분 창을 둔다.
+  [ "$((10#$hhmm))" -ge "$((10#$start))" ] && [ "$((10#$hhmm))" -le "$((10#$end))" ]
+}
+
+find_tmux_session() {
+  local project_root="$1"
+  local base sanitized upper var cand
+
+  base=$(basename "$project_root")
+  sanitized=$(echo "$base" | tr -- '-. ' '___')
+  for cand in "claude_${sanitized}_" "claude_${base}_"; do
+    if tmux has-session -t "$cand" 2>/dev/null; then
+      echo "$cand"
+      return 0
+    fi
+  done
+
+  upper=$(echo "$sanitized" | tr 'a-z' 'A-Z')
+  var="WALWAL_HARNESS_TMUX_${upper}"
+  if [ -n "${!var:-}" ] && tmux has-session -t "${!var}" 2>/dev/null; then
+    echo "${!var}"
+    return 0
+  fi
+
+  return 1
+}
+
+resolve_agent_bin() {
+  local executor="$1"
+  local env_name cand
+
+  case "$executor" in
+    codex)
+      env_name="${HARNESS_CODEX_BIN:-${CODEX_BIN:-}}"
+      ;;
+    claude|*)
+      env_name="${HARNESS_CLAUDE_BIN:-${CLAUDE_BIN:-}}"
+      executor="claude"
+      ;;
+  esac
+
+  for cand in "$env_name" "$HOME/.local/bin/$executor" "/opt/homebrew/bin/$executor" "/usr/local/bin/$executor"; do
+    [ -n "$cand" ] && [ -x "$cand" ] && { echo "$cand"; return 0; }
+  done
+
+  command -v "$executor" 2>/dev/null && return 0
+  return 1
+}
+
+run_conductor_fallback() {
+  local project_root="$1"
+  local reason="$2"
+  local tick="$project_root/scripts/conductor-tick.sh"
+  local progress="$project_root/.harness/progress.json"
+  local progress_set="$project_root/scripts/harness-progress-set.sh"
+  local before after status
+
+  [ "${HARNESS_WAKE_CONDUCTOR_FALLBACK:-1}" = "1" ] || return 0
+  [ -x "$tick" ] || return 0
+  [ -f "$progress" ] || return 0
+  command -v jq >/dev/null 2>&1 || return 0
+
+  before="$(jq -c '{current_agent,next_agent,agent_status,conductor:(.conductor.state // null),decision:(.meetings.decision // {})}' "$progress" 2>/dev/null || echo '{}')"
+
+  if [ -x "$progress_set" ] &&
+    jq -e '
+      (.meetings.decision.owner // "") != "" and
+      ((((.meetings.active // []) | length) > 0) or ((.meetings.decision.required_execution // null) != null))
+    ' "$progress" >/dev/null 2>&1 && {
+      [ "$(jq -r '.current_agent // ""' "$progress")" != "meeting-manager" ] ||
+      [ "$(jq -r '.agent_status // ""' "$progress")" != "completed" ];
+    }; then
+    bash "$progress_set" "$project_root" '
+      .current_agent = "meeting-manager" |
+      .agent_status = "completed" |
+      .conductor.state = "running" |
+      .conductor.current_action = "wake-meeting-decision-ready" |
+      .workflow.last_transition = (now | todate) |
+      .workflow.last_reason = "wake-meeting-decision-ready"
+    ' >/dev/null 2>&1 || true
+  fi
+
+  if bash "$tick" "$project_root" >/dev/null 2>&1; then
+    status="ok"
+  else
+    status="failed"
+  fi
+
+  after="$(jq -c '{current_agent,next_agent,agent_status,conductor:(.conductor.state // null),last_action:(.conductor.current_action // null)}' "$progress" 2>/dev/null || echo '{}')"
+  echo "$(date -u "+%Y-%m-%dT%H:%M:%SZ") | wake | conductor-fallback | $status | reason=$reason | before=$before | after=$after" >> "$project_root/.harness/progress.log"
+  say "conductor-fallback: $project_root ($status, reason=$reason)"
+}
+
+start_headless_tick() {
+  local project_root="$1"
+  local idle="$2"
+  local force="$3"
+  local review_path="$4"
+  local mode executor agent_bin stamp wake_dir ops_dir prompt_rel log_rel prompt_path log_path pid_file old_pid pid status tmux_session session_name session_safe
+
+  mode="${HARNESS_WAKE_MODE:-headless}"
+  executor="${HARNESS_WAKE_EXECUTOR:-claude}"
+  stamp="$(date -u "+%Y%m%dT%H%M%SZ")"
+  wake_dir="$project_root/.harness/actions/wake"
+  ops_dir="$project_root/.harness/ops/wake"
+  mkdir -p "$wake_dir" "$ops_dir"
+
+  prompt_rel=".harness/actions/wake/wake-${stamp}.prompt.md"
+  log_rel=".harness/ops/wake/wake-${stamp}.log"
+  prompt_path="$project_root/$prompt_rel"
+  log_path="$project_root/$log_rel"
+  pid_file="$ops_dir/wake.pid"
+
+  if [ -f "$pid_file" ]; then
+    old_pid="$(cat "$pid_file" 2>/dev/null || true)"
+    if [ -n "$old_pid" ] && kill -0 "$old_pid" 2>/dev/null; then
+      say "skip-headless: $project_root (previous wake pid=$old_pid still running)"
+      return 0
+    fi
+  fi
+
+  cat > "$prompt_path" <<EOF
+You are the walwal-harness autonomous hourly wake tick.
+
+Project root: $project_root
+Wake reason: idle=${idle}s force=${force}
+Hourly review: ${review_path:-"(not available)"}
+
+Policy:
+- Owner input after the initial GOAL is an interrupt or additional request, never a reason to wait.
+- Never set conductor.state to waiting_owner. Normalize any waiting_owner state to waiting_meeting and continue.
+- meeting-manager is the default synchronization loop. Incidents, service warnings, goal drift, and escalations go to meeting-manager first.
+- Keep this to one bounded autonomous tick. Do not run an endless loop.
+- Do not write future timestamps to .harness/progress.log or artifacts.
+- Keep terminal output concise; write evidence to project files.
+
+Tasks:
+1. Read CONVENTIONS.md if present, .harness/conventions/shared.md, relevant .harness/conventions/<role>.md, .harness/gotchas/<role>.md, .harness/memory.md, .harness/progress.json, and the hourly review above.
+2. If service_ops.requested_mode is monitor, run or trigger one service-ops monitor pass and record last_check. stream_active may be true only during the pass and must be false when finished.
+3. Treat the hourly review as Executive Meeting Minutes. Verify it contains CEO/COO/CTO/CQO/Service-Ops role positions, discussion, decision JSON, and action items.
+4. Check conductor state against the current GOAL and route the next department without waiting for Owner.
+5. If there is an active incident or operational warning, make sure meeting-manager has shared context and an action decision that names CTO/CQO/Service-Ops responsibilities.
+6. Split meaningful progress from paperwork-only artifacts in your summary.
+7. Append a short factual summary to .harness/progress.log and any normal harness artifacts used by this project.
+EOF
+
+  case "$mode" in
+    record)
+      status="recorded"
+      ;;
+    headless|"")
+      if agent_bin="$(resolve_agent_bin "$executor")"; then
+        (
+          cd "$project_root" || exit 1
+          if [ "$executor" = "codex" ]; then
+            "$agent_bin" exec -C "$project_root" "$(cat "$prompt_path")" > "$log_path" 2>&1
+          else
+            "$agent_bin" -p "$(cat "$prompt_path")" > "$log_path" 2>&1
+          fi
+        ) &
+        pid=$!
+        echo "$pid" > "$pid_file"
+        status="spawned executor=$executor pid=$pid"
+      else
+        status="BLOCKED_RUNTIME ${executor}-not-found"
+      fi
+      ;;
+    tmux)
+      if ! command -v tmux >/dev/null 2>&1; then
+        status="BLOCKED_RUNTIME tmux-not-found"
+      elif agent_bin="$(resolve_agent_bin "$executor")"; then
+        session_safe="$(basename "$project_root" | tr -c '[:alnum:]_' '_')"
+        session_name="walwal_${session_safe}_${stamp}"
+        if [ "$executor" = "codex" ]; then
+          tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' exec -C '$project_root' - < '$prompt_path' 2>&1 | tee '$log_path'"
+        else
+          tmux new-session -d -s "$session_name" "cd '$project_root' && '$agent_bin' -p \"\$(cat '$prompt_path')\" 2>&1 | tee '$log_path'"
+        fi
+        status="spawned-tmux executor=$executor session=$session_name"
+      else
+        status="BLOCKED_RUNTIME ${executor}-not-found"
+      fi
+      ;;
+    *)
+      status="recorded unsupported-mode=$mode"
+      ;;
+  esac
+
+  echo "$(date -u "+%Y-%m-%dT%H:%M:%SZ") | wake | agent-tick | $status | idle=${idle}s | force=${force} | mode=${mode} | prompt=$prompt_rel | log=$log_rel" >> "$project_root/.harness/progress.log"
+  say "wake-agent: $project_root (idle ${idle}s, force=${force}, mode=${mode}, executor=${executor}) → $status $log_rel"
+
+  run_conductor_fallback "$project_root" "$status"
+
+  if tmux_session="$(find_tmux_session "$project_root" 2>/dev/null)"; then
+    tmux display-message -t "$tmux_session" "walwal wake headless tick: $status ($log_rel)" 2>/dev/null || true
+  fi
+}
+
+PROJECTS_LIST="${HOME}/.walwal-harness/projects.list"
+PROJECTS=()
+
+if [ -n "${WALWAL_HARNESS_PROJECTS:-}" ]; then
+  IFS=':' read -r -a PROJECTS <<< "$WALWAL_HARNESS_PROJECTS"
+elif [ -f "$PROJECTS_LIST" ]; then
+  while IFS= read -r line; do
+    line="${line%%#*}"
+    line="$(echo "$line" | xargs)"
+    [ -z "$line" ] && continue
+    PROJECTS+=("$line")
+  done < "$PROJECTS_LIST"
+fi
+
+if [ "${#PROJECTS[@]}" -eq 0 ]; then
+  say "no registered projects (set ~/.walwal-harness/projects.list or WALWAL_HARNESS_PROJECTS)"
+  exit 0
+fi
+
+# 임계치: idle 60분 이상이면 깨운다 (Stop 훅이 정상 동작하면 거의 연속 활동이므로
+# 1시간 이상 정지 = 어디선가 멈춘 상태로 판단)
+IDLE_THRESHOLD_SECONDS="${HARNESS_WAKE_IDLE_SECONDS:-3300}"   # 55분 (안전 마진)
+NOW_EPOCH=$(date "+%s")
+FORCE_WAKE=0
+if in_force_wake_window; then
+  FORCE_WAKE=1
+fi
+
+for PROJECT_ROOT in "${PROJECTS[@]}"; do
+  if [ ! -d "$PROJECT_ROOT" ]; then
+    say "skip: $PROJECT_ROOT (not a directory)"
+    continue
+  fi
+  PROGRESS="$PROJECT_ROOT/.harness/progress.json"
+  if [ ! -f "$PROGRESS" ]; then
+    say "skip: $PROJECT_ROOT (no .harness/progress.json)"
+    continue
+  fi
+  PROJECT_FORCE_WAKE="$FORCE_WAKE"
+
+  if command -v jq >/dev/null 2>&1 && [ "$(jq -r '.conductor.state // "idle"' "$PROGRESS" 2>/dev/null || echo idle)" = "waiting_owner" ]; then
+    if [ -x "$PROJECT_ROOT/scripts/harness-progress-set.sh" ]; then
+      bash "$PROJECT_ROOT/scripts/harness-progress-set.sh" "$PROJECT_ROOT" \
+        '.conductor.state = "waiting_meeting" |
+         .conductor.current_action = "autonomous-normalize-waiting-owner" |
+         .next_agent = "meeting-manager" |
+         .agent_status = "pending" |
+         .meetings.active = ((.meetings.active // []) + ["meeting-manager"] | unique) |
+         .meetings.requested_type = (.meetings.requested_type // "followup-review") |
+         .meetings.requested_reason = (.meetings.requested_reason // "autonomous-normalize-waiting-owner") |
+         .workflow.stage = "ops-monitoring" |
+         .workflow.last_transition = (now | todate) |
+         .workflow.last_reason = "autonomous-normalize-waiting-owner"' \
+        >/dev/null 2>&1 || true
+      say "normalize: $PROJECT_ROOT (conductor=waiting_owner → waiting_meeting)"
+      PROJECT_FORCE_WAKE=1
+    fi
+  fi
+
+  # idle 시간은 hourly-review 실행 전에 캡처한다. review 는 progress.json 과
+  # progress.log 를 갱신하므로, 이후 mtime 을 보면 wake 가 자기 활동을
+  # "프로젝트 활동 중"으로 오판한다.
+  if MTIME=$(stat_mtime "$PROGRESS"); then :;
+  else
+    say "skip: $PROJECT_ROOT (cannot stat progress.json)"
+    continue
+  fi
+  IDLE=$((NOW_EPOCH - MTIME))
+
+  # Every hourly batch must leave disk-backed evidence, even if Claude/tmux is
+  # stopped or busy. This deterministic review runs after the idle snapshot.
+  if [ -x "$PROJECT_ROOT/scripts/harness-hourly-review.sh" ]; then
+    review_output=$(bash "$PROJECT_ROOT/scripts/harness-hourly-review.sh" "$PROJECT_ROOT" 2>/dev/null || true)
+    review_path=$(printf "%s\n" "$review_output" | grep -Eo '(/[^[:space:]]+|[.][^[:space:]]+)\.md' | tail -1)
+    if [ -z "$review_path" ]; then
+      review_path=$(printf "%s\n" "$review_output" | tail -1)
+    fi
+    if [ -n "$review_path" ]; then
+      say "review: $PROJECT_ROOT → $review_path"
+    else
+      say "review-fail: $PROJECT_ROOT"
+    fi
+  fi
+
+  if [ "$IDLE" -lt "$IDLE_THRESHOLD_SECONDS" ] && [ "$PROJECT_FORCE_WAKE" -ne 1 ]; then
+    say "skip: $PROJECT_ROOT (idle ${IDLE}s < threshold ${IDLE_THRESHOLD_SECONDS}s — 활동 중)"
+    continue
+  fi
+
+  # 회사 루프가 멈춘 상태인지 확인
+  if command -v jq >/dev/null 2>&1; then
+    CSTATE=$(jq -r '.conductor.state // "idle"' "$PROGRESS" 2>/dev/null || echo "idle")
+    SSTATUS=$(jq -r '.sprint.status // "init"' "$PROGRESS" 2>/dev/null || echo "init")
+    if [ "$SSTATUS" = "completed" ] || [ "$SSTATUS" = "aborted" ]; then
+      say "continue: $PROJECT_ROOT (sprint=$SSTATUS — autonomous review still required)"
+    fi
+    if [ "$CSTATE" = "paused" ] || [ "$CSTATE" = "completed" ] || [ "$CSTATE" = "escalated" ]; then
+      say "continue: $PROJECT_ROOT (conductor=$CSTATE — route through meeting-manager/service-ops)"
+    fi
+  fi
+
+  # 발화 직전 service-ops monitor 트리거 partial update.
+  # requested_mode 만 set — conductor-tick 이 이걸 보고 service-ops 를 spawn 한다.
+  # stream_active 는 service-ops 본인이 spawn 시 §3.1.1 에 따라 직접 set (정직성 룰).
+  # auto-retro / incident / null / monitor 가 아닌 모드가 진행 중이면 덮어쓰지 않음.
+  if [ -x "$PROJECT_ROOT/scripts/harness-progress-set.sh" ]; then
+    bash "$PROJECT_ROOT/scripts/harness-progress-set.sh" "$PROJECT_ROOT" \
+      'if (.service_ops.requested_mode // "") == "" or (.service_ops.requested_mode // "") == "monitor" or (.service_ops.requested_mode // "") == "auto-retro"
+       then .service_ops.requested_mode = "monitor" |
+            .service_ops.monitor.wake_trigger_at = (now | todate)
+       else . end' \
+      >/dev/null 2>&1 || true
+  fi
+
+  start_headless_tick "$PROJECT_ROOT" "$IDLE" "$PROJECT_FORCE_WAKE" "$review_path"
+done
+
+exit 0

package/scripts/harness-worker-dispatch.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+# harness-worker-dispatch.sh — connect feature queue to actual worker launches
+#
+# Deterministic responsibilities:
+#   1. auto-dispatch ready features to idle worker slots
+#   2. create per-worker prompt + log paths
+#   3. optionally launch `claude -p` workers in background
+#   4. write progress.json.company_state so dashboards/CLI show real activity
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/harness-render-progress.sh"
+source "$SCRIPT_DIR/lib/harness-agent-resolver.sh"
+
+PROJECT_ROOT="$(resolve_harness_root "${1:-.}")" || exit 0
+PROGRESS="$PROJECT_ROOT/.harness/progress.json"
+CONFIG="$PROJECT_ROOT/.harness/config.json"
+FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
+QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
+WORKER_DIR="$PROJECT_ROOT/.harness/actions/workers"
+LOG_DIR="$PROJECT_ROOT/.harness/ops/workers"
+DISPATCH_LOCK="$PROJECT_ROOT/.harness/.worker-dispatch-lock"
+DISPATCH_LOCK_STALE_SEC="${DISPATCH_LOCK_STALE_SEC:-900}"
+
+[ -f "$PROGRESS" ] || exit 0
+[ -f "$CONFIG" ] || exit 0
+[ -f "$FEATURES" ] || exit 0
+[ -x "$SCRIPT_DIR/harness-queue-manager.sh" ] || exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+
+mkdir -p "$WORKER_DIR" "$LOG_DIR"
+
+acquire_dispatch_lock() {
+  if mkdir "$DISPATCH_LOCK" 2>/dev/null; then
+    printf '%s\n' "$$" > "$DISPATCH_LOCK/pid"
+    printf '%s\n' "$(date +%s)" > "$DISPATCH_LOCK/created_at"
+    trap 'rm -rf "$DISPATCH_LOCK" 2>/dev/null || true' EXIT INT TERM
+    return 0
+  fi
+
+  local now created age holder
+  now="$(date +%s)"
+  created="$(cat "$DISPATCH_LOCK/created_at" 2>/dev/null || echo "$now")"
+  holder="$(cat "$DISPATCH_LOCK/pid" 2>/dev/null || echo unknown)"
+  age=$((now - created))
+  if [ "$age" -ge "$DISPATCH_LOCK_STALE_SEC" ]; then
+    rm -rf "$DISPATCH_LOCK" 2>/dev/null || true
+    if mkdir "$DISPATCH_LOCK" 2>/dev/null; then
+      printf '%s\n' "$$" > "$DISPATCH_LOCK/pid"
+      printf '%s\n' "$now" > "$DISPATCH_LOCK/created_at"
+      trap 'rm -rf "$DISPATCH_LOCK" 2>/dev/null || true' EXIT INT TERM
+      return 0
+    fi
+  fi
+
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | conductor | worker-dispatch | skipped-locked | holder=${holder} age=${age}s" >> "$PROJECT_ROOT/.harness/progress.log"
+  echo "[]"
+  exit 0
+}
+
+acquire_dispatch_lock
+
+spawn_mode="$(jq -r '.company_mode.worker_spawn // "claude"' "$CONFIG" 2>/dev/null || echo claude)"
+pipeline="$(jq -r '.pipeline // "FULLSTACK"' "$PROGRESS" 2>/dev/null || echo FULLSTACK)"
+ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+stamp="$(date -u +%Y%m%dT%H%M%SZ)"
+
+build_prompt() {
+  local team="$1" fid="$2" agent="$3" prompt_path="$4" log_path="$5"
+  cat > "$prompt_path" <<EOF
+You are running as walwal-harness company worker.
+
+Agent: harness-${agent}
+Worker slot: ${team}
+Feature ID: ${fid}
+Project root: ${PROJECT_ROOT}
+
+Follow these rules exactly:
+1. Read AGENTS.md, CONVENTIONS.md if present, .harness/conventions/shared.md, .harness/conventions/${agent}.md if present, .harness/gotchas/${agent}.md if present, .harness/memory.md, .harness/progress.json, .harness/actions/feature-list.json, .harness/actions/api-contract.json, and the relevant harness skill for ${agent}.
+2. Work only on FEATURE_ID=${fid}. Do not broaden scope.
+3. Respect IA ownership and do not edit files outside your department.
+4. Write a report to .harness/actions/gen-report-${fid}.md if you are a generator, or .harness/actions/evaluation-${fid}.md if you are an evaluator.
+5. On success, update feature-list passes and run: bash scripts/harness-queue-manager.sh pass ${fid}
+6. On failure, write the reason and run: bash scripts/harness-queue-manager.sh fail ${fid} "<short reason>"
+7. Use partial progress updates only via scripts/harness-progress-set.sh.
+8. Append real timestamped progress to .harness/progress.log. Never write future timestamps.
+
+This worker log is: ${log_path#$PROJECT_ROOT/}
+EOF
+}
+
+if [ ! -f "$QUEUE" ]; then
+  bash "$SCRIPT_DIR/harness-queue-manager.sh" init all "$PROJECT_ROOT" >/dev/null 2>&1 || exit 0
+else
+  bash "$SCRIPT_DIR/harness-queue-manager.sh" recover "$PROJECT_ROOT" >/dev/null 2>&1 || true
+fi
+
+pairs="$(bash "$SCRIPT_DIR/harness-queue-manager.sh" auto-dispatch "$PROJECT_ROOT" 2>/dev/null || echo "[]")"
+if ! jq -e 'type == "array"' >/dev/null 2>&1 <<<"$pairs"; then
+  pairs="[]"
+fi
+
+count="$(jq 'length' <<<"$pairs")"
+if [ "$count" -eq 0 ]; then
+  active_workers="$(jq '[.teams | to_entries[] | select(.value.status == "busy") | {team:(.key|tonumber), feature:.value.feature, pid:.value.pid, phase:(.value.phase // "gen")}]' "$QUEUE" 2>/dev/null || echo "[]")"
+  jq --arg ts "$ts" --argjson workers "$active_workers" '
+    .company_state.active_workers = ($workers | length) |
+    .company_state.workers = $workers |
+    .company_state.last_dispatch_at = (.company_state.last_dispatch_at // null)
+  ' "$PROGRESS" > "${PROGRESS}.tmp" && mv "${PROGRESS}.tmp" "$PROGRESS"
+  echo "[]"
+  exit 0
+fi
+
+dispatches_file="$(mktemp)"
+: > "$dispatches_file"
+
+i=0
+while [ "$i" -lt "$count" ]; do
+  team="$(jq -r ".[$i].team" <<<"$pairs")"
+  fid="$(jq -r ".[$i].feature" <<<"$pairs")"
+  phase="$(jq -r --arg fid "$fid" '.queue.in_progress[$fid].phase // "gen"' "$QUEUE" 2>/dev/null || echo gen)"
+  agent="$(resolve_feature_agent "$PROJECT_ROOT" "$fid" "$phase" "$pipeline" 2>/dev/null || true)"
+  prompt_rel=".harness/actions/workers/T${team}-${fid}-${stamp}.prompt.md"
+  log_rel=".harness/ops/workers/T${team}-${fid}-${stamp}.log"
+  prompt_path="$PROJECT_ROOT/$prompt_rel"
+  log_path="$PROJECT_ROOT/$log_rel"
+
+  if [ -z "$agent" ]; then
+    reason="agent_resolution_failed phase=${phase}"
+    bash "$SCRIPT_DIR/harness-queue-manager.sh" fail "$fid" "$PROJECT_ROOT" >/dev/null 2>&1 || true
+    printf '%s\n' "$reason" > "$log_path"
+    jq -n --argjson team "$team" --arg feature "$fid" --arg phase "$phase" --arg status "blocked" --arg reason "$reason" \
+      '{team:$team, feature:$feature, phase:$phase, agent:null, prompt:null, log:null, status:$status, reason:$reason, pid:null}' >> "$dispatches_file"
+    echo "$ts | conductor | worker-dispatch | blocked | T${team}/${fid} | ${reason}" >> "$PROJECT_ROOT/.harness/progress.log"
+    i=$((i + 1))
+    continue
+  fi
+
+  build_prompt "$team" "$fid" "$agent" "$prompt_path" "$log_path"
+
+  pid="null"
+  status="recorded"
+  if [ "$spawn_mode" = "claude" ] && command -v claude >/dev/null 2>&1; then
+    (
+      cd "$PROJECT_ROOT" || exit 1
+      claude -p "$(cat "$prompt_path")" > "$log_path" 2>&1
+    ) &
+    pid="$!"
+    status="spawned"
+  fi
+
+  tmpq="${QUEUE}.tmp.$$.$i"
+  jq --arg tid "$team" --arg agent "$agent" --arg phase "$phase" --arg prompt "$prompt_rel" --arg log "$log_rel" --arg status "$status" --argjson pid "$pid" --arg ts "$ts" '
+    .teams[$tid].pid = $pid |
+    .teams[$tid].agent = $agent |
+    .teams[$tid].phase = $phase |
+    .teams[$tid].prompt = $prompt |
+    .teams[$tid].log = $log |
+    .teams[$tid].spawn_status = $status |
+    .teams[$tid].started_at = $ts |
+    .queue.in_progress[.teams[$tid].feature].agent = $agent |
+    .queue.in_progress[.teams[$tid].feature].phase = $phase |
+    .queue.in_progress[.teams[$tid].feature].prompt = $prompt |
+    .queue.in_progress[.teams[$tid].feature].log = $log |
+    .queue.in_progress[.teams[$tid].feature].pid = $pid
+  ' "$QUEUE" > "$tmpq" && mv "$tmpq" "$QUEUE"
+
+  jq -n --argjson team "$team" --arg feature "$fid" --arg agent "$agent" --arg phase "$phase" --arg prompt "$prompt_rel" --arg log "$log_rel" --arg status "$status" --argjson pid "$pid" \
+    '{team:$team, feature:$feature, agent:$agent, phase:$phase, prompt:$prompt, log:$log, status:$status, pid:$pid}' >> "$dispatches_file"
+  echo "$ts | conductor | worker-dispatch | $status | T${team}/${fid} | $agent phase=$phase pid=$pid" >> "$PROJECT_ROOT/.harness/progress.log"
+  i=$((i + 1))
+done
+
+dispatches="$(jq -s '.' "$dispatches_file")"
+rm -f "$dispatches_file"
+active_workers="$(jq '[.teams | to_entries[] | select(.value.status == "busy") | {team:(.key|tonumber), feature:.value.feature, agent:.value.agent, pid:.value.pid, phase:(.value.phase // "gen"), prompt:.value.prompt, log:.value.log, spawn_status:.value.spawn_status}]' "$QUEUE")"
+
+jq --arg ts "$ts" --argjson dispatches "$dispatches" --argjson workers "$active_workers" '
+  .company_state.active_workers = ($workers | length) |
+  .company_state.workers = $workers |
+  .company_state.last_dispatch_at = $ts |
+  .company_state.last_dispatch = $dispatches |
+  .conductor.worker_dispatches = ((.conductor.worker_dispatches // []) + $dispatches)
+' "$PROGRESS" > "${PROGRESS}.tmp" && mv "${PROGRESS}.tmp" "$PROGRESS"
+
+echo "$dispatches"

package/scripts/lib/harness-agent-resolver.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# harness-agent-resolver.sh — canonical feature/phase → harness agent resolver
+#
+# Worker dispatch must not guess the department when Planner already wrote
+# owner_agents/applicable_eval_axes. This resolver is intentionally strict:
+# declared metadata wins; keyword fallback is only allowed when metadata is
+# absent.
+
+set -uo pipefail
+
+resolve_feature_agent() {
+  local project_root="$1" fid="$2" phase="${3:-gen}" pipeline="${4:-FULLSTACK}"
+  local features="$project_root/.harness/actions/feature-list.json"
+
+  [ -f "$features" ] || return 2
+  command -v jq >/dev/null 2>&1 || return 2
+
+  local feature_json
+  feature_json="$(jq -c --arg id "$fid" '.features[]? | select(.id == $id)' "$features" 2>/dev/null | head -1)"
+  [ -n "$feature_json" ] && [ "$feature_json" != "null" ] || return 3
+
+  case "$phase" in
+    eval|eval:*|evaluation|evaluator-*)
+      _resolve_eval_agent "$feature_json" "$phase"
+      return $?
+      ;;
+    *)
+      _resolve_generation_agent "$feature_json" "$pipeline"
+      return $?
+      ;;
+  esac
+}
+
+_resolve_generation_agent() {
+  local feature_json="$1" pipeline="$2"
+  local owner_count agent
+
+  owner_count="$(jq '(.owner_agents // []) | length' <<<"$feature_json")"
+  if [ "${owner_count:-0}" -gt 0 ]; then
+    agent="$(jq -r '
+      (.owner_agents // [])
+      | map(select(
+          . == "generator-backend" or
+          . == "generator-frontend" or
+          . == "generator-designer" or
+          . == "generator-devops"
+        ))
+      | .[0] // empty
+    ' <<<"$feature_json")"
+    [ -n "$agent" ] || return 4
+    echo "$agent"
+    return 0
+  fi
+
+  local layer service title text
+  layer="$(jq -r '(.layer // .type // "")' <<<"$feature_json")"
+  service="$(jq -r '(.service // "")' <<<"$feature_json")"
+  title="$(jq -r '(.title // .name // .description // "")' <<<"$feature_json")"
+  text="$(printf '%s %s %s' "$layer" "$service" "$title" | tr '[:upper:]' '[:lower:]')"
+
+  case "$text" in
+    *frontend*|*ui*|*web*|*react*|*next*) echo "generator-frontend" ;;
+    *design*|*token*|*component-spec*) echo "generator-designer" ;;
+    *devops*|*infra*|*deploy*|*ci*) echo "generator-devops" ;;
+    *)
+      if [ "$pipeline" = "FE-ONLY" ]; then echo "generator-frontend"; else echo "generator-backend"; fi
+      ;;
+  esac
+}
+
+_resolve_eval_agent() {
+  local feature_json="$1" phase="$2"
+  local requested_axis axes_count agent
+
+  requested_axis="${phase#eval:}"
+  requested_axis="${requested_axis#evaluator-}"
+  [ "$requested_axis" = "$phase" ] && requested_axis=""
+  [ "$requested_axis" = "eval" ] && requested_axis=""
+  [ "$requested_axis" = "evaluation" ] && requested_axis=""
+
+  axes_count="$(jq '(.applicable_eval_axes // []) | length' <<<"$feature_json")"
+  [ "${axes_count:-0}" -gt 0 ] || return 5
+
+  if [ -n "$requested_axis" ]; then
+    agent="$(_axis_to_evaluator "$requested_axis")" || return 6
+    jq -e --arg agent "$agent" '
+      def map_axis:
+        if . == "code-quality" or . == "code_quality" or . == "evaluator-code-quality" then "evaluator-code-quality"
+        elif . == "functional" or . == "evaluator-functional" then "evaluator-functional"
+        elif . == "visual" or . == "evaluator-visual" then "evaluator-visual"
+        elif . == "architecture" or . == "evaluator-architecture" then "evaluator-architecture"
+        elif . == "security" or . == "evaluator-security" then "evaluator-security"
+        else empty end;
+      (.applicable_eval_axes // []) | map(map_axis) | index($agent)
+    ' <<<"$feature_json" >/dev/null || return 7
+    echo "$agent"
+    return 0
+  fi
+
+  agent="$(jq -r '
+    def map_axis:
+      if . == "code-quality" or . == "code_quality" or . == "evaluator-code-quality" then "evaluator-code-quality"
+      elif . == "functional" or . == "evaluator-functional" then "evaluator-functional"
+      elif . == "visual" or . == "evaluator-visual" then "evaluator-visual"
+      elif . == "architecture" or . == "evaluator-architecture" then "evaluator-architecture"
+      elif . == "security" or . == "evaluator-security" then "evaluator-security"
+      else empty end;
+    (.applicable_eval_axes // []) | map(map_axis) | .[0] // empty
+  ' <<<"$feature_json")"
+  [ -n "$agent" ] || return 6
+  echo "$agent"
+}
+
+_axis_to_evaluator() {
+  case "$1" in
+    code-quality|code_quality|evaluator-code-quality) echo "evaluator-code-quality" ;;
+    functional|evaluator-functional) echo "evaluator-functional" ;;
+    visual|evaluator-visual) echo "evaluator-visual" ;;
+    architecture|evaluator-architecture) echo "evaluator-architecture" ;;
+    security|evaluator-security) echo "evaluator-security" ;;
+    *) return 1 ;;
+  esac
+}
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+  resolve_feature_agent "${1:-.}" "${2:-}" "${3:-gen}" "${4:-FULLSTACK}"
+fi