trading-cli

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

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
STATE_DIR="$ROOT_DIR/.trading-cli"
DEV_DIR="$STATE_DIR/dev"
LOG_DIR="$DEV_DIR/logs"
RUN_BOTS_SCRIPT="$ROOT_DIR/run-bots.sh"

KNOWN_COMMANDS=(
  help
  test
  weather
  arbitrage
  llm-workflow
  temporal
  observability
  sports-agent
  clawdbot-trading
  clawdbot-trading-up
  clawdbot-trading-down
  clawdbot-trading-ps
  clawdbot-trading-logs
  clawdbot-trading-ping
  clawdbot-trading-status
  clawdbot-trading-capabilities
  clawdbot-trading-doctor
  clawdbot-trading-start
  clawdbot-trading-stop
  clawdbot-trading-venue-list
  clawdbot-trading-portfolio-balances
  clawdbot-trading-portfolio-positions
  dev
  down
  status
  bots
)

usage() {
  cat <<'EOF'
Usage:
  ./trading-cli <command> [args]

Commands:
  ./trading-cli help                                # show this help + examples
  ./trading-cli test [suite]                        # run tests from repo root (inclusive by default)
  ./trading-cli weather [go|up|down|status|logs] [prod|dry-run|check-auth]   # deterministic weather orchestrator
  ./trading-cli arbitrage [go|up|down|status|logs] [prod|dry-run|check-auth] # deterministic arbitrage orchestrator
  ./trading-cli llm-workflow [go|up|down|status|logs]                         # llm workflow orchestrator
  ./trading-cli temporal [up|down|status|logs|ui|list|describe|show]          # temporal debugger/server orchestrator
  ./trading-cli observability [up|down|status|logs|ui] [service]              # observability stack orchestrator
  ./trading-cli sports-agent [go|up|down|status|logs|approve|execute|cancel|hard-cancel|stop-service] [--mode <hitl|auto_ultra_strict>] [--dry-run] <workflow_id_or_trace_id>
  ./trading-cli clawdbot-trading [up|down|ps|logs|ping|status|capabilities|doctor|start|stop|venue-list|venue-status|venue-enable|venue-disable|portfolio-balances|portfolio-positions|order-list|order-cancel|order-submit|execution-mode-get|execution-mode-set] [args...]
                                                                         # OpenClaw + Rust trading bridge controls (up checks required service health)
  ./trading-cli clawdbot-trading-up|clawdbot-trading-down|clawdbot-trading-ps
                                                                         # convenience aliases for compose lifecycle
  ./trading-cli clawdbot-trading-ping|clawdbot-trading-status|clawdbot-trading-capabilities|clawdbot-trading-doctor|clawdbot-trading-start|clawdbot-trading-stop
                                                                         # convenience aliases for bridge health/control
  ./trading-cli clawdbot-trading-venue-list|clawdbot-trading-portfolio-balances|clawdbot-trading-portfolio-positions
                                                                         # convenience aliases for additive multi-asset controls
                                                                         # note: openclaw-cli is an on-demand helper container and may be Exited
  ./trading-cli dev                                 # launch weather+arbitrage+llm-workflow (bg)
  ./trading-cli down                                # stop all background services
  ./trading-cli status                              # show all background service statuses
  ./trading-cli bots [prod|dry-run|check-auth]      # legacy wrapper for run-bots.sh

Test suites:
  all|inclusive (default)
  common
  kalshi-client
  weather|weather-bot
  arbitrage|arbitrage-bot
  llm-workflow|llm-rules-bot
  llm-candidate-engine
  llm-decision-engine
  llm-execution-engine
  llm-client
  llm-rules-bot-bin
  sports-agent
  observability

Examples:
  ./trading-cli test
  ./trading-cli test inclusive
  ./trading-cli test weather-bot
  ./trading-cli test observability
  ./trading-cli weather go dry-run
  ./trading-cli weather up check-auth
  ./trading-cli arbitrage go check-auth
  ./trading-cli llm-workflow up
  ./trading-cli llm-workflow logs
  ./trading-cli temporal up
  ./trading-cli temporal ui
  ./trading-cli temporal list
  ./trading-cli temporal describe <workflow_id>
  ./trading-cli observability up
  ./trading-cli observability ui
  ./trading-cli clawdbot-trading up
  ./trading-cli clawdbot-trading ping
  ./trading-cli clawdbot-trading status
  ./trading-cli clawdbot-trading capabilities
  ./trading-cli clawdbot-trading doctor
  ./trading-cli clawdbot-trading start
  ./trading-cli clawdbot-trading stop
  ./trading-cli clawdbot-trading venue-list
  ./trading-cli clawdbot-trading portfolio-balances
  ./trading-cli clawdbot-trading execution-mode-get --venue-id kalshi --market-type binary
  ./trading-cli clawdbot-trading down
  ./trading-cli sports-agent up --mode hitl
  ./trading-cli sports-agent execute <workflow_id_or_trace_id>
  ./trading-cli sports-agent cancel <workflow_id_or_trace_id>
  ./trading-cli sports-agent cancel <workflow_id_or_trace_id> --hard
  ./trading-cli sports-agent stop-service
  ./trading-cli temporal down
  ./trading-cli dev
  ./trading-cli down
EOF
}

suggest_command() {
  local input="$1"

  if [[ "$input" == "llm" || "$input" == "llm-workflow" ]]; then
    echo "llm-workflow"
    return
  fi
  if [[ "$input" == "arb" || "$input" == "arbitrage" ]]; then
    echo "arbitrage"
    return
  fi
  if [[ "$input" == "temp" || "$input" == "temporal" || "$input" == "debugger" ]]; then
    echo "temporal"
    return
  fi
  if [[ "$input" == "observability" || "$input" == "observe" || "$input" == "obs" ]]; then
    echo "observability"
    return
  fi
  if [[ "$input" == "sports-agent" || "$input" == "sports" || "$input" == "agent" ]]; then
    echo "sports-agent"
    return
  fi

  for cmd in "${KNOWN_COMMANDS[@]}"; do
    if [[ "$cmd" == "$input"* ]]; then
      echo "$cmd"
      return
    fi
  done
  for cmd in "${KNOWN_COMMANDS[@]}"; do
    if [[ "$cmd" == *"$input"* ]]; then
      echo "$cmd"
      return
    fi
  done

  # Fuzzy fallback: match first 3 chars when available.
  if [[ "${#input}" -ge 3 ]]; then
    local prefix="${input:0:3}"
    for cmd in "${KNOWN_COMMANDS[@]}"; do
      if [[ "$cmd" == "$prefix"* ]]; then
        echo "$cmd"
        return
      fi
    done
  fi
}

run_step() {
  local label="$1"
  shift

  echo
  echo "==> $label"
  "$@"
}

test_common() {
  run_step \
    "common tests" \
    cargo test --manifest-path "$ROOT_DIR/non-agent-workflows/libs/common/Cargo.toml"
}

