agent-control-plane 0.4.9 → 0.6.0

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

@@ -1,1029 +0,0 @@
-#!/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}"
-}
-
-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
-
-
-# --- 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"
-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
-  if declare -F heartbeat_invalidate_snapshot_cache >/dev/null 2>&1; then
-    heartbeat_invalidate_snapshot_cache
-  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
-
-# --- PR launch dispatcher ---
-
-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
-}
-
-# ============================================================================
-# MAIN EXECUTION
-# ============================================================================
-
-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
-
-
-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"