#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# shellcheck disable=SC1091
source "${SCRIPT_DIR}/lib_ops_center.sh"
ops_center_load_config "${SCRIPT_DIR}"

OPS_CENTER_CURL_CONNECT_TIMEOUT="${OPS_CENTER_CURL_CONNECT_TIMEOUT:-3}"
OPS_CENTER_CURL_MAX_TIME="${OPS_CENTER_CURL_MAX_TIME:-20}"
OPS_CENTER_CURL_MAX_TIME_CODEX_BRIEF="${OPS_CENTER_CURL_MAX_TIME_CODEX_BRIEF:-45}"
OPS_CENTER_REPORT_COMMAND_TIMEOUT_SECONDS="${OPS_CENTER_REPORT_COMMAND_TIMEOUT_SECONDS:-25}"
OPS_CENTER_DOCTOR_REPORT_TIMEOUT_SECONDS="${OPS_CENTER_DOCTOR_REPORT_TIMEOUT_SECONDS:-${OPS_CENTER_REPORT_COMMAND_TIMEOUT_SECONDS}}"

usage() {
  cat <<'EOF'
usage:
  bash domain-api/deploy/multi-region/drive_ops_center.sh <command> [args...]

commands:
  help
  config
  contracts [mainland_base_url] [contract_key]
  env-audit [mainland_base_url]
  runtime-refresh-check [mainland_base_url]
  runtime-refresh-recover [mainland_base_url]
  stack-diagnosis [mainland_base_url] [summary|full]
  stack-check [mainland_base_url] [summary|full]  (backward-compatible alias of stack-diagnosis)
  go-live-check [mainland_base_url] [overseas_base_url] [summary|full]
  go-live-recover [mainland_base_url] [overseas_base_url]
  go-live-export [report_dir] [mainland_base_url] [overseas_base_url]
  go-live-review [manifest.json|report_dir]
  go-live-signoff [manifest.json|report_dir|mainland_base_url] [overseas_base_url]
  stack-next [mainland_base_url] [preview|run] [confirm] [requested_by]
  release-package [skip-smoke]
  release-verify [archive_path] [hash_path]
  release-prepare
  release-show
  release-launchpad [mainland_base_url] [channel]
  release-preview [mainland_base_url]
  release-preview-smart [mainland_base_url] <worker|control>
  release-import-latest [mainland_base_url]
  publish-latest [mainland_base_url] <worker|control> [confirm] [skip-smoke]
  doctor-export [report_dir] [mainland_base_url] [overseas_base_url]
  doctor-decision [manifest_path|report_dir|mainland_base_url] [overseas_base_url]
  doctor [mainland_base_url] [overseas_base_url]
  ops-plane [mainland_base_url]
  inspection [mainland_base_url]
  participation [mainland_base_url]
  topology [mainland_base_url] [overseas_base_url]
  nodes [mainland_base_url]
  stack-first-gap-handover [mainland_base_url]
  node-bind-ssh [mainland_base_url] <node_code> <ssh_host> <ssh_user> [ssh_port] [title]
  node-handover [mainland_base_url] <node_code>
  node-onboarding [mainland_base_url] <node_code>
  node-recover [mainland_base_url] <node_code> [confirm] [requested_by]
  node-bootstrap-preview [mainland_base_url] <node_code> [requested_by]
  node-bootstrap-run [mainland_base_url] <node_code> [requested_by]
  node-acceptance-plan [mainland_base_url] <node_code> [requested_by]
  node-acceptance-run [mainland_base_url] <node_code> [requested_by]
  scene-node-log [mainland_base_url] <node_code> [limit] [key|full]
  log-sync-check [mainland_base_url]
  log-sync-recover [mainland_base_url] [key|full] [confirm] [requested_by]
  agent-gap-check [mainland_base_url]
  agent-gap-recover [mainland_base_url] [confirm] [requested_by]
  agent-gap-export [report_dir] [mainland_base_url] [requested_by]
  node-bootstrap-plan [mainland_base_url] <node_code> [issued_by] [expires_in_hours] [control_plane_base_url] [root_dir]
  queue-status [mainland_base_url] <node_code>
  queue-records [mainland_base_url] <node_code> [state]
  queue-flush [mainland_base_url] <node_code> [limit] [requested_by]
  queue-replay [mainland_base_url] <node_code> [limit] [requested_by]
  queue-replay-record [mainland_base_url] <node_code> <record_id> [requested_by]
  queue-discard-record [mainland_base_url] <node_code> <record_id> <reason> [requested_by]
  driver-feed [mainland_base_url]
  activity-stream [mainland_base_url] [key=value ...]
  activity-preview [mainland_base_url] [activity_key] [requested_by]
  driver-focus-preview [mainland_base_url] [entry_key] [requested_by]
  driver-focus-run [mainland_base_url] [entry_key] [primary|secondary] [confirm] [requested_by]
  codex-brief [mainland_base_url]
  codex-focus-preview [mainland_base_url] [entry_key] [requested_by]
  codex-focus-run [mainland_base_url] [entry_key] [confirm] [requested_by]
  release-hub [mainland_base_url] <release-hub-command> [args...]
  driver-preview [mainland_base_url] <action_code> [action_payload_json|@payload.json] [requested_by]
  driver-resolve [mainland_base_url] <action_code> [action_payload_json|@payload.json] [requested_by]
  driver-run [mainland_base_url] <action_code> [action_payload_json|@payload.json] [confirm] [requested_by]
  driver [mainland_base_url] <action_code> [action_payload_json|@payload.json] [requested_by]
  runbook-preview [mainland_base_url] <sequence_key> [action_payload_json|@payload.json] [requested_by]
  runbook-run [mainland_base_url] <sequence_key> [primary|secondary] [action_payload_json|@payload.json] [confirm] [requested_by]
  runbook-resolve [mainland_base_url] <sequence_key> [primary|secondary] [action_payload_json|@payload.json] [requested_by]
  runbook-sequence [mainland_base_url] <sequence_key> [primary|secondary] [action_payload_json|@payload.json] [requested_by]
  smart-latest [mainland_base_url] <worker|control> [confirm]
  smart-release [mainland_base_url] <release_id> <worker|control> [confirm]
  agent-plan [mainland_base_url] <node_code> [node_region] [node_role] [control_plane_base_url] [root_dir]
  agent-plan-export [report_dir] [mainland_base_url] <node_code> [node_region] [node_role] [control_plane_base_url] [root_dir]
  agent-check [service_name] [env_file]

examples:
  bash domain-api/deploy/multi-region/drive_ops_center.sh config
  bash domain-api/deploy/multi-region/drive_ops_center.sh contracts
  bash domain-api/deploy/multi-region/drive_ops_center.sh env-audit
  bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-check
  bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover
  bash domain-api/deploy/multi-region/drive_ops_center.sh stack-diagnosis
  bash domain-api/deploy/multi-region/drive_ops_center.sh contracts ops_stack_diagnosis_contract
  bash domain-api/deploy/multi-region/drive_ops_center.sh contracts http://127.0.0.1:8100 release_hub_contract
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-recover
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-check
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-export
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-review
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-signoff
  bash domain-api/deploy/multi-region/drive_ops_center.sh go-live-signoff /path/to/go-live-bundle
  bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next
  bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next run confirm
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-package
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-show
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-launchpad
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-preview
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-preview-smart worker
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-import-latest
  bash domain-api/deploy/multi-region/drive_ops_center.sh publish-latest worker
  bash domain-api/deploy/multi-region/drive_ops_center.sh doctor-export
  bash domain-api/deploy/multi-region/drive_ops_center.sh doctor-decision
  bash domain-api/deploy/multi-region/drive_ops_center.sh doctor http://127.0.0.1:8100 http://152.53.37.118:8100
  bash domain-api/deploy/multi-region/drive_ops_center.sh nodes
  bash domain-api/deploy/multi-region/drive_ops_center.sh stack-first-gap-handover
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-bind-ssh mainland-worker-01 121.204.244.248 root
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-bind-ssh http://127.0.0.1:8100 mainland-controller-01 121.204.244.188 root 22 mainland-controller
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-onboarding mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-recover mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-recover mainland-worker-01 confirm ops-center
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-preview mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-run mainland-worker-01 ops-center
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-plan mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-run mainland-worker-01 ops-center
  bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log http://127.0.0.1:8100 mainland-worker-01 120 full
  bash domain-api/deploy/multi-region/drive_ops_center.sh log-sync-check
  bash domain-api/deploy/multi-region/drive_ops_center.sh log-sync-recover
  bash domain-api/deploy/multi-region/drive_ops_center.sh log-sync-recover http://127.0.0.1:8100 full confirm cli/ops
  bash domain-api/deploy/multi-region/drive_ops_center.sh agent-gap-check
  bash domain-api/deploy/multi-region/drive_ops_center.sh agent-gap-recover
  bash domain-api/deploy/multi-region/drive_ops_center.sh agent-gap-export
  bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-plan mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-status mainland-worker-01
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-records mainland-worker-01 dead_letter
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-flush mainland-worker-01 20
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-replay mainland-worker-01 20
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-replay-record mainland-worker-01 event-ops-123-2
  bash domain-api/deploy/multi-region/drive_ops_center.sh queue-discard-record mainland-worker-01 event-ops-123-2 "确认已人工归档"
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-feed
  bash domain-api/deploy/multi-region/drive_ops_center.sh activity-stream
  bash domain-api/deploy/multi-region/drive_ops_center.sh activity-stream kind=ops_job status=running
  bash domain-api/deploy/multi-region/drive_ops_center.sh activity-preview
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-focus-preview
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-focus-run
  bash domain-api/deploy/multi-region/drive_ops_center.sh codex-brief
  bash domain-api/deploy/multi-region/drive_ops_center.sh codex-focus-preview
  bash domain-api/deploy/multi-region/drive_ops_center.sh codex-focus-run
  bash domain-api/deploy/multi-region/drive_ops_center.sh release-hub http://127.0.0.1:8100 latest-package
  bash domain-api/deploy/multi-region/drive_ops_center.sh smart-release http://127.0.0.1:8100 12 worker
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-preview http://127.0.0.1:8100 open_release_dialog
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-resolve http://127.0.0.1:8100 enable_log_sync_key
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver-run http://127.0.0.1:8100 enable_log_sync_key
  bash domain-api/deploy/multi-region/drive_ops_center.sh driver http://127.0.0.1:8100 open_release_dialog
  bash domain-api/deploy/multi-region/drive_ops_center.sh runbook-preview release_progression
  bash domain-api/deploy/multi-region/drive_ops_center.sh runbook-run release_progression
  bash domain-api/deploy/multi-region/drive_ops_center.sh runbook-resolve release_progression
  bash domain-api/deploy/multi-region/drive_ops_center.sh runbook-sequence release_progression

design:
  - this is the single overseas control-plane entrypoint
  - it does not execute remote shell directly
  - it first delegates to contract preview APIs, then to ops/release execute APIs
EOF
}

COMMAND="${1:-help}"
shift || true

run_step() {
  local title="$1"
  shift
  echo "============================================================"
  echo "${title}"
  echo "============================================================"
  "$@"
  echo
}

print_json_or_raw() {
  local raw_text="${1:-}"
  python3 - "${raw_text}" <<'PY'
import json
import sys

raw_text = str(sys.argv[1] or "")
try:
    payload = json.loads(raw_text)
except Exception:
    print(raw_text)
else:
    print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
}

request_with_status_custom() {
  local method="$1"
  local url="$2"
  local body="${3:-}"
  local connect_timeout="${4:-${OPS_CENTER_CURL_CONNECT_TIMEOUT}}"
  local max_time="${5:-${OPS_CENTER_CURL_MAX_TIME}}"
  if [[ "${method}" == "POST" ]]; then
    curl -sS -X POST "${url}" \
      --connect-timeout "${connect_timeout}" \
      --max-time "${max_time}" \
      -H 'Content-Type: application/json' \
      -d "${body}" \
      -w $'\nHTTP_STATUS=%{http_code}'
  else
    curl -sS \
      --connect-timeout "${connect_timeout}" \
      --max-time "${max_time}" \
      "${url}" \
      -w $'\nHTTP_STATUS=%{http_code}'
  fi
}

request_with_status() {
  local method="$1"
  local url="$2"
  local body="${3:-}"
  request_with_status_custom "${method}" "${url}" "${body}" \
    "${OPS_CENTER_CURL_CONNECT_TIMEOUT}" "${OPS_CENTER_CURL_MAX_TIME}"
}

print_config() {
  local requested_profile="${1:-${OPS_CENTER_ACTIVE_PROFILE}}"
  local saved_profile="${OPS_CENTER_ACTIVE_PROFILE}"
  local saved_profile_key="${OPS_CENTER_ACTIVE_PROFILE_KEY}"
  OPS_CENTER_ACTIVE_PROFILE="${requested_profile}"
  OPS_CENTER_ACTIVE_PROFILE_KEY="$(ops_center_normalize_profile_key "${OPS_CENTER_ACTIVE_PROFILE}")"
  python3 - <<'PY' "${OPS_CENTER_CONFIG_FILE}" \
    "${OPS_CENTER_ACTIVE_PROFILE}" \
    "${OPS_CENTER_PROFILE_NAMES}" \
    "$(ops_center_resolve_mainland_api_base_url)" \
    "$(ops_center_resolve_overseas_api_base_url)" \
    "$(ops_center_resolve_control_plane_base_url)" \
    "$(ops_center_resolve_requested_by)" \
    "$(ops_center_resolve_issued_by)" \
    "$(ops_center_resolve_expires_in_hours)" \
    "$(ops_center_resolve_root_dir)" \
    "$(ops_center_resolve_node_agent_service_name)" \
    "$(ops_center_resolve_node_agent_env_file)" \
    "${OPS_CENTER_REPORT_ROOT}"
import json
import sys
from pathlib import Path

config_path = Path(sys.argv[1])
print(json.dumps({
    "config_file": str(config_path),
    "config_exists": config_path.exists(),
    "active_profile": sys.argv[2],
    "available_profiles": [item.strip() for item in str(sys.argv[3]).split(",") if item.strip()],
    "ops_mainland_api_base_url": sys.argv[4],
    "ops_overseas_api_base_url": sys.argv[5],
    "ops_default_control_plane_base_url": sys.argv[6],
    "ops_default_requested_by": sys.argv[7],
    "ops_default_issued_by": sys.argv[8],
    "ops_default_expires_in_hours": int(sys.argv[9] or 72),
    "ops_default_root_dir": sys.argv[10],
    "ops_node_agent_service_name": sys.argv[11],
    "ops_node_agent_env_file": sys.argv[12],
    "ops_report_root": sys.argv[13],
}, ensure_ascii=False, indent=2))
PY
  OPS_CENTER_ACTIVE_PROFILE="${saved_profile}"
  OPS_CENTER_ACTIVE_PROFILE_KEY="${saved_profile_key}"
}

timestamp_now() {
  date '+%Y%m%d_%H%M%S'
}

ops_center_repo_root() {
  printf '%s' "${OPS_CENTER_PROJECT_ROOT}"
}

confirm_to_bool() {
  local raw_value="${1:-}"
  case "$(printf '%s' "${raw_value}" | tr '[:upper:]' '[:lower:]')" in
    1|true|yes|y|confirm|confirmed|skip|skip-smoke)
      printf 'true'
      ;;
    *)
      printf 'false'
      ;;
  esac
}

is_confirm_token() {
  local raw_value="${1:-}"
  case "$(printf '%s' "${raw_value}" | tr '[:upper:]' '[:lower:]')" in
    1|true|yes|y|confirm|confirmed)
      return 0
      ;;
    *)
      return 1
      ;;
  esac
}

is_secondary_token() {
  local raw_value="${1:-}"
  case "$(printf '%s' "${raw_value}" | tr '[:upper:]' '[:lower:]')" in
    secondary|second|2|true|yes|y)
      return 0
      ;;
    *)
      return 1
      ;;
  esac
}

normalize_payload_json_input() {
  local raw_value="${1:-}"
  if [[ -z "${raw_value}" ]]; then
    printf '{}'
    return 0
  fi
  if [[ "${raw_value}" == @* ]]; then
    local payload_path="${raw_value#@}"
    if [[ ! -f "${payload_path}" ]]; then
      echo "payload file not found: ${payload_path}" >&2
      return 1
    fi
    cat "${payload_path}"
    return 0
  fi
  printf '%s' "${raw_value}"
}

enrich_driver_action_payload_json() {
  local mainland_base_url="$1"
  local action_code="$2"
  local payload_json="$3"

  python3 - <<'PY' "${mainland_base_url}" "${action_code}" "${payload_json}"
import json
import sys
import urllib.request


def normalize_codes(*groups):
    result = []
    for group in groups:
        for item in list(group or []):
            node_code = str(item or "").strip()
            if node_code and node_code not in result:
                result.append(node_code)
    return result


base_url = str(sys.argv[1] or "").rstrip("/")
action_code = str(sys.argv[2] or "").strip()
payload_raw = str(sys.argv[3] or "").strip() or "{}"

try:
    payload = json.loads(payload_raw)
except Exception:
    payload = {}
if not isinstance(payload, dict):
    payload = {}

existing_node_codes = normalize_codes(payload.get("node_codes") or [])
if existing_node_codes:
    print(json.dumps(payload, ensure_ascii=False))
    raise SystemExit(0)

supported_actions = {
    "open_worker_logs_participating",
    "run_inspection_participating",
    "open_worker_logs_standby",
    "run_inspection_standby",
    "open_worker_logs",
    "run_standard_inspection",
}
if action_code not in supported_actions or not base_url:
    print(json.dumps(payload, ensure_ascii=False))
    raise SystemExit(0)

overview = {}
try:
    with urllib.request.urlopen(f"{base_url}/api/v1/ops/overview", timeout=20) as response:
        overview_payload = json.loads(response.read().decode("utf-8"))
        overview = dict((overview_payload or {}).get("data") or {})
except Exception:
    print(json.dumps(payload, ensure_ascii=False))
    raise SystemExit(0)

execution_scene = dict(overview.get("execution_scene") or {})
participation_summary = dict(execution_scene.get("participation_summary") or {})
log_sync = dict(execution_scene.get("log_sync") or {})

dispatch_active = normalize_codes(participation_summary.get("dispatch_active_node_codes") or [])
recent_only = normalize_codes(participation_summary.get("recent_only_node_codes") or [])
standby = normalize_codes(
    participation_summary.get("standby_node_codes") or [],
    participation_summary.get("non_participating_node_codes") or [],
)
missing_logs = normalize_codes(log_sync.get("missing_participating_nodes") or [])

derived_node_codes = []
if action_code in {"open_worker_logs_participating", "run_inspection_participating"}:
    derived_node_codes = normalize_codes(missing_logs, dispatch_active, recent_only)
elif action_code in {"open_worker_logs_standby", "run_inspection_standby"}:
    derived_node_codes = normalize_codes(standby)
elif action_code == "open_worker_logs":
    derived_node_codes = normalize_codes(missing_logs, dispatch_active, recent_only, standby)
elif action_code == "run_standard_inspection":
    derived_node_codes = normalize_codes(dispatch_active, recent_only, standby)

if derived_node_codes:
    payload["node_codes"] = derived_node_codes
    payload.setdefault("_auto_context", {})
    payload["_auto_context"]["resolved_by"] = "drive_ops_center"
    payload["_auto_context"]["resolved_from"] = "ops.overview"
    payload["_auto_context"]["action_code"] = action_code

print(json.dumps(payload, ensure_ascii=False))
PY
}

normalize_optional_base_url_arg() {
  local raw_value="${1:-}"
  local default_value="${2:-}"
  case "$(printf '%s' "${raw_value}" | tr '[:upper:]' '[:lower:]')" in
    "" )
      printf '%s' "${default_value}"
      ;;
    -|none|null|disabled|off)
      printf ''
      ;;
    *)
      printf '%s' "${raw_value}"
      ;;
  esac
}

write_json_file() {
  local output_path="$1"
  local json_payload="$2"
  python3 - "${output_path}" "${json_payload}" <<'PY'
import json
import sys
from pathlib import Path

path = Path(sys.argv[1])
payload = json.loads(sys.argv[2])
path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
PY
}

run_and_capture_report() {
  local title="$1"
  local output_path="$2"
  shift 2
  {
    echo "============================================================"
    echo "${title}"
    echo "============================================================"
    "$@"
    echo
  } | tee "${output_path}"
}

capture_report_quiet() {
  local title="$1"
  local output_path="$2"
  shift 2
  local command_exit_code=0
  echo "============================================================"
  echo "${title}"
  echo "============================================================"
  {
    echo "============================================================"
    echo "${title}"
    echo "============================================================"
    set +e
    timeout "${OPS_CENTER_DOCTOR_REPORT_TIMEOUT_SECONDS}" "$@"
    command_exit_code=$?
    set -e
    echo
    echo "command_exit_code=${command_exit_code}"
  } >"${output_path}"
  echo "saved_report=${output_path}"
  echo "command_exit_code=${command_exit_code}"
  echo
}

capture_report_optional() {
  local title="$1"
  local output_path="$2"
  shift 2
  local command_exit_code=0

  echo "============================================================"
  echo "${title}"
  echo "============================================================"
  {
    echo "============================================================"
    echo "${title}"
    echo "============================================================"
    set +e
    timeout "${OPS_CENTER_DOCTOR_REPORT_TIMEOUT_SECONDS}" "$@"
    command_exit_code=$?
    set -e
    echo
    echo "command_exit_code=${command_exit_code}"
  } >"${output_path}" 2>&1
  echo "saved_report=${output_path}"
  echo "command_exit_code=${command_exit_code}"
  echo
}

run_doctor_report_export() {
  local report_dir="$1"
  local mainland_base_url="$2"
  local overseas_base_url="$3"
  ops_center_ensure_report_dir "${report_dir}"
  local -a report_files=(
    "00_ops_center_stack_summary.txt"
    "01_ops_plane.txt"
    "02_release_hub.txt"
    "03_inspection.txt"
    "04_participation.txt"
  )
  if [[ -n "${overseas_base_url}" ]]; then
    report_files+=("05_topology.txt")
  fi
  report_files+=(
    "06_contracts_registry.txt"
    "07_driver_feed.txt"
    "08_activity_stream.txt"
    "09_codex_brief.txt"
    "10_stack_next_preview.txt"
    "11_driver_focus_preview.txt"
    "12_activity_preview.txt"
    "13_codex_focus_preview.txt"
    "14_first_handover_gap.txt"
  )

  capture_report_quiet "[doctor/0] ops center stack" "${report_dir}/00_ops_center_stack_summary.txt" \
    bash "${SCRIPT_DIR}/check_ops_center_stack.sh" "${mainland_base_url}" summary
  capture_report_quiet "[doctor/1] ops plane" "${report_dir}/01_ops_plane.txt" \
    bash "${SCRIPT_DIR}/check_ops_plane.sh" "${mainland_base_url}"
  capture_report_quiet "[doctor/2] release hub" "${report_dir}/02_release_hub.txt" \
    bash "${SCRIPT_DIR}/check_release_hub.sh" "${mainland_base_url}"
  capture_report_quiet "[doctor/3] inspection" "${report_dir}/03_inspection.txt" \
    bash "${SCRIPT_DIR}/check_ops_inspection.sh" "${mainland_base_url}"
  capture_report_quiet "[doctor/4] participation" "${report_dir}/04_participation.txt" \
    bash "${SCRIPT_DIR}/check_worker_participation.sh" "${mainland_base_url}"
  if [[ -n "${overseas_base_url}" ]]; then
    capture_report_quiet "[doctor/5] temp topology" "${report_dir}/05_topology.txt" \
      bash "${SCRIPT_DIR}/check_temp_topology.sh" "${mainland_base_url}" "${overseas_base_url}"
  fi
  capture_report_quiet "[doctor/6] contracts registry" "${report_dir}/06_contracts_registry.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" contracts "${mainland_base_url}"
  capture_report_quiet "[doctor/7] driver feed" "${report_dir}/07_driver_feed.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" driver-feed "${mainland_base_url}"
  capture_report_quiet "[doctor/8] activity stream" "${report_dir}/08_activity_stream.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" activity-stream "${mainland_base_url}"
  capture_report_quiet "[doctor/9] codex brief" "${report_dir}/09_codex_brief.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" codex-brief "${mainland_base_url}"
  capture_report_optional "[doctor/10] stack next preview" "${report_dir}/10_stack_next_preview.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" stack-next "${mainland_base_url}" preview
  capture_report_optional "[doctor/11] driver focus preview" "${report_dir}/11_driver_focus_preview.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" driver-focus-preview "${mainland_base_url}"
  capture_report_optional "[doctor/12] activity preview" "${report_dir}/12_activity_preview.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" activity-preview "${mainland_base_url}"
  capture_report_optional "[doctor/13] codex focus preview" "${report_dir}/13_codex_focus_preview.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" codex-focus-preview "${mainland_base_url}"
  capture_report_optional "[doctor/14] first handover gap" "${report_dir}/14_first_handover_gap.txt" \
    bash "${SCRIPT_DIR}/drive_ops_center.sh" stack-first-gap-handover "${mainland_base_url}"

  local scene_log_targets_json
  scene_log_targets_json="$(python3 - <<'PY' "${report_dir}/00_ops_center_stack_summary.txt"
import json
import re
import sys
from pathlib import Path

target = Path(str(sys.argv[1] or "").strip())
if not target.exists():
    print("[]")
    raise SystemExit(0)

text = target.read_text(encoding="utf-8", errors="replace")
decoder = json.JSONDecoder()
best = None
for index, ch in enumerate(text):
    if ch not in "{[":
        continue
    try:
        value, end = decoder.raw_decode(text[index:])
    except Exception:
        continue
    absolute_end = index + end
    if best is None or absolute_end >= best[0]:
        best = (absolute_end, value)

payload = best[1] if best else {}
diagnosis = dict((payload or {}).get("diagnosis") or {})
issues = list(diagnosis.get("issues") or [])
next_step = dict(diagnosis.get("next_step") or {})
operator_decision = dict(diagnosis.get("operator_decision") or {})

targets = []
seen = set()

def add_focus_ref(focus_ref):
    if not isinstance(focus_ref, dict):
        return
    if str(focus_ref.get("kind") or "").strip() != "node_scene_log":
        return
    node_code = str(focus_ref.get("node_code") or "").strip()
    if not node_code or node_code in seen:
        return
    seen.add(node_code)
    mode = str(focus_ref.get("mode") or "key").strip().lower()
    if mode not in {"key", "full"}:
        mode = "key"
    try:
        limit = int(focus_ref.get("limit") or 80)
    except Exception:
        limit = 80
    limit = max(20, min(limit, 300))
    targets.append({
        "node_code": node_code,
        "mode": mode,
        "limit": limit,
        "source": str(focus_ref.get("source") or "").strip(),
    })

for issue in issues:
    add_focus_ref((issue or {}).get("focus_ref"))
add_focus_ref(next_step.get("focus_ref"))
add_focus_ref(operator_decision.get("next_focus"))

print(json.dumps(targets[:3], ensure_ascii=False))
PY
)"

  while IFS=$'\t' read -r scene_node_code scene_mode scene_limit scene_source; do
    [[ -z "${scene_node_code}" ]] && continue
    local safe_node_code
    safe_node_code="$(printf '%s' "${scene_node_code}" | tr -c 'A-Za-z0-9._-' '_')"
    local scene_report_name="15_scene_node_log_${safe_node_code}.txt"
    report_files+=("${scene_report_name}")
    capture_report_optional "[doctor/15] scene node log ${scene_node_code}" "${report_dir}/${scene_report_name}" \
      bash "${SCRIPT_DIR}/drive_ops_center.sh" scene-node-log "${mainland_base_url}" "${scene_node_code}" "${scene_limit:-80}" "${scene_mode:-key}"
  done < <(
    python3 - <<'PY' "${scene_log_targets_json}"
import json
import sys

targets = json.loads(str(sys.argv[1] or "[]"))
for item in targets:
    print(
        "\t".join(
            [
                str(item.get("node_code") or "").strip(),
                str(item.get("mode") or "key").strip(),
                str(item.get("limit") or 80).strip(),
                str(item.get("source") or "").strip(),
            ]
        )
    )
PY
  )

  write_json_file "${report_dir}/meta.json" "$(python3 - \
    "${OPS_CENTER_CONFIG_FILE}" \
    "${OPS_CENTER_ACTIVE_PROFILE}" \
    "${mainland_base_url}" \
    "${overseas_base_url}" \
    "${report_dir}" \
    "${report_files[@]}" <<'PY'
import json
import sys
from datetime import datetime

files = list(sys.argv[6:])

print(json.dumps({
    "generated_at": datetime.now().isoformat(timespec="seconds"),
    "config_file": sys.argv[1],
    "active_profile": sys.argv[2],
    "mainland_api_base_url": sys.argv[3],
    "overseas_api_base_url": sys.argv[4],
    "report_dir": sys.argv[5],
    "files": files,
}, ensure_ascii=False))
PY
)"

  write_json_file "${report_dir}/manifest.json" "$(python3 - \
    "${OPS_CENTER_CONFIG_FILE}" \
    "${OPS_CENTER_ACTIVE_PROFILE}" \
    "${mainland_base_url}" \
    "${overseas_base_url}" \
    "${report_dir}" \
    "${report_files[@]}" <<'PY'
import json
import re
import sys
from datetime import datetime
from pathlib import Path

config_file = str(sys.argv[1] or "").strip()
active_profile = str(sys.argv[2] or "").strip()
mainland_api_base_url = str(sys.argv[3] or "").strip()
overseas_api_base_url = str(sys.argv[4] or "").strip()
report_dir = Path(str(sys.argv[5] or "").strip())
report_files = [str(item or "").strip() for item in sys.argv[6:] if str(item or "").strip()]
optional_preview_files = {
    "10_stack_next_preview.txt",
    "11_driver_focus_preview.txt",
    "12_activity_preview.txt",
    "13_codex_focus_preview.txt",
}


def extract_exit_code(text: str) -> int:
    matches = re.findall(r"(?m)^command_exit_code=(\d+)\s*$", text)
    if matches:
        try:
            return int(matches[-1])
        except Exception:
            return 1
    return 0


def extract_last_json_value(text: str):
    decoder = json.JSONDecoder()
    best = None
    for index, ch in enumerate(text):
        if ch not in "{[":
            continue
        try:
            value, end = decoder.raw_decode(text[index:])
        except Exception:
            continue
        absolute_end = index + end
        if best is None or absolute_end >= best[0]:
            best = (absolute_end, value)
    return None if best is None else best[1]


def last_nonempty_line(text: str) -> str:
    for line in reversed(text.splitlines()):
        stripped = line.strip()
        if stripped:
            return stripped[:300]
    return ""


def collect_contract_keys(value, bucket: set) -> None:
    if isinstance(value, dict):
        for key, child in value.items():
            if key in {"contract_key", "primary_contract_key"}:
                contract_key = str(child or "").strip()
                if contract_key:
                    bucket.add(contract_key)
                continue
            if key in {"contract_keys", "related_contract_keys"} and isinstance(child, list):
                for item in child:
                    contract_key = str(item or "").strip()
                    if contract_key:
                        bucket.add(contract_key)
                continue
            collect_contract_keys(child, bucket)
    elif isinstance(value, list):
        for item in value:
            collect_contract_keys(item, bucket)