test_kalshi_client() {
  run_step \
    "kalshi-client tests" \
    cargo test --manifest-path "$ROOT_DIR/non-agent-workflows/libs/kalshi_client/Cargo.toml"
}

test_weather_bot() {
  run_step \
    "weather-bot workspace tests" \
    cargo test --manifest-path "$ROOT_DIR/non-agent-workflows/weather-bot/Cargo.toml" --workspace
}

test_arbitrage_bot() {
  run_step \
    "arbitrage-bot workspace tests" \
    cargo test --manifest-path "$ROOT_DIR/non-agent-workflows/arbitrage-bot/Cargo.toml" --workspace
}

test_llm_rules_bot() {
  run_step \
    "llm-rules-bot workspace tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/Cargo.toml" --workspace
}

test_llm_candidate_engine() {
  run_step \
    "llm candidate-engine tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/crates/candidate-engine/Cargo.toml"
}

test_llm_decision_engine() {
  run_step \
    "llm decision-engine tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/crates/decision-engine/Cargo.toml"
}

test_llm_execution_engine() {
  run_step \
    "llm execution-engine tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/crates/execution-engine/Cargo.toml"
}

test_llm_client() {
  run_step \
    "llm client tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/crates/llm-client/Cargo.toml"
}

test_llm_rules_bot_bin() {
  run_step \
    "llm-rules-bot binary tests" \
    cargo test --manifest-path "$ROOT_DIR/llm-workflows/llm-rules-bot/Cargo.toml" --bin llm-rules-bot
}

test_sports_agent() {
  run_step \
    "sports-agent worker tests" \
    cargo test --manifest-path "$ROOT_DIR/observability-platform/sports-agent-worker/Cargo.toml"
}

test_observability() {
  local node_bin
  node_bin="$(resolve_cmd node || true)"
  if [[ -z "$node_bin" ]]; then
    echo
    echo "==> observability tests"
    echo "Skipping observability tests: Node.js 18+ not found."
    return 0
  fi

  run_step \
    "observability platform tests" \
    run_in_dir "$ROOT_DIR/observability-platform" "$node_bin" --test \
      tests/http-json.test.mjs \
      tests/local-ops-cache.test.mjs \
      tests/config-response.test.mjs \
      tests/temporal-broker.api.test.mjs \
      tests/trace-api.api.test.mjs
}

test_llm_workflow_inclusive() {
  test_llm_rules_bot
  test_llm_candidate_engine
  test_llm_decision_engine
  test_llm_execution_engine
  test_llm_client
  test_llm_rules_bot_bin
}

run_tests() {
  local suite="${1:-all}"

  case "$suite" in
    all|inclusive)
      test_common
      test_kalshi_client
      test_weather_bot
      test_arbitrage_bot
      test_llm_workflow_inclusive
      test_sports_agent
      test_observability
      ;;
    common)
      test_common
      ;;
    kalshi-client)
      test_kalshi_client
      ;;
    weather|weather-bot)
      test_weather_bot
      ;;
    arbitrage|arbitrage-bot)
      test_arbitrage_bot
      ;;
    llm-workflow|llm|llm-rules-bot)
      test_llm_workflow_inclusive
      ;;
    llm-candidate-engine)
      test_llm_candidate_engine
      ;;
    llm-decision-engine)
      test_llm_decision_engine
      ;;
    llm-execution-engine)
      test_llm_execution_engine
      ;;
    llm-client)
      test_llm_client
      ;;
    llm-rules-bot-bin)
      test_llm_rules_bot_bin
      ;;
    sports-agent|sports-agent-worker)
      test_sports_agent
      ;;
    observability|observability-platform|trace-api|temporal-broker)
      test_observability
      ;;
    *)
      echo "Unknown test suite: $suite" >&2
      usage
      exit 1
      ;;
  esac
}

run_legacy_bots() {
  local mode="${1:-}"

  if [[ -z "$mode" ]]; then
    echo "Missing bots mode. Choose one of: prod | dry-run | check-auth" >&2
    usage
    exit 1
  fi

  case "$mode" in
    prod|dry-run|check-auth) ;;
    *)
      echo "Invalid bots mode: $mode" >&2
      usage
      exit 1
      ;;
  esac

  exec "$RUN_BOTS_SCRIPT" "$mode"
}

temporal_address() {
  echo "${TEMPORAL_ADDRESS:-127.0.0.1:7233}"
}

temporal_ui_url() {
  local ui_ip="${TEMPORAL_UI_IP:-127.0.0.1}"
  local ui_port="${TEMPORAL_UI_PORT:-8233}"
  echo "http://${ui_ip}:${ui_port}"
}

temporal_server_ip() {
  echo "${TEMPORAL_SERVER_IP:-127.0.0.1}"
}

temporal_server_ui_port() {
  echo "${TEMPORAL_UI_PORT:-8233}"
}

resolve_cmd() {
  local name="$1"

  if command -v "$name" >/dev/null 2>&1; then
    command -v "$name"
    return 0
  fi

  if [[ -x "/opt/homebrew/bin/$name" ]]; then
    echo "/opt/homebrew/bin/$name"
    return 0
  fi

  if [[ -x "/usr/local/bin/$name" ]]; then
    echo "/usr/local/bin/$name"
    return 0
  fi

  return 1
}

require_temporal_cli() {
  if ! resolve_cmd temporal >/dev/null 2>&1; then
    echo "Temporal CLI not found. Install with: brew install temporal" >&2
    exit 1
  fi
}

js_runtime() {
  if resolve_cmd node >/dev/null 2>&1; then
    resolve_cmd node
    return 0
  fi
  if resolve_cmd bun >/dev/null 2>&1; then
    resolve_cmd bun
    return 0
  fi
  return 1
}

require_js_runtime() {
  local runtime
  runtime="$(js_runtime || true)"
  if [[ -z "$runtime" ]]; then
    echo "No JS runtime found. Install a JS runtime (for example, Node.js 18+ or Bun) to run observability services." >&2
    echo "macOS install example: brew install node" >&2
    exit 1
  fi
}

docker_compose_bin() {
  local docker_bin
  docker_bin="$(resolve_cmd docker || true)"
  if [[ -z "$docker_bin" ]]; then
    echo "Docker is required for clawdbot-trading commands." >&2
    echo "Install Docker Desktop and retry." >&2
    return 1
  fi
  if ! "$docker_bin" compose version >/dev/null 2>&1; then
    echo "Docker Compose v2 is required for clawdbot-trading commands." >&2
    return 1
  fi
  echo "$docker_bin"
}

clawdbot_trading_compose_file() {
  echo "$ROOT_DIR/clawdbot-workflows/docker-compose.yml"
}

clawdbot_trading_container_id() {
  local docker_bin="$1"
  local compose_file="$2"
  local service="$3"
  "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" ps -q "$service" 2>/dev/null || true
}

