agent-control-plane 0.2.0 → 0.4.9

package/tools/bin/agent-project-heartbeat-loop

@@ -158,269 +158,6 @@ log_phase() {
   printf 'HEARTBEAT_LOOP_PHASE=%s\n' "${1:?phase required}"
 }
 
-all_tmux_sessions() {
-  ensure_tmux_sessions_cache
-  printf '%s\n' "$tmux_sessions_cache"
-}
-
-session_matches_prefix() {
-  local session="${1:?session required}"
-  [[ "$session" == "${issue_prefix}"* || "$session" == "${pr_prefix}"* ]]
-}
-
-session_runner_state() {
-  local session="${1:?session required}"
-  local runner_state_file="${runs_root}/${session}/runner.env"
-  if [[ ! -f "$runner_state_file" ]]; then
-    return 1
-  fi
-  awk -F= '/^RUNNER_STATE=/{print $2; exit}' "$runner_state_file"
-}
-
-session_is_auth_waiting() {
-  local session="${1:?session required}"
-  local runner_state=""
-  runner_state="$(session_runner_state "$session" || true)"
-  [[ "$runner_state" == "waiting-auth-refresh" || "$runner_state" == "switching-account" ]]
-}
-
-all_running_workers() {
-  ensure_all_running_workers_cache
-  printf '%s\n' "$all_running_workers_cache"
-}
-
-running_issue_workers() {
-  ensure_running_issue_workers_cache
-  printf '%s\n' "$running_issue_workers_cache"
-}
-
-pending_launch_pid() {
-  local kind="${1:?kind required}"
-  local item_id="${2:?item id required}"
-  local pending_file pid
-
-  pending_file="${pending_launch_dir}/${kind}-${item_id}.pid"
-  if [[ ! -f "$pending_file" ]]; then
-    return 1
-  fi
-
-  pid="$(tr -d '[:space:]' <"$pending_file" 2>/dev/null || true)"
-  if [[ -z "$pid" ]]; then
-    rm -f "$pending_file"
-    return 1
-  fi
-
-  if kill -0 "$pid" 2>/dev/null; then
-    printf '%s\n' "$pid"
-    return 0
-  fi
-
-  rm -f "$pending_file"
-  return 1
-}
-
-pending_issue_launch_active() {
-  local issue_id="${1:?issue id required}"
-  if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-    rm -f "${pending_launch_dir}/issue-${issue_id}.pid" 2>/dev/null || true
-    return 1
-  fi
-  pending_launch_pid issue "$issue_id" >/dev/null
-}
-
-resident_issue_controller_file() {
-  local issue_id="${1:?issue id required}"
-  printf '%s/resident-workers/issues/%s/controller.env\n' "${state_root}" "${issue_id}"
-}
-
-resident_issue_controller_state() {
-  local issue_id="${1:?issue id required}"
-  local controller_file state=""
-
-  controller_file="$(resident_issue_controller_file "$issue_id")"
-  [[ -f "${controller_file}" ]] || return 1
-
-  state="$(awk -F= '/^CONTROLLER_STATE=/{print $2; exit}' "${controller_file}" 2>/dev/null | tr -d '"' || true)"
-  [[ -n "${state}" ]] || return 1
-  printf '%s\n' "${state}"
-}
-
-pending_issue_launch_counts_toward_capacity() {
-  local issue_id="${1:?issue id required}"
-  local controller_state=""
-
-  if ! pending_issue_launch_active "${issue_id}"; then
-    return 1
-  fi
-
-  controller_state="$(resident_issue_controller_state "${issue_id}" || true)"
-  if [[ -n "${controller_state}" ]]; then
-    case "${controller_state}" in
-      idle|sleeping|waiting-due|waiting-open-pr|waiting-provider)
-        return 1
-        ;;
-    esac
-  fi
-
-  return 0
-}
-
-pending_pr_launch_active() {
-  local pr_id="${1:?pr id required}"
-  if tmux has-session -t "${pr_prefix}${pr_id}" 2>/dev/null; then
-    rm -f "${pending_launch_dir}/pr-${pr_id}.pid" 2>/dev/null || true
-    return 1
-  fi
-  pending_launch_pid pr "$pr_id" >/dev/null
-}
-
-running_pr_workers() {
-  ensure_running_pr_workers_cache
-  printf '%s\n' "$running_pr_workers_cache"
-}
-
-ensure_tmux_sessions_cache() {
-  if [[ "$tmux_sessions_cache_loaded" != "yes" ]]; then
-    tmux_sessions_cache="$(tmux list-sessions -F '#S' 2>/dev/null || true)"
-    tmux_sessions_cache_loaded="yes"
-  fi
-}
-
-ensure_all_running_workers_cache() {
-  local session
-  if [[ "$all_running_workers_cache_loaded" == "yes" ]]; then
-    return 0
-  fi
-  ensure_tmux_sessions_cache
-  all_running_workers_cache=""
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    if session_matches_prefix "$session"; then
-      all_running_workers_cache+="${session}"$'\n'
-    fi
-  done <<<"$tmux_sessions_cache"
-  all_running_workers_cache="${all_running_workers_cache%$'\n'}"
-  all_running_workers_cache_loaded="yes"
-}
-
-auth_wait_workers() {
-  ensure_auth_wait_workers_cache
-  printf '%s\n' "$auth_wait_workers_cache"
-}
-
-ensure_auth_wait_workers_cache() {
-  local session
-  if [[ "$auth_wait_workers_cache_loaded" == "yes" ]]; then
-    return 0
-  fi
-  ensure_tmux_sessions_cache
-  auth_wait_workers_cache=""
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    session_matches_prefix "$session" || continue
-    if session_is_auth_waiting "$session"; then
-      auth_wait_workers_cache+="${session}"$'\n'
-    fi
-  done <<<"$tmux_sessions_cache"
-  auth_wait_workers_cache="${auth_wait_workers_cache%$'\n'}"
-  auth_wait_workers_cache_loaded="yes"
-}
-
-ensure_running_issue_workers_cache() {
-  local session
-  if [[ "$running_issue_workers_cache_loaded" == "yes" ]]; then
-    return 0
-  fi
-  ensure_tmux_sessions_cache
-  running_issue_workers_cache=""
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    if [[ "$session" == "${issue_prefix}"* ]]; then
-      if session_is_auth_waiting "$session"; then
-        continue
-      fi
-      running_issue_workers_cache+="${session}"$'\n'
-    fi
-  done <<<"$tmux_sessions_cache"
-  running_issue_workers_cache="${running_issue_workers_cache%$'\n'}"
-  running_issue_workers_cache_loaded="yes"
-}
-
-ensure_running_pr_workers_cache() {
-  local session
-  if [[ "$running_pr_workers_cache_loaded" == "yes" ]]; then
-    return 0
-  fi
-  ensure_tmux_sessions_cache
-  running_pr_workers_cache=""
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    if [[ "$session" == "${pr_prefix}"* ]]; then
-      if session_is_auth_waiting "$session"; then
-        continue
-      fi
-      running_pr_workers_cache+="${session}"$'\n'
-    fi
-  done <<<"$tmux_sessions_cache"
-  running_pr_workers_cache="${running_pr_workers_cache%$'\n'}"
-  running_pr_workers_cache_loaded="yes"
-}
-
-worker_count() {
-  local workers="${1:-}"
-  if [[ -z "$workers" ]]; then
-    printf '0\n'
-    return
-  fi
-  printf '%s\n' "$workers" | sed '/^$/d' | wc -l | tr -d ' '
-}
-
-retry_ready() {
-  local kind="${1:?kind required}"
-  local item_id="${2:?item id required}"
-  local retry_out ready
-
-  retry_out="$(
-    "${shared_agent_home}/tools/bin/agent-project-retry-state" \
-      --state-root "$state_root" \
-      --kind "$kind" \
-      --item-id "$item_id" \
-      --action get
-  )"
-  ready="$(awk -F= '/^READY=/{print $2}' <<<"$retry_out")"
-  [[ "$ready" == "yes" ]]
-}
-
-provider_cooldown_state() {
-  "${shared_agent_home}/tools/bin/provider-cooldown-state.sh" get
-}
-
-issue_id_from_session() {
-  local session="${1:?session required}"
-  local issue_id=""
-  if [[ "$session" == "${issue_prefix}"* ]]; then
-    issue_id="${session#${issue_prefix}}"
-  fi
-  if [[ "$issue_id" =~ ^[0-9]+$ ]]; then
-    printf '%s\n' "$issue_id"
-    return 0
-  fi
-  return 1
-}
-
-pr_id_from_session() {
-  local session="${1:?session required}"
-  local pr_id=""
-  if [[ "$session" == "${pr_prefix}"* ]]; then
-    pr_id="${session#${pr_prefix}}"
-  fi
-  if [[ "$pr_id" =~ ^[0-9]+$ ]]; then
-    printf '%s\n' "$pr_id"
-    return 0
-  fi
-  return 1
-}
-
 if [[ ! -f "$hook_file" ]]; then
   echo "missing hook file: $hook_file" >&2
   exit 1