def summarize_report(name: str, payload, exit_code: int, text: str) -> dict:
    if not isinstance(payload, dict):
        return {
            "parsed_json": False,
            "available": exit_code == 0,
            "text_tail": last_nonempty_line(text),
        }

    if name == "00_ops_center_stack_summary.txt":
        diagnosis = dict(payload.get("diagnosis") or {})
        api = dict(payload.get("api") or {})
        issues = list(diagnosis.get("issues") or payload.get("issues") or [])
        next_step = dict(diagnosis.get("next_step") or payload.get("next_step") or {})
        operator_decision = dict(diagnosis.get("operator_decision") or {})
        next_actions = dict(diagnosis.get("next_actions") or {})
        recommended_commands = dict(diagnosis.get("recommended_commands") or {})
        stack_status = str(diagnosis.get("stack_status") or payload.get("stack_status") or payload.get("status") or "")
        blocked_issue = next(
            (dict(item or {}) for item in issues if str((item or {}).get("severity") or "") == "blocked"),
            {},
        )
        headline = ""
        if stack_status == "blocked":
            headline = str(blocked_issue.get("summary") or "").strip()
        if not headline:
            headline = str(
                diagnosis.get("headline")
                or (payload.get("link_snapshot") or {}).get("headline")
                or ""
            ).strip()
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(api.get("http_status", 0) or 0),
            "stack_status": stack_status,
            "surface_status": str(diagnosis.get("surface_status") or ""),
            "automation_status": str(diagnosis.get("automation_status") or ""),
            "issues_total": len(issues),
            "blocked_issues": sum(1 for item in issues if str((item or {}).get("severity") or "") == "blocked"),
            "headline": headline,
            "blocked_issue_detail": str(blocked_issue.get("detail") or "").strip(),
            "launchpad_recommended_target_node_code": str(diagnosis.get("launchpad_recommended_target_node_code") or ""),
            "launchpad_recommended_recovery_label": str(diagnosis.get("launchpad_recommended_recovery_label") or ""),
            "launchpad_recommended_recovery_summary": str(diagnosis.get("launchpad_recommended_recovery_summary") or ""),
            "launchpad_onboarding_bootstrap_pending_nodes": int(diagnosis.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
            "launchpad_onboarding_acceptance_ready_nodes": int(diagnosis.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
            "next_step_action_code": str(next_step.get("action_code") or ""),
            "next_step_summary": str(next_step.get("summary") or next_step.get("title") or next_step.get("reason") or ""),
            "operator_lane": str(operator_decision.get("lane") or "").strip(),
            "operator_priority": str(operator_decision.get("priority") or "").strip(),
            "operator_reason_code": str(operator_decision.get("reason_code") or "").strip(),
            "operator_title": str(operator_decision.get("title") or "").strip(),
            "operator_summary": str(operator_decision.get("summary") or "").strip(),
            "operator_primary_command_key": str(operator_decision.get("primary_command_key") or "").strip(),
            "operator_secondary_command_key": str(operator_decision.get("secondary_command_key") or "").strip(),
            "operator_primary_command": str(
                next_actions.get("primary_command")
                or recommended_commands.get(str(operator_decision.get("primary_command_key") or "").strip())
                or ""
            ).strip(),
            "operator_secondary_command": str(
                next_actions.get("secondary_command")
                or recommended_commands.get(str(operator_decision.get("secondary_command_key") or "").strip())
                or ""
            ).strip(),
            "operator_focus_kind": str((operator_decision.get("next_focus") or {}).get("kind") or "").strip(),
            "operator_focus_node_code": str((operator_decision.get("next_focus") or {}).get("node_code") or "").strip(),
        }

    if name == "06_contracts_registry.txt":
        contracts = list(payload.get("contracts") or [])
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "registry_version": str(payload.get("registry_version") or ""),
            "schema_version": str(payload.get("schema_version") or ""),
            "contracts_total": int(payload.get("contracts_total", 0) or len(contracts)),
        }

    if name == "07_driver_feed.txt":
        summary = dict(payload.get("summary") or {})
        top_recommendation = dict(payload.get("top_recommendation") or {})
        contract_navigation = dict(payload.get("contract_navigation") or {})
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "headline": str(payload.get("headline") or ""),
            "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
            "entry_count": len(list(payload.get("entries") or [])),
            "activity_focus_count": len(list(payload.get("activity_focus") or [])),
            "top_recommendation_key": str(top_recommendation.get("key") or ""),
            "top_recommendation_contract_key": str(top_recommendation.get("primary_contract_key") or ""),
            "do_now_total": int(summary.get("do_now_total", 0) or 0),
            "launchpad_recommended_target_node_code": str(summary.get("launchpad_recommended_target_node_code") or ""),
            "launchpad_recommended_recovery_label": str(summary.get("launchpad_recommended_recovery_label") or ""),
            "launchpad_recommended_recovery_summary": str(summary.get("launchpad_recommended_recovery_summary") or ""),
            "launchpad_onboarding_bootstrap_pending_nodes": int(summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
            "launchpad_onboarding_acceptance_ready_nodes": int(summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
        }

    if name == "08_activity_stream.txt":
        summary = dict(payload.get("summary") or {})
        contract_navigation = dict(payload.get("contract_navigation") or {})
        items = list(payload.get("items") or [])
        first_item = dict(items[0] or {}) if items else {}
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
            "filtered_total": int(summary.get("filtered_total", 0) or 0),
            "item_count": len(items),
            "first_item_key": str(first_item.get("activity_key") or ""),
            "first_item_contract_key": str(first_item.get("primary_contract_key") or ""),
        }

    if name == "09_codex_brief.txt":
        summary = dict(payload.get("summary") or {})
        focus = dict(payload.get("focus") or {})
        contract_navigation = dict(payload.get("contract_navigation") or {})
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "headline": str(payload.get("headline") or ""),
            "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
            "focus_entry_key": str(focus.get("entry_key") or ""),
            "focus_contract_key": str(focus.get("primary_contract_key") or ""),
            "entry_count": len(list(payload.get("entries") or [])),
            "activity_focus_count": len(list(payload.get("activity_focus") or [])),
            "blocked_total": int(summary.get("blocked_total", 0) or 0),
            "launchpad_recommended_target_node_code": str(summary.get("launchpad_recommended_target_node_code") or ""),
            "launchpad_recommended_recovery_label": str(summary.get("launchpad_recommended_recovery_label") or ""),
            "launchpad_recommended_recovery_summary": str(summary.get("launchpad_recommended_recovery_summary") or ""),
            "launchpad_onboarding_bootstrap_pending_nodes": int(summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
            "launchpad_onboarding_acceptance_ready_nodes": int(summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
        }

    if name in optional_preview_files:
        contract = dict(payload.get("contract") or {})
        gate = dict(payload.get("gate") or {})
        selected = dict(payload.get("selected_entry") or {})
        selected_key = (
            str(selected.get("key") or "").strip()
            or str(selected.get("activity_key") or "").strip()
            or str(selected.get("action_code") or "").strip()
        )
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "contract_key": str(contract.get("contract_key") or ""),
            "contract_version": str(contract.get("contract_version") or ""),
            "preview_endpoint": str(contract.get("preview_endpoint") or ""),
            "gate_decision": str(gate.get("decision") or ""),
            "selected_key": selected_key,
            "selected_title": str(selected.get("title") or ""),
        }

    if name.startswith("15_scene_node_log_"):
        participation = dict(payload.get("participation") or {})
        source_summary = dict(payload.get("source_summary") or {})
        return {
            "parsed_json": True,
            "available": exit_code == 0,
            "http_status": int(payload.get("http_status", 0) or 0),
            "node_code": str(payload.get("node_code") or ""),
            "status": str(payload.get("status") or ""),
            "status_label": str(payload.get("status_label") or ""),
            "mode": str(payload.get("mode") or ""),
            "records_total": int(payload.get("records_total", 0) or 0),
            "detect_participating": bool(participation.get("detect_participating", False)),
            "participation_label": str(participation.get("participation_label") or ""),
            "source_line_count": int(source_summary.get("line_count", 0) or 0),
            "missing_reason_code": str(payload.get("missing_reason_code") or ""),
        }

    return {
        "parsed_json": True,
        "available": exit_code == 0,
        "top_level_keys": list(payload.keys())[:12],
    }


def classify_report_failure(name: str, exists: bool, payload, summary: dict, exit_code: int, text: str) -> dict:
    http_status_raw = ""
    if isinstance(summary, dict):
        http_status_raw = str(summary.get("http_status") or "").strip()
    text_tail = last_nonempty_line(text)
    has_payload = isinstance(payload, (dict, list))
    detail = ""
    reason_code = ""
    label = ""
    if not exists:
        reason_code = "report_missing"
        label = "未生成报告"
        detail = "导出阶段没有落盘该 report 文件。"
    elif exit_code == 124:
        reason_code = "command_timeout"
        label = "执行超时"
        detail = "报告命令超过超时阈值后被终止，建议先单独复跑对应子命令。"
    elif exit_code != 0:
        reason_code = "command_failed"
        label = "命令失败"
        detail = f"报告命令退出码为 {exit_code}。"
    elif http_status_raw and http_status_raw.isdigit() and not (200 <= int(http_status_raw) < 300):
        http_status = int(http_status_raw)
        if http_status == 0:
            reason_code = "http_unreachable"
            label = "接口不可达"
            detail = "curl 未拿到有效 HTTP 状态，通常表示超时、连接失败或被中间网络丢弃。"
        else:
            reason_code = "http_error"
            label = "接口异常"
            detail = f"目标接口返回 HTTP {http_status}。"
    elif not has_payload:
        reason_code = "result_unparsed"
        label = "结果不可解析"
        detail = "命令成功返回，但未解析出结构化 JSON 结果。"
    else:
        reason_code = "ok"
        label = "正常"
        detail = ""

    if text_tail and reason_code != "ok":
        detail = (detail + f" 最近输出: {text_tail}")[:500].strip()

    return {
        "reason_code": reason_code,
        "label": label,
        "detail": detail,
        "timeout": reason_code == "command_timeout",
        "http_status": int(http_status_raw) if http_status_raw.isdigit() else 0,
        "text_tail": text_tail,
        "parsed_json": bool(isinstance(summary, dict) and summary.get("parsed_json")),
    }


reports = []
all_contract_keys = set()
required_failures = []
optional_unavailable = []

for name in report_files:
    path = report_dir / name
    exists = path.exists()
    text = path.read_text(encoding="utf-8", errors="replace") if exists else ""
    exit_code = extract_exit_code(text) if exists else 1
    parsed_payload = extract_last_json_value(text) if exists else None
    summary = summarize_report(name, parsed_payload, exit_code, text)
    if parsed_payload is not None:
        collect_contract_keys(parsed_payload, all_contract_keys)
    http_status = summary.get("http_status") if isinstance(summary, dict) else None
    http_ok = True
    if isinstance(http_status, int):
        http_ok = 200 <= http_status < 300
    report_ok = exists and exit_code == 0 and http_ok
    if isinstance(summary, dict) and "available" in summary:
        summary["available"] = report_ok
    report_entry = {
        "name": name,
        "path": str(path),
        "exists": exists,
        "size_bytes": int(path.stat().st_size) if exists else 0,
        "optional": name in optional_preview_files,
        "command_exit_code": exit_code,
        "ok": report_ok,
        "summary": summary,
        "failure": classify_report_failure(name, exists, parsed_payload, summary, exit_code, text),
    }
    reports.append(report_entry)

    if name in optional_preview_files:
        if not report_entry["ok"]:
            optional_unavailable.append(name)
    else:
        if not report_entry["ok"]:
            required_failures.append(name)

preview_contract_keys = sorted(
    {
        str((report.get("summary") or {}).get("contract_key") or "").strip()
        for report in reports
        if report.get("name") in optional_preview_files
        and str((report.get("summary") or {}).get("contract_key") or "").strip()
    }
)
primary_contract_keys = sorted(
    {
        str((report.get("summary") or {}).get("primary_contract_key") or "").strip()
        for report in reports
        if str((report.get("summary") or {}).get("primary_contract_key") or "").strip()
    }
)
reports_by_name = {str(report.get("name") or ""): report for report in reports}
scene_log_reports = [
    report
    for report in reports
    if str(report.get("name") or "").startswith("15_scene_node_log_")
]
scene_log_report_summaries = [dict(report.get("summary") or {}) for report in scene_log_reports]
scene_log_reports_total = len(scene_log_reports)
scene_log_reports_ok = sum(1 for report in scene_log_reports if bool(report.get("ok")))
scene_log_status_counts = {}
for summary in scene_log_report_summaries:
    status_key = str(summary.get("status") or "unknown").strip() or "unknown"
    scene_log_status_counts[status_key] = int(scene_log_status_counts.get(status_key, 0) or 0) + 1
scene_log_problem_reports = [
    summary
    for summary in scene_log_report_summaries
    if str(summary.get("status") or "").strip() in {"waiting_sample", "missing_sample", "disabled", "standby", "unknown"}
]
scene_log_problem_node_codes = [
    str(summary.get("node_code") or "").strip()
    for summary in scene_log_problem_reports
    if str(summary.get("node_code") or "").strip()
]
scene_log_healthy_reports = [
    summary
    for summary in scene_log_report_summaries
    if str(summary.get("status") or "").strip() in {"healthy", "full_capture", "historical_sample"}
]

required_failure_details = [
    {
        "name": str(report.get("name") or ""),
        "reason_code": str((report.get("failure") or {}).get("reason_code") or ""),
        "label": str((report.get("failure") or {}).get("label") or ""),
        "detail": str((report.get("failure") or {}).get("detail") or ""),
    }
    for report in reports
    if not bool(report.get("optional")) and not bool(report.get("ok"))
]
optional_unavailable_details = [
    {
        "name": str(report.get("name") or ""),
        "reason_code": str((report.get("failure") or {}).get("reason_code") or ""),
        "label": str((report.get("failure") or {}).get("label") or ""),
        "detail": str((report.get("failure") or {}).get("detail") or ""),
    }
    for report in reports
    if bool(report.get("optional")) and not bool(report.get("ok"))
]


def report_summary(name: str) -> dict:
    return dict((reports_by_name.get(name) or {}).get("summary") or {})


def report_ok(name: str) -> bool:
    return bool((reports_by_name.get(name) or {}).get("ok"))


def report_http_status(name: str) -> int:
    value = report_summary(name).get("http_status")
    return int(value or 0) if isinstance(value, int) or str(value).isdigit() else 0


contracts_summary = report_summary("06_contracts_registry.txt")
driver_feed_summary = report_summary("07_driver_feed.txt")
activity_stream_summary = report_summary("08_activity_stream.txt")
codex_brief_summary = report_summary("09_codex_brief.txt")
stack_summary = report_summary("00_ops_center_stack_summary.txt")
launchpad_recommended_target_node_code = next(
    (
        str(source.get("launchpad_recommended_target_node_code") or "").strip()
        for source in [driver_feed_summary, codex_brief_summary, stack_summary]
        if str(source.get("launchpad_recommended_target_node_code") or "").strip()
    ),
    "",
)
launchpad_recommended_recovery_label = next(
    (
        str(source.get("launchpad_recommended_recovery_label") or "").strip()
        for source in [driver_feed_summary, codex_brief_summary, stack_summary]
        if str(source.get("launchpad_recommended_recovery_label") or "").strip()
    ),
    "",
)
launchpad_recommended_recovery_summary = next(
    (
        str(source.get("launchpad_recommended_recovery_summary") or "").strip()
        for source in [driver_feed_summary, codex_brief_summary, stack_summary]
        if str(source.get("launchpad_recommended_recovery_summary") or "").strip()
    ),
    "",
)
launchpad_onboarding_bootstrap_pending_nodes = max(
    int(driver_feed_summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
    int(codex_brief_summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
    int(stack_summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
)
launchpad_onboarding_acceptance_ready_nodes = max(
    int(driver_feed_summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    int(codex_brief_summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    int(stack_summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
)
stack_status = str(stack_summary.get("stack_status") or "").strip()
stack_headline = str(stack_summary.get("headline") or "").strip()
stack_blocked_issue_detail = str(stack_summary.get("blocked_issue_detail") or "").strip()
stack_next_summary = str(stack_summary.get("next_step_summary") or "").strip()
stack_next_action_code = str(stack_summary.get("next_step_action_code") or "").strip()
stack_blocked_issues = int(stack_summary.get("blocked_issues", 0) or 0)
stack_operator_lane = str(stack_summary.get("operator_lane") or "").strip()
stack_operator_priority = str(stack_summary.get("operator_priority") or "").strip()
stack_operator_reason_code = str(stack_summary.get("operator_reason_code") or "").strip()
stack_operator_title = str(stack_summary.get("operator_title") or "").strip()
stack_operator_summary = str(stack_summary.get("operator_summary") or "").strip()
stack_operator_primary_command_key = str(stack_summary.get("operator_primary_command_key") or "").strip()
stack_operator_secondary_command_key = str(stack_summary.get("operator_secondary_command_key") or "").strip()
stack_operator_primary_command = str(stack_summary.get("operator_primary_command") or "").strip()
stack_operator_secondary_command = str(stack_summary.get("operator_secondary_command") or "").strip()
stack_operator_focus_kind = str(stack_summary.get("operator_focus_kind") or "").strip()
stack_operator_focus_node_code = str(stack_summary.get("operator_focus_node_code") or "").strip()

stack_primary_commands = []
for candidate in [
    stack_operator_primary_command,
    stack_operator_secondary_command,
]:
    normalized_candidate = str(candidate or "").strip()
    if normalized_candidate and normalized_candidate not in stack_primary_commands:
        stack_primary_commands.append(normalized_candidate)

stack_preferred_surface = "stack-summary"
if stack_operator_focus_kind == "node_scene_log":
    stack_preferred_surface = "execution-scene"
elif stack_operator_lane == "node_handover":
    stack_preferred_surface = "managed-nodes"
elif stack_operator_lane == "release":
    stack_preferred_surface = "release-hub"
elif stack_operator_lane == "observability":
    stack_preferred_surface = "execution-scene"
elif stack_operator_lane in {"ops_jobs", "steady"}:
    stack_preferred_surface = "driver-feed"

contract_surface_gaps = []
if report_ok("07_driver_feed.txt") and not str(driver_feed_summary.get("primary_contract_key") or "").strip():
    contract_surface_gaps.append("driver-feed")
if report_ok("08_activity_stream.txt") and not str(activity_stream_summary.get("primary_contract_key") or "").strip():
    contract_surface_gaps.append("activity-stream")
if report_ok("09_codex_brief.txt") and not str(codex_brief_summary.get("primary_contract_key") or "").strip():
    contract_surface_gaps.append("codex-brief")

surface_http_status = {
    "stack_summary": report_http_status("00_ops_center_stack_summary.txt"),
    "contracts_registry": report_http_status("06_contracts_registry.txt"),
    "driver_feed": report_http_status("07_driver_feed.txt"),
    "activity_stream": report_http_status("08_activity_stream.txt"),
    "codex_brief": report_http_status("09_codex_brief.txt"),
    "stack_next_preview": report_http_status("10_stack_next_preview.txt"),
    "driver_focus_preview": report_http_status("11_driver_focus_preview.txt"),
    "activity_preview": report_http_status("12_activity_preview.txt"),
    "codex_focus_preview": report_http_status("13_codex_focus_preview.txt"),
}

doctor_command = f"bash domain-api/deploy/multi-region/drive_ops_center.sh doctor {mainland_api_base_url}"
if overseas_api_base_url:
    doctor_command += f" {overseas_api_base_url}"

decision = {
    "status": "ready",
    "reason_code": "ops_center_ready",
    "headline": "海外控制面已经具备协议驱动的观察与预览能力。",
    "detail": "",
    "preferred_surface": "driver-feed",
    "next_action_code": "review_driver_feed",
    "recommended_commands": [
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh driver-feed {mainland_api_base_url}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh activity-stream {mainland_api_base_url}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh codex-brief {mainland_api_base_url}",
    ],
    "evidence": {
        "required_failures": required_failures,
        "optional_unavailable": optional_unavailable,
        "contract_surface_gaps": contract_surface_gaps,
        "surface_http_status": surface_http_status,
    },
}

if "06_contracts_registry.txt" in required_failures:
    http_status = int(contracts_summary.get("http_status", 0) or 0)
    contracts_failure = next(
        (
            item for item in required_failure_details
            if str(item.get("name") or "") == "06_contracts_registry.txt"
        ),
        {},
    )
    contracts_reason_code = str(contracts_failure.get("reason_code") or "").strip()
    contracts_failure_detail = str(contracts_failure.get("detail") or "").strip()
    decision = {
        "status": "blocked",
        "reason_code": contracts_reason_code or "contracts_registry_unavailable",
        "headline": (
            "控制面 contract registry 拉取超时，海外驾驶链路当前无法确认协议面是否完整。 "
            if contracts_reason_code == "command_timeout"
            else "控制面还没暴露 ops/contracts，海外驾驶链路当前不完整。"
        ),
        "detail": contracts_failure_detail or f"06_contracts_registry.txt http_status={http_status}，先恢复 contract registry，再继续 preview / execute。",
        "preferred_surface": "contracts",
        "next_action_code": "restore_contract_registry",
        "recommended_commands": [
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh contracts {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
        },
    }
elif required_failures:
    scene_log_required_failures = [
        name for name in required_failures
        if str(name or "").startswith("15_scene_node_log_")
    ]
    if scene_log_required_failures and stack_primary_commands:
        decision = {
            "status": "blocked" if stack_status == "blocked" else "attention",
            "reason_code": stack_operator_reason_code or "scene_log_surface_unavailable",
            "headline": stack_operator_title or "执行现场观察链路还没拿到可用日志样本。",
            "detail": stack_operator_summary or " / ".join(scene_log_required_failures),
            "preferred_surface": stack_preferred_surface,
            "next_action_code": stack_operator_primary_command_key or "inspect_scene_log_reports",
            "recommended_commands": [
                *stack_primary_commands,
                f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
                doctor_command,
            ],
            "evidence": {
                "required_failures": required_failures,
                "required_failure_details": required_failure_details,
                "optional_unavailable": optional_unavailable,
                "optional_unavailable_details": optional_unavailable_details,
                "contract_surface_gaps": contract_surface_gaps,
                "surface_http_status": surface_http_status,
                "scene_log_status_counts": scene_log_status_counts,
            },
        }
    else:
        decision = {
            "status": "blocked",
            "reason_code": "required_surfaces_unavailable",
            "headline": "海外控制面仍有必需 surface 缺失，先修 surface 再谈自动驾驶。",
            "detail": " / ".join(required_failures),
            "preferred_surface": stack_preferred_surface if stack_primary_commands else "stack-summary",
            "next_action_code": stack_operator_primary_command_key or "repair_required_surfaces",
            "recommended_commands": [
                *stack_primary_commands,
                doctor_command,
                f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
            ],
            "evidence": {
                "required_failures": required_failures,
                "required_failure_details": required_failure_details,
                "optional_unavailable": optional_unavailable,
                "optional_unavailable_details": optional_unavailable_details,
                "contract_surface_gaps": contract_surface_gaps,
                "surface_http_status": surface_http_status,
            },
        }
elif contract_surface_gaps:
    decision = {
        "status": "attention",
        "reason_code": "contract_navigation_incomplete",
        "headline": "核心观察面已在线，但 contract_navigation 还没完全补齐。",
        "detail": "缺少主协议标记的 surface: " + " / ".join(contract_surface_gaps),
        "preferred_surface": contract_surface_gaps[0],
        "next_action_code": "fill_contract_navigation",
        "recommended_commands": [
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh driver-feed {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh activity-stream {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh codex-brief {mainland_api_base_url}",
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
        },
    }
elif stack_status == "blocked":
    decision = {
        "status": "blocked",
        "reason_code": stack_operator_reason_code or "stack_diagnosis_blocked",
        "headline": stack_operator_title or stack_headline or "控制面总检已判定当前现场存在阻断问题，暂不应继续执行自动化动作。",
        "detail": stack_operator_summary or stack_blocked_issue_detail or stack_next_summary or f"stack_diagnosis.blocked_issues={stack_blocked_issues}",
        "preferred_surface": stack_preferred_surface,
        "next_action_code": stack_operator_primary_command_key or stack_next_action_code or "resolve_stack_blockers",
        "recommended_commands": [
            *stack_primary_commands,
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
            doctor_command,
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
        },
    }
elif stack_status == "attention":
    if stack_operator_reason_code == "runtime_build_schema_stale":
        restart_commands = []
        for candidate in [
            stack_operator_primary_command,
            stack_operator_secondary_command,
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {mainland_api_base_url}",
            doctor_command,
        ]:
            normalized_candidate = str(candidate or "").strip()
            if normalized_candidate and normalized_candidate not in restart_commands:
                restart_commands.append(normalized_candidate)
        decision = {
            "status": "attention",
            "reason_code": "runtime_build_schema_stale",
            "headline": stack_operator_title or "仓库代码已更新，但运行中的控制面 API 还是旧 schema。",
            "detail": stack_operator_summary or stack_next_summary or "先执行 runtime-refresh-recover，让控制面 API 切到最新代码；随后重新执行 stack-diagnosis / stack-next，再继续节点接管。",
            "preferred_surface": "stack-summary",
            "next_action_code": stack_operator_primary_command_key or "api-restart",
            "recommended_commands": restart_commands,
            "evidence": {
                "required_failures": required_failures,
                "required_failure_details": required_failure_details,
                "optional_unavailable": optional_unavailable,
                "optional_unavailable_details": optional_unavailable_details,
                "contract_surface_gaps": contract_surface_gaps,
                "surface_http_status": surface_http_status,
            },
        }
    else:
        decision = {
            "status": "attention",
            "reason_code": stack_operator_reason_code or "stack_diagnosis_attention",
            "headline": stack_operator_title or stack_headline or "控制面总检已发现待收口事项，建议先顺着 next_step 收口后再继续预览或执行。",
            "detail": stack_operator_summary or stack_next_summary or "请先处理 stack-diagnosis 提示的 attention 项。",
            "preferred_surface": stack_preferred_surface,
            "next_action_code": stack_operator_primary_command_key or stack_next_action_code or "review_stack_next",
            "recommended_commands": [
                *stack_primary_commands,
                f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {mainland_api_base_url}",
                f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
                doctor_command,
            ],
            "evidence": {
                "required_failures": required_failures,
                "required_failure_details": required_failure_details,
                "optional_unavailable": optional_unavailable,
                "optional_unavailable_details": optional_unavailable_details,
                "contract_surface_gaps": contract_surface_gaps,
                "surface_http_status": surface_http_status,
            },
        }
elif optional_unavailable:
    focus_entry = str(codex_brief_summary.get("focus_entry_key") or "").strip()
    decision = {
        "status": "attention",
        "reason_code": "preview_unavailable",
        "headline": "核心观察面已可用，但当前 preview 入口还没形成可执行焦点。",
        "detail": "当前不可用 preview: " + " / ".join(optional_unavailable),
        "preferred_surface": "codex-brief" if focus_entry else "driver-feed",
        "next_action_code": "inspect_focus_surfaces",
        "recommended_commands": [
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh driver-feed {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh activity-stream {mainland_api_base_url}",
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh codex-brief {mainland_api_base_url}",
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
        },
    }
elif scene_log_reports_total > 0 and scene_log_reports_ok == 0:
    first_scene_log = dict(scene_log_report_summaries[0] or {}) if scene_log_report_summaries else {}
    scene_log_node_code = str(first_scene_log.get("node_code") or "").strip()
    scene_log_mode = str(first_scene_log.get("mode") or "key").strip() or "key"
    decision = {
        "status": "attention",
        "reason_code": "scene_log_reports_unavailable",
        "headline": "总检已经识别出关键节点现场，但节点现场日志附件还没有成功形成可用样本。",
        "detail": (
            f"scene_log_reports_total={scene_log_reports_total}，全部附件当前不可用；"
            f"缺口节点 {', '.join(scene_log_problem_node_codes) or scene_log_node_code or '-'}"
        ),
        "preferred_surface": "execution-scene",
        "next_action_code": "inspect_scene_log_reports",
        "recommended_commands": [
            *(
                [
                    f"bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log {mainland_api_base_url} {scene_log_node_code} 120 {scene_log_mode}"
                ]
                if scene_log_node_code
                else []
            ),
            f"bash domain-api/deploy/multi-region/check_ops_center_stack.sh {mainland_api_base_url} summary",
            doctor_command,
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
            "scene_log_status_counts": scene_log_status_counts,
        },
    }
elif scene_log_problem_reports:
    first_scene_log = dict(scene_log_problem_reports[0] or {})
    scene_log_node_code = str(first_scene_log.get("node_code") or "").strip()
    scene_log_mode = str(first_scene_log.get("mode") or "key").strip() or "key"
    decision = {
        "status": "attention",
        "reason_code": "scene_log_reports_need_attention",
        "headline": "总检已经带回节点现场日志附件，但仍有参与节点的现场样本没有完全收口。",
        "detail": (
            f"问题节点 {', '.join(scene_log_problem_node_codes) or scene_log_node_code or '-'}；"
            f" 当前状态分布 {scene_log_status_counts}"
        ),
        "preferred_surface": "execution-scene",
        "next_action_code": "inspect_scene_log_reports",
        "recommended_commands": [
            *(
                [
                    f"bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log {mainland_api_base_url} {scene_log_node_code} 120 {scene_log_mode}"
                ]
                if scene_log_node_code
                else []
            ),
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {mainland_api_base_url}",
            doctor_command,
        ],
        "evidence": {
            "required_failures": required_failures,
            "required_failure_details": required_failure_details,
            "optional_unavailable": optional_unavailable,
            "optional_unavailable_details": optional_unavailable_details,
            "contract_surface_gaps": contract_surface_gaps,
            "surface_http_status": surface_http_status,
            "scene_log_status_counts": scene_log_status_counts,
        },
    }
else:
    codex_headline = str(codex_brief_summary.get("headline") or "").strip()
    driver_headline = str(driver_feed_summary.get("headline") or "").strip()
    decision["headline"] = stack_operator_title or codex_headline or driver_headline or decision["headline"]
    decision["detail"] = stack_operator_summary or stack_next_summary or "先看 driver-feed，再按 manifest 已准备好的 preview surface 继续收敛。"
    decision["preferred_surface"] = (
        stack_preferred_surface
        if stack_operator_primary_command_key or stack_operator_focus_kind
        else ("codex-brief" if str(codex_brief_summary.get("focus_entry_key") or "").strip() else "driver-feed")
    )
    decision["next_action_code"] = stack_operator_primary_command_key or stack_next_action_code or "preview_primary_focus"
    decision["recommended_commands"] = [
        *stack_primary_commands,
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {mainland_api_base_url}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh driver-focus-preview {mainland_api_base_url}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh codex-focus-preview {mainland_api_base_url}",
    ]

if isinstance(decision.get("evidence"), dict):
    decision["evidence"].update({
        "launchpad_recommended_target_node_code": launchpad_recommended_target_node_code,
        "launchpad_recommended_recovery_label": launchpad_recommended_recovery_label,
        "launchpad_recommended_recovery_summary": launchpad_recommended_recovery_summary,
        "launchpad_onboarding_bootstrap_pending_nodes": launchpad_onboarding_bootstrap_pending_nodes,
        "launchpad_onboarding_acceptance_ready_nodes": launchpad_onboarding_acceptance_ready_nodes,
    })

manifest = {
    "generated_at": datetime.now().isoformat(timespec="seconds"),
    "config_file": config_file,
    "active_profile": active_profile,
    "mainland_api_base_url": mainland_api_base_url,
    "overseas_api_base_url": overseas_api_base_url,
    "report_dir": str(report_dir),
    "reports_total": len(reports),
    "reports": reports,
    "summary": {
        "ok": len(required_failures) == 0,
        "required_failures": required_failures,
        "required_failure_details": required_failure_details,
        "optional_unavailable": optional_unavailable,
        "optional_unavailable_details": optional_unavailable_details,
        "scene_log_reports_total": scene_log_reports_total,
        "scene_log_reports_ok": scene_log_reports_ok,
        "scene_log_status_counts": scene_log_status_counts,
        "scene_log_reports": [
            {
                "name": str(report.get("name") or ""),
                "node_code": str((report.get("summary") or {}).get("node_code") or ""),
                "status": str((report.get("summary") or {}).get("status") or ""),
                "status_label": str((report.get("summary") or {}).get("status_label") or ""),
                "mode": str((report.get("summary") or {}).get("mode") or ""),
                "records_total": int((report.get("summary") or {}).get("records_total", 0) or 0),
                "ok": bool(report.get("ok")),
            }
            for report in scene_log_reports
        ],
        "available_preview_reports": sum(
            1 for report in reports if report.get("name") in optional_preview_files and report.get("ok")
        ),
        "discovered_contract_keys": sorted(all_contract_keys),
        "primary_contract_keys": primary_contract_keys,
        "preview_contract_keys": preview_contract_keys,
        "contract_surface_gaps": contract_surface_gaps,
        "surface_http_status": surface_http_status,
        "launchpad_recommended_target_node_code": launchpad_recommended_target_node_code,
        "launchpad_recommended_recovery_label": launchpad_recommended_recovery_label,
        "launchpad_recommended_recovery_summary": launchpad_recommended_recovery_summary,
        "launchpad_onboarding_bootstrap_pending_nodes": launchpad_onboarding_bootstrap_pending_nodes,
        "launchpad_onboarding_acceptance_ready_nodes": launchpad_onboarding_acceptance_ready_nodes,
    },
    "decision": decision,
}

print(json.dumps(manifest, ensure_ascii=False))
PY
)"

  cat >"${report_dir}/README.txt" <<EOF
domainCheck ops-center doctor export
generated_at=$(date '+%Y-%m-%d %H:%M:%S')
active_profile=${OPS_CENTER_ACTIVE_PROFILE}
mainland_api_base_url=${mainland_base_url}
overseas_api_base_url=${overseas_base_url}

files:
- meta.json
- manifest.json
$(for file_name in "${report_files[@]}"; do echo "- ${file_name}"; done)

notes:
- preview reports are exported in optional mode
- if a current focus does not exist, the report file still exists and ends with command_exit_code=1
- manifest.json is the machine-readable summary for overseas Codex / future UI automation
EOF

  python3 - <<'PY' "${report_dir}"
import json
import sys
from pathlib import Path

report_dir = Path(sys.argv[1])
manifest_path = report_dir / "manifest.json"
decision = {}
summary = {}
if manifest_path.exists():
    try:
        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    except Exception:
        manifest = {}
    decision = dict(manifest.get("decision") or {})
    summary = dict(manifest.get("summary") or {})

print(json.dumps({
    "ok": True,
    "report_dir": str(report_dir),
    "meta_path": str(report_dir / "meta.json"),
    "manifest_path": str(manifest_path),
    "readme_path": str(report_dir / "README.txt"),
    "summary": {
        "ok": bool(summary.get("ok", False)),
        "required_failures": list(summary.get("required_failures") or []),
        "optional_unavailable": list(summary.get("optional_unavailable") or []),
        "scene_log_reports_total": int(summary.get("scene_log_reports_total", 0) or 0),
        "scene_log_reports_ok": int(summary.get("scene_log_reports_ok", 0) or 0),
        "scene_log_status_counts": dict(summary.get("scene_log_status_counts") or {}),
        "scene_log_reports": list(summary.get("scene_log_reports") or []),
        "contract_surface_gaps": list(summary.get("contract_surface_gaps") or []),
        "launchpad_recommended_target_node_code": str(summary.get("launchpad_recommended_target_node_code") or ""),
        "launchpad_recommended_recovery_label": str(summary.get("launchpad_recommended_recovery_label") or ""),
        "launchpad_recommended_recovery_summary": str(summary.get("launchpad_recommended_recovery_summary") or ""),
        "launchpad_onboarding_bootstrap_pending_nodes": int(summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
        "launchpad_onboarding_acceptance_ready_nodes": int(summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    },
    "decision": {
        "status": str(decision.get("status") or ""),
        "reason_code": str(decision.get("reason_code") or ""),
        "headline": str(decision.get("headline") or ""),
        "detail": str(decision.get("detail") or ""),
        "preferred_surface": str(decision.get("preferred_surface") or ""),
        "next_action_code": str(decision.get("next_action_code") or ""),
        "recommended_commands": list(decision.get("recommended_commands") or []),
    },
}, ensure_ascii=False, indent=2))
PY
}

print_doctor_manifest_summary() {
  local manifest_target="$1"
  python3 - <<'PY' "${manifest_target}"
import json
import sys
from pathlib import Path

target = Path(str(sys.argv[1] or "").strip())
if target.is_dir():
    target = target / "manifest.json"

if not target.exists():
    raise SystemExit(f"manifest not found: {target}")

payload = json.loads(target.read_text(encoding="utf-8"))
print(json.dumps({
    "ok": bool(payload.get("summary", {}).get("ok", False)),
    "report_dir": str(payload.get("report_dir") or target.parent),
    "manifest_path": str(target),
    "summary": {
        "ok": bool(payload.get("summary", {}).get("ok", False)),
        "required_failures": list(payload.get("summary", {}).get("required_failures") or []),
        "required_failure_details": list(payload.get("summary", {}).get("required_failure_details") or []),
        "optional_unavailable": list(payload.get("summary", {}).get("optional_unavailable") or []),
        "optional_unavailable_details": list(payload.get("summary", {}).get("optional_unavailable_details") or []),
        "scene_log_reports_total": int(payload.get("summary", {}).get("scene_log_reports_total", 0) or 0),
        "scene_log_reports_ok": int(payload.get("summary", {}).get("scene_log_reports_ok") or 0),
        "scene_log_status_counts": dict(payload.get("summary", {}).get("scene_log_status_counts") or {}),
        "scene_log_reports": list(payload.get("summary", {}).get("scene_log_reports") or []),
        "contract_surface_gaps": list(payload.get("summary", {}).get("contract_surface_gaps") or []),
        "discovered_contract_keys": list(payload.get("summary", {}).get("discovered_contract_keys") or []),
        "launchpad_recommended_target_node_code": str(payload.get("summary", {}).get("launchpad_recommended_target_node_code") or ""),
        "launchpad_recommended_recovery_label": str(payload.get("summary", {}).get("launchpad_recommended_recovery_label") or ""),
        "launchpad_recommended_recovery_summary": str(payload.get("summary", {}).get("launchpad_recommended_recovery_summary") or ""),
        "launchpad_onboarding_bootstrap_pending_nodes": int(payload.get("summary", {}).get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
        "launchpad_onboarding_acceptance_ready_nodes": int(payload.get("summary", {}).get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
    },
    "decision": dict(payload.get("decision") or {}),
}, ensure_ascii=False, indent=2))
PY
}

run_doctor_decision() {
  local first_arg="${1:-}"
  local second_arg="${2:-}"
  local report_target=""

  if [[ -n "${first_arg}" && ( -f "${first_arg}" || -d "${first_arg}" ) ]]; then
    report_target="${first_arg}"
    print_doctor_manifest_summary "${report_target}"
    return 0
  fi

  local mainland_base_url="${first_arg:-$(ops_center_resolve_mainland_api_base_url)}"
  local overseas_base_url
  overseas_base_url="$(normalize_optional_base_url_arg "${second_arg}" "$(ops_center_resolve_overseas_api_base_url)")"
  local report_dir
  report_dir="$(mktemp -d /tmp/domaincheck-doctor-export-XXXXXX)"
  run_doctor_report_export "${report_dir}" "${mainland_base_url}" "${overseas_base_url}" >/dev/null
  print_doctor_manifest_summary "${report_dir}/manifest.json"
}

export_agent_plan() {
  local report_dir="$1"
  local mainland_base_url="$2"
  local node_code="$3"
  local node_region="$4"
  local node_role="$5"
  local control_plane_base_url="$6"
  local root_dir="$7"
  local timestamp
  timestamp="$(timestamp_now)"
  local safe_node_code
  safe_node_code="$(printf '%s' "${node_code}" | tr '/:' '__')"
  ops_center_ensure_report_dir "${report_dir}"
  local output_path="${report_dir}/agent-plan-${safe_node_code}-${timestamp}.txt"
  ISSUED_BY="$(ops_center_resolve_issued_by)" \
  EXPIRES_IN_HOURS="$(ops_center_resolve_expires_in_hours)" \
  bash "${SCRIPT_DIR}/build_node_agent_bootstrap_plan.sh" \
    "${mainland_base_url}" \
    "${node_code}" \
    "${node_region}" \
    "${node_role}" \
    "${control_plane_base_url}" \
    "${root_dir}" | tee "${output_path}"

  write_json_file "${output_path}.meta.json" "$(python3 - \
    "${node_code}" "${node_region}" "${node_role}" "${mainland_base_url}" "${control_plane_base_url}" "${root_dir}" "${output_path}" <<'PY'
import json
import sys
from datetime import datetime

print(json.dumps({
    "generated_at": datetime.now().isoformat(timespec="seconds"),
    "node_code": sys.argv[1],
    "node_region": sys.argv[2],
    "node_role": sys.argv[3],
    "mainland_api_base_url": sys.argv[4],
    "control_plane_base_url": sys.argv[5],
    "root_dir": sys.argv[6],
    "output_path": sys.argv[7],
}, ensure_ascii=False))
PY
)"

  python3 - <<'PY' "${output_path}" "${output_path}.meta.json"
import json
import sys

print(json.dumps({
    "ok": True,
    "output_path": sys.argv[1],
    "meta_path": sys.argv[2],
}, ensure_ascii=False, indent=2))
PY
}

run_publish_latest() {
  local mainland_base_url="$1"
  local mode="$2"
  local confirm_flag="$3"
  local skip_smoke_flag="$4"
  local repo_root
  repo_root="$(ops_center_repo_root)"
  local skip_smoke
  skip_smoke="$(confirm_to_bool "${skip_smoke_flag}")"

  if [[ "${mode}" != "worker" && "${mode}" != "control" ]]; then
    echo "mode must be worker or control" >&2
    usage
    exit 1
  fi

  echo "============================================================"
  echo "[publish/1] package latest"
  echo "============================================================"
  if [[ "${skip_smoke}" == "true" ]]; then
    DOMAINCHECK_SKIP_SMOKE_TEST=1 bash "${repo_root}/package_domain_release.sh"
  else
    bash "${repo_root}/package_domain_release.sh"
  fi
  echo

  echo "============================================================"
  echo "[publish/2] preview smart rollout from latest package"
  echo "============================================================"
  bash "${SCRIPT_DIR}/drive_release_hub.sh" "${mainland_base_url}" preview-latest-smart "${mode}"
  echo

  echo "============================================================"
  echo "[publish/3] smart rollout from latest package"
  echo "============================================================"
  bash "${SCRIPT_DIR}/drive_release_hub.sh" "${mainland_base_url}" smart-latest "${mode}" "${confirm_flag}"
}

show_ops_contracts() {
  local mainland_base_url="$1"
  local contract_key="${2:-}"
  local raw_http_response
  if [[ -n "${contract_key}" ]]; then
    raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/contracts/${contract_key}")"
  else
    raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/contracts")"
  fi
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}" "${contract_key}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
contract_key = str(sys.argv[3] or "").strip()
data = payload.get("data") or {}

if contract_key:
    contract = data.get("contract") or {}
    related_contracts = list(data.get("related_contracts") or [])
    print(json.dumps({
        "http_status": http_status,
        "requested_contract_key": contract_key,
        "registry_version": str(data.get("registry_version") or ""),
        "schema_version": str(data.get("schema_version") or ""),
        "docs_root": str(data.get("docs_root") or ""),
        "detail_endpoint": str(data.get("detail_endpoint") or ""),
        "contract": {
            "key": str(contract.get("key") or ""),
            "title": str(contract.get("title") or ""),
            "status": str(contract.get("status") or ""),
            "version": str(contract.get("version") or ""),
            "primary_endpoint": str(contract.get("primary_endpoint") or ""),
            "schema_doc_path": str(contract.get("schema_doc_path") or ""),
            "summary": str(contract.get("summary") or ""),
            "consumers": list(contract.get("consumers") or []),
            "service_keys": list(contract.get("service_keys") or []),
            "related_contract_keys": list(contract.get("related_contract_keys") or data.get("related_contract_keys") or []),
            "discovery_endpoints": list(contract.get("discovery_endpoints") or []),
        },
        "related_contracts": [
            {
                "key": str(item.get("key") or ""),
                "title": str(item.get("title") or ""),
                "version": str(item.get("version") or ""),
                "primary_endpoint": str(item.get("primary_endpoint") or ""),
            }
            for item in related_contracts
        ],
    }, ensure_ascii=False, indent=2))
else:
    contracts = list(data.get("contracts") or [])
    print(json.dumps({
        "http_status": http_status,
        "registry_version": str(data.get("registry_version") or ""),
        "schema_version": str(data.get("schema_version") or ""),
        "contracts_total": int(data.get("contracts_total", 0) or 0),
        "docs_root": str(data.get("docs_root") or ""),
        "discovery_entrypoints": list(data.get("discovery_entrypoints") or []),
        "contracts": [
            {
                "key": str(item.get("key") or ""),
                "version": str(item.get("version") or ""),
                "primary_endpoint": str(item.get("primary_endpoint") or ""),
                "schema_doc_path": str(item.get("schema_doc_path") or ""),
                "related_contract_keys": list(item.get("related_contract_keys") or []),
            }
            for item in contracts
        ],
    }, ensure_ascii=False, indent=2))
PY
}

show_activity_stream() {
  local mainland_base_url="$1"
  shift || true

  local request_url
  request_url="$(python3 - <<'PY' "${mainland_base_url}" "$@"
import sys
from urllib.parse import urlencode

base_url = str(sys.argv[1] or "").rstrip("/")
tokens = [str(item or "").strip() for item in sys.argv[2:] if str(item or "").strip()]
params = {}
allowed = {"limit", "kind", "status", "execution_mode", "query"}
for token in tokens:
    if "=" in token:
        key, value = token.split("=", 1)
        key = str(key or "").strip()
        value = str(value or "").strip()
        if key in allowed and value:
            params[key] = value
    elif "query" not in params:
        params["query"] = token

query_string = urlencode(params)
endpoint = f"{base_url}/api/v1/ops/activity-stream"
print(f"{endpoint}?{query_string}" if query_string else endpoint)
PY
)"

  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${request_url}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  printf '%s\n' "request_url=${request_url}"
  print_json_or_raw "${response_json}"
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}" "${request_url}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
request_url = str(sys.argv[3] or "").strip()
data = payload.get("data") or {}
summary = data.get("summary") or {}
items = list(data.get("items") or [])
contract_navigation = data.get("contract_navigation") or {}

print(json.dumps({
    "http_status": http_status,
    "request_url": request_url,
    "contract_navigation": {
        "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
        "contract_keys": list(contract_navigation.get("contract_keys") or []),
        "detail_endpoint_pattern": str(contract_navigation.get("detail_endpoint_pattern") or ""),
    },
    "summary": {
        "status": str(summary.get("status") or ""),
        "status_label": str(summary.get("status_label") or ""),
        "summary_text": str(summary.get("summary_text") or ""),
        "total": int(summary.get("total", 0) or 0),
        "filtered_total": int(summary.get("filtered_total", 0) or 0),
        "unfiltered_total": int(summary.get("unfiltered_total", 0) or 0),
        "latest_at": str(summary.get("latest_at") or ""),
        "filters": dict(summary.get("filters") or {}),
        "kind_counts": dict(summary.get("kind_counts") or {}),
        "status_counts": dict(summary.get("status_counts") or {}),
    },
    "items": [
        {
            "activity_key": str(item.get("activity_key") or ""),
            "kind": str(item.get("kind") or ""),
            "title": str(item.get("title") or ""),
            "status": str(item.get("status") or ""),
            "status_label": str(item.get("status_label") or ""),
            "execution_mode": str(item.get("execution_mode") or ""),
            "occurred_at": str(item.get("occurred_at") or ""),
            "primary_contract_key": str((item.get("contract_navigation") or {}).get("primary_contract_key") or ""),
            "contract_keys": list((item.get("contract_navigation") or {}).get("contract_keys") or []),
            "focus_ref": item.get("focus_ref") or {},
            "ui_intent": item.get("ui_intent") or {},
        }
        for item in items
    ],
}, ensure_ascii=False, indent=2))
PY
}

build_activity_preview_bundle() {
  local activity_response_json="$1"
  local activity_key="$2"
  local requested_by="$3"
  local source_label="$4"
  python3 - <<'PY' "${activity_response_json}" "${activity_key}" "${requested_by}" "${source_label}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
requested_activity_key = str(sys.argv[2] or "").strip()
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/activity-preview"
source_label = str(sys.argv[4] or "").strip() or "cli/activity-preview"
data = payload.get("data") or {}
items = [dict(item or {}) for item in list(data.get("items") or []) if dict(item or {})]

target_item = {}
if requested_activity_key:
    target_item = next((item for item in items if str(item.get("activity_key") or "").strip() == requested_activity_key), {})
if not target_item:
    target_item = next((item for item in items if str((item.get("ui_intent") or {}).get("kind") or "").strip()), {})
if not target_item:
    raise SystemExit("activity-stream 当前没有可预览的活动项")

ui_intent = dict(target_item.get("ui_intent") or {})
if not str(ui_intent.get("kind") or "").strip():
    raise SystemExit("目标活动项没有 ui_intent，当前不能生成 preview")

kind = str(target_item.get("kind") or "").strip()
if kind == "playbook_run":
    primary_label = "查看编排"
elif kind == "rollout":
    primary_label = "查看任务"
elif kind == "runbook_sequence":
    primary_label = "查看路径"
elif kind in {"execution_scene", "log_sync"}:
    primary_label = "查看现场"
elif str(ui_intent.get("kind") or "").strip() == "job_detail":
    primary_label = "看详情"
else:
    primary_label = "看事件"

focus_ref = dict(target_item.get("focus_ref") or {})
request_payload = {
    "source_label": source_label,
    "title": str(target_item.get("title") or "").strip() or str(target_item.get("activity_key") or "").strip() or "activity-preview",
    "summary": str(target_item.get("summary_text") or target_item.get("summary") or "").strip(),
    "reason": str(target_item.get("summary_text") or target_item.get("summary") or "").strip() or "建议先进入该活动项对应的工作区。",
    "meta_text": str(target_item.get("meta_text") or "").strip(),
    "executor_kind": "driver_action",
    "focus_ref": focus_ref,
    "primary_focus_ref": focus_ref,
    "primary_label": primary_label,
    "primary_action_code": "focus_activity_item",
    "primary_action_payload": {
        "activity_key": str(target_item.get("activity_key") or "").strip(),
        "kind": kind,
        "status": str(target_item.get("status") or "").strip(),
        "ui_intent": ui_intent,
        "focus_ref": focus_ref,
    },
    "include_secondary": False,
    "requested_by": requested_by,
}

print(json.dumps({
    "selected_entry": {
        "activity_key": str(target_item.get("activity_key") or "").strip(),
        "kind": kind,
        "title": str(target_item.get("title") or "").strip(),
        "status": str(target_item.get("status") or "").strip(),
        "status_label": str(target_item.get("status_label") or "").strip(),
        "summary": str(target_item.get("summary_text") or target_item.get("summary") or "").strip(),
        "focus_ref": focus_ref,
        "ui_intent": ui_intent,
        "contract_navigation": dict(target_item.get("contract_navigation") or {}),
    },
    "request": request_payload,
}, ensure_ascii=False))
PY
}

preview_activity_item() {
  local mainland_base_url="$1"
  local activity_key="$2"
  local requested_by="$3"

  local raw_activity_response
  raw_activity_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/activity-stream?limit=50")"
  local activity_http_status="${raw_activity_response##*$'\n'HTTP_STATUS=}"
  local activity_response_json="${raw_activity_response%$'\n'HTTP_STATUS=*}"

  if [[ "${activity_http_status}" -lt 200 || "${activity_http_status}" -ge 300 ]]; then
    echo "[1/3] activity stream raw response"
    printf '%s\n' "http_status=${activity_http_status}"
    print_json_or_raw "${activity_response_json}"
    exit 1
  fi

  local bundle_json
  bundle_json="$(build_activity_preview_bundle "${activity_response_json}" "${activity_key}" "${requested_by}" "cli/activity-preview")"
  local selected_entry_json
  selected_entry_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("selected_entry") or {}, ensure_ascii=False))
PY
)"
  local request_json
  request_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("request") or {}, ensure_ascii=False))
PY
)"

  echo "[1/4] selected activity"
  print_json_or_raw "${selected_entry_json}"
  echo
  echo

  echo "[2/4] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/resolve" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[3/4] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[4/4] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}" "${selected_entry_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
selected = json.loads(str(sys.argv[3] or "{}"))
data = payload.get("data") or {}
preview = data.get("preview") or {}
primary = preview.get("primary") or {}
gate = data.get("gate") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "selected_entry": selected,
    "contract": {
        "contract_key": str(preview.get("contract_key") or ""),
        "contract_version": str(preview.get("contract_version") or ""),
        "contract_primary_endpoint": str(preview.get("contract_primary_endpoint") or ""),
        "preview_endpoint": str(preview.get("preview_endpoint") or ""),
        "schema_doc_path": str(preview.get("contract_schema_doc_path") or ""),
    },
    "execution_chain": str(preview.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "gate": {
        "decision": str(gate.get("decision") or ""),
        "decision_label": str(gate.get("decision_label") or ""),
        "recommendation": str(gate.get("recommendation") or ""),
        "recommendation_label": str(gate.get("recommendation_label") or ""),
        "will_execute": bool(gate.get("will_execute", False)),
        "confirm_required": bool(gate.get("confirm_required", False)),
        "target_api": str(gate.get("target_api") or ""),
        "focus_ref": gate.get("focus_ref") or {},
    },
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
        "request_payload": primary.get("request_payload") or {},
    },
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

show_delivery_queue_status() {
  local mainland_base_url="$1"
  local node_code="$2"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/delivery-queue")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
summary = data.get("summary") or {}
node = data.get("node") or {}
records_capability = data.get("records_capability") or {}
print(json.dumps({
    "http_status": http_status,
    "node": {
        "node_code": str(node.get("node_code") or ""),
        "region": str(node.get("region") or ""),
        "role": str(node.get("role") or ""),
        "agent_state_label": str(node.get("agent_state_label") or ""),
        "remote_access_label": str(node.get("remote_access_label") or ""),
    },
    "summary": {
        "state": str(summary.get("state") or ""),
        "label": str(summary.get("label") or ""),
        "reason": str(summary.get("reason") or ""),
        "pending_count": int(summary.get("pending_count", 0) or 0),
        "dead_letter_count": int(summary.get("dead_letter_count", 0) or 0),
        "last_flush_at": str(summary.get("last_flush_at") or ""),
        "oldest_pending_at": str(summary.get("oldest_pending_at") or ""),
        "oldest_dead_letter_at": str(summary.get("oldest_dead_letter_at") or ""),
    },
    "records_capability": {
        "record_visibility": str(records_capability.get("record_visibility") or ""),
        "record_source": str(records_capability.get("record_source") or ""),
        "full_records_available": bool(records_capability.get("full_records_available", False)),
    },
    "recommended_commands": {
        "records": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue-records http://127.0.0.1:8100 {str(node.get('node_code') or '')}"
            if str(node.get("node_code") or "").strip()
            else ""
        ),
        "flush": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue-flush http://127.0.0.1:8100 {str(node.get('node_code') or '')}"
            if str(node.get("node_code") or "").strip()
            else ""
        ),
        "replay": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue-replay http://127.0.0.1:8100 {str(node.get('node_code') or '')}"
            if str(node.get("node_code") or "").strip()
            else ""
        ),
    },
    "head_records": data.get("head_records") or {},
}, ensure_ascii=False, indent=2))
PY
}