clawdbot_trading_service_state() {
  local docker_bin="$1"
  local compose_file="$2"
  local service="$3"

  local container_id
  container_id="$(clawdbot_trading_container_id "$docker_bin" "$compose_file" "$service")"
  if [[ -z "$container_id" ]]; then
    echo "missing"
    return
  fi

  local state
  state="$("$docker_bin" inspect -f '{{.State.Status}}' "$container_id" 2>/dev/null || true)"
  if [[ -z "$state" ]]; then
    echo "unknown"
    return
  fi
  echo "$state"
}

clawdbot_trading_wait_for_required_services() {
  local docker_bin="$1"
  local compose_file="$2"
  local timeout_seconds="${3:-30}"

  local start_epoch now
  start_epoch="$(date +%s)"

  while true; do
    local daemon_state gateway_state
    daemon_state="$(clawdbot_trading_service_state "$docker_bin" "$compose_file" "trading-daemon" || true)"
    gateway_state="$(clawdbot_trading_service_state "$docker_bin" "$compose_file" "openclaw-gateway" || true)"

    if [[ "$daemon_state" == "running" && "$gateway_state" == "running" ]]; then
      local cli_state
      cli_state="$(clawdbot_trading_service_state "$docker_bin" "$compose_file" "openclaw-cli" || true)"

      echo
      echo "Trading bridge services are up:"
      echo "  trading-daemon: $daemon_state"
      echo "  openclaw-gateway: $gateway_state"
      echo "  openclaw-cli: ${cli_state:-unknown} (ephemeral helper container; may be exited)"
      return 0
    fi

    now="$(date +%s)"
    if (( now - start_epoch >= timeout_seconds )); then
      echo >&2
      echo "Timed out waiting for required trading bridge services to be healthy." >&2
      echo "Required services:" >&2
      echo "  trading-daemon: ${daemon_state:-unknown}" >&2
      echo "  openclaw-gateway: ${gateway_state:-unknown}" >&2
      echo >&2
      echo "Recent logs (openclaw-gateway, trading-daemon):" >&2
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" logs --tail=80 openclaw-gateway trading-daemon >&2 || true
      return 1
    fi

    sleep 1
  done
}

dotenv_value() {
  local key="$1"
  local default_value="${2:-}"

  local env_value="${!key:-}"
  if [[ -n "$env_value" ]]; then
    echo "$env_value"
    return
  fi

  local env_file="$ROOT_DIR/.env"
  if [[ -f "$env_file" ]]; then
    local line
    line="$(grep -E "^${key}=" "$env_file" | tail -n 1 || true)"
    if [[ -n "$line" ]]; then
      local value="${line#*=}"
      value="${value%$'\r'}"
      value="${value%\"}"
      value="${value#\"}"
      value="${value%\'}"
      value="${value#\'}"
      echo "$value"
      return
    fi
  fi

  echo "$default_value"
}

gateway_trading_hft_health_ok() {
  local response="$1"

  local jq_bin
  jq_bin="$(resolve_cmd jq || true)"
  if [[ -n "$jq_bin" ]]; then
    if printf '%s' "$response" | "$jq_bin" -e '.ok == true and (.result | type == "object") and .result.ok == true' >/dev/null 2>&1; then
      return 0
    fi
    return 1
  fi

  local node_bin
  node_bin="$(resolve_cmd node || true)"
  if [[ -n "$node_bin" ]]; then
    if printf '%s' "$response" | "$node_bin" -e '
let data = "";
process.stdin.on("data", (chunk) => (data += chunk));
process.stdin.on("end", () => {
  try {
    const parsed = JSON.parse(data);
    process.exit(parsed?.ok === true && parsed?.result?.ok === true ? 0 : 1);
  } catch {
    process.exit(1);
  }
});
' >/dev/null 2>&1; then
      return 0
    fi
    return 1
  fi

  local compact
  compact="$(printf '%s' "$response" | tr -d '[:space:]')"
  [[ "$compact" == *'"ok":true'* && "$compact" == *'"result":{'* && "$compact" == *'"result":{"ok":true'* ]]
}