@@ -493,6 +230,23 @@ if ! declare -F heartbeat_sync_issue_labels >/dev/null 2>&1; then
   heartbeat_sync_issue_labels() { :; }
 fi
 
+
+# --- Source modular libraries ---
+
+heartbeat_lib_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "${heartbeat_lib_dir}/heartbeat-loop-worker-lib.sh"
+# shellcheck source=/dev/null
+source "${heartbeat_lib_dir}/heartbeat-loop-cache-lib.sh"
+# shellcheck source=/dev/null
+source "${heartbeat_lib_dir}/heartbeat-loop-counting-lib.sh"
+# shellcheck source=/dev/null
+source "${heartbeat_lib_dir}/heartbeat-loop-scheduling-lib.sh"
+# shellcheck source=/dev/null
+source "${heartbeat_lib_dir}/heartbeat-loop-pr-strategy-lib.sh"
+
+# --- Launch staging & rollback ---
+
 launch_in_progress_kind=""
 launch_in_progress_id=""
 launch_in_progress_issue_is_heavy="no"
@@ -606,1161 +360,125 @@ rollback_launch_in_progress() {
 
 trap rollback_launch_in_progress EXIT INT TERM
 
-cache_prefix() {
-  local raw_prefix="${issue_prefix:-${pr_prefix:-agent-control-plane}}"
-  local sanitized=""
-
-  sanitized="$(printf '%s' "${raw_prefix}" | tr '/[:space:]' '-' | tr -cd '[:alnum:]_.-')"
-  if [[ -z "${sanitized}" ]]; then
-    sanitized="agent-control-plane"
-  fi
-
-  printf '%s\n' "${sanitized}"
-}
-
-ensure_issue_attr_cache_dir() {
-  if [[ -z "${issue_attr_cache_dir:-}" || ! -d "${issue_attr_cache_dir:-}" ]]; then
-    issue_attr_cache_dir="$(mktemp -d "${TMPDIR:-/tmp}/$(cache_prefix)-issue-attrs.XXXXXX")"
-  fi
-}
-
-ensure_pr_attr_cache_dir() {
-  if [[ -z "${pr_attr_cache_dir:-}" || ! -d "${pr_attr_cache_dir:-}" ]]; then
-    pr_attr_cache_dir="$(mktemp -d "${TMPDIR:-/tmp}/$(cache_prefix)-pr-attrs.XXXXXX")"
-  fi
-}
-
-ensure_pr_risk_cache_dir() {
-  if [[ -z "${pr_risk_cache_dir:-}" || ! -d "${pr_risk_cache_dir:-}" ]]; then
-    pr_risk_cache_dir="$(mktemp -d "${TMPDIR:-/tmp}/$(cache_prefix)-pr-risk.XXXXXX")"
-  fi
-}
-
-pr_risk_runtime_cache_fresh() {
-  local cache_file="${1:?cache file required}"
-  local modified_at now age
-  [[ -f "$cache_file" ]] || return 1
-  modified_at="$(stat -f '%m' "$cache_file" 2>/dev/null || true)"
-  [[ "$modified_at" =~ ^[0-9]+$ ]] || return 1
-  now="$(date +%s)"
-  age=$((now - modified_at))
-  (( age >= 0 && age <= pr_risk_runtime_cache_ttl_seconds ))
-}
+# --- PR launch dispatcher ---
 
-cached_issue_attr() {
-  local attr_name="${1:?attr name required}"
-  local issue_id="${2:?issue id required}"
-  local cache_file attr_value
+launch_pr_candidate_json() {
+  local pr_candidate_json="${1:?pr candidate json required}"
+  local pr_number pr_lane launch_out
 
-  ensure_issue_attr_cache_dir
-  cache_file="${issue_attr_cache_dir}/${issue_id}.${attr_name}"
-  if [[ -f "${cache_file}" ]]; then
-    cat "${cache_file}"
-    return 0
-  fi
+  pr_number="$(jq -r '.number' <<<"$pr_candidate_json")"
+  pr_lane="$(jq -r '.agentLane' <<<"$pr_candidate_json")"
+  stage_pr_launch "$pr_number"
 
-  case "${attr_name}" in
-    heavy)
-      attr_value="$(heartbeat_issue_is_heavy "${issue_id}")"
-      ;;
-    recurring)
-      attr_value="$(heartbeat_issue_is_recurring "${issue_id}")"
+  case "$pr_lane" in
+    double-check-1|double-check-2|automerge)
+      if ! launch_out="$(heartbeat_start_pr_review_worker "$pr_number" 2>&1)"; then
+        heartbeat_clear_pr_running "$pr_number" || true
+        clear_launch_in_progress
+        record_memory "failed to launch PR review worker for #${pr_number}"
+        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+        exit 1
+      fi
+      record_memory "launched PR review worker for #${pr_number}"
       ;;
-    scheduled)
-      attr_value="$(heartbeat_issue_is_scheduled "${issue_id}")"
+    merge-repair)
+      if ! launch_out="$(heartbeat_start_pr_merge_repair_worker "$pr_number" 2>&1)"; then
+        heartbeat_clear_pr_running "$pr_number" || true
+        clear_launch_in_progress
+        record_memory "failed to launch PR merge-repair worker for #${pr_number}"
+        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+        exit 1
+      fi
+      record_memory "launched PR merge-repair worker for #${pr_number}"
       ;;