show_node_handover() {
  local mainland_base_url="$1"
  local node_code="$2"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/handover")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  local effective_http_status="${http_status}"
  local fallback_json=""

  if [[ "${http_status}" == "404" ]]; then
    local stack_http_response stack_http_status stack_response_json
    stack_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
    stack_http_status="${stack_http_response##*$'\n'HTTP_STATUS=}"
    stack_response_json="${stack_http_response%$'\n'HTTP_STATUS=*}"
    if [[ "${stack_http_status}" -ge 200 && "${stack_http_status}" -lt 300 ]]; then
      fallback_json="$(python3 - <<'PY' "${stack_response_json}" "${node_code}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
target_node_code = str(sys.argv[2] or "").strip()
backend_http_status = int(sys.argv[3] or 404)
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]

node = next(
    (item for item in problem_nodes if str(item.get("node_code") or "").strip() == target_node_code),
    {},
)
first_gap = dict(managed_nodes.get("first_handover_gap") or {})
if not node and str(first_gap.get("node_code") or "").strip() == target_node_code:
    node = dict(first_gap.get("node") or {})
    if not node:
        node = {"node_code": target_node_code}

agent_state = str(node.get("agent_state") or "").strip()
remote_access_state = str(node.get("remote_access_state") or "").strip()
summary = "当前节点存在接管缺口，建议先生成 bootstrap 方案并检查 Node Agent 接入。"
stage_code = "unknown"
stage_label = "待判断"
stage_summary = summary
next_step = {
    "code": "managed_node_handover",
    "label": "先看节点接管详情",
    "summary": "建议先确认节点为什么还没进入 remote-agent 就绪状态。",
}

if agent_state == "pending_bootstrap":
    stage_code = "pending_bootstrap"
    stage_label = "待执行接入"
    stage_summary = "已签发有效 Token，但目标节点尚未执行 bootstrap 片段。"
    next_step = {
        "code": "execute_bootstrap_plan",
        "label": "去目标机执行接入片段",
        "summary": "把 bootstrap env 和一键落地片段放到目标机执行，然后观察 register / heartbeat 是否建立。",
    }
elif agent_state == "runtime_only":
    stage_code = "runtime_only"
    stage_label = "仅运行态在线"
    stage_summary = "控制面能看到 runtime 心跳，但 Node Agent 尚未接管。"
    next_step = {
        "code": "issue_bootstrap_plan",
        "label": "生成接入方案",
        "summary": "下一步应生成 bootstrap env、脚本和一键落地命令，再在目标节点启动 domaincheck-node-agent。",
    }
elif agent_state == "stale":
    stage_code = "stale"
    stage_label = "心跳过期"
    stage_summary = "Node Agent 曾接入过，但心跳已过期，需先恢复服务或重新接入。"
    next_step = {
        "code": "recover_agent",
        "label": "优先恢复 Agent",
        "summary": "先检查 domaincheck-node-agent 服务、网络连通性和控制面地址，再决定是否重新签发接入方案。",
    }
elif remote_access_state == "agent_pending":
    stage_code = "agent_pending"
    stage_label = "待接入"
    stage_summary = "当前 remote-agent 仍未就绪，先补齐 bootstrap 接入链路。"

result = {
    "http_status": 200,
    "backend_http_status": backend_http_status,
    "fallback_used": True,
    "fallback_source": "stack_diagnosis",
    "compatibility_warning": "当前运行中的 API 尚未暴露 /api/v1/ops/nodes/{node_code}/handover，已降级为 stack-diagnosis 兼容视图。",
    "node_code": target_node_code,
    "summary": stage_summary,
    "stage": {
        "code": stage_code,
        "label": stage_label,
        "summary": stage_summary,
        "next_step": next_step,
    },
    "readiness": {
        "is_managed": True,
        "is_enabled": True,
        "has_ssh_access": False,
        "is_agent_online": agent_state in {"online", "online_busy"},
        "is_remote_access_ready": False,
    },
    "ssh_profile": {
        "host": "",
        "port": 22,
        "user": "",
        "label": "",
        "reason": "兼容视图未携带 SSH 资料，请到托管节点详情页补看。",
        "ssh_command_hint": "",
    },
    "cluster": {
        "status": "",
        "current_load": 0,
        "last_heartbeat_at": "",
    },
    "blocking_items": [stage_summary] if stage_code in {"pending_bootstrap", "runtime_only", "stale", "agent_pending"} else [],
    "attention_items": [
        "当前是兼容降级视图，如需完整 SSH / Token / delivery queue 详情，请升级控制面 API 到包含 handover 路由的版本。"
    ],
    "bootstrap_defaults": {
        "control_plane_base_url": "",
        "root_dir": "/opt/domaincheck",
        "node_region": "",
        "node_role": "",
    },
    "endpoints": {
        "detail": f"/api/v1/ops/nodes/{target_node_code}/handover",
        "bootstrap_plan": f"/api/v1/ops/nodes/{target_node_code}/handover/bootstrap-plan",
    },
}

print(json.dumps(result, ensure_ascii=False))
PY
)"
      if [[ -n "${fallback_json}" ]]; then
        effective_http_status="200"
      fi
    fi
  fi
  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  if [[ -n "${fallback_json}" ]]; then
    echo
    printf '%s\n' "fallback=stack_diagnosis"
    print_json_or_raw "${fallback_json}"
  fi
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${effective_http_status}" "${fallback_json}"
import json
import pathlib
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
fallback_json = str(sys.argv[3] or "").strip()
if fallback_json:
    data = json.loads(fallback_json)
else:
    data = payload.get("data") or {}
stage = data.get("stage") or {}
readiness = data.get("readiness") or {}
ssh_profile = data.get("ssh_profile") or {}
cluster = data.get("cluster") or {}
bootstrap_defaults = data.get("bootstrap_defaults") or {}
node_code = str(data.get("node_code") or "").strip()
next_step = stage.get("next_step") or {}
print(json.dumps({
    "http_status": http_status,
    "backend_http_status": int(data.get("backend_http_status", 0) or 0) if fallback_json else http_status,
    "fallback_used": bool(data.get("fallback_used", False)),
    "fallback_source": str(data.get("fallback_source") or ""),
    "compatibility_warning": str(data.get("compatibility_warning") or ""),
    "node_code": node_code,
    "summary": str(data.get("summary") or ""),
    "stage": {
        "code": str(stage.get("code") or ""),
        "label": str(stage.get("label") or ""),
        "summary": str(stage.get("summary") or ""),
        "next_step": next_step,
    },
    "readiness": {
        "is_managed": bool(readiness.get("is_managed", False)),
        "is_enabled": bool(readiness.get("is_enabled", False)),
        "has_ssh_access": bool(readiness.get("has_ssh_access", False)),
        "is_agent_online": bool(readiness.get("is_agent_online", False)),
        "is_remote_access_ready": bool(readiness.get("is_remote_access_ready", False)),
    },
    "ssh_profile": {
        "host": str(ssh_profile.get("host") or ""),
        "port": int(ssh_profile.get("port", 22) or 22),
        "user": str(ssh_profile.get("user") or ""),
        "label": str(ssh_profile.get("label") or ""),
        "reason": str(ssh_profile.get("reason") or ""),
        "ssh_command_hint": str(ssh_profile.get("ssh_command_hint") or ""),
    },
    "cluster": {
        "status": str(cluster.get("status") or ""),
        "current_load": int(cluster.get("current_load", 0) or 0),
        "last_heartbeat_at": str(cluster.get("last_heartbeat_at") or ""),
    },
    "blocking_items": list(data.get("blocking_items") or []),
    "attention_items": list(data.get("attention_items") or []),
    "bootstrap_defaults": {
        "control_plane_base_url": str(bootstrap_defaults.get("control_plane_base_url") or ""),
        "root_dir": str(bootstrap_defaults.get("root_dir") or ""),
        "node_region": str(bootstrap_defaults.get("node_region") or ""),
        "node_role": str(bootstrap_defaults.get("node_role") or ""),
    },
    "endpoints": data.get("endpoints") or {},
    "recommended_commands": {
        "bootstrap_plan": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-plan http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
        "delivery_queue": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
        "node_agent_check": "bash domain-api/deploy/multi-region/check_node_agent.sh",
        "ssh_hint": str(ssh_profile.get("ssh_command_hint") or ""),
    },
}, ensure_ascii=False, indent=2))
PY
}

show_ops_nodes() {
  local mainland_base_url="$1"
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
summary = data.get("summary") or {}
nodes = [dict(item or {}) for item in list(data.get("nodes") or []) if isinstance(item, dict)]

rows = []
for node in nodes:
    rows.append({
        "node_code": str(node.get("node_code") or "").strip(),
        "region": str(node.get("region") or "").strip(),
        "role": str(node.get("role") or "").strip(),
        "agent_state": str(node.get("agent_state") or "").strip(),
        "remote_access_state": str(node.get("remote_access_state") or "").strip(),
        "ssh_access_label": str(node.get("ssh_access_label") or "").strip(),
        "ssh_entry": (
            f"{str(node.get('ssh_user') or '').strip()}@{str(node.get('ssh_host') or '').strip()}:{int(node.get('ssh_port') or 22)}"
            if str(node.get("ssh_host") or "").strip() and str(node.get("ssh_user") or "").strip()
            else ""
        ),
        "participation_state": str(node.get("participation_state") or "").strip(),
        "cluster_status": str(node.get("cluster_status") or "").strip(),
        "current_load": int(node.get("cluster_current_load", 0) or 0),
    })

print(json.dumps({
    "http_status": http_status,
    "summary": {
        "total": int(summary.get("total", len(nodes)) or 0),
        "managed_enabled": int(summary.get("managed_enabled", 0) or 0),
        "agent_ready": int(summary.get("agent_ready", 0) or 0),
        "ssh_ready": int(summary.get("ssh_ready", 0) or 0),
        "remote_access_ready": int(summary.get("remote_access_ready", 0) or 0),
        "participating": int(summary.get("participating", 0) or 0),
        "queue_dead_letter_nodes": int(summary.get("queue_dead_letter_nodes", 0) or 0),
        "remote_access_state_counts": dict(summary.get("remote_access_state_counts") or {}),
    },
    "nodes": rows,
}, ensure_ascii=False, indent=2))
PY
}

bind_node_ssh_profile() {
  local mainland_base_url="$1"
  local node_code="$2"
  local ssh_host="$3"
  local ssh_user="$4"
  local ssh_port="${5:-22}"
  local title="${6:-}"
  if [[ -z "${node_code}" || -z "${ssh_host}" || -z "${ssh_user}" ]]; then
    echo "usage: node-bind-ssh [mainland_base_url] <node_code> <ssh_host> <ssh_user> [ssh_port] [title]" >&2
    exit 1
  fi

  local request_json
  request_json="$(python3 - <<'PY' "${node_code}" "${ssh_host}" "${ssh_user}" "${ssh_port}" "${title}"
import json
import sys

node_code = str(sys.argv[1] or "").strip()
ssh_host = str(sys.argv[2] or "").strip()
ssh_user = str(sys.argv[3] or "").strip()
ssh_port = int(sys.argv[4] or 22)
title = str(sys.argv[5] or "").strip()

payload = {
    "node_code": node_code,
    "ssh_host": ssh_host,
    "ssh_user": ssh_user,
    "ssh_port": ssh_port,
    "auth_mode": "key",
    "metadata": {
        "ssh_bound_via": "drive_ops_center.sh/node-bind-ssh",
    },
}
if title:
    payload["title"] = title

print(json.dumps(payload, ensure_ascii=False))
PY
)"

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[1/3] save managed node ssh profile"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo

  echo "[2/3] node handover after binding"
  show_node_handover "${mainland_base_url}" "${node_code}"
  echo

  echo "[3/3] condensed ssh binding"
  python3 - <<'PY' "${response_json}" "${http_status}" "${node_code}" "${ssh_host}" "${ssh_user}" "${ssh_port}" "${mainland_base_url}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
node_code = str(sys.argv[3] or "").strip()
ssh_host = str(sys.argv[4] or "").strip()
ssh_user = str(sys.argv[5] or "").strip()
ssh_port = int(sys.argv[6] or 22)
base_url = str(sys.argv[7] or "http://127.0.0.1:8100").strip() or "http://127.0.0.1:8100"
data = payload.get("data") or {}
node = dict(data.get("node") or {})

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "node_code": node_code,
    "ssh_entry": f"{ssh_user}@{ssh_host}:{ssh_port}",
    "saved_title": str(node.get("title") or "").strip(),
    "saved_region": str(node.get("region") or "").strip(),
    "saved_role": str(node.get("role") or "").strip(),
    "next_recommended_commands": {
        "nodes": f"bash domain-api/deploy/multi-region/drive_ops_center.sh nodes {base_url}",
        "handover": f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover {base_url} {node_code}",
        "bootstrap_plan": f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-plan {base_url} {node_code}",
    },
}, ensure_ascii=False, indent=2))
PY
}

show_node_scene_log() {
  local mainland_base_url="$1"
  local node_code="$2"
  local limit="${3:-80}"
  local mode="${4:-}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi

  local request_url
  request_url="$(python3 - <<'PY' "${mainland_base_url}" "${node_code}" "${limit}" "${mode}"
import sys
from urllib.parse import quote, urlencode

base_url = str(sys.argv[1] or "").rstrip("/")
node_code = str(sys.argv[2] or "").strip()
limit = max(1, min(int(sys.argv[3] or 80), 400))
mode = str(sys.argv[4] or "").strip().lower()
params = {"limit": limit}
if mode in {"key", "full"}:
    params["mode"] = mode
endpoint = f"{base_url}/api/v1/ops/nodes/{quote(node_code, safe='')}/scene-log"
query_string = urlencode(params)
print(f"{endpoint}?{query_string}" if query_string else endpoint)
PY
)"

  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${request_url}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  local effective_http_status="${http_status}"
  local fallback_json=""

  if [[ "${http_status}" == "404" ]]; then
    local runtime_http_response runtime_http_status runtime_response_json
    runtime_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/runtime/status")"
    runtime_http_status="${runtime_http_response##*$'\n'HTTP_STATUS=}"
    runtime_response_json="${runtime_http_response%$'\n'HTTP_STATUS=*}"
    if [[ "${runtime_http_status}" -ge 200 && "${runtime_http_status}" -lt 300 ]]; then
      fallback_json="$(python3 - <<'PY' "${runtime_response_json}" "${node_code}" "${limit}" "${mode}" "${http_status}"
import json
import re
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
node_code = str(sys.argv[2] or "").strip()
limit = max(1, min(int(sys.argv[3] or 80), 400))
requested_mode = str(sys.argv[4] or "").strip().lower()
backend_http_status = int(sys.argv[5] or 404)

data = dict(payload.get("data") or {})
detect = dict(data.get("detect") or {})
cluster = dict(data.get("cluster") or {})
log_sync = dict(detect.get("log_sync") or {})

mode = "full" if requested_mode == "full" else ("full" if str(log_sync.get("mode") or "").strip().lower() == "full" else "key")

cluster_nodes = [dict(item or {}) for item in list(cluster.get("nodes") or []) if isinstance(item, dict)]
cluster_map = {str(item.get("node_code") or "").strip(): item for item in cluster_nodes if str(item.get("node_code") or "").strip()}

participating_nodes = [dict(item or {}) for item in list(detect.get("participating_nodes") or []) if isinstance(item, dict)]
standby_nodes = [dict(item or {}) for item in list(detect.get("non_participating_nodes") or []) if isinstance(item, dict)]
participating_map = {str(item.get("node_code") or "").strip(): item for item in participating_nodes if str(item.get("node_code") or "").strip()}
standby_map = {str(item.get("node_code") or "").strip(): item for item in standby_nodes if str(item.get("node_code") or "").strip()}

preview_lines = [str(item or "").strip() for item in list(log_sync.get("preview_lines") or []) if str(item or "").strip()]
pattern = re.compile(r"^\[(?P<created_at>[^\]]+)\]\s+\[(?P<node_code>[^\]]+)\]\s+(?P<message>.+)$")
node_preview_lines = []
for line in preview_lines:
    match = pattern.match(line)
    if not match:
        continue
    if str(match.group("node_code") or "").strip() != node_code:
        continue
    node_preview_lines.append({
        "created_at": str(match.group("created_at") or "").strip(),
        "node_code": node_code,
        "message": str(match.group("message") or "").strip(),
        "line": line,
        "mode": "key",
    })
node_preview_lines = node_preview_lines[-limit:]

source_summary_map = {
    str(item.get("node_code") or "").strip(): dict(item or {})
    for item in list(log_sync.get("source_node_summaries") or [])
    if isinstance(item, dict) and str(item.get("node_code") or "").strip()
}
missing_summary_map = {
    str(item.get("node_code") or "").strip(): dict(item or {})
    for item in list(log_sync.get("missing_participating_node_summaries") or [])
    if isinstance(item, dict) and str(item.get("node_code") or "").strip()
}
covered_summary_map = {
    str(item.get("node_code") or "").strip(): dict(item or {})
    for item in list(log_sync.get("covered_participating_node_summaries") or [])
    if isinstance(item, dict) and str(item.get("node_code") or "").strip()
}

node_meta = dict(participating_map.get(node_code) or standby_map.get(node_code) or {})
cluster_meta = dict(cluster_map.get(node_code) or {})
source_summary = dict(source_summary_map.get(node_code) or covered_summary_map.get(node_code) or {})
missing_summary = dict(missing_summary_map.get(node_code) or {})

derived_line_count = len(node_preview_lines)
derived_last_at = str((node_preview_lines[-1] if node_preview_lines else {}).get("created_at") or "").strip()
derived_last_line = str((node_preview_lines[-1] if node_preview_lines else {}).get("line") or "").strip()

source_summary = {
    "node_code": node_code,
    "line_count": max(int(source_summary.get("line_count", 0) or 0), derived_line_count),
    "key_line_count": max(int(source_summary.get("key_line_count", 0) or 0), derived_line_count),
    "full_line_count": int(source_summary.get("full_line_count", 0) or 0),
    "last_at": derived_last_at or str(source_summary.get("last_at") or "").strip(),
    "last_line": derived_last_line or str(source_summary.get("last_line") or "").strip(),
}

log_sync_enabled = bool(log_sync.get("enabled", False))
detect_participating = node_code in participating_map
standby_visible = node_code in standby_map
record_available = bool(source_summary.get("line_count", 0) or node_preview_lines)

if record_available:
    if detect_participating:
        status = "full_capture" if mode == "full" else "healthy"
    else:
        status = "historical_sample"