clawdbot_trading_doctor() {
  local docker_bin="$1"
  local compose_file="$2"
  local failures=0

  local pass="PASS"
  local fail="FAIL"

  echo "Running clawdbot trading doctor..."

  local daemon_state gateway_state
  daemon_state="$(clawdbot_trading_service_state "$docker_bin" "$compose_file" "trading-daemon" || true)"
  gateway_state="$(clawdbot_trading_service_state "$docker_bin" "$compose_file" "openclaw-gateway" || true)"

  if [[ "$daemon_state" == "running" ]]; then
    echo "[$pass] trading-daemon service running"
  else
    echo "[$fail] trading-daemon service not running (state=$daemon_state)" >&2
    failures=$((failures + 1))
  fi

  if [[ "$gateway_state" == "running" ]]; then
    echo "[$pass] openclaw-gateway service running"
  else
    echo "[$fail] openclaw-gateway service not running (state=$gateway_state)" >&2
    failures=$((failures + 1))
  fi

  if [[ "$daemon_state" == "running" ]]; then
    local capabilities_output
    if capabilities_output="$("$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" exec -T trading-daemon tradingctl capabilities 2>&1)"; then
      if echo "$capabilities_output" | grep -q '"protocol_version"'; then
        echo "[$pass] daemon exposes protocol_version in capabilities"
      else
        echo "[$fail] daemon capabilities missing protocol_version" >&2
        failures=$((failures + 1))
      fi

      if echo "$capabilities_output" | grep -q '"status_schema_version"'; then
        echo "[$pass] daemon exposes status_schema_version in capabilities"
      else
        echo "[$fail] daemon capabilities missing status_schema_version" >&2
        failures=$((failures + 1))
      fi

      if echo "$capabilities_output" | grep -q 'Control.Capabilities'; then
        echo "[$pass] daemon advertises Control.Capabilities command support"
      else
        echo "[$fail] daemon command surface does not include Control.Capabilities" >&2
        failures=$((failures + 1))
      fi

      if echo "$capabilities_output" | grep -q 'Engine.GetMode'; then
        echo "[$pass] daemon advertises Engine.GetMode command support"
      else
        echo "[$fail] daemon command surface does not include Engine.GetMode" >&2
        failures=$((failures + 1))
      fi

      if echo "$capabilities_output" | grep -q 'Execution.Place'; then
        echo "[$pass] daemon advertises Execution.Place command support"
      else
        echo "[$fail] daemon command surface does not include Execution.Place" >&2
        failures=$((failures + 1))
      fi

      if echo "$capabilities_output" | grep -q 'Portfolio.Exposure'; then
        echo "[$pass] daemon advertises Portfolio.Exposure command support"
      else
        echo "[$fail] daemon command surface does not include Portfolio.Exposure" >&2
        failures=$((failures + 1))
      fi
    else
      echo "[$fail] tradingctl capabilities command failed" >&2
      echo "$capabilities_output" >&2
      failures=$((failures + 1))
    fi

    local status_output
    if status_output="$("$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" exec -T trading-daemon tradingctl status 2>&1)"; then
      if echo "$status_output" | grep -q '"status_schema_version"'; then
        echo "[$pass] status payload includes status_schema_version"
      else
        echo "[$fail] status payload missing status_schema_version (schema drift)" >&2
        failures=$((failures + 1))
      fi
    else
      echo "[$fail] tradingctl status command failed" >&2
      echo "$status_output" >&2
      failures=$((failures + 1))
    fi

    local mode_output
    if mode_output="$("$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" exec -T trading-daemon tradingctl engine-get-mode 2>&1)"; then
      if echo "$mode_output" | grep -q '"mode"'; then
        echo "[$pass] engine mode endpoint responds with mode payload"
      else
        echo "[$fail] engine-get-mode missing mode payload" >&2
        failures=$((failures + 1))
      fi
    else
      echo "[$fail] tradingctl engine-get-mode command failed" >&2
      echo "$mode_output" >&2
      failures=$((failures + 1))
    fi
  fi

  if [[ "$gateway_state" == "running" ]]; then
    local curl_bin
    curl_bin="$(resolve_cmd curl || true)"
    if [[ -z "$curl_bin" ]]; then
      echo "[$fail] curl not found; cannot verify gateway trading_hft tool availability" >&2
      failures=$((failures + 1))
    else
      local gateway_port gateway_token gateway_response
      gateway_port="$(dotenv_value OPENCLAW_GATEWAY_PORT 18789)"
      gateway_token="$(dotenv_value OPENCLAW_GATEWAY_TOKEN "")"

      if [[ -z "$gateway_token" ]]; then
        echo "[$fail] OPENCLAW_GATEWAY_TOKEN is empty; cannot call /tools/invoke" >&2
        failures=$((failures + 1))
      else
        if gateway_response="$("$curl_bin" -fsS -X POST "http://127.0.0.1:${gateway_port}/tools/invoke" \
          -H "content-type: application/json" \
          -H "authorization: Bearer ${gateway_token}" \
          --data '{"tool":"trading_hft","action":"json","args":{"action":"health"}}' 2>&1)"; then
          if echo "$gateway_response" | grep -q 'Tool not available: trading_hft'; then
            echo "[$fail] trading_hft tool is not registered in gateway runtime" >&2
            failures=$((failures + 1))
          elif gateway_trading_hft_health_ok "$gateway_response"; then
            echo "[$pass] trading_hft tool is available and returns healthy result via gateway /tools/invoke"
          else
            echo "[$fail] gateway response did not confirm trading_hft readiness" >&2
            echo "$gateway_response" >&2
            failures=$((failures + 1))
          fi
        else
          echo "[$fail] failed to call gateway /tools/invoke trading_hft health" >&2
          echo "$gateway_response" >&2
          failures=$((failures + 1))
        fi

        local gateway_mode_response
        if gateway_mode_response="$("$curl_bin" -fsS -X POST "http://127.0.0.1:${gateway_port}/tools/invoke" \
          -H "content-type: application/json" \
          -H "authorization: Bearer ${gateway_token}" \
          --data '{"tool":"trading_hft","action":"json","args":{"action":"engine_get_mode"}}' 2>&1)"; then
          if echo "$gateway_mode_response" | grep -q '"ok":true'; then
            echo "[$pass] trading_hft engine_get_mode action responds via gateway /tools/invoke"
          else
            echo "[$fail] gateway engine_get_mode action did not return ok=true" >&2
            echo "$gateway_mode_response" >&2
            failures=$((failures + 1))
          fi
        else
          echo "[$fail] failed to call gateway /tools/invoke trading_hft engine_get_mode" >&2
          echo "$gateway_mode_response" >&2
          failures=$((failures + 1))
        fi

        local gateway_open_orders_response
        if gateway_open_orders_response="$("$curl_bin" -fsS -X POST "http://127.0.0.1:${gateway_port}/tools/invoke" \
          -H "content-type: application/json" \
          -H "authorization: Bearer ${gateway_token}" \
          --data '{"tool":"trading_hft","action":"json","args":{"action":"execution_open_orders"}}' 2>&1)"; then
          if echo "$gateway_open_orders_response" | grep -q '"ok":true'; then
            echo "[$pass] trading_hft execution_open_orders action responds via gateway /tools/invoke"
          else
            echo "[$fail] gateway execution_open_orders action did not return ok=true" >&2
            echo "$gateway_open_orders_response" >&2
            failures=$((failures + 1))
          fi
        else
          echo "[$fail] failed to call gateway /tools/invoke trading_hft execution_open_orders" >&2
          echo "$gateway_open_orders_response" >&2
          failures=$((failures + 1))
        fi
      fi
    fi
  fi

  if (( failures > 0 )); then
    echo "Doctor completed with $failures failure(s)." >&2
    return 1
  fi

  echo "Doctor completed successfully."
}

run_clawdbot_trading() {
  local action="${1:-status}"
  shift || true

  local docker_bin compose_file
  docker_bin="$(docker_compose_bin)" || exit 1
  compose_file="$(clawdbot_trading_compose_file)"

  case "$action" in
    up)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for clawdbot-trading up command" >&2
        echo "Use: ./trading-cli clawdbot-trading up" >&2
        exit 1
      fi
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" up -d --build
      local timeout_seconds="${CLAWDBOT_TRADING_UP_TIMEOUT_SECONDS:-30}"
      clawdbot_trading_wait_for_required_services "$docker_bin" "$compose_file" "$timeout_seconds"
      ;;
    down)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for clawdbot-trading down command" >&2
        echo "Use: ./trading-cli clawdbot-trading down" >&2
        exit 1
      fi
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" down
      ;;
    ps|services)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for clawdbot-trading ps command" >&2
        echo "Use: ./trading-cli clawdbot-trading ps" >&2
        exit 1
      fi
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" ps
      ;;
    logs)
      local service="${1:-trading-daemon}"
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for clawdbot-trading logs command" >&2
        echo "Use: ./trading-cli clawdbot-trading logs [trading-daemon|openclaw-gateway|openclaw-cli]" >&2
        exit 1
      fi
      case "$service" in
        trading-daemon|openclaw-gateway|openclaw-cli) ;;
        *)
          echo "Unknown clawdbot-trading service: $service" >&2
          echo "Use: ./trading-cli clawdbot-trading logs [trading-daemon|openclaw-gateway|openclaw-cli]" >&2
          exit 1
          ;;
      esac
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" logs -f "$service"
      ;;
    doctor)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for clawdbot-trading doctor command" >&2
        echo "Use: ./trading-cli clawdbot-trading doctor" >&2
        exit 1
      fi
      clawdbot_trading_doctor "$docker_bin" "$compose_file"
      ;;
    ping|status|capabilities|start|stop)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for clawdbot-trading $action command" >&2
        echo "Use: ./trading-cli clawdbot-trading $action" >&2
        exit 1
      fi
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" exec trading-daemon tradingctl "$action"
      ;;
    venue-list|venue-enable|venue-disable|venue-status|portfolio-balances|portfolio-positions|order-submit|order-cancel|order-list|execution-mode-get|execution-mode-set)
      "$docker_bin" compose -f "$compose_file" --project-directory "$ROOT_DIR" exec trading-daemon tradingctl "$action" "$@"
      ;;
    *)
      echo "Unknown clawdbot-trading action: $action" >&2
      echo "Use: ./trading-cli clawdbot-trading [up|down|ps|logs|ping|status|capabilities|doctor|start|stop|venue-list|venue-status|venue-enable|venue-disable|portfolio-balances|portfolio-positions|order-list|order-cancel|order-submit|execution-mode-get|execution-mode-set]" >&2
      exit 1
      ;;
  esac
}

