agent-control-plane 0.2.0 → 0.4.9

package/tools/bin/start-resident-issue-loop.sh

@@ -159,16 +159,32 @@ issue_pending_file() {
   printf '%s/issue-%s.pid\n' "${PENDING_LAUNCH_DIR}" "${issue_id}"
 }
 
-controller_unregister_pending_issue() {
-  local issue_id="${1:-${ISSUE_ID:-}}"
-  [[ -n "${issue_id}" ]] || return 0
-  rm -f "$(issue_pending_file "${issue_id}")"
-}
-
-controller_register_pending_issue() {
-  [[ -n "${ISSUE_ID:-}" ]] || return 0
-  printf '%s\n' "$$" >"$(issue_pending_file "${ISSUE_ID}")"
-}
+RESIDENT_CONTROLLER_LIB=""
+for _rcl_candidate in \
+  "${SCRIPT_DIR}/resident-issue-controller-lib.sh" \
+  "${AGENT_CONTROL_PLANE_ROOT:-}/tools/bin/resident-issue-controller-lib.sh" \
+  "${ACP_ROOT:-}/tools/bin/resident-issue-controller-lib.sh" \
+  "${SHARED_AGENT_HOME:-}/tools/bin/resident-issue-controller-lib.sh"; do
+  if [[ -n "${_rcl_candidate}" && -f "${_rcl_candidate}" ]]; then
+    RESIDENT_CONTROLLER_LIB="${_rcl_candidate}"
+    break
+  fi
+done
+if [[ -n "${SHARED_AGENT_HOME:-}" && -z "${RESIDENT_CONTROLLER_LIB}" ]]; then
+  for _rcl_skill in "${AGENT_CONTROL_PLANE_SKILL_NAME:-agent-control-plane}" "${AGENT_CONTROL_PLANE_COMPAT_ALIAS:-}"; do
+    [[ -n "${_rcl_skill}" ]] || continue
+    _rcl_candidate="${SHARED_AGENT_HOME}/skills/openclaw/${_rcl_skill}/tools/bin/resident-issue-controller-lib.sh"
+    if [[ -f "${_rcl_candidate}" ]]; then
+      RESIDENT_CONTROLLER_LIB="${_rcl_candidate}"
+      break
+    fi
+  done
+fi
+if [[ -z "${RESIDENT_CONTROLLER_LIB}" ]]; then
+  echo "unable to locate resident-issue-controller-lib.sh" >&2
+  exit 1
+fi
+source "${RESIDENT_CONTROLLER_LIB}"
 
 issue_id_is_recurring() {
   local issue_id="${1:?issue id required}"
@@ -190,161 +206,6 @@ issue_id_is_scheduled() {
   issue_json_is_scheduled "$(issue_json_for "${issue_id}" 2>/dev/null || printf '{}\n')"
 }
 
-controller_refresh_execution_context() {
-  unset \
-    ACP_CODING_WORKER \
-    ACP_CODEX_PROFILE_SAFE F_LOSNING_CODEX_PROFILE_SAFE \
-    ACP_CODEX_PROFILE_BYPASS F_LOSNING_CODEX_PROFILE_BYPASS \
-    ACP_CLAUDE_MODEL F_LOSNING_CLAUDE_MODEL \
-    ACP_CLAUDE_PERMISSION_MODE F_LOSNING_CLAUDE_PERMISSION_MODE \
-    ACP_CLAUDE_EFFORT F_LOSNING_CLAUDE_EFFORT \
-    ACP_CLAUDE_TIMEOUT_SECONDS F_LOSNING_CLAUDE_TIMEOUT_SECONDS \
-    ACP_CLAUDE_MAX_ATTEMPTS F_LOSNING_CLAUDE_MAX_ATTEMPTS \
-    ACP_CLAUDE_RETRY_BACKOFF_SECONDS F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS \
-    ACP_OPENCLAW_MODEL F_LOSNING_OPENCLAW_MODEL \
-    ACP_OPENCLAW_THINKING F_LOSNING_OPENCLAW_THINKING \
-    ACP_OPENCLAW_TIMEOUT_SECONDS F_LOSNING_OPENCLAW_TIMEOUT_SECONDS \
-    ACP_OPENCLAW_STALL_SECONDS F_LOSNING_OPENCLAW_STALL_SECONDS \
-    ACP_ACTIVE_PROVIDER_POOL_NAME F_LOSNING_ACTIVE_PROVIDER_POOL_NAME \
-    ACP_ACTIVE_PROVIDER_BACKEND F_LOSNING_ACTIVE_PROVIDER_BACKEND \
-    ACP_ACTIVE_PROVIDER_MODEL F_LOSNING_ACTIVE_PROVIDER_MODEL \
-    ACP_ACTIVE_PROVIDER_KEY F_LOSNING_ACTIVE_PROVIDER_KEY \
-    ACP_PROVIDER_POOLS_EXHAUSTED F_LOSNING_PROVIDER_POOLS_EXHAUSTED \
-    ACP_PROVIDER_POOL_SELECTION_REASON F_LOSNING_PROVIDER_POOL_SELECTION_REASON \
-    ACP_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH \
-    ACP_PROVIDER_POOL_NEXT_ATTEMPT_AT F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_AT \
-    ACP_PROVIDER_POOL_LAST_REASON F_LOSNING_PROVIDER_POOL_LAST_REASON
-  flow_export_execution_env "${CONFIG_YAML}"
-  flow_export_project_env_aliases
-  CODING_WORKER="${ACP_CODING_WORKER:-codex}"
-  controller_capture_active_provider_context
-}
-
-controller_refresh_issue_lane_context() {
-  local is_scheduled="${1:-no}"
-  local schedule_interval_seconds="${2:-0}"
-
-  if [[ "${is_scheduled}" == "yes" ]]; then
-    ACTIVE_RESIDENT_LANE_KIND="scheduled"
-    ACTIVE_RESIDENT_LANE_VALUE="${schedule_interval_seconds}"
-  else
-    ACTIVE_RESIDENT_LANE_KIND="recurring"
-    ACTIVE_RESIDENT_LANE_VALUE="general"
-  fi
-
-  ACTIVE_RESIDENT_WORKER_KEY="$(flow_resident_issue_lane_key "${CODING_WORKER}" "${MODE}" "${ACTIVE_RESIDENT_LANE_KIND}" "${ACTIVE_RESIDENT_LANE_VALUE}")"
-  ACTIVE_RESIDENT_META_FILE="$(flow_resident_issue_lane_meta_file "${CONFIG_YAML}" "${ACTIVE_RESIDENT_WORKER_KEY}")"
-}
-
-controller_live_lane_peer() {
-  [[ -n "${ACTIVE_RESIDENT_WORKER_KEY}" ]] || return 1
-  flow_resident_live_issue_controller_for_key "${CONFIG_YAML}" "${ACTIVE_RESIDENT_WORKER_KEY}" "$$" || return 1
-}
-
-controller_yield_to_live_lane_peer() {
-  local live_controller=""
-  local controller_issue_id=""
-  local controller_state=""
-
-  live_controller="$(controller_live_lane_peer || true)"
-  [[ -n "${live_controller}" ]] || return 1
-
-  controller_issue_id="$(awk -F= '/^ISSUE_ID=/{print $2; exit}' <<<"${live_controller}")"
-  controller_state="$(awk -F= '/^CONTROLLER_STATE=/{print $2; exit}' <<<"${live_controller}")"
-
-  if [[ -n "${controller_issue_id}" && "${controller_issue_id}" != "${ISSUE_ID}" ]]; then
-    flow_resident_issue_enqueue "${CONFIG_YAML}" "${ISSUE_ID}" "resident-live-lane" >/dev/null || true
-    CONTROLLER_REASON="live-lane-controller-${controller_issue_id}-${controller_state:-running}"
-  else
-    CONTROLLER_REASON="duplicate-live-lane-controller"
-  fi
-
-  return 0
-}
-
-controller_capture_active_provider_context() {
-  ACTIVE_PROVIDER_POOL_NAME="${ACP_ACTIVE_PROVIDER_POOL_NAME:-${F_LOSNING_ACTIVE_PROVIDER_POOL_NAME:-}}"
-  ACTIVE_PROVIDER_BACKEND="${ACP_ACTIVE_PROVIDER_BACKEND:-${F_LOSNING_ACTIVE_PROVIDER_BACKEND:-${CODING_WORKER:-}}}"
-  ACTIVE_PROVIDER_MODEL="${ACP_ACTIVE_PROVIDER_MODEL:-${F_LOSNING_ACTIVE_PROVIDER_MODEL:-}}"
-  ACTIVE_PROVIDER_KEY="${ACP_ACTIVE_PROVIDER_KEY:-${F_LOSNING_ACTIVE_PROVIDER_KEY:-}}"
-  ACTIVE_PROVIDER_SELECTION_REASON="${ACP_PROVIDER_POOL_SELECTION_REASON:-${F_LOSNING_PROVIDER_POOL_SELECTION_REASON:-}}"
-  ACTIVE_PROVIDER_NEXT_ATTEMPT_EPOCH="${ACP_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH:-${F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH:-}}"
-  ACTIVE_PROVIDER_NEXT_ATTEMPT_AT="${ACP_PROVIDER_POOL_NEXT_ATTEMPT_AT:-${F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_AT:-}}"
-  ACTIVE_PROVIDER_LAST_REASON="${ACP_PROVIDER_POOL_LAST_REASON:-${F_LOSNING_PROVIDER_POOL_LAST_REASON:-}}"
-
-  if [[ -z "${ACTIVE_PROVIDER_MODEL}" ]]; then
-    case "${ACTIVE_PROVIDER_BACKEND}" in
-      openclaw)
-        ACTIVE_PROVIDER_MODEL="${ACP_OPENCLAW_MODEL:-${F_LOSNING_OPENCLAW_MODEL:-}}"
-        ;;
-      claude)
-        ACTIVE_PROVIDER_MODEL="${ACP_CLAUDE_MODEL:-${F_LOSNING_CLAUDE_MODEL:-}}"
-        ;;
-      codex)
-        ACTIVE_PROVIDER_MODEL="${ACP_CODEX_PROFILE_SAFE:-${F_LOSNING_CODEX_PROFILE_SAFE:-}}"
-        ;;
-    esac
-  fi
-
-  if [[ -z "${ACTIVE_PROVIDER_KEY}" && -n "${ACTIVE_PROVIDER_BACKEND}" && -n "${ACTIVE_PROVIDER_MODEL}" ]]; then
-    ACTIVE_PROVIDER_KEY="$(flow_sanitize_provider_key "${ACTIVE_PROVIDER_BACKEND}-${ACTIVE_PROVIDER_MODEL}")"
-  fi
-}
-
-controller_set_recorded_provider_from_active() {
-  LAST_RECORDED_PROVIDER_POOL_NAME="${ACTIVE_PROVIDER_POOL_NAME}"
-  LAST_RECORDED_PROVIDER_BACKEND="${ACTIVE_PROVIDER_BACKEND}"
-  LAST_RECORDED_PROVIDER_MODEL="${ACTIVE_PROVIDER_MODEL}"
-  LAST_RECORDED_PROVIDER_KEY="${ACTIVE_PROVIDER_KEY}"
-}
-
-controller_mark_provider_launched() {
-  LAST_LAUNCHED_PROVIDER_POOL_NAME="${ACTIVE_PROVIDER_POOL_NAME}"
-  LAST_LAUNCHED_PROVIDER_BACKEND="${ACTIVE_PROVIDER_BACKEND}"
-  LAST_LAUNCHED_PROVIDER_MODEL="${ACTIVE_PROVIDER_MODEL}"
-  LAST_LAUNCHED_PROVIDER_KEY="${ACTIVE_PROVIDER_KEY}"
-
-  if [[ -z "${LAST_RECORDED_PROVIDER_KEY}" ]]; then
-    controller_set_recorded_provider_from_active
-  fi
-}
-
-controller_track_provider_selection() {
-  local reason="${1:-provider-selection}"
-  local now_at=""
-
-  [[ -n "${ACTIVE_PROVIDER_KEY}" ]] || return 0
-
-  if [[ -z "${LAST_RECORDED_PROVIDER_KEY}" ]]; then
-    controller_set_recorded_provider_from_active
-    return 0
-  fi
-
-  if [[ "${ACTIVE_PROVIDER_KEY}" == "${LAST_RECORDED_PROVIDER_KEY}" ]]; then
-    return 0
-  fi
-
-  now_at="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-  PROVIDER_SWITCH_COUNT=$((PROVIDER_SWITCH_COUNT + 1))
-  LAST_PROVIDER_SWITCH_AT="${now_at}"
-  LAST_PROVIDER_SWITCH_REASON="${reason}"
-  LAST_PROVIDER_FROM_POOL_NAME="${LAST_RECORDED_PROVIDER_POOL_NAME}"
-  LAST_PROVIDER_FROM_BACKEND="${LAST_RECORDED_PROVIDER_BACKEND}"
-  LAST_PROVIDER_FROM_MODEL="${LAST_RECORDED_PROVIDER_MODEL}"
-  LAST_PROVIDER_FROM_KEY="${LAST_RECORDED_PROVIDER_KEY}"
-  LAST_PROVIDER_TO_POOL_NAME="${ACTIVE_PROVIDER_POOL_NAME}"
-  LAST_PROVIDER_TO_BACKEND="${ACTIVE_PROVIDER_BACKEND}"
-  LAST_PROVIDER_TO_MODEL="${ACTIVE_PROVIDER_MODEL}"
-  LAST_PROVIDER_TO_KEY="${ACTIVE_PROVIDER_KEY}"
-
-  if [[ "${reason}" == "provider-failover" ]]; then
-    PROVIDER_FAILOVER_COUNT=$((PROVIDER_FAILOVER_COUNT + 1))
-    LAST_PROVIDER_FAILOVER_AT="${now_at}"
-  fi
-
-  controller_set_recorded_provider_from_active
-}
-
 select_next_recurring_issue_id() {
   local candidate_id=""
 
@@ -371,274 +232,6 @@ select_next_recurring_issue_id() {
   return 1
 }
 
-controller_adopt_issue() {
-  local next_issue_id="${1:?issue id required}"
-  local previous_issue_id="${ISSUE_ID:-}"
-  local previous_controller_file="${CONTROLLER_FILE:-}"
-
-  if [[ -n "${previous_issue_id}" && "${previous_issue_id}" != "${next_issue_id}" ]]; then
-    controller_unregister_pending_issue "${previous_issue_id}"
-    if [[ -n "${previous_controller_file}" && -f "${previous_controller_file}" ]]; then
-      rm -f "${previous_controller_file}"
-    fi
-  fi
-
-  ISSUE_ID="${next_issue_id}"
-  SESSION="${ISSUE_SESSION_PREFIX}${ISSUE_ID}"
-  CONTROLLER_FILE="$(flow_resident_issue_controller_file "${CONFIG_YAML}" "${ISSUE_ID}")"
-  RESIDENT_META_FILE="$(flow_resident_issue_meta_file "${CONFIG_YAML}" "${ISSUE_ID}")"
-  CONTROLLER_LOOP_COUNT="0"
-  NEXT_WAKE_EPOCH=""
-  NEXT_WAKE_AT=""
-  IDLE_WAIT_STARTED_EPOCH=""
-  ACTIVE_RESIDENT_WORKER_KEY=""
-  ACTIVE_RESIDENT_META_FILE=""
-  ACTIVE_RESIDENT_LANE_KIND=""
-  ACTIVE_RESIDENT_LANE_VALUE=""
-}
-
-controller_mark_issue_running() {
-  local is_heavy="no"
-
-  if declare -F heartbeat_issue_is_heavy >/dev/null 2>&1; then
-    is_heavy="$(heartbeat_issue_is_heavy "${ISSUE_ID}" 2>/dev/null || printf 'no\n')"
-  fi
-
-  if declare -F heartbeat_mark_issue_running >/dev/null 2>&1; then
-    heartbeat_mark_issue_running "${ISSUE_ID}" "${is_heavy}" >/dev/null 2>&1 || true
-  fi
-}
-
-controller_rollback_issue_launch() {
-  if declare -F heartbeat_issue_launch_failed >/dev/null 2>&1; then
-    heartbeat_issue_launch_failed "${ISSUE_ID}" >/dev/null 2>&1 || true
-  fi
-}
-
-controller_adopt_next_recurring_issue() {
-  local next_issue_id=""
-  local claim_out=""
-  local claim_file=""
-
-  claim_out="$(flow_resident_issue_claim_next "${CONFIG_YAML}" "${SESSION}" "${ISSUE_ID}" || true)"
-  next_issue_id="$(awk -F= '/^ISSUE_ID=/{print $2}' <<<"${claim_out}")"
-  claim_file="$(awk -F= '/^CLAIM_FILE=/{print $2}' <<<"${claim_out}")"
-  if [[ -z "${next_issue_id}" ]]; then
-    next_issue_id="$(select_next_recurring_issue_id || true)"
-  fi
-  [[ -n "${next_issue_id}" ]] || return 1
-
-  controller_adopt_issue "${next_issue_id}"
-  flow_resident_issue_release_claim "${claim_file}"
-  CONTROLLER_REASON="adopted-next-recurring-issue"
-  controller_write_state "adopting-issue" ""
-  return 0
-}
-
-controller_wait_for_leased_issue() {
-  local idle_timeout="${IDLE_TIMEOUT_SECONDS:-0}"
-  local now_epoch=""
-
-  case "${idle_timeout}" in
-    ''|*[!0-9]*) idle_timeout="0" ;;
-  esac
-
-  if [[ "${idle_timeout}" -le 0 ]]; then
-    return 1
-  fi
-
-  if [[ -z "${IDLE_WAIT_STARTED_EPOCH}" ]]; then
-    IDLE_WAIT_STARTED_EPOCH="$(date +%s)"
-  fi
-
-  while true; do
-    if controller_adopt_next_recurring_issue; then
-      return 0
-    fi
-
-    now_epoch="$(date +%s)"
-    if (( now_epoch - IDLE_WAIT_STARTED_EPOCH >= idle_timeout )); then
-      CONTROLLER_REASON="idle-timeout"
-      return 1
-    fi
-
-    controller_write_state "idle" ""
-    sleep "${POLL_SECONDS}"
-  done
-}
-
-controller_write_state() {
-  local state="${1:?state required}"
-  local reason="${2:-${CONTROLLER_REASON}}"
-
-  CONTROLLER_STATE="${state}"
-  CONTROLLER_REASON="${reason}"
-  flow_resident_write_metadata "${CONTROLLER_FILE}" \
-    "ISSUE_ID=${ISSUE_ID}" \
-    "SESSION=${SESSION}" \
-    "CONTROLLER_PID=$$" \
-    "CONTROLLER_MODE=${MODE}" \
-    "CONTROLLER_LOOP_COUNT=${CONTROLLER_LOOP_COUNT}" \
-    "CONTROLLER_STATE=${CONTROLLER_STATE}" \
-    "CONTROLLER_REASON=${CONTROLLER_REASON}" \
-    "ACTIVE_RESIDENT_WORKER_KEY=${ACTIVE_RESIDENT_WORKER_KEY}" \
-    "ACTIVE_RESIDENT_LANE_KIND=${ACTIVE_RESIDENT_LANE_KIND}" \
-    "ACTIVE_RESIDENT_LANE_VALUE=${ACTIVE_RESIDENT_LANE_VALUE}" \
-    "ACTIVE_PROVIDER_POOL_NAME=${ACTIVE_PROVIDER_POOL_NAME}" \
-    "ACTIVE_PROVIDER_BACKEND=${ACTIVE_PROVIDER_BACKEND}" \
-    "ACTIVE_PROVIDER_MODEL=${ACTIVE_PROVIDER_MODEL}" \
-    "ACTIVE_PROVIDER_KEY=${ACTIVE_PROVIDER_KEY}" \
-    "ACTIVE_PROVIDER_SELECTION_REASON=${ACTIVE_PROVIDER_SELECTION_REASON}" \
-    "ACTIVE_PROVIDER_NEXT_ATTEMPT_EPOCH=${ACTIVE_PROVIDER_NEXT_ATTEMPT_EPOCH}" \
-    "ACTIVE_PROVIDER_NEXT_ATTEMPT_AT=${ACTIVE_PROVIDER_NEXT_ATTEMPT_AT}" \
-    "ACTIVE_PROVIDER_LAST_REASON=${ACTIVE_PROVIDER_LAST_REASON}" \
-    "LAST_LAUNCHED_PROVIDER_POOL_NAME=${LAST_LAUNCHED_PROVIDER_POOL_NAME}" \
-    "LAST_LAUNCHED_PROVIDER_BACKEND=${LAST_LAUNCHED_PROVIDER_BACKEND}" \
-    "LAST_LAUNCHED_PROVIDER_MODEL=${LAST_LAUNCHED_PROVIDER_MODEL}" \
-    "LAST_LAUNCHED_PROVIDER_KEY=${LAST_LAUNCHED_PROVIDER_KEY}" \
-    "PROVIDER_SWITCH_COUNT=${PROVIDER_SWITCH_COUNT}" \
-    "PROVIDER_FAILOVER_COUNT=${PROVIDER_FAILOVER_COUNT}" \
-    "LAST_PROVIDER_SWITCH_AT=${LAST_PROVIDER_SWITCH_AT}" \
-    "LAST_PROVIDER_SWITCH_REASON=${LAST_PROVIDER_SWITCH_REASON}" \
-    "LAST_PROVIDER_FROM_POOL_NAME=${LAST_PROVIDER_FROM_POOL_NAME}" \
-    "LAST_PROVIDER_FROM_BACKEND=${LAST_PROVIDER_FROM_BACKEND}" \
-    "LAST_PROVIDER_FROM_MODEL=${LAST_PROVIDER_FROM_MODEL}" \
-    "LAST_PROVIDER_FROM_KEY=${LAST_PROVIDER_FROM_KEY}" \
-    "LAST_PROVIDER_TO_POOL_NAME=${LAST_PROVIDER_TO_POOL_NAME}" \
-    "LAST_PROVIDER_TO_BACKEND=${LAST_PROVIDER_TO_BACKEND}" \
-    "LAST_PROVIDER_TO_MODEL=${LAST_PROVIDER_TO_MODEL}" \
-    "LAST_PROVIDER_TO_KEY=${LAST_PROVIDER_TO_KEY}" \
-    "LAST_PROVIDER_FAILOVER_AT=${LAST_PROVIDER_FAILOVER_AT}" \
-    "PROVIDER_WAIT_COUNT=${PROVIDER_WAIT_COUNT}" \
-    "PROVIDER_WAIT_TOTAL_SECONDS=${PROVIDER_WAIT_TOTAL_SECONDS}" \
-    "PROVIDER_LAST_WAIT_SECONDS=${PROVIDER_LAST_WAIT_SECONDS}" \
-    "PROVIDER_LAST_WAIT_STARTED_AT=${PROVIDER_LAST_WAIT_STARTED_AT}" \
-    "PROVIDER_LAST_WAIT_COMPLETED_AT=${PROVIDER_LAST_WAIT_COMPLETED_AT}" \
-    "NEXT_WAKE_EPOCH=${NEXT_WAKE_EPOCH}" \
-    "NEXT_WAKE_AT=${NEXT_WAKE_AT}" \
-    "UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-
-  if [[ "${CONTROLLER_STATE}" == "stopped" ]]; then
-    controller_unregister_pending_issue "${ISSUE_ID}"
-  elif flow_resident_issue_controller_counts_as_pending "${CONTROLLER_STATE}"; then
-    controller_register_pending_issue
-  else
-    controller_unregister_pending_issue "${ISSUE_ID}"
-  fi
-}
-
-controller_last_failure_reason() {
-  local metadata_file="${ACTIVE_RESIDENT_META_FILE:-${RESIDENT_META_FILE:-}}"
-  [[ -n "${metadata_file}" && -f "${metadata_file}" ]] || return 1
-  awk -F= '/^LAST_FAILURE_REASON=/{print $2; exit}' "${metadata_file}" 2>/dev/null | tr -d '"' || true
-}
-
-controller_provider_state() {
-  local provider_state_script="${FLOW_TOOLS_DIR}/provider-cooldown-state.sh"
-  local provider_state=""
-
-  if [[ ! -x "${provider_state_script}" ]]; then
-    printf 'READY=yes\n'
-    return 0
-  fi
-
-  provider_state="$(
-    env \
-      -u ACP_CODING_WORKER \
-      -u ACP_CODEX_PROFILE_SAFE -u F_LOSNING_CODEX_PROFILE_SAFE \
-      -u ACP_CODEX_PROFILE_BYPASS -u F_LOSNING_CODEX_PROFILE_BYPASS \
-      -u ACP_CLAUDE_MODEL -u F_LOSNING_CLAUDE_MODEL \
-      -u ACP_CLAUDE_PERMISSION_MODE -u F_LOSNING_CLAUDE_PERMISSION_MODE \
-      -u ACP_CLAUDE_EFFORT -u F_LOSNING_CLAUDE_EFFORT \
-      -u ACP_CLAUDE_TIMEOUT_SECONDS -u F_LOSNING_CLAUDE_TIMEOUT_SECONDS \
-      -u ACP_CLAUDE_MAX_ATTEMPTS -u F_LOSNING_CLAUDE_MAX_ATTEMPTS \
-      -u ACP_CLAUDE_RETRY_BACKOFF_SECONDS -u F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS \
-      -u ACP_OPENCLAW_MODEL -u F_LOSNING_OPENCLAW_MODEL \
-      -u ACP_OPENCLAW_THINKING -u F_LOSNING_OPENCLAW_THINKING \
-      -u ACP_OPENCLAW_TIMEOUT_SECONDS -u F_LOSNING_OPENCLAW_TIMEOUT_SECONDS \
-      -u ACP_ACTIVE_PROVIDER_POOL_NAME -u F_LOSNING_ACTIVE_PROVIDER_POOL_NAME \
-      -u ACP_ACTIVE_PROVIDER_BACKEND -u F_LOSNING_ACTIVE_PROVIDER_BACKEND \
-      -u ACP_ACTIVE_PROVIDER_MODEL -u F_LOSNING_ACTIVE_PROVIDER_MODEL \
-      -u ACP_ACTIVE_PROVIDER_KEY -u F_LOSNING_ACTIVE_PROVIDER_KEY \
-      -u ACP_PROVIDER_POOLS_EXHAUSTED -u F_LOSNING_PROVIDER_POOLS_EXHAUSTED \
-      -u ACP_PROVIDER_POOL_SELECTION_REASON -u F_LOSNING_PROVIDER_POOL_SELECTION_REASON \
-      -u ACP_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH -u F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH \
-      -u ACP_PROVIDER_POOL_NEXT_ATTEMPT_AT -u F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_AT \
-      -u ACP_PROVIDER_POOL_LAST_REASON -u F_LOSNING_PROVIDER_POOL_LAST_REASON \
-      "${provider_state_script}" get 2>/dev/null || true
-  )"
-  if [[ -z "${provider_state}" ]]; then
-    printf 'READY=yes\n'
-    return 0
-  fi
-
-  printf '%s\n' "${provider_state}"
-}
-
-controller_wait_for_provider_capacity() {
-  local provider_state=""
-  local provider_ready=""
-  local provider_next_epoch=""
-  local provider_next_at=""
-  local now_epoch=""
-  local remaining=""
-  local sleep_seconds=""
-  local wait_started_epoch=""
-  local wait_completed_epoch=""
-
-  PROVIDER_WAITED="no"
-
-  while true; do
-    provider_state="$(controller_provider_state)"
-    provider_ready="$(flow_kv_get "${provider_state}" "READY")"
-    if [[ "${provider_ready}" == "yes" ]]; then
-      if [[ -n "${wait_started_epoch}" ]]; then
-        wait_completed_epoch="$(date +%s)"
-        if (( wait_completed_epoch >= wait_started_epoch )); then
-          PROVIDER_LAST_WAIT_SECONDS=$((wait_completed_epoch - wait_started_epoch))
-          PROVIDER_WAIT_TOTAL_SECONDS=$((PROVIDER_WAIT_TOTAL_SECONDS + PROVIDER_LAST_WAIT_SECONDS))
-          PROVIDER_LAST_WAIT_COMPLETED_AT="$(date -u -r "${wait_completed_epoch}" +"%Y-%m-%dT%H:%M:%SZ")"
-        fi
-      fi
-      NEXT_WAKE_EPOCH=""
-      NEXT_WAKE_AT=""
-      return 0
-    fi
-
-    provider_next_epoch="$(flow_kv_get "${provider_state}" "NEXT_ATTEMPT_EPOCH")"
-    provider_next_at="$(flow_kv_get "${provider_state}" "NEXT_ATTEMPT_AT")"
-    if ! [[ "${provider_next_epoch}" =~ ^[0-9]+$ ]] || [[ "${provider_next_epoch}" == "0" ]]; then
-      return 1
-    fi
-
-    if [[ -z "${wait_started_epoch}" ]]; then
-      wait_started_epoch="$(date +%s)"
-      PROVIDER_WAIT_COUNT=$((PROVIDER_WAIT_COUNT + 1))
-      PROVIDER_LAST_WAIT_STARTED_AT="$(date -u -r "${wait_started_epoch}" +"%Y-%m-%dT%H:%M:%SZ")"
-    fi
-
-    PROVIDER_WAITED="yes"
-    NEXT_WAKE_EPOCH="${provider_next_epoch}"
-    NEXT_WAKE_AT="${provider_next_at}"
-    CONTROLLER_REASON="provider-cooldown"
-    controller_write_state "waiting-provider" ""
-
-    now_epoch="$(date +%s)"
-    remaining=$((provider_next_epoch - now_epoch))
-    sleep_seconds="${POLL_SECONDS}"
-    if ! [[ "${sleep_seconds}" =~ ^[1-9][0-9]*$ ]]; then
-      sleep_seconds="60"
-    fi
-    if (( remaining > 0 && remaining < sleep_seconds )); then
-      sleep_seconds="${remaining}"
-    fi
-    if (( sleep_seconds <= 0 )); then
-      sleep_seconds="1"
-    fi
-    sleep "${sleep_seconds}"
-  done
-}
-
 record_scheduled_next_due() {
   local interval_seconds="${1:-0}"
   local state_file now_epoch next_due_epoch
@@ -650,22 +243,18 @@ record_scheduled_next_due() {
   now_epoch="$(date +%s)"
   next_due_epoch=$((now_epoch + interval_seconds))
   NEXT_WAKE_EPOCH="${next_due_epoch}"
-  NEXT_WAKE_AT="$(date -u -r "${next_due_epoch}" +"%Y-%m-%dT%H:%M:%SZ")"
+  NEXT_WAKE_AT="$(flow_format_epoch_utc "${next_due_epoch}")"
   state_file="${SCHEDULED_STATE_DIR}/${ISSUE_ID}.env"
   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")
+LAST_STARTED_AT=$(flow_format_epoch_utc "${now_epoch}")
 NEXT_DUE_EPOCH=${next_due_epoch}
 NEXT_DUE_AT=${NEXT_WAKE_AT}
 UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 EOF
 }
 
-controller_cleanup() {
-  controller_write_state "stopped" "${CONTROLLER_REASON:-stopped}"
-}
-
 trap 'CONTROLLER_REASON="${CONTROLLER_REASON:-terminated}"; controller_cleanup' EXIT
 trap 'CONTROLLER_REASON="interrupted"; exit 0' INT TERM
 

package/tools/dashboard/app.js

@@ -111,9 +111,10 @@ function renderOverview(snapshot) {
       acc.cooldowns += profile.counts.provider_cooldowns;
       acc.queue += profile.counts.queued_issues;
       acc.alerts += profile.counts.alerts || 0;
+      acc.pendingGithubWrites += profile.counts.pending_github_writes || 0;
       return acc;
     },
-    { activeRuns: 0, runningRuns: 0, implementedRuns: 0, reportedRuns: 0, blockedRuns: 0, controllers: 0, cooldowns: 0, queue: 0, alerts: 0 },
+    { activeRuns: 0, runningRuns: 0, implementedRuns: 0, reportedRuns: 0, blockedRuns: 0, controllers: 0, cooldowns: 0, queue: 0, alerts: 0, pendingGithubWrites: 0 },
   );
 
   overviewNode.innerHTML = [
@@ -125,6 +126,7 @@ function renderOverview(snapshot) {
     ["Blocked", totals.blockedRuns],
     ["Live Controllers", totals.controllers],
     ["Provider Cooldowns", totals.cooldowns],
+    ["Pending GitHub Writes", totals.pendingGithubWrites],
     ["Alerts", totals.alerts],
     ["Queued Issues", totals.queue],
   ]
@@ -219,6 +221,9 @@ function renderProfile(profile) {
       ? `<span class="badge">${profile.provider_pool.backend}: ${profile.provider_pool.model || "n/a"}</span>`
       : "",
     profile.provider_pool.name ? `<span class="badge">${profile.provider_pool.name}</span>` : "",
+    profile.provider_pool.pools_exhausted
+      ? `<span class="badge warn">pools exhausted</span>`
+      : "",
     profile.provider_pool.last_reason ? `<span class="badge warn">${profile.provider_pool.last_reason}</span>` : "",
   ]
     .filter(Boolean)
@@ -234,6 +239,8 @@ function renderProfile(profile) {
     ["Live controllers", profile.counts.live_resident_controllers],
     ["Stale controllers", profile.counts.stale_resident_controllers],
     ["Provider cooldowns", profile.counts.provider_cooldowns],
+    ["Pending GitHub writes", profile.counts.pending_github_writes || 0],
+    ["Failed GitHub writes", profile.counts.failed_github_writes || 0],
     ["Alerts", profile.counts.alerts || 0],
     ["Issue retries", profile.counts.active_retries],
     ["Queued issues", profile.counts.queued_issues],
@@ -280,6 +287,7 @@ function renderProfile(profile) {
     [
       { label: "Issue", key: "issue_id" },
       { label: "State", render: renderControllerState },
+      { label: "Lane", render: (row) => `${row.lane_kind || "n/a"} / ${row.lane_value || "n/a"}` },
       { label: "Reason", render: (row) => row.reason || "n/a" },
       { label: "Provider", render: (row) => `${row.provider_backend || "n/a"} ${row.provider_model || ""}`.trim() },
       { label: "Failover", render: (row) => `${row.provider_failover_count} failovers / ${row.provider_switch_count} switches` },
@@ -320,6 +328,7 @@ function renderProfile(profile) {
       { label: "Scope", key: "scope" },
       { label: "Worker", key: "coding_worker" },
       { label: "Issue", render: (row) => row.issue_id || "n/a" },
+      { label: "Lane", render: (row) => `${row.resident_lane_kind || "n/a"} / ${row.resident_lane_value || "n/a"}` },
       { label: "Tasks", key: "task_count" },
       { label: "Last status", render: (row) => row.last_status || "n/a" },
       { label: "Last started", render: (row) => row.last_started_at ? `${relativeTime(row.last_started_at)}<div class="muted">${row.last_started_at}</div>` : "n/a" },
@@ -355,6 +364,7 @@ function renderProfile(profile) {
     [
       { label: "Issue", key: "issue_id" },
       { label: "Session", render: (row) => row.session ? `<div class="mono">${row.session}</div>` : "n/a" },
+      { label: "Queued by", key: "queued_by" },
       { label: "Updated", render: (row) => row.updated_at ? `${relativeTime(row.updated_at)}<div class="muted">${row.updated_at}</div>` : "n/a" },
     ],
     profile.issue_queue.pending,
@@ -365,12 +375,33 @@ function renderProfile(profile) {
     [
       { label: "Issue", key: "issue_id" },
       { label: "Session", render: (row) => row.session ? `<div class="mono">${row.session}</div>` : "n/a" },
+      { label: "Claimed by", key: "claimer" },
       { label: "Updated", render: (row) => row.updated_at ? `${relativeTime(row.updated_at)}<div class="muted">${row.updated_at}</div>` : "n/a" },
     ],
     profile.issue_queue.claims || [],
     "No claimed issues.",
   );
 
+  const githubOutbox = profile.github_outbox || { counts: {}, pending: [] };
+  const githubOutboxTable = renderTable(
+    [
+      { label: "Type", render: (row) => row.type || "n/a" },
+      { label: "Target", render: (row) => `${row.kind || row.type || "write"} #${row.number || "?"}` },
+      {
+        label: "Payload",
+        render: (row) => {
+          if (row.type === "labels") {
+            return `+${row.add_count || 0} / -${row.remove_count || 0}`;
+          }
+          return row.body_preview || "n/a";
+        },
+      },
+      { label: "Created", render: (row) => row.created_at ? `${relativeTime(row.created_at)}<div class="muted">${row.created_at}</div>` : "n/a" },
+    ],
+    githubOutbox.pending || [],
+    "No pending GitHub write intents.",
+  );
+
   const codexRotationPanel =
     profile.coding_worker === "codex"
       ? `
@@ -445,6 +476,11 @@ function renderProfile(profile) {
           <h3>Claimed Issues</h3>
           ${claimsTable}
         </section>
+        <section class="panel">
+          <h3>GitHub Outbox</h3>
+          <p class="panel-subtitle">Local write intents queued while ACP defers or retries GitHub sync. Pending ${githubOutbox.counts?.pending || 0}, sent ${githubOutbox.counts?.sent || 0}, failed ${githubOutbox.counts?.failed || 0}.</p>
+          ${githubOutboxTable}
+        </section>
       </section>
     </article>
   `;