elif missing_summary:
    missing_reason_code = str(missing_summary.get("missing_reason_code") or "").strip()
    if missing_reason_code == "disabled":
        status = "disabled"
    elif missing_reason_code == "waiting_sample":
        status = "waiting_sample"
    else:
        status = "missing_sample"
elif detect_participating:
    status = "waiting_sample" if log_sync_enabled else "disabled"
elif standby_visible:
    status = "standby"
else:
    status = "unknown"

status_labels = {
    "healthy": ("关键覆盖", "success"),
    "full_capture": ("全量观察", "success"),
    "historical_sample": ("历史样本", "success"),
    "waiting_sample": ("等待样本", "warning"),
    "missing_sample": ("缺少样本", "warning"),
    "disabled": ("已关闭", "info"),
    "standby": ("在线待命", "info"),
    "unknown": ("未发现", "info"),
}
status_label, status_type = status_labels.get(status, ("待确认", "info"))

if record_available and detect_participating:
    summary = f"节点当前正在参与检测，已通过兼容降级视图识别到 {int(source_summary.get('line_count', 0) or 0)} 条现场日志样本。"
elif record_available:
    summary = f"节点已通过兼容降级视图识别到 {int(source_summary.get('line_count', 0) or 0)} 条现场日志样本。"
elif missing_summary:
    summary = str(missing_summary.get("missing_reason") or "").strip() or "当前还没有收到该节点的现场日志样本。"
elif detect_participating and log_sync_enabled:
    summary = "节点正在参与检测，但当前现场日志样本仍未形成。"
elif detect_participating:
    summary = "节点正在参与检测，但远端日志回传当前关闭。"
elif standby_visible:
    summary = "节点当前在线但未参与本轮检测，暂时没有新的现场日志样本。"
else:
    summary = "当前没有找到该节点的现场日志记录。"

latest_record = dict(node_preview_lines[-1] or {}) if node_preview_lines else {}
missing_reason_code = str(missing_summary.get("missing_reason_code") or "").strip()
missing_reason = str(missing_summary.get("missing_reason") or "").strip()

result = {
    "http_status": 200,
    "backend_http_status": backend_http_status,
    "fallback_used": True,
    "fallback_source": "runtime_status",
    "fallback_reason": "running_api_missing_scene_log_route",
    "compatibility_warning": "当前运行中的 API 尚未暴露 /api/v1/ops/nodes/{node_code}/scene-log，已降级为 runtime/status 兼容视图。",
    "node_code": node_code,
    "status": status,
    "status_label": status_label,
    "status_type": status_type,
    "mode": mode,
    "mode_label": "全量回传" if mode == "full" else "关键回传",
    "summary": summary,
    "node": {
        "region": str(node_meta.get("region") or cluster_meta.get("region") or missing_summary.get("region") or "").strip(),
        "role": str(node_meta.get("role") or cluster_meta.get("role") or missing_summary.get("role") or "").strip(),
        "status": str(node_meta.get("status") or cluster_meta.get("status") or "").strip(),
        "current_load": int(node_meta.get("current_load", cluster_meta.get("current_load", 0)) or 0),
        "last_heartbeat_at": str(node_meta.get("last_heartbeat_at") or cluster_meta.get("last_heartbeat_at") or "").strip(),
    },
    "participation": {
        "detect_participating": detect_participating,
        "participation_label": str(node_meta.get("participation_label") or "").strip(),
        "participation_bucket": str(node_meta.get("participation_bucket") or "").strip(),
        "participation_reason": str(node_meta.get("participation_reason") or "").strip(),
    },
    "source_summary": {
        "line_count": int(source_summary.get("line_count", 0) or 0),
        "key_line_count": int(source_summary.get("key_line_count", 0) or 0),
        "full_line_count": int(source_summary.get("full_line_count", 0) or 0),
        "last_at": str(source_summary.get("last_at") or "").strip(),
        "last_line": str(source_summary.get("last_line") or "").strip(),
    },
    "missing_reason_code": missing_reason_code,
    "missing_reason": missing_reason,
    "records_total": int(source_summary.get("line_count", 0) or 0),
    "records_visible": len(node_preview_lines),
    "records_truncated": False,
    "latest_record": latest_record,
    "preview_lines": [str(item.get("line") or "").strip() for item in node_preview_lines[-8:]],
  }
print(json.dumps(result, ensure_ascii=False))
PY
)"
      if [[ -n "${fallback_json}" ]]; then
        effective_http_status="200"
      fi
    fi
  fi

  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  printf '%s\n' "request_url=${request_url}"
  print_json_or_raw "${response_json}"
  if [[ -n "${fallback_json}" ]]; then
    echo
    printf '%s\n' "fallback=runtime_status"
    print_json_or_raw "${fallback_json}"
  fi
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${effective_http_status}" "${fallback_json}"
import json
import pathlib
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
fallback_json = str(sys.argv[3] or "").strip()

if fallback_json:
    data = json.loads(fallback_json)
    node = data.get("node") or {}
    participation = data.get("participation") or {}
    source_summary = data.get("source_summary") or {}
    latest_record = data.get("latest_record") or {}
    preview_lines = list(data.get("preview_lines") or [])
else:
    data = payload.get("data") or {}
    node = data.get("node") or {}
    participation = data.get("participation") or {}
    source_summary = data.get("source_summary") or {}
    records = [dict(item or {}) for item in list(data.get("records") or []) if dict(item or {})]
    latest_record = data.get("latest_record") or {}
    preview_lines = [str(item.get("line") or "") for item in records[-8:]]

print(json.dumps({
    "http_status": http_status,
    "backend_http_status": int(data.get("backend_http_status", 0) or 0) if fallback_json else http_status,
    "fallback_used": bool(data.get("fallback_used", False)),
    "fallback_source": str(data.get("fallback_source") or ""),
    "compatibility_warning": str(data.get("compatibility_warning") or ""),
    "node_code": str(data.get("node_code") or ""),
    "status": str(data.get("status") or ""),
    "status_label": str(data.get("status_label") or ""),
    "mode": str(data.get("mode") or ""),
    "mode_label": str(data.get("mode_label") or ""),
    "summary": str(data.get("summary") or ""),
    "node": {
        "region": str(node.get("region") or ""),
        "role": str(node.get("role") or ""),
        "status": str(node.get("status") or ""),
        "current_load": int(node.get("current_load", 0) or 0),
        "last_heartbeat_at": str(node.get("last_heartbeat_at") or ""),
    },
    "participation": {
        "detect_participating": bool(participation.get("detect_participating", False)),
        "participation_label": str(participation.get("participation_label") or ""),
        "participation_bucket": str(participation.get("participation_bucket") or ""),
        "participation_reason": str(participation.get("participation_reason") or ""),
    },
    "source_summary": {
        "line_count": int(source_summary.get("line_count", 0) or 0),
        "key_line_count": int(source_summary.get("key_line_count", 0) or 0),
        "full_line_count": int(source_summary.get("full_line_count", 0) or 0),
        "last_at": str(source_summary.get("last_at") or ""),
        "last_line": str(source_summary.get("last_line") or ""),
    },
    "missing_reason_code": str(data.get("missing_reason_code") or ""),
    "missing_reason": str(data.get("missing_reason") or ""),
    "records_total": int(data.get("records_total", 0) or 0),
    "records_visible": int(data.get("records_visible", 0) or 0),
    "records_truncated": bool(data.get("records_truncated", False)),
    "latest_record": latest_record,
    "preview_lines": [str(item or "") for item in preview_lines],
}, ensure_ascii=False, indent=2))
PY
}

build_node_handover_bootstrap_plan() {
  local mainland_base_url="$1"
  local node_code="$2"
  local issued_by="$3"
  local expires_in_hours="$4"
  local control_plane_base_url="$5"
  local root_dir="$6"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${issued_by}" "${expires_in_hours}" "${control_plane_base_url}" "${root_dir}"
import json
import sys

issued_by = str(sys.argv[1] or "cli/ops-center/node-bootstrap-plan").strip() or "cli/ops-center/node-bootstrap-plan"
expires_in_hours = max(1, min(int(sys.argv[2] or 72), 24 * 30))
control_plane_base_url = str(sys.argv[3] or "").strip()
root_dir = str(sys.argv[4] or "/opt/domaincheck").strip() or "/opt/domaincheck"
print(json.dumps({
    "issued_by": issued_by,
    "expires_in_hours": expires_in_hours,
    "control_plane_base_url": control_plane_base_url,
    "root_dir": root_dir,
    "metadata": {
        "issued_from": "cli-node-handover-bootstrap-plan",
    },
}, ensure_ascii=False))
PY
)"
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/handover/bootstrap-plan" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  local effective_http_status="${http_status}"
  local fallback_json=""

  if [[ "${http_status}" == "404" ]]; then
    local generic_request_json generic_http_response generic_http_status generic_response_json
    generic_request_json="$(python3 - <<'PY' "${node_code}" "${issued_by}" "${expires_in_hours}" "${control_plane_base_url}" "${root_dir}"
import json
import sys

node_code = str(sys.argv[1] or "").strip()
issued_by = str(sys.argv[2] or "cli/ops-center/node-bootstrap-plan").strip() or "cli/ops-center/node-bootstrap-plan"
expires_in_hours = max(1, min(int(sys.argv[3] or 72), 24 * 30))
control_plane_base_url = str(sys.argv[4] or "").strip()
root_dir = str(sys.argv[5] or "/opt/domaincheck").strip() or "/opt/domaincheck"

normalized = node_code.lower()
node_region = "overseas" if normalized.startswith("overseas-") else "mainland"
node_role = "control" if ("controller" in normalized or "-control" in normalized) else "worker"

print(json.dumps({
    "node_code": node_code,
    "node_region": node_region,
    "node_role": node_role,
    "issued_by": issued_by,
    "expires_in_hours": expires_in_hours,
    "control_plane_base_url": control_plane_base_url,
    "root_dir": root_dir,
    "metadata": {
        "issued_from": "cli-node-handover-bootstrap-plan-fallback",
        "fallback_used": True,
    },
}, ensure_ascii=False))
PY
)"
    generic_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/agent/bootstrap-plan" "${generic_request_json}")"
    generic_http_status="${generic_http_response##*$'\n'HTTP_STATUS=}"
    generic_response_json="${generic_http_response%$'\n'HTTP_STATUS=*}"
    if [[ "${generic_http_status}" -ge 200 && "${generic_http_status}" -lt 300 ]]; then
      fallback_json="$(python3 - <<'PY' "${generic_response_json}" "${http_status}" "${node_code}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
backend_http_status = int(sys.argv[2] or 404)
node_code = str(sys.argv[3] or "").strip()
data = payload.get("data") or {}
bootstrap_plan = dict(data.get("bootstrap_plan") or {})

print(json.dumps({
    "http_status": 200,
    "backend_http_status": backend_http_status,
    "fallback_used": True,
    "fallback_source": "ops_agent_bootstrap_plan",
    "compatibility_warning": "当前运行中的 API 尚未暴露节点级 /handover/bootstrap-plan，已降级为通用 /ops/agent/bootstrap-plan。",
    "message": str(payload.get("message") or ""),
    "node_code": node_code,
    "token_preview": str(data.get("token_preview") or ""),
    "expires_at": str(data.get("expires_at") or ""),
    "control_plane_base_url": str(data.get("control_plane_base_url") or ""),
    "bootstrap_plan": bootstrap_plan,
    "handover_stage": {
        "code": "bootstrap_plan_issued",
        "label": "已生成接入方案",
        "summary": "当前已通过通用 bootstrap-plan 接口生成接入方案，可直接去目标节点执行。",
    },
}, ensure_ascii=False))
PY
)"
      effective_http_status="200"
    fi
  fi
  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  if [[ -n "${fallback_json}" ]]; then
    echo
    printf '%s\n' "fallback=ops_agent_bootstrap_plan"
    print_json_or_raw "${fallback_json}"
  fi
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${effective_http_status}" "${fallback_json}"
import json
import pathlib
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
fallback_json = str(sys.argv[3] or "").strip()
if fallback_json:
    data = json.loads(fallback_json)
    plan = data.get("bootstrap_plan") or {}
    stage = data.get("handover_stage") or {}
    node_code = str(data.get("node_code") or "").strip()
else:
    data = payload.get("data") or {}
    plan = data.get("bootstrap_plan") or {}
    handover = data.get("handover") or {}
    stage = handover.get("stage") or {}
    node_code = str(data.get("node_code") or handover.get("node_code") or "").strip()
workspace_root = pathlib.Path.cwd()
ops_agent_service_path = workspace_root / "domain-api" / "app" / "services" / "ops_agent_service.py"
bootstrap_script_path = workspace_root / "domain-api" / "deploy" / "multi-region" / "bootstrap_node_agent.sh"
ops_agent_service_text = ""
bootstrap_script_text = ""
try:
    ops_agent_service_text = ops_agent_service_path.read_text(encoding="utf-8", errors="replace")
except Exception:
    ops_agent_service_text = ""
try:
    bootstrap_script_text = bootstrap_script_path.read_text(encoding="utf-8", errors="replace")
except Exception:
    bootstrap_script_text = ""

repo_supports_install_command_block = (
    "install_command_block" in ops_agent_service_text
    and "_candidate_node_agent_install_paths" in ops_agent_service_text
)
repo_supports_multi_layout_bootstrap = "resolve_project_root" in bootstrap_script_text
install_command_block_present = bool(str(plan.get("install_command_block") or "").strip())
runtime_may_need_restart = bool(repo_supports_install_command_block and not install_command_block_present)
runtime_restart_hint = (
    "仓库代码已支持 install_command_block，但本次接口响应里仍未返回，当前运行中的控制面 API 可能还没重启到最新代码。"
    if runtime_may_need_restart
    else ""
)
print(json.dumps({
    "http_status": http_status,
    "backend_http_status": int(data.get("backend_http_status", 0) or 0) if fallback_json else http_status,
    "fallback_used": bool(data.get("fallback_used", False)),
    "fallback_source": str(data.get("fallback_source") or ""),
    "compatibility_warning": str(data.get("compatibility_warning") or ""),
    "runtime_restart_hint": runtime_restart_hint,
    "message": str(payload.get("message") or ""),
    "node_code": node_code,
    "token_preview": str(data.get("token_preview") or ""),
    "expires_at": str(data.get("expires_at") or ""),
    "control_plane_base_url": str(data.get("control_plane_base_url") or ""),
    "bootstrap_plan": {
        "env_file": str(plan.get("env_file") or ""),
        "service_name": str(plan.get("service_name") or ""),
        "bootstrap_script_name": str(plan.get("bootstrap_script_name") or ""),
        "bootstrap_script_path": str(plan.get("bootstrap_script_path") or ""),
        "install_command_block_present": install_command_block_present,
        "bootstrap_run_script_block_present": bool(str(plan.get("bootstrap_run_script_block") or "").strip()),
    },
    "repo_capability": {
        "supports_install_command_block": repo_supports_install_command_block,
        "supports_multi_layout_bootstrap": repo_supports_multi_layout_bootstrap,
        "runtime_may_need_restart": runtime_may_need_restart,
    },
    "handover_stage": {
        "code": str(stage.get("code") or ""),
        "label": str(stage.get("label") or ""),
        "summary": str(stage.get("summary") or ""),
    },
    "recommended_commands": {
        "node_handover": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
        "delivery_queue": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
        "restart_api_if_runtime_stale": (
            "bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover http://127.0.0.1:8100"
            if runtime_may_need_restart
            else ""
        ),
    },
}, ensure_ascii=False, indent=2))
PY
}

show_stack_first_gap_handover() {
  local mainland_base_url="$1"
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  local first_gap_node_code
  first_gap_node_code="$(python3 - <<'PY' "${response_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
first_gap = managed_nodes.get("first_handover_gap") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]
node_code = str(
    first_gap.get("node_code")
    or managed_nodes.get("first_handover_gap_node_code")
    or ((problem_nodes[0] or {}).get("node_code") if problem_nodes else "")
    or ""
).strip()
print(node_code)
PY
)"
  if [[ -z "${first_gap_node_code}" ]]; then
    python3 - <<'PY' "${http_status}" "${response_json}"
import json
import sys

http_status = int(sys.argv[1] or 0)
payload = json.loads(str(sys.argv[2] or "{}"))
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
print(json.dumps({
    "http_status": http_status,
    "message": "当前 stack diagnosis 没有首个 handover gap 节点。",
    "managed_nodes": {
        "managed_enabled": int(managed_nodes.get("managed_enabled", 0) or 0),
        "remote_access_ready": int(managed_nodes.get("remote_access_ready", 0) or 0),
        "problem_nodes": list(managed_nodes.get("problem_nodes") or [])[:5],
    },
}, ensure_ascii=False, indent=2))
PY
    return 0
  fi
  show_node_handover "${mainland_base_url}" "${first_gap_node_code}"
}

show_node_onboarding() {
  local mainland_base_url="$1"
  local node_code="$2"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  local effective_http_status="${http_status}"
  local fallback_json=""

  if [[ "${http_status}" == "404" ]]; then
    local handover_http_response handover_http_status handover_response_json
    handover_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/handover")"
    handover_http_status="${handover_http_response##*$'\n'HTTP_STATUS=}"
    handover_response_json="${handover_http_response%$'\n'HTTP_STATUS=*}"
    if [[ "${handover_http_status}" == "404" ]]; then
      local stack_http_response stack_http_status stack_response_json
      stack_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
      stack_http_status="${stack_http_response##*$'\n'HTTP_STATUS=}"
      stack_response_json="${stack_http_response%$'\n'HTTP_STATUS=*}"
      if [[ "${stack_http_status}" -ge 200 && "${stack_http_status}" -lt 300 ]]; then
        handover_response_json="$(python3 - <<'PY' "${stack_response_json}" "${node_code}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
target_node_code = str(sys.argv[2] or "").strip()
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]
first_gap = dict(managed_nodes.get("first_handover_gap") or {})

node = next((item for item in problem_nodes if str(item.get("node_code") or "").strip() == target_node_code), {})
if not node and str(first_gap.get("node_code") or "").strip() == target_node_code:
    node = dict(first_gap.get("node") or {})
if not node:
    node = {"node_code": target_node_code}

agent_state = str(node.get("agent_state") or "").strip()
remote_access_state = str(node.get("remote_access_state") or "").strip()
stage_code = "unknown"
stage_label = "待判断"
stage_summary = "当前节点存在接管缺口，建议先生成 bootstrap 方案并检查 Node Agent 接入。"
if agent_state == "pending_bootstrap":
    stage_code = "pending_bootstrap"
    stage_label = "待执行接入"
    stage_summary = "已签发有效 Token，但目标节点尚未执行 bootstrap 片段。"
elif agent_state == "runtime_only":
    stage_code = "runtime_only"
    stage_label = "仅运行态在线"
    stage_summary = "控制面能看到 runtime 心跳，但 Node Agent 尚未接管。"
elif agent_state == "stale":
    stage_code = "stale"
    stage_label = "心跳过期"
    stage_summary = "Node Agent 曾接入过，但心跳已过期，需先恢复服务或重新接入。"
elif remote_access_state == "agent_pending":
    stage_code = "agent_pending"
    stage_label = "待接入"
    stage_summary = "当前 remote-agent 仍未就绪，先补齐 bootstrap 接入链路。"

print(json.dumps({
    "data": {
        "node_code": target_node_code,
        "summary": stage_summary,
        "stage": {
            "code": stage_code,
            "label": stage_label,
            "summary": stage_summary,
        },
        "readiness": {
            "is_managed": True,
            "is_enabled": True,
            "has_ssh_access": False,
            "is_agent_online": agent_state in {"online", "online_busy"},
            "is_remote_access_ready": False,
        },
    }
}, ensure_ascii=False))
PY
)"
        handover_http_status="200"
      fi
    fi
    if [[ "${handover_http_status}" -ge 200 && "${handover_http_status}" -lt 300 ]]; then
      fallback_json="$(python3 - <<'PY' "${handover_response_json}" "${node_code}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
node_code = str(sys.argv[2] or "").strip()
backend_http_status = int(sys.argv[3] or 404)
data = payload.get("data") or {}
readiness = data.get("readiness") or {}
stage = data.get("stage") or {}
is_agent_online = bool(readiness.get("is_agent_online", False))
has_ssh_access = bool(readiness.get("has_ssh_access", False))
is_remote_access_ready = bool(readiness.get("is_remote_access_ready", False))

acceptance_execution_mode = ""
acceptance_status_code = "blocked"
acceptance_status_label = "暂不可验收"
acceptance_summary = "当前还没进入标准接管就绪状态，暂不建议直接跑 onboarding.acceptance。"
if is_agent_online:
    acceptance_execution_mode = "remote-agent"
    acceptance_status_code = "ready"
    acceptance_status_label = "可远端验收"
    acceptance_summary = "Node Agent 已在线，可以直接跑 onboarding.acceptance 做标准接管验收。"
elif has_ssh_access:
    acceptance_execution_mode = "ssh"
    acceptance_status_code = "ssh_only"
    acceptance_status_label = "可走 SSH 验收"
    acceptance_summary = "当前 Agent 还没在线，但 SSH 已备好，可先走 SSH 模式做接管验收。"

onboarding_stage_code = str(stage.get("code") or "").strip() or "unknown"
onboarding_stage_label = str(stage.get("label") or "").strip() or "待判断"
onboarding_summary = str(data.get("summary") or stage.get("summary") or "").strip()
if acceptance_status_code in {"ready", "ssh_only"} and onboarding_stage_code == "ready":
    onboarding_stage_code = "acceptance_ready"
    onboarding_stage_label = "待接管验收"
    onboarding_summary = acceptance_summary

actions = []
if onboarding_stage_code in {"pending_bootstrap", "runtime_only", "profile_incomplete", "ssh_ready", "token_issue", "stale"}:
    actions.append({
        "key": "bootstrap_plan",
        "label": "生成接入方案",
        "summary": "先生成并执行 Node Agent bootstrap 方案，再观察 register / heartbeat 是否建立。",
    })
if acceptance_status_code in {"ready", "ssh_only"}:
    actions.append({
        "key": "run_acceptance",
        "label": "执行接管验收",
        "summary": acceptance_summary,
    })

recovery_decision = {
    "action": "noop",
    "label": "当前无需额外恢复动作",
    "summary": onboarding_summary or "当前节点暂无需要执行的接管恢复动作。",
    "command_hint": "",
    "needs_confirmation": True,
    "window": "none",
    "stage_code": onboarding_stage_code,
    "acceptance_status_code": acceptance_status_code,
}
if onboarding_stage_code == "acceptance_ready" or is_agent_online:
    recovery_decision = {
        "action": "run_acceptance",
        "label": "执行接管验收",
        "summary": acceptance_summary,
        "command_hint": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-run http://127.0.0.1:8100 {node_code} cli"
            if node_code else ""
        ),
        "needs_confirmation": True,
        "window": "acceptance",
        "stage_code": onboarding_stage_code,
        "acceptance_status_code": acceptance_status_code,
    }
elif onboarding_stage_code in {"pending_bootstrap", "runtime_only", "profile_incomplete", "ssh_ready", "token_issue", "stale", "agent_pending", "unknown", ""}:
    recovery_decision = {
        "action": "bootstrap_run",
        "label": "签发接入工单",
        "summary": "当前节点仍处于接入阶段，建议先签发 onboarding.bootstrap 并等待 register / heartbeat 建立。",
        "command_hint": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-run http://127.0.0.1:8100 {node_code} cli"
            if node_code else ""
        ),
        "needs_confirmation": True,
        "window": "bootstrap",
        "stage_code": onboarding_stage_code,
        "acceptance_status_code": acceptance_status_code,
    }

print(json.dumps({
    "http_status": 200,
    "backend_http_status": backend_http_status,
    "fallback_used": True,
    "fallback_source": "node_handover",
    "compatibility_warning": "当前运行中的 API 尚未暴露 /api/v1/ops/nodes/{node_code}/onboarding，已降级为 handover 兼容视图。",
    "node_code": node_code,
    "summary": onboarding_summary,
    "onboarding_stage": {
        "code": onboarding_stage_code,
        "label": onboarding_stage_label,
        "summary": onboarding_summary,
    },
    "handover": data,
    "acceptance": {
        "status_code": acceptance_status_code,
        "status_label": acceptance_status_label,
        "summary": acceptance_summary,
        "execution_mode": acceptance_execution_mode,
        "is_agent_online": is_agent_online,
        "has_ssh_access": has_ssh_access,
        "is_remote_access_ready": is_remote_access_ready,
        "playbook": {
            "playbook_key": "onboarding.acceptance",
            "target_node_codes": [node_code] if node_code else [],
            "execution_mode": acceptance_execution_mode or "remote-agent",
            "auto_approve": True,
        },
    },
    "recommended_actions": actions,
    "recovery_decision": recovery_decision,
}, ensure_ascii=False))
PY
)"
      effective_http_status="200"
    fi
  fi

  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  if [[ -n "${fallback_json}" ]]; then
    echo
    printf '%s\n' "fallback=node_handover"
    print_json_or_raw "${fallback_json}"
  fi
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${effective_http_status}" "${fallback_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
fallback_json = str(sys.argv[3] or "").strip()
data = json.loads(fallback_json) if fallback_json else (payload.get("data") or {})
onboarding_stage = data.get("onboarding_stage") or {}
acceptance = data.get("acceptance") or {}
recovery_decision = data.get("recovery_decision") or {}
playbook = acceptance.get("playbook") or {}
node_code = str(data.get("node_code") or "").strip()
print(json.dumps({
    "http_status": http_status,
    "backend_http_status": int(data.get("backend_http_status", 0) or 0) if fallback_json else http_status,
    "fallback_used": bool(data.get("fallback_used", False)),
    "fallback_source": str(data.get("fallback_source") or ""),
    "compatibility_warning": str(data.get("compatibility_warning") or ""),
    "node_code": node_code,
    "summary": str(data.get("summary") or ""),
    "onboarding_stage": {
        "code": str(onboarding_stage.get("code") or ""),
        "label": str(onboarding_stage.get("label") or ""),
        "summary": str(onboarding_stage.get("summary") or ""),
    },
    "acceptance": {
        "status_code": str(acceptance.get("status_code") or ""),
        "status_label": str(acceptance.get("status_label") or ""),
        "summary": str(acceptance.get("summary") or ""),
        "execution_mode": str(acceptance.get("execution_mode") or ""),
        "is_agent_online": bool(acceptance.get("is_agent_online", False)),
        "has_ssh_access": bool(acceptance.get("has_ssh_access", False)),
        "is_remote_access_ready": bool(acceptance.get("is_remote_access_ready", False)),
        "playbook": playbook,
    },
    "recommended_actions": list(data.get("recommended_actions") or []),
    "recovery_decision": {
        "action": str(recovery_decision.get("action") or ""),
        "label": str(recovery_decision.get("label") or ""),
        "summary": str(recovery_decision.get("summary") or ""),
        "command_hint": str(recovery_decision.get("command_hint") or ""),
        "needs_confirmation": bool(recovery_decision.get("needs_confirmation", False)),
        "window": str(recovery_decision.get("window") or ""),
        "stage_code": str(recovery_decision.get("stage_code") or ""),
        "acceptance_status_code": str(recovery_decision.get("acceptance_status_code") or ""),
    },
    "recommended_commands": {
        "node_handover": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover http://127.0.0.1:8100 {node_code}"
            if node_code else ""
        ),
        "node_bootstrap_preview": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-preview http://127.0.0.1:8100 {node_code}"
            if node_code else ""
        ),
        "node_bootstrap_run": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-run http://127.0.0.1:8100 {node_code} cli"
            if node_code else ""
        ),
        "node_bootstrap_plan": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-plan http://127.0.0.1:8100 {node_code}"
            if node_code else ""
        ),
        "node_acceptance_plan": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-plan http://127.0.0.1:8100 {node_code}"
            if node_code else ""
        ),
        "node_acceptance_run": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-run http://127.0.0.1:8100 {node_code} cli"
            if node_code else ""
        ),
        "agent_gap_check": "bash domain-api/deploy/multi-region/drive_ops_center.sh agent-gap-check http://127.0.0.1:8100",
    },
}, ensure_ascii=False, indent=2))
PY
}

recover_node_onboarding() {
  local mainland_base_url="$1"
  local node_code="$2"
  local confirm_flag="${3:-}"
  local requested_by="${4:-cli}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi

  local recovery_endpoint
  if [[ "${confirm_flag}" == "confirm" ]]; then
    recovery_endpoint="${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/recovery/execute"
  else
    recovery_endpoint="${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/recovery/preview"
  fi
  local recovery_request_json
  recovery_request_json="$(python3 - <<'PY' "${requested_by}"
import json
import sys
print(json.dumps({"requested_by": str(sys.argv[1] or "cli").strip() or "cli"}, ensure_ascii=False))
PY
)"

  local raw_http_response
  local source_mode="recovery_endpoint"
  raw_http_response="$(request_with_status "POST" "${recovery_endpoint}" "${recovery_request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  if [[ "${http_status}" == "404" ]]; then
    source_mode="onboarding"
    raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding")"
    http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  fi

  if [[ "${http_status}" == "404" ]]; then
    source_mode="handover"
    raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/handover")"
    http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
    if [[ "${http_status}" == "404" ]]; then
      source_mode="stack_diagnosis"
      raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
      http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
      response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
      if [[ "${http_status}" -ge 200 && "${http_status}" -lt 300 ]]; then
        response_json="$(python3 - <<'PY' "${response_json}" "${node_code}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
target_node_code = str(sys.argv[2] or "").strip()
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]
node = next((item for item in problem_nodes if str(item.get("node_code") or "").strip() == target_node_code), {})
first_gap = dict(managed_nodes.get("first_handover_gap") or {})
if not node and str(first_gap.get("node_code") or "").strip() == target_node_code:
    node = dict(first_gap.get("node") or {})
agent_state = str(node.get("agent_state") or "").strip()
stage_code = "unknown"
stage_summary = "当前节点存在接管缺口，建议先生成 bootstrap 方案并检查 Node Agent 接入。"
if agent_state == "pending_bootstrap":
    stage_code = "pending_bootstrap"
    stage_summary = "已签发有效 Token，但目标节点尚未执行 bootstrap 片段。"
elif agent_state == "runtime_only":
    stage_code = "runtime_only"
    stage_summary = "控制面能看到 runtime 心跳，但 Node Agent 尚未接管。"
elif agent_state == "stale":
    stage_code = "stale"
    stage_summary = "Node Agent 曾接入过，但心跳已过期，需先恢复服务或重新接入。"
elif str(node.get("remote_access_state") or "").strip() == "agent_pending":
    stage_code = "agent_pending"
    stage_summary = "当前 remote-agent 仍未就绪，先补齐 bootstrap 接入链路。"

print(json.dumps({
    "data": {
        "node_code": target_node_code,
        "summary": stage_summary,
        "onboarding_stage": {
            "code": stage_code,
            "summary": stage_summary,
        },
        "acceptance": {
            "status_code": "blocked",
            "summary": "当前还没进入标准接管就绪状态，暂不建议直接跑 onboarding.acceptance。",
        },
    }
}, ensure_ascii=False))
PY
)"
        http_status="200"
      fi
    fi
  fi

  python3 - <<'PY' "${response_json}" "${node_code}" "${mainland_base_url}" "${confirm_flag}" "${requested_by}" "${http_status}" "${source_mode}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
node_code = str(sys.argv[2] or "").strip()
base_url = str(sys.argv[3] or "").strip()
confirm_flag = str(sys.argv[4] or "").strip()
requested_by = str(sys.argv[5] or "cli").strip() or "cli"
backend_http_status = int(sys.argv[6] or 0)
source_mode = str(sys.argv[7] or "").strip()

data = payload.get("data") or {}
if str(data.get("recovery_action") or "").strip():
    recovery_decision = (data.get("recovery_decision") or {})
    selected_preview = (data.get("selected_preview") or {})
    selected_run = (data.get("selected_run") or {})
    selected_payload = selected_run or selected_preview
    playbook_preview = (selected_payload.get("playbook_preview") or {})
    playbook_run = (selected_payload.get("playbook_run") or {})
    follow_up = (selected_payload.get("follow_up") or {})
    result = {
        "node_code": node_code,
        "source_mode": source_mode,
        "backend_http_status": backend_http_status,
        "stage_code": str((recovery_decision.get("stage_code") or "")).strip(),
        "acceptance_status_code": str((recovery_decision.get("acceptance_status_code") or "")).strip(),
        "recovery_action": str(data.get("recovery_action") or "").strip(),
        "selected_action": "node_acceptance_run" if str(data.get("recovery_action") or "").strip() == "run_acceptance" else "node_bootstrap_run",
        "summary": str((recovery_decision.get("summary") or payload.get("message") or "")).strip(),
        "command": str((recovery_decision.get("command_hint") or "")).strip(),
        "execution_mode": str((selected_payload.get("execution_mode") or "")).strip(),
        "playbook_preview_key": str(((playbook_preview.get("playbook") or {}).get("key") or "")).strip(),
        "playbook_run_code": str((playbook_run.get("run_code") or "")).strip(),
        "follow_up_next_stage_code": str((follow_up.get("next_stage_code") or "")).strip(),
        "follow_up_summary": str((follow_up.get("summary") or "")).strip(),
        "follow_up_commands": list(follow_up.get("recommended_commands") or []),
        "confirm_required": True,
        "confirmed": confirm_flag == "confirm",
        "handled_by_recovery_endpoint": source_mode == "recovery_endpoint",
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))
    raise SystemExit(0)

stage = data.get("onboarding_stage") or data.get("stage") or {}
acceptance = data.get("acceptance") or {}
recovery = data.get("recovery_decision") or {}
stage_code = str(stage.get("code") or "").strip()
acceptance_status_code = str(acceptance.get("status_code") or "").strip()
stage_summary = str(stage.get("summary") or data.get("summary") or "").strip()

if not stage_code:
    handover_stage = data.get("stage") or {}
    stage_code = str(handover_stage.get("code") or "").strip()
    stage_summary = str(handover_stage.get("summary") or stage_summary).strip()

action = "noop"
reason = stage_summary or "当前节点暂无可执行恢复动作。"
command = ""
recovery_action = str(recovery.get("action") or "").strip()
recovery_command_hint = str(recovery.get("command_hint") or "").strip()
recovery_summary = str(recovery.get("summary") or "").strip()
if recovery_action == "run_acceptance":
    action = "node_acceptance_run"
    reason = recovery_summary or "当前节点已进入验收窗口，建议直接跑 onboarding.acceptance。"
    command = recovery_command_hint or f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-run {base_url} {node_code} {requested_by}"
elif recovery_action == "bootstrap_run":
    action = "node_bootstrap_run"
    reason = recovery_summary or "当前节点仍处于接入阶段，建议先签发 onboarding.bootstrap。"
    command = recovery_command_hint or f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-run {base_url} {node_code} {requested_by}"
elif acceptance_status_code in {"ready", "ssh_only"} or stage_code == "acceptance_ready":
    action = "node_acceptance_run"
    reason = "当前节点已进入验收窗口，建议直接跑 onboarding.acceptance。"
    command = f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-acceptance-run {base_url} {node_code} {requested_by}"