temporal_reachable() {
  local temporal_bin
  temporal_bin="$(resolve_cmd temporal || true)"
  if [[ -z "$temporal_bin" ]]; then
    return 1
  fi
  "$temporal_bin" workflow list --address "$(temporal_address)" --limit 1 >/dev/null 2>&1
}

workflow_mode_to_arg() {
  local mode="$1"
  case "$mode" in
    prod)
      echo ""
      ;;
    dry-run)
      echo "--dry-run"
      ;;
    check-auth)
      echo "--check-auth"
      ;;
    *)
      return 1
      ;;
  esac
}

run_in_dir() {
  local workdir="$1"
  shift
  (
    cd "$workdir"
    exec "$@"
  )
}

pidfile_for() {
  local service="$1"
  echo "$DEV_DIR/${service}.pid"
}

logfile_for() {
  local service="$1"
  echo "$LOG_DIR/${service}.log"
}

is_pid_running() {
  local pid="$1"
  kill -0 "$pid" 2>/dev/null
}

service_status_line() {
  local service="$1"
  local pidfile
  pidfile="$(pidfile_for "$service")"
  if [[ ! -f "$pidfile" ]]; then
    printf "%-13s stopped\n" "$service"
    return
  fi

  local pid
  pid="$(cat "$pidfile" 2>/dev/null || true)"
  if [[ -z "$pid" ]]; then
    printf "%-13s stopped\n" "$service"
    rm -f "$pidfile"
    return
  fi

  if is_pid_running "$pid"; then
    printf "%-13s running (pid=%s)\n" "$service" "$pid"
  else
    printf "%-13s stopped (stale pid cleaned)\n" "$service"
    rm -f "$pidfile"
  fi
}

start_service_bg() {
  local service="$1"
  local workdir="$2"
  shift 2
  local pidfile logfile
  pidfile="$(pidfile_for "$service")"
  logfile="$(logfile_for "$service")"

  if [[ -f "$pidfile" ]]; then
    local existing_pid
    existing_pid="$(cat "$pidfile" 2>/dev/null || true)"
    if [[ -n "$existing_pid" ]] && is_pid_running "$existing_pid"; then
      echo "$service already running (pid=$existing_pid)." >&2
      return 1
    fi
    rm -f "$pidfile"
  fi

  (
    cd "$workdir"
    exec "$@"
  ) >"$logfile" 2>&1 &

  local pid="$!"
  echo "$pid" > "$pidfile"

  # Quick liveness check for early crashes.
  sleep 0.3
  if ! is_pid_running "$pid"; then
    echo "Failed to start $service. Check log: $logfile" >&2
    tail -n 40 "$logfile" 2>/dev/null || true
    rm -f "$pidfile"
    return 1
  fi

  echo "Started $service (pid=$pid, log=$logfile)"
  return 0
}

run_dev() {
  mkdir -p "$LOG_DIR"

  if ! start_service_bg "weather" "$ROOT_DIR/non-agent-workflows/weather-bot" cargo run -- --dry-run; then
    echo "dev startup failed while starting weather" >&2
    run_down >/dev/null 2>&1 || true
    exit 1
  fi
  if ! start_service_bg "arbitrage" "$ROOT_DIR/non-agent-workflows/arbitrage-bot" cargo run --release -- --dry-run; then
    echo "dev startup failed while starting arbitrage" >&2
    run_down >/dev/null 2>&1 || true
    exit 1
  fi
  if ! start_service_bg "llm-workflow" "$ROOT_DIR/llm-workflows/llm-rules-bot" cargo run; then
    echo "dev startup failed while starting llm-workflow" >&2
    run_down >/dev/null 2>&1 || true
    exit 1
  fi

  echo
  echo "Development services are up."
  run_status
}

stop_service_bg() {
  local service="$1"
  local pidfile
  pidfile="$(pidfile_for "$service")"
  if [[ ! -f "$pidfile" ]]; then
    echo "$service already stopped"
    return
  fi

  local pid
  pid="$(cat "$pidfile" 2>/dev/null || true)"
  if [[ -z "$pid" ]]; then
    rm -f "$pidfile"
    echo "$service already stopped"
    return
  fi

  if ! is_pid_running "$pid"; then
    rm -f "$pidfile"
    echo "$service already stopped (stale pid removed)"
    return
  fi

  kill "$pid" 2>/dev/null || true
  local i
  for i in {1..20}; do
    if ! is_pid_running "$pid"; then
      break
    fi
    sleep 0.2
  done

  if is_pid_running "$pid"; then
    echo "Force stopping $service (pid=$pid)"
    kill -9 "$pid" 2>/dev/null || true
  fi

  rm -f "$pidfile"
  echo "Stopped $service"
}

run_down() {
  stop_service_bg "weather"
  stop_service_bg "arbitrage"
  stop_service_bg "llm-workflow"
  stop_service_bg "sports-agent"
  stop_service_bg "trace-api"
  stop_service_bg "temporal-broker"
  stop_service_bg "temporal"
}

run_status() {
  echo "Service status:"
  service_status_line "weather"
  service_status_line "arbitrage"
  service_status_line "llm-workflow"
  service_status_line "sports-agent"
  service_status_line "trace-api"
  service_status_line "temporal-broker"
  service_status_line "temporal"
}

run_service_logs() {
  local service="$1"
  local logfile
  logfile="$(logfile_for "$service")"
  if [[ ! -f "$logfile" ]]; then
    echo "No log file for $service yet. Start it first and then retry." >&2
    exit 1
  fi
  exec tail -n 120 -f "$logfile"
}