-    schedule_interval_seconds)
-      attr_value="$(heartbeat_issue_schedule_interval_seconds "${issue_id}")"
+    ci-refresh)
+      if ! launch_out="$(heartbeat_start_pr_ci_refresh "$pr_number" 2>&1)"; then
+        heartbeat_clear_pr_running "$pr_number" || true
+        clear_launch_in_progress
+        record_memory "failed to trigger PR ci-refresh for #${pr_number}"
+        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+        exit 1
+      fi
+      heartbeat_clear_pr_running "$pr_number" || true
+      record_memory "triggered PR ci-refresh for #${pr_number}"
       ;;
-    exclusive)
-      attr_value="$(heartbeat_issue_is_exclusive "${issue_id}")"
+    fix)
+      if ! launch_out="$(heartbeat_start_pr_fix_worker "$pr_number" 2>&1)"; then
+        heartbeat_clear_pr_running "$pr_number" || true
+        clear_launch_in_progress
+        record_memory "failed to launch PR fix worker for #${pr_number}"
+        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+        exit 1
+      fi
+      record_memory "launched PR fix worker for #${pr_number}"
       ;;
     *)
-      echo "unsupported issue cache attr: ${attr_name}" >&2
-      return 1
+      launch_out="Unsupported PR lane: ${pr_lane}"
+      heartbeat_clear_pr_running "$pr_number" || true
+      clear_launch_in_progress
+      print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+      exit 1
       ;;
   esac
 
-  printf '%s\n' "${attr_value}" >"${cache_file}"
-  printf '%s\n' "${attr_value}"
-}
-
-cached_pr_is_exclusive() {
-  local pr_number="${1:?pr number required}"
-  local cache_file attr_value
-
-  ensure_pr_attr_cache_dir
-  cache_file="${pr_attr_cache_dir}/${pr_number}.exclusive"
-  if [[ -f "${cache_file}" ]]; then
-    cat "${cache_file}"
-    return 0
-  fi
-
-  attr_value="$(heartbeat_pr_is_exclusive "${pr_number}")"
-  printf '%s\n' "${attr_value}" >"${cache_file}"
-  printf '%s\n' "${attr_value}"
-}
-
-cached_pr_risk_json() {
-  local pr_number="${1:?pr number required}"
-  local cache_file runtime_cache_file risk_json
-
-  ensure_pr_risk_cache_dir
-  cache_file="${pr_risk_cache_dir}/${pr_number}.json"
-  runtime_cache_file="${pr_risk_runtime_cache_dir}/${pr_number}.json"
-  if [[ -f "${cache_file}" ]]; then
-    cat "${cache_file}"
-    return 0
+  clear_launch_in_progress
+  print_block "LAUNCHED_PR=${pr_number}" "$(printf 'LANE=%s\n%s' "$pr_lane" "$launch_out")"
+  if [[ "$pr_lane" != "ci-refresh" ]]; then
+    running_total_count=$((running_total_count + 1))
+    running_pr_count=$((running_pr_count + 1))
   fi
-
-  if pr_risk_runtime_cache_fresh "${runtime_cache_file}"; then
-    cp "${runtime_cache_file}" "${cache_file}"
-    cat "${cache_file}"
-    return 0
+  launched_pr_count=$((launched_pr_count + 1))
+  if (( launch_budget_remaining > 0 )); then
+    launch_budget_remaining=$((launch_budget_remaining - 1))
   fi
-
-  risk_json="$(heartbeat_pr_risk_json "${pr_number}")"
-  printf '%s\n' "${risk_json}" >"${cache_file}"
-  printf '%s\n' "${risk_json}" >"${runtime_cache_file}"
-  printf '%s\n' "${risk_json}"
 }
 
-running_heavy_issue_workers() {
-  local session issue_id is_heavy count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_heavy="$(cached_issue_attr heavy "$issue_id")"
-    if [[ "$is_heavy" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
+# ============================================================================
+# MAIN EXECUTION
+# ============================================================================
 
-pending_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id"; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
+log_phase "reconcile-completed-workers:start"
+ensure_completed_workers_cache
+while IFS= read -r completed_session; do
+  [[ -n "$completed_session" ]] || continue
+  case "$completed_session" in
+    "${issue_prefix}"*)
+      if reconcile_out="$(heartbeat_reconcile_issue "$completed_session" 2>&1)"; then
+        record_memory "reconciled issue worker ${completed_session}"
+        print_block "RECONCILED_SESSION=${completed_session}" "$reconcile_out"
+      else
+        record_memory "failed to reconcile issue worker ${completed_session}"
+        print_block "RECONCILE_FAILED_SESSION=${completed_session}" "$reconcile_out"
+      fi
+      ;;
+    "${pr_prefix}"*)
+      if reconcile_out="$(heartbeat_reconcile_pr "$completed_session" 2>&1)"; then
+        record_memory "reconciled PR worker ${completed_session}"
+        print_block "RECONCILED_SESSION=${completed_session}" "$reconcile_out"
+      else
+        completed_pr_number="${completed_session#${pr_prefix}}"
+        if [[ -n "$completed_pr_number" ]]; then
+          heartbeat_clear_pr_running "$completed_pr_number" >/dev/null || true
+          heartbeat_sync_pr_labels "$completed_pr_number" >/dev/null || true
+        fi
+        record_memory "failed to reconcile PR worker ${completed_session}"
+        print_block "RECONCILE_FAILED_SESSION=${completed_session}" "$reconcile_out"
+      fi
+      ;;
+    *)
+      echo "unknown completed worker session: ${completed_session}" >&2
+      exit 1
+      ;;
+  esac
+done <<<"$completed_workers_cache"
+log_phase "reconcile-completed-workers:end"
 