elif stage_code in {"pending_bootstrap", "runtime_only", "profile_incomplete", "ssh_ready", "token_issue", "stale", "agent_pending", "unknown", ""}:
    action = "node_bootstrap_run"
    reason = "当前节点仍处于接入阶段，建议先签发 onboarding.bootstrap。"
    command = f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-run {base_url} {node_code} {requested_by}"

result = {
    "node_code": node_code,
    "source_mode": source_mode,
    "backend_http_status": backend_http_status,
    "stage_code": stage_code,
    "acceptance_status_code": acceptance_status_code,
    "recovery_action": recovery_action,
    "selected_action": action,
    "summary": reason,
    "command": command,
    "confirm_required": True,
    "confirmed": confirm_flag == "confirm",
}
print(json.dumps(result, ensure_ascii=False, indent=2))
PY

  if [[ "${confirm_flag}" != "confirm" ]]; then
    return 0
  fi

  if [[ "${source_mode}" == "recovery_endpoint" ]]; then
    return 0
  fi

  local selected_action
  selected_action="$(python3 - <<'PY' "${response_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
data = payload.get("data") or {}
stage = data.get("onboarding_stage") or data.get("stage") or {}
acceptance = data.get("acceptance") or {}
recovery = data.get("recovery_decision") or {}
stage_code = str(stage.get("code") or "").strip()
acceptance_status_code = str(acceptance.get("status_code") or "").strip()
recovery_action = str(recovery.get("action") or "").strip()
if recovery_action == "run_acceptance":
    print("node_acceptance_run")
elif recovery_action == "bootstrap_run":
    print("node_bootstrap_run")
elif acceptance_status_code in {"ready", "ssh_only"} or stage_code == "acceptance_ready":
    print("node_acceptance_run")
elif stage_code in {"pending_bootstrap", "runtime_only", "profile_incomplete", "ssh_ready", "token_issue", "stale", "agent_pending", "unknown", ""}:
    print("node_bootstrap_run")
else:
    print("")
PY
)"

  case "${selected_action}" in
    node_bootstrap_run)
      run_node_bootstrap "${mainland_base_url}" "${node_code}" "${requested_by}"
      ;;
    node_acceptance_run)
      run_node_acceptance "${mainland_base_url}" "${node_code}" "${requested_by}"
      ;;
    *)
      printf '%s\n' '{"message":"当前节点没有可自动执行的恢复动作。"}'
      ;;
  esac
}

show_node_acceptance_plan() {
  local mainland_base_url="$1"
  local node_code="$2"
  local requested_by="${3:-cli}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${requested_by}"
import json
import sys
print(json.dumps({"requested_by": str(sys.argv[1] or "cli").strip() or "cli"}, ensure_ascii=False))
PY
)"
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/acceptance/preview" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  if [[ "${http_status}" == "404" ]]; then
    request_json="$(python3 - <<'PY' "${node_code}" "${requested_by}"
import json
import sys
node_code = str(sys.argv[1] or "").strip()
requested_by = str(sys.argv[2] or "cli").strip() or "cli"
print(json.dumps({
    "playbook_key": "onboarding.acceptance",
    "node_codes": [node_code] if node_code else [],
    "execution_mode": "remote-agent",
    "auto_approve": True,
    "requested_by": requested_by,
}, ensure_ascii=False))
PY
)"
    raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/playbooks/preview" "${request_json}")"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  fi
  printf '%s\n' "${response_json}"
}

show_node_bootstrap_preview() {
  local mainland_base_url="$1"
  local node_code="$2"
  local requested_by="${3:-cli}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${requested_by}"
import json
import sys
print(json.dumps({"requested_by": str(sys.argv[1] or "cli").strip() or "cli"}, ensure_ascii=False))
PY
)"
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/bootstrap/preview" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  if [[ "${http_status}" == "404" ]]; then
    request_json="$(python3 - <<'PY' "${node_code}" "${requested_by}"
import json
import sys
node_code = str(sys.argv[1] or "").strip()
requested_by = str(sys.argv[2] or "cli").strip() or "cli"
print(json.dumps({
    "playbook_key": "onboarding.bootstrap",
    "node_codes": [node_code] if node_code else [],
    "execution_mode": "control-plane",
    "auto_approve": True,
    "requested_by": requested_by,
}, ensure_ascii=False))
PY
)"
    raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/playbooks/preview" "${request_json}")"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  fi
  printf '%s\n' "${response_json}"
}

run_node_bootstrap() {
  local mainland_base_url="$1"
  local node_code="$2"
  local requested_by="${3:-cli}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${requested_by}"
import json
import sys
print(json.dumps({"requested_by": str(sys.argv[1] or "cli").strip() or "cli"}, ensure_ascii=False))
PY
)"
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/bootstrap/execute" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  if [[ "${http_status}" == "404" ]]; then
    request_json="$(python3 - <<'PY' "${node_code}" "${requested_by}"
import json
import sys
node_code = str(sys.argv[1] or "").strip()
requested_by = str(sys.argv[2] or "cli").strip() or "cli"
print(json.dumps({
    "playbook_key": "onboarding.bootstrap",
    "node_codes": [node_code] if node_code else [],
    "execution_mode": "control-plane",
    "auto_approve": True,
    "requested_by": requested_by,
}, ensure_ascii=False))
PY
)"
    raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/playbooks/execute" "${request_json}")"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  fi
  printf '%s\n' "${response_json}"
  echo
  echo "[follow-up]"
  python3 - <<'PY' "${response_json}" "${node_code}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
node_code = str(sys.argv[2] or "").strip()
data = payload.get("data") or {}
follow_up = dict(data.get("follow_up") or {})
playbook_run = dict(data.get("playbook_run") or {})
follow_up_summary = str(follow_up.get("summary") or "").strip() or str(playbook_run.get("focus_summary") or "").strip()
print(json.dumps({
    "node_code": node_code,
    "playbook_run_code": str(playbook_run.get("run_code") or "").strip(),
    "follow_up_next_stage_code": str(follow_up.get("next_stage_code") or "").strip(),
    "follow_up_summary": follow_up_summary,
    "follow_up_commands": list(follow_up.get("recommended_commands") or []),
}, ensure_ascii=False, indent=2))
PY
}

run_node_acceptance() {
  local mainland_base_url="$1"
  local node_code="$2"
  local requested_by="${3:-cli}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${requested_by}"
import json
import sys
print(json.dumps({"requested_by": str(sys.argv[1] or "cli").strip() or "cli"}, ensure_ascii=False))
PY
)"
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}/onboarding/acceptance/execute" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  if [[ "${http_status}" == "404" ]]; then
    request_json="$(python3 - <<'PY' "${node_code}" "${requested_by}"
import json
import sys
node_code = str(sys.argv[1] or "").strip()
requested_by = str(sys.argv[2] or "cli").strip() or "cli"
print(json.dumps({
    "playbook_key": "onboarding.acceptance",
    "node_codes": [node_code] if node_code else [],
    "execution_mode": "remote-agent",
    "auto_approve": True,
    "requested_by": requested_by,
}, ensure_ascii=False))
PY
)"
    raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/playbooks/execute" "${request_json}")"
    response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  fi
  printf '%s\n' "${response_json}"
  echo
  echo "[follow-up]"
  python3 - <<'PY' "${response_json}" "${node_code}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
node_code = str(sys.argv[2] or "").strip()
data = payload.get("data") or {}
follow_up = dict(data.get("follow_up") or {})
playbook_run = dict(data.get("playbook_run") or {})
follow_up_summary = str(follow_up.get("summary") or "").strip() or str(playbook_run.get("focus_summary") or "").strip()
print(json.dumps({
    "node_code": node_code,
    "playbook_run_code": str(playbook_run.get("run_code") or "").strip(),
    "follow_up_next_stage_code": str(follow_up.get("next_stage_code") or "").strip(),
    "follow_up_summary": follow_up_summary,
    "follow_up_commands": list(follow_up.get("recommended_commands") or []),
}, ensure_ascii=False, indent=2))
PY
}

show_delivery_queue_records() {
  local mainland_base_url="$1"
  local node_code="$2"
  local state="${3:-}"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local url="${mainland_base_url}/api/v1/ops/nodes/${node_code}/delivery-queue/records"
  if [[ -n "${state}" ]]; then
    url="${url}?state=${state}"
  fi
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${url}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  echo "[1/2] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo "[2/2] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
summary = data.get("summary") or {}
records = list(data.get("records") or [])
node_code = str(data.get("node_code") or "").strip()
print(json.dumps({
    "http_status": http_status,
    "node_code": node_code,
    "summary": {
        "total": int(summary.get("total", 0) or 0),
        "available_total": int(summary.get("available_total", 0) or 0),
        "record_visibility": str(summary.get("record_visibility") or ""),
        "available_state_counts": dict(summary.get("available_state_counts") or {}),
    },
    "recommended_commands": {
        "queue_status": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
        "replay": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh delivery-queue-replay http://127.0.0.1:8100 {node_code}"
            if node_code
            else ""
        ),
    },
    "records": [
        {
            "record_id": str(item.get("record_id") or item.get("client_request_id") or item.get("record_key") or ""),
            "state": str(item.get("state") or ""),
            "request_kind": str(item.get("request_kind") or ""),
            "created_at": str(item.get("created_at") or ""),
            "dead_letter_at": str(item.get("dead_letter_at") or ""),
            "label": str(item.get("label") or ""),
            "record_source": str(item.get("record_source") or ""),
        }
        for item in records
    ],
}, ensure_ascii=False, indent=2))
PY
}

run_delivery_queue_action() {
  local mainland_base_url="$1"
  local node_code="$2"
  local action_path="$3"
  local body_json="$4"
  if [[ -z "${node_code}" ]]; then
    echo "node_code is required" >&2
    exit 1
  fi
  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/nodes/${node_code}${action_path}" "${body_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
}

preview_runbook_sequence() {
  local mainland_base_url="$1"
  local sequence_key="$2"
  local action_payload_json="$3"
  local requested_by="$4"

  if [[ "${action_payload_json}" == @* ]]; then
    local action_payload_path="${action_payload_json#@}"
    if [[ ! -f "${action_payload_path}" ]]; then
      echo "payload file not found: ${action_payload_path}" >&2
      exit 1
    fi
    action_payload_json="$(cat "${action_payload_path}")"
  fi

  local request_json
  request_json="$(python3 - <<'PY' "${sequence_key}" "${action_payload_json}" "${requested_by}"
import json
import sys

sequence_key = str(sys.argv[1] or "").strip()
payload_raw = str(sys.argv[2] or "").strip() or "{}"
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/runbook-preview"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

request_payload = {
    "source_label": "cli/runbook-preview",
    "title": sequence_key,
    "executor_kind": "runbook_sequence",
    "sequence_key": sequence_key,
    "requested_by": requested_by,
    "include_secondary": True,
    "primary_action_payload": action_payload,
    "secondary_action_payload": action_payload,
}
print(json.dumps(request_payload, ensure_ascii=False))
PY
)"

  echo "[1/3] runbook preview request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/preview" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[3/3] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
primary = data.get("primary") or {}
secondary = data.get("secondary") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "sequence_key": str(data.get("sequence_key") or ""),
    "execution_chain": str(data.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "primary_focus_ref": data.get("primary_focus_ref") or {},
    "secondary_focus_ref": data.get("secondary_focus_ref") or {},
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
        "request_payload": primary.get("request_payload") or {},
    },
    "secondary": (
        {
            "label": str(secondary.get("label") or ""),
            "action_code": str(secondary.get("action_code") or ""),
            "target_api": str(secondary.get("target_api") or ""),
            "recommendation_label": str(secondary.get("recommendation_label") or ""),
            "focus_ref": secondary.get("focus_ref") or {},
            "request_payload": secondary.get("request_payload") or {},
        }
        if secondary else {}
    ),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

build_codex_focus_bundle() {
  local codex_response_json="$1"
  local entry_key="$2"
  local requested_by="$3"
  local source_label="$4"
  python3 - <<'PY' "${codex_response_json}" "${entry_key}" "${requested_by}" "${source_label}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
requested_entry_key = str(sys.argv[2] or "").strip()
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/codex-focus-preview"
source_label = str(sys.argv[4] or "").strip() or "cli/codex-focus-preview"
data = payload.get("data") or {}
focus = data.get("focus") or {}
entries = [dict(item or {}) for item in list(data.get("entries") or []) if dict(item or {})]
activity_focus = [dict(item or {}) for item in list(data.get("activity_focus") or []) if dict(item or {})]

def build_activity_focus_entry(item):
    normalized = dict(item or {})
    focus_action_code = str(normalized.get("focus_action_code") or "").strip()
    if not str(normalized.get("key") or "").strip() or not focus_action_code:
        return {}

    focus_ref = dict(normalized.get("focus_ref") or {})
    target_node_codes = list(normalized.get("target_node_codes") or [])
    focus_action_payload = dict(normalized.get("focus_action_payload") or {})
    summary = str(normalized.get("summary") or "").strip()
    reason = summary or "该焦点属于运行态观察项，建议进入对应工作区查看上下文。"
    return {
        "key": str(normalized.get("key") or "").strip(),
        "title": str(normalized.get("title") or "").strip(),
        "summary": summary,
        "reason": reason,
        "meta_text": str(normalized.get("meta_text") or "").strip(),
        "executor_kind": "driver_action",
        "primary_action_code": focus_action_code,
        "secondary_action_code": "",
        "focus_ref": focus_ref,
        "primary_focus_ref": focus_ref,
        "secondary_focus_ref": {},
        "primary_label": "进入工作区",
        "secondary_label": "",
        "primary_execution": {
            "label": "进入工作区",
            "node_codes": target_node_codes,
            "action_payload": focus_action_payload,
        },
        "secondary_execution": {},
        "autopilot": {
            "recommendation": "open_ui",
            "automation_level": "ui_only",
            "status_text": str(normalized.get("status_label") or normalized.get("status") or "").strip(),
            "executor_mode_hint": "ui-intent",
            "target_api": "/api/v1/ops/driver-actions/execute",
            "target_method": "POST",
            "reason": reason,
            "confirm_required": False,
            "ui_only": True,
            "blocked": False,
        },
        "observation_only": True,
        "activity_key": str(normalized.get("activity_key") or "").strip(),
        "activity_kind": str(normalized.get("activity_kind") or "").strip(),
        "ui_intent_kind": str(normalized.get("ui_intent_kind") or "").strip(),
        "contract_navigation": dict(normalized.get("contract_navigation") or {}),
    }

activity_focus_entries = [entry for entry in (build_activity_focus_entry(item) for item in activity_focus) if entry]

target_entry_key = requested_entry_key or str(focus.get("entry_key") or "").strip()
target_entry = {}
if target_entry_key:
    target_entry = next((item for item in entries if str(item.get("key") or "").strip() == target_entry_key), {})
if not target_entry and target_entry_key:
    target_entry = next((item for item in activity_focus_entries if str(item.get("key") or "").strip() == target_entry_key), {})
if not target_entry and entries:
    target_entry = dict(entries[0] or {})
    target_entry_key = str(target_entry.get("key") or "").strip()
if not target_entry and activity_focus_entries:
    target_entry = dict(activity_focus_entries[0] or {})
    target_entry_key = str(target_entry.get("key") or "").strip()

if not target_entry:
    raise SystemExit("codex brief 当前没有可预览的 entry")

autopilot = dict(target_entry.get("autopilot") or {})
primary_execution = dict(target_entry.get("primary_execution") or {})
secondary_execution = dict(target_entry.get("secondary_execution") or {})
request_payload = {
    "source_label": source_label,
    "title": str(target_entry.get("title") or "").strip() or target_entry_key or "codex-focus",
    "summary": str(target_entry.get("summary") or "").strip(),
    "reason": str(target_entry.get("reason") or "").strip(),
    "meta_text": str(target_entry.get("meta_text") or "").strip(),
    "executor_kind": str(target_entry.get("executor_kind") or "driver_action").strip() or "driver_action",
    "sequence_key": str(target_entry.get("sequence_key") or "").strip(),
    "focus_ref": dict(target_entry.get("focus_ref") or {}),
    "primary_focus_ref": dict(target_entry.get("primary_focus_ref") or {}),
    "secondary_focus_ref": dict(target_entry.get("secondary_focus_ref") or {}),
    "primary_label": str(primary_execution.get("label") or target_entry.get("primary_label") or "").strip(),
    "secondary_label": str(secondary_execution.get("label") or target_entry.get("secondary_label") or "").strip(),
    "primary_action_code": str(target_entry.get("primary_action_code") or "").strip(),
    "secondary_action_code": str(target_entry.get("secondary_action_code") or "").strip(),
    "primary_node_codes": list(primary_execution.get("node_codes") or target_entry.get("node_codes") or []),
    "secondary_node_codes": list(secondary_execution.get("node_codes") or target_entry.get("node_codes") or []),
    "primary_action_payload": dict(primary_execution.get("action_payload") or {}),
    "secondary_action_payload": dict(secondary_execution.get("action_payload") or {}),
    "include_secondary": True,
    "requested_by": requested_by,
}

print(json.dumps({
    "selected_entry": {
        "key": target_entry_key,
        "title": str(target_entry.get("title") or "").strip(),
        "executor_kind": str(target_entry.get("executor_kind") or "").strip(),
        "recommendation": str(autopilot.get("recommendation") or "").strip(),
        "automation_level": str(autopilot.get("automation_level") or "").strip(),
        "status_text": str(autopilot.get("status_text") or "").strip(),
        "executor_mode_hint": str(autopilot.get("executor_mode_hint") or "").strip(),
        "target_api": str(autopilot.get("target_api") or "").strip(),
        "target_method": str(autopilot.get("target_method") or "").strip(),
        "reason": str(autopilot.get("reason") or "").strip(),
        "confirm_required": bool(autopilot.get("confirm_required", False)),
        "ui_only": bool(autopilot.get("ui_only", False)),
        "blocked": bool(autopilot.get("blocked", False)),
        "primary_action_code": str(target_entry.get("primary_action_code") or "").strip(),
        "sequence_key": str(target_entry.get("sequence_key") or "").strip(),
        "focus_ref": dict(target_entry.get("focus_ref") or {}),
        "primary_focus_ref": dict(target_entry.get("primary_focus_ref") or {}),
        "secondary_focus_ref": dict(target_entry.get("secondary_focus_ref") or {}),
        "observation_only": bool(target_entry.get("observation_only", False)),
        "activity_key": str(target_entry.get("activity_key") or ""),
        "activity_kind": str(target_entry.get("activity_kind") or ""),
        "ui_intent_kind": str(target_entry.get("ui_intent_kind") or ""),
        "contract_navigation": dict(target_entry.get("contract_navigation") or {}),
    },
    "preview_request": request_payload,
}, ensure_ascii=False))
PY
}

preview_codex_focus_entry() {
  local mainland_base_url="$1"
  local entry_key="$2"
  local requested_by="$3"
  local request_json
  request_json="$(python3 - <<'PY' "${entry_key}" "${requested_by}"
import json
import sys
print(json.dumps({
    "entry_key": str(sys.argv[1] or "").strip(),
    "requested_by": str(sys.argv[2] or "").strip() or "cli/ops-center/codex-focus-preview",
    "source_label": "cli/codex-focus-preview",
    "include_secondary": True,
}, ensure_ascii=False))
PY
)"

  echo "[1/3] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/codex-actions/resolve" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[3/3] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
selected = data.get("selected_entry") or {}
preview = data.get("preview") or {}
primary = preview.get("primary") or {}
secondary = preview.get("secondary") or {}
gate = data.get("gate") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "entry_key": str(data.get("entry_key") or ""),
    "title": str(selected.get("title") or ""),
    "executor_kind": str(preview.get("executor_kind") or selected.get("executor_kind") or ""),
    "contract": {
        "contract_key": str(preview.get("contract_key") or ""),
        "contract_version": str(preview.get("contract_version") or ""),
        "contract_primary_endpoint": str(preview.get("contract_primary_endpoint") or ""),
        "preview_endpoint": str(preview.get("preview_endpoint") or ""),
        "schema_doc_path": str(preview.get("contract_schema_doc_path") or ""),
    },
    "execution_chain": str(preview.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "gate": {
        "decision": str(gate.get("decision") or ""),
        "decision_label": str(gate.get("decision_label") or ""),
        "recommendation": str(gate.get("recommendation") or ""),
        "recommendation_label": str(gate.get("recommendation_label") or ""),
        "will_execute": bool(gate.get("will_execute", False)),
        "confirm_required": bool(gate.get("confirm_required", False)),
        "target_api": str(gate.get("target_api") or ""),
        "focus_ref": gate.get("focus_ref") or {},
    },
    "selected_entry": {
        "key": str(selected.get("key") or ""),
        "contract_navigation": selected.get("contract_navigation") or {},
        "focus_ref": selected.get("focus_ref") or {},
        "primary_focus_ref": selected.get("primary_focus_ref") or {},
        "secondary_focus_ref": selected.get("secondary_focus_ref") or {},
    },
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
    },
    "secondary": (
        {
            "label": str(secondary.get("label") or ""),
            "action_code": str(secondary.get("action_code") or ""),
            "target_api": str(secondary.get("target_api") or ""),
            "recommendation_label": str(secondary.get("recommendation_label") or ""),
            "focus_ref": secondary.get("focus_ref") or {},
        }
        if secondary else {}
    ),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

run_codex_focus_entry() {
  local mainland_base_url="$1"
  local entry_key="$2"
  local confirm_flag="$3"
  local requested_by="$4"
  local confirm_risky
  confirm_risky="$(confirm_to_bool "${confirm_flag}")"

  local request_json
  request_json="$(python3 - <<'PY' "${entry_key}" "${requested_by}" "${confirm_risky}"
import json
import sys
print(json.dumps({
    "entry_key": str(sys.argv[1] or "").strip(),
    "requested_by": str(sys.argv[2] or "").strip() or "cli/ops-center/codex-focus-run",
    "source_label": "cli/codex-focus-run",
    "include_secondary": True,
    "confirm": str(sys.argv[3] or "").strip().lower() == "true",
}, ensure_ascii=False))
PY
)"

  echo "[1/3] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local execute_http_response
  execute_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/codex-actions/execute" "${request_json}")"
  local execute_http_status="${execute_http_response##*$'\n'HTTP_STATUS=}"
  local execute_response_json="${execute_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${execute_http_status}"
  print_json_or_raw "${execute_response_json}"
  echo
  echo

  echo "[3/3] execution result"
  python3 - <<'PY' "${execute_response_json}" "${execute_http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
gate = data.get("gate") or {}
execution_result = data.get("execution_result") or {}
print(json.dumps({
    "http_status": http_status,
    "entry_key": str(data.get("entry_key") or ""),
    "code": int((0 if payload.get("code", 1) in (0, "0", False) else payload.get("code", 1)) or 0),
    "message": str(payload.get("message") or ""),
    "executed": bool(data.get("executed", False)),
    "focus_ref": data.get("focus_ref") or {},
    "decision": str(gate.get("decision") or ""),
    "decision_label": str(gate.get("decision_label") or ""),
    "recommendation": str(gate.get("recommendation") or ""),
    "target_api": str(gate.get("target_api") or ""),
    "target_method": str(gate.get("target_method") or ""),
    "gate_focus_ref": gate.get("focus_ref") or {},
    "handled": bool(execution_result.get("handled", False)),
    "mode": str(execution_result.get("mode") or ""),
    "action_code": str(gate.get("action_code") or execution_result.get("action_code") or execution_result.get("driver_action_code") or ""),
    "sequence_key": str(gate.get("sequence_key") or execution_result.get("sequence_key") or ""),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${execute_http_status}" -lt 200 || "${execute_http_status}" -ge 300 ]]; then
    exit 1
  fi
}

build_driver_focus_bundle() {
  local driver_feed_response_json="$1"
  local entry_key="$2"
  local requested_by="$3"
  local source_label="$4"
  local secondary_flag="$5"
  local confirm_flag="$6"
  python3 - <<'PY' "${driver_feed_response_json}" "${entry_key}" "${requested_by}" "${source_label}" "${secondary_flag}" "${confirm_flag}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
requested_entry_key = str(sys.argv[2] or "").strip()
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/driver-focus-preview"
source_label = str(sys.argv[4] or "").strip() or "cli/driver-focus-preview"
secondary_flag = str(sys.argv[5] or "primary").strip().lower()
confirm_flag = str(sys.argv[6] or "").strip().lower()
data = payload.get("data") or {}
top_recommendation = dict(data.get("top_recommendation") or {})
entries = [dict(item or {}) for item in list(data.get("entries") or []) if dict(item or {})]
activity_focus = [dict(item or {}) for item in list(data.get("activity_focus") or []) if dict(item or {})]

secondary = secondary_flag in {"secondary", "second", "2", "true", "yes", "y"}
confirm = confirm_flag in {"1", "true", "yes", "y", "confirm", "confirmed"}

def build_activity_focus_entry(item):
    normalized = dict(item or {})
    focus_action_code = str(normalized.get("focus_action_code") or "").strip()
    if not str(normalized.get("key") or "").strip() or not focus_action_code:
        return {}

    focus_ref = dict(normalized.get("focus_ref") or {})
    target_node_codes = list(normalized.get("target_node_codes") or [])
    focus_action_payload = dict(normalized.get("focus_action_payload") or {})
    summary = str(normalized.get("summary") or "").strip()
    reason = summary or "该焦点属于运行态观察项，建议进入对应工作区查看上下文。"
    return {
        "key": str(normalized.get("key") or "").strip(),
        "kind": "activity_focus",
        "lane": "activity_focus",
        "title": str(normalized.get("title") or "").strip(),
        "summary": summary,
        "reason": reason,
        "meta_text": str(normalized.get("meta_text") or "").strip(),
        "status": str(normalized.get("status") or "").strip(),
        "executor_kind": "driver_action",
        "sequence_key": "",
        "primary_label": "进入工作区",
        "secondary_label": "",
        "primary_action_code": focus_action_code,
        "secondary_action_code": "",
        "node_codes": target_node_codes,
        "primary_node_codes": target_node_codes,
        "secondary_node_codes": [],
        "focus_ref": focus_ref,
        "primary_focus_ref": focus_ref,
        "secondary_focus_ref": {},
        "primary_action_payload": focus_action_payload,
        "secondary_action_payload": {},
        "observation_only": True,
        "activity_key": str(normalized.get("activity_key") or "").strip(),
        "activity_kind": str(normalized.get("activity_kind") or "").strip(),
        "ui_intent_kind": str(normalized.get("ui_intent_kind") or "").strip(),
        "contract_navigation": dict(normalized.get("contract_navigation") or {}),
    }

activity_focus_entries = [entry for entry in (build_activity_focus_entry(item) for item in activity_focus) if entry]

target_entry = {}
target_entry_key = requested_entry_key
if requested_entry_key:
    target_entry = next((item for item in entries if str(item.get("key") or "").strip() == requested_entry_key), {})
if not target_entry and requested_entry_key:
    target_entry = next((item for item in activity_focus_entries if str(item.get("key") or "").strip() == requested_entry_key), {})
if not target_entry and requested_entry_key and str(top_recommendation.get("key") or "").strip() == requested_entry_key:
    target_entry = dict(top_recommendation or {})
if not target_entry:
    target_entry = dict(top_recommendation or {})
    target_entry_key = str(target_entry.get("key") or "").strip()
if not target_entry and entries:
    target_entry = dict(entries[0] or {})
    target_entry_key = str(target_entry.get("key") or "").strip()
if not target_entry and activity_focus_entries:
    target_entry = dict(activity_focus_entries[0] or {})
    target_entry_key = str(target_entry.get("key") or "").strip()

if not target_entry:
    raise SystemExit("driver feed 当前没有可执行的焦点动作")

request_payload = {
    "source_label": source_label,
    "title": str(target_entry.get("title") or "").strip() or target_entry_key or "driver-focus",
    "summary": str(target_entry.get("summary") or "").strip(),
    "reason": str(target_entry.get("reason") or "").strip(),
    "meta_text": str(target_entry.get("meta_text") or "").strip(),
    "executor_kind": str(target_entry.get("executor_kind") or "driver_action").strip() or "driver_action",
    "sequence_key": str(target_entry.get("sequence_key") or "").strip(),
    "focus_ref": dict(target_entry.get("focus_ref") or {}),
    "primary_focus_ref": dict(target_entry.get("primary_focus_ref") or {}),
    "secondary_focus_ref": dict(target_entry.get("secondary_focus_ref") or {}),
    "primary_label": str(target_entry.get("primary_label") or "").strip(),
    "secondary_label": str(target_entry.get("secondary_label") or "").strip(),
    "primary_action_code": str(target_entry.get("primary_action_code") or "").strip(),
    "secondary_action_code": str(target_entry.get("secondary_action_code") or "").strip(),
    "primary_node_codes": list(target_entry.get("primary_node_codes") or target_entry.get("node_codes") or []),
    "secondary_node_codes": list(target_entry.get("secondary_node_codes") or target_entry.get("node_codes") or []),
    "primary_action_payload": dict(target_entry.get("primary_action_payload") or {}),
    "secondary_action_payload": dict(target_entry.get("secondary_action_payload") or {}),
    "include_secondary": True,
    "requested_by": requested_by,
    "secondary": secondary,
    "confirm": confirm,
}

print(json.dumps({
    "selected_entry": {
        "key": target_entry_key,
        "kind": str(target_entry.get("kind") or "").strip(),
        "lane": str(target_entry.get("lane") or "").strip(),
        "title": str(target_entry.get("title") or "").strip(),
        "status": str(target_entry.get("status") or "").strip(),
        "executor_kind": str(target_entry.get("executor_kind") or "").strip(),
        "sequence_key": str(target_entry.get("sequence_key") or "").strip(),
        "primary_action_code": str(target_entry.get("primary_action_code") or "").strip(),
        "secondary_action_code": str(target_entry.get("secondary_action_code") or "").strip(),
        "focus_ref": dict(target_entry.get("focus_ref") or {}),
        "primary_focus_ref": dict(target_entry.get("primary_focus_ref") or {}),
        "secondary_focus_ref": dict(target_entry.get("secondary_focus_ref") or {}),
        "observation_only": bool(target_entry.get("observation_only", False)),
        "activity_key": str(target_entry.get("activity_key") or ""),
        "activity_kind": str(target_entry.get("activity_kind") or ""),
        "ui_intent_kind": str(target_entry.get("ui_intent_kind") or ""),
        "contract_navigation": dict(target_entry.get("contract_navigation") or {}),
    },
    "request": request_payload,
}, ensure_ascii=False))
PY
}

preview_driver_focus_entry() {
  local mainland_base_url="$1"
  local entry_key="$2"
  local requested_by="$3"

  local raw_driver_feed_response
  raw_driver_feed_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/driver-feed")"
  local driver_feed_http_status="${raw_driver_feed_response##*$'\n'HTTP_STATUS=}"
  local driver_feed_response_json="${raw_driver_feed_response%$'\n'HTTP_STATUS=*}"

  if [[ "${driver_feed_http_status}" -lt 200 || "${driver_feed_http_status}" -ge 300 ]]; then
    echo "[1/3] driver feed raw response"
    printf '%s\n' "http_status=${driver_feed_http_status}"
    print_json_or_raw "${driver_feed_response_json}"
    exit 1
  fi

  local bundle_json
  bundle_json="$(build_driver_focus_bundle "${driver_feed_response_json}" "${entry_key}" "${requested_by}" "cli/driver-focus-preview" "primary" "false")"
  local selected_entry_json
  selected_entry_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("selected_entry") or {}, ensure_ascii=False))
PY
)"
  local request_json
  request_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("request") or {}, ensure_ascii=False))
PY
)"

  echo "[1/4] selected focus"
  print_json_or_raw "${selected_entry_json}"
  echo
  echo

  echo "[2/4] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/resolve" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[3/4] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[4/4] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}" "${selected_entry_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
selected = json.loads(str(sys.argv[3] or "{}"))
data = payload.get("data") or {}
preview = data.get("preview") or {}
primary = preview.get("primary") or {}
secondary = preview.get("secondary") or {}
gate = data.get("gate") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "selected_entry": selected,
    "selected_section": str(data.get("selected_section") or ""),
    "contract": {
        "contract_key": str(preview.get("contract_key") or ""),
        "contract_version": str(preview.get("contract_version") or ""),
        "contract_primary_endpoint": str(preview.get("contract_primary_endpoint") or ""),
        "preview_endpoint": str(preview.get("preview_endpoint") or ""),
        "schema_doc_path": str(preview.get("contract_schema_doc_path") or ""),
    },
    "execution_chain": str(preview.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "gate": {
        "decision": str(gate.get("decision") or ""),
        "decision_label": str(gate.get("decision_label") or ""),
        "recommendation": str(gate.get("recommendation") or ""),
        "recommendation_label": str(gate.get("recommendation_label") or ""),
        "will_execute": bool(gate.get("will_execute", False)),
        "confirm_required": bool(gate.get("confirm_required", False)),
        "target_api": str(gate.get("target_api") or ""),
        "focus_ref": gate.get("focus_ref") or {},
    },
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
        "request_payload": primary.get("request_payload") or {},
    },
    "secondary": (
        {
            "label": str(secondary.get("label") or ""),
            "action_code": str(secondary.get("action_code") or ""),
            "target_api": str(secondary.get("target_api") or ""),
            "recommendation_label": str(secondary.get("recommendation_label") or ""),
            "focus_ref": secondary.get("focus_ref") or {},
            "request_payload": secondary.get("request_payload") or {},
        }
        if secondary else {}
    ),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

run_driver_focus_entry() {
  local mainland_base_url="$1"
  local entry_key="$2"
  local secondary_flag="$3"
  local confirm_flag="$4"
  local requested_by="$5"

  local raw_driver_feed_response
  raw_driver_feed_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/driver-feed")"
  local driver_feed_http_status="${raw_driver_feed_response##*$'\n'HTTP_STATUS=}"
  local driver_feed_response_json="${raw_driver_feed_response%$'\n'HTTP_STATUS=*}"

  if [[ "${driver_feed_http_status}" -lt 200 || "${driver_feed_http_status}" -ge 300 ]]; then
    echo "[1/3] driver feed raw response"
    printf '%s\n' "http_status=${driver_feed_http_status}"
    print_json_or_raw "${driver_feed_response_json}"
    exit 1
  fi

  local bundle_json
  bundle_json="$(build_driver_focus_bundle "${driver_feed_response_json}" "${entry_key}" "${requested_by}" "cli/driver-focus-run" "${secondary_flag}" "${confirm_flag}")"
  local selected_entry_json
  selected_entry_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("selected_entry") or {}, ensure_ascii=False))
PY
)"
  local request_json
  request_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("request") or {}, ensure_ascii=False))
PY
)"

  echo "[1/4] selected focus"
  print_json_or_raw "${selected_entry_json}"
  echo
  echo

  echo "[2/4] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/execute-resolved" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[3/4] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[4/4] execution result"
  python3 - <<'PY' "${response_json}" "${http_status}" "${selected_entry_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
selected = json.loads(str(sys.argv[3] or "{}"))
data = payload.get("data") or {}
gate = data.get("gate") or {}
execution_result = data.get("execution_result") or {}

raw_code = payload.get("code", 1)
if raw_code in (0, "0", False):
    normalized_code = 0
else:
    normalized_code = int(raw_code or 1)