run_weather() {
  local action="${1:-go}"
  local mode="${2:-dry-run}"
  local mode_arg
  if [[ $# -gt 2 ]]; then
    echo "Too many arguments for weather command" >&2
    echo "Use: ./trading-cli weather [go|up|down|status|logs] [prod|dry-run|check-auth]" >&2
    exit 1
  fi

  case "$action" in
    go|run)
      if ! mode_arg="$(workflow_mode_to_arg "$mode")"; then
        echo "Invalid weather mode: $mode" >&2
        usage
        exit 1
      fi
      if [[ -n "$mode_arg" ]]; then
        run_in_dir "$ROOT_DIR/non-agent-workflows/weather-bot" cargo run -- "$mode_arg"
      else
        run_in_dir "$ROOT_DIR/non-agent-workflows/weather-bot" cargo run
      fi
      ;;
    up|start)
      if ! mode_arg="$(workflow_mode_to_arg "$mode")"; then
        echo "Invalid weather mode: $mode" >&2
        usage
        exit 1
      fi
      mkdir -p "$LOG_DIR"
      if [[ -n "$mode_arg" ]]; then
        if ! start_service_bg "weather" "$ROOT_DIR/non-agent-workflows/weather-bot" cargo run -- "$mode_arg"; then
          exit 1
        fi
      else
        if ! start_service_bg "weather" "$ROOT_DIR/non-agent-workflows/weather-bot" cargo run; then
          exit 1
        fi
      fi
      ;;
    down|stop)
      stop_service_bg "weather"
      ;;
    status)
      service_status_line "weather"
      ;;
    logs)
      run_service_logs "weather"
      ;;
    prod|dry-run|check-auth)
      if [[ $# -gt 1 ]]; then
        echo "Mode shorthand takes one argument: ./trading-cli weather <prod|dry-run|check-auth>" >&2
        exit 1
      fi
      run_weather go "$action"
      ;;
    *)
      echo "Unknown weather action: $action" >&2
      echo "Use: ./trading-cli weather [go|up|down|status|logs] [prod|dry-run|check-auth]" >&2
      exit 1
      ;;
  esac
}

run_arbitrage() {
  local action="${1:-go}"
  local mode="${2:-dry-run}"
  local mode_arg
  if [[ $# -gt 2 ]]; then
    echo "Too many arguments for arbitrage command" >&2
    echo "Use: ./trading-cli arbitrage [go|up|down|status|logs] [prod|dry-run|check-auth]" >&2
    exit 1
  fi

  case "$action" in
    go|run)
      if ! mode_arg="$(workflow_mode_to_arg "$mode")"; then
        echo "Invalid arbitrage mode: $mode" >&2
        usage
        exit 1
      fi
      if [[ -n "$mode_arg" ]]; then
        run_in_dir "$ROOT_DIR/non-agent-workflows/arbitrage-bot" cargo run --release -- "$mode_arg"
      else
        run_in_dir "$ROOT_DIR/non-agent-workflows/arbitrage-bot" cargo run --release
      fi
      ;;
    up|start)
      if ! mode_arg="$(workflow_mode_to_arg "$mode")"; then
        echo "Invalid arbitrage mode: $mode" >&2
        usage
        exit 1
      fi
      mkdir -p "$LOG_DIR"
      if [[ -n "$mode_arg" ]]; then
        if ! start_service_bg "arbitrage" "$ROOT_DIR/non-agent-workflows/arbitrage-bot" cargo run --release -- "$mode_arg"; then
          exit 1
        fi
      else
        if ! start_service_bg "arbitrage" "$ROOT_DIR/non-agent-workflows/arbitrage-bot" cargo run --release; then
          exit 1
        fi
      fi
      ;;
    down|stop)
      stop_service_bg "arbitrage"
      ;;
    status)
      service_status_line "arbitrage"
      ;;
    logs)
      run_service_logs "arbitrage"
      ;;
    prod|dry-run|check-auth)
      if [[ $# -gt 1 ]]; then
        echo "Mode shorthand takes one argument: ./trading-cli arbitrage <prod|dry-run|check-auth>" >&2
        exit 1
      fi
      run_arbitrage go "$action"
      ;;
    *)
      echo "Unknown arbitrage action: $action" >&2
      echo "Use: ./trading-cli arbitrage [go|up|down|status|logs] [prod|dry-run|check-auth]" >&2
      exit 1
      ;;
  esac
}

run_llm_workflow() {
  local action="${1:-go}"
  if [[ $# -gt 1 ]]; then
    echo "Too many arguments for llm-workflow command" >&2
    echo "Use: ./trading-cli llm-workflow [go|up|down|status|logs]" >&2
    exit 1
  fi

  case "$action" in
    go|run)
      run_in_dir "$ROOT_DIR/llm-workflows/llm-rules-bot" cargo run
      ;;
    up|start)
      mkdir -p "$LOG_DIR"
      if ! start_service_bg "llm-workflow" "$ROOT_DIR/llm-workflows/llm-rules-bot" cargo run; then
        exit 1
      fi
      ;;
    down|stop)
      stop_service_bg "llm-workflow"
      ;;
    status)
      service_status_line "llm-workflow"
      ;;
    logs)
      run_service_logs "llm-workflow"
      ;;
    *)
      echo "Unknown llm-workflow action: $action" >&2
      echo "Use: ./trading-cli llm-workflow [go|up|down|status|logs]" >&2
      exit 1
      ;;
  esac
}

run_temporal() {
  local action="${1:-status}"
  shift || true
  local temporal_bin
  temporal_bin="$(resolve_cmd temporal || true)"

  case "$action" in
    up|start)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for temporal command" >&2
        echo "Use: ./trading-cli temporal [up|down|status|logs|ui|list|describe|show]" >&2
        exit 1
      fi
      require_temporal_cli
      mkdir -p "$LOG_DIR"
      local server_ip ui_port
      server_ip="$(temporal_server_ip)"
      ui_port="$(temporal_server_ui_port)"
      if temporal_reachable; then
        echo "Temporal server already reachable at $(temporal_address) (external process)."
        echo "Temporal UI: $(temporal_ui_url)"
        return 0
      fi
      if ! start_service_bg "temporal" "$ROOT_DIR" "$temporal_bin" server start-dev --ip "$server_ip" --ui-port "$ui_port"; then
        exit 1
      fi
      echo "Temporal address: $(temporal_address)"
      echo "Temporal UI: $(temporal_ui_url)"
      ;;
    down|stop)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for temporal command" >&2
        echo "Use: ./trading-cli temporal down" >&2
        exit 1
      fi
      stop_service_bg "temporal"
      ;;
    status)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for temporal command" >&2
        echo "Use: ./trading-cli temporal status" >&2
        exit 1
      fi
      service_status_line "temporal"
      echo "Temporal address: $(temporal_address)"
      echo "Temporal UI: $(temporal_ui_url)"
      if [[ -n "$temporal_bin" ]]; then
        if temporal_reachable; then
          echo "Temporal reachable: yes"
        else
          echo "Temporal reachable: no"
        fi
      else
        echo "Temporal reachable: unknown (temporal CLI not installed)"
      fi
      ;;
    logs)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for temporal command" >&2
        echo "Use: ./trading-cli temporal logs" >&2
        exit 1
      fi
      run_service_logs "temporal"
      ;;
    ui)
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for temporal ui command" >&2
        echo "Use: ./trading-cli temporal ui [open]" >&2
        exit 1
      fi
      local ui_url
      ui_url="$(temporal_ui_url)"
      echo "$ui_url"
      if [[ "${1:-}" == "open" ]]; then
        if command -v open >/dev/null 2>&1; then
          open "$ui_url"
        else
          echo "Open this URL in your browser: $ui_url" >&2
        fi
      fi
      ;;
    list)
      require_temporal_cli
      "$temporal_bin" workflow list --address "$(temporal_address)" "$@"
      ;;
    describe)
      require_temporal_cli
      local workflow_id="${1:-}"
      if [[ -z "$workflow_id" ]]; then
        echo "Missing workflow id. Use: ./trading-cli temporal describe <workflow_id>" >&2
        exit 1
      fi
      shift || true
      "$temporal_bin" workflow describe --workflow-id "$workflow_id" --address "$(temporal_address)" "$@"
      ;;
    show)
      require_temporal_cli
      local workflow_id="${1:-}"
      if [[ -z "$workflow_id" ]]; then
        echo "Missing workflow id. Use: ./trading-cli temporal show <workflow_id>" >&2
        exit 1
      fi
      shift || true
      "$temporal_bin" workflow show --workflow-id "$workflow_id" --address "$(temporal_address)" "$@"
      ;;
    *)
      echo "Unknown temporal action: $action" >&2
      echo "Use: ./trading-cli temporal [up|down|status|logs|ui|list|describe|show]" >&2
      exit 1
      ;;
  esac
}

