npm - agent-control-plane - Versions diffs - 0.6.0 → 0.7.0 - Mend

agent-control-plane 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +38 -5
package/package.json +1 -1
package/tools/bin/flow-config-lib.sh +13 -3508
package/tools/bin/flow-execution-lib.sh +243 -0
package/tools/bin/flow-forge-lib.sh +1770 -0
package/tools/bin/flow-profile-lib.sh +335 -0
package/tools/bin/flow-provider-lib.sh +981 -0
package/tools/bin/flow-session-lib.sh +317 -0
package/tools/dashboard/app.js +40 -3
package/tools/dashboard/requirements.txt +3 -0
package/tools/dashboard/server.py +250 -152

package/tools/bin/flow-config-lib.sh CHANGED Viewed

@@ -2,3515 +2,20 @@
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Core shell library (required by all modules)
 # shellcheck source=/dev/null
 source "${SCRIPT_DIR}/flow-shell-lib.sh"
 flow_export_project_env_aliases
-flow_explicit_github_repo_id() {
-  local requested_repo_slug="${1:-}"
-  local configured_repo_slug="${ACP_REPO_SLUG:-${F_LOSNING_REPO_SLUG:-}}"
-  local explicit_repo_id="${ACP_REPO_ID:-${F_LOSNING_REPO_ID:-${ACP_GITHUB_REPOSITORY_ID:-${F_LOSNING_GITHUB_REPOSITORY_ID:-}}}}"
-  [[ -n "${explicit_repo_id}" ]] || return 1
-  if [[ -n "${requested_repo_slug}" && -n "${configured_repo_slug}" && "${configured_repo_slug}" != "${requested_repo_slug}" ]]; then
-    return 1
-  fi
-  printf '%s\n' "${explicit_repo_id}"
-}
-flow_explicit_profile_id() {
-  printf '%s\n' "${ACP_PROJECT_ID:-${AGENT_PROJECT_ID:-}}"
-}
-resolve_flow_profile_registry_root() {
-  local platform_home="${AGENT_PLATFORM_HOME:-${HOME}/.agent-runtime}"
-  printf '%s\n' "${AGENT_CONTROL_PLANE_PROFILE_ROOT:-${ACP_PROFILE_REGISTRY_ROOT:-${platform_home}/control-plane/profiles}}"
-}
-flow_list_profiles_in_root() {
-  local profiles_root="${1:-}"
-  local profile_file=""
-  local profile_id=""
-  [[ -d "${profiles_root}" ]] || return 0
-  while IFS= read -r profile_file; do
-    [[ -n "${profile_file}" ]] || continue
-    profile_id="$(basename "$(dirname "${profile_file}")")"
-    [[ -n "${profile_id}" ]] || continue
-    printf '%s\n' "${profile_id}"
-  done < <(find "${profiles_root}" -mindepth 2 -maxdepth 2 -type f -name 'control-plane.yaml' 2>/dev/null | sort)
-}
-flow_list_installed_profile_ids() {
-  flow_list_profiles_in_root "$(resolve_flow_profile_registry_root)"
-}
-flow_find_profile_dir_by_id() {
-  local flow_root="${1:-}"
-  local profile_id="${2:?profile id required}"
-  local registry_root=""
-  local candidate=""
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  registry_root="$(resolve_flow_profile_registry_root)"
-  candidate="${registry_root}/${profile_id}"
-  if [[ -f "${candidate}/control-plane.yaml" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  printf '%s/%s\n' "${registry_root}" "${profile_id}"
-}
-flow_profile_count() {
-  local flow_root="${1:-}"
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_list_profile_ids "${flow_root}" | awk 'NF { count += 1 } END { print count + 0 }'
-}
-flow_default_profile_id() {
-  local flow_root="${1:-}"
-  local preferred_profile="${AGENT_CONTROL_PLANE_DEFAULT_PROFILE_ID:-${ACP_DEFAULT_PROFILE_ID:-${AGENT_PROJECT_DEFAULT_PROFILE_ID:-}}}"
-  local candidate=""
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  for candidate in "${preferred_profile}" "default"; do
-    [[ -n "${candidate}" ]] || continue
-    if [[ -f "$(flow_find_profile_dir_by_id "${flow_root}" "${candidate}")/control-plane.yaml" ]]; then
-      printf '%s\n' "${candidate}"
-      return 0
-    fi
-  done
-  candidate="$(flow_list_profile_ids "${flow_root}" | grep -v '^demo$' | head -n 1 || true)"
-  if [[ -n "${candidate}" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  candidate="$(flow_list_profile_ids "${flow_root}" | head -n 1 || true)"
-  if [[ -n "${candidate}" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  printf 'default\n'
-}
-flow_profile_selection_mode() {
-  local flow_root="${1:-}"
-  local explicit_profile=""
-  local profile_count="0"
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  explicit_profile="$(flow_explicit_profile_id)"
-  if [[ -n "${explicit_profile}" ]]; then
-    printf 'explicit\n'
-    return 0
-  fi
-  profile_count="$(flow_profile_count "${flow_root}")"
-  if [[ "${profile_count}" -gt 1 ]]; then
-    printf 'implicit-default\n'
-    return 0
-  fi
-  printf 'single-profile-default\n'
-}
-flow_profile_selection_hint() {
-  local flow_root="${1:-}"
-  local mode=""
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  mode="$(flow_profile_selection_mode "${flow_root}")"
-  if [[ "${mode}" == "implicit-default" ]]; then
-    printf 'Set ACP_PROJECT_ID=<id> or AGENT_PROJECT_ID=<id> when multiple available profiles exist.\n'
-  fi
-}
-flow_profile_guard_message() {
-  local flow_root="${1:-}"
-  local command_name="${2:-this command}"
-  local hint=""
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  hint="$(flow_profile_selection_hint "${flow_root}")"
-  printf 'explicit profile selection required for %s when multiple available profiles exist.\n' "${command_name}"
-  if [[ -n "${hint}" ]]; then
-    printf '%s\n' "${hint}"
-  fi
-}
-flow_require_explicit_profile_selection() {
-  local flow_root="${1:-}"
-  local command_name="${2:-this command}"
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  if [[ "${ACP_ALLOW_IMPLICIT_PROFILE_SELECTION:-0}" == "1" ]]; then
-    return 0
-  fi
-  if [[ "$(flow_profile_selection_mode "${flow_root}")" == "implicit-default" ]]; then
-    flow_profile_guard_message "${flow_root}" "${command_name}" >&2
-    return 1
-  fi
-  return 0
-}
-resolve_flow_config_yaml() {
-  local script_path="${1:-${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}}"
-  local flow_root
-  local profile_id=""
-  local candidate=""
-  flow_root="$(resolve_flow_skill_dir "${script_path}")"
-  profile_id="${ACP_PROJECT_ID:-${AGENT_PROJECT_ID:-$(flow_default_profile_id "${flow_root}")}}"
-  for candidate in \
-    "${AGENT_CONTROL_PLANE_CONFIG:-}" \
-    "${ACP_CONFIG:-}" \
-    "${AGENT_PROJECT_CONFIG_PATH:-}" \
-    "${F_LOSNING_FLOW_CONFIG:-}"; do
-    if [[ -n "${candidate}" && -f "${candidate}" ]]; then
-      printf '%s\n' "${candidate}"
-      return 0
-    fi
-  done
-  candidate="$(flow_find_profile_dir_by_id "${flow_root}" "${profile_id}")/control-plane.yaml"
-  if [[ -f "${candidate}" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  printf '%s\n' "${candidate}"
-}
-flow_list_profile_ids() {
-  local flow_root="${1:-}"
-  local found_any=""
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  found_any="$(
-    {
-      flow_list_installed_profile_ids
-    } | awk 'NF { print }' | sort -u
-  )"
-  if [[ -z "${found_any}" ]]; then
-    return 0
-  fi
-  printf '%s\n' "${found_any}"
-}
-flow_git_remote_repo_slug() {
-  local repo_root="${1:-}"
-  local remote_name="${2:-origin}"
-  local remote_url=""
-  local normalized=""
-  [[ -n "${repo_root}" && -d "${repo_root}" ]] || return 1
-  remote_url="$(git -C "${repo_root}" remote get-url "${remote_name}" 2>/dev/null || true)"
-  [[ -n "${remote_url}" ]] || return 1
-  normalized="${remote_url%.git}"
-  case "${normalized}" in
-    ssh://*@*/*)
-      normalized="${normalized#ssh://}"
-      normalized="${normalized#*@}"
-      normalized="${normalized#*/}"
-      ;;
-    *@*:*/*)
-      normalized="${normalized#*@}"
-      normalized="${normalized#*:}"
-      ;;
-    https://*/*|http://*/*)
-      normalized="${normalized#http://}"
-      normalized="${normalized#https://}"
-      normalized="${normalized#*/}"
-      ;;
-    *)
-      return 1
-      ;;
-  esac
-  if [[ "${normalized}" == */*/* ]]; then
-    normalized="${normalized#*/}"
-  fi
-  if [[ "${normalized}" =~ ^[^/]+/[^/]+$ ]]; then
-    printf '%s\n' "${normalized}"
-    return 0
-  fi
-  return 1
-}
-flow_git_has_remote() {
-  local repo_root="${1:-}"
-  local remote_name="${2:-}"
-  [[ -n "${repo_root}" && -d "${repo_root}" && -n "${remote_name}" ]] || return 1
-  git -C "${repo_root}" remote get-url "${remote_name}" >/dev/null 2>&1
-}
-flow_resolve_forge_primary_remote() {
-  local repo_root="${1:-}"
-  local repo_slug="${2:-}"
-  local remote_name=""
-  local override="${ACP_SOURCE_SYNC_REMOTE:-${F_LOSNING_SOURCE_SYNC_REMOTE:-}}"
-  local forge_provider=""
-  [[ -n "${repo_root}" && -d "${repo_root}" ]] || return 1
-  if [[ -n "${override}" ]] && flow_git_has_remote "${repo_root}" "${override}"; then
-    printf '%s\n' "${override}"
-    return 0
-  fi
-  forge_provider="$(flow_forge_provider)"
-  case "${forge_provider}" in
-    gitea)
-      if flow_git_has_remote "${repo_root}" "gitea"; then
-        printf 'gitea\n'
-        return 0
-      fi
-      ;;
-    github)
-      if flow_git_has_remote "${repo_root}" "origin"; then
-        printf 'origin\n'
-        return 0
-      fi
-      ;;
-  esac
-  if [[ -n "${repo_slug}" ]]; then
-    while IFS= read -r remote_name; do
-      [[ -n "${remote_name}" ]] || continue
-      if [[ "$(flow_git_remote_repo_slug "${repo_root}" "${remote_name}" 2>/dev/null || true)" == "${repo_slug}" ]]; then
-        printf '%s\n' "${remote_name}"
-        return 0
-      fi
-    done < <(git -C "${repo_root}" remote)
-  fi
-  for remote_name in origin gitea; do
-    if flow_git_has_remote "${repo_root}" "${remote_name}"; then
-      printf '%s\n' "${remote_name}"
-      return 0
-    fi
-  done
-  return 1
-}
-flow_git_credential_token_for_repo_slug() {
-  local repo_slug="${1:-}"
-  local host="${2:-github.com}"
-  local path_suffix="${3:-${repo_slug}.git}"
-  local credential_payload=""
-  local token=""
-  [[ -n "${repo_slug}" && -n "${host}" && -n "${path_suffix}" ]] || return 1
-  command -v git >/dev/null 2>&1 || return 1
-  credential_payload="$(
-    printf 'protocol=https\nhost=%s\npath=%s\n\n' "${host}" "${path_suffix}" \
-      | git credential fill 2>/dev/null || true
-  )"
-  token="$(awk -F= '/^password=/{print $2; exit}' <<<"${credential_payload}")"
-  [[ -n "${token}" ]] || return 1
-  printf '%s\n' "${token}"
-}
-flow_export_github_cli_auth_env() {
-  local repo_slug="${1:-}"
-  local token=""
-  if flow_using_gitea; then
-    return 0
-  fi
-  if [[ -n "${GH_TOKEN:-}" ]]; then
-    return 0
-  fi
-  if [[ -n "${GITHUB_TOKEN:-}" ]]; then
-    export GH_TOKEN="${GITHUB_TOKEN}"
-    return 0
-  fi
-  if command -v gh >/dev/null 2>&1; then
-    if env -u GH_TOKEN -u GITHUB_TOKEN gh auth status >/dev/null 2>&1 \
-      || env -u GH_TOKEN -u GITHUB_TOKEN gh api user --jq .login >/dev/null 2>&1; then
-      return 0
-    fi
-  fi
-  token="$(flow_git_credential_token_for_repo_slug "${repo_slug}" || true)"
-  if [[ -n "${token}" ]]; then
-    export GH_TOKEN="${token}"
-    return 0
-  fi
-  if [[ -n "${GITHUB_PERSONAL_ACCESS_TOKEN:-}" ]]; then
-    export GH_TOKEN="${GITHUB_PERSONAL_ACCESS_TOKEN}"
-  fi
-}
-flow_forge_provider() {
-  local provider="${ACP_FORGE_PROVIDER:-${F_LOSNING_FORGE_PROVIDER:-github}}"
-  provider="$(printf '%s' "${provider}" | tr '[:upper:]' '[:lower:]')"
-  case "${provider}" in
-    github|gitea)
-      printf '%s\n' "${provider}"
-      ;;
-    *)
-      printf 'github\n'
-      ;;
-  esac
-}
-flow_using_gitea() {
-  [[ "$(flow_forge_provider)" == "gitea" ]]
-}
-flow_gitea_base_url() {
-  local base_url="${ACP_GITEA_BASE_URL:-${GITEA_BASE_URL:-}}"
-  [[ -n "${base_url}" ]] || return 1
-  printf '%s\n' "${base_url%/}"
-}
-flow_gitea_base_host() {
-  local base_url=""
-  base_url="$(flow_gitea_base_url)" || return 1
-  base_url="${base_url#http://}"
-  base_url="${base_url#https://}"
-  printf '%s\n' "${base_url%%/*}"
-}
-flow_gitea_api_url_for_repo() {
-  local repo_slug="${1:?repo slug required}"
-  local route="${2:-}"
-  local base_url=""
-  base_url="$(flow_gitea_base_url)" || return 1
-  route="${route#/}"
-  if [[ -n "${route}" ]]; then
-    printf '%s/api/v1/repos/%s/%s\n' "${base_url}" "${repo_slug}" "${route}"
-    return 0
-  fi
-  printf '%s/api/v1/repos/%s\n' "${base_url}" "${repo_slug}"
-}
-flow_gitea_auth_curl_args() {
-  local repo_slug="${1:-}"
-  local credential_token=""
-  if [[ -n "${ACP_GITEA_TOKEN:-${GITEA_TOKEN:-}}" ]]; then
-    printf -- "-H\0Authorization: token %s\0" "${ACP_GITEA_TOKEN:-${GITEA_TOKEN:-}}"
-    return 0
-  fi
-  if [[ -n "${ACP_GITEA_USERNAME:-${GITEA_USERNAME:-}}" && -n "${ACP_GITEA_PASSWORD:-${GITEA_PASSWORD:-}}" ]]; then
-    printf -- "-u\0%s:%s\0" "${ACP_GITEA_USERNAME:-${GITEA_USERNAME:-}}" "${ACP_GITEA_PASSWORD:-${GITEA_PASSWORD:-}}"
-    return 0
-  fi
-  if [[ -n "${repo_slug}" ]]; then
-    credential_token="$(flow_git_credential_token_for_repo_slug "${repo_slug}" "$(flow_gitea_base_host)" "${repo_slug}.git" || true)"
-    if [[ -n "${credential_token}" ]]; then
-      printf -- "-H\0Authorization: token %s\0" "${credential_token}"
-      return 0
-    fi
-  fi
-  return 1
-}
-flow_gitea_api_repo() {
-  local repo_slug="${1:?repo slug required}"
-  local route="${2:-}"
-  local method="GET"
-  local paginate="no"
-  local slurp="no"
-  local jq_filter=""
-  local expect_input="no"
-  local arg=""
-  local url=""
-  local input_file=""
-  local output=""
-  local page="1"
-  local per_page="100"
-  local response=""
-  local body=""
-  local link_header=""
-  local header_file=""
-  local stdout_file=""
-  local stderr_file=""
-  local curl_status="0"
-  local response_status="0"
-  local -a curl_args=()
-  local -a auth_args=()
-  local -a extra_headers=()
-  local -a form_fields=()
-  local -a pages=()
-  shift 2
-  while [[ $# -gt 0 ]]; do
-    arg="${1:-}"
-    case "${arg}" in
-      --method)
-        method="${2:-GET}"
-        shift 2
-        ;;
-      --paginate)
-        paginate="yes"
-        shift
-        ;;
-      --slurp)
-        slurp="yes"
-        shift
-        ;;
-      --jq)
-        jq_filter="${2:-}"
-        shift 2
-        ;;
-      --input)
-        expect_input="yes"
-        if [[ "${2:-}" == "-" ]]; then
-          input_file="$(mktemp)"
-          cat >"${input_file}"
-          shift 2
-        else
-          input_file="${2:-}"
-          shift 2
-        fi
-        ;;
-      -f|--field)
-        form_fields+=("${2:-}")
-        shift 2
-        ;;
-      *)
-        shift
-        ;;
-    esac
-  done
-  url="$(flow_gitea_api_url_for_repo "${repo_slug}" "${route}")" || {
-    rm -f "${input_file}"
-    return 1
-  }
-  while IFS= read -r -d '' arg; do
-    auth_args+=("${arg}")
-  done < <(flow_gitea_auth_curl_args "${repo_slug}") || true
-  if [[ "${#auth_args[@]}" -eq 0 && "${method}" != "GET" ]]; then
-    rm -f "${input_file}"
-    return 1
-  fi
-  if [[ "${expect_input}" == "yes" && -n "${input_file}" ]]; then
-    extra_headers+=(-H "Content-Type: application/json")
-  fi
-  if [[ "${#form_fields[@]}" -gt 0 ]]; then
-    extra_headers+=(-H "Content-Type: application/json")
-    body="$(
-      FORM_FIELDS="$(printf '%s\n' "${form_fields[@]}")" python3 - <<'PY'
-import json
-import os
-payload = {}
-for line in os.environ.get("FORM_FIELDS", "").splitlines():
-    line = line.rstrip("\n")
-    if "=" not in line:
-        continue
-    key, value = line.split("=", 1)
-    payload[key] = value
-print(json.dumps(payload))
-PY
-    )"
-    input_file="$(mktemp)"
-    printf '%s' "${body}" >"${input_file}"
-  fi
-  if [[ "${paginate}" != "yes" ]]; then
-    stdout_file="$(mktemp)"
-    stderr_file="$(mktemp)"
-    header_file="$(mktemp)"
-    curl_args=(-sS -D "${header_file}" -X "${method}")
-    if [[ "${#auth_args[@]}" -gt 0 ]]; then
-      curl_args+=("${auth_args[@]}")
-    fi
-    if [[ "${#extra_headers[@]}" -gt 0 ]]; then
-      curl_args+=("${extra_headers[@]}")
-    fi
-    if [[ -n "${input_file}" ]]; then
-      curl_args+=(--data-binary "@${input_file}")
-    fi
-    if curl "${curl_args[@]}" "${url}" >"${stdout_file}" 2>"${stderr_file}"; then
-      output="$(cat "${stdout_file}" 2>/dev/null || true)"
-      if [[ -n "${jq_filter}" ]]; then
-        jq -r "${jq_filter}" <<<"${output}"
-      else
-        printf '%s' "${output}"
-      fi
-      rm -f "${input_file}" "${stdout_file}" "${stderr_file}" "${header_file}"
-      return 0
-    fi
-    rm -f "${input_file}" "${stdout_file}" "${stderr_file}" "${header_file}"
-    return 1
-  fi
-  while :; do
-    stdout_file="$(mktemp)"
-    stderr_file="$(mktemp)"
-    header_file="$(mktemp)"
-    curl_args=(-sS -D "${header_file}" -X "${method}")
-    if [[ "${#auth_args[@]}" -gt 0 ]]; then
-      curl_args+=("${auth_args[@]}")
-    fi
-    if [[ "${#extra_headers[@]}" -gt 0 ]]; then
-      curl_args+=("${extra_headers[@]}")
-    fi
-    if curl "${curl_args[@]}" "${url}$([[ "${url}" == *\?* ]] && printf '&' || printf '?')page=${page}&limit=${per_page}" >"${stdout_file}" 2>"${stderr_file}"; then
-      response="$(cat "${stdout_file}" 2>/dev/null || true)"
-      pages+=("${response}")
-      link_header="$(tr -d '\r' <"${header_file}" | awk 'BEGIN{IGNORECASE=1}/^link:/{sub(/^link:[[:space:]]*/,""); print; exit}')"
-      rm -f "${stdout_file}" "${stderr_file}" "${header_file}"
-      if [[ "${link_header}" != *'rel="next"'* ]]; then
-        break
-      fi
-      page="$((page + 1))"
-    else
-      response_status="1"
-      rm -f "${stdout_file}" "${stderr_file}" "${header_file}" "${input_file}"
-      return "${response_status}"
-    fi
-  done
-  rm -f "${input_file}"
-  if [[ "${slurp}" == "yes" ]]; then
-    printf '%s\n' "${pages[@]}" | jq -s '.'
-    return 0
-  fi
-  printf '%s' "${pages[0]:-[]}"
-}
-flow_gitea_issue_view_json() {
-  local repo_slug="${1:?repo slug required}"
-  local issue_id="${2:?issue id required}"
-  local issue_json=""
-  local comments_json=""
-  issue_json="$(flow_gitea_api_repo "${repo_slug}" "issues/${issue_id}" 2>/dev/null || true)"
-  issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-  comments_json="$(flow_gitea_api_repo "${repo_slug}" "issues/${issue_id}/comments" --paginate --slurp 2>/dev/null || true)"
-  comments_json="$(flow_json_or_default "${comments_json}" '[]')"
-  ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comments_json}" python3 - <<'PY'
-import json
-import os
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-result = {
-    "number": issue.get("number"),
-    "state": str(issue.get("state", "")).upper(),
-    "title": issue.get("title") or "",
-    "body": issue.get("body") or "",
-    "url": issue.get("html_url") or issue.get("url") or "",
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-    "createdAt": issue.get("created_at") or "",
-    "updatedAt": issue.get("updated_at") or "",
-}
-print(json.dumps(result))
-PY
-}
-flow_gitea_issue_list_json() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local issues_json=""
-  issues_json="$(flow_gitea_api_repo "${repo_slug}" "issues?state=${state}" --paginate --slurp 2>/dev/null || true)"
-  issues_json="$(flow_json_or_default "${issues_json}" '[]')"
-  ISSUE_PAGES_JSON="${issues_json}" ISSUE_LIMIT="${limit}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("ISSUE_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("ISSUE_LIMIT", "100") or "100")
-issues = []
-for page in pages:
-    if isinstance(page, list):
-        issues.extend(page)
-    elif isinstance(page, dict):
-        issues.append(page)
-result = []
-for issue in issues:
-    if not isinstance(issue, dict):
-        continue
-    if issue.get("pull_request"):
-        continue
-    result.append({
-        "number": issue.get("number"),
-        "createdAt": issue.get("created_at") or "",
-        "updatedAt": issue.get("updated_at") or "",
-        "title": issue.get("title") or "",
-        "url": issue.get("html_url") or issue.get("url") or "",
-        "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    })
-print(json.dumps(result[:limit]))
-PY
-}
-flow_gitea_pr_view_json() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  local pr_json=""
-  local comment_pages_json=""
-  local files_json=""
-  local reviews_json=""
-  pr_json="$(flow_gitea_api_repo "${repo_slug}" "pulls/${pr_number}" 2>/dev/null || true)"
-  pr_json="$(flow_json_or_default "${pr_json}" '{}')"
-  comment_pages_json="$(flow_gitea_api_repo "${repo_slug}" "issues/${pr_number}/comments" --paginate --slurp 2>/dev/null || true)"
-  comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-  files_json="$(flow_gitea_api_repo "${repo_slug}" "pulls/${pr_number}/files" --paginate --slurp 2>/dev/null || true)"
-  files_json="$(flow_json_or_default "${files_json}" '[]')"
-  reviews_json="$(flow_gitea_api_repo "${repo_slug}" "pulls/${pr_number}/reviews" --paginate --slurp 2>/dev/null || true)"
-  reviews_json="$(flow_json_or_default "${reviews_json}" '[]')"
-  PR_JSON="${pr_json}" COMMENT_PAGES_JSON="${comment_pages_json}" FILES_JSON="${files_json}" REVIEWS_JSON="${reviews_json}" python3 - <<'PY'
-import json
-import os
-pr = json.loads(os.environ.get("PR_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-file_pages = json.loads(os.environ.get("FILES_JSON", "[]") or "[]")
-review_pages = json.loads(os.environ.get("REVIEWS_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-files = []
-for page in file_pages:
-    if isinstance(page, list):
-        files.extend(page)
-    elif isinstance(page, dict):
-        files.append(page)
-reviews = []
-for page in review_pages:
-    if isinstance(page, list):
-        reviews.extend(page)
-    elif isinstance(page, dict):
-        reviews.append(page)
-pr_state = str(pr.get("state", "")).upper()
-if pr.get("merged") or pr.get("merged_at"):
-    pr_state = "MERGED"
-review_states = [
-    str(review.get("state") or "").upper()
-    for review in reviews
-    if isinstance(review, dict)
-]
-review_decision = ""
-if any(state == "APPROVED" for state in review_states):
-    review_decision = "APPROVED"
-elif any(state in {"CHANGES_REQUESTED", "REQUEST_CHANGES"} for state in review_states):
-    review_decision = "CHANGES_REQUESTED"
-result = {
-    "number": pr.get("number"),
-    "title": pr.get("title") or "",
-    "body": pr.get("body") or "",
-    "url": pr.get("html_url") or pr.get("url") or "",
-    "headRefName": ((pr.get("head") or {}).get("ref")) or "",
-    "headRefOid": ((pr.get("head") or {}).get("sha")) or "",
-    "baseRefName": ((pr.get("base") or {}).get("ref")) or "",
-    "mergeStateStatus": "CLEAN" if pr.get("mergeable") else "UNKNOWN",
-    "statusCheckRollup": [],
-    "labels": [{"name": label.get("name", "")} for label in pr.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-    "state": pr_state,
-    "isDraft": bool(pr.get("draft")),
-    "createdAt": pr.get("created_at") or "",
-    "updatedAt": pr.get("updated_at") or "",
-    "mergedAt": pr.get("merged_at") or "",
-    "authorLogin": ((pr.get("user") or {}).get("login")) or "",
-    "files": [
-        {"path": file.get("filename") or ""}
-        for file in files
-        if isinstance(file, dict) and (file.get("filename") or "")
-    ],
-    "reviewRequests": [
-        {"login": reviewer.get("login") or ""}
-        for reviewer in (pr.get("requested_reviewers") or [])
-        if isinstance(reviewer, dict)
-    ],
-    "reviewDecision": review_decision,
-}
-print(json.dumps(result))
-PY
-}
-flow_gitea_pr_list_json() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local pulls_state="${state}"
-  local pr_pages_json=""
-  if [[ "${state}" == "merged" ]]; then
-    pulls_state="closed"
-  fi
-  pr_pages_json="$(flow_gitea_api_repo "${repo_slug}" "pulls?state=${pulls_state}" --paginate --slurp 2>/dev/null || true)"
-  pr_pages_json="$(flow_json_or_default "${pr_pages_json}" '[]')"
-  PR_PAGES_JSON="${pr_pages_json}" PR_LIMIT="${limit}" PR_STATE_FILTER="${state}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("PR_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("PR_LIMIT", "100") or "100")
-state_filter = os.environ.get("PR_STATE_FILTER", "open")
-prs = []
-for page in pages:
-    if isinstance(page, list):
-        prs.extend(page)
-    elif isinstance(page, dict):
-        prs.append(page)
-result = []
-for pr in prs:
-    if not isinstance(pr, dict):
-        continue
-    merged = bool(pr.get("merged") or pr.get("merged_at"))
-    state = str(pr.get("state", "")).lower()
-    if state_filter == "open" and state != "open":
-        continue
-    if state_filter == "closed" and state != "closed":
-        continue
-    if state_filter == "merged" and not merged:
-        continue
-    normalized_state = "MERGED" if merged else state.upper()
-    result.append({
-        "number": pr.get("number"),
-        "title": pr.get("title") or "",
-        "body": pr.get("body") or "",
-        "url": pr.get("html_url") or pr.get("url") or "",
-        "headRefName": ((pr.get("head") or {}).get("ref")) or "",
-        "headRefOid": ((pr.get("head") or {}).get("sha")) or "",
-        "baseRefName": ((pr.get("base") or {}).get("ref")) or "",
-        "createdAt": pr.get("created_at") or "",
-        "mergedAt": pr.get("merged_at") or "",
-        "state": normalized_state,
-        "isDraft": bool(pr.get("draft")),
-        "labels": [{"name": label.get("name", "")} for label in pr.get("labels", []) if isinstance(label, dict)],
-        "comments": [],
-        "authorLogin": ((pr.get("user") or {}).get("login")) or "",
-    })
-    if len(result) >= limit:
-        break
-print(json.dumps(result))
-PY
-}
-flow_github_output_indicates_rate_limit() {
-  grep -Eiq 'API rate limit exceeded|secondary rate limit|rate limit exceeded|HTTP 403' <<<"${1:-}"
-}
-flow_github_core_rate_limit_state_bin() {
-  local flow_root=""
-  local candidate=""
-  flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")" || return 1
-  candidate="${flow_root}/tools/bin/github-core-rate-limit-state.sh"
-  [[ -x "${candidate}" ]] || return 1
-  printf '%s\n' "${candidate}"
-}
-flow_github_core_rate_limit_state_output() {
-  local state_bin=""
-  state_bin="$(flow_github_core_rate_limit_state_bin)" || return 1
-  "${state_bin}" get 2>/dev/null || true
-}
-flow_github_core_rate_limit_active() {
-  local state_out=""
-  local ready=""
-  state_out="$(flow_github_core_rate_limit_state_output)" || return 1
-  ready="$(awk -F= '/^READY=/{print $2; exit}' <<<"${state_out}")"
-  [[ "${ready}" == "no" ]]
-}
-flow_github_core_rate_limit_schedule() {
-  local reason="${1:-github-api-rate-limit}"
-  local reset_epoch="${2:-}"
-  local state_bin=""
-  local now_epoch=""
-  state_bin="$(flow_github_core_rate_limit_state_bin)" || return 0
-  now_epoch="$(date +%s)"
-  if [[ "${reset_epoch}" =~ ^[0-9]+$ ]] && (( reset_epoch > now_epoch )); then
-    "${state_bin}" schedule "${reason}" --next-at-epoch "${reset_epoch}" >/dev/null 2>&1 || true
-    return 0
-  fi
-  "${state_bin}" schedule "${reason}" >/dev/null 2>&1 || true
-}
-flow_github_core_rate_limit_clear() {
-  local state_bin=""
-  state_bin="$(flow_github_core_rate_limit_state_bin)" || return 0
-  "${state_bin}" clear >/dev/null 2>&1 || true
-}
-flow_github_graphql_available() {
-  local repo_slug="${1:-}"
-  local rate_limit_json=""
-  local graphql_remaining=""
-  local core_remaining=""
-  local core_reset=""
-  local stderr_file=""
-  local stderr_output=""
-  if [[ "${FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE:-}" == "yes" ]]; then
-    return 0
-  fi
-  if [[ "${FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE:-}" == "no" ]]; then
-    return 1
-  fi
-  if flow_github_core_rate_limit_active; then
-    FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE="no"
-    return 1
-  fi
-  flow_export_github_cli_auth_env "${repo_slug}"
-  stderr_file="$(mktemp)"
-  if rate_limit_json="$(gh api rate_limit 2>"${stderr_file}")"; then
-    graphql_remaining="$(jq -r '.resources.graphql.remaining // empty' <<<"${rate_limit_json}" 2>/dev/null || true)"
-    core_remaining="$(jq -r '.resources.core.remaining // empty' <<<"${rate_limit_json}" 2>/dev/null || true)"
-    core_reset="$(jq -r '.resources.core.reset // empty' <<<"${rate_limit_json}" 2>/dev/null || true)"
-    if [[ "${core_remaining}" =~ ^[0-9]+$ ]]; then
-      if (( core_remaining > 0 )); then
-        flow_github_core_rate_limit_clear
-      else
-        flow_github_core_rate_limit_schedule "github-api-rate-limit" "${core_reset}"
-        FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE="no"
-        rm -f "${stderr_file}"
-        return 1
-      fi
-    fi
-  else
-    stderr_output="$(cat "${stderr_file}" 2>/dev/null || true)"
-    if flow_github_output_indicates_rate_limit "${stderr_output}"; then
-      flow_github_core_rate_limit_schedule "github-api-rate-limit"
-    fi
-    FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE="no"
-    rm -f "${stderr_file}"
-    return 1
-  fi
-  rm -f "${stderr_file}"
-  if [[ "${graphql_remaining}" =~ ^[0-9]+$ ]] && (( graphql_remaining > 0 )); then
-    FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE="yes"
-    return 0
-  fi
-  FLOW_GITHUB_GRAPHQL_AVAILABLE_CACHE="no"
-  return 1
-}
-flow_github_repo_id_cache_var() {
-  local repo_slug="${1:-}"
-  local sanitized="${repo_slug//[^A-Za-z0-9]/_}"
-  printf 'FLOW_GITHUB_REPO_ID_CACHE_%s\n' "${sanitized}"
-}
-flow_github_repo_id_for_repo_slug() {
-  local repo_slug="${1:-}"
-  local cache_var=""
-  local cached_value=""
-  local repos_pages_json=""
-  local repo_id=""
-  local stderr_file=""
-  local stderr_output=""
-  [[ -n "${repo_slug}" ]] || return 1
-  command -v gh >/dev/null 2>&1 || return 1
-  cache_var="$(flow_github_repo_id_cache_var "${repo_slug}")"
-  cached_value="${!cache_var:-}"
-  if [[ -n "${cached_value}" ]]; then
-    printf '%s\n' "${cached_value}"
-    return 0
-  fi
-  repo_id="$(flow_explicit_github_repo_id "${repo_slug}" || true)"
-  if [[ -n "${repo_id}" ]]; then
-    printf -v "${cache_var}" '%s' "${repo_id}"
-    printf '%s\n' "${repo_id}"
-    return 0
-  fi
-  if flow_github_core_rate_limit_active; then
-    return 1
-  fi
-  flow_export_github_cli_auth_env "${repo_slug}"
-  stderr_file="$(mktemp)"
-  if repos_pages_json="$(
-    gh api 'user/repos?per_page=100&visibility=all&affiliation=owner,collaborator,organization_member' \
-      --paginate \
-      --slurp 2>"${stderr_file}" || true
-  )" && [[ -n "${repos_pages_json}" ]]; then
-    flow_github_core_rate_limit_clear
-  else
-    stderr_output="$(cat "${stderr_file}" 2>/dev/null || true)"
-    if flow_github_output_indicates_rate_limit "${stderr_output}"; then
-      flow_github_core_rate_limit_schedule "github-api-rate-limit"
-    fi
-  fi
-  rm -f "${stderr_file}"
-  [[ -n "${repos_pages_json}" ]] || return 1
-  repo_id="$(
-    REPOS_PAGES_JSON="${repos_pages_json}" TARGET_REPO_SLUG="${repo_slug}" python3 - <<'PY'
-import json
-import os
-import sys
-pages = json.loads(os.environ.get("REPOS_PAGES_JSON", "[]") or "[]")
-target = os.environ.get("TARGET_REPO_SLUG", "")
-for page in pages:
-    if isinstance(page, list):
-        for repo in page:
-            if isinstance(repo, dict) and repo.get("full_name") == target:
-                value = repo.get("id")
-                if value is not None:
-                    print(value)
-                    sys.exit(0)
-    elif isinstance(page, dict) and page.get("full_name") == target:
-        value = page.get("id")
-        if value is not None:
-            print(value)
-            sys.exit(0)
-PY
-  )"
-  [[ -n "${repo_id}" ]] || return 1
-  printf -v "${cache_var}" '%s' "${repo_id}"
-  printf '%s\n' "${repo_id}"
-}
-flow_github_repo_api_prefix() {
-  local repo_slug="${1:-}"
-  local repo_id=""
-  repo_id="$(flow_github_repo_id_for_repo_slug "${repo_slug}")" || return 1
-  printf 'repositories/%s\n' "${repo_id}"
-}
-flow_github_api_repo() {
-  local repo_slug="${1:?repo slug required}"
-  local route="${2:-}"
-  local repo_prefix=""
-  local direct_route="repos/${repo_slug}"
-  local fallback_route=""
-  local output=""
-  local stdin_file=""
-  local request_status=0
-  local expect_input_value="false"
-  local arg=""
-  local index=0
-  local gh_arg_count=0
-  local stdout_file=""
-  local stderr_file=""
-  local error_output=""
-  local -a gh_args=()
-  if flow_using_gitea; then
-    flow_gitea_api_repo "$@"
-    return $?
-  fi
-  route="${route#/}"
-  if [[ -n "${route}" ]]; then
-    direct_route="${direct_route}/${route}"
-  fi
-  if [[ $# -gt 2 ]]; then
-    gh_args=("${@:3}")
-    gh_arg_count="${#gh_args[@]}"
-  fi
-  for ((index = 0; index < ${#gh_args[@]}; index++)); do
-    arg="${gh_args[${index}]}"
-    if [[ "${expect_input_value}" == "true" ]]; then
-      if [[ "${arg}" == "-" ]]; then
-        if [[ -z "${stdin_file}" ]]; then
-          stdin_file="$(mktemp)"
-          cat >"${stdin_file}"
-        fi
-        gh_args[${index}]="${stdin_file}"
-      fi
-      expect_input_value="false"
-    elif [[ "${arg}" == "--input" ]]; then
-      expect_input_value="true"
-    fi
-  done
-  if flow_github_core_rate_limit_active; then
-    rm -f "${stdin_file}"
-    return 1
-  fi
-  flow_export_github_cli_auth_env "${repo_slug}"
-  stdout_file="$(mktemp)"
-  stderr_file="$(mktemp)"
-  if [[ "${gh_arg_count}" -gt 0 ]]; then
-    if gh api "${direct_route}" "${gh_args[@]}" >"${stdout_file}" 2>"${stderr_file}"; then
-      output="$(cat "${stdout_file}" 2>/dev/null || true)"
-      flow_github_core_rate_limit_clear
-      printf '%s' "${output}"
-      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-      return 0
-    fi
-  else
-    if gh api "${direct_route}" >"${stdout_file}" 2>"${stderr_file}"; then
-      output="$(cat "${stdout_file}" 2>/dev/null || true)"
-      flow_github_core_rate_limit_clear
-      printf '%s' "${output}"
-      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-      return 0
-    fi
-  fi
-  error_output="$(cat "${stderr_file}" 2>/dev/null || true)"
-  if flow_github_output_indicates_rate_limit "${error_output}"; then
-    flow_github_core_rate_limit_schedule "github-api-rate-limit"
-    rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-    return 1
-  fi
-  if ! repo_prefix="$(flow_github_repo_api_prefix "${repo_slug}")"; then
-    rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-    return 1
-  fi
-  fallback_route="${repo_prefix}"
-  if [[ -n "${route}" ]]; then
-    fallback_route="${fallback_route}/${route}"
-  fi
-  if [[ "${gh_arg_count}" -gt 0 ]]; then
-    if gh api "${fallback_route}" "${gh_args[@]}" >"${stdout_file}" 2>"${stderr_file}"; then
-      output="$(cat "${stdout_file}" 2>/dev/null || true)"
-      flow_github_core_rate_limit_clear
-      printf '%s' "${output}"
-      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-      return 0
-    else
-      request_status=$?
-    fi
-  else
-    if gh api "${fallback_route}" >"${stdout_file}" 2>"${stderr_file}"; then
-      output="$(cat "${stdout_file}" 2>/dev/null || true)"
-      flow_github_core_rate_limit_clear
-      printf '%s' "${output}"
-      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-      return 0
-    else
-      request_status=$?
-    fi
-  fi
-  error_output="$(cat "${stderr_file}" 2>/dev/null || true)"
-  if flow_github_output_indicates_rate_limit "${error_output}"; then
-    flow_github_core_rate_limit_schedule "github-api-rate-limit"
-  fi
-  rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
-  return "${request_status}"
-}
-flow_json_or_default() {
-  local raw_value="${1-}"
-  local default_value="${2:-null}"
-  if [[ -z "${raw_value}" ]]; then
-    printf '%s\n' "${default_value}"
-    return 0
-  fi
-  if jq -e . >/dev/null 2>&1 <<<"${raw_value}"; then
-    printf '%s\n' "${raw_value}"
-  else
-    printf '%s\n' "${default_value}"
-  fi
-}
-flow_github_urlencode() {
-  local raw_value="${1:-}"
-  RAW_VALUE="${raw_value}" python3 - <<'PY'
-import os
-from urllib.parse import quote
-print(quote(os.environ.get("RAW_VALUE", ""), safe=""))
-PY
-}
-flow_github_issue_view_json_live() {
-  local repo_slug="${1:?repo slug required}"
-  local issue_id="${2:?issue id required}"
-  local issue_json=""
-  local comment_pages_json=""
-  if flow_using_gitea; then
-    flow_gitea_issue_view_json "${repo_slug}" "${issue_id}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && issue_json="$(gh issue view "${issue_id}" -R "${repo_slug}" --json number,state,title,body,url,labels,comments,createdAt,updatedAt 2>/dev/null)"; then
-    printf '%s\n' "${issue_json}"
-    return 0
-  fi
-  if ! issue_json="$(flow_github_api_repo "${repo_slug}" "issues/${issue_id}" 2>/dev/null)"; then
-    return 1
-  fi
-  issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-  if ! comment_pages_json="$(flow_github_api_repo "${repo_slug}" "issues/${issue_id}/comments?per_page=100" --paginate --slurp 2>/dev/null)"; then
-    return 1
-  fi
-  comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-  ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comment_pages_json}" python3 - <<'PY'
-import json
-import os
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-result = {
-    "number": issue.get("number"),
-    "state": str(issue.get("state", "")).upper(),
-    "title": issue.get("title") or "",
-    "body": issue.get("body") or "",
-    "url": issue.get("html_url") or issue.get("url") or "",
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-    "createdAt": issue.get("created_at") or "",
-    "updatedAt": issue.get("updated_at") or "",
-}
-print(json.dumps(result))
-PY
-}
-flow_github_issue_view_json() {
-  local repo_slug="${1:?repo slug required}"
-  local issue_id="${2:?issue id required}"
-  local issue_json=""
-  local comment_pages_json=""
-  if flow_using_gitea; then
-    flow_gitea_issue_view_json "${repo_slug}" "${issue_id}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && issue_json="$(gh issue view "${issue_id}" -R "${repo_slug}" --json number,state,title,body,url,labels,comments,createdAt,updatedAt 2>/dev/null)"; then
-    printf '%s\n' "${issue_json}"
-    return 0
-  fi
-  issue_json="$(flow_github_api_repo "${repo_slug}" "issues/${issue_id}" 2>/dev/null || true)"
-  issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-  comment_pages_json="$(flow_github_api_repo "${repo_slug}" "issues/${issue_id}/comments?per_page=100" --paginate --slurp 2>/dev/null || true)"
-  comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-  ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comment_pages_json}" python3 - <<'PY'
-import json
-import os
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-result = {
-    "number": issue.get("number"),
-    "state": str(issue.get("state", "")).upper(),
-    "title": issue.get("title") or "",
-    "body": issue.get("body") or "",
-    "url": issue.get("html_url") or issue.get("url") or "",
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-    "createdAt": issue.get("created_at") or "",
-    "updatedAt": issue.get("updated_at") or "",
-}
-print(json.dumps(result))
-PY
-}
-flow_github_issue_list_json_live() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local issues_json=""
-  local per_page="100"
-  if flow_using_gitea; then
-    flow_gitea_issue_list_json "${repo_slug}" "${state}" "${limit}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && issues_json="$(gh issue list -R "${repo_slug}" --state "${state}" --limit "${limit}" --json number,createdAt,updatedAt,title,url,labels 2>/dev/null)"; then
-    printf '%s\n' "${issues_json}"
-    return 0
-  fi
-  if [[ "${limit}" =~ ^[0-9]+$ ]] && (( limit > 0 && limit < 100 )); then
-    per_page="${limit}"
-  fi
-  if ! issues_json="$(flow_github_api_repo "${repo_slug}" "issues?state=${state}&per_page=${per_page}" --paginate --slurp 2>/dev/null)"; then
-    return 1
-  fi
-  issues_json="$(flow_json_or_default "${issues_json}" '[]')"
-  ISSUE_PAGES_JSON="${issues_json}" ISSUE_LIMIT="${limit}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("ISSUE_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("ISSUE_LIMIT", "100") or "100")
-issues = []
-for page in pages:
-    if isinstance(page, list):
-        issues.extend(page)
-    elif isinstance(page, dict):
-        issues.append(page)
-result = []
-for issue in issues:
-    if not isinstance(issue, dict):
-        continue
-    if issue.get("pull_request"):
-        continue
-    result.append({
-        "number": issue.get("number"),
-        "createdAt": issue.get("created_at") or "",
-        "updatedAt": issue.get("updated_at") or "",
-        "title": issue.get("title") or "",
-        "url": issue.get("html_url") or issue.get("url") or "",
-        "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    })
-print(json.dumps(result[:limit]))
-PY
-}
-flow_github_issue_list_json() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local issues_json=""
-  local per_page="100"
-  if flow_using_gitea; then
-    flow_gitea_issue_list_json "${repo_slug}" "${state}" "${limit}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && issues_json="$(gh issue list -R "${repo_slug}" --state "${state}" --limit "${limit}" --json number,createdAt,updatedAt,title,url,labels 2>/dev/null)"; then
-    printf '%s\n' "${issues_json}"
-    return 0
-  fi
-  if [[ "${limit}" =~ ^[0-9]+$ ]] && (( limit > 0 && limit < 100 )); then
-    per_page="${limit}"
-  fi
-  issues_json="$(flow_github_api_repo "${repo_slug}" "issues?state=${state}&per_page=${per_page}" --paginate --slurp 2>/dev/null || true)"
-  issues_json="$(flow_json_or_default "${issues_json}" '[]')"
-  ISSUE_PAGES_JSON="${issues_json}" ISSUE_LIMIT="${limit}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("ISSUE_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("ISSUE_LIMIT", "100") or "100")
-issues = []
-for page in pages:
-    if isinstance(page, list):
-        issues.extend(page)
-    elif isinstance(page, dict):
-        issues.append(page)
-result = []
-for issue in issues:
-    if not isinstance(issue, dict):
-        continue
-    if issue.get("pull_request"):
-        continue
-    result.append({
-        "number": issue.get("number"),
-        "createdAt": issue.get("created_at") or "",
-        "updatedAt": issue.get("updated_at") or "",
-        "title": issue.get("title") or "",
-        "url": issue.get("html_url") or issue.get("url") or "",
-        "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    })
-print(json.dumps(result[:limit]))
-PY
-}
-flow_github_pr_view_json() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  local pr_json=""
-  local issue_json=""
-  local comment_pages_json=""
-  local head_sha=""
-  local check_runs_json="{}"
-  local status_json="{}"
-  if flow_using_gitea; then
-    flow_gitea_pr_view_json "${repo_slug}" "${pr_number}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && pr_json="$(gh pr view "${pr_number}" -R "${repo_slug}" --json number,title,body,url,headRefName,baseRefName,mergeStateStatus,statusCheckRollup,labels,comments,state,isDraft 2>/dev/null)"; then
-    printf '%s\n' "${pr_json}"
-    return 0
-  fi
-  pr_json="$(flow_github_api_repo "${repo_slug}" "pulls/${pr_number}" 2>/dev/null || true)"
-  pr_json="$(flow_json_or_default "${pr_json}" '{}')"
-  issue_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}" 2>/dev/null || true)"
-  issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-  comment_pages_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}/comments?per_page=100" --paginate --slurp 2>/dev/null || true)"
-  comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-  head_sha="$(
-    PR_JSON="${pr_json}" python3 - <<'PY'
-import json
-import os
-payload = json.loads(os.environ.get("PR_JSON", "{}") or "{}")
-head = payload.get("head") or {}
-print(head.get("sha") or "")
-PY
-  )"
-  if [[ -n "${head_sha}" ]]; then
-    check_runs_json="$(flow_github_api_repo "${repo_slug}" "commits/${head_sha}/check-runs?per_page=100" 2>/dev/null || true)"
-    check_runs_json="$(flow_json_or_default "${check_runs_json}" '{}')"
-    status_json="$(flow_github_api_repo "${repo_slug}" "commits/${head_sha}/status" 2>/dev/null || true)"
-    status_json="$(flow_json_or_default "${status_json}" '{}')"
-  fi
-  PR_JSON="${pr_json}" ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comment_pages_json}" CHECK_RUNS_JSON="${check_runs_json}" STATUS_JSON="${status_json}" python3 - <<'PY'
-import json
-import os
-pr = json.loads(os.environ.get("PR_JSON", "{}") or "{}")
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-check_runs_payload = json.loads(os.environ.get("CHECK_RUNS_JSON", "{}") or "{}")
-status_payload = json.loads(os.environ.get("STATUS_JSON", "{}") or "{}")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-status_check_rollup = []
-for run in check_runs_payload.get("check_runs", []) or []:
-    if not isinstance(run, dict):
-        continue
-    status_check_rollup.append({
-        "name": run.get("name") or "",
-        "status": run.get("status") or "",
-        "conclusion": run.get("conclusion") or "",
-    })
-for item in status_payload.get("statuses", []) or []:
-    if not isinstance(item, dict):
-        continue
-    state = item.get("state") or ""
-    status_check_rollup.append({
-        "context": item.get("context") or "",
-        "status": state,
-        "conclusion": state,
-    })
-pr_state = str(pr.get("state", "")).upper()
-if pr.get("merged_at"):
-    pr_state = "MERGED"
-result = {
-    "number": pr.get("number"),
-    "title": pr.get("title") or "",
-    "body": pr.get("body") or issue.get("body") or "",
-    "url": pr.get("html_url") or pr.get("url") or "",
-    "headRefName": ((pr.get("head") or {}).get("ref")) or "",
-    "headRefOid": ((pr.get("head") or {}).get("sha")) or "",
-    "baseRefName": ((pr.get("base") or {}).get("ref")) or "",
-    "mergeStateStatus": str(pr.get("mergeable_state") or "UNKNOWN").upper(),
-    "statusCheckRollup": status_check_rollup,
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-    "state": pr_state,
-    "isDraft": bool(pr.get("draft")),
-    "createdAt": pr.get("created_at") or "",
-    "updatedAt": pr.get("updated_at") or "",
-    "mergedAt": pr.get("merged_at") or "",
-    "authorLogin": ((pr.get("user") or {}).get("login")) or "",
-}
-print(json.dumps(result))
-PY
-}
-flow_github_pr_list_json_live() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local pr_json=""
-  local per_page="100"
-  local pulls_state="${state}"
-  local pull_pages_json=""
-  local selected_prs_json=""
-  local item_jsonl_file=""
-  local current_pr_json=""
-  local issue_json=""
-  local comment_pages_json=""
-  local pr_number=""
-  if flow_using_gitea; then
-    flow_gitea_pr_list_json "${repo_slug}" "${state}" "${limit}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && pr_json="$(gh pr list -R "${repo_slug}" --state "${state}" --limit "${limit}" --json number,title,body,url,headRefName,labels,comments,createdAt,mergedAt,isDraft 2>/dev/null)"; then
-    printf '%s\n' "${pr_json}"
-    return 0
-  fi
-  if [[ "${state}" == "merged" ]]; then
-    pulls_state="closed"
-  fi
-  if [[ "${limit}" =~ ^[0-9]+$ ]] && (( limit > 0 && limit < 100 )); then
-    per_page="${limit}"
-  fi
-  if ! pull_pages_json="$(flow_github_api_repo "${repo_slug}" "pulls?state=${pulls_state}&per_page=${per_page}" --paginate --slurp 2>/dev/null)"; then
-    return 1
-  fi
-  pull_pages_json="$(flow_json_or_default "${pull_pages_json}" '[]')"
-  if ! selected_prs_json="$(
-    PULL_PAGES_JSON="${pull_pages_json}" PR_LIMIT="${limit}" PR_STATE_FILTER="${state}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("PULL_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("PR_LIMIT", "100") or "100")
-state_filter = os.environ.get("PR_STATE_FILTER", "open")
-pulls = []
-for page in pages:
-    if isinstance(page, list):
-        pulls.extend(page)
-    elif isinstance(page, dict):
-        pulls.append(page)
-result = []
-for pr in pulls:
-    if not isinstance(pr, dict):
-        continue
-    if state_filter == "merged" and not pr.get("merged_at"):
-        continue
-    result.append({
-        "number": pr.get("number"),
-        "title": pr.get("title") or "",
-        "body": pr.get("body") or "",
-        "url": pr.get("html_url") or pr.get("url") or "",
-        "headRefName": ((pr.get("head") or {}).get("ref")) or "",
-        "createdAt": pr.get("created_at") or "",
-        "mergedAt": pr.get("merged_at") or "",
-        "isDraft": bool(pr.get("draft")),
-    })
-    if len(result) >= limit:
-        break
-print(json.dumps(result))
-PY
-  )"; then
-    return 1
-  fi
-  item_jsonl_file="$(mktemp)"
-  while IFS= read -r current_pr_json; do
-    [[ -n "${current_pr_json}" ]] || continue
-    pr_number="$(jq -r '.number // ""' <<<"${current_pr_json}")"
-    [[ -n "${pr_number}" ]] || continue
-    if ! issue_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}" 2>/dev/null)"; then
-      rm -f "${item_jsonl_file}"
-      return 1
-    fi
-    issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-    if ! comment_pages_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}/comments?per_page=100" --paginate --slurp 2>/dev/null)"; then
-      rm -f "${item_jsonl_file}"
-      return 1
-    fi
-    comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-    PR_JSON="${current_pr_json}" ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comment_pages_json}" python3 - <<'PY' >>"${item_jsonl_file}"
-import json
-import os
-pr = json.loads(os.environ.get("PR_JSON", "{}") or "{}")
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-result = {
-    "number": pr.get("number"),
-    "title": pr.get("title") or "",
-    "body": pr.get("body") or issue.get("body") or "",
-    "url": pr.get("url") or issue.get("html_url") or issue.get("url") or "",
-    "headRefName": pr.get("headRefName") or "",
-    "createdAt": pr.get("createdAt") or "",
-    "mergedAt": pr.get("mergedAt") or "",
-    "isDraft": bool(pr.get("isDraft")),
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-}
-print(json.dumps(result))
-PY
-  done < <(jq -c '.[]' <<<"${selected_prs_json}" 2>/dev/null || true)
-  if ! jq -s '.' "${item_jsonl_file}" 2>/dev/null; then
-    rm -f "${item_jsonl_file}"
-    return 1
-  fi
-  rm -f "${item_jsonl_file}"
-}
-flow_github_pr_list_json() {
-  local repo_slug="${1:?repo slug required}"
-  local state="${2:-open}"
-  local limit="${3:-100}"
-  local pr_json=""
-  local per_page="100"
-  local pulls_state="${state}"
-  local pull_pages_json=""
-  local selected_prs_json=""
-  local item_jsonl_file=""
-  local current_pr_json=""
-  local issue_json=""
-  local comment_pages_json=""
-  local pr_number=""
-  if flow_using_gitea; then
-    flow_gitea_pr_list_json "${repo_slug}" "${state}" "${limit}"
-    return $?
-  fi
-  if flow_github_graphql_available "${repo_slug}" \
-    && pr_json="$(gh pr list -R "${repo_slug}" --state "${state}" --limit "${limit}" --json number,title,body,url,headRefName,labels,comments,createdAt,mergedAt,isDraft 2>/dev/null)"; then
-    printf '%s\n' "${pr_json}"
-    return 0
-  fi
-  if [[ "${state}" == "merged" ]]; then
-    pulls_state="closed"
-  fi
-  if [[ "${limit}" =~ ^[0-9]+$ ]] && (( limit > 0 && limit < 100 )); then
-    per_page="${limit}"
-  fi
-  pull_pages_json="$(flow_github_api_repo "${repo_slug}" "pulls?state=${pulls_state}&per_page=${per_page}" --paginate --slurp 2>/dev/null || true)"
-  pull_pages_json="$(flow_json_or_default "${pull_pages_json}" '[]')"
-  selected_prs_json="$(
-    PULL_PAGES_JSON="${pull_pages_json}" PR_LIMIT="${limit}" PR_STATE_FILTER="${state}" python3 - <<'PY'
-import json
-import os
-pages = json.loads(os.environ.get("PULL_PAGES_JSON", "[]") or "[]")
-limit = int(os.environ.get("PR_LIMIT", "100") or "100")
-state_filter = os.environ.get("PR_STATE_FILTER", "open")
-pulls = []
-for page in pages:
-    if isinstance(page, list):
-        pulls.extend(page)
-    elif isinstance(page, dict):
-        pulls.append(page)
-result = []
-for pr in pulls:
-    if not isinstance(pr, dict):
-        continue
-    if state_filter == "merged" and not pr.get("merged_at"):
-        continue
-    result.append({
-        "number": pr.get("number"),
-        "title": pr.get("title") or "",
-        "body": pr.get("body") or "",
-        "url": pr.get("html_url") or pr.get("url") or "",
-        "headRefName": ((pr.get("head") or {}).get("ref")) or "",
-        "createdAt": pr.get("created_at") or "",
-        "mergedAt": pr.get("merged_at") or "",
-        "isDraft": bool(pr.get("draft")),
-    })
-    if len(result) >= limit:
-        break
-print(json.dumps(result))
-PY
-  )" || selected_prs_json='[]'
-  item_jsonl_file="$(mktemp)"
-  trap 'rm -f "${item_jsonl_file}"' RETURN
-  while IFS= read -r current_pr_json; do
-    [[ -n "${current_pr_json}" ]] || continue
-    pr_number="$(jq -r '.number // ""' <<<"${current_pr_json}")"
-    [[ -n "${pr_number}" ]] || continue
-    issue_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}" 2>/dev/null || true)"
-    issue_json="$(flow_json_or_default "${issue_json}" '{}')"
-    comment_pages_json="$(flow_github_api_repo "${repo_slug}" "issues/${pr_number}/comments?per_page=100" --paginate --slurp 2>/dev/null || true)"
-    comment_pages_json="$(flow_json_or_default "${comment_pages_json}" '[]')"
-    PR_JSON="${current_pr_json}" ISSUE_JSON="${issue_json}" COMMENT_PAGES_JSON="${comment_pages_json}" python3 - <<'PY' >>"${item_jsonl_file}"
-import json
-import os
-pr = json.loads(os.environ.get("PR_JSON", "{}") or "{}")
-issue = json.loads(os.environ.get("ISSUE_JSON", "{}") or "{}")
-comment_pages = json.loads(os.environ.get("COMMENT_PAGES_JSON", "[]") or "[]")
-comments = []
-for page in comment_pages:
-    if isinstance(page, list):
-        comments.extend(page)
-    elif isinstance(page, dict):
-        comments.append(page)
-result = {
-    "number": pr.get("number"),
-    "title": pr.get("title") or "",
-    "body": pr.get("body") or issue.get("body") or "",
-    "url": pr.get("url") or issue.get("html_url") or issue.get("url") or "",
-    "headRefName": pr.get("headRefName") or "",
-    "createdAt": pr.get("createdAt") or "",
-    "mergedAt": pr.get("mergedAt") or "",
-    "isDraft": bool(pr.get("isDraft")),
-    "labels": [{"name": label.get("name", "")} for label in issue.get("labels", []) if isinstance(label, dict)],
-    "comments": [
-        {
-            "body": comment.get("body") or "",
-            "createdAt": comment.get("created_at") or "",
-            "updatedAt": comment.get("updated_at") or "",
-            "url": comment.get("html_url") or "",
-        }
-        for comment in comments
-        if isinstance(comment, dict)
-    ],
-}
-print(json.dumps(result))
-PY
-  done < <(jq -c '.[]' <<<"${selected_prs_json}")
-  ITEM_JSONL_FILE="${item_jsonl_file}" python3 - <<'PY'
-import json
-import os
-path = os.environ.get("ITEM_JSONL_FILE", "")
-items = []
-if path:
-    with open(path, "r", encoding="utf-8") as fh:
-        for line in fh:
-            line = line.strip()
-            if not line:
-                continue
-            items.append(json.loads(line))
-print(json.dumps(items))
-PY
-}
-flow_github_issue_close() {
-  local repo_slug="${1:?repo slug required}"
-  local issue_id="${2:?issue id required}"
-  local comment_body="${3:-}"
-  local payload=""
-  if flow_using_gitea; then
-    if [[ -n "${comment_body}" ]]; then
-      flow_github_api_repo "${repo_slug}" "issues/${issue_id}/comments" --method POST -f body="${comment_body}" >/dev/null || return 1
-    fi
-    payload='{"state":"closed"}'
-    printf '%s' "${payload}" | flow_github_api_repo "${repo_slug}" "issues/${issue_id}" --method PATCH --input - >/dev/null
-    return $?
-  fi
-  if [[ -n "${comment_body}" ]]; then
-    if gh issue close "${issue_id}" -R "${repo_slug}" --comment "${comment_body}" >/dev/null 2>&1; then
-      return 0
-    fi
-    flow_github_api_repo "${repo_slug}" "issues/${issue_id}/comments" --method POST -f body="${comment_body}" >/dev/null
-  else
-    if gh issue close "${issue_id}" -R "${repo_slug}" >/dev/null 2>&1; then
-      return 0
-    fi
-  fi
-  payload='{"state":"closed"}'
-  printf '%s' "${payload}" | flow_github_api_repo "${repo_slug}" "issues/${issue_id}" --method PATCH --input - >/dev/null
-}
-flow_github_issue_update_body() {
-  local repo_slug="${1:?repo slug required}"
-  local issue_id="${2:?issue id required}"
-  local body_text="${3:?body text required}"
-  local payload=""
-  payload="$(
-    ISSUE_BODY="${body_text}" python3 - <<'PY'
-import json
-import os
-print(json.dumps({"body": os.environ.get("ISSUE_BODY", "")}))
-PY
-  )"
-  printf '%s' "${payload}" | flow_github_api_repo "${repo_slug}" "issues/${issue_id}" --method PATCH --input - >/dev/null
-}
-flow_github_label_create() {
-  local repo_slug="${1:?repo slug required}"
-  local label_name="${2:?label name required}"
-  local label_description="${3:-}"
-  local label_color="${4:-1D76DB}"
-  local encoded_label=""
-  if gh label create "${label_name}" -R "${repo_slug}" --description "${label_description}" --color "${label_color}" --force >/dev/null 2>&1; then
-    return 0
-  fi
-  if flow_github_api_repo "${repo_slug}" "labels" --method POST -f name="${label_name}" -f description="${label_description}" -f color="${label_color}" >/dev/null 2>&1; then
-    return 0
-  fi
-  encoded_label="$(flow_github_urlencode "${label_name}")"
-  flow_github_api_repo "${repo_slug}" "labels/${encoded_label}" --method PATCH -f new_name="${label_name}" -f description="${label_description}" -f color="${label_color}" >/dev/null 2>&1 || true
-}
-flow_github_issue_create() {
-  local repo_slug="${1:?repo slug required}"
-  local title="${2:?title required}"
-  local body_file="${3:?body file required}"
-  local issue_url=""
-  local body_text=""
-  if flow_using_gitea; then
-    body_text="$(cat "${body_file}")"
-    issue_url="$(
-      ISSUE_TITLE="${title}" ISSUE_BODY="${body_text}" python3 - <<'PY' | flow_github_api_repo "${repo_slug}" "issues" --method POST --input - | jq -r '.html_url // ""'
-import json
-import os
-payload = {
-    "title": os.environ.get("ISSUE_TITLE", ""),
-    "body": os.environ.get("ISSUE_BODY", ""),
-}
-print(json.dumps(payload))
-PY
-    )"
-    [[ -n "${issue_url}" ]] || return 1
-    printf '%s\n' "${issue_url}"
-    return 0
-  fi
-  if issue_url="$(gh issue create -R "${repo_slug}" --title "${title}" --body-file "${body_file}" 2>/dev/null)"; then
-    printf '%s\n' "${issue_url}"
-    return 0
-  fi
-  body_text="$(cat "${body_file}")"
-  issue_url="$(
-    ISSUE_TITLE="${title}" ISSUE_BODY="${body_text}" python3 - <<'PY' | flow_github_api_repo "${repo_slug}" "issues" --method POST --input - | jq -r '.html_url // ""'
-import json
-import os
-payload = {
-    "title": os.environ.get("ISSUE_TITLE", ""),
-    "body": os.environ.get("ISSUE_BODY", ""),
-}
-print(json.dumps(payload))
-PY
-  )"
-  [[ -n "${issue_url}" ]] || return 1
-  printf '%s\n' "${issue_url}"
-}
-flow_github_current_login() {
-  if flow_using_gitea; then
-    local user_json=""
-    local auth_header=""
-    local base_url=""
-    base_url="$(flow_gitea_base_url)" || return 1
-    if [[ -n "${ACP_GITEA_TOKEN:-${GITEA_TOKEN:-}}" ]]; then
-      user_json="$(curl -sS -H "Authorization: token ${ACP_GITEA_TOKEN:-${GITEA_TOKEN:-}}" "${base_url}/api/v1/user" 2>/dev/null || true)"
-    elif [[ -n "${ACP_GITEA_USERNAME:-${GITEA_USERNAME:-}}" && -n "${ACP_GITEA_PASSWORD:-${GITEA_PASSWORD:-}}" ]]; then
-      user_json="$(curl -sS -u "${ACP_GITEA_USERNAME:-${GITEA_USERNAME:-}}:${ACP_GITEA_PASSWORD:-${GITEA_PASSWORD:-}}" "${base_url}/api/v1/user" 2>/dev/null || true)"
-    fi
-    jq -r '.login // ""' <<<"${user_json:-{}}" 2>/dev/null || true
-    return 0
-  fi
-  gh api user --jq '.login // ""' 2>/dev/null || true
-}
-flow_github_pr_author_login() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  flow_github_pr_view_json "${repo_slug}" "${pr_number}" 2>/dev/null | jq -r '.authorLogin // ""' 2>/dev/null || true
-}
-flow_github_pr_head_oid() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  flow_github_pr_view_json "${repo_slug}" "${pr_number}" 2>/dev/null | jq -r '.headRefOid // ""' 2>/dev/null || true
-}
-flow_github_pr_review_approve() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  local body_text="${3:-Automated final review passed.}"
-  local output=""
-  if flow_using_gitea; then
-    if output="$(
-      REVIEW_BODY="${body_text}" python3 - <<'PY' | flow_github_api_repo "${repo_slug}" "pulls/${pr_number}/reviews" --method POST --input - 2>&1
-import json
-import os
-print(json.dumps({"event": "APPROVED", "body": os.environ.get("REVIEW_BODY", "")}))
-PY
-    )"; then
-      return 0
-    fi
-    if grep -q "approve your own pull is not allowed" <<<"${output}"; then
-      return 0
-    fi
-    printf '%s\n' "${output}" >&2
-    return 1
-  fi
-  gh api "repos/${repo_slug}/pulls/${pr_number}/reviews" --method POST -f event=APPROVE -f body="${body_text}" >/dev/null
-}
-flow_github_pr_create() {
-  local repo_slug="${1:?repo slug required}"
-  local base_branch="${2:?base branch required}"
-  local head_branch="${3:?head branch required}"
-  local title="${4:?title required}"
-  local body_file="${5:?body file required}"
-  local pr_url=""
-  local body_text=""
-  if flow_using_gitea; then
-    body_text="$(cat "${body_file}")"
-    pr_url="$(
-      BASE_BRANCH="${base_branch}" HEAD_BRANCH="${head_branch}" PR_TITLE="${title}" PR_BODY="${body_text}" python3 - <<'PY' | flow_github_api_repo "${repo_slug}" "pulls" --method POST --input - | jq -r '.html_url // ""'
-import json
-import os
-payload = {
-    "title": os.environ.get("PR_TITLE", ""),
-    "head": os.environ.get("HEAD_BRANCH", ""),
-    "base": os.environ.get("BASE_BRANCH", ""),
-    "body": os.environ.get("PR_BODY", ""),
-}
-print(json.dumps(payload))
-PY
-    )"
-    [[ -n "${pr_url}" ]] || return 1
-    printf '%s\n' "${pr_url}"
-    return 0
-  fi
-  if pr_url="$(gh pr create -R "${repo_slug}" --base "${base_branch}" --head "${head_branch}" --title "${title}" --body-file "${body_file}" 2>/dev/null)"; then
-    printf '%s\n' "${pr_url}"
-    return 0
-  fi
-  body_text="$(cat "${body_file}")"
-  pr_url="$(
-    BASE_BRANCH="${base_branch}" HEAD_BRANCH="${head_branch}" PR_TITLE="${title}" PR_BODY="${body_text}" python3 - <<'PY' | flow_github_api_repo "${repo_slug}" "pulls" --method POST --input - | jq -r '.html_url // ""'
-import json
-import os
-payload = {
-    "title": os.environ.get("PR_TITLE", ""),
-    "head": os.environ.get("HEAD_BRANCH", ""),
-    "base": os.environ.get("BASE_BRANCH", ""),
-    "body": os.environ.get("PR_BODY", ""),
-}
-print(json.dumps(payload))
-PY
-  )"
-  [[ -n "${pr_url}" ]] || return 1
-  printf '%s\n' "${pr_url}"
-}
-flow_github_pr_merge() {
-  local repo_slug="${1:?repo slug required}"
-  local pr_number="${2:?pr number required}"
-  local merge_method="${3:-squash}"
-  local delete_branch="${4:-no}"
-  local pr_json=""
-  local head_ref=""
-  local encoded_ref=""
-  if flow_using_gitea; then
-    printf '%s' "$(
-      MERGE_METHOD="${merge_method}" DELETE_BRANCH="${delete_branch}" python3 - <<'PY'
-import json
-import os
-method = os.environ.get("MERGE_METHOD", "squash")
-delete_branch = os.environ.get("DELETE_BRANCH", "no") == "yes"
-method_map = {"merge": "merge", "squash": "squash", "rebase": "rebase"}
-print(json.dumps({
-    "Do": method_map.get(method, "squash"),
-    "delete_branch_after_merge": delete_branch,
-}))
-PY
-    )" | flow_github_api_repo "${repo_slug}" "pulls/${pr_number}/merge" --method POST --input - >/dev/null
-    return $?
-  fi
-  if gh pr merge "${pr_number}" -R "${repo_slug}" "--${merge_method}" $([[ "${delete_branch}" == "yes" ]] && printf '%s' '--delete-branch') --admin >/dev/null 2>&1; then
-    return 0
-  fi
-  printf '{"merge_method":"%s"}' "${merge_method}" \
-    | flow_github_api_repo "${repo_slug}" "pulls/${pr_number}/merge" --method PUT --input - >/dev/null
-  if [[ "${delete_branch}" == "yes" ]]; then
-    pr_json="$(flow_github_pr_view_json "${repo_slug}" "${pr_number}" 2>/dev/null || printf '{}\n')"
-    head_ref="$(jq -r '.headRefName // ""' <<<"${pr_json}")"
-    if [[ -n "${head_ref}" ]]; then
-      encoded_ref="$(flow_github_urlencode "heads/${head_ref}")"
-      flow_github_api_repo "${repo_slug}" "git/refs/${encoded_ref}" --method DELETE >/dev/null 2>&1 || true
-    fi
-  fi
-}
-flow_config_get() {
-  local config_file="${1:?config file required}"
-  local target_path="${2:?target path required}"
-  python3 - "$config_file" "$target_path" <<'PY'
-import sys
-config_file = sys.argv[1]
-target_path = sys.argv[2]
-stack = []
-found = False
-with open(config_file, "r", encoding="utf-8") as fh:
-    for raw_line in fh:
-        stripped = raw_line.strip()
-        if not stripped or stripped.startswith("#") or stripped.startswith("- "):
-            continue
-        if ":" not in raw_line:
-            continue
-        indent = len(raw_line) - len(raw_line.lstrip())
-        key, value = stripped.split(":", 1)
-        key = key.strip()
-        value = value.strip().strip("\"'")
-        while stack and indent <= stack[-1][0]:
-            stack.pop()
-        stack.append((indent, key))
-        current_path = ".".join(part for _, part in stack)
-        if current_path == target_path and value:
-            print(value)
-            found = True
-            break
-if not found:
-    print("")
-PY
-}
-flow_kv_get() {
-  local payload="${1:-}"
-  local key="${2:?key required}"
-  awk -F= -v key="${key}" '$1 == key { print substr($0, length(key) + 2); exit }' <<<"${payload}"
-}
-flow_env_or_config() {
-  local config_file="${1:?config file required}"
-  local env_names="${2:?env names required}"
-  local config_key="${3:?config key required}"
-  local default_value="${4:-}"
-  local env_name=""
-  local value=""
-  for env_name in ${env_names}; do
-    value="${!env_name:-}"
-    if [[ -n "${value}" ]]; then
-      printf '%s\n' "${value}"
-      return 0
-    fi
-  done
-  if [[ -f "${config_file}" ]]; then
-    value="$(flow_config_get "${config_file}" "${config_key}")"
-    if [[ -n "${value}" ]]; then
-      printf '%s\n' "${value}"
-      return 0
-    fi
-  fi
-  printf '%s\n' "${default_value}"
-}
-flow_resolve_adapter_id() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_profile_id)"
-  flow_env_or_config "${config_file}" "ACP_PROJECT_ID AGENT_PROJECT_ID" "id" "${default_value}"
-}
-flow_resolve_profile_notes_file() {
-  local config_file="${1:-}"
-  local config_dir=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  config_dir="$(cd "$(dirname "${config_file}")" 2>/dev/null && pwd -P || dirname "${config_file}")"
-  printf '%s/README.md
-' "${config_dir}"
-}
-flow_default_issue_session_prefix() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf '%s-issue-\n' "${adapter_id}"
-}
-flow_default_pr_session_prefix() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf '%s-pr-\n' "${adapter_id}"
-}
-flow_default_issue_branch_prefix() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf 'agent/%s/issue\n' "${adapter_id}"
-}
-flow_default_pr_worktree_branch_prefix() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf 'agent/%s/pr\n' "${adapter_id}"
-}
-flow_default_managed_pr_branch_globs() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf 'agent/%s/* codex/* openclaw/*\n' "${adapter_id}"
-}
-flow_default_agent_root() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  local platform_home="${AGENT_PLATFORM_HOME:-${HOME}/.agent-runtime}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf '%s/projects/%s
-' "${platform_home}" "${adapter_id}"
-}
-flow_default_repo_slug() {
-  local config_file="${1:-}"
-  local adapter_id=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  printf 'example/%s
-' "${adapter_id}"
-}
-flow_default_repo_id() {
-  printf '\n'
-}
-flow_default_repo_root() {
-  local config_file="${1:-}"
-  local agent_root=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  agent_root="$(flow_default_agent_root "${config_file}")"
-  printf '%s/repo
-' "${agent_root}"
-}
-flow_default_worktree_root() {
-  local config_file="${1:-}"
-  local agent_root=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  agent_root="$(flow_default_agent_root "${config_file}")"
-  printf '%s/worktrees
-' "${agent_root}"
-}
-flow_default_retained_repo_root() {
-  local config_file="${1:-}"
-  local agent_root=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  agent_root="$(flow_default_agent_root "${config_file}")"
-  printf '%s/retained
-' "${agent_root}"
-}
-flow_default_vscode_workspace_file() {
-  local config_file="${1:-}"
-  local agent_root=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  agent_root="$(flow_default_agent_root "${config_file}")"
-  printf '%s/workspace.code-workspace
-' "${agent_root}"
-}
-flow_resolve_repo_slug() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_repo_slug "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_REPO_SLUG F_LOSNING_REPO_SLUG" "repo.slug" "${default_value}"
-}
-flow_resolve_repo_id() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_repo_id)"
-  flow_env_or_config "${config_file}" "ACP_REPO_ID F_LOSNING_REPO_ID ACP_GITHUB_REPOSITORY_ID F_LOSNING_GITHUB_REPOSITORY_ID" "repo.id" "${default_value}"
-}
-flow_resolve_default_branch() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_env_or_config "${config_file}" "ACP_DEFAULT_BRANCH F_LOSNING_DEFAULT_BRANCH" "repo.default_branch" "main"
-}
-flow_resolve_project_label() {
-  local config_file="${1:-}"
-  local repo_slug=""
-  local adapter_id=""
-  local label=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  repo_slug="$(flow_resolve_repo_slug "${config_file}")"
-  adapter_id="$(flow_resolve_adapter_id "${config_file}")"
-  label="${repo_slug##*/}"
-  if [[ -n "${label}" ]]; then
-    printf '%s\n' "${label}"
-  else
-    printf '%s\n' "${adapter_id}"
-  fi
-}
-flow_resolve_repo_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_repo_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_REPO_ROOT F_LOSNING_REPO_ROOT" "repo.root" "${default_value}"
-}
-flow_resolve_agent_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_agent_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_AGENT_ROOT F_LOSNING_AGENT_ROOT" "runtime.orchestrator_agent_root" "${default_value}"
-}
-flow_resolve_agent_repo_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_resolve_repo_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_AGENT_REPO_ROOT F_LOSNING_AGENT_REPO_ROOT" "runtime.agent_repo_root" "${default_value}"
-}
-flow_resolve_worktree_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_worktree_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_WORKTREE_ROOT F_LOSNING_WORKTREE_ROOT" "runtime.worktree_root" "${default_value}"
-}
-flow_resolve_runs_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  local explicit_root="${ACP_RUNS_ROOT:-${F_LOSNING_RUNS_ROOT:-}}"
-  local umbrella_root="${ACP_AGENT_ROOT:-${F_LOSNING_AGENT_ROOT:-}}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  if [[ -n "${explicit_root}" ]]; then
-    printf '%s\n' "${explicit_root}"
-    return 0
-  fi
-  default_value="$(flow_resolve_agent_root "${config_file}")/runs"
-  if [[ -n "${umbrella_root}" ]]; then
-    printf '%s\n' "${default_value}"
-    return 0
-  fi
-  flow_env_or_config "${config_file}" "ACP_RUNS_ROOT F_LOSNING_RUNS_ROOT" "runtime.runs_root" "${default_value}"
-}
-flow_resolve_state_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  local explicit_root="${ACP_STATE_ROOT:-${F_LOSNING_STATE_ROOT:-}}"
-  local umbrella_root="${ACP_AGENT_ROOT:-${F_LOSNING_AGENT_ROOT:-}}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  if [[ -n "${explicit_root}" ]]; then
-    printf '%s\n' "${explicit_root}"
-    return 0
-  fi
-  default_value="$(flow_resolve_agent_root "${config_file}")/state"
-  if [[ -n "${umbrella_root}" ]]; then
-    printf '%s\n' "${default_value}"
-    return 0
-  fi
-  flow_env_or_config "${config_file}" "ACP_STATE_ROOT F_LOSNING_STATE_ROOT" "runtime.state_root" "${default_value}"
-}
-flow_resolve_history_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  local explicit_root="${ACP_HISTORY_ROOT:-${F_LOSNING_HISTORY_ROOT:-}}"
-  local umbrella_root="${ACP_AGENT_ROOT:-${F_LOSNING_AGENT_ROOT:-}}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  if [[ -n "${explicit_root}" ]]; then
-    printf '%s\n' "${explicit_root}"
-    return 0
-  fi
-  default_value="$(flow_resolve_agent_root "${config_file}")/history"
-  if [[ -n "${umbrella_root}" ]]; then
-    printf '%s\n' "${default_value}"
-    return 0
-  fi
-  flow_env_or_config "${config_file}" "ACP_HISTORY_ROOT F_LOSNING_HISTORY_ROOT" "runtime.history_root" "${default_value}"
-}
-flow_resolve_retained_repo_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_retained_repo_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_RETAINED_REPO_ROOT F_LOSNING_RETAINED_REPO_ROOT" "runtime.retained_repo_root" "${default_value}"
-}
-flow_resolve_source_repo_root() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_resolve_retained_repo_root "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_SOURCE_REPO_ROOT F_LOSNING_SOURCE_REPO_ROOT" "runtime.source_repo_root" "${default_value}"
-}
-flow_resolve_vscode_workspace_file() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_vscode_workspace_file "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_VSCODE_WORKSPACE_FILE F_LOSNING_VSCODE_WORKSPACE_FILE" "runtime.vscode_workspace_file" "${default_value}"
-}
-flow_resolve_web_playwright_command() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_env_or_config "${config_file}" "ACP_WEB_PLAYWRIGHT_COMMAND F_LOSNING_WEB_PLAYWRIGHT_COMMAND" "execution.verification.web_playwright_command" "pnpm exec playwright test"
-}
-flow_resolve_codex_quota_bin() {
-  local flow_root="${1:-}"
-  local shared_home=""
-  local explicit_bin="${ACP_CODEX_QUOTA_BIN:-${F_LOSNING_CODEX_QUOTA_BIN:-}}"
-  local candidate=""
-  if [[ -n "${explicit_bin}" ]]; then
-    printf '%s\n' "${explicit_bin}"
-    return 0
-  fi
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  shared_home="${SHARED_AGENT_HOME:-$(resolve_shared_agent_home "${flow_root}")}"
-  for candidate in \
-    "${flow_root}/tools/bin/codex-quota" \
-    "${shared_home}/tools/bin/codex-quota"; do
-    if [[ -x "${candidate}" ]]; then
-      printf '%s\n' "${candidate}"
-      return 0
-    fi
-  done
-  candidate="$(command -v codex-quota 2>/dev/null || true)"
-  if [[ -n "${candidate}" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  printf '%s\n' "${flow_root}/tools/bin/codex-quota"
-}
-flow_resolve_codex_quota_manager_script() {
-  local flow_root="${1:-}"
-  local shared_home=""
-  local explicit_script="${ACP_CODEX_QUOTA_MANAGER_SCRIPT:-${F_LOSNING_CODEX_QUOTA_MANAGER_SCRIPT:-}}"
-  local candidate=""
-  if [[ -n "${explicit_script}" ]]; then
-    printf '%s\n' "${explicit_script}"
-    return 0
-  fi
-  if [[ -z "${flow_root}" ]]; then
-    flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  shared_home="${SHARED_AGENT_HOME:-$(resolve_shared_agent_home "${flow_root}")}"
-  for candidate in \
-    "${flow_root}/tools/vendor/codex-quota-manager/scripts/auto-switch.sh" \
-    "${shared_home}/tools/vendor/codex-quota-manager/scripts/auto-switch.sh" \
-    "${shared_home}/skills/openclaw/codex-quota-manager/scripts/auto-switch.sh"; do
-    if [[ -x "${candidate}" ]]; then
-      printf '%s\n' "${candidate}"
-      return 0
-    fi
-  done
-  printf '%s\n' "${flow_root}/tools/vendor/codex-quota-manager/scripts/auto-switch.sh"
-}
-flow_resolve_template_file() {
-  local template_name="${1:?template name required}"
-  local workspace_dir="${2:-}"
-  local config_file="${3:-}"
-  local flow_root=""
-  local profile_id=""
-  local config_dir=""
-  local template_dir=""
-  local candidate=""
-  local workspace_real=""
-  local canonical_tools_real=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
-  config_dir="$(cd "$(dirname "${config_file}")" 2>/dev/null && pwd -P || dirname "${config_file}")"
-  for template_dir in \
-    "${AGENT_CONTROL_PLANE_TEMPLATE_DIR:-}" \
-    "${ACP_TEMPLATE_DIR:-}" \
-    "${F_LOSNING_TEMPLATE_DIR:-}"; do
-    if [[ -n "${template_dir}" && -f "${template_dir}/${template_name}" ]]; then
-      printf '%s\n' "${template_dir}/${template_name}"
-      return 0
-    fi
-  done
-  if [[ -n "${workspace_dir}" && -f "${workspace_dir}/templates/${template_name}" ]]; then
-    workspace_real="$(cd "${workspace_dir}" && pwd -P)"
-    canonical_tools_real="$(cd "${flow_root}/tools" && pwd -P)"
-    if [[ "${workspace_real}" != "${canonical_tools_real}" ]]; then
-      printf '%s\n' "${workspace_dir}/templates/${template_name}"
-      return 0
-    fi
-  fi
-  candidate="${config_dir}/templates/${template_name}"
-  if [[ -f "${candidate}" ]]; then
-    printf '%s\n' "${candidate}"
-    return 0
-  fi
-  if [[ -n "${workspace_dir}" && -f "${workspace_dir}/templates/${template_name}" ]]; then
-    printf '%s\n' "${workspace_dir}/templates/${template_name}"
-    return 0
-  fi
-  printf '%s\n' "${flow_root}/tools/templates/${template_name}"
-}
-flow_resolve_retry_cooldowns() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_env_or_config "${config_file}" "ACP_RETRY_COOLDOWNS F_LOSNING_RETRY_COOLDOWNS" "execution.retry.cooldowns" "300,900,1800,3600"
-}
-flow_resolve_provider_quota_cooldowns() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_env_or_config "${config_file}" "ACP_PROVIDER_QUOTA_COOLDOWNS F_LOSNING_PROVIDER_QUOTA_COOLDOWNS" "execution.provider_quota.cooldowns" "300,900,1800,3600"
-}
-flow_resolve_provider_pool_order() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  flow_env_or_config "${config_file}" "ACP_PROVIDER_POOL_ORDER F_LOSNING_PROVIDER_POOL_ORDER" "execution.provider_pool_order" ""
-}
-flow_provider_pool_names() {
-  local config_file="${1:-}"
-  local order=""
-  local pool_name=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  order="$(flow_resolve_provider_pool_order "${config_file}")"
-  for pool_name in ${order}; do
-    [[ -n "${pool_name}" ]] || continue
-    printf '%s\n' "${pool_name}"
-  done
-}
-flow_provider_pools_enabled() {
-  local config_file="${1:-}"
-  [[ -n "$(flow_resolve_provider_pool_order "${config_file}")" ]]
-}
-flow_provider_pool_value() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  local relative_path="${3:?relative path required}"
-  flow_config_get "${config_file}" "execution.provider_pools.${pool_name}.${relative_path}"
-}
-flow_provider_pool_backend() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "coding_worker"
-}
-flow_provider_pool_safe_profile() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "safe_profile"
-}
-flow_provider_pool_bypass_profile() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "bypass_profile"
-}
-flow_provider_pool_claude_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.model"
-}
-flow_provider_pool_claude_permission_mode() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.permission_mode"
-}
-flow_provider_pool_claude_effort() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.effort"
-}
-flow_provider_pool_claude_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.timeout_seconds"
-}
-flow_provider_pool_claude_max_attempts() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.max_attempts"
-}
-flow_provider_pool_claude_retry_backoff_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "claude.retry_backoff_seconds"
-}
-flow_provider_pool_openclaw_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "openclaw.model"
-}
-flow_provider_pool_openclaw_thinking() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "openclaw.thinking"
-}
-flow_provider_pool_openclaw_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "openclaw.timeout_seconds"
-}
-flow_provider_pool_ollama_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "ollama.model"
-}
-flow_provider_pool_ollama_base_url() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "ollama.base_url"
-}
-flow_provider_pool_ollama_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "ollama.timeout_seconds"
-}
-flow_provider_pool_pi_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "pi.model"
-}
-flow_provider_pool_pi_thinking() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "pi.thinking"
-}
-flow_provider_pool_pi_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "pi.timeout_seconds"
-}
-flow_provider_pool_opencode_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "opencode.model"
-}
-flow_provider_pool_opencode_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "opencode.timeout_seconds"
-}
-flow_provider_pool_kilo_model() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "kilo.model"
-}
-flow_provider_pool_kilo_timeout_seconds() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  flow_provider_pool_value "${config_file}" "${pool_name}" "kilo.timeout_seconds"
-}
-flow_sanitize_provider_key() {
-  local raw_key="${1:?raw key required}"
-  printf '%s' "${raw_key}" \
-    | tr '[:upper:]' '[:lower:]' \
-    | sed -E 's/[^a-z0-9._-]+/-/g; s/^-+//; s/-+$//; s/-+/-/g'
-}
-flow_provider_pool_model_identity() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  local backend=""
-  backend="$(flow_provider_pool_backend "${config_file}" "${pool_name}")"
-  case "${backend}" in
-    codex)
-      flow_provider_pool_safe_profile "${config_file}" "${pool_name}"
-      ;;
-    claude)
-      flow_provider_pool_claude_model "${config_file}" "${pool_name}"
-      ;;
-    openclaw)
-      flow_provider_pool_openclaw_model "${config_file}" "${pool_name}"
-      ;;
-    ollama)
-      flow_provider_pool_ollama_model "${config_file}" "${pool_name}"
-      ;;
-    pi)
-      flow_provider_pool_pi_model "${config_file}" "${pool_name}"
-      ;;
-    opencode)
-      flow_provider_pool_opencode_model "${config_file}" "${pool_name}"
-      ;;
-    kilo)
-      flow_provider_pool_kilo_model "${config_file}" "${pool_name}"
-      ;;
-    *)
-      printf '\n'
-      ;;
-  esac
-}
-flow_provider_pool_state_get() {
-  local config_file="${1:?config file required}"
-  local pool_name="${2:?pool name required}"
-  local backend=""
-  local model=""
-  local state_root=""
-  local provider_key=""
-  local state_file=""
-  local attempts="0"
-  local next_attempt_epoch="0"
-  local next_attempt_at=""
-  local last_reason=""
-  local updated_at=""
-  local ready="yes"
-  local valid="yes"
-  local now_epoch=""
-  local safe_profile=""
-  local bypass_profile=""
-  local claude_model=""
-  local claude_permission_mode=""
-  local claude_effort=""
-  local claude_timeout_seconds=""
-  local claude_max_attempts=""
-  local claude_retry_backoff_seconds=""
-  local openclaw_model=""
-  local openclaw_thinking=""
-  local openclaw_timeout_seconds=""
-  local ollama_model=""
-  local ollama_base_url=""
-  local ollama_timeout_seconds=""
-  local pi_model=""
-  local pi_thinking=""
-  local pi_timeout_seconds=""
-  local opencode_model=""
-  local opencode_timeout_seconds=""
-  local kilo_model=""
-  local kilo_timeout_seconds=""
-  backend="$(flow_provider_pool_backend "${config_file}" "${pool_name}")"
-  safe_profile="$(flow_provider_pool_safe_profile "${config_file}" "${pool_name}")"
-  bypass_profile="$(flow_provider_pool_bypass_profile "${config_file}" "${pool_name}")"
-  claude_model="$(flow_provider_pool_claude_model "${config_file}" "${pool_name}")"
-  claude_permission_mode="$(flow_provider_pool_claude_permission_mode "${config_file}" "${pool_name}")"
-  claude_effort="$(flow_provider_pool_claude_effort "${config_file}" "${pool_name}")"
-  claude_timeout_seconds="$(flow_provider_pool_claude_timeout_seconds "${config_file}" "${pool_name}")"
-  claude_max_attempts="$(flow_provider_pool_claude_max_attempts "${config_file}" "${pool_name}")"
-  claude_retry_backoff_seconds="$(flow_provider_pool_claude_retry_backoff_seconds "${config_file}" "${pool_name}")"
-  openclaw_model="$(flow_provider_pool_openclaw_model "${config_file}" "${pool_name}")"
-  openclaw_thinking="$(flow_provider_pool_openclaw_thinking "${config_file}" "${pool_name}")"
-  openclaw_timeout_seconds="$(flow_provider_pool_openclaw_timeout_seconds "${config_file}" "${pool_name}")"
-  ollama_model="$(flow_provider_pool_ollama_model "${config_file}" "${pool_name}")"
-  ollama_base_url="$(flow_provider_pool_ollama_base_url "${config_file}" "${pool_name}")"
-  ollama_timeout_seconds="$(flow_provider_pool_ollama_timeout_seconds "${config_file}" "${pool_name}")"
-  pi_model="$(flow_provider_pool_pi_model "${config_file}" "${pool_name}")"
-  pi_thinking="$(flow_provider_pool_pi_thinking "${config_file}" "${pool_name}")"
-  pi_timeout_seconds="$(flow_provider_pool_pi_timeout_seconds "${config_file}" "${pool_name}")"
-  opencode_model="$(flow_provider_pool_opencode_model "${config_file}" "${pool_name}")"
-  opencode_timeout_seconds="$(flow_provider_pool_opencode_timeout_seconds "${config_file}" "${pool_name}")"
-  kilo_model="$(flow_provider_pool_kilo_model "${config_file}" "${pool_name}")"
-  kilo_timeout_seconds="$(flow_provider_pool_kilo_timeout_seconds "${config_file}" "${pool_name}")"
-  model="$(flow_provider_pool_model_identity "${config_file}" "${pool_name}")"
-  case "${backend}" in
-    codex)
-      [[ -n "${safe_profile}" && -n "${bypass_profile}" ]] || valid="no"
-      ;;
-    claude)
-      [[ -n "${claude_model}" && -n "${claude_permission_mode}" && -n "${claude_effort}" && -n "${claude_timeout_seconds}" && -n "${claude_max_attempts}" && -n "${claude_retry_backoff_seconds}" ]] || valid="no"
-      ;;
-    openclaw)
-      [[ -n "${openclaw_model}" && -n "${openclaw_thinking}" && -n "${openclaw_timeout_seconds}" ]] || valid="no"
-      ;;
-    ollama)
-      [[ -n "${ollama_model}" ]] || valid="no"
-      ;;
-    pi)
-      [[ -n "${pi_model}" ]] || valid="no"
-      ;;
-    opencode)
-      [[ -n "${opencode_model}" && -n "${opencode_timeout_seconds}" ]] || valid="no"
-      ;;
-    kilo)
-      [[ -n "${kilo_model}" && -n "${kilo_timeout_seconds}" ]] || valid="no"
-      ;;
-    *)
-      valid="no"
-      ;;
-  esac
-  if [[ "${valid}" == "yes" && -n "${model}" ]]; then
-    state_root="$(flow_resolve_state_root "${config_file}")"
-    provider_key="$(flow_sanitize_provider_key "${backend}-${model}")"
-    state_file="${state_root}/retries/providers/${provider_key}.env"
-    if [[ -f "${state_file}" ]]; then
-      set -a
-      # shellcheck source=/dev/null
-      source "${state_file}"
-      set +a
-      attempts="${ATTEMPTS:-0}"
-      next_attempt_epoch="${NEXT_ATTEMPT_EPOCH:-0}"
-      next_attempt_at="${NEXT_ATTEMPT_AT:-}"
-      last_reason="${LAST_REASON:-}"
-      updated_at="${UPDATED_AT:-}"
-    fi
-    now_epoch="$(date +%s)"
-    if [[ "${next_attempt_epoch}" =~ ^[0-9]+$ ]] && (( next_attempt_epoch > now_epoch )); then
-      ready="no"
-    fi
-  else
-    ready="no"
-  fi
-  printf 'POOL_NAME=%s\n' "${pool_name}"
-  printf 'VALID=%s\n' "${valid}"
-  printf 'BACKEND=%s\n' "${backend}"
-  printf 'MODEL=%s\n' "${model}"
-  printf 'PROVIDER_KEY=%s\n' "${provider_key}"
-  printf 'ATTEMPTS=%s\n' "${attempts}"
-  printf 'NEXT_ATTEMPT_EPOCH=%s\n' "${next_attempt_epoch}"
-  printf 'NEXT_ATTEMPT_AT=%s\n' "${next_attempt_at}"
-  printf 'READY=%s\n' "${ready}"
-  printf 'LAST_REASON=%s\n' "${last_reason}"
-  printf 'UPDATED_AT=%s\n' "${updated_at}"
-  printf 'SAFE_PROFILE=%s\n' "${safe_profile}"
-  printf 'BYPASS_PROFILE=%s\n' "${bypass_profile}"
-  printf 'CLAUDE_MODEL=%s\n' "${claude_model}"
-  printf 'CLAUDE_PERMISSION_MODE=%s\n' "${claude_permission_mode}"
-  printf 'CLAUDE_EFFORT=%s\n' "${claude_effort}"
-  printf 'CLAUDE_TIMEOUT_SECONDS=%s\n' "${claude_timeout_seconds}"
-  printf 'CLAUDE_MAX_ATTEMPTS=%s\n' "${claude_max_attempts}"
-  printf 'CLAUDE_RETRY_BACKOFF_SECONDS=%s\n' "${claude_retry_backoff_seconds}"
-  printf 'OPENCLAW_MODEL=%s\n' "${openclaw_model}"
-  printf 'OPENCLAW_THINKING=%s\n' "${openclaw_thinking}"
-  printf 'OPENCLAW_TIMEOUT_SECONDS=%s\n' "${openclaw_timeout_seconds}"
-  printf 'OLLAMA_MODEL=%s\n' "${ollama_model}"
-  printf 'OLLAMA_BASE_URL=%s\n' "${ollama_base_url}"
-  printf 'OLLAMA_TIMEOUT_SECONDS=%s\n' "${ollama_timeout_seconds}"
-  printf 'PI_MODEL=%s\n' "${pi_model}"
-  printf 'PI_THINKING=%s\n' "${pi_thinking}"
-  printf 'PI_TIMEOUT_SECONDS=%s\n' "${pi_timeout_seconds}"
-  printf 'OPENCODE_MODEL=%s\n' "${opencode_model}"
-  printf 'OPENCODE_TIMEOUT_SECONDS=%s\n' "${opencode_timeout_seconds}"
-  printf 'KILO_MODEL=%s\n' "${kilo_model}"
-  printf 'KILO_TIMEOUT_SECONDS=%s\n' "${kilo_timeout_seconds}"
-}
-flow_selected_provider_pool_env() {
-  local config_file="${1:-}"
-  local pool_name=""
-  local candidate=""
-  local candidate_valid=""
-  local candidate_ready=""
-  local candidate_next_epoch="0"
-  local exhausted_candidate=""
-  local exhausted_epoch=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  if ! flow_provider_pools_enabled "${config_file}"; then
-    return 1
-  fi
-  while IFS= read -r pool_name; do
-    [[ -n "${pool_name}" ]] || continue
-    candidate="$(flow_provider_pool_state_get "${config_file}" "${pool_name}")"
-    candidate_valid="$(awk -F= '/^VALID=/{print $2}' <<<"${candidate}")"
-    [[ "${candidate_valid}" == "yes" ]] || continue
-    candidate_ready="$(awk -F= '/^READY=/{print $2}' <<<"${candidate}")"
-    if [[ "${candidate_ready}" == "yes" ]]; then
-      printf '%s\n' "${candidate}"
-      printf 'POOLS_EXHAUSTED=no\n'
-      printf 'SELECTION_REASON=ready\n'
-      return 0
-    fi
-    candidate_next_epoch="$(awk -F= '/^NEXT_ATTEMPT_EPOCH=/{print $2}' <<<"${candidate}")"
-    if [[ -z "${exhausted_candidate}" ]]; then
-      exhausted_candidate="${candidate}"
-      exhausted_epoch="${candidate_next_epoch}"
-      continue
-    fi
-    if [[ "${candidate_next_epoch}" =~ ^[0-9]+$ && "${exhausted_epoch}" =~ ^[0-9]+$ ]] && (( candidate_next_epoch < exhausted_epoch )); then
-      exhausted_candidate="${candidate}"
-      exhausted_epoch="${candidate_next_epoch}"
-    fi
-  done < <(flow_provider_pool_names "${config_file}")
-  [[ -n "${exhausted_candidate}" ]] || return 1
-  printf '%s\n' "${exhausted_candidate}"
-  printf 'POOLS_EXHAUSTED=yes\n'
-  printf 'SELECTION_REASON=all-cooldown\n'
-}
-flow_resolve_issue_session_prefix() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_issue_session_prefix "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_ISSUE_SESSION_PREFIX F_LOSNING_ISSUE_SESSION_PREFIX" "session_naming.issue_prefix" "${default_value}"
-}
-flow_resolve_pr_session_prefix() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_pr_session_prefix "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_PR_SESSION_PREFIX F_LOSNING_PR_SESSION_PREFIX" "session_naming.pr_prefix" "${default_value}"
-}
-flow_resolve_issue_branch_prefix() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_issue_branch_prefix "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_ISSUE_BRANCH_PREFIX F_LOSNING_ISSUE_BRANCH_PREFIX" "session_naming.issue_branch_prefix" "${default_value}"
-}
-flow_resolve_pr_worktree_branch_prefix() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_pr_worktree_branch_prefix "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_PR_WORKTREE_BRANCH_PREFIX F_LOSNING_PR_WORKTREE_BRANCH_PREFIX" "session_naming.pr_worktree_branch_prefix" "${default_value}"
-}
-flow_resolve_managed_pr_branch_globs() {
-  local config_file="${1:-}"
-  local default_value=""
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  default_value="$(flow_default_managed_pr_branch_globs "${config_file}")"
-  flow_env_or_config "${config_file}" "ACP_MANAGED_PR_BRANCH_GLOBS F_LOSNING_MANAGED_PR_BRANCH_GLOBS" "session_naming.managed_pr_branch_globs" "${default_value}"
-}
-flow_escape_regex() {
-  local raw_value="${1:-}"
-  python3 - "${raw_value}" <<'PY'
-import re
-import sys
-print(re.escape(sys.argv[1]))
-PY
-}
-flow_managed_pr_prefixes() {
-  local config_file="${1:-}"
-  local managed_globs=""
-  local branch_glob=""
-  local prefix=""
-  managed_globs="$(flow_resolve_managed_pr_branch_globs "${config_file}")"
-  for branch_glob in ${managed_globs}; do
-    prefix="${branch_glob%\*}"
-    [[ -n "${prefix}" ]] || continue
-    printf '%s\n' "${prefix}"
-  done
-}
-flow_managed_pr_prefixes_json() {
-  local config_file="${1:-}"
-  local prefixes=()
-  local prefix=""
-  while IFS= read -r prefix; do
-    [[ -n "${prefix}" ]] || continue
-    prefixes+=("${prefix}")
-  done < <(flow_managed_pr_prefixes "${config_file}")
-  python3 - "${prefixes[@]}" <<'PY'
-import json
-import sys
-print(json.dumps(sys.argv[1:]))
-PY
-}
-flow_managed_issue_branch_regex() {
-  local config_file="${1:-}"
-  local prefix=""
-  local normalized_prefix=""
-  local escaped_prefix=""
-  local joined=""
-  while IFS= read -r prefix; do
-    [[ -n "${prefix}" ]] || continue
-    normalized_prefix="${prefix%/}"
-    escaped_prefix="$(flow_escape_regex "${normalized_prefix}")"
-    if [[ -n "${joined}" ]]; then
-      joined="${joined}|${escaped_prefix}"
-    else
-      joined="${escaped_prefix}"
-    fi
-  done < <(flow_managed_pr_prefixes "${config_file}")
-  if [[ -z "${joined}" ]]; then
-    joined="$(flow_escape_regex "agent/$(flow_resolve_adapter_id "${config_file}")")"
-  fi
-  printf '^(?:%s)/issue-(?<id>[0-9]+)(?:-|$)\n' "${joined}"
-}
-flow_export_execution_env() {
-  local config_file="${1:-}"
-  if [[ -z "${config_file}" ]]; then
-    config_file="$(resolve_flow_config_yaml "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
-  fi
-  [[ -f "${config_file}" ]] || return 0
-  local repo_id=""
-  local coding_worker=""
-  local provider_quota_cooldowns=""
-  local provider_pool_order=""
-  local provider_pool_selection=""
-  local explicit_coding_worker=""
-  local active_provider_pool_name=""
-  local active_provider_backend=""
-  local active_provider_model=""
-  local active_provider_key=""
-  local active_provider_next_attempt_epoch=""
-  local active_provider_next_attempt_at=""
-  local active_provider_last_reason=""
-  local active_provider_pools_exhausted="no"
-  local active_provider_selection_reason="legacy-config"
-  local safe_profile=""
-  local bypass_profile=""
-  local claude_model=""
-  local claude_permission_mode=""
-  local claude_effort=""
-  local claude_timeout=""
-  local claude_max_attempts=""
-  local claude_retry_backoff_seconds=""
-  local openclaw_model=""
-  local openclaw_thinking=""
-  local openclaw_timeout=""
-  local openclaw_stall=""
-  local ollama_model=""
-  local ollama_base_url=""
-  local ollama_timeout=""
-  local pi_model=""
-  local pi_thinking=""
-  local pi_timeout=""
-  local opencode_model=""
-  local opencode_timeout=""
-  local kilo_model=""
-  local kilo_timeout=""
-  repo_id="$(flow_resolve_repo_id "${config_file}")"
-  provider_quota_cooldowns="$(flow_resolve_provider_quota_cooldowns "${config_file}")"
-  provider_pool_order="$(flow_resolve_provider_pool_order "${config_file}")"
-  explicit_coding_worker="${ACP_CODING_WORKER:-}"
-  if [[ -z "${explicit_coding_worker}" && -n "${provider_pool_order}" ]]; then
-    provider_pool_selection="$(flow_selected_provider_pool_env "${config_file}" || true)"
-  fi
-  if [[ -n "${provider_pool_selection}" ]]; then
-    active_provider_pool_name="$(flow_kv_get "${provider_pool_selection}" "POOL_NAME")"
-    active_provider_backend="$(flow_kv_get "${provider_pool_selection}" "BACKEND")"
-    active_provider_model="$(flow_kv_get "${provider_pool_selection}" "MODEL")"
-    active_provider_key="$(flow_kv_get "${provider_pool_selection}" "PROVIDER_KEY")"
-    active_provider_next_attempt_epoch="$(flow_kv_get "${provider_pool_selection}" "NEXT_ATTEMPT_EPOCH")"
-    active_provider_next_attempt_at="$(flow_kv_get "${provider_pool_selection}" "NEXT_ATTEMPT_AT")"
-    active_provider_last_reason="$(flow_kv_get "${provider_pool_selection}" "LAST_REASON")"
-    active_provider_pools_exhausted="$(flow_kv_get "${provider_pool_selection}" "POOLS_EXHAUSTED")"
-    active_provider_selection_reason="$(flow_kv_get "${provider_pool_selection}" "SELECTION_REASON")"
-    coding_worker="${active_provider_backend}"
-    safe_profile="$(flow_kv_get "${provider_pool_selection}" "SAFE_PROFILE")"
-    bypass_profile="$(flow_kv_get "${provider_pool_selection}" "BYPASS_PROFILE")"
-    claude_model="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_MODEL")"
-    claude_permission_mode="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_PERMISSION_MODE")"
-    claude_effort="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_EFFORT")"
-    claude_timeout="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_TIMEOUT_SECONDS")"
-    claude_max_attempts="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_MAX_ATTEMPTS")"
-    claude_retry_backoff_seconds="$(flow_kv_get "${provider_pool_selection}" "CLAUDE_RETRY_BACKOFF_SECONDS")"
-    openclaw_model="$(flow_kv_get "${provider_pool_selection}" "OPENCLAW_MODEL")"
-    openclaw_thinking="$(flow_kv_get "${provider_pool_selection}" "OPENCLAW_THINKING")"
-    openclaw_timeout="$(flow_kv_get "${provider_pool_selection}" "OPENCLAW_TIMEOUT_SECONDS")"
-    openclaw_stall="$(flow_kv_get "${provider_pool_selection}" "OPENCLAW_STALL_SECONDS")"
-    ollama_model="$(flow_kv_get "${provider_pool_selection}" "OLLAMA_MODEL")"
-    ollama_base_url="$(flow_kv_get "${provider_pool_selection}" "OLLAMA_BASE_URL")"
-    ollama_timeout="$(flow_kv_get "${provider_pool_selection}" "OLLAMA_TIMEOUT_SECONDS")"
-    pi_model="$(flow_kv_get "${provider_pool_selection}" "PI_MODEL")"
-    pi_thinking="$(flow_kv_get "${provider_pool_selection}" "PI_THINKING")"
-    pi_timeout="$(flow_kv_get "${provider_pool_selection}" "PI_TIMEOUT_SECONDS")"
-    opencode_model="$(flow_kv_get "${provider_pool_selection}" "OPENCODE_MODEL")"
-    opencode_timeout="$(flow_kv_get "${provider_pool_selection}" "OPENCODE_TIMEOUT_SECONDS")"
-    kilo_model="$(flow_kv_get "${provider_pool_selection}" "KILO_MODEL")"
-    kilo_timeout="$(flow_kv_get "${provider_pool_selection}" "KILO_TIMEOUT_SECONDS")"
-  else
-    if [[ -n "${explicit_coding_worker}" ]]; then
-      active_provider_selection_reason="env-override"
-    fi
-    coding_worker="$(flow_env_or_config "${config_file}" "ACP_CODING_WORKER" "execution.coding_worker" "")"
-    safe_profile="$(flow_env_or_config "${config_file}" "ACP_CODEX_PROFILE_SAFE F_LOSNING_CODEX_PROFILE_SAFE" "execution.safe_profile" "")"
-    bypass_profile="$(flow_env_or_config "${config_file}" "ACP_CODEX_PROFILE_BYPASS F_LOSNING_CODEX_PROFILE_BYPASS" "execution.bypass_profile" "")"
-    claude_model="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_MODEL F_LOSNING_CLAUDE_MODEL" "execution.claude.model" "")"
-    claude_permission_mode="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_PERMISSION_MODE F_LOSNING_CLAUDE_PERMISSION_MODE" "execution.claude.permission_mode" "")"
-    claude_effort="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_EFFORT F_LOSNING_CLAUDE_EFFORT" "execution.claude.effort" "")"
-    claude_timeout="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_TIMEOUT_SECONDS F_LOSNING_CLAUDE_TIMEOUT_SECONDS" "execution.claude.timeout_seconds" "")"
-    claude_max_attempts="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_MAX_ATTEMPTS F_LOSNING_CLAUDE_MAX_ATTEMPTS" "execution.claude.max_attempts" "")"
-    claude_retry_backoff_seconds="$(flow_env_or_config "${config_file}" "ACP_CLAUDE_RETRY_BACKOFF_SECONDS F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS" "execution.claude.retry_backoff_seconds" "")"
-    openclaw_model="$(flow_env_or_config "${config_file}" "ACP_OPENCLAW_MODEL F_LOSNING_OPENCLAW_MODEL" "execution.openclaw.model" "")"
-    openclaw_thinking="$(flow_env_or_config "${config_file}" "ACP_OPENCLAW_THINKING F_LOSNING_OPENCLAW_THINKING" "execution.openclaw.thinking" "")"
-    openclaw_timeout="$(flow_env_or_config "${config_file}" "ACP_OPENCLAW_TIMEOUT_SECONDS F_LOSNING_OPENCLAW_TIMEOUT_SECONDS" "execution.openclaw.timeout_seconds" "")"
-    openclaw_stall="$(flow_env_or_config "${config_file}" "ACP_OPENCLAW_STALL_SECONDS F_LOSNING_OPENCLAW_STALL_SECONDS" "execution.openclaw.stall_seconds" "")"
-    ollama_model="$(flow_env_or_config "${config_file}" "ACP_OLLAMA_MODEL F_LOSNING_OLLAMA_MODEL" "execution.ollama.model" "")"
-    ollama_base_url="$(flow_env_or_config "${config_file}" "ACP_OLLAMA_BASE_URL F_LOSNING_OLLAMA_BASE_URL" "execution.ollama.base_url" "")"
-    ollama_timeout="$(flow_env_or_config "${config_file}" "ACP_OLLAMA_TIMEOUT_SECONDS F_LOSNING_OLLAMA_TIMEOUT_SECONDS" "execution.ollama.timeout_seconds" "")"
-    pi_model="$(flow_env_or_config "${config_file}" "ACP_PI_MODEL F_LOSNING_PI_MODEL" "execution.pi.model" "")"
-    pi_thinking="$(flow_env_or_config "${config_file}" "ACP_PI_THINKING F_LOSNING_PI_THINKING" "execution.pi.thinking" "")"
-    pi_timeout="$(flow_env_or_config "${config_file}" "ACP_PI_TIMEOUT_SECONDS F_LOSNING_PI_TIMEOUT_SECONDS" "execution.pi.timeout_seconds" "")"
-    opencode_model="$(flow_env_or_config "${config_file}" "ACP_OPENCODE_MODEL F_LOSNING_OPENCODE_MODEL" "execution.opencode.model" "")"
-    opencode_timeout="$(flow_env_or_config "${config_file}" "ACP_OPENCODE_TIMEOUT_SECONDS F_LOSNING_OPENCODE_TIMEOUT_SECONDS" "execution.opencode.timeout_seconds" "")"
-    kilo_model="$(flow_env_or_config "${config_file}" "ACP_KILO_MODEL F_LOSNING_KILO_MODEL" "execution.kilo.model" "")"
-    kilo_timeout="$(flow_env_or_config "${config_file}" "ACP_KILO_TIMEOUT_SECONDS F_LOSNING_KILO_TIMEOUT_SECONDS" "execution.kilo.timeout_seconds" "")"
-  fi
-  if [[ -n "${coding_worker}" ]]; then
-    export ACP_CODING_WORKER="${coding_worker}"
-  fi
-  if [[ -n "${repo_id}" ]]; then
-    export F_LOSNING_REPO_ID="${repo_id}"
-    export ACP_REPO_ID="${repo_id}"
-    export F_LOSNING_GITHUB_REPOSITORY_ID="${repo_id}"
-    export ACP_GITHUB_REPOSITORY_ID="${repo_id}"
-  fi
-  if [[ -n "${provider_quota_cooldowns}" ]]; then
-    export F_LOSNING_PROVIDER_QUOTA_COOLDOWNS="${provider_quota_cooldowns}"
-    export ACP_PROVIDER_QUOTA_COOLDOWNS="${provider_quota_cooldowns}"
-  fi
-  export F_LOSNING_PROVIDER_POOL_ORDER="${provider_pool_order}"
-  export ACP_PROVIDER_POOL_ORDER="${provider_pool_order}"
-  export F_LOSNING_ACTIVE_PROVIDER_POOL_NAME="${active_provider_pool_name}"
-  export ACP_ACTIVE_PROVIDER_POOL_NAME="${active_provider_pool_name}"
-  export F_LOSNING_ACTIVE_PROVIDER_BACKEND="${active_provider_backend}"
-  export ACP_ACTIVE_PROVIDER_BACKEND="${active_provider_backend}"
-  export F_LOSNING_ACTIVE_PROVIDER_MODEL="${active_provider_model}"
-  export ACP_ACTIVE_PROVIDER_MODEL="${active_provider_model}"
-  export F_LOSNING_ACTIVE_PROVIDER_KEY="${active_provider_key}"
-  export ACP_ACTIVE_PROVIDER_KEY="${active_provider_key}"
-  export F_LOSNING_PROVIDER_POOLS_EXHAUSTED="${active_provider_pools_exhausted}"
-  export ACP_PROVIDER_POOLS_EXHAUSTED="${active_provider_pools_exhausted}"
-  export F_LOSNING_PROVIDER_POOL_SELECTION_REASON="${active_provider_selection_reason}"
-  export ACP_PROVIDER_POOL_SELECTION_REASON="${active_provider_selection_reason}"
-  export F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH="${active_provider_next_attempt_epoch}"
-  export ACP_PROVIDER_POOL_NEXT_ATTEMPT_EPOCH="${active_provider_next_attempt_epoch}"
-  export F_LOSNING_PROVIDER_POOL_NEXT_ATTEMPT_AT="${active_provider_next_attempt_at}"
-  export ACP_PROVIDER_POOL_NEXT_ATTEMPT_AT="${active_provider_next_attempt_at}"
-  export F_LOSNING_PROVIDER_POOL_LAST_REASON="${active_provider_last_reason}"
-  export ACP_PROVIDER_POOL_LAST_REASON="${active_provider_last_reason}"
-  if [[ -n "${safe_profile}" ]]; then
-    export F_LOSNING_CODEX_PROFILE_SAFE="${safe_profile}"
-    export ACP_CODEX_PROFILE_SAFE="${safe_profile}"
-  fi
-  if [[ -n "${bypass_profile}" ]]; then
-    export F_LOSNING_CODEX_PROFILE_BYPASS="${bypass_profile}"
-    export ACP_CODEX_PROFILE_BYPASS="${bypass_profile}"
-  fi
-  if [[ -n "${claude_model}" ]]; then
-    export F_LOSNING_CLAUDE_MODEL="${claude_model}"
-    export ACP_CLAUDE_MODEL="${claude_model}"
-  fi
-  if [[ -n "${claude_permission_mode}" ]]; then
-    export F_LOSNING_CLAUDE_PERMISSION_MODE="${claude_permission_mode}"
-    export ACP_CLAUDE_PERMISSION_MODE="${claude_permission_mode}"
-  fi
-  if [[ -n "${claude_effort}" ]]; then
-    export F_LOSNING_CLAUDE_EFFORT="${claude_effort}"
-    export ACP_CLAUDE_EFFORT="${claude_effort}"
-  fi
-  if [[ -n "${claude_timeout}" ]]; then
-    export F_LOSNING_CLAUDE_TIMEOUT_SECONDS="${claude_timeout}"
-    export ACP_CLAUDE_TIMEOUT_SECONDS="${claude_timeout}"
-  fi
-  if [[ -n "${claude_max_attempts}" ]]; then
-    export F_LOSNING_CLAUDE_MAX_ATTEMPTS="${claude_max_attempts}"
-    export ACP_CLAUDE_MAX_ATTEMPTS="${claude_max_attempts}"
-  fi
-  if [[ -n "${claude_retry_backoff_seconds}" ]]; then
-    export F_LOSNING_CLAUDE_RETRY_BACKOFF_SECONDS="${claude_retry_backoff_seconds}"
-    export ACP_CLAUDE_RETRY_BACKOFF_SECONDS="${claude_retry_backoff_seconds}"
-  fi
-  if [[ -n "${openclaw_model}" ]]; then
-    export F_LOSNING_OPENCLAW_MODEL="${openclaw_model}"
-    export ACP_OPENCLAW_MODEL="${openclaw_model}"
-  fi
-  if [[ -n "${openclaw_thinking}" ]]; then
-    export F_LOSNING_OPENCLAW_THINKING="${openclaw_thinking}"
-    export ACP_OPENCLAW_THINKING="${openclaw_thinking}"
-  fi
-  if [[ -n "${openclaw_timeout}" ]]; then
-    export F_LOSNING_OPENCLAW_TIMEOUT_SECONDS="${openclaw_timeout}"
-    export ACP_OPENCLAW_TIMEOUT_SECONDS="${openclaw_timeout}"
-  fi
-  if [[ -n "${openclaw_stall}" ]]; then
-    export F_LOSNING_OPENCLAW_STALL_SECONDS="${openclaw_stall}"
-    export ACP_OPENCLAW_STALL_SECONDS="${openclaw_stall}"
-  fi
-  if [[ -n "${ollama_model}" ]]; then
-    export F_LOSNING_OLLAMA_MODEL="${ollama_model}"
-    export ACP_OLLAMA_MODEL="${ollama_model}"
-  fi
-  if [[ -n "${ollama_base_url}" ]]; then
-    export F_LOSNING_OLLAMA_BASE_URL="${ollama_base_url}"
-    export ACP_OLLAMA_BASE_URL="${ollama_base_url}"
-  fi
-  if [[ -n "${ollama_timeout}" ]]; then
-    export F_LOSNING_OLLAMA_TIMEOUT_SECONDS="${ollama_timeout}"
-    export ACP_OLLAMA_TIMEOUT_SECONDS="${ollama_timeout}"
-  fi
-  if [[ -n "${pi_model}" ]]; then
-    export F_LOSNING_PI_MODEL="${pi_model}"
-    export ACP_PI_MODEL="${pi_model}"
-  fi
-  if [[ -n "${pi_thinking}" ]]; then
-    export F_LOSNING_PI_THINKING="${pi_thinking}"
-    export ACP_PI_THINKING="${pi_thinking}"
-  fi
-  if [[ -n "${pi_timeout}" ]]; then
-    export F_LOSNING_PI_TIMEOUT_SECONDS="${pi_timeout}"
-    export ACP_PI_TIMEOUT_SECONDS="${pi_timeout}"
-  fi
-  if [[ -n "${opencode_model}" ]]; then
-    export F_LOSNING_OPENCODE_MODEL="${opencode_model}"
-    export ACP_OPENCODE_MODEL="${opencode_model}"
-  fi
-  if [[ -n "${opencode_timeout}" ]]; then
-    export F_LOSNING_OPENCODE_TIMEOUT_SECONDS="${opencode_timeout}"
-    export ACP_OPENCODE_TIMEOUT_SECONDS="${opencode_timeout}"
-  fi
-  if [[ -n "${kilo_model}" ]]; then
-    export F_LOSNING_KILO_MODEL="${kilo_model}"
-    export ACP_KILO_MODEL="${kilo_model}"
-  fi
-  if [[ -n "${kilo_timeout}" ]]; then
-    export F_LOSNING_KILO_TIMEOUT_SECONDS="${kilo_timeout}"
-    export ACP_KILO_TIMEOUT_SECONDS="${kilo_timeout}"
-  fi
-  flow_export_github_cli_auth_env "$(flow_resolve_repo_slug "${config_file}")"
-  flow_export_project_env_aliases
-}
+# Load modules in dependency order
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-profile-lib.sh"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-forge-lib.sh"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-provider-lib.sh"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-session-lib.sh"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-execution-lib.sh"