agent-control-plane 0.1.0

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

@@ -0,0 +1,2347 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage:
+  agent-project-heartbeat-loop --repo-slug <owner/repo> --runs-root <path> --state-root <path> --issue-prefix <prefix> --pr-prefix <prefix> --hook-file <path> [options]
+
+Shared scheduler loop for project adapters. The shared engine owns:
+  - completed worker reconciliation
+  - retry/cooldown gating
+  - concurrency accounting
+  - issue/PR launch ordering
+  - operational summary output
+
+Options:
+  --memory-dir <path>                Optional memory log root
+  --max-concurrent-workers <n>       Default 5
+  --max-concurrent-heavy-workers <n> Default 1
+  --max-concurrent-pr-workers <n>    Default 5
+  --max-recurring-issue-workers <n>  Default 1
+  --max-concurrent-scheduled-issue-workers <n> Default 0 (disabled)
+  --max-concurrent-scheduled-heavy-workers <n> Default 1
+  --max-concurrent-blocked-recovery-issue-workers <n> Default 0 (disabled)
+  --blocked-recovery-cooldown-seconds <n> Default 0 (disabled)
+  --max-open-agent-prs-for-recurring <n> Default 0 (disabled)
+  --max-launches-per-pass <n>        Default matches max-concurrent-workers
+  --heavy-running-label <name>       Default HEAVY_ISSUE
+  --heavy-deferred-key <name>        Default HEAVY_DEFERRED
+  --heavy-deferred-message <text>    Default heavy-queue message
+  --help                             Show this help
+EOF
+}
+
+shared_agent_home="${SHARED_AGENT_HOME:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+repo_slug=""
+runs_root=""
+state_root=""
+memory_dir=""
+issue_prefix=""
+pr_prefix=""
+hook_file=""
+max_concurrent_workers="5"
+max_concurrent_heavy_workers="1"
+max_concurrent_pr_workers="5"
+max_recurring_issue_workers="1"
+max_concurrent_scheduled_issue_workers="0"
+max_concurrent_scheduled_heavy_workers="1"
+max_concurrent_blocked_recovery_issue_workers="0"
+blocked_recovery_cooldown_seconds="0"
+max_open_agent_prs_for_recurring="0"
+max_launches_per_pass="$max_concurrent_workers"
+heavy_running_label="HEAVY_ISSUE"
+heavy_deferred_key="HEAVY_DEFERRED"
+heavy_deferred_message="Heavy issues remain queued until the heavy slot is free."
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo-slug) repo_slug="${2:-}"; shift 2 ;;
+    --runs-root) runs_root="${2:-}"; shift 2 ;;
+    --state-root) state_root="${2:-}"; shift 2 ;;
+    --memory-dir) memory_dir="${2:-}"; shift 2 ;;
+    --issue-prefix) issue_prefix="${2:-}"; shift 2 ;;
+    --pr-prefix) pr_prefix="${2:-}"; shift 2 ;;
+    --hook-file) hook_file="${2:-}"; shift 2 ;;
+    --max-concurrent-workers) max_concurrent_workers="${2:-}"; shift 2 ;;
+    --max-concurrent-heavy-workers) max_concurrent_heavy_workers="${2:-}"; shift 2 ;;
+    --max-concurrent-pr-workers) max_concurrent_pr_workers="${2:-}"; shift 2 ;;
+    --max-recurring-issue-workers) max_recurring_issue_workers="${2:-}"; shift 2 ;;
+    --max-concurrent-scheduled-issue-workers) max_concurrent_scheduled_issue_workers="${2:-}"; shift 2 ;;
+    --max-concurrent-scheduled-heavy-workers) max_concurrent_scheduled_heavy_workers="${2:-}"; shift 2 ;;
+    --max-concurrent-blocked-recovery-issue-workers) max_concurrent_blocked_recovery_issue_workers="${2:-}"; shift 2 ;;
+    --blocked-recovery-cooldown-seconds) blocked_recovery_cooldown_seconds="${2:-}"; shift 2 ;;
+    --max-open-agent-prs-for-recurring) max_open_agent_prs_for_recurring="${2:-}"; shift 2 ;;
+    --max-launches-per-pass) max_launches_per_pass="${2:-}"; shift 2 ;;
+    --heavy-running-label) heavy_running_label="${2:-}"; shift 2 ;;
+    --heavy-deferred-key) heavy_deferred_key="${2:-}"; shift 2 ;;
+    --heavy-deferred-message) heavy_deferred_message="${2:-}"; shift 2 ;;
+    --help|-h) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
+  esac
+done
+
+if [[ -z "$repo_slug" || -z "$runs_root" || -z "$state_root" || -z "$issue_prefix" || -z "$pr_prefix" || -z "$hook_file" ]]; then
+  usage >&2
+  exit 1
+fi
+
+mkdir -p "$runs_root"
+memory_file=""
+tmux_sessions_cache=""
+tmux_sessions_cache_loaded="no"
+auth_wait_workers_cache=""
+auth_wait_workers_cache_loaded="no"
+all_running_workers_cache=""
+all_running_workers_cache_loaded="no"
+running_issue_workers_cache=""
+running_issue_workers_cache_loaded="no"
+running_pr_workers_cache=""
+running_pr_workers_cache_loaded="no"
+completed_workers_cache=""
+completed_workers_cache_loaded="no"
+ready_issue_ids_cache=""
+ready_issue_ids_cache_loaded="no"
+open_agent_pr_ids_cache=""
+open_agent_pr_ids_cache_loaded="no"
+running_issue_ids_cache=""
+running_issue_ids_cache_loaded="no"
+exclusive_issue_ids_cache=""
+exclusive_issue_ids_cache_loaded="no"
+exclusive_pr_ids_cache=""
+exclusive_pr_ids_cache_loaded="no"
+blocked_recovery_issue_ids_cache=""
+blocked_recovery_issue_ids_cache_loaded="no"
+ordered_ready_issue_ids_cache=""
+ordered_ready_issue_ids_cache_loaded="no"
+due_scheduled_issue_ids_cache=""
+due_scheduled_issue_ids_cache_loaded="no"
+due_blocked_recovery_issue_ids_cache=""
+due_blocked_recovery_issue_ids_cache_loaded="no"
+issue_attr_cache_dir=""
+pr_attr_cache_dir=""
+pr_risk_cache_dir=""
+pr_risk_runtime_cache_dir="${state_root}/pr-risk-cache"
+pr_risk_runtime_cache_ttl_seconds="${ACP_PR_RISK_CACHE_TTL_SECONDS:-${F_LOSNING_PR_RISK_CACHE_TTL_SECONDS:-300}}"
+recurring_rotation_dir="${state_root}/recurring"
+recurring_rotation_file="${recurring_rotation_dir}/last-launched-issue-id"
+scheduled_state_dir="${state_root}/scheduled-issues"
+blocked_recovery_state_dir="${state_root}/blocked-recovery-issues"
+pending_launch_dir="${state_root}/pending-launches"
+if [[ -n "$memory_dir" ]]; then
+  mkdir -p "$memory_dir"
+  memory_file="${memory_dir}/$(date +%F).md"
+  touch "$memory_file"
+fi
+mkdir -p "$recurring_rotation_dir"
+mkdir -p "$scheduled_state_dir"
+mkdir -p "$blocked_recovery_state_dir"
+mkdir -p "$pending_launch_dir"
+mkdir -p "$pr_risk_runtime_cache_dir"
+
+record_memory() {
+  local message="${1:?message required}"
+  [[ -n "$memory_file" ]] || return 0
+  printf -- "- %s %s\n" "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "$message" >>"$memory_file"
+}
+
+print_block() {
+  local header="${1:?header required}"
+  local body="${2:-}"
+  printf '%s\n' "$header"
+  if [[ -n "$body" ]]; then
+    printf '%s\n' "$body"
+  fi
+}
+
+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
+fi
+# shellcheck source=/dev/null
+source "$hook_file"
+
+resident_lib="${shared_agent_home}/skills/openclaw/agent-control-plane/tools/bin/flow-resident-worker-lib.sh"
+if [[ -f "${resident_lib}" ]]; then
+  # shellcheck source=/dev/null
+  source "${resident_lib}"
+fi
+
+if declare -F flow_resident_issue_reap_stale_state >/dev/null 2>&1; then
+  flow_resident_issue_reap_stale_state >/dev/null 2>&1 || true
+fi
+
+required_hooks=(
+  heartbeat_list_ready_issue_ids
+  heartbeat_list_open_agent_pr_ids
+  heartbeat_issue_is_heavy
+  heartbeat_issue_is_recurring
+  heartbeat_sync_pr_labels
+  heartbeat_pr_risk_json
+  heartbeat_mark_issue_running
+  heartbeat_issue_launch_failed
+  heartbeat_start_issue_worker
+  heartbeat_mark_pr_running
+  heartbeat_clear_pr_running
+  heartbeat_start_pr_merge_repair_worker
+  heartbeat_start_pr_review_worker
+  heartbeat_start_pr_fix_worker
+  heartbeat_start_pr_ci_refresh
+  heartbeat_reconcile_issue
+  heartbeat_reconcile_pr
+)
+
+for hook_name in "${required_hooks[@]}"; do
+  if ! declare -F "$hook_name" >/dev/null 2>&1; then
+    echo "missing required heartbeat hook: $hook_name" >&2
+    exit 1
+  fi
+done
+
+if ! declare -F heartbeat_list_exclusive_issue_ids >/dev/null 2>&1; then
+  heartbeat_list_exclusive_issue_ids() { :; }
+fi
+
+if ! declare -F heartbeat_list_exclusive_pr_ids >/dev/null 2>&1; then
+  heartbeat_list_exclusive_pr_ids() { :; }
+fi
+
+if ! declare -F heartbeat_issue_is_exclusive >/dev/null 2>&1; then
+  heartbeat_issue_is_exclusive() { printf 'no\n'; }
+fi
+
+if ! declare -F heartbeat_pr_is_exclusive >/dev/null 2>&1; then
+  heartbeat_pr_is_exclusive() { printf 'no\n'; }
+fi
+
+if ! declare -F heartbeat_list_running_issue_ids >/dev/null 2>&1; then
+  heartbeat_list_running_issue_ids() { :; }
+fi
+
+if ! declare -F heartbeat_list_blocked_recovery_issue_ids >/dev/null 2>&1; then
+  heartbeat_list_blocked_recovery_issue_ids() { :; }
+fi
+
+if ! declare -F heartbeat_sync_issue_labels >/dev/null 2>&1; then
+  heartbeat_sync_issue_labels() { :; }
+fi
+
+launch_in_progress_kind=""
+launch_in_progress_id=""
+launch_in_progress_issue_is_heavy="no"
+launch_in_progress_cleanup_enabled="no"
+reserved_pr_launch_ids=""
+
+clear_launch_in_progress() {
+  launch_in_progress_kind=""
+  launch_in_progress_id=""
+  launch_in_progress_issue_is_heavy="no"
+  launch_in_progress_cleanup_enabled="no"
+}
+
+pr_launch_reserved() {
+  local pr_number="${1:?pr number required}"
+  [[ -n "$reserved_pr_launch_ids" ]] || return 1
+  grep -Fxq "$pr_number" <<<"$reserved_pr_launch_ids"
+}
+
+reserve_pr_launch() {
+  local pr_number="${1:?pr number required}"
+  if pr_launch_reserved "$pr_number"; then
+    return 0
+  fi
+  reserved_pr_launch_ids+="${pr_number}"$'\n'
+}
+
+cleanup_scheduler_caches() {
+  tmux_sessions_cache=""
+  tmux_sessions_cache_loaded="no"
+  all_running_workers_cache=""
+  all_running_workers_cache_loaded="no"
+  running_issue_workers_cache=""
+  running_issue_workers_cache_loaded="no"
+  running_pr_workers_cache=""
+  running_pr_workers_cache_loaded="no"
+  completed_workers_cache=""
+  completed_workers_cache_loaded="no"
+  ready_issue_ids_cache=""
+  ready_issue_ids_cache_loaded="no"
+  open_agent_pr_ids_cache=""
+  open_agent_pr_ids_cache_loaded="no"
+  running_issue_ids_cache=""
+  running_issue_ids_cache_loaded="no"
+  exclusive_issue_ids_cache=""
+  exclusive_issue_ids_cache_loaded="no"
+  exclusive_pr_ids_cache=""
+  exclusive_pr_ids_cache_loaded="no"
+  blocked_recovery_issue_ids_cache=""
+  blocked_recovery_issue_ids_cache_loaded="no"
+  ordered_ready_issue_ids_cache=""
+  ordered_ready_issue_ids_cache_loaded="no"
+  due_scheduled_issue_ids_cache=""
+  due_scheduled_issue_ids_cache_loaded="no"
+  due_blocked_recovery_issue_ids_cache=""
+  due_blocked_recovery_issue_ids_cache_loaded="no"
+  if [[ -n "${issue_attr_cache_dir:-}" && -d "${issue_attr_cache_dir}" ]]; then
+    rm -rf "${issue_attr_cache_dir}" || true
+  fi
+  if [[ -n "${pr_attr_cache_dir:-}" && -d "${pr_attr_cache_dir}" ]]; then
+    rm -rf "${pr_attr_cache_dir}" || true
+  fi
+  if [[ -n "${pr_risk_cache_dir:-}" && -d "${pr_risk_cache_dir}" ]]; then
+    rm -rf "${pr_risk_cache_dir}" || true
+  fi
+}
+
+stage_issue_launch() {
+  local issue_id="${1:?issue id required}"
+  local is_heavy="${2:-no}"
+  launch_in_progress_kind="issue"
+  launch_in_progress_id="$issue_id"
+  launch_in_progress_issue_is_heavy="$is_heavy"
+  launch_in_progress_cleanup_enabled="yes"
+  heartbeat_mark_issue_running "$issue_id" "$is_heavy"
+}
+
+stage_pr_launch() {
+  local pr_number="${1:?pr number required}"
+  reserve_pr_launch "$pr_number"
+  launch_in_progress_kind="pr"
+  launch_in_progress_id="$pr_number"
+  launch_in_progress_issue_is_heavy="no"
+  launch_in_progress_cleanup_enabled="yes"
+  heartbeat_mark_pr_running "$pr_number"
+}
+
+rollback_launch_in_progress() {
+  # Always cleanup caches on exit to avoid leaks
+  cleanup_scheduler_caches
+  # Only rollback labels if a launch was in progress and failed
+  if [[ "${launch_in_progress_cleanup_enabled:-no}" == "yes" ]]; then
+    case "${launch_in_progress_kind:-}" in
+      issue)
+        if [[ -n "${launch_in_progress_id:-}" ]]; then
+          heartbeat_issue_launch_failed "${launch_in_progress_id}" >/dev/null 2>&1 || true
+        fi
+        ;;
+      pr)
+        if [[ -n "${launch_in_progress_id:-}" ]]; then
+          heartbeat_clear_pr_running "${launch_in_progress_id}" >/dev/null 2>&1 || true
+        fi
+        ;;
+    esac
+  fi
+  clear_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 ))
+}
+
+cached_issue_attr() {
+  local attr_name="${1:?attr name required}"
+  local issue_id="${2:?issue id required}"
+  local cache_file attr_value
+
+  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
+
+  case "${attr_name}" in
+    heavy)
+      attr_value="$(heartbeat_issue_is_heavy "${issue_id}")"
+      ;;
+    recurring)
+      attr_value="$(heartbeat_issue_is_recurring "${issue_id}")"
+      ;;
+    scheduled)
+      attr_value="$(heartbeat_issue_is_scheduled "${issue_id}")"
+      ;;
+    schedule_interval_seconds)
+      attr_value="$(heartbeat_issue_schedule_interval_seconds "${issue_id}")"
+      ;;
+    exclusive)
+      attr_value="$(heartbeat_issue_is_exclusive "${issue_id}")"
+      ;;
+    *)
+      echo "unsupported issue cache attr: ${attr_name}" >&2
+      return 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
+  fi
+
+  if pr_risk_runtime_cache_fresh "${runtime_cache_file}"; then
+    cp "${runtime_cache_file}" "${cache_file}"
+    cat "${cache_file}"
+    return 0
+  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"
+}
+
+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"
+}
+
+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"
+  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
+    for issue_id in "${recurring_ids[@]}"; do
+      if [[ "$seen_last" == "yes" ]]; then
+        printf '%s\n' "$issue_id"
+      fi
+      if [[ "$issue_id" == "$last_recurring_issue" ]]; then
+        seen_last="yes"
+      fi
+    done
+  fi
+
+  for issue_id in "${recurring_ids[@]}"; do
+    if [[ -n "$last_recurring_issue" && "$seen_last" == "yes" && "$issue_id" == "$last_recurring_issue" ]]; then
+      break
+    fi
+    printf '%s\n' "$issue_id"
+  done
+}
+
+completed_workers() {
+  ensure_completed_workers_cache
+  printf '%s\n' "$completed_workers_cache"
+}
+
+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
+    [[ -f "$dir/reconciled.ok" ]] && continue
+    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")"
+    if [[ "$status" == "UNKNOWN" ]]; then
+      heartbeat_sync_issue_labels "$issue_id" >/dev/null || true
+    fi
+  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 "snapshot-running-counts:start"
+running_workers_now="$(all_running_workers)"
+auth_wait_workers_now="$(auth_wait_workers)"
+running_issue_workers_now="$(running_issue_workers)"
+running_pr_workers_now="$(running_pr_workers)"
+pending_issue_count="$(pending_issue_launch_count)"
+pending_pr_count="$(pending_pr_launch_count)"
+pending_heavy_issue_count="$(pending_heavy_issue_launch_count)"
+pending_scheduled_issue_count="$(pending_scheduled_issue_launch_count)"
+pending_scheduled_heavy_issue_count="$(pending_scheduled_heavy_issue_launch_count)"
+pending_recurring_issue_count="$(pending_recurring_issue_launch_count)"
+pending_blocked_recovery_issue_count="$(pending_blocked_recovery_issue_launch_count)"
+pending_exclusive_issue_count="$(pending_exclusive_issue_launch_count)"
+pending_exclusive_pr_count="$(pending_exclusive_pr_launch_count)"
+auth_wait_worker_count="$(worker_count "$auth_wait_workers_now")"
+running_issue_count="$(worker_count "$running_issue_workers_now")"
+running_pr_count="$(worker_count "$running_pr_workers_now")"
+running_total_count=$((running_issue_count + running_pr_count))
+running_issue_count=$((running_issue_count + pending_issue_count))
+running_pr_count=$((running_pr_count + pending_pr_count))
+running_total_count=$((running_total_count + pending_issue_count + pending_pr_count))
+running_heavy_issue_count="$(running_heavy_issue_workers)"
+running_non_recurring_issue_count="$(running_non_recurring_issue_workers)"
+running_recurring_issue_count="$(running_recurring_issue_workers)"
+running_scheduled_issue_count="$(running_scheduled_issue_workers)"
+running_scheduled_heavy_issue_count="$(running_scheduled_heavy_issue_workers)"
+running_blocked_recovery_issue_count="$(running_blocked_recovery_issue_workers)"
+running_exclusive_issue_count="$(running_exclusive_issue_workers)"
+running_exclusive_pr_count="$(running_exclusive_pr_workers)"
+running_heavy_issue_count=$((running_heavy_issue_count + pending_heavy_issue_count))
+running_scheduled_issue_count=$((running_scheduled_issue_count + pending_scheduled_issue_count))
+running_scheduled_heavy_issue_count=$((running_scheduled_heavy_issue_count + pending_scheduled_heavy_issue_count))
+running_recurring_issue_count=$((running_recurring_issue_count + pending_recurring_issue_count))
+running_blocked_recovery_issue_count=$((running_blocked_recovery_issue_count + pending_blocked_recovery_issue_count))
+running_non_recurring_issue_count=$((running_non_recurring_issue_count + pending_issue_count - pending_recurring_issue_count - pending_scheduled_issue_count))
+running_exclusive_issue_count=$((running_exclusive_issue_count + pending_exclusive_issue_count))
+running_exclusive_pr_count=$((running_exclusive_pr_count + pending_exclusive_pr_count))
+ensure_open_agent_pr_ids_cache
+open_agent_pr_count="$(worker_count "$open_agent_pr_ids_cache")"
+ready_non_recurring_count="$(ready_non_recurring_issue_count)"
+log_phase "snapshot-running-counts:end"
+
+exclusive_lock_mode="no"
+exclusive_lock_kind=""
+exclusive_lock_item=""
+exclusive_waiting_reason=""
+ensure_exclusive_pr_ids_cache
+ensure_exclusive_issue_ids_cache
+exclusive_pr_item_id="${exclusive_pr_ids_cache%%$'\n'*}"
+exclusive_issue_item_id="${exclusive_issue_ids_cache%%$'\n'*}"
+[[ "$exclusive_pr_item_id" == "$exclusive_pr_ids_cache" && -z "$exclusive_pr_ids_cache" ]] && exclusive_pr_item_id=""
+[[ "$exclusive_issue_item_id" == "$exclusive_issue_ids_cache" && -z "$exclusive_issue_ids_cache" ]] && exclusive_issue_item_id=""
+exclusive_pr_risk_json=""
+
+if (( running_exclusive_issue_count + running_exclusive_pr_count > 0 )); then
+  exclusive_lock_mode="running"
+elif [[ -n "$exclusive_pr_item_id" ]]; then
+  exclusive_lock_mode="pending"
+  exclusive_lock_kind="pr"
+  exclusive_lock_item="$exclusive_pr_item_id"
+  exclusive_pr_risk_json="$(cached_pr_risk_json "$exclusive_pr_item_id")"
+elif [[ -n "$exclusive_issue_item_id" ]]; then
+  exclusive_lock_mode="pending"
+  exclusive_lock_kind="issue"
+  exclusive_lock_item="$exclusive_issue_item_id"
+fi
+
+launched_issue_count=0
+launched_pr_count=0
+launch_budget_remaining="$max_launches_per_pass"
+heavy_deferred_count=0
+retry_deferred_issue_count=0
+provider_launch_suppressed="no"
+provider_cooldown_backend=""
+provider_cooldown_model=""
+provider_cooldown_until=""
+provider_cooldown_reason=""
+issue_capacity_limit="$max_concurrent_workers"
+reserved_pr_slots=0
+pr_backlog_eligible_count=0
+priority_review_backlog_count=0
+priority_review_launches_remaining="${ACP_MAX_DOUBLE_CHECK_FAST_LAUNCHES:-${F_LOSNING_MAX_DOUBLE_CHECK_FAST_LAUNCHES:-3}}"
+
+if provider_cooldown_out="$(provider_cooldown_state 2>/dev/null || true)"; then
+  provider_cooldown_ready="$(awk -F= '/^READY=/{print $2}' <<<"$provider_cooldown_out")"
+  provider_cooldown_backend="$(awk -F= '/^BACKEND=/{print $2}' <<<"$provider_cooldown_out")"
+  provider_cooldown_model="$(awk -F= '/^MODEL=/{print $2}' <<<"$provider_cooldown_out")"
+  provider_cooldown_until="$(awk -F= '/^NEXT_ATTEMPT_AT=/{print $2}' <<<"$provider_cooldown_out")"
+  provider_cooldown_reason="$(awk -F= '/^LAST_REASON=/{print $2}' <<<"$provider_cooldown_out")"
+  if [[ "${provider_cooldown_ready}" == "no" ]]; then
+    provider_launch_suppressed="yes"
+    launch_budget_remaining=0
+  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"
+  pr_lane="$(jq -r '.agentLane' <<<"$exclusive_pr_risk_json")"
+  if pending_pr_launch_active "$pr_number"; then
+    exclusive_waiting_reason="launch-pending"
+  elif [[ "$pr_lane" == "human-review" ]]; then
+    # Do not lock exclusive for PRs requiring human review; treat as normal PR
+    exclusive_waiting_reason=""
+    exclusive_lock_mode="no"
+    exclusive_lock_kind=""
+    exclusive_lock_item=""
+  elif [[ "$pr_lane" != "double-check-1" && "$pr_lane" != "double-check-2" && "$pr_lane" != "automerge" && "$pr_lane" != "merge-repair" && "$pr_lane" != "ci-refresh" && "$pr_lane" != "fix" ]]; then
+    exclusive_waiting_reason="lane-${pr_lane}"
+  elif [[ "$provider_launch_suppressed" == "yes" ]]; then
+    exclusive_waiting_reason="provider-cooldown"
+  elif ! retry_ready pr "$pr_number"; then
+    exclusive_waiting_reason="retry-cooldown"
+  elif (( running_pr_count >= max_concurrent_pr_workers )); then
+    exclusive_waiting_reason="pr-capacity-full"
+  elif (( running_total_count >= max_concurrent_workers )); then
+    exclusive_waiting_reason="capacity-full"
+  else
+    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 exclusive PR review worker for #${pr_number}"
+          print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+          exit 1
+        fi
+        record_memory "launched exclusive 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 exclusive PR merge-repair worker for #${pr_number}"
+          print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+          exit 1
+        fi
+        record_memory "launched exclusive 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 exclusive 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 exclusive 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 exclusive PR fix worker for #${pr_number}"
+          print_block "LAUNCH_FAILED_PR=${pr_number}" "$launch_out"
+          exit 1
+        fi
+        record_memory "launched exclusive PR fix worker for #${pr_number}"
+        ;;
+    esac
+    clear_launch_in_progress
+    print_block "LAUNCHED_PR=${pr_number}" "$(printf 'LANE=%s\nEXCLUSIVE=yes\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))
+      running_exclusive_pr_count=$((running_exclusive_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
+    exclusive_lock_mode="running"
+    exclusive_waiting_reason=""
+  fi
+elif [[ "$exclusive_lock_mode" == "pending" && "$exclusive_lock_kind" == "issue" ]]; then
+  issue_id="$exclusive_lock_item"
+  is_heavy="$(cached_issue_attr heavy "$issue_id")"
+  is_recurring="$(cached_issue_attr recurring "$issue_id")"
+  if pending_issue_launch_active "$issue_id"; then
+    exclusive_waiting_reason="launch-pending"
+  elif [[ "$provider_launch_suppressed" == "yes" ]]; then
+    exclusive_waiting_reason="provider-cooldown"
+  elif ! retry_ready issue "$issue_id"; then
+    exclusive_waiting_reason="retry-cooldown"
+  elif (( running_total_count >= max_concurrent_workers )); then
+    exclusive_waiting_reason="capacity-full"
+  elif [[ "$is_heavy" == "yes" ]] && (( running_heavy_issue_count >= max_concurrent_heavy_workers )); then
+    exclusive_waiting_reason="heavy-slot-busy"
+  else
+    stage_issue_launch "$issue_id" "$is_heavy"
+    if ! launch_out="$(heartbeat_start_issue_worker "$issue_id" 2>&1)"; then
+      heartbeat_issue_launch_failed "$issue_id" "$is_heavy" || true
+      clear_launch_in_progress
+      record_memory "failed to launch exclusive issue worker for #${issue_id}"
+      print_block "LAUNCH_FAILED_ISSUE=${issue_id}" "$launch_out"
+      exit 1
+    fi
+
+    clear_launch_in_progress
+    record_memory "launched exclusive issue worker for #${issue_id}"
+    print_block "LAUNCHED_ISSUE=${issue_id}" "$(printf 'EXCLUSIVE=yes\n%s' "$launch_out")"
+    launched_issue_count=$((launched_issue_count + 1))
+    if (( launch_budget_remaining > 0 )); then
+      launch_budget_remaining=$((launch_budget_remaining - 1))
+    fi
+    running_total_count=$((running_total_count + 1))
+    running_issue_count=$((running_issue_count + 1))
+    running_exclusive_issue_count=$((running_exclusive_issue_count + 1))
+    if [[ "$is_heavy" == "yes" ]]; then
+      running_heavy_issue_count=$((running_heavy_issue_count + 1))
+    fi
+    if [[ "$is_recurring" == "yes" ]]; then
+      running_recurring_issue_count=$((running_recurring_issue_count + 1))
+      record_recurring_issue_launch "$issue_id"
+    else
+      running_non_recurring_issue_count=$((running_non_recurring_issue_count + 1))
+    fi
+    exclusive_lock_mode="running"
+    exclusive_waiting_reason=""
+  fi
+fi
+
+if [[ "$exclusive_lock_mode" == "no" ]]; then
+  launch_budget_remaining="${launch_budget_remaining:-$max_launches_per_pass}"
+  priority_review_launches_remaining="${priority_review_launches_remaining:-${ACP_MAX_DOUBLE_CHECK_FAST_LAUNCHES:-${F_LOSNING_MAX_DOUBLE_CHECK_FAST_LAUNCHES:-3}}}"
+  log_phase "launch-planning:start"
+  log_phase "launch-planning:scheduled-issue-loop:start"
+  ensure_due_scheduled_issue_ids_cache
+  while IFS= read -r issue_id; do
+    [[ -n "$issue_id" ]] || continue
+    if (( launch_budget_remaining <= 0 )); then
+      break
+    fi
+    if pending_issue_launch_active "$issue_id"; then
+      continue
+    fi
+    if (( running_scheduled_issue_count >= max_concurrent_scheduled_issue_workers )); then
+      break
+    fi
+
+    is_heavy="$(cached_issue_attr heavy "$issue_id")"
+    if [[ "$is_heavy" == "yes" ]] && (( running_scheduled_heavy_issue_count >= max_concurrent_scheduled_heavy_workers )); then
+      heavy_deferred_count=$((heavy_deferred_count + 1))
+      continue
+    fi
+
+    stage_issue_launch "$issue_id" "$is_heavy"
+    if ! launch_out="$(heartbeat_start_issue_worker "$issue_id" 2>&1)"; then
+      heartbeat_issue_launch_failed "$issue_id" "$is_heavy" || true
+      clear_launch_in_progress
+      record_memory "failed to launch scheduled issue worker for #${issue_id}"
+      print_block "LAUNCH_FAILED_SCHEDULED_ISSUE=${issue_id}" "$launch_out"
+      exit 1
+    fi
+
+    clear_launch_in_progress
+    record_scheduled_issue_launch "$issue_id"
+    record_memory "launched scheduled issue worker for #${issue_id}"
+    print_block "LAUNCHED_SCHEDULED_ISSUE=${issue_id}" "$(printf 'SCHEDULED=yes\n%s' "$launch_out")"
+    launched_issue_count=$((launched_issue_count + 1))
+    if (( launch_budget_remaining > 0 )); then
+      launch_budget_remaining=$((launch_budget_remaining - 1))
+    fi
+    running_total_count=$((running_total_count + 1))
+    running_issue_count=$((running_issue_count + 1))
+    running_scheduled_issue_count=$((running_scheduled_issue_count + 1))
+    if [[ "$is_heavy" == "yes" ]]; then
+      running_heavy_issue_count=$((running_heavy_issue_count + 1))
+      running_scheduled_heavy_issue_count=$((running_scheduled_heavy_issue_count + 1))
+    fi
+  done <<<"$due_scheduled_issue_ids_cache"
+  log_phase "launch-planning:scheduled-issue-loop:end"
+  # Fast-path independent review lanes so high-risk PRs do not wait behind
+  # issue work or lower-priority PR lanes in short heartbeat windows.
+  log_phase "launch-planning:priority-review:start"
+  while (( priority_review_launches_remaining > 0 )) && (( launch_budget_remaining > 0 )) && (( running_pr_count < max_concurrent_pr_workers )) && (( running_total_count < max_concurrent_workers )); do
+    pr_candidate_json="$(next_priority_review_pr_candidate_json || true)"
+    [[ -n "$pr_candidate_json" ]] || break
+    launch_pr_candidate_json "$pr_candidate_json"
+    priority_review_launches_remaining=$((priority_review_launches_remaining - 1))
+  done
+  log_phase "launch-planning:priority-review:end"
+  log_phase "launch-planning:first-pr:start"
+  if (( launch_budget_remaining > 0 )) && (( running_pr_count < max_concurrent_pr_workers )) && (( running_total_count < max_concurrent_workers )); then
+    pr_candidate_json="$(next_pr_candidate_json || true)"
+    if [[ -n "$pr_candidate_json" ]]; then
+      # Launch a PR before issue work so short heartbeat windows do not starve PR lanes.
+      launch_pr_candidate_json "$pr_candidate_json"
+    fi
+  fi
+  log_phase "launch-planning:first-pr:end"
+
+  log_phase "launch-planning:backlog-counts:start"
+  pr_backlog_eligible_count="$(eligible_pr_backlog_count)"
+  priority_review_backlog_count="$(priority_review_backlog_count)"
+  if (( pr_backlog_eligible_count > 0 )); then
+    reserved_pr_slots=4
+    if (( priority_review_backlog_count > reserved_pr_slots )); then
+      reserved_pr_slots="$priority_review_backlog_count"
+    fi
+    if (( reserved_pr_slots > pr_backlog_eligible_count )); then
+      reserved_pr_slots="$pr_backlog_eligible_count"
+    fi
+    if (( reserved_pr_slots > max_concurrent_pr_workers - running_pr_count )); then
+      reserved_pr_slots=$((max_concurrent_pr_workers - running_pr_count))
+    fi
+    if (( reserved_pr_slots > max_concurrent_workers - running_total_count )); then
+      reserved_pr_slots=$((max_concurrent_workers - running_total_count))
+    fi
+    if (( reserved_pr_slots < 0 )); then
+      reserved_pr_slots=0
+    fi
+  fi
+  issue_capacity_limit=$((max_concurrent_workers - reserved_pr_slots))
+  if (( issue_capacity_limit < running_total_count )); then
+    issue_capacity_limit="$running_total_count"
+  fi
+  log_phase "launch-planning:backlog-counts:end"
+
+  log_phase "launch-planning:blocked-recovery-loop:start"
+  ensure_due_blocked_recovery_issue_ids_cache
+  while IFS= read -r issue_id; do
+    [[ -n "$issue_id" ]] || continue
+    if pending_issue_launch_active "$issue_id"; then
+      continue
+    fi
+    if (( max_concurrent_blocked_recovery_issue_workers <= 0 )); then
+      break
+    fi
+    if (( launch_budget_remaining <= 0 )); then
+      break
+    fi
+    if (( running_total_count >= max_concurrent_workers )); then
+      break
+    fi
+    if (( running_blocked_recovery_issue_count >= max_concurrent_blocked_recovery_issue_workers )); then
+      break
+    fi
+    if ! retry_ready issue "$issue_id"; then
+      retry_deferred_issue_count=$((retry_deferred_issue_count + 1))
+      continue
+    fi
+
+    is_heavy="$(cached_issue_attr heavy "$issue_id")"
+    is_recurring="$(cached_issue_attr recurring "$issue_id")"
+    if [[ "$is_recurring" == "yes" ]]; then
+      if (( running_recurring_issue_count >= max_recurring_issue_workers )); then
+        continue
+      fi
+      if (( max_open_agent_prs_for_recurring > 0 )) && (( open_agent_pr_count >= max_open_agent_prs_for_recurring )); then
+        continue
+      fi
+    fi
+    if [[ "$is_heavy" == "yes" ]] && (( running_heavy_issue_count >= max_concurrent_heavy_workers )); then
+      heavy_deferred_count=$((heavy_deferred_count + 1))
+      continue
+    fi
+
+    stage_issue_launch "$issue_id" "$is_heavy"
+    if ! launch_out="$(heartbeat_start_issue_worker "$issue_id" 2>&1)"; then
+      heartbeat_issue_launch_failed "$issue_id" "$is_heavy" || true
+      clear_launch_in_progress
+      clear_blocked_recovery_issue_state "$issue_id"
+      record_memory "failed to launch blocked-recovery issue worker for #${issue_id}"
+      print_block "LAUNCH_FAILED_BLOCKED_RECOVERY_ISSUE=${issue_id}" "$launch_out"
+      exit 1
+    fi
+
+    record_blocked_recovery_issue_launch "$issue_id"
+    clear_launch_in_progress
+    record_memory "launched blocked-recovery issue worker for #${issue_id}"
+    print_block "LAUNCHED_BLOCKED_RECOVERY_ISSUE=${issue_id}" "$(printf 'BLOCKED_RECOVERY=yes\n%s' "$launch_out")"
+    launched_issue_count=$((launched_issue_count + 1))
+    if (( launch_budget_remaining > 0 )); then
+      launch_budget_remaining=$((launch_budget_remaining - 1))
+    fi
+    running_total_count=$((running_total_count + 1))
+    running_issue_count=$((running_issue_count + 1))
+    running_blocked_recovery_issue_count=$((running_blocked_recovery_issue_count + 1))
+    if [[ "$is_heavy" == "yes" ]]; then
+      running_heavy_issue_count=$((running_heavy_issue_count + 1))
+    fi
+    if [[ "$is_recurring" == "yes" ]]; then
+      running_recurring_issue_count=$((running_recurring_issue_count + 1))
+      record_recurring_issue_launch "$issue_id"
+    else
+      running_non_recurring_issue_count=$((running_non_recurring_issue_count + 1))
+    fi
+  done <<<"$due_blocked_recovery_issue_ids_cache"
+  log_phase "launch-planning:blocked-recovery-loop:end"
+
+  log_phase "launch-planning:issue-loop:start"
+  ensure_ordered_ready_issue_ids_cache
+  while IFS= read -r issue_id; do
+    [[ -n "$issue_id" ]] || continue
+    if pending_issue_launch_active "$issue_id"; then
+      continue
+    fi
+    if (( launch_budget_remaining <= 0 )); then
+      break
+    fi
+    if (( running_total_count >= issue_capacity_limit )); then
+      break
+    fi
+    if ! retry_ready issue "$issue_id"; then
+      retry_deferred_issue_count=$((retry_deferred_issue_count + 1))
+      continue
+    fi
+
+    if [[ "$(cached_issue_attr scheduled "$issue_id")" == "yes" ]]; then
+      continue
+    fi
+
+    is_heavy="$(cached_issue_attr heavy "$issue_id")"
+    is_recurring="$(cached_issue_attr recurring "$issue_id")"
+    if [[ "$is_recurring" == "yes" ]]; then
+      if (( running_recurring_issue_count >= max_recurring_issue_workers )); then
+        continue
+      fi
+      if (( max_open_agent_prs_for_recurring > 0 )) && (( open_agent_pr_count >= max_open_agent_prs_for_recurring )); then
+        continue
+      fi
+    fi
+    if [[ "$is_heavy" == "yes" ]] && (( running_heavy_issue_count >= max_concurrent_heavy_workers )); then
+      heavy_deferred_count=$((heavy_deferred_count + 1))
+      continue
+    fi
+
+    stage_issue_launch "$issue_id" "$is_heavy"
+    if ! launch_out="$(heartbeat_start_issue_worker "$issue_id" 2>&1)"; then
+      heartbeat_issue_launch_failed "$issue_id" "$is_heavy" || true
+      clear_launch_in_progress
+      record_memory "failed to launch issue worker for #${issue_id}"
+      print_block "LAUNCH_FAILED_ISSUE=${issue_id}" "$launch_out"
+      exit 1
+    fi
+
+    clear_launch_in_progress
+    record_memory "launched issue worker for #${issue_id}"
+    print_block "LAUNCHED_ISSUE=${issue_id}" "$launch_out"
+    launched_issue_count=$((launched_issue_count + 1))
+    if (( launch_budget_remaining > 0 )); then
+      launch_budget_remaining=$((launch_budget_remaining - 1))
+    fi
+    running_total_count=$((running_total_count + 1))
+    running_issue_count=$((running_issue_count + 1))
+    if [[ "$is_heavy" == "yes" ]]; then
+      running_heavy_issue_count=$((running_heavy_issue_count + 1))
+    fi
+    if [[ "$is_recurring" == "yes" ]]; then
+      running_recurring_issue_count=$((running_recurring_issue_count + 1))
+      record_recurring_issue_launch "$issue_id"
+    else
+      running_non_recurring_issue_count=$((running_non_recurring_issue_count + 1))
+    fi
+  done <<<"$ordered_ready_issue_ids_cache"
+  log_phase "launch-planning:issue-loop:end"
+
+  log_phase "launch-planning:pr-fill:start"
+  while (( launch_budget_remaining > 0 )) && (( running_pr_count < max_concurrent_pr_workers )) && (( running_total_count < max_concurrent_workers )); do
+    pr_candidate_json="$(next_pr_candidate_json || true)"
+    [[ -n "$pr_candidate_json" ]] || break
+    launch_pr_candidate_json "$pr_candidate_json"
+  done
+  log_phase "launch-planning:pr-fill:end"
+  log_phase "launch-planning:end"
+fi
+
+log_phase "post-launch-summary:start"
+human_review_ids="$(human_review_pr_ids)"
+human_review_count="$(worker_count "$human_review_ids")"
+retry_deferred_pr_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
+  risk_json="$(cached_pr_risk_json "$pr_number")"
+  lane="$(jq -r '.agentLane' <<<"$risk_json")"
+    if [[ "$lane" != "fix" && "$lane" != "merge-repair" && "$lane" != "ci-refresh" && "$lane" != "automerge" && "$lane" != "double-check-1" && "$lane" != "double-check-2" ]]; then
+    continue
+  fi
+  if ! retry_ready pr "$pr_number"; then
+    retry_deferred_pr_count=$((retry_deferred_pr_count + 1))
+  fi
+done <<<"$open_agent_pr_ids_cache"
+log_phase "post-launch-summary:end"
+
+if (( launched_issue_count > 0 || running_total_count > 0 || auth_wait_worker_count > 0 )); then
+print_block "RUNNING_COUNTS" "$(printf 'TOTAL=%s\nISSUE=%s\nPR=%s\nAUTH_WAITING_WORKERS=%s\nSCHEDULED_ISSUE=%s\nBLOCKED_RECOVERY_ISSUE=%s\nLAUNCHED_ISSUES=%s\nLAUNCHED_PRS=%s\nLAUNCH_BUDGET_REMAINING=%s\nPR_BACKLOG_ELIGIBLE=%s\nPR_RESERVED_SLOTS=%s\nISSUE_CAPACITY_LIMIT=%s\n%s=%s' "$running_total_count" "$running_issue_count" "$running_pr_count" "$auth_wait_worker_count" "$running_scheduled_issue_count" "$running_blocked_recovery_issue_count" "$launched_issue_count" "$launched_pr_count" "$launch_budget_remaining" "$pr_backlog_eligible_count" "$reserved_pr_slots" "$issue_capacity_limit" "$heavy_running_label" "$running_heavy_issue_count")"
+  ensure_all_running_workers_cache
+  while IFS= read -r running_session; do
+    [[ -n "$running_session" ]] || continue
+    status_out="$(
+      "${shared_agent_home}/tools/bin/agent-project-worker-status" \
+        --runs-root "$runs_root" \
+      --session "$running_session"
+    )"
+    print_block "RUNNING_SESSION=${running_session}" "$status_out"
+  done <<<"$all_running_workers_cache"
+  if [[ "$exclusive_lock_mode" != "no" ]]; then
+    print_block "EXCLUSIVE_QUEUE_LOCK" "$(printf 'STATE=%s\nKIND=%s\nITEM_ID=%s\nREASON=%s' "$exclusive_lock_mode" "${exclusive_lock_kind:-}" "${exclusive_lock_item:-}" "${exclusive_waiting_reason:-active}")"
+  fi
+  if (( human_review_count > 0 )); then
+    print_block "PENDING_HUMAN_REVIEW=${human_review_count}" "$(printf 'High-risk PRs are green and intentionally idle pending human review.\nPRS=%s' "$(printf '%s\n' "$human_review_ids" | paste -sd, -)")"
+  fi
+  if (( heavy_deferred_count > 0 )); then
+    print_block "${heavy_deferred_key}=${heavy_deferred_count}" "$heavy_deferred_message"
+  fi
+  if (( retry_deferred_issue_count > 0 || retry_deferred_pr_count > 0 )); then
+    print_block "RETRY_DEFERRED" "$(printf 'ISSUES=%s\nPRS=%s' "$retry_deferred_issue_count" "$retry_deferred_pr_count")"
+  fi
+  if [[ "$provider_launch_suppressed" == "yes" ]]; then
+    print_block "PROVIDER_COOLDOWN" "$(printf 'BACKEND=%s\nMODEL=%s\nNEXT_ATTEMPT_AT=%s\nLAST_REASON=%s' "${provider_cooldown_backend:-}" "${provider_cooldown_model:-}" "${provider_cooldown_until:-}" "${provider_cooldown_reason:-provider-quota-limit}")"
+  fi
+  exit 0
+fi
+
+if [[ "$exclusive_lock_mode" != "no" ]]; then
+  print_block "EXCLUSIVE_QUEUE_LOCK" "$(printf 'STATE=%s\nKIND=%s\nITEM_ID=%s\nREASON=%s' "$exclusive_lock_mode" "${exclusive_lock_kind:-}" "${exclusive_lock_item:-}" "${exclusive_waiting_reason:-active}")"
+  exit 0
+fi
+
+if (( human_review_count > 0 )); then
+  print_block "PENDING_HUMAN_REVIEW=${human_review_count}" "$(printf 'High-risk PRs are green and intentionally idle pending human review.\nPRS=%s' "$(printf '%s\n' "$human_review_ids" | paste -sd, -)")"
+  exit 0
+fi
+
+if (( heavy_deferred_count > 0 )); then
+  print_block "${heavy_deferred_key}=${heavy_deferred_count}" "$heavy_deferred_message"
+  exit 0
+fi
+
+if (( retry_deferred_issue_count > 0 || retry_deferred_pr_count > 0 )); then
+  print_block "RETRY_DEFERRED" "$(printf 'ISSUES=%s\nPRS=%s' "$retry_deferred_issue_count" "$retry_deferred_pr_count")"
+  exit 0
+fi
+
+if [[ "$provider_launch_suppressed" == "yes" ]]; then
+  print_block "PROVIDER_COOLDOWN" "$(printf 'BACKEND=%s\nMODEL=%s\nNEXT_ATTEMPT_AT=%s\nLAST_REASON=%s' "${provider_cooldown_backend:-}" "${provider_cooldown_model:-}" "${provider_cooldown_until:-}" "${provider_cooldown_reason:-provider-quota-limit}")"
+  exit 0
+fi
+
+echo "HEARTBEAT_OK"