run_observability() {
  local action="${1:-status}"
  shift || true

  case "$action" in
    up|start)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for observability up command" >&2
        echo "Use: ./trading-cli observability up" >&2
        exit 1
      fi

      require_js_runtime
      run_temporal up
      mkdir -p "$LOG_DIR"
      local runtime
      runtime="$(js_runtime)"

      if ! start_service_bg "temporal-broker" "$ROOT_DIR/observability-platform/temporal-broker" "$runtime" broker.mjs; then
        exit 1
      fi
      if ! start_service_bg "trace-api" "$ROOT_DIR/observability-platform/trace-api" "$runtime" server.mjs; then
        exit 1
      fi

      echo "Observability dashboard: http://127.0.0.1:${TRACE_API_PORT:-8791}"
      echo "Temporal UI: $(temporal_ui_url)"
      ;;
    down|stop)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for observability down command" >&2
        echo "Use: ./trading-cli observability down" >&2
        exit 1
      fi
      stop_service_bg "trace-api"
      stop_service_bg "temporal-broker"
      run_temporal down
      ;;
    status)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for observability status command" >&2
        echo "Use: ./trading-cli observability status" >&2
        exit 1
      fi
      service_status_line "trace-api"
      service_status_line "temporal-broker"
      run_temporal status
      echo "Observability dashboard: http://127.0.0.1:${TRACE_API_PORT:-8791}"
      ;;
    logs)
      local service="${1:-trace-api}"
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for observability logs command" >&2
        echo "Use: ./trading-cli observability logs [trace-api|temporal-broker|temporal]" >&2
        exit 1
      fi
      case "$service" in
        trace-api|temporal-broker)
          run_service_logs "$service"
          ;;
        temporal)
          run_temporal logs
          ;;
        *)
          echo "Unknown observability service: $service" >&2
          echo "Use: ./trading-cli observability logs [trace-api|temporal-broker|temporal]" >&2
          exit 1
          ;;
      esac
      ;;
    ui)
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for observability ui command" >&2
        echo "Use: ./trading-cli observability ui [open]" >&2
        exit 1
      fi
      local dashboard_url="http://127.0.0.1:${TRACE_API_PORT:-8791}"
      echo "Observability dashboard: $dashboard_url"
      echo "Temporal UI: $(temporal_ui_url)"
      if [[ "${1:-}" == "open" ]]; then
        if command -v open >/dev/null 2>&1; then
          open "$dashboard_url"
          open "$(temporal_ui_url)"
        else
          echo "Open in browser:" >&2
          echo "  $dashboard_url" >&2
          echo "  $(temporal_ui_url)" >&2
        fi
      fi
      ;;
    *)
      echo "Unknown observability action: $action" >&2
      echo "Use: ./trading-cli observability [up|down|status|logs|ui]" >&2
      exit 1
      ;;
  esac
}

observability_api_url() {
  echo "http://127.0.0.1:${TRACE_API_PORT:-8791}"
}

observability_project() {
  echo "${OBS_PROJECT:-local}"
}

observability_location() {
  echo "${OBS_LOCATION:-us-central1}"
}

observability_control_token() {
  echo "${OBS_CONTROL_TOKEN:-local-dev-token}"
}

json_escape() {
  local input="$1"
  input="${input//\\/\\\\}"
  input="${input//\"/\\\"}"
  input="${input//$'\n'/\\n}"
  input="${input//$'\r'/\\r}"
  input="${input//$'\t'/\\t}"
  echo "$input"
}

sports_agent_control_request() {
  local method="$1"
  local endpoint="$2"
  local payload="$3"

  local curl_bin
  curl_bin="$(resolve_cmd curl || true)"
  if [[ -z "$curl_bin" ]]; then
    echo "curl is required for sports-agent control commands" >&2
    return 1
  fi

  "$curl_bin" -fsS \
    -X "$method" \
    "$(observability_api_url)$endpoint" \
    -H "authorization: Bearer $(observability_control_token)" \
    -H "content-type: application/json" \
    -d "$payload"
}

sports_agent_workflow_action() {
  local workflow_id="$1"
  local action="$2"
  local reason="$3"

  local project location request_id payload
  project="$(observability_project)"
  location="$(observability_location)"
  request_id="trading-cli-$(date +%s)-$RANDOM"
  payload="{\"actor\":\"trading-cli\",\"reason\":\"$(json_escape "$reason")\",\"requestId\":\"$(json_escape "$request_id")\"}"

  sports_agent_control_request \
    POST \
    "/v1/projects/${project}/locations/${location}/workflows/${workflow_id}:${action}" \
    "$payload"
  echo
}

sports_agent_stop_service_action() {
  local project location request_id payload
  project="$(observability_project)"
  location="$(observability_location)"
  request_id="trading-cli-$(date +%s)-$RANDOM"
  payload="{\"actor\":\"trading-cli\",\"reason\":\"manual service stop from trading-cli\",\"requestId\":\"$(json_escape "$request_id")\"}"

  sports_agent_control_request \
    POST \
    "/v1/projects/${project}/locations/${location}/services/sports-agent:stop" \
    "$payload"
  echo
}