print(json.dumps({
    "http_status": http_status,
    "code": normalized_code,
    "message": str(payload.get("message") or ""),
    "selected_entry": selected,
    "executed": bool(data.get("executed", False)),
    "selected_section": str(data.get("selected_section") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "decision": str(gate.get("decision") or ""),
    "decision_label": str(gate.get("decision_label") or ""),
    "recommendation": str(gate.get("recommendation") or ""),
    "target_api": str(gate.get("target_api") or ""),
    "target_method": str(gate.get("target_method") or ""),
    "gate_focus_ref": gate.get("focus_ref") or {},
    "action_code": str(gate.get("action_code") or execution_result.get("action_code") or execution_result.get("driver_action_code") or ""),
    "sequence_key": str(gate.get("sequence_key") or execution_result.get("sequence_key") or ""),
    "handled": bool(execution_result.get("handled", False)),
    "mode": str(execution_result.get("mode") or ""),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

build_stack_next_bundle() {
  local stack_diagnosis_response_json="$1"
  local requested_by="$2"
  local source_label="$3"
  local confirm_flag="$4"
  python3 - <<'PY' "${stack_diagnosis_response_json}" "${requested_by}" "${source_label}" "${confirm_flag}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
requested_by = str(sys.argv[2] or "").strip() or "cli/ops-center/stack-next"
source_label = str(sys.argv[3] or "").strip() or "cli/stack-next"
confirm_flag = str(sys.argv[4] or "").strip().lower()

data = payload.get("data") or {}
diagnosis = dict(data.get("diagnosis") or {})
operator_decision = dict(diagnosis.get("operator_decision") or {})
next_actions = dict(diagnosis.get("next_actions") or {})
recommended_commands = dict(diagnosis.get("recommended_commands") or {})
next_step = dict(diagnosis.get("next_step") or {})
recommended_actions = [dict(item or {}) for item in list(diagnosis.get("recommended_actions") or []) if dict(item or {})]
recommended_action_codes = {
    str(item.get("action_code") or "").strip()
    for item in recommended_actions
    if str(item.get("action_code") or "").strip()
}
overview = dict(data.get("overview") or {})
managed_nodes = dict(data.get("managed_nodes") or {})
release_hub = dict(data.get("release_hub") or {})
issues = [dict(item or {}) for item in list(diagnosis.get("issues") or []) if dict(item or {})]

def normalize_node_codes(value):
    result = []
    seen = set()
    if not isinstance(value, list):
        return result
    for item in value:
        if isinstance(item, dict):
            node_code = str(item.get("node_code") or "").strip()
        else:
            node_code = str(item or "").strip()
        if not node_code or node_code in seen:
            continue
        seen.add(node_code)
        result.append(node_code)
    return result


def scene_node_log_command(node_code, limit=120, mode="key"):
    node_code = str(node_code or "").strip()
    if not node_code:
        return ""
    return (
        "bash domain-api/deploy/multi-region/drive_ops_center.sh "
        f"scene-node-log http://127.0.0.1:8100 {node_code} {int(limit or 120)} {str(mode or 'key').strip() or 'key'}"
    )


if not operator_decision or not next_actions or not recommended_commands:
    log_sync = dict((overview.get("log_sync") or {}))
    problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if dict(item or {})]
    launchpad_focus_ref = dict(release_hub.get("focus_ref") or release_hub.get("default_rollout_gate_focus_ref") or {})
    default_rollout_gate_status = str(release_hub.get("default_rollout_gate_status") or "").strip()
    first_problem_node_code = str((problem_nodes[0] if problem_nodes else {}).get("node_code") or "").strip()
    missing_sample_node_codes = normalize_node_codes(log_sync.get("missing_sample_node_codes") or [])
    scene_log_target_node_code = missing_sample_node_codes[0] if missing_sample_node_codes else first_problem_node_code

    synthesized_recommended_commands = {
        "api-restart": "bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover http://127.0.0.1:8100",
        "stack-diagnosis": "bash domain-api/deploy/multi-region/drive_ops_center.sh stack-diagnosis http://127.0.0.1:8100 summary",
        "stack-check": "bash domain-api/deploy/multi-region/drive_ops_center.sh stack-diagnosis http://127.0.0.1:8100 summary",
        "managed-node-bootstrap-plan": (
            "bash domain-api/deploy/multi-region/drive_ops_center.sh "
            f"node-bootstrap-plan http://127.0.0.1:8100 {first_problem_node_code}"
            if first_problem_node_code
            else ""
        ),
        "scene_log": scene_node_log_command(scene_log_target_node_code, 120, "key"),
        "driver_focus_preview": "bash domain-api/deploy/multi-region/drive_ops_center.sh driver-focus-preview http://127.0.0.1:8100",
        "doctor": "bash domain-api/deploy/multi-region/drive_ops_center.sh doctor http://127.0.0.1:8100",
        "node_handover": (
            f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover http://127.0.0.1:8100 {first_problem_node_code}"
            if first_problem_node_code
            else ""
        ),
        "release_launchpad": "bash domain-api/deploy/multi-region/drive_ops_center.sh release-launchpad http://127.0.0.1:8100",
    }
    synthesized_operator_decision = {}
    if any(str(item.get("code") or "").strip() in {"remote_log_sync_disabled", "remote_log_sync_waiting_sample"} for item in issues):
        synthesized_operator_decision = {
            "lane": "observability",
            "priority": "high",
            "reason_code": "scene_log_attention",
            "title": "先看执行现场日志",
            "summary": "当前总检优先建议先补现场可见性，再决定是否继续接管或推进发布。",
            "next_focus": {
                "kind": "node_scene_log",
                "node_code": scene_log_target_node_code,
                "mode": "key",
                "limit": 120,
            } if scene_log_target_node_code else {},
            "primary_command_key": "scene_log",
            "secondary_command_key": "driver_focus_preview",
        }
    elif any(str(item.get("code") or "").strip() == "runtime_build_schema_stale" for item in issues):
        synthesized_operator_decision = {
            "lane": "runtime_recovery",
            "priority": "high",
            "reason_code": "runtime_build_schema_stale",
            "title": "先重启控制面 API，让运行时切到最新 schema",
            "summary": "当前属于仓库代码已更新，但运行中的 API 仍旧停留在旧 schema 的场景。先重启 domaincheck-api，再重新看 stack-diagnosis 与 node-bootstrap-plan。",
            "next_focus": {
                "kind": "runtime_build_info",
                "node_code": "",
            },
            "primary_command_key": "api-restart",
            "secondary_command_key": "managed-node-bootstrap-plan" if first_problem_node_code else "stack-diagnosis",
        }
    elif any(str(item.get("code") or "").strip() == "managed_nodes_agent_pending" for item in issues):
        synthesized_operator_decision = {
            "lane": "node_handover",
            "priority": "high",
            "reason_code": "managed_nodes_agent_pending",
            "title": "先补接管缺口",
            "summary": "当前真正阻断是 remote-agent / 接管未就绪，应先把节点接入链路打通。",
            "next_focus": {},
            "primary_command_key": "node_handover",
            "secondary_command_key": "doctor",
        }
    elif default_rollout_gate_status == "blocked":
        synthesized_operator_decision = {
            "lane": "release",
            "priority": "medium",
            "reason_code": "release_rollout_gate_blocked",
            "title": "先看发布门禁",
            "summary": str(release_hub.get("default_rollout_gate_summary") or "").strip(),
            "next_focus": launchpad_focus_ref,
            "primary_command_key": "release_launchpad",
            "secondary_command_key": "doctor",
        }

    if synthesized_operator_decision:
        operator_decision = synthesized_operator_decision
    if synthesized_recommended_commands:
        merged_recommended_commands = dict(synthesized_recommended_commands)
        merged_recommended_commands.update({
            str(key or "").strip(): str(value or "").strip()
            for key, value in recommended_commands.items()
            if str(key or "").strip() and str(value or "").strip()
        })
        recommended_commands = merged_recommended_commands
    if operator_decision:
        primary_key = str(operator_decision.get("primary_command_key") or "").strip()
        secondary_key = str(operator_decision.get("secondary_command_key") or "").strip()
        next_actions = {
            "primary_command_key": primary_key,
            "primary_command": str(recommended_commands.get(primary_key) or "").strip(),
            "secondary_command_key": secondary_key,
            "secondary_command": str(recommended_commands.get(secondary_key) or "").strip(),
        }

primary_command_key = str(operator_decision.get("primary_command_key") or "").strip()
primary_command = str(
    next_actions.get("primary_command")
    or recommended_commands.get(primary_command_key)
    or ""
).strip()
operator_focus_ref = dict(operator_decision.get("next_focus") or {})
action_code = ""
selection_mode = "driver_action"

if primary_command_key and primary_command_key in recommended_action_codes:
    action_code = primary_command_key
elif primary_command_key and primary_command:
    selection_mode = "command_only"
elif str(next_step.get("action_code") or "").strip():
    action_code = str(next_step.get("action_code") or "").strip()
elif primary_command:
    selection_mode = "command_only"
else:
    raise SystemExit("stack diagnosis 当前既没有可执行 driver action，也没有可下钻命令")

matched_action = next(
    (item for item in recommended_actions if str(item.get("action_code") or "").strip() == action_code),
    {},
)
focus_ref = dict(operator_focus_ref or next_step.get("focus_ref") or matched_action.get("focus_ref") or {})
confirm = confirm_flag in {"1", "true", "yes", "y", "confirm", "confirmed"}

request_payload = {
    "source_label": source_label,
    "title": str(matched_action.get("title") or action_code).strip() or action_code,
    "summary": str(next_step.get("reason") or matched_action.get("reason") or "").strip(),
    "reason": str(next_step.get("reason") or matched_action.get("reason") or "").strip(),
    "meta_text": str(next_step.get("source") or matched_action.get("source") or "stack-diagnosis").strip(),
    "executor_kind": "driver_action",
    "focus_ref": focus_ref,
    "primary_focus_ref": focus_ref,
    "primary_label": str(matched_action.get("title") or action_code).strip() or action_code,
    "primary_action_code": action_code,
    "primary_action_payload": {},
    "include_secondary": True,
    "requested_by": requested_by,
    "confirm": confirm,
}

if selection_mode == "command_only":
    print(json.dumps({
        "http_status": 200,
        "mode": selection_mode,
        "message": "当前主决策优先指向命令型下钻动作，不进入 driver-actions/resolve。",
        "contract": {
            "contract_key": str((diagnosis.get("contract_navigation") or {}).get("primary_contract_key") or "ops_stack_diagnosis_contract").strip(),
            "contract_version": str(diagnosis.get("contract_version") or "").strip(),
            "contract_primary_endpoint": "/api/v1/ops/stack-diagnosis",
            "preview_endpoint": "",
            "schema_doc_path": "docs/schemas/ops_stack_diagnosis_contract.md",
        },
        "selected_entry": {
            "action_code": primary_command_key,
            "source": str(operator_decision.get("reason_code") or next_step.get("source") or "stack-diagnosis").strip(),
            "title": str(operator_decision.get("title") or primary_command_key or "stack-next").strip(),
            "reason": str(operator_decision.get("summary") or next_step.get("reason") or "").strip(),
            "command": primary_command,
            "focus_ref": focus_ref,
            "contract_navigation": dict(
                diagnosis.get("contract_navigation")
                or next_step.get("contract_navigation")
                or {}
            ),
        },
        "gate": {
            "decision": "command_only",
            "decision_label": "命令下钻",
            "recommendation": "open_ui",
            "recommendation_label": "先下钻",
            "will_execute": False,
            "confirm_required": False,
            "target_api": "",
            "focus_ref": focus_ref,
        },
        "execution_chain": "stack-diagnosis -> command-only guidance",
        "focus_ref": focus_ref,
        "request": {},
    }, ensure_ascii=False))
    raise SystemExit(0)

print(json.dumps({
    "mode": selection_mode,
    "selected_entry": {
        "action_code": action_code,
        "source": str(next_step.get("source") or matched_action.get("source") or "stack-diagnosis").strip(),
        "title": str(matched_action.get("title") or action_code).strip() or action_code,
        "reason": str(next_step.get("reason") or matched_action.get("reason") or "").strip(),
        "command": str(next_step.get("command") or matched_action.get("command") or "").strip(),
        "focus_ref": focus_ref,
        "contract_navigation": dict(next_step.get("contract_navigation") or matched_action.get("contract_navigation") or {}),
    },
    "request": request_payload,
}, ensure_ascii=False))
PY
}

print_stack_diagnosis_failure_and_hint() {
  local mainland_base_url="$1"
  local stack_http_status="$2"
  local stack_response_json="$3"

  echo "[1/3] stack diagnosis raw response"
  printf '%s\n' "http_status=${stack_http_status}"
  print_json_or_raw "${stack_response_json}"
  echo
  echo

  echo "[2/3] compatibility hint"
  python3 - <<'PY' "${mainland_base_url}" "${stack_http_status}" "${stack_response_json}"
import json
import sys

base_url = str(sys.argv[1] or "").strip()
http_status = int(sys.argv[2] or 0)
raw_text = str(sys.argv[3] or "")

detail = ""
try:
    payload = json.loads(raw_text)
except Exception:
    payload = {}
else:
    detail = str(payload.get("detail") or payload.get("message") or "").strip()

message = "stack-diagnosis 请求失败，请先检查控制面 API 连通性。"
commands = [
    f"curl -sS {base_url}/api/v1/ops/stack-diagnosis",
]

if http_status == 404:
    message = "当前控制面 API 还未暴露 /api/v1/ops/stack-diagnosis，通常表示运行中的后端版本还没升级或升级后未重启。"
    commands = [
        "git status",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh runtime-refresh-recover {base_url}",
        f"curl -sS {base_url}/api/v1/ops/stack-diagnosis",
    ]

print(json.dumps({
    "http_status": http_status,
    "detail": detail,
    "message": message,
    "recommended_commands": commands,
}, ensure_ascii=False, indent=2))
PY
  echo
  echo

  echo "[3/3] next action"
  if [[ "${stack_http_status}" == "404" ]]; then
    printf '%s\n' "先把控制面后端升级到包含 /api/v1/ops/stack-diagnosis 的版本，并重启 domaincheck-api；随后再重试 stack-next。"
  else
    printf '%s\n' "先修复控制面 API / 网络问题，再重试 stack-next。"
  fi
}

preview_stack_next_entry() {
  local mainland_base_url="$1"
  local requested_by="$2"

  local raw_stack_response
  raw_stack_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
  local stack_http_status="${raw_stack_response##*$'\n'HTTP_STATUS=}"
  local stack_response_json="${raw_stack_response%$'\n'HTTP_STATUS=*}"

  if [[ "${stack_http_status}" -lt 200 || "${stack_http_status}" -ge 300 ]]; then
    print_stack_diagnosis_failure_and_hint "${mainland_base_url}" "${stack_http_status}" "${stack_response_json}"
    exit 1
  fi

  local bundle_json
  bundle_json="$(build_stack_next_bundle "${stack_response_json}" "${requested_by}" "cli/stack-next-preview" "false")"
  local bundle_mode
  bundle_mode="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(str(payload.get("mode") or "driver_action").strip())
PY
)"
  local selected_entry_json
  selected_entry_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("selected_entry") or {}, ensure_ascii=False))
PY
)"
  if [[ "${bundle_mode}" == "command_only" ]]; then
    echo "[1/2] selected next step"
    print_json_or_raw "${selected_entry_json}"
    echo
    echo
    echo "[2/2] command-only guidance"
    python3 - <<'PY' "${selected_entry_json}"
import json
import sys

selected = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps({
    "http_status": 200,
    "mode": "command_only",
    "message": "当前主决策优先指向命令型下钻动作，不进入 driver-actions/resolve。",
    "contract": {
        "contract_key": str((selected.get("contract_navigation") or {}).get("primary_contract_key") or "ops_stack_diagnosis_contract"),
        "contract_version": "",
        "contract_primary_endpoint": "/api/v1/ops/stack-diagnosis",
        "preview_endpoint": "",
        "schema_doc_path": "docs/schemas/ops_stack_diagnosis_contract.md",
    },
    "selected_entry": selected,
    "gate": {
        "decision": "command_only",
        "decision_label": "命令下钻",
        "recommendation": "open_ui",
        "recommendation_label": "先下钻",
        "will_execute": False,
        "confirm_required": False,
        "target_api": "",
        "focus_ref": selected.get("focus_ref") or {},
    },
    "execution_chain": "stack-diagnosis -> command-only guidance",
    "focus_ref": selected.get("focus_ref") or {},
    "recommended_next_command": str(selected.get("command") or ""),
}, ensure_ascii=False, indent=2))
PY
    return 0
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("request") or {}, ensure_ascii=False))
PY
)"

  echo "[1/4] selected next step"
  print_json_or_raw "${selected_entry_json}"
  echo
  echo

  echo "[2/4] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/resolve" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[3/4] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[4/4] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}" "${selected_entry_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
selected = json.loads(str(sys.argv[3] or "{}"))
data = payload.get("data") or {}
preview = data.get("preview") or {}
primary = preview.get("primary") or {}
secondary = preview.get("secondary") or {}
gate = data.get("gate") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "selected_entry": selected,
    "selected_section": str(data.get("selected_section") or ""),
    "contract": {
        "contract_key": str(preview.get("contract_key") or ""),
        "contract_version": str(preview.get("contract_version") or ""),
        "contract_primary_endpoint": str(preview.get("contract_primary_endpoint") or ""),
        "preview_endpoint": str(preview.get("preview_endpoint") or ""),
        "schema_doc_path": str(preview.get("contract_schema_doc_path") or ""),
    },
    "execution_chain": str(preview.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "gate": {
        "decision": str(gate.get("decision") or ""),
        "decision_label": str(gate.get("decision_label") or ""),
        "recommendation": str(gate.get("recommendation") or ""),
        "recommendation_label": str(gate.get("recommendation_label") or ""),
        "will_execute": bool(gate.get("will_execute", False)),
        "confirm_required": bool(gate.get("confirm_required", False)),
        "target_api": str(gate.get("target_api") or ""),
        "focus_ref": gate.get("focus_ref") or {},
    },
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
        "request_payload": primary.get("request_payload") or {},
    },
    "secondary": (
        {
            "label": str(secondary.get("label") or ""),
            "action_code": str(secondary.get("action_code") or ""),
            "target_api": str(secondary.get("target_api") or ""),
            "recommendation_label": str(secondary.get("recommendation_label") or ""),
            "focus_ref": secondary.get("focus_ref") or {},
            "request_payload": secondary.get("request_payload") or {},
        }
        if secondary else {}
    ),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

run_stack_next_entry() {
  local mainland_base_url="$1"
  local confirm_flag="$2"
  local requested_by="$3"

  local raw_stack_response
  raw_stack_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
  local stack_http_status="${raw_stack_response##*$'\n'HTTP_STATUS=}"
  local stack_response_json="${raw_stack_response%$'\n'HTTP_STATUS=*}"

  if [[ "${stack_http_status}" -lt 200 || "${stack_http_status}" -ge 300 ]]; then
    print_stack_diagnosis_failure_and_hint "${mainland_base_url}" "${stack_http_status}" "${stack_response_json}"
    exit 1
  fi

  local bundle_json
  bundle_json="$(build_stack_next_bundle "${stack_response_json}" "${requested_by}" "cli/stack-next-run" "${confirm_flag}")"
  local bundle_mode
  bundle_mode="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(str(payload.get("mode") or "driver_action").strip())
PY
)"
  local selected_entry_json
  selected_entry_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("selected_entry") or {}, ensure_ascii=False))
PY
)"
  if [[ "${bundle_mode}" == "command_only" ]]; then
    echo "[1/2] selected next step"
    print_json_or_raw "${selected_entry_json}"
    echo
    echo
    echo "[2/2] command-only guidance"
    python3 - <<'PY' "${selected_entry_json}"
import json
import sys

selected = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps({
    "http_status": 200,
    "mode": "command_only",
    "executed": False,
    "message": "当前主决策属于命令型下钻动作，stack-next run 不会代替你执行本地 shell。",
    "contract": {
        "contract_key": str((selected.get("contract_navigation") or {}).get("primary_contract_key") or "ops_stack_diagnosis_contract"),
        "contract_version": "",
        "contract_primary_endpoint": "/api/v1/ops/stack-diagnosis",
        "preview_endpoint": "",
        "schema_doc_path": "docs/schemas/ops_stack_diagnosis_contract.md",
    },
    "selected_entry": selected,
    "gate": {
        "decision": "command_only",
        "decision_label": "命令下钻",
        "recommendation": "open_ui",
        "recommendation_label": "先下钻",
        "will_execute": False,
        "confirm_required": False,
        "target_api": "",
        "focus_ref": selected.get("focus_ref") or {},
    },
    "execution_chain": "stack-diagnosis -> command-only guidance",
    "focus_ref": selected.get("focus_ref") or {},
    "recommended_next_command": str(selected.get("command") or ""),
}, ensure_ascii=False, indent=2))
PY
    return 0
  fi
  local request_json
  request_json="$(python3 - <<'PY' "${bundle_json}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload.get("request") or {}, ensure_ascii=False))
PY
)"

  echo "[1/4] selected next step"
  print_json_or_raw "${selected_entry_json}"
  echo
  echo

  echo "[2/4] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/execute-resolved" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[3/4] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[4/4] execution result"
  python3 - <<'PY' "${response_json}" "${http_status}" "${selected_entry_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
selected = json.loads(str(sys.argv[3] or "{}"))
data = payload.get("data") or {}
gate = data.get("gate") or {}
execution_result = data.get("execution_result") or {}

raw_code = payload.get("code", 1)
if raw_code in (0, "0", False):
    normalized_code = 0
else:
    normalized_code = int(raw_code or 1)