-pending_pr_launch_count() {
-  local pending_file pr_id count=0
-  for pending_file in "${pending_launch_dir}"/pr-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    pr_id="${pending_file##*/pr-}"
-    pr_id="${pr_id%.pid}"
-    [[ -n "$pr_id" ]] || continue
-    if tmux has-session -t "${pr_prefix}${pr_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_pr_launch_active "$pr_id"; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_heavy_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" && [[ "$(cached_issue_attr heavy "$issue_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_scheduled_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" && [[ "$(cached_issue_attr scheduled "$issue_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_scheduled_heavy_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" \
-      && [[ "$(cached_issue_attr scheduled "$issue_id")" == "yes" ]] \
-      && [[ "$(cached_issue_attr heavy "$issue_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_recurring_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" \
-      && [[ "$(cached_issue_attr scheduled "$issue_id")" != "yes" ]] \
-      && [[ "$(cached_issue_attr recurring "$issue_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_blocked_recovery_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" && blocked_recovery_issue_has_state "$issue_id"; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_exclusive_issue_launch_count() {
-  local pending_file issue_id count=0
-  for pending_file in "${pending_launch_dir}"/issue-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    issue_id="${pending_file##*/issue-}"
-    issue_id="${issue_id%.pid}"
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_counts_toward_capacity "$issue_id" && [[ "$(cached_issue_attr exclusive "$issue_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-pending_exclusive_pr_launch_count() {
-  local pending_file pr_id count=0
-  for pending_file in "${pending_launch_dir}"/pr-*.pid; do
-    [[ -f "$pending_file" ]] || continue
-    pr_id="${pending_file##*/pr-}"
-    pr_id="${pr_id%.pid}"
-    [[ -n "$pr_id" ]] || continue
-    if tmux has-session -t "${pr_prefix}${pr_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_pr_launch_active "$pr_id" && [[ "$(cached_pr_is_exclusive "$pr_id")" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done
-  printf '%s\n' "$count"
-}
-
-running_non_recurring_issue_workers() {
-  local session issue_id is_recurring is_scheduled count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_scheduled="$(cached_issue_attr scheduled "$issue_id")"
-    if [[ "$is_scheduled" == "yes" ]]; then
-      continue
-    fi
-    is_recurring="$(cached_issue_attr recurring "$issue_id")"
-    if [[ "$is_recurring" != "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
-
-running_recurring_issue_workers() {
-  local session issue_id is_recurring is_scheduled count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_scheduled="$(cached_issue_attr scheduled "$issue_id")"
-    if [[ "$is_scheduled" == "yes" ]]; then
-      continue
-    fi
-    is_recurring="$(cached_issue_attr recurring "$issue_id")"
-    if [[ "$is_recurring" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  # Also count pending recurring launches that are still in progress
-  # (prevents infinite respawning when workers die before creating tmux sessions)
-  count=$((count + $(pending_recurring_issue_launch_count)))
-  printf '%s\n' "$count"
-}
-
-running_blocked_recovery_issue_workers() {
-  local session issue_id count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    if blocked_recovery_issue_has_state "$issue_id"; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
-
-running_exclusive_issue_workers() {
-  local session issue_id is_exclusive count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_exclusive="$(cached_issue_attr exclusive "$issue_id")"
-    if [[ "$is_exclusive" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
-
-running_exclusive_pr_workers() {
-  local session pr_id is_exclusive count=0
-  ensure_running_pr_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    pr_id="$(pr_id_from_session "$session" || true)"
-    [[ -n "$pr_id" ]] || continue
-    is_exclusive="$(cached_pr_is_exclusive "$pr_id")"
-    if [[ "$is_exclusive" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_pr_workers_cache"
-  printf '%s\n' "$count"
-}
-
-running_scheduled_issue_workers() {
-  local session issue_id is_scheduled count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_scheduled="$(cached_issue_attr scheduled "$issue_id")"
-    if [[ "$is_scheduled" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
-
-running_scheduled_heavy_issue_workers() {
-  local session issue_id is_scheduled is_heavy count=0
-  ensure_running_issue_workers_cache
-  while IFS= read -r session; do
-    [[ -n "$session" ]] || continue
-    issue_id="$(issue_id_from_session "$session" || true)"
-    [[ -n "$issue_id" ]] || continue
-    is_scheduled="$(cached_issue_attr scheduled "$issue_id")"
-    is_heavy="$(cached_issue_attr heavy "$issue_id")"
-    if [[ "$is_scheduled" == "yes" && "$is_heavy" == "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$running_issue_workers_cache"
-  printf '%s\n' "$count"
-}
-
-ready_non_recurring_issue_count() {
-  local issue_id is_recurring count=0
-  ensure_ready_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if [[ "$(cached_issue_attr scheduled "$issue_id")" == "yes" ]]; then
-      continue
-    fi
-    is_recurring="$(cached_issue_attr recurring "$issue_id")"
-    if [[ "$is_recurring" != "yes" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$ready_issue_ids_cache"
-  printf '%s\n' "$count"
-}
-
-blocked_recovery_issue_ids() {
-  ensure_blocked_recovery_issue_ids_cache
-  printf '%s\n' "$blocked_recovery_issue_ids_cache"
-}
-
-ordered_ready_issue_ids() {
-  ensure_ordered_ready_issue_ids_cache
-  printf '%s\n' "$ordered_ready_issue_ids_cache"
-}
-
-due_scheduled_issue_ids() {
-  ensure_due_scheduled_issue_ids_cache
-  printf '%s\n' "$due_scheduled_issue_ids_cache"
-}
-
-due_blocked_recovery_issue_ids() {
-  ensure_due_blocked_recovery_issue_ids_cache
-  printf '%s\n' "$due_blocked_recovery_issue_ids_cache"
-}
-
-ensure_due_scheduled_issue_ids_cache() {
-  if [[ "$due_scheduled_issue_ids_cache_loaded" != "yes" ]]; then
-    due_scheduled_issue_ids_cache="$(build_due_scheduled_issue_ids_cache)"
-    due_scheduled_issue_ids_cache_loaded="yes"
-  fi
-}
-
-ensure_due_blocked_recovery_issue_ids_cache() {
-  if [[ "$due_blocked_recovery_issue_ids_cache_loaded" != "yes" ]]; then
-    due_blocked_recovery_issue_ids_cache="$(build_due_blocked_recovery_issue_ids_cache)"
-    due_blocked_recovery_issue_ids_cache_loaded="yes"
-  fi
-}
-
-build_due_scheduled_issue_ids_cache() {
-  local issue_id now_epoch due_epoch
-  now_epoch="$(date +%s)"
-  ensure_ready_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if [[ "$(cached_issue_attr scheduled "$issue_id")" != "yes" ]]; then
-      continue
-    fi
-    if ! scheduled_issue_is_due "$issue_id"; then
-      continue
-    fi
-    due_epoch="$(scheduled_issue_due_epoch "$issue_id")"
-    if ! [[ "${due_epoch:-}" =~ ^[0-9]+$ ]]; then
-      due_epoch=0
-    fi
-    printf '%s\t%s\n' "$due_epoch" "$issue_id"
-  done <<<"$ready_issue_ids_cache" | sort -n -k1,1 -k2,2n | cut -f2
-}
-
-build_due_blocked_recovery_issue_ids_cache() {
-  local issue_id due_epoch
-  if (( max_concurrent_blocked_recovery_issue_workers <= 0 )); then
-    return 0
-  fi
-
-  ensure_blocked_recovery_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if ! blocked_recovery_issue_is_due "$issue_id"; then
-      continue
-    fi
-    due_epoch="$(blocked_recovery_issue_due_epoch "$issue_id")"
-    if ! [[ "${due_epoch:-}" =~ ^[0-9]+$ ]]; then
-      due_epoch=0
-    fi
-    printf '%s\t%s\n' "$due_epoch" "$issue_id"
-  done <<<"$blocked_recovery_issue_ids_cache" | sort -n -k1,1 -k2,2n | cut -f2
-}
-
-build_ordered_ready_issue_ids_cache() {
-  local issue_id is_recurring last_recurring_issue seen_last="no"
-  local -a recurring_ids=()
-  ensure_ready_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if [[ "$(cached_issue_attr scheduled "$issue_id")" == "yes" ]]; then
-      continue
-    fi
-    is_recurring="$(cached_issue_attr recurring "$issue_id")"
-    if [[ "$is_recurring" != "yes" ]]; then
-      printf '%s\n' "$issue_id"
-    else
-      recurring_ids+=("$issue_id")
-    fi
-  done <<<"$ready_issue_ids_cache"
-
-  if (( ${#recurring_ids[@]} == 0 )); then
-    return 0
-  fi
-
-  last_recurring_issue="$(last_launched_recurring_issue_id || true)"
-  if [[ -n "$last_recurring_issue" ]]; then
-    local emitted_after_last=0
-    for issue_id in "${recurring_ids[@]}"; do
-      if [[ "$seen_last" == "yes" ]]; then
-        printf '%s\n' "$issue_id"
-        emitted_after_last=$((emitted_after_last + 1))
-      fi
-      if [[ "$issue_id" == "$last_recurring_issue" ]]; then
-        seen_last="yes"
-      fi
-    done
-  fi
-
-  for issue_id in "${recurring_ids[@]}"; do
-    # Stop the wrap-around once we reach the last-launched issue, but only
-    # when the first loop already emitted at least one issue after it.
-    # When there is exactly one recurring issue (or the last-launched issue
-    # is the final element), emitted_after_last is 0, so we must still
-    # include it here to avoid producing an empty list.
-    if [[ -n "$last_recurring_issue" && "$seen_last" == "yes" && "$issue_id" == "$last_recurring_issue" && "$emitted_after_last" -gt 0 ]]; then
-      break
-    fi
-    printf '%s\n' "$issue_id"
-  done
-}
-
-completed_workers() {
-  ensure_completed_workers_cache
-  printf '%s\n' "$completed_workers_cache"
-}
-
-reconciled_marker_matches_run() {
-  local run_dir="${1:?run dir required}"
-  local marker_file="${run_dir}/reconciled.ok"
-  local run_env="${run_dir}/run.env"
-  local marker_started_at=""
-  local run_started_at=""
-
-  [[ -f "${marker_file}" && -f "${run_env}" ]] || return 1
-
-  marker_started_at="$(awk -F= '/^STARTED_AT=/{print $2}' "${marker_file}" 2>/dev/null | tr -d '"' | tail -n 1 || true)"
-  run_started_at="$(awk -F= '/^STARTED_AT=/{print $2}' "${run_env}" 2>/dev/null | tr -d '"' | tail -n 1 || true)"
-
-  [[ -n "${marker_started_at}" && -n "${run_started_at}" && "${marker_started_at}" == "${run_started_at}" ]]
-}
-
-ensure_completed_workers_cache() {
-  local dir session issue_id status_line status
-  if [[ "$completed_workers_cache_loaded" == "yes" ]]; then
-    return 0
-  fi
-  completed_workers_cache=""
-  for dir in "$runs_root"/*; do
-    [[ -d "$dir" ]] || continue
-    session="${dir##*/}"
-    session_matches_prefix "$session" || continue
-    if reconciled_marker_matches_run "$dir"; then
-      continue
-    fi
-    if [[ "$session" == "${issue_prefix}"* ]]; then
-      issue_id="$(issue_id_from_session "$session" || true)"
-      if [[ -n "${issue_id}" ]] && pending_issue_launch_active "${issue_id}"; then
-        continue
-      fi
-    fi
-    status_line="$(
-      "${shared_agent_home}/tools/bin/agent-project-worker-status" \
-        --runs-root "$runs_root" \
-        --session "$session" \
-        | awk -F= '/^STATUS=/{print $2}' || true
-    )"
-    status="${status_line:-UNKNOWN}"
-    if [[ "$status" == "SUCCEEDED" || "$status" == "FAILED" ]]; then
-      completed_workers_cache+="${session}"$'\n'
-    fi
-  done
-  completed_workers_cache="${completed_workers_cache%$'\n'}"
-  completed_workers_cache_loaded="yes"
-}
-
-ready_issue_ids() {
-  ensure_ready_issue_ids_cache
-  printf '%s\n' "$ready_issue_ids_cache"
-}
-
-ensure_ready_issue_ids_cache() {
-  if [[ "$ready_issue_ids_cache_loaded" != "yes" ]]; then
-    ready_issue_ids_cache="$(heartbeat_list_ready_issue_ids)"
-    ready_issue_ids_cache_loaded="yes"
-  fi
-}
-
-last_launched_recurring_issue_id() {
-  if [[ -f "$recurring_rotation_file" ]]; then
-    tr -d '[:space:]' <"$recurring_rotation_file"
-  fi
-}
-
-record_recurring_issue_launch() {
-  local issue_id="${1:?issue id required}"
-  printf '%s\n' "$issue_id" >"$recurring_rotation_file"
-}
-
-scheduled_state_file() {
-  local issue_id="${1:?issue id required}"
-  printf '%s\n' "${scheduled_state_dir}/${issue_id}.env"
-}
-
-scheduled_issue_due_epoch() {
-  local issue_id="${1:?issue id required}"
-  local state_file next_due_epoch
-  state_file="$(scheduled_state_file "$issue_id")"
-  if [[ ! -f "$state_file" ]]; then
-    printf '0\n'
-    return 0
-  fi
-
-  next_due_epoch="$(awk -F= '/^NEXT_DUE_EPOCH=/{print $2}' "$state_file" 2>/dev/null | tr -d '[:space:]' || true)"
-  if ! [[ "${next_due_epoch:-}" =~ ^[0-9]+$ ]]; then
-    printf '0\n'
-    return 0
-  fi
-
-  printf '%s\n' "$next_due_epoch"
-}
-
-scheduled_issue_is_due() {
-  local issue_id="${1:?issue id required}"
-  local interval_seconds due_epoch now_epoch
-  interval_seconds="$(cached_issue_attr schedule_interval_seconds "$issue_id")"
-  if ! [[ "${interval_seconds:-}" =~ ^[1-9][0-9]*$ ]]; then
-    return 1
-  fi
-
-  due_epoch="$(scheduled_issue_due_epoch "$issue_id")"
-  now_epoch="$(date +%s)"
-  if ! [[ "${due_epoch:-}" =~ ^[0-9]+$ ]] || (( due_epoch == 0 || due_epoch <= now_epoch )); then
-    return 0
-  fi
-  return 1
-}
-
-record_scheduled_issue_launch() {
-  local issue_id="${1:?issue id required}"
-  local interval_seconds state_file now_epoch due_epoch next_due_epoch
-
-  interval_seconds="$(cached_issue_attr schedule_interval_seconds "$issue_id")"
-  if ! [[ "${interval_seconds:-}" =~ ^[1-9][0-9]*$ ]]; then
-    return 0
-  fi
-
-  now_epoch="$(date +%s)"
-  due_epoch="$(scheduled_issue_due_epoch "$issue_id")"
-  if ! [[ "${due_epoch:-}" =~ ^[0-9]+$ ]] || (( due_epoch <= 0 )); then
-    next_due_epoch=$((now_epoch + interval_seconds))
-  else
-    next_due_epoch="$due_epoch"
-    while (( next_due_epoch <= now_epoch )); do
-      next_due_epoch=$((next_due_epoch + interval_seconds))
-    done
-  fi
-
-  state_file="$(scheduled_state_file "$issue_id")"
-  cat >"$state_file" <<EOF
-INTERVAL_SECONDS=${interval_seconds}
-LAST_STARTED_EPOCH=${now_epoch}
-LAST_STARTED_AT=$(date -u -r "$now_epoch" +"%Y-%m-%dT%H:%M:%SZ")
-NEXT_DUE_EPOCH=${next_due_epoch}
-NEXT_DUE_AT=$(date -u -r "$next_due_epoch" +"%Y-%m-%dT%H:%M:%SZ")
-UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-EOF
-}
-
-record_scheduled_issue_result() {
-  local issue_id="${1:?issue id required}"
-  local result_status="${2:-unknown}"
-  local state_file interval_seconds last_started_epoch next_due_epoch now_epoch
-
-  state_file="$(scheduled_state_file "$issue_id")"
-  interval_seconds="$(cached_issue_attr schedule_interval_seconds "$issue_id")"
-  last_started_epoch="$(awk -F= '/^LAST_STARTED_EPOCH=/{print $2}' "$state_file" 2>/dev/null | tr -d '[:space:]' || true)"
-  next_due_epoch="$(awk -F= '/^NEXT_DUE_EPOCH=/{print $2}' "$state_file" 2>/dev/null | tr -d '[:space:]' || true)"
-  now_epoch="$(date +%s)"
-
-  if ! [[ "${interval_seconds:-}" =~ ^[1-9][0-9]*$ ]]; then
-    interval_seconds=0
-  fi
-  if ! [[ "${last_started_epoch:-}" =~ ^[0-9]+$ ]]; then
-    last_started_epoch=0
-  fi
-  if ! [[ "${next_due_epoch:-}" =~ ^[0-9]+$ ]]; then
-    next_due_epoch=0
-  fi
-
-  cat >"$state_file" <<EOF
-INTERVAL_SECONDS=${interval_seconds}
-LAST_STARTED_EPOCH=${last_started_epoch}
-LAST_STARTED_AT=$(if [[ "$last_started_epoch" =~ ^[0-9]+$ ]] && (( last_started_epoch > 0 )); then date -u -r "$last_started_epoch" +"%Y-%m-%dT%H:%M:%SZ"; fi)
-LAST_RESULT_STATUS=${result_status}
-LAST_RESULT_EPOCH=${now_epoch}
-LAST_RESULT_AT=$(date -u -r "$now_epoch" +"%Y-%m-%dT%H:%M:%SZ")
-NEXT_DUE_EPOCH=${next_due_epoch}
-NEXT_DUE_AT=$(if [[ "$next_due_epoch" =~ ^[0-9]+$ ]] && (( next_due_epoch > 0 )); then date -u -r "$next_due_epoch" +"%Y-%m-%dT%H:%M:%SZ"; fi)
-UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-EOF
-}
-
-blocked_recovery_state_file() {
-  local issue_id="${1:?issue id required}"
-  printf '%s\n' "${blocked_recovery_state_dir}/${issue_id}.env"
-}
-
-blocked_recovery_issue_has_state() {
-  local issue_id="${1:?issue id required}"
-  [[ -f "$(blocked_recovery_state_file "$issue_id")" ]]
-}
-
-blocked_recovery_issue_due_epoch() {
-  local issue_id="${1:?issue id required}"
-  local state_file next_due_epoch
-  state_file="$(blocked_recovery_state_file "$issue_id")"
-  if [[ ! -f "$state_file" ]]; then
-    printf '0\n'
-    return 0
-  fi
-
-  next_due_epoch="$(awk -F= '/^NEXT_DUE_EPOCH=/{print $2}' "$state_file" 2>/dev/null | tr -d '[:space:]' || true)"
-  if ! [[ "${next_due_epoch:-}" =~ ^[0-9]+$ ]]; then
-    printf '0\n'
-    return 0
-  fi
-
-  printf '%s\n' "$next_due_epoch"
-}
-
-blocked_recovery_issue_is_due() {
-  local issue_id="${1:?issue id required}"
-  local due_epoch now_epoch
-  if ! [[ "${blocked_recovery_cooldown_seconds:-}" =~ ^[1-9][0-9]*$ ]]; then
-    return 0
-  fi
-
-  due_epoch="$(blocked_recovery_issue_due_epoch "$issue_id")"
-  now_epoch="$(date +%s)"
-  if ! [[ "${due_epoch:-}" =~ ^[0-9]+$ ]] || (( due_epoch == 0 || due_epoch <= now_epoch )); then
-    return 0
-  fi
-  return 1
-}
-
-record_blocked_recovery_issue_launch() {
-  local issue_id="${1:?issue id required}"
-  local state_file now_epoch next_due_epoch next_due_at
-
-  now_epoch="$(date +%s)"
-  next_due_epoch=0
-  next_due_at=""
-  if [[ "${blocked_recovery_cooldown_seconds:-}" =~ ^[1-9][0-9]*$ ]]; then
-    next_due_epoch=$((now_epoch + blocked_recovery_cooldown_seconds))
-    next_due_at="$(date -u -r "$next_due_epoch" +"%Y-%m-%dT%H:%M:%SZ")"
-  fi
-
-  state_file="$(blocked_recovery_state_file "$issue_id")"
-  cat >"$state_file" <<EOF
-LANE=blocked-recovery
-LAST_STARTED_EPOCH=${now_epoch}
-LAST_STARTED_AT=$(date -u -r "$now_epoch" +"%Y-%m-%dT%H:%M:%SZ")
-NEXT_DUE_EPOCH=${next_due_epoch}
-NEXT_DUE_AT=${next_due_at}
-UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-EOF
-}
-
-clear_blocked_recovery_issue_state() {
-  local issue_id="${1:?issue id required}"
-  rm -f "$(blocked_recovery_state_file "$issue_id")"
-}
-
-open_agent_pr_ids() {
-  ensure_open_agent_pr_ids_cache
-  printf '%s\n' "$open_agent_pr_ids_cache"
-}
-
-ensure_open_agent_pr_ids_cache() {
-  if [[ "$open_agent_pr_ids_cache_loaded" != "yes" ]]; then
-    open_agent_pr_ids_cache="$(heartbeat_list_open_agent_pr_ids)"
-    open_agent_pr_ids_cache_loaded="yes"
-  fi
-}
-
-running_issue_ids() {
-  ensure_running_issue_ids_cache
-  printf '%s\n' "$running_issue_ids_cache"
-}
-
-exclusive_issue_ids() {
-  ensure_exclusive_issue_ids_cache
-  printf '%s\n' "$exclusive_issue_ids_cache"
-}
-
-exclusive_pr_ids() {
-  ensure_exclusive_pr_ids_cache
-  printf '%s\n' "$exclusive_pr_ids_cache"
-}
-
-ensure_running_issue_ids_cache() {
-  if [[ "$running_issue_ids_cache_loaded" != "yes" ]]; then
-    running_issue_ids_cache="$(heartbeat_list_running_issue_ids)"
-    running_issue_ids_cache_loaded="yes"
-  fi
-}
-
-ensure_exclusive_issue_ids_cache() {
-  if [[ "$exclusive_issue_ids_cache_loaded" != "yes" ]]; then
-    exclusive_issue_ids_cache="$(heartbeat_list_exclusive_issue_ids)"
-    exclusive_issue_ids_cache_loaded="yes"
-  fi
-}
-
-ensure_exclusive_pr_ids_cache() {
-  if [[ "$exclusive_pr_ids_cache_loaded" != "yes" ]]; then
-    exclusive_pr_ids_cache="$(heartbeat_list_exclusive_pr_ids)"
-    exclusive_pr_ids_cache_loaded="yes"
-  fi
-}
-
-ensure_ordered_ready_issue_ids_cache() {
-  if [[ "$ordered_ready_issue_ids_cache_loaded" != "yes" ]]; then
-    ordered_ready_issue_ids_cache="$(build_ordered_ready_issue_ids_cache)"
-    ordered_ready_issue_ids_cache_loaded="yes"
-  fi
-}
-
-ensure_blocked_recovery_issue_ids_cache() {
-  if [[ "$blocked_recovery_issue_ids_cache_loaded" != "yes" ]]; then
-    blocked_recovery_issue_ids_cache="$(heartbeat_list_blocked_recovery_issue_ids)"
-    blocked_recovery_issue_ids_cache_loaded="yes"
-  fi
-}
-
-sync_open_agent_issues() {
-  local issue_id status_out status
-  ensure_running_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_active "$issue_id"; then
-      if pending_issue_launch_counts_toward_capacity "$issue_id"; then
-        heartbeat_mark_issue_running "$issue_id" "$(cached_issue_attr heavy "$issue_id")" >/dev/null || true
-      fi
-      continue
-    fi
-    status_out="$(
-      "${shared_agent_home}/tools/bin/agent-project-worker-status" \
-        --runs-root "$runs_root" \
-        --session "${issue_prefix}${issue_id}"
-    )"
-    status="$(awk -F= '/^STATUS=/{print $2}' <<<"$status_out")"
-    case "$status" in
-      RUNNING)
-        ;;
-      *)
-        heartbeat_sync_issue_labels "$issue_id" >/dev/null || true
-        ;;
-    esac
-  done <<<"$running_issue_ids_cache"
-}
-
-sync_open_agent_prs() {
-  local pr_number status_out status
-  ensure_open_agent_pr_ids_cache
-  while IFS= read -r pr_number; do
-    [[ -n "$pr_number" ]] || continue
-    if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-      continue
-    fi
-    if pending_pr_launch_active "$pr_number"; then
-      heartbeat_mark_pr_running "$pr_number" >/dev/null || true
-      continue
-    fi
-    status_out="$(
-      "${shared_agent_home}/tools/bin/agent-project-worker-status" \
-        --runs-root "$runs_root" \
-        --session "${pr_prefix}${pr_number}"
-    )"
-    status="$(awk -F= '/^STATUS=/{print $2}' <<<"$status_out")"
-    case "$status" in
-      UNKNOWN)
-        heartbeat_clear_pr_running "$pr_number" >/dev/null || true
-        heartbeat_sync_pr_labels "$pr_number" >/dev/null || true
-        ;;
-      RUNNING)
-        ;;
-      *)
-        heartbeat_clear_pr_running "$pr_number" >/dev/null || true
-        heartbeat_sync_pr_labels "$pr_number" >/dev/null || true
-        ;;
-    esac
-  done <<<"$open_agent_pr_ids_cache"
-}
-
-next_pr_candidate_json() {
-  local target_lane pr_number risk_json lane
-  ensure_open_agent_pr_ids_cache
-  for target_lane in double-check-2 double-check-1 automerge merge-repair fix ci-refresh; do
-    while IFS= read -r pr_number; do
-      [[ -n "$pr_number" ]] || continue
-      if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-        continue
-      fi
-      if pr_launch_reserved "$pr_number"; then
-        continue
-      fi
-      if pending_pr_launch_active "$pr_number"; then
-        continue
-      fi
-      if ! retry_ready pr "$pr_number"; then
-        continue
-      fi
-      risk_json="$(cached_pr_risk_json "$pr_number")"
-      lane="$(jq -r '.agentLane' <<<"$risk_json")"
-      if [[ "$lane" == "$target_lane" ]]; then
-        printf '%s\n' "$risk_json"
-        return 0
-      fi
-    done <<<"$open_agent_pr_ids_cache"
-  done
-}
-
-next_priority_review_pr_candidate_json() {
-  local target_lane pr_number risk_json lane
-  ensure_open_agent_pr_ids_cache
-  for target_lane in double-check-2 double-check-1; do
-    while IFS= read -r pr_number; do
-      [[ -n "$pr_number" ]] || continue
-      if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-        continue
-      fi
-      if pr_launch_reserved "$pr_number"; then
-        continue
-      fi
-      if pending_pr_launch_active "$pr_number"; then
-        continue
-      fi
-      if ! retry_ready pr "$pr_number"; then
-        continue
-      fi
-      risk_json="$(cached_pr_risk_json "$pr_number")"
-      lane="$(jq -r '.agentLane' <<<"$risk_json")"
-      if [[ "$lane" == "$target_lane" ]]; then
-        printf '%s\n' "$risk_json"
-        return 0
-      fi
-    done <<<"$open_agent_pr_ids_cache"
-  done
-}
-
-eligible_pr_backlog_count() {
-  local pr_number risk_json lane count=0
-  ensure_open_agent_pr_ids_cache
-  while IFS= read -r pr_number; do
-    [[ -n "$pr_number" ]] || continue
-    if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-      continue
-    fi
-    if pr_launch_reserved "$pr_number"; then
-      continue
-    fi
-    if pending_pr_launch_active "$pr_number"; then
-      continue
-    fi
-    if ! retry_ready pr "$pr_number"; then
-      continue
-    fi
-    risk_json="$(cached_pr_risk_json "$pr_number")"
-    lane="$(jq -r '.agentLane' <<<"$risk_json")"
-    case "$lane" in
-      double-check-1|double-check-2|automerge|merge-repair|fix)
-        count=$((count + 1))
-        ;;
-    esac
-  done <<<"$open_agent_pr_ids_cache"
-  printf '%s\n' "$count"
-}
-
-priority_review_backlog_count() {
-  local pr_number risk_json lane count=0
-  ensure_open_agent_pr_ids_cache
-  while IFS= read -r pr_number; do
-    [[ -n "$pr_number" ]] || continue
-    if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-      continue
-    fi
-    if pr_launch_reserved "$pr_number"; then
-      continue
-    fi
-    if pending_pr_launch_active "$pr_number"; then
-      continue
-    fi
-    if ! retry_ready pr "$pr_number"; then
-      continue
-    fi
-    risk_json="$(cached_pr_risk_json "$pr_number")"
-    lane="$(jq -r '.agentLane' <<<"$risk_json")"
-    case "$lane" in
-      double-check-1|double-check-2)
-        count=$((count + 1))
-        ;;
-    esac
-  done <<<"$open_agent_pr_ids_cache"
-  printf '%s\n' "$count"
-}
-
-next_exclusive_pr_candidate_json() {
-  local target_lane pr_number risk_json lane
-  ensure_exclusive_pr_ids_cache
-  for target_lane in double-check-2 double-check-1 automerge merge-repair fix ci-refresh; do
-    while IFS= read -r pr_number; do
-      [[ -n "$pr_number" ]] || continue
-      if tmux has-session -t "${pr_prefix}${pr_number}" 2>/dev/null; then
-        continue
-      fi
-      if pr_launch_reserved "$pr_number"; then
-        continue
-      fi
-      if pending_pr_launch_active "$pr_number"; then
-        continue
-      fi
-      if ! retry_ready pr "$pr_number"; then
-        continue
-      fi
-      risk_json="$(cached_pr_risk_json "$pr_number")"
-      lane="$(jq -r '.agentLane' <<<"$risk_json")"
-      # Skip PRs requiring human review; they should not hold exclusive lock
-      if [[ "$lane" == "human-review" ]]; then
-        continue
-      fi
-      if [[ "$lane" == "$target_lane" ]]; then
-        printf '%s\n' "$risk_json"
-        return 0
-      fi
-    done <<<"$exclusive_pr_ids_cache"
-  done
-}
-
-next_exclusive_issue_id() {
-  local issue_id
-  ensure_exclusive_issue_ids_cache
-  while IFS= read -r issue_id; do
-    [[ -n "$issue_id" ]] || continue
-    if tmux has-session -t "${issue_prefix}${issue_id}" 2>/dev/null; then
-      continue
-    fi
-    if pending_issue_launch_active "$issue_id"; then
-      continue
-    fi
-    if ! retry_ready issue "$issue_id"; then
-      continue
-    fi
-    printf '%s\n' "$issue_id"
-    return 0
-  done <<<"$exclusive_issue_ids_cache"
-}
-
-count_pr_lane() {
-  local target_lane="${1:?target lane required}"
-  local pr_number risk_json lane count=0
-  ensure_open_agent_pr_ids_cache
-  while IFS= read -r pr_number; do
-    [[ -n "$pr_number" ]] || continue
-    risk_json="$(cached_pr_risk_json "$pr_number")"
-    lane="$(jq -r '.agentLane' <<<"$risk_json")"
-    if [[ "$lane" == "$target_lane" ]]; then
-      count=$((count + 1))
-    fi
-  done <<<"$open_agent_pr_ids_cache"
-  printf '%s\n' "$count"
-}
-
-human_review_pr_ids() {
-  local pr_number risk_json lane
-  ensure_open_agent_pr_ids_cache
-  while IFS= read -r pr_number; do
-    [[ -n "$pr_number" ]] || continue
-    risk_json="$(cached_pr_risk_json "$pr_number")"
-    lane="$(jq -r '.agentLane' <<<"$risk_json")"
-    if [[ "$lane" == "human-review" ]]; then
-      printf '%s\n' "$pr_number"
-    fi
-  done <<<"$open_agent_pr_ids_cache"
-}
-
-log_phase "reconcile-completed-workers:start"
-ensure_completed_workers_cache
-while IFS= read -r completed_session; do
-  [[ -n "$completed_session" ]] || continue
-  case "$completed_session" in
-    "${issue_prefix}"*)
-      if reconcile_out="$(heartbeat_reconcile_issue "$completed_session" 2>&1)"; then
-        record_memory "reconciled issue worker ${completed_session}"
-        print_block "RECONCILED_SESSION=${completed_session}" "$reconcile_out"
-      else
-        record_memory "failed to reconcile issue worker ${completed_session}"
-        print_block "RECONCILE_FAILED_SESSION=${completed_session}" "$reconcile_out"
-      fi
-      ;;
-    "${pr_prefix}"*)
-      if reconcile_out="$(heartbeat_reconcile_pr "$completed_session" 2>&1)"; then
-        record_memory "reconciled PR worker ${completed_session}"
-        print_block "RECONCILED_SESSION=${completed_session}" "$reconcile_out"
-      else
-        completed_pr_number="${completed_session#${pr_prefix}}"
-        if [[ -n "$completed_pr_number" ]]; then
-          heartbeat_clear_pr_running "$completed_pr_number" >/dev/null || true
-          heartbeat_sync_pr_labels "$completed_pr_number" >/dev/null || true
-        fi
-        record_memory "failed to reconcile PR worker ${completed_session}"
-        print_block "RECONCILE_FAILED_SESSION=${completed_session}" "$reconcile_out"
-      fi
-      ;;
-    *)
-      echo "unknown completed worker session: ${completed_session}" >&2
-      exit 1
-      ;;
-  esac
-done <<<"$completed_workers_cache"
-log_phase "reconcile-completed-workers:end"
-
-log_phase "sync-open-agent-issues:start"
-sync_open_agent_issues
-log_phase "sync-open-agent-issues:end"
-log_phase "sync-open-agent-prs:start"
-sync_open_agent_prs
-log_phase "sync-open-agent-prs:end"
+log_phase "sync-open-agent-issues:start"
+sync_open_agent_issues
+log_phase "sync-open-agent-issues:end"
+log_phase "sync-open-agent-prs:start"
+sync_open_agent_prs
+log_phase "sync-open-agent-prs:end"
 
 log_phase "snapshot-running-counts:start"
 running_workers_now="$(all_running_workers)"
@@ -1857,76 +575,6 @@ if provider_cooldown_out="$(provider_cooldown_state 2>/dev/null || true)"; then
   fi
 fi
 
-launch_pr_candidate_json() {
-  local pr_candidate_json="${1:?pr candidate json required}"
-  local pr_number pr_lane launch_out
-
-  pr_number="$(jq -r '.number' <<<"$pr_candidate_json")"
-  pr_lane="$(jq -r '.agentLane' <<<"$pr_candidate_json")"
-  stage_pr_launch "$pr_number"
-
-  case "$pr_lane" in
-    double-check-1|double-check-2|automerge)
-      if ! launch_out="$(heartbeat_start_pr_review_worker "$pr_number" 2>&1)"; then
-        heartbeat_clear_pr_running "$pr_number" || true
-        clear_launch_in_progress
-        record_memory "failed to launch PR review worker for #${pr_number}"
-        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
-        exit 1
-      fi
-      record_memory "launched PR review worker for #${pr_number}"
-      ;;
-    merge-repair)
-      if ! launch_out="$(heartbeat_start_pr_merge_repair_worker "$pr_number" 2>&1)"; then
-        heartbeat_clear_pr_running "$pr_number" || true
-        clear_launch_in_progress
-        record_memory "failed to launch PR merge-repair worker for #${pr_number}"
-        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
-        exit 1
-      fi
-      record_memory "launched PR merge-repair worker for #${pr_number}"
-      ;;
-    ci-refresh)
-      if ! launch_out="$(heartbeat_start_pr_ci_refresh "$pr_number" 2>&1)"; then
-        heartbeat_clear_pr_running "$pr_number" || true
-        clear_launch_in_progress
-        record_memory "failed to trigger PR ci-refresh for #${pr_number}"
-        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
-        exit 1
-      fi
-      heartbeat_clear_pr_running "$pr_number" || true
-      record_memory "triggered PR ci-refresh for #${pr_number}"
-      ;;
-    fix)
-      if ! launch_out="$(heartbeat_start_pr_fix_worker "$pr_number" 2>&1)"; then
-        heartbeat_clear_pr_running "$pr_number" || true
-        clear_launch_in_progress
-        record_memory "failed to launch PR fix worker for #${pr_number}"
-        print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
-        exit 1
-      fi
-      record_memory "launched PR fix worker for #${pr_number}"
-      ;;
-    *)
-      launch_out="Unsupported PR lane: ${pr_lane}"
-      heartbeat_clear_pr_running "$pr_number" || true
-      clear_launch_in_progress
-      print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
-      exit 1
-      ;;
-  esac
-
-  clear_launch_in_progress
-  print_block "LAUNCHED_PR=${pr_number}" "$(printf 'LANE=%s\n%s' "$pr_lane" "$launch_out")"
-  if [[ "$pr_lane" != "ci-refresh" ]]; then
-    running_total_count=$((running_total_count + 1))
-    running_pr_count=$((running_pr_count + 1))
-  fi
-  launched_pr_count=$((launched_pr_count + 1))
-  if (( launch_budget_remaining > 0 )); then
-    launch_budget_remaining=$((launch_budget_remaining - 1))
-  fi
-}
 
 if [[ "$exclusive_lock_mode" == "pending" && "$exclusive_lock_kind" == "pr" ]]; then
   pr_number="$exclusive_lock_item"