run_sports_agent() {
  local action="${1:-go}"
  shift || true

  case "$action" in
    go|run|up|start)
      local mode="hitl"
      local dry_run_flag=0

      while [[ $# -gt 0 ]]; do
        case "$1" in
          --mode)
            mode="${2:-}"
            shift 2
            ;;
          --dry-run)
            dry_run_flag=1
            shift
            ;;
          *)
            echo "Unknown sports-agent option: $1" >&2
            echo "Use: ./trading-cli sports-agent [go|up] [--mode <hitl|auto_ultra_strict>] [--dry-run]" >&2
            exit 1
            ;;
        esac
      done

      case "$mode" in
        hitl|auto_ultra_strict) ;;
        *)
          echo "Invalid sports-agent mode: $mode" >&2
          echo "Use --mode <hitl|auto_ultra_strict>" >&2
          exit 1
          ;;
      esac

      local cmd=(cargo run -- --mode "$mode")
      if [[ "$dry_run_flag" -eq 1 ]]; then
        cmd+=(--dry-run)
      fi

      if [[ "$action" == "up" || "$action" == "start" ]]; then
        mkdir -p "$LOG_DIR"
        if ! start_service_bg "sports-agent" "$ROOT_DIR/observability-platform/sports-agent-worker" "${cmd[@]}"; then
          exit 1
        fi
      else
        run_in_dir "$ROOT_DIR/observability-platform/sports-agent-worker" "${cmd[@]}"
      fi
      ;;
    down|stop)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for sports-agent down command" >&2
        echo "Use: ./trading-cli sports-agent down" >&2
        exit 1
      fi
      stop_service_bg "sports-agent"
      ;;
    status)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for sports-agent status command" >&2
        echo "Use: ./trading-cli sports-agent status" >&2
        exit 1
      fi
      service_status_line "sports-agent"
      ;;
    logs)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for sports-agent logs command" >&2
        echo "Use: ./trading-cli sports-agent logs" >&2
        exit 1
      fi
      run_service_logs "sports-agent"
      ;;
    execute|approve)
      local workflow_id="${1:-}"
      if [[ -z "$workflow_id" ]]; then
        echo "Missing workflow/trace id. Use: ./trading-cli sports-agent execute <workflow_id_or_trace_id>" >&2
        exit 1
      fi
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for sports-agent execute command" >&2
        echo "Use: ./trading-cli sports-agent execute <workflow_id_or_trace_id>" >&2
        exit 1
      fi
      sports_agent_workflow_action "$workflow_id" "execute" "manual execute from trading-cli"
      ;;
    cancel)
      local workflow_id="${1:-}"
      if [[ -z "$workflow_id" ]]; then
        echo "Missing workflow id. Use: ./trading-cli sports-agent cancel <workflow_id_or_trace_id> [--hard]" >&2
        exit 1
      fi
      shift || true

      local hard_cancel_flag=0
      while [[ $# -gt 0 ]]; do
        case "$1" in
          --hard)
            hard_cancel_flag=1
            shift
            ;;
          *)
            echo "Unknown sports-agent cancel option: $1" >&2
            echo "Use: ./trading-cli sports-agent cancel <workflow_id_or_trace_id> [--hard]" >&2
            exit 1
            ;;
        esac
      done

      if [[ "$hard_cancel_flag" -eq 1 ]]; then
        sports_agent_workflow_action "$workflow_id" "hardCancel" "manual hard cancel from trading-cli"
      else
        sports_agent_workflow_action "$workflow_id" "cancel" "manual soft cancel from trading-cli"
      fi
      ;;
    hard-cancel)
      local workflow_id="${1:-}"
      if [[ -z "$workflow_id" ]]; then
        echo "Missing workflow id. Use: ./trading-cli sports-agent hard-cancel <workflow_id_or_trace_id>" >&2
        exit 1
      fi
      if [[ $# -gt 1 ]]; then
        echo "Too many arguments for sports-agent hard-cancel command" >&2
        echo "Use: ./trading-cli sports-agent hard-cancel <workflow_id_or_trace_id>" >&2
        exit 1
      fi
      sports_agent_workflow_action "$workflow_id" "hardCancel" "manual hard cancel from trading-cli"
      ;;
    stop-service)
      if [[ $# -gt 0 ]]; then
        echo "Too many arguments for sports-agent stop-service command" >&2
        echo "Use: ./trading-cli sports-agent stop-service" >&2
        exit 1
      fi
      sports_agent_stop_service_action
      ;;
    *)
      echo "Unknown sports-agent action: $action" >&2
      echo "Use: ./trading-cli sports-agent [go|up|down|status|logs|approve|execute|cancel|hard-cancel|stop-service] [--mode <hitl|auto_ultra_strict>] [--dry-run]" >&2
      exit 1
      ;;
  esac
}

main() {
  local cmd="${1:-}"
  shift || true

  if [[ -z "$cmd" ]]; then
    usage
    exit 0
  fi

  case "$cmd" in
    test)
      run_tests "${1:-all}"
      ;;
    weather)
      run_weather "$@"
      ;;
    arbitrage|arb)
      run_arbitrage "$@"
      ;;
    llm-workflow|llm)
      run_llm_workflow "$@"
      ;;
    temporal|temp)
      run_temporal "$@"
      ;;
    observability|observe|obs)
      run_observability "$@"
      ;;
    sports-agent|sports)
      run_sports_agent "$@"
      ;;
    clawdbot-trading)
      run_clawdbot_trading "$@"
      ;;
    clawdbot-trading-up)
      run_clawdbot_trading up "$@"
      ;;
    clawdbot-trading-down)
      run_clawdbot_trading down "$@"
      ;;
    clawdbot-trading-ps)
      run_clawdbot_trading ps "$@"
      ;;
    clawdbot-trading-logs)
      run_clawdbot_trading logs "$@"
      ;;
    clawdbot-trading-ping)
      run_clawdbot_trading ping "$@"
      ;;
    clawdbot-trading-status)
      run_clawdbot_trading status "$@"
      ;;
    clawdbot-trading-capabilities)
      run_clawdbot_trading capabilities "$@"
      ;;
    clawdbot-trading-doctor)
      run_clawdbot_trading doctor "$@"
      ;;
    clawdbot-trading-start)
      run_clawdbot_trading start "$@"
      ;;
    clawdbot-trading-stop)
      run_clawdbot_trading stop "$@"
      ;;
    clawdbot-trading-venue-list)
      run_clawdbot_trading venue-list "$@"
      ;;
    clawdbot-trading-portfolio-balances)
      run_clawdbot_trading portfolio-balances "$@"
      ;;
    clawdbot-trading-portfolio-positions)
      run_clawdbot_trading portfolio-positions "$@"
      ;;
    dev)
      run_dev
      ;;
    down)
      run_down
      ;;
    status)
      run_status
      ;;
    bots)
      run_legacy_bots "${1:-}"
      ;;
    help|-h|--help)
      usage
      ;;
    *)
      echo "Unknown command: $cmd" >&2
      local suggestion
      suggestion="$(suggest_command "$cmd" || true)"
      if [[ -n "$suggestion" ]]; then
        echo "Did you mean: ./trading-cli $suggestion" >&2
      fi
      echo >&2
      usage
      exit 1
      ;;
  esac
}

main "$@"