print(json.dumps({
    "http_status": http_status,
    "code": normalized_code,
    "message": str(payload.get("message") or ""),
    "selected_entry": selected,
    "executed": bool(data.get("executed", False)),
    "selected_section": str(data.get("selected_section") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "decision": str(gate.get("decision") or ""),
    "decision_label": str(gate.get("decision_label") or ""),
    "recommendation": str(gate.get("recommendation") or ""),
    "target_api": str(gate.get("target_api") or ""),
    "target_method": str(gate.get("target_method") or ""),
    "gate_focus_ref": gate.get("focus_ref") or {},
    "action_code": str(gate.get("action_code") or execution_result.get("action_code") or execution_result.get("driver_action_code") or ""),
    "sequence_key": str(gate.get("sequence_key") or execution_result.get("sequence_key") or ""),
    "handled": bool(execution_result.get("handled", False)),
    "mode": str(execution_result.get("mode") or ""),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

resolve_driver_action_entry() {
  local mainland_base_url="$1"
  local action_code="$2"
  local action_payload_json="$3"
  local requested_by="$4"
  local source_label="$5"

  action_payload_json="$(normalize_payload_json_input "${action_payload_json}")"
  action_payload_json="$(enrich_driver_action_payload_json "${mainland_base_url}" "${action_code}" "${action_payload_json}")"

  local request_json
  request_json="$(python3 - <<'PY' "${action_code}" "${action_payload_json}" "${requested_by}" "${source_label}"
import json
import sys

action_code = str(sys.argv[1] or "").strip()
payload_raw = str(sys.argv[2] or "").strip() or "{}"
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/driver-resolve"
source_label = str(sys.argv[4] or "").strip() or "cli/driver-resolve"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

node_codes = []
seen = set()
for item in list(action_payload.get("node_codes") or []):
    value = str(item or "").strip()
    if not value or value in seen:
        continue
    seen.add(value)
    node_codes.append(value)

print(json.dumps({
    "source_label": source_label,
    "title": action_code,
    "executor_kind": "driver_action",
    "primary_label": action_code,
    "primary_action_code": action_code,
    "primary_node_codes": node_codes,
    "primary_action_payload": action_payload,
    "include_secondary": True,
    "requested_by": requested_by,
}, ensure_ascii=False))
PY
)"

  echo "[1/3] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/resolve" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[3/3] condensed summary"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
preview = data.get("preview") or {}
primary = preview.get("primary") or {}
secondary = preview.get("secondary") or {}
gate = data.get("gate") or {}

print(json.dumps({
    "http_status": http_status,
    "message": str(payload.get("message") or ""),
    "selected_section": str(data.get("selected_section") or ""),
    "execution_chain": str(preview.get("execution_chain") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "gate": {
        "decision": str(gate.get("decision") or ""),
        "decision_label": str(gate.get("decision_label") or ""),
        "recommendation": str(gate.get("recommendation") or ""),
        "recommendation_label": str(gate.get("recommendation_label") or ""),
        "will_execute": bool(gate.get("will_execute", False)),
        "confirm_required": bool(gate.get("confirm_required", False)),
        "target_api": str(gate.get("target_api") or ""),
        "focus_ref": gate.get("focus_ref") or {},
    },
    "primary": {
        "label": str(primary.get("label") or ""),
        "action_code": str(primary.get("action_code") or ""),
        "target_api": str(primary.get("target_api") or ""),
        "recommendation_label": str(primary.get("recommendation_label") or ""),
        "focus_ref": primary.get("focus_ref") or {},
        "request_payload": primary.get("request_payload") or {},
    },
    "secondary": (
        {
            "label": str(secondary.get("label") or ""),
            "action_code": str(secondary.get("action_code") or ""),
            "target_api": str(secondary.get("target_api") or ""),
            "recommendation_label": str(secondary.get("recommendation_label") or ""),
            "focus_ref": secondary.get("focus_ref") or {},
            "request_payload": secondary.get("request_payload") or {},
        }
        if secondary else {}
    ),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

run_driver_action_entry() {
  local mainland_base_url="$1"
  local action_code="$2"
  local action_payload_json="$3"
  local confirm_flag="$4"
  local requested_by="$5"
  local source_label="$6"
  local confirm_value
  confirm_value="$(confirm_to_bool "${confirm_flag}")"

  action_payload_json="$(normalize_payload_json_input "${action_payload_json}")"
  action_payload_json="$(enrich_driver_action_payload_json "${mainland_base_url}" "${action_code}" "${action_payload_json}")"

  local request_json
  request_json="$(python3 - <<'PY' "${action_code}" "${action_payload_json}" "${requested_by}" "${source_label}" "${confirm_value}"
import json
import sys

action_code = str(sys.argv[1] or "").strip()
payload_raw = str(sys.argv[2] or "").strip() or "{}"
requested_by = str(sys.argv[3] or "").strip() or "cli/ops-center/driver-run"
source_label = str(sys.argv[4] or "").strip() or "cli/driver-run"
confirm = str(sys.argv[5] or "").strip().lower() == "true"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

node_codes = []
seen = set()
for item in list(action_payload.get("node_codes") or []):
    value = str(item or "").strip()
    if not value or value in seen:
        continue
    seen.add(value)
    node_codes.append(value)

print(json.dumps({
    "source_label": source_label,
    "title": action_code,
    "executor_kind": "driver_action",
    "primary_label": action_code,
    "primary_action_code": action_code,
    "primary_node_codes": node_codes,
    "primary_action_payload": action_payload,
    "include_secondary": True,
    "requested_by": requested_by,
    "confirm": confirm,
}, ensure_ascii=False))
PY
)"

  echo "[1/3] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/execute-resolved" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[3/3] execution result"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
gate = data.get("gate") or {}
execution_result = data.get("execution_result") or {}

raw_code = payload.get("code", 1)
if raw_code in (0, "0", False):
    normalized_code = 0
else:
    normalized_code = int(raw_code or 1)

print(json.dumps({
    "http_status": http_status,
    "code": normalized_code,
    "message": str(payload.get("message") or ""),
    "executed": bool(data.get("executed", False)),
    "selected_section": str(data.get("selected_section") or ""),
    "focus_ref": data.get("focus_ref") or {},
    "decision": str(gate.get("decision") or ""),
    "decision_label": str(gate.get("decision_label") or ""),
    "recommendation": str(gate.get("recommendation") or ""),
    "target_api": str(gate.get("target_api") or ""),
    "target_method": str(gate.get("target_method") or ""),
    "gate_focus_ref": gate.get("focus_ref") or {},
    "action_code": str(gate.get("action_code") or execution_result.get("action_code") or execution_result.get("driver_action_code") or ""),
    "handled": bool(execution_result.get("handled", False)),
    "mode": str(execution_result.get("mode") or ""),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi

  if [[ "${action_code}" == "enable_log_sync_key" || "${action_code}" == "enable_log_sync_full" || "${action_code}" == "disable_log_sync" ]]; then
    echo
    echo "[4/4] log sync post-check"
    print_log_sync_post_check "${mainland_base_url}"
  fi
}

print_log_sync_post_check() {
  local mainland_base_url="$1"
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/overview")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
execution_scene = data.get("execution_scene") or {}
log_sync = execution_scene.get("log_sync") or {}
participation_summary = execution_scene.get("participation_summary") or {}

participating_nodes = int(
    log_sync.get("participating_nodes_total", log_sync.get("participating_node_count", 0))
    or participation_summary.get("participating_nodes", 0)
    or 0
)
covered_nodes = int(
    log_sync.get("covered_participating_nodes", log_sync.get("covered_participating_node_count", 0))
    or 0
)
line_count = int(log_sync.get("line_count", 0) or 0)
source_node_count = int(log_sync.get("source_node_count", 0) or 0)
missing_nodes = list(log_sync.get("missing_participating_nodes") or [])
mode = str(log_sync.get("mode") or "key").strip() or "key"
enabled = bool(log_sync.get("enabled", False))
last_at = str(log_sync.get("last_at") or "").strip()
preview_lines = [
    str(item or "").strip()
    for item in list(log_sync.get("preview_lines") or [])
    if str(item or "").strip()
][:5]

status = "standby"
summary = "当前没有参与检测节点，远端日志回传处于待命状态。"
if participating_nodes > 0 and not enabled:
    status = "disabled"
    summary = "当前已有参与检测节点，但远端日志回传仍关闭。"
elif participating_nodes > 0 and (line_count <= 0 or source_node_count <= 0 or missing_nodes):
    status = "waiting_sample"
    summary = "远端日志回传已经开启，但样本或覆盖仍未形成完整闭环。"
elif participating_nodes > 0:
    status = "ready"
    summary = "远端日志回传已经形成样本，可以继续下钻节点现场日志。"

result = {
    "http_status": http_status,
    "code": int(payload.get("code", 0) or 0),
    "message": str(payload.get("message") or ""),
    "status": status,
    "summary": summary,
    "log_sync": {
        "enabled": enabled,
        "mode": mode,
        "participating_nodes": participating_nodes,
        "covered_participating_nodes": covered_nodes,
        "line_count": line_count,
        "source_node_count": source_node_count,
        "missing_participating_nodes": missing_nodes,
        "last_at": last_at,
        "preview_lines": preview_lines,
    },
}

if http_status < 200 or http_status >= 300:
    result["warning"] = "post-check 未能成功读取 /api/v1/ops/overview，请确认当前 API 版本是否已包含 ops overview。"

print(json.dumps(result, ensure_ascii=False, indent=2))
PY
}

run_log_sync_recover_flow() {
  local mainland_base_url="$1"
  local desired_mode_raw="$2"
  local confirm_flag="$3"
  local requested_by="$4"
  local desired_mode
  desired_mode="$(printf '%s' "${desired_mode_raw:-key}" | tr '[:upper:]' '[:lower:]')"
  if [[ "${desired_mode}" != "full" ]]; then
    desired_mode="key"
  fi

  local action_code="enable_log_sync_key"
  if [[ "${desired_mode}" == "full" ]]; then
    action_code="enable_log_sync_full"
  fi

  echo "[1/2] execute log sync recovery action"
  run_driver_action_entry "${mainland_base_url}" "${action_code}" '{}' "${confirm_flag}" "${requested_by}" "cli/log-sync-recover"
  echo
  echo "[2/2] recovery guidance"
  build_log_sync_guidance_json "${mainland_base_url}"
}

build_log_sync_guidance_json() {
  local mainland_base_url="$1"
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/overview")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  python3 - <<'PY' "${response_json}" "${http_status}" "${mainland_base_url}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
base_url = str(sys.argv[3] or "").strip()
data = payload.get("data") or {}
execution_scene = data.get("execution_scene") or {}
log_sync = execution_scene.get("log_sync") or {}
participation_summary = execution_scene.get("participation_summary") or {}

state = str(log_sync.get("state") or "").strip() or "unknown"
description = str(log_sync.get("description") or "").strip()
enabled = bool(log_sync.get("enabled", False))
mode = str(log_sync.get("mode") or "key").strip() or "key"
source_nodes = [str(item or "").strip() for item in list(log_sync.get("source_nodes") or []) if str(item or "").strip()]
missing_nodes = [str(item or "").strip() for item in list(log_sync.get("missing_participating_nodes") or []) if str(item or "").strip()]
covered_nodes = [str(item or "").strip() for item in list(log_sync.get("covered_participating_nodes") or []) if str(item or "").strip()]
preview_lines = [str(item or "").strip() for item in list(log_sync.get("preview_lines") or []) if str(item or "").strip()][:5]
participating_nodes = int(
    log_sync.get("participating_node_count", participation_summary.get("participating_nodes", 0))
    or participation_summary.get("participating_nodes", 0)
    or 0
)
covered_count = int(log_sync.get("covered_participating_node_count", len(covered_nodes)) or len(covered_nodes))
line_count = int(log_sync.get("line_count", 0) or 0)

recommended_commands = []
primary_target = ""
if source_nodes:
    primary_target = source_nodes[0]
elif covered_nodes:
    primary_target = covered_nodes[0]
elif missing_nodes:
    primary_target = missing_nodes[0]

if primary_target:
    recommended_commands.append(
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log {base_url} {primary_target} 120 {mode}"
    )
if missing_nodes:
    recommended_commands.extend(
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh scene-node-log {base_url} {node_code} 120 {mode}"
        for node_code in missing_nodes[:2]
        if node_code != primary_target
    )
recommended_commands.append(
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh log-sync-check {base_url}"
)
recommended_commands.append(
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh doctor {base_url}"
)

next_step = "继续观察"
if state in {"disabled", "unknown"}:
    next_step = "开关仍未真正生效，先确认当前 API 是否已加载最新 runtime_settings，并复查执行链。"
elif state in {"waiting_sample", "partial_coverage"}:
    next_step = "开关已经生效，但样本或覆盖还不完整，优先下钻参与节点现场日志。"
elif state in {"healthy", "full_capture"}:
    next_step = "远端日志回传已进入可用状态，可以继续从海外控制面盯现场。"
elif state == "idle":
    next_step = "当前没有参与检测节点，日志回传已就绪，等任务进入执行即可。"

print(json.dumps({
    "http_status": http_status,
    "code": int(payload.get("code", 0) or 0),
    "message": str(payload.get("message") or ""),
    "status": state,
    "summary": description,
    "next_step": next_step,
    "log_sync": {
        "enabled": enabled,
        "mode": mode,
        "participating_nodes": participating_nodes,
        "covered_participating_nodes": covered_count,
        "line_count": line_count,
        "source_nodes": source_nodes,
        "missing_participating_nodes": missing_nodes,
        "preview_lines": preview_lines,
    },
    "recommended_commands": recommended_commands[:5],
}, ensure_ascii=False, indent=2))
PY
}

run_runtime_refresh_recover() {
  local mainland_base_url="$1"
  local audit_output
  audit_output="$(bash "${SCRIPT_DIR}/check_env_drift.sh" "${mainland_base_url}")"

  echo "[1/2] env audit"
  printf '%s\n' "${audit_output}"
  echo
  echo

  echo "[2/2] runtime refresh guidance"
  python3 - <<'PY' "${audit_output}" "${mainland_base_url}"
import json
import sys

raw_text = str(sys.argv[1] or "")
base_url = str(sys.argv[2] or "").strip()
marker = "[8/8] condensed env audit summary"
candidate_text = raw_text.split(marker, 1)[1].strip() if marker in raw_text else raw_text.strip()

payload = {}
if candidate_text:
    try:
        payload = json.loads(candidate_text)
    except Exception:
        payload = {}

runtime = dict(payload.get("runtime") or {})
recommended_actions = [
    str(item).strip()
    for item in list(payload.get("recommended_actions") or [])
    if str(item).strip()
]

recommended_commands = []
for candidate in recommended_actions:
    if candidate not in recommended_commands:
        recommended_commands.append(candidate)

for candidate in [
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-diagnosis {base_url} summary",
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-next {base_url}",
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh doctor-decision {base_url} -",
]:
    normalized_candidate = str(candidate or "").strip()
    if normalized_candidate and normalized_candidate not in recommended_commands:
        recommended_commands.append(normalized_candidate)

status = str(payload.get("status") or "").strip() or "unknown"
headline = str(payload.get("headline") or "").strip()
runtime_may_need_restart = bool(runtime.get("runtime_may_need_restart", False))
repo_capability_drift = bool(runtime.get("repo_capability_drift", False))
repo_commit_drift = bool(runtime.get("repo_commit_drift", False))

summary = "当前没有识别到明显的运行时版本漂移。"
if runtime_may_need_restart:
    summary = "已经识别到运行时版本漂移，先让 domaincheck-api 切到最新代码，再继续节点接管与上线复核。"
elif status == "blocked":
    summary = "当前环境本身仍有阻断项，先修环境，再谈运行时刷新。"
elif status == "attention":
    summary = "当前环境存在注意项，但不一定都是运行时版本问题。"

print(json.dumps({
    "status": status,
    "headline": headline,
    "summary": summary,
    "runtime_refresh": {
        "runtime_may_need_restart": runtime_may_need_restart,
        "repo_capability_drift": repo_capability_drift,
        "repo_commit_drift": repo_commit_drift,
        "build_commit_sha": str(runtime.get("build_commit_sha") or "").strip(),
        "build_commit_ref": str(runtime.get("build_commit_ref") or "").strip(),
        "route_surface_declares_bootstrap_plan": bool(runtime.get("route_surface_declares_bootstrap_plan", False)),
        "route_surface_missing_keys": [
            str(item).strip()
            for item in list(runtime.get("route_surface_missing_keys") or [])
            if str(item).strip()
        ],
    },
    "recommended_commands": recommended_commands[:6],
}, ensure_ascii=False, indent=2))
PY
}

run_go_live_recover() {
  local mainland_base_url="$1"
  local overseas_base_url="$2"

  echo "[1/5] runtime refresh recover"
  run_runtime_refresh_recover "${mainland_base_url}"
  echo
  echo

  echo "[2/5] stack check summary"
  bash "${SCRIPT_DIR}/check_ops_center_stack.sh" "${mainland_base_url}" "summary"
  echo
  echo

  echo "[3/5] stack next preview"
  preview_stack_next_entry "${mainland_base_url}" "$(ops_center_resolve_requested_by)"
  echo
  echo

  echo "[4/5] go live check summary"
  bash "${SCRIPT_DIR}/check_go_live.sh" "${mainland_base_url}" "${overseas_base_url}" "summary"
  echo
  echo

  echo "[5/5] doctor decision"
  run_doctor_decision "${mainland_base_url}" "${overseas_base_url}"
}

show_agent_gap_check() {
  local mainland_base_url="$1"
  local raw_http_response
  raw_http_response="$(request_with_status "GET" "${mainland_base_url}/api/v1/ops/stack-diagnosis?base_url=${mainland_base_url}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  python3 - <<'PY' "${response_json}" "${http_status}" "${mainland_base_url}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
base_url = str(sys.argv[3] or "").strip()
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]
first_gap = dict(managed_nodes.get("first_handover_gap") or {})
managed_enabled = int(managed_nodes.get("managed_enabled", 0) or 0)
remote_access_ready = int(managed_nodes.get("remote_access_ready", 0) or 0)
first_node_code = str(
    first_gap.get("node_code")
    or managed_nodes.get("first_handover_gap_node_code")
    or ((problem_nodes[0] or {}).get("node_code") if problem_nodes else "")
    or ""
).strip()
summary = "当前没有启用托管节点。"
if problem_nodes and managed_enabled > 0 and remote_access_ready <= 0:
    summary = "当前已有托管节点，但 remote-agent 仍未就绪，优先补齐节点接管链路。"
elif problem_nodes and managed_enabled > 0 and remote_access_ready < managed_enabled:
    summary = (
        f"当前仍有 {len(problem_nodes)} 台托管节点未进入 remote-agent 就绪状态，"
        "优先补齐剩余节点接管。"
    )
elif managed_enabled > 0:
    summary = "当前托管节点均已进入 remote-agent 就绪状态。"

recommended_commands = []
if first_node_code:
    recommended_commands.extend([
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-recover {base_url} {first_node_code}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-onboarding {base_url} {first_node_code}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-handover {base_url} {first_node_code}",
        f"bash domain-api/deploy/multi-region/drive_ops_center.sh node-bootstrap-plan {base_url} {first_node_code}",
    ])
recommended_commands.extend([
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh agent-gap-export /tmp/domaincheck-agent-gap {base_url}",
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh stack-first-gap-handover {base_url}",
    f"bash domain-api/deploy/multi-region/drive_ops_center.sh doctor {base_url}",
])

print(json.dumps({
    "http_status": http_status,
    "code": int(payload.get("code", 0) or 0),
    "message": str(payload.get("message") or ""),
    "summary": summary,
    "managed_nodes": {
        "managed_enabled": managed_enabled,
        "remote_access_ready": remote_access_ready,
        "first_gap_node_code": first_node_code,
        "problem_nodes": [
            {
                "node_code": str(item.get("node_code") or "").strip(),
                "agent_state": str(item.get("agent_state") or "").strip(),
                "remote_access_state": str(item.get("remote_access_state") or "").strip(),
                "delivery_queue_state": str(item.get("delivery_queue_state") or "").strip(),
                "participation_state": str(item.get("participation_state") or "").strip(),
            }
            for item in problem_nodes[:5]
        ],
    },
    "recommended_commands": recommended_commands[:5],
}, ensure_ascii=False, indent=2))
PY
}

run_agent_gap_recover_flow() {
  local mainland_base_url="$1"
  local confirm_flag="$2"
  local requested_by="$3"
  local normalized_confirm
  normalized_confirm="$(confirm_to_bool "${confirm_flag}")"

  echo "[1/4] stack first gap handover"
  show_stack_first_gap_handover "${mainland_base_url}"
  echo
  echo "[2/4] first node bootstrap plan"
  local first_gap_node_code
  first_gap_node_code="$(python3 - <<'PY' "${mainland_base_url}" "${OPS_CENTER_CURL_CONNECT_TIMEOUT}" "${OPS_CENTER_CURL_MAX_TIME}"
import json
import subprocess
import sys

base_url = str(sys.argv[1] or "").strip()
connect_timeout = str(sys.argv[2] or "3").strip()
max_time = str(sys.argv[3] or "10").strip()
proc = subprocess.run(
    [
        "curl",
        "-sS",
        "--connect-timeout",
        connect_timeout,
        "--max-time",
        max_time,
        f"{base_url}/api/v1/ops/stack-diagnosis?base_url={base_url}",
    ],
    capture_output=True,
    text=True,
    check=False,
)
raw = (proc.stdout or "").strip()
try:
    payload = json.loads(raw)
except Exception:
    print("")
    raise SystemExit(0)
data = payload.get("data") or {}
managed_nodes = data.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed_nodes.get("problem_nodes") or []) if isinstance(item, dict)]
first_gap = dict(managed_nodes.get("first_handover_gap") or {})
node_code = str(
    first_gap.get("node_code")
    or managed_nodes.get("first_handover_gap_node_code")
    or ((problem_nodes[0] or {}).get("node_code") if problem_nodes else "")
    or ""
).strip()
print(node_code)
PY
)"
  if [[ -n "${first_gap_node_code}" ]]; then
    build_node_handover_bootstrap_plan \
      "${mainland_base_url}" \
      "${first_gap_node_code}" \
      "${requested_by}" \
      "72" \
      "${mainland_base_url}" \
      "/opt/domaincheck"
  else
    echo '{"message":"当前没有可生成 bootstrap-plan 的缺口节点。"}'
  fi
  echo
  echo "[3/4] node onboarding view"
  if [[ -n "${first_gap_node_code}" ]]; then
    show_node_onboarding "${mainland_base_url}" "${first_gap_node_code}"
  else
    echo '{"message":"当前没有可查看 onboarding 的缺口节点。"}'
  fi
  echo
  echo "[4/4] first node recovery decision"
  if [[ -n "${first_gap_node_code}" ]]; then
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-recover "${mainland_base_url}" "${first_gap_node_code}" "" "${requested_by}"
    echo
    echo "[follow-up] gap recovery guidance"
    show_agent_gap_check "${mainland_base_url}"
  else
    echo '{"message":"当前没有可生成恢复决策的缺口节点。"}'
    echo
    echo "[follow-up] gap recovery guidance"
    show_agent_gap_check "${mainland_base_url}"
  fi
  if [[ "${normalized_confirm}" == "true" ]]; then
    echo
    echo '{"confirm":"true","note":"当前 agent-gap-recover 仍是结构化恢复流，不会直接 SSH 落地远端 bootstrap。"}'
  fi
}

export_agent_gap_bundle() {
  local report_dir="$1"
  local mainland_base_url="$2"
  local requested_by="$3"
  ops_center_ensure_report_dir "${report_dir}"

  local stack_json_path="${report_dir}/00_stack_first_gap_handover.json"
  local check_json_path="${report_dir}/01_agent_gap_check.json"
  local onboarding_json_path="${report_dir}/02_node_onboarding.json"
  local bootstrap_plan_txt_path="${report_dir}/03_node_bootstrap_plan.txt"
  local bootstrap_preview_json_path="${report_dir}/04_node_bootstrap_preview.json"
  local acceptance_plan_json_path="${report_dir}/05_node_acceptance_plan.json"
  local manifest_path="${report_dir}/manifest.json"
  local nodes_dir="${report_dir}/nodes"

  bash "${SCRIPT_DIR}/drive_ops_center.sh" stack-first-gap-handover "${mainland_base_url}" >"${stack_json_path}"
  bash "${SCRIPT_DIR}/drive_ops_center.sh" agent-gap-check "${mainland_base_url}" >"${check_json_path}"

  local first_gap_node_code
  local gap_nodes_json
  gap_nodes_json="$(python3 - <<'PY' "${check_json_path}"
import json
import sys
from pathlib import Path

text = Path(sys.argv[1]).read_text(encoding="utf-8")
decoder = json.JSONDecoder()
best = None
for index, ch in enumerate(text):
    if ch not in "{[":
        continue
    try:
        value, end = decoder.raw_decode(text[index:])
    except Exception:
        continue
    absolute_end = index + end
    if best is None or absolute_end >= best[0]:
        best = (absolute_end, value)
payload = best[1] if best else {}
managed = payload.get("managed_nodes") or {}
problem_nodes = [dict(item or {}) for item in list(managed.get("problem_nodes") or []) if isinstance(item, dict)]
first_gap_node_code = str(managed.get("first_gap_node_code") or "").strip()
node_codes = []
for item in problem_nodes:
    node_code = str(item.get("node_code") or "").strip()
    if node_code and node_code not in node_codes:
        node_codes.append(node_code)
if first_gap_node_code and first_gap_node_code not in node_codes:
    node_codes.insert(0, first_gap_node_code)
print(json.dumps({
    "first_gap_node_code": first_gap_node_code,
    "gap_node_codes": node_codes,
}, ensure_ascii=False))
PY
)"
  first_gap_node_code="$(python3 - <<'PY' "${gap_nodes_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
print(str(payload.get("first_gap_node_code") or "").strip())
PY
)"
  mapfile -t gap_node_codes < <(python3 - <<'PY' "${gap_nodes_json}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
for item in list(payload.get("gap_node_codes") or []):
    node_code = str(item or "").strip()
    if node_code:
        print(node_code)
PY
)

  if [[ -n "${first_gap_node_code}" ]]; then
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-onboarding "${mainland_base_url}" "${first_gap_node_code}" >"${onboarding_json_path}"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-bootstrap-plan "${mainland_base_url}" "${first_gap_node_code}" "${requested_by}" "72" "${mainland_base_url}" "/opt/domaincheck" >"${bootstrap_plan_txt_path}"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-bootstrap-preview "${mainland_base_url}" "${first_gap_node_code}" "${requested_by}" >"${bootstrap_preview_json_path}"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-acceptance-plan "${mainland_base_url}" "${first_gap_node_code}" "${requested_by}" >"${acceptance_plan_json_path}" || true
  fi

  mkdir -p "${nodes_dir}"
  local node_code safe_node_code node_dir
  for node_code in "${gap_node_codes[@]}"; do
    [[ -n "${node_code}" ]] || continue
    safe_node_code="$(printf '%s' "${node_code}" | tr '/:' '__')"
    safe_node_code="${safe_node_code// /_}"
    node_dir="${nodes_dir}/${safe_node_code}"
    mkdir -p "${node_dir}"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-handover "${mainland_base_url}" "${node_code}" >"${node_dir}/00_node_handover.json"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-onboarding "${mainland_base_url}" "${node_code}" >"${node_dir}/01_node_onboarding.json"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-bootstrap-plan "${mainland_base_url}" "${node_code}" "${requested_by}" "72" "${mainland_base_url}" "/opt/domaincheck" >"${node_dir}/02_node_bootstrap_plan.txt"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-bootstrap-preview "${mainland_base_url}" "${node_code}" "${requested_by}" >"${node_dir}/03_node_bootstrap_preview.json"
    bash "${SCRIPT_DIR}/drive_ops_center.sh" node-acceptance-plan "${mainland_base_url}" "${node_code}" "${requested_by}" >"${node_dir}/04_node_acceptance_plan.json" || true
  done

  python3 - <<'PY' \
    "${manifest_path}" \
    "${report_dir}" \
    "${mainland_base_url}" \
    "${requested_by}" \
    "${first_gap_node_code}" \
    "${gap_nodes_json}" \
    "${nodes_dir}" \
    "${stack_json_path}" \
    "${check_json_path}" \
    "${onboarding_json_path}" \
    "${bootstrap_plan_txt_path}" \
    "${bootstrap_preview_json_path}" \
    "${acceptance_plan_json_path}"
import json
import sys
from pathlib import Path

manifest_path = Path(sys.argv[1])
report_dir = Path(sys.argv[2])
base_url = sys.argv[3]
requested_by = sys.argv[4]
first_gap_node_code = sys.argv[5]
gap_nodes_payload = json.loads(str(sys.argv[6] or "{}"))
nodes_dir = Path(sys.argv[7])
paths = {
    "stack_first_gap_handover": Path(sys.argv[8]),
    "agent_gap_check": Path(sys.argv[9]),
    "node_onboarding": Path(sys.argv[10]),
    "node_bootstrap_plan": Path(sys.argv[11]),
    "node_bootstrap_preview": Path(sys.argv[12]),
    "node_acceptance_plan": Path(sys.argv[13]),
}

artifacts = []
for key, path in paths.items():
    artifacts.append({
        "key": key,
        "path": str(path),
        "exists": path.exists(),
        "size": path.stat().st_size if path.exists() else 0,
    })

node_bundles = []
for node_code in list(gap_nodes_payload.get("gap_node_codes") or []):
    normalized_node_code = str(node_code or "").strip()
    if not normalized_node_code:
        continue
    normalized_dir_name = normalized_node_code.replace("/", "_").replace(":", "_").replace(" ", "_")
    node_dir = nodes_dir / normalized_dir_name
    bundle_paths = {
        "node_handover": node_dir / "00_node_handover.json",
        "node_onboarding": node_dir / "01_node_onboarding.json",
        "node_bootstrap_plan": node_dir / "02_node_bootstrap_plan.txt",
        "node_bootstrap_preview": node_dir / "03_node_bootstrap_preview.json",
        "node_acceptance_plan": node_dir / "04_node_acceptance_plan.json",
    }
    node_bundles.append({
        "node_code": normalized_node_code,
        "bundle_dir": str(node_dir),
        "artifacts": [
            {
                "key": key,
                "path": str(path),
                "exists": path.exists(),
                "size": path.stat().st_size if path.exists() else 0,
            }
            for key, path in bundle_paths.items()
        ],
    })

payload = {
    "report_dir": str(report_dir),
    "mainland_base_url": base_url,
    "requested_by": requested_by,
    "first_gap_node_code": first_gap_node_code,
    "gap_node_codes": list(gap_nodes_payload.get("gap_node_codes") or []),
    "gap_node_total": len(list(gap_nodes_payload.get("gap_node_codes") or [])),
    "artifacts": artifacts,
    "node_bundles": node_bundles,
    "summary": {
        "ok": bool(node_bundles),
        "headline": (
            f"已为 {len(node_bundles)} 台接管缺口节点导出接管材料；首个缺口节点为 {first_gap_node_code}。"
            if node_bundles and first_gap_node_code
            else (
                f"已为 {len(node_bundles)} 台接管缺口节点导出接管材料。"
                if node_bundles
                else "当前没有可导出的接管缺口节点。"
            )
        ),
    },
}
manifest_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
}

run_resolved_runbook_sequence() {
  local mainland_base_url="$1"
  local sequence_key="$2"
  local secondary_flag="$3"
  local action_payload_json="$4"
  local confirm_flag="$5"
  local requested_by="$6"
  local source_label="$7"
  local confirm_value
  confirm_value="$(confirm_to_bool "${confirm_flag}")"

  action_payload_json="$(normalize_payload_json_input "${action_payload_json}")"

  local request_json
  request_json="$(python3 - <<'PY' "${sequence_key}" "${secondary_flag}" "${action_payload_json}" "${requested_by}" "${source_label}" "${confirm_value}"
import json
import sys

sequence_key = str(sys.argv[1] or "").strip()
secondary_flag = str(sys.argv[2] or "primary").strip().lower()
payload_raw = str(sys.argv[3] or "").strip() or "{}"
requested_by = str(sys.argv[4] or "").strip() or "cli/ops-center/runbook-run"
source_label = str(sys.argv[5] or "").strip() or "cli/runbook-run"
confirm = str(sys.argv[6] or "").strip().lower() == "true"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

secondary = secondary_flag in {"secondary", "second", "2", "true", "yes", "y"}

print(json.dumps({
    "source_label": source_label,
    "title": sequence_key,
    "executor_kind": "runbook_sequence",
    "sequence_key": sequence_key,
    "include_secondary": True,
    "requested_by": requested_by,
    "secondary": secondary,
    "confirm": confirm,
    "primary_action_payload": action_payload,
    "secondary_action_payload": action_payload,
}, ensure_ascii=False))
PY
)"

  echo "[1/3] request"
  print_json_or_raw "${request_json}"
  echo
  echo

  local raw_http_response
  raw_http_response="$(request_with_status "POST" "${mainland_base_url}/api/v1/ops/driver-actions/execute-resolved" "${request_json}")"
  local http_status="${raw_http_response##*$'\n'HTTP_STATUS=}"
  local response_json="${raw_http_response%$'\n'HTTP_STATUS=*}"

  echo "[2/3] raw response"
  printf '%s\n' "http_status=${http_status}"
  print_json_or_raw "${response_json}"
  echo
  echo

  echo "[3/3] execution result"
  python3 - <<'PY' "${response_json}" "${http_status}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
gate = data.get("gate") or {}
execution_result = data.get("execution_result") or {}

raw_code = payload.get("code", 1)
if raw_code in (0, "0", False):
    normalized_code = 0
else:
    normalized_code = int(raw_code or 1)

print(json.dumps({
    "http_status": http_status,
    "code": normalized_code,
    "message": str(payload.get("message") or ""),
    "executed": bool(data.get("executed", False)),
    "selected_section": str(data.get("selected_section") or ""),
    "decision": str(gate.get("decision") or ""),
    "decision_label": str(gate.get("decision_label") or ""),
    "recommendation": str(gate.get("recommendation") or ""),
    "sequence_key": str(gate.get("sequence_key") or execution_result.get("sequence_key") or ""),
    "action_code": str(gate.get("action_code") or execution_result.get("action_code") or execution_result.get("driver_action_code") or ""),
    "handled": bool(execution_result.get("handled", False)),
    "mode": str(execution_result.get("mode") or ""),
}, ensure_ascii=False, indent=2))
PY

  if [[ "${http_status}" -lt 200 || "${http_status}" -ge 300 ]]; then
    exit 1
  fi
}

case "${COMMAND}" in
  help|-h|--help)
    usage
    ;;
  config)
    print_config "${1:-${OPS_CENTER_ACTIVE_PROFILE}}"
    ;;
  contracts)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    CONTRACT_KEY="${2:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      CONTRACT_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_ops_contracts "${MAINLAND_BASE_URL}" "${CONTRACT_KEY}"
    ;;
  env-audit)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_env_drift.sh" "${MAINLAND_BASE_URL}"
    ;;
  runtime-refresh-check)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_env_drift.sh" "${MAINLAND_BASE_URL}"
    ;;
  runtime-refresh-recover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    run_runtime_refresh_recover "${MAINLAND_BASE_URL}"
    ;;
  stack-diagnosis|stack-check)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    VIEW_MODE="${2:-summary}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      VIEW_MODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    exec bash "${SCRIPT_DIR}/check_ops_center_stack.sh" "${MAINLAND_BASE_URL}" "${VIEW_MODE}"
    ;;
  go-live-check)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="${2:-$(ops_center_resolve_overseas_api_base_url)}"
    VIEW_MODE="${3:-summary}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      VIEW_MODE="${OVERSEAS_BASE_URL:-summary}"
      OVERSEAS_BASE_URL="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    exec bash "${SCRIPT_DIR}/check_go_live.sh" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}" "${VIEW_MODE}"
    ;;
  go-live-recover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${2:-}" "$(ops_center_resolve_overseas_api_base_url)")"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${MAINLAND_BASE_URL}" "$(ops_center_resolve_overseas_api_base_url)")"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    run_go_live_recover "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"
    ;;
  go-live-export)
    REPORT_DIR="${1:-${OPS_CENTER_REPORT_ROOT}/go-live-bundles/go-live-bundle-$(timestamp_now)}"
    MAINLAND_BASE_URL="${2:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${3:-}" "$(ops_center_resolve_overseas_api_base_url)")"
    if [[ "${REPORT_DIR}" == http://* || "${REPORT_DIR}" == https://* ]]; then
      OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${MAINLAND_BASE_URL:-}" "$(ops_center_resolve_overseas_api_base_url)")"
      MAINLAND_BASE_URL="${REPORT_DIR}"
      REPORT_DIR="${OPS_CENTER_REPORT_ROOT}/go-live-bundles/go-live-bundle-$(timestamp_now)}"
    fi
    exec bash "${SCRIPT_DIR}/export_go_live_bundle.sh" "${REPORT_DIR}" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"
    ;;
  go-live-review)
    TARGET_PATH="${1:-${OPS_CENTER_REPORT_ROOT}/go-live-bundles}"
    if [[ -d "${TARGET_PATH}" && ! -f "${TARGET_PATH}/manifest.json" ]]; then
      TARGET_PATH="$(find "${TARGET_PATH}" -mindepth 1 -maxdepth 1 -type d | sort | tail -n 1)"
    fi
    exec bash "${SCRIPT_DIR}/review_go_live_bundle.sh" "${TARGET_PATH}"
    ;;
  go-live-signoff)
    FIRST_ARG="${1:-}"
    SECOND_ARG="${2:-}"
    if [[ -n "${FIRST_ARG}" && -d "${FIRST_ARG}" && ! -f "${FIRST_ARG}/manifest.json" ]]; then
      FIRST_ARG="$(find "${FIRST_ARG}" -mindepth 1 -maxdepth 1 -type d | sort | tail -n 1)"
    fi
    exec bash "${SCRIPT_DIR}/check_go_live_signoff.sh" "${FIRST_ARG}" "${SECOND_ARG}"
    ;;
  stack-next)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    STACK_MODE="${2:-preview}"
    CONFIRM_FLAG="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${CONFIRM_FLAG:-$(ops_center_resolve_requested_by)}"
      CONFIRM_FLAG="${STACK_MODE:-}"
      STACK_MODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    if is_confirm_token "${STACK_MODE}" && [[ -z "${CONFIRM_FLAG}" ]]; then
      CONFIRM_FLAG="${STACK_MODE}"
      STACK_MODE="run"
    fi
    case "$(printf '%s' "${STACK_MODE}" | tr '[:upper:]' '[:lower:]')" in
      preview|show|resolve|"")
        preview_stack_next_entry "${MAINLAND_BASE_URL}" "${REQUESTED_BY}"
        ;;
      run|execute)
        run_stack_next_entry "${MAINLAND_BASE_URL}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
        ;;
      *)
        echo "stack-next mode must be preview or run" >&2
        exit 1
        ;;
    esac
    ;;
  release-package)
    REPO_ROOT="$(ops_center_repo_root)"
    SKIP_SMOKE="$(confirm_to_bool "${1:-}")"
    if [[ "${SKIP_SMOKE}" == "true" ]]; then
      DOMAINCHECK_SKIP_SMOKE_TEST=1 exec bash "${REPO_ROOT}/package_domain_release.sh"
    fi
    exec bash "${REPO_ROOT}/package_domain_release.sh"
    ;;
  release-verify)
    REPO_ROOT="$(ops_center_repo_root)"
    exec bash "${REPO_ROOT}/verify_domain_release.sh" "${1:-}" "${2:-}"
    ;;
  release-prepare)
    REPO_ROOT="$(ops_center_repo_root)"
    exec bash "${REPO_ROOT}/prepare_final_release.sh"
    ;;
  release-show)
    REPO_ROOT="$(ops_center_repo_root)"
    exec bash "${REPO_ROOT}/show_latest_release.sh"
    ;;
  release-launchpad)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    CHANNEL="${2:-stable}"
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" launchpad "${CHANNEL}"
    ;;
  release-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" preview-latest
    ;;
  release-preview-smart)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    MODE="${2:-}"
    if [[ -z "${MODE}" && ( "${MAINLAND_BASE_URL}" == "worker" || "${MAINLAND_BASE_URL}" == "control" ) ]]; then
      MODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    if [[ "${MODE}" != "worker" && "${MODE}" != "control" ]]; then
      echo "mode must be worker or control" >&2
      usage
      exit 1
    fi
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" preview-latest-smart "${MODE}"
    ;;
  release-import-latest)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" create-latest-release
    ;;
  publish-latest)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    MODE="${2:-}"
    CONFIRM_FLAG="${3:-}"
    SKIP_SMOKE_FLAG="${4:-}"
    if [[ -z "${MODE}" && ( "${MAINLAND_BASE_URL}" == "worker" || "${MAINLAND_BASE_URL}" == "control" ) ]]; then
      MODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      CONFIRM_FLAG="${2:-}"
      SKIP_SMOKE_FLAG="${3:-}"
    fi
    run_publish_latest "${MAINLAND_BASE_URL}" "${MODE}" "${CONFIRM_FLAG}" "${SKIP_SMOKE_FLAG}"
    ;;
  doctor-export)
    REPORT_DIR="${1:-${OPS_CENTER_REPORT_ROOT}/doctor-$(timestamp_now)}"
    MAINLAND_BASE_URL="${2:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${3:-}" "$(ops_center_resolve_overseas_api_base_url)")"
    run_doctor_report_export "${REPORT_DIR}" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"
    ;;
  doctor-decision)
    FIRST_ARG="${1:-}"
    SECOND_ARG="${2:-}"
    run_doctor_decision "${FIRST_ARG}" "${SECOND_ARG}"
    ;;
  doctor)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="$(normalize_optional_base_url_arg "${2:-}" "$(ops_center_resolve_overseas_api_base_url)")"
    run_step "[doctor/0] ops center stack" bash "${SCRIPT_DIR}/check_ops_center_stack.sh" "${MAINLAND_BASE_URL}" summary
    run_step "[doctor/1] ops plane" bash "${SCRIPT_DIR}/check_ops_plane.sh" "${MAINLAND_BASE_URL}"
    run_step "[doctor/2] release hub" bash "${SCRIPT_DIR}/check_release_hub.sh" "${MAINLAND_BASE_URL}"
    run_step "[doctor/3] inspection" bash "${SCRIPT_DIR}/check_ops_inspection.sh" "${MAINLAND_BASE_URL}"
    run_step "[doctor/4] participation" bash "${SCRIPT_DIR}/check_worker_participation.sh" "${MAINLAND_BASE_URL}"
    if [[ -n "${OVERSEAS_BASE_URL}" ]]; then
      run_step "[doctor/5] temp topology" bash "${SCRIPT_DIR}/check_temp_topology.sh" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"
    fi
    ;;
  ops-plane)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_ops_plane.sh" "${MAINLAND_BASE_URL}"
    ;;
  inspection)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_ops_inspection.sh" "${MAINLAND_BASE_URL}"
    ;;
  participation)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_worker_participation.sh" "${MAINLAND_BASE_URL}"
    ;;
  topology)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    OVERSEAS_BASE_URL="${2:-$(ops_center_resolve_overseas_api_base_url)}"
    exec bash "${SCRIPT_DIR}/check_temp_topology.sh" "${MAINLAND_BASE_URL}" "${OVERSEAS_BASE_URL}"
    ;;
  nodes)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    show_ops_nodes "${MAINLAND_BASE_URL}"
    ;;
  stack-first-gap-handover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_stack_first_gap_handover "${MAINLAND_BASE_URL}"
    ;;
  node-bind-ssh)
    ARG1="${1:-}"
    ARG2="${2:-}"
    ARG3="${3:-}"
    ARG4="${4:-}"
    ARG5="${5:-}"
    ARG6="${6:-}"
    if [[ -n "${ARG1}" && ( "${ARG1}" == http://* || "${ARG1}" == https://* ) ]]; then
      MAINLAND_BASE_URL="${ARG1}"
      NODE_CODE="${ARG2:-}"
      SSH_HOST="${ARG3:-}"
      SSH_USER="${ARG4:-}"
      SSH_PORT="${ARG5:-22}"
      TITLE="${ARG6:-}"
    else
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      NODE_CODE="${ARG1:-}"
      SSH_HOST="${ARG2:-}"
      SSH_USER="${ARG3:-}"
      SSH_PORT="${ARG4:-22}"
      TITLE="${ARG5:-}"
    fi
    bind_node_ssh_profile "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${SSH_HOST}" "${SSH_USER}" "${SSH_PORT}" "${TITLE}"
    ;;
  node-handover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_node_handover "${MAINLAND_BASE_URL}" "${NODE_CODE}"
    ;;
  node-onboarding)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_node_onboarding "${MAINLAND_BASE_URL}" "${NODE_CODE}"
    ;;
  node-recover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    CONFIRM_FLAG="${3:-}"
    REQUESTED_BY="${4:-cli}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${CONFIRM_FLAG:-cli}"
      CONFIRM_FLAG="${NODE_CODE:-}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    recover_node_onboarding "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
    ;;
  node-bootstrap-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    REQUESTED_BY="${3:-cli}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${NODE_CODE:-cli}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_node_bootstrap_preview "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${REQUESTED_BY}"
    ;;
  node-bootstrap-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    REQUESTED_BY="${3:-cli}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${NODE_CODE:-cli}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    run_node_bootstrap "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${REQUESTED_BY}"
    ;;
  node-acceptance-plan)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    REQUESTED_BY="${3:-cli}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${NODE_CODE:-cli}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_node_acceptance_plan "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${REQUESTED_BY}"
    ;;
  node-acceptance-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    REQUESTED_BY="${3:-cli}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${NODE_CODE:-cli}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    run_node_acceptance "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${REQUESTED_BY}"
    ;;
  scene-node-log)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    LIMIT="${3:-80}"
    MODE="${4:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      MODE="${LIMIT:-}"
      LIMIT="${NODE_CODE:-80}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_node_scene_log "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${LIMIT}" "${MODE}"
    ;;
  log-sync-check)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    print_log_sync_post_check "${MAINLAND_BASE_URL}"
    ;;
  log-sync-recover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    MODE_ARG="${2:-key}"
    CONFIRM_FLAG="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${CONFIRM_FLAG:-$(ops_center_resolve_requested_by)}"
      CONFIRM_FLAG="${MODE_ARG:-}"
      MODE_ARG="${MAINLAND_BASE_URL:-key}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    run_log_sync_recover_flow "${MAINLAND_BASE_URL}" "${MODE_ARG}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
    ;;
  agent-gap-check)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    show_agent_gap_check "${MAINLAND_BASE_URL}"
    ;;
  agent-gap-recover)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    CONFIRM_FLAG="${2:-}"
    REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${CONFIRM_FLAG:-$(ops_center_resolve_requested_by)}"
      CONFIRM_FLAG="${MAINLAND_BASE_URL:-}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    run_agent_gap_recover_flow "${MAINLAND_BASE_URL}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
    ;;
  agent-gap-export)
    ARG1="${1:-}"
    ARG2="${2:-}"
    ARG3="${3:-$(ops_center_resolve_requested_by)}"
    if [[ -n "${ARG1}" && "${ARG1}" != http://* && "${ARG1}" != https://* ]]; then
      REPORT_DIR="${ARG1}"
      MAINLAND_BASE_URL="${ARG2:-$(ops_center_resolve_mainland_api_base_url)}"
      REQUESTED_BY="${ARG3:-$(ops_center_resolve_requested_by)}"
    else
      REPORT_DIR="${OPS_CENTER_REPORT_ROOT}/agent-gap-export-$(timestamp_now)"
      MAINLAND_BASE_URL="${ARG1:-$(ops_center_resolve_mainland_api_base_url)}"
      REQUESTED_BY="${ARG2:-$(ops_center_resolve_requested_by)}"
    fi
    export_agent_gap_bundle "${REPORT_DIR}" "${MAINLAND_BASE_URL}" "${REQUESTED_BY}"
    ;;
  node-bootstrap-plan)
    ARG1="${1:-}"
    ARG2="${2:-}"
    ARG3="${3:-}"
    ARG4="${4:-}"
    ARG5="${5:-}"
    ARG6="${6:-}"
    if [[ -n "${ARG1}" && ( "${ARG1}" == http://* || "${ARG1}" == https://* ) ]]; then
      MAINLAND_BASE_URL="${ARG1}"
      NODE_CODE="${ARG2:-}"
      ISSUED_BY="${ARG3:-cli/ops-center/node-bootstrap-plan}"
      EXPIRES_IN_HOURS="${ARG4:-72}"
      CONTROL_PLANE_BASE_URL="${ARG5:-${MAINLAND_BASE_URL}}"
      ROOT_DIR="${ARG6:-/opt/domaincheck}"
    else
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      NODE_CODE="${ARG1:-}"
      ISSUED_BY="${ARG2:-cli/ops-center/node-bootstrap-plan}"
      EXPIRES_IN_HOURS="${ARG3:-72}"
      CONTROL_PLANE_BASE_URL="${ARG4:-${MAINLAND_BASE_URL}}"
      ROOT_DIR="${ARG5:-/opt/domaincheck}"
    fi
    build_node_handover_bootstrap_plan \
      "${MAINLAND_BASE_URL}" \
      "${NODE_CODE}" \
      "${ISSUED_BY}" \
      "${EXPIRES_IN_HOURS}" \
      "${CONTROL_PLANE_BASE_URL}" \
      "${ROOT_DIR}"
    ;;
  queue-status)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_delivery_queue_status "${MAINLAND_BASE_URL}" "${NODE_CODE}"
    ;;
  queue-records)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    STATE_FILTER="${3:-}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      STATE_FILTER="${NODE_CODE:-}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_delivery_queue_records "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${STATE_FILTER}"
    ;;
  queue-flush)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    LIMIT="${3:-20}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${LIMIT:-$(ops_center_resolve_requested_by)}"
      LIMIT="${NODE_CODE:-20}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    BODY_JSON="$(python3 - <<'PY' "${LIMIT}" "${REQUESTED_BY}"
import json
import sys
print(json.dumps({
    "limit": max(1, min(int(sys.argv[1] or 20), 200)),
    "requested_by": str(sys.argv[2] or "cli/ops-center/queue-flush"),
}, ensure_ascii=False))
PY
)"
    run_delivery_queue_action "${MAINLAND_BASE_URL}" "${NODE_CODE}" "/delivery-queue/flush" "${BODY_JSON}"
    ;;
  queue-replay)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    LIMIT="${3:-20}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${LIMIT:-$(ops_center_resolve_requested_by)}"
      LIMIT="${NODE_CODE:-20}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    BODY_JSON="$(python3 - <<'PY' "${LIMIT}" "${REQUESTED_BY}"
import json
import sys
print(json.dumps({
    "limit": max(1, min(int(sys.argv[1] or 20), 200)),
    "flush_after_replay": True,
    "reason": "cli quick replay from drive_ops_center.sh",
    "requested_by": str(sys.argv[2] or "cli/ops-center/queue-replay"),
}, ensure_ascii=False))
PY
)"
    run_delivery_queue_action "${MAINLAND_BASE_URL}" "${NODE_CODE}" "/delivery-queue/replay" "${BODY_JSON}"
    ;;
  queue-replay-record)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    RECORD_ID="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${RECORD_ID:-$(ops_center_resolve_requested_by)}"
      RECORD_ID="${NODE_CODE:-}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    if [[ -z "${RECORD_ID}" ]]; then
      echo "record_id is required" >&2
      exit 1
    fi
    BODY_JSON="$(python3 - <<'PY' "${REQUESTED_BY}"
import json
import sys
print(json.dumps({
    "limit": 1,
    "flush_after_replay": True,
    "reason": "cli replay visible head record",
    "requested_by": str(sys.argv[1] or "cli/ops-center/queue-replay-record"),
}, ensure_ascii=False))
PY
)"
    run_delivery_queue_action "${MAINLAND_BASE_URL}" "${NODE_CODE}" "/delivery-queue/records/${RECORD_ID}/replay" "${BODY_JSON}"
    ;;
  queue-discard-record)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    RECORD_ID="${3:-}"
    DISCARD_REASON="${4:-}"
    REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      REQUESTED_BY="${DISCARD_REASON:-$(ops_center_resolve_requested_by)}"
      DISCARD_REASON="${RECORD_ID:-}"
      RECORD_ID="${NODE_CODE:-}"
      NODE_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    if [[ -z "${RECORD_ID}" || -z "${DISCARD_REASON}" ]]; then
      echo "record_id and reason are required" >&2
      exit 1
    fi
    BODY_JSON="$(python3 - <<'PY' "${DISCARD_REASON}" "${REQUESTED_BY}"
import json
import sys
print(json.dumps({
    "limit": 1,
    "reason": str(sys.argv[1] or "").strip(),
    "discarded_by": "cli",
    "requested_by": str(sys.argv[2] or "cli/ops-center/queue-discard-record"),
}, ensure_ascii=False))
PY
)"
    run_delivery_queue_action "${MAINLAND_BASE_URL}" "${NODE_CODE}" "/delivery-queue/records/${RECORD_ID}/discard" "${BODY_JSON}"
    ;;
  activity-stream)
    if [[ $# -gt 0 && ( "$1" == http://* || "$1" == https://* ) ]]; then
      MAINLAND_BASE_URL="$1"
      shift || true
    else
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
    fi
    show_activity_stream "${MAINLAND_BASE_URL}" "$@"
    ;;
  activity-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ACTIVITY_KEY="${2:-}"
    REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ACTIVITY_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      REQUESTED_BY="${2:-$(ops_center_resolve_requested_by)}"
    fi
    preview_activity_item "${MAINLAND_BASE_URL}" "${ACTIVITY_KEY}" "${REQUESTED_BY}"
    ;;
  driver-feed)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    RAW_HTTP_RESPONSE="$(request_with_status "GET" "${MAINLAND_BASE_URL}/api/v1/ops/driver-feed")"
    HTTP_STATUS="${RAW_HTTP_RESPONSE##*$'\n'HTTP_STATUS=}"
    RESPONSE_JSON="${RAW_HTTP_RESPONSE%$'\n'HTTP_STATUS=*}"
    RESPONSE_JSON_FILE="$(mktemp)"
    printf '%s' "${RESPONSE_JSON}" > "${RESPONSE_JSON_FILE}"
    echo "[1/2] raw response"
    printf '%s\n' "http_status=${HTTP_STATUS}"
    python3 - <<'PY' "${RESPONSE_JSON_FILE}"
import json
import sys
with open(sys.argv[1], "r", encoding="utf-8") as fh:
    payload = json.loads(fh.read() or "{}")
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
    echo
    echo "[2/2] condensed summary"
    python3 - <<'PY' "${RESPONSE_JSON_FILE}" "${HTTP_STATUS}"
import json
import sys

with open(sys.argv[1], "r", encoding="utf-8") as fh:
    payload = json.loads(fh.read() or "{}")
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
summary = data.get("summary") or {}
entries = list(data.get("entries") or [])
activity_focus = list(data.get("activity_focus") or [])
top_recommendation = data.get("top_recommendation") or {}
scene_log_observation = data.get("scene_log_observation") or {}
contract_navigation = data.get("contract_navigation") or {}
print(json.dumps({
    "http_status": http_status,
    "headline": str(data.get("headline") or ""),
    "generated_at": str(data.get("generated_at") or ""),
    "contract_navigation": {
        "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
        "contract_keys": list(contract_navigation.get("contract_keys") or []),
        "detail_endpoint_pattern": str(contract_navigation.get("detail_endpoint_pattern") or ""),
    },
    "top_recommendation": {
        "key": str(top_recommendation.get("key") or ""),
        "kind": str(top_recommendation.get("kind") or ""),
        "lane": str(top_recommendation.get("lane") or ""),
        "title": str(top_recommendation.get("title") or ""),
        "primary_contract_key": str((top_recommendation.get("contract_navigation") or {}).get("primary_contract_key") or ""),
        "contract_keys": list((top_recommendation.get("contract_navigation") or {}).get("contract_keys") or []),
    },
    "summary": {
        "total": int(summary.get("total", 0) or 0),
        "do_now_total": int(summary.get("do_now_total", 0) or 0),
        "standard_path_total": int(summary.get("standard_path_total", 0) or 0),
        "publish_ready": bool(summary.get("publish_ready", False)),
        "publish_status": str(summary.get("publish_status") or ""),
        "publish_status_label": str(summary.get("publish_status_label") or ""),
        "launchpad_recommended_target_node_code": str(summary.get("launchpad_recommended_target_node_code") or ""),
        "launchpad_recommended_recovery_label": str(summary.get("launchpad_recommended_recovery_label") or ""),
        "launchpad_recommended_recovery_summary": str(summary.get("launchpad_recommended_recovery_summary") or ""),
        "launchpad_onboarding_bootstrap_pending_nodes": int(summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
        "launchpad_onboarding_acceptance_ready_nodes": int(summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
        "scene_log_status": str(summary.get("scene_log_status") or ""),
        "kind_counts": dict(summary.get("kind_counts") or {}),
    },
    "scene_log_observation": {
        "status": str(scene_log_observation.get("status") or ""),
        "status_label": str(scene_log_observation.get("status_label") or ""),
        "summary": str(scene_log_observation.get("summary") or ""),
        "target_node_code": str(scene_log_observation.get("target_node_code") or ""),
        "participating_node_count": int(scene_log_observation.get("participating_node_count", 0) or 0),
        "covered_participating_node_count": int(scene_log_observation.get("covered_participating_node_count", 0) or 0),
        "line_count": int(scene_log_observation.get("line_count", 0) or 0),
        "focus_ref": scene_log_observation.get("focus_ref") or {},
        "primary_contract_key": str((scene_log_observation.get("contract_navigation") or {}).get("primary_contract_key") or ""),
        "contract_keys": list((scene_log_observation.get("contract_navigation") or {}).get("contract_keys") or []),
    },
    "entries": [
        {
            "key": str(item.get("key") or ""),
            "kind": str(item.get("kind") or ""),
            "lane": str(item.get("lane") or ""),
            "title": str(item.get("title") or ""),
            "status": str(item.get("status") or ""),
            "primary_label": str(item.get("primary_label") or ""),
            "secondary_label": str(item.get("secondary_label") or ""),
            "primary_contract_key": str((item.get("contract_navigation") or {}).get("primary_contract_key") or ""),
            "contract_keys": list((item.get("contract_navigation") or {}).get("contract_keys") or []),
        }
        for item in entries
    ],
    "activity_focus": [
        {
            "key": str(item.get("key") or ""),
            "title": str(item.get("title") or ""),
            "status": str(item.get("status") or ""),
            "primary_contract_key": str((item.get("contract_navigation") or {}).get("primary_contract_key") or ""),
            "contract_keys": list((item.get("contract_navigation") or {}).get("contract_keys") or []),
        }
        for item in activity_focus
    ],
}, ensure_ascii=False, indent=2))
PY
    rm -f "${RESPONSE_JSON_FILE}"
    ;;
  driver-focus-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ENTRY_KEY="${2:-}"
    REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ENTRY_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      REQUESTED_BY="${2:-$(ops_center_resolve_requested_by)}"
    fi
    preview_driver_focus_entry "${MAINLAND_BASE_URL}" "${ENTRY_KEY}" "${REQUESTED_BY}"
    ;;
  driver-focus-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ENTRY_KEY="${2:-}"
    SECONDARY_FLAG="${3:-primary}"
    CONFIRM_FLAG="${4:-}"
    REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ENTRY_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      SECONDARY_FLAG="${2:-primary}"
      CONFIRM_FLAG="${3:-}"
      REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    fi
    if is_secondary_token "${ENTRY_KEY}"; then
      REQUESTED_BY="${CONFIRM_FLAG:-$(ops_center_resolve_requested_by)}"
      CONFIRM_FLAG="${SECONDARY_FLAG:-}"
      SECONDARY_FLAG="${ENTRY_KEY}"
      ENTRY_KEY=""
    fi
    if is_confirm_token "${SECONDARY_FLAG}" && [[ -z "${CONFIRM_FLAG}" ]]; then
      CONFIRM_FLAG="${SECONDARY_FLAG}"
      SECONDARY_FLAG="primary"
    fi
    run_driver_focus_entry "${MAINLAND_BASE_URL}" "${ENTRY_KEY}" "${SECONDARY_FLAG}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
    ;;
  codex-brief)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    RAW_HTTP_RESPONSE="$(
      request_with_status_custom \
        "GET" \
        "${MAINLAND_BASE_URL}/api/v1/ops/codex-brief" \
        "" \
        "${OPS_CENTER_CURL_CONNECT_TIMEOUT}" \
        "${OPS_CENTER_CURL_MAX_TIME_CODEX_BRIEF}"
    )"
    HTTP_STATUS="${RAW_HTTP_RESPONSE##*$'\n'HTTP_STATUS=}"
    RESPONSE_JSON="${RAW_HTTP_RESPONSE%$'\n'HTTP_STATUS=*}"
    RESPONSE_JSON_FILE="$(mktemp)"
    printf '%s' "${RESPONSE_JSON}" > "${RESPONSE_JSON_FILE}"
    echo "[1/2] raw response"
    printf '%s\n' "http_status=${HTTP_STATUS}"
    python3 - <<'PY' "${RESPONSE_JSON_FILE}"
import json
import sys
with open(sys.argv[1], "r", encoding="utf-8") as fh:
    payload = json.loads(fh.read() or "{}")
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
    echo
    echo "[2/2] condensed summary"
    python3 - <<'PY' "${RESPONSE_JSON_FILE}" "${HTTP_STATUS}"
import json
import sys

with open(sys.argv[1], "r", encoding="utf-8") as fh:
    payload = json.loads(fh.read() or "{}")
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
summary = data.get("summary") or {}
focus = data.get("focus") or {}
entries = list(data.get("entries") or [])
activity_focus = list(data.get("activity_focus") or [])
scene_log_observation = data.get("scene_log_observation") or {}
contract_navigation = data.get("contract_navigation") or {}
print(json.dumps({
    "http_status": http_status,
    "headline": str(data.get("headline") or ""),
    "generated_at": str(data.get("generated_at") or ""),
    "contract_navigation": {
        "primary_contract_key": str(contract_navigation.get("primary_contract_key") or ""),
        "contract_keys": list(contract_navigation.get("contract_keys") or []),
        "detail_endpoint_pattern": str(contract_navigation.get("detail_endpoint_pattern") or ""),
    },
    "focus": {
        "entry_key": str(focus.get("entry_key") or ""),
        "title": str(focus.get("title") or ""),
        "recommendation": str(focus.get("recommendation") or ""),
        "status_text": str(focus.get("status_text") or ""),
        "target_method": str(focus.get("target_method") or ""),
        "target_api": str(focus.get("target_api") or ""),
        "focus_ref": focus.get("focus_ref") or {},
        "primary_focus_ref": focus.get("primary_focus_ref") or {},
        "secondary_focus_ref": focus.get("secondary_focus_ref") or {},
        "primary_contract_key": str((focus.get("contract_navigation") or {}).get("primary_contract_key") or ""),
        "contract_keys": list((focus.get("contract_navigation") or {}).get("contract_keys") or []),
    },
    "summary": {
        "total": int(summary.get("total", 0) or 0),
        "go_live_status": str(summary.get("go_live_status") or ""),
        "publish_ready": bool(summary.get("publish_ready", False)),
        "publish_status": str(summary.get("publish_status") or ""),
        "publish_status_label": str(summary.get("publish_status_label") or ""),
        "launchpad_recommended_target_node_code": str(summary.get("launchpad_recommended_target_node_code") or ""),
        "launchpad_recommended_recovery_label": str(summary.get("launchpad_recommended_recovery_label") or ""),
        "launchpad_recommended_recovery_summary": str(summary.get("launchpad_recommended_recovery_summary") or ""),
        "launchpad_onboarding_bootstrap_pending_nodes": int(summary.get("launchpad_onboarding_bootstrap_pending_nodes", 0) or 0),
        "launchpad_onboarding_acceptance_ready_nodes": int(summary.get("launchpad_onboarding_acceptance_ready_nodes", 0) or 0),
        "auto_execute_total": int(summary.get("auto_execute_total", 0) or 0),
        "confirm_then_execute_total": int(summary.get("confirm_then_execute_total", 0) or 0),
        "resolve_first_total": int(summary.get("resolve_first_total", 0) or 0),
        "open_ui_total": int(summary.get("open_ui_total", 0) or 0),
        "blocked_total": int(summary.get("blocked_total", 0) or 0),
        "automation_level_counts": dict(summary.get("automation_level_counts") or {}),
    },
    "scene_log_observation": {
        "status": str(scene_log_observation.get("status") or ""),
        "status_label": str(scene_log_observation.get("status_label") or ""),
        "summary": str(scene_log_observation.get("summary") or ""),
        "target_node_code": str(scene_log_observation.get("target_node_code") or ""),
        "participating_node_count": int(scene_log_observation.get("participating_node_count", 0) or 0),
        "covered_participating_node_count": int(scene_log_observation.get("covered_participating_node_count", 0) or 0),
        "line_count": int(scene_log_observation.get("line_count", 0) or 0),
        "focus_ref": scene_log_observation.get("focus_ref") or {},
        "primary_contract_key": str((scene_log_observation.get("contract_navigation") or {}).get("primary_contract_key") or ""),
        "contract_keys": list((scene_log_observation.get("contract_navigation") or {}).get("contract_keys") or []),
    },
    "entries": [
        {
            "key": str(item.get("key") or ""),
            "kind": str(item.get("kind") or ""),
            "title": str(item.get("title") or ""),
            "executor_kind": str(item.get("executor_kind") or ""),
            "recommendation": str((item.get("autopilot") or {}).get("recommendation") or ""),
            "automation_level": str((item.get("autopilot") or {}).get("automation_level") or ""),
            "executor_mode_hint": str((item.get("autopilot") or {}).get("executor_mode_hint") or ""),
            "primary_action_code": str(item.get("primary_action_code") or ""),
            "focus_ref": item.get("focus_ref") or {},
            "primary_focus_ref": item.get("primary_focus_ref") or {},
            "secondary_focus_ref": item.get("secondary_focus_ref") or {},
            "primary_contract_key": str((item.get("contract_navigation") or {}).get("primary_contract_key") or ""),
            "contract_keys": list((item.get("contract_navigation") or {}).get("contract_keys") or []),
        }
        for item in entries
    ],
    "activity_focus": [
        {
            "key": str(item.get("key") or ""),
            "title": str(item.get("title") or ""),
            "status": str(item.get("status") or ""),
            "primary_contract_key": str((item.get("contract_navigation") or {}).get("primary_contract_key") or ""),
            "contract_keys": list((item.get("contract_navigation") or {}).get("contract_keys") or []),
        }
        for item in activity_focus
    ],
}, ensure_ascii=False, indent=2))
PY
    rm -f "${RESPONSE_JSON_FILE}"
    ;;
  codex-focus-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ENTRY_KEY="${2:-}"
    REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ENTRY_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      REQUESTED_BY="${2:-$(ops_center_resolve_requested_by)}"
    fi
    preview_codex_focus_entry "${MAINLAND_BASE_URL}" "${ENTRY_KEY}" "${REQUESTED_BY}"
    ;;
  codex-focus-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ENTRY_KEY="${2:-}"
    CONFIRM_FLAG="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ENTRY_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      CONFIRM_FLAG="${2:-}"
      REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    fi
    run_codex_focus_entry "${MAINLAND_BASE_URL}" "${ENTRY_KEY}" "${CONFIRM_FLAG}" "${REQUESTED_BY}"
    ;;
  release-hub)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    shift || true
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" "$@"
    ;;
  driver-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ACTION_CODE="${2:-}"
    ACTION_PAYLOAD_JSON="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${ACTION_CODE}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ACTION_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      ACTION_PAYLOAD_JSON="${2:-}"
      REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${ACTION_CODE}" ]]; then
      usage
      exit 1
    fi
    exec bash "${SCRIPT_DIR}/drive_ops_action.sh" "${MAINLAND_BASE_URL}" preview "${ACTION_CODE}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}"
    ;;
  driver-resolve)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ACTION_CODE="${2:-}"
    ACTION_PAYLOAD_JSON="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${ACTION_CODE}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ACTION_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      ACTION_PAYLOAD_JSON="${2:-}"
      REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_CODE}" ]]; then
      usage
      exit 1
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    resolve_driver_action_entry "${MAINLAND_BASE_URL}" "${ACTION_CODE}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}" "cli/driver-resolve"
    ;;
  driver-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ACTION_CODE="${2:-}"
    ACTION_PAYLOAD_JSON="${3:-}"
    CONFIRM_FLAG="${4:-}"
    REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${ACTION_CODE}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ACTION_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      ACTION_PAYLOAD_JSON="${2:-}"
      CONFIRM_FLAG="${3:-}"
      REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    fi
    if is_confirm_token "${ACTION_PAYLOAD_JSON}" && [[ -z "${CONFIRM_FLAG}" ]]; then
      CONFIRM_FLAG="${ACTION_PAYLOAD_JSON}"
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${ACTION_CODE}" ]]; then
      usage
      exit 1
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    run_driver_action_entry "${MAINLAND_BASE_URL}" "${ACTION_CODE}" "${ACTION_PAYLOAD_JSON}" "${CONFIRM_FLAG}" "${REQUESTED_BY}" "cli/driver-run"
    ;;
  driver)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    ACTION_CODE="${2:-}"
    ACTION_PAYLOAD_JSON="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${ACTION_CODE}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      ACTION_CODE="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      ACTION_PAYLOAD_JSON="${2:-}"
      REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${ACTION_CODE}" ]]; then
      usage
      exit 1
    fi
    exec bash "${SCRIPT_DIR}/drive_ops_action.sh" "${MAINLAND_BASE_URL}" "${ACTION_CODE}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}"
    ;;
  runbook-preview)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    SEQUENCE_KEY="${2:-}"
    ACTION_PAYLOAD_JSON="${3:-}"
    REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${SEQUENCE_KEY}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      SEQUENCE_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      ACTION_PAYLOAD_JSON="${2:-}"
      REQUESTED_BY="${3:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${SEQUENCE_KEY}" ]]; then
      echo "sequence_key is required" >&2
      usage
      exit 1
    fi
    preview_runbook_sequence "${MAINLAND_BASE_URL}" "${SEQUENCE_KEY}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}"
    ;;
  runbook-run)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    SEQUENCE_KEY="${2:-}"
    SECONDARY_FLAG="${3:-primary}"
    ACTION_PAYLOAD_JSON="${4:-}"
    CONFIRM_FLAG="${5:-}"
    REQUESTED_BY="${6:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${SEQUENCE_KEY}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      SEQUENCE_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      SECONDARY_FLAG="${2:-primary}"
      ACTION_PAYLOAD_JSON="${3:-}"
      CONFIRM_FLAG="${4:-}"
      REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    fi
    if is_confirm_token "${ACTION_PAYLOAD_JSON}" && [[ -z "${CONFIRM_FLAG}" ]]; then
      CONFIRM_FLAG="${ACTION_PAYLOAD_JSON}"
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${SEQUENCE_KEY}" ]]; then
      echo "sequence_key is required" >&2
      usage
      exit 1
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    run_resolved_runbook_sequence "${MAINLAND_BASE_URL}" "${SEQUENCE_KEY}" "${SECONDARY_FLAG}" "${ACTION_PAYLOAD_JSON}" "${CONFIRM_FLAG}" "${REQUESTED_BY}" "cli/runbook-run"
    ;;
  runbook-resolve)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    SEQUENCE_KEY="${2:-}"
    SECONDARY_FLAG="${3:-primary}"
    ACTION_PAYLOAD_JSON="${4:-}"
    REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${SEQUENCE_KEY}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      SEQUENCE_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      SECONDARY_FLAG="${2:-primary}"
      ACTION_PAYLOAD_JSON="${3:-}"
      REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${SEQUENCE_KEY}" ]]; then
      echo "sequence_key is required" >&2
      usage
      exit 1
    fi
    if [[ "${ACTION_PAYLOAD_JSON}" == @* ]]; then
      ACTION_PAYLOAD_PATH="${ACTION_PAYLOAD_JSON#@}"
      if [[ ! -f "${ACTION_PAYLOAD_PATH}" ]]; then
        echo "payload file not found: ${ACTION_PAYLOAD_PATH}" >&2
        exit 1
      fi
      ACTION_PAYLOAD_JSON="$(cat "${ACTION_PAYLOAD_PATH}")"
    fi
    REQUEST_JSON="$(python3 - <<'PY' "${SECONDARY_FLAG}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}"
import json
import sys

secondary_flag = str(sys.argv[1] or "primary").strip().lower()
payload_raw = str(sys.argv[2] or "").strip() or "{}"
requested_by = str(sys.argv[3] or "").strip() or "cli/drive_ops_center"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

request_payload = {
    "secondary": secondary_flag in {"secondary", "second", "2", "true", "yes", "y"},
    "action_payload": action_payload,
    "requested_by": requested_by,
}
print(json.dumps(request_payload, ensure_ascii=False))
PY
)"
    echo "[1/3] runbook resolve request"
    python3 - <<'PY' "${MAINLAND_BASE_URL}" "${SEQUENCE_KEY}" "${REQUEST_JSON}"
import json
import sys
print(json.dumps({
    "base_url": str(sys.argv[1] or ""),
    "sequence_key": str(sys.argv[2] or ""),
    "request": json.loads(str(sys.argv[3] or "{}")),
}, ensure_ascii=False, indent=2))
PY
    echo
    echo
    RAW_HTTP_RESPONSE="$(request_with_status "POST" "${MAINLAND_BASE_URL}/api/v1/ops/runbook/sequences/${SEQUENCE_KEY}/resolve" "${REQUEST_JSON}")"
    HTTP_STATUS="${RAW_HTTP_RESPONSE##*$'\n'HTTP_STATUS=}"
    RESPONSE_JSON="${RAW_HTTP_RESPONSE%$'\n'HTTP_STATUS=*}"
    echo "[2/3] raw response"
    printf '%s\n' "http_status=${HTTP_STATUS}"
    python3 - <<'PY' "${RESPONSE_JSON}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
    echo
    echo
    echo "[3/3] condensed summary"
    python3 - <<'PY' "${RESPONSE_JSON}" "${HTTP_STATUS}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
code = payload.get("code", 1)
if code in (None, ""):
    code = 0 if http_status == 200 else 1
data = payload.get("data") or {}
print(json.dumps({
    "http_status": http_status,
    "code": int(code or 0),
    "message": str(payload.get("message") or ""),
    "sequence_key": str(data.get("sequence_key") or ""),
    "driver_action_code": str(data.get("driver_action_code") or ""),
    "driver_action_label": str(data.get("driver_action_label") or ""),
    "driver_node_codes": list(data.get("driver_node_codes") or []),
    "driver_requested_by": str(data.get("driver_requested_by") or ""),
    "resolved_at": str(data.get("resolved_at") or ""),
    "sequence_focus_ref": ((data.get("sequence") or {}).get("focus_ref") or {}),
    "action_focus_ref": ((data.get("sequence") or {}).get("action_focus_ref") or {}),
}, ensure_ascii=False, indent=2))
PY
    ;;
  runbook-sequence)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    SEQUENCE_KEY="${2:-}"
    SECONDARY_FLAG="${3:-primary}"
    ACTION_PAYLOAD_JSON="${4:-}"
    REQUESTED_BY="${5:-$(ops_center_resolve_requested_by)}"
    if [[ -z "${SEQUENCE_KEY}" && "${MAINLAND_BASE_URL}" != http://* && "${MAINLAND_BASE_URL}" != https://* ]]; then
      SEQUENCE_KEY="${MAINLAND_BASE_URL}"
      MAINLAND_BASE_URL="$(ops_center_resolve_mainland_api_base_url)"
      SECONDARY_FLAG="${2:-primary}"
      ACTION_PAYLOAD_JSON="${3:-}"
      REQUESTED_BY="${4:-$(ops_center_resolve_requested_by)}"
    fi
    if [[ -z "${ACTION_PAYLOAD_JSON}" ]]; then
      ACTION_PAYLOAD_JSON='{}'
    fi
    if [[ -z "${SEQUENCE_KEY}" ]]; then
      echo "sequence_key is required" >&2
      usage
      exit 1
    fi
    if [[ "${ACTION_PAYLOAD_JSON}" == @* ]]; then
      ACTION_PAYLOAD_PATH="${ACTION_PAYLOAD_JSON#@}"
      if [[ ! -f "${ACTION_PAYLOAD_PATH}" ]]; then
        echo "payload file not found: ${ACTION_PAYLOAD_PATH}" >&2
        exit 1
      fi
      ACTION_PAYLOAD_JSON="$(cat "${ACTION_PAYLOAD_PATH}")"
    fi
    REQUEST_JSON="$(python3 - <<'PY' "${SECONDARY_FLAG}" "${ACTION_PAYLOAD_JSON}" "${REQUESTED_BY}"
import json
import sys

secondary_flag = str(sys.argv[1] or "primary").strip().lower()
payload_raw = str(sys.argv[2] or "").strip() or "{}"
requested_by = str(sys.argv[3] or "").strip() or "cli/drive_ops_center"

try:
    action_payload = json.loads(payload_raw)
except Exception as exc:
    raise SystemExit(f"invalid action payload json: {exc}")

if not isinstance(action_payload, dict):
    raise SystemExit("action payload must be a json object")

request_payload = {
    "secondary": secondary_flag in {"secondary", "second", "2", "true", "yes", "y"},
    "action_payload": action_payload,
    "requested_by": requested_by,
}
print(json.dumps(request_payload, ensure_ascii=False))
PY
)"
    echo "[1/3] runbook sequence request"
    python3 - <<'PY' "${MAINLAND_BASE_URL}" "${SEQUENCE_KEY}" "${REQUEST_JSON}"
import json
import sys
print(json.dumps({
    "base_url": str(sys.argv[1] or ""),
    "sequence_key": str(sys.argv[2] or ""),
    "request": json.loads(str(sys.argv[3] or "{}")),
}, ensure_ascii=False, indent=2))
PY
    echo
    echo
    RAW_HTTP_RESPONSE="$(request_with_status "POST" "${MAINLAND_BASE_URL}/api/v1/ops/runbook/sequences/${SEQUENCE_KEY}/execute" "${REQUEST_JSON}")"
    HTTP_STATUS="${RAW_HTTP_RESPONSE##*$'\n'HTTP_STATUS=}"
    RESPONSE_JSON="${RAW_HTTP_RESPONSE%$'\n'HTTP_STATUS=*}"
    echo "[2/3] raw response"
    printf '%s\n' "http_status=${HTTP_STATUS}"
    python3 - <<'PY' "${RESPONSE_JSON}"
import json
import sys
payload = json.loads(str(sys.argv[1] or "{}"))
print(json.dumps(payload, ensure_ascii=False, indent=2))
PY
    echo
    echo
    echo "[3/3] condensed summary"
    python3 - <<'PY' "${RESPONSE_JSON}" "${HTTP_STATUS}"
import json
import sys

payload = json.loads(str(sys.argv[1] or "{}"))
http_status = int(sys.argv[2] or 0)
data = payload.get("data") or {}
raw_code = payload.get("code", 1)
if raw_code in (0, "0", False):
    normalized_code = 0
else:
    normalized_code = int(raw_code or 1)

summary = {
    "http_status": http_status,
    "code": normalized_code,
    "message": str(payload.get("message") or ""),
    "sequence_key": str(data.get("sequence_key") or ""),
    "driver_action_code": str(data.get("driver_action_code") or ""),
    "handled": bool(data.get("handled", False)),
    "mode": str(data.get("mode") or ""),
    "sequence": data.get("sequence") or {},
}
print(json.dumps(summary, ensure_ascii=False, indent=2))
PY
    if [[ "${HTTP_STATUS}" -lt 200 || "${HTTP_STATUS}" -ge 300 ]]; then
      exit 1
    fi
    ;;
  smart-latest)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    MODE="${2:-}"
    CONFIRM_FLAG="${3:-}"
    if [[ "${MODE}" != "worker" && "${MODE}" != "control" ]]; then
      echo "mode must be worker or control" >&2
      usage
      exit 1
    fi
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" smart-latest "${MODE}" "${CONFIRM_FLAG}"
    ;;
  smart-release)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    RELEASE_ID="${2:-}"
    MODE="${3:-}"
    CONFIRM_FLAG="${4:-}"
    if [[ -z "${RELEASE_ID}" ]]; then
      echo "release_id is required" >&2
      usage
      exit 1
    fi
    if [[ "${MODE}" != "worker" && "${MODE}" != "control" ]]; then
      echo "mode must be worker or control" >&2
      usage
      exit 1
    fi
    exec bash "${SCRIPT_DIR}/drive_release_hub.sh" "${MAINLAND_BASE_URL}" smart-release "${RELEASE_ID}" "${MODE}" "${CONFIRM_FLAG}"
    ;;
  agent-plan)
    MAINLAND_BASE_URL="${1:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${2:-}"
    NODE_REGION="${3:-mainland}"
    NODE_ROLE="${4:-worker}"
    CONTROL_PLANE_BASE_URL="${5:-$(ops_center_resolve_control_plane_base_url)}"
    if [[ -z "${CONTROL_PLANE_BASE_URL}" ]]; then
      CONTROL_PLANE_BASE_URL="$(ops_center_resolve_overseas_api_base_url)"
    fi
    ROOT_DIR="${6:-$(ops_center_resolve_root_dir)}"
    if [[ -z "${NODE_CODE}" ]]; then
      echo "node_code is required" >&2
      usage
      exit 1
    fi
    ISSUED_BY="$(ops_center_resolve_issued_by)" \
    EXPIRES_IN_HOURS="$(ops_center_resolve_expires_in_hours)" \
    exec bash "${SCRIPT_DIR}/build_node_agent_bootstrap_plan.sh" \
      "${MAINLAND_BASE_URL}" \
      "${NODE_CODE}" \
      "${NODE_REGION}" \
      "${NODE_ROLE}" \
      "${CONTROL_PLANE_BASE_URL}" \
      "${ROOT_DIR}"
    ;;
  agent-plan-export)
    REPORT_DIR="${1:-${OPS_CENTER_REPORT_ROOT}/agent-plans}"
    MAINLAND_BASE_URL="${2:-$(ops_center_resolve_mainland_api_base_url)}"
    NODE_CODE="${3:-}"
    NODE_REGION="${4:-mainland}"
    NODE_ROLE="${5:-worker}"
    CONTROL_PLANE_BASE_URL="${6:-$(ops_center_resolve_control_plane_base_url)}"
    if [[ -z "${CONTROL_PLANE_BASE_URL}" ]]; then
      CONTROL_PLANE_BASE_URL="$(ops_center_resolve_overseas_api_base_url)"
    fi
    ROOT_DIR="${7:-$(ops_center_resolve_root_dir)}"
    if [[ -z "${NODE_CODE}" ]]; then
      echo "node_code is required" >&2
      usage
      exit 1
    fi
    export_agent_plan "${REPORT_DIR}" "${MAINLAND_BASE_URL}" "${NODE_CODE}" "${NODE_REGION}" "${NODE_ROLE}" "${CONTROL_PLANE_BASE_URL}" "${ROOT_DIR}"
    ;;
  agent-check)
    SERVICE_NAME="${1:-$(ops_center_resolve_node_agent_service_name)}"
    ENV_FILE="${2:-$(ops_center_resolve_node_agent_env_file)}"
    SERVICE_NAME="${SERVICE_NAME}" ENV_FILE="${ENV_FILE}" exec bash "${SCRIPT_DIR}/check_node_agent.sh"
    ;;
  *)
    echo "unknown command: ${COMMAND}" >&2
    usage
    exit 1
    ;;
esac