agent-control-plane 0.2.0 → 0.4.9

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

@@ -243,13 +243,28 @@ flow_git_remote_repo_slug() {
   [[ -n "${remote_url}" ]] || return 1
 
   normalized="${remote_url%.git}"
-  normalized="${normalized#ssh://git@github.com/}"
-  normalized="${normalized#git@github.com:}"
-  normalized="${normalized#https://github.com/}"
-  normalized="${normalized#http://github.com/}"
+  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}" == "${remote_url%.git}" ]]; then
-    return 1
+  if [[ "${normalized}" == */*/* ]]; then
+    normalized="${normalized#*/}"
   fi
 
   if [[ "${normalized}" =~ ^[^/]+/[^/]+$ ]]; then
@@ -260,16 +275,76 @@ flow_git_remote_repo_slug() {
   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}" ]] || return 1
+  [[ -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=github.com\npath=%s.git\n\n' "${repo_slug}" \
+    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}")"
@@ -282,6 +357,10 @@ 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
@@ -309,9 +388,562 @@ flow_export_github_cli_auth_env() {
   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 remaining=""
+  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
@@ -320,9 +952,39 @@ flow_github_graphql_available() {
     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}"
-  remaining="$(gh api rate_limit --jq '.resources.graphql.remaining' 2>/dev/null || true)"
-  if [[ "${remaining}" =~ ^[0-9]+$ ]] && (( remaining > 0 )); then
+  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
@@ -343,6 +1005,8 @@ flow_github_repo_id_for_repo_slug() {
   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
@@ -361,12 +1025,25 @@ flow_github_repo_id_for_repo_slug() {
     return 0
   fi
 
+  if flow_github_core_rate_limit_active; then
+    return 1
+  fi
+
   flow_export_github_cli_auth_env "${repo_slug}"
-  repos_pages_json="$(
+  stderr_file="$(mktemp)"
+  if repos_pages_json="$(
     gh api 'user/repos?per_page=100&visibility=all&affiliation=owner,collaborator,organization_member' \
       --paginate \
-      --slurp 2>/dev/null || true
-  )"
+      --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="$(
@@ -415,13 +1092,21 @@ flow_github_api_repo() {
   local fallback_route=""
   local output=""
   local stdin_file=""
-  local status=0
+  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}"
@@ -447,21 +1132,40 @@ flow_github_api_repo() {
     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
-    output="$(gh api "${direct_route}" "${gh_args[@]}" 2>/dev/null)" && {
+    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}"
+      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
       return 0
-    }
-  elif output="$(gh api "${direct_route}" 2>/dev/null)"; then
-    printf '%s' "${output}"
-    rm -f "${stdin_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}"
+    rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
     return 1
   fi
   fallback_route="${repo_prefix}"
@@ -469,19 +1173,32 @@ flow_github_api_repo() {
     fallback_route="${fallback_route}/${route}"
   fi
   if [[ "${gh_arg_count}" -gt 0 ]]; then
-    output="$(gh api "${fallback_route}" "${gh_args[@]}")" && {
+    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}"
+      rm -f "${stdin_file}" "${stdout_file}" "${stderr_file}"
       return 0
-    }
-  elif output="$(gh api "${fallback_route}")"; then
-    printf '%s' "${output}"
-    rm -f "${stdin_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
-  status=$?
-  rm -f "${stdin_file}"
-  return "${status}"
+  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() {
@@ -511,12 +1228,81 @@ 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}"
@@ -562,7 +1348,67 @@ result = {
     "updatedAt": issue.get("updated_at") or "",
 }
 
-print(json.dumps(result))
+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
 }
 
@@ -573,6 +1419,11 @@ flow_github_issue_list_json() {
   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}"
@@ -629,6 +1480,11 @@ flow_github_pr_view_json() {
   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}"
@@ -704,6 +1560,7 @@ result = {
     "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,
@@ -723,10 +1580,154 @@ result = {
     "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() {
@@ -744,6 +1745,11 @@ flow_github_pr_list_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}"
@@ -874,6 +1880,15 @@ flow_github_issue_close() {
   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
@@ -933,6 +1948,25 @@ flow_github_issue_create() {
   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
@@ -955,6 +1989,66 @@ PY
   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}"
@@ -964,6 +2058,27 @@ flow_github_pr_create() {
   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
@@ -997,6 +2112,24 @@ flow_github_pr_merge() {
   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
@@ -1429,6 +2562,16 @@ flow_resolve_retained_repo_root() {
   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=""
@@ -1741,6 +2884,34 @@ flow_provider_pool_pi_timeout_seconds() {
   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}"
 
@@ -1771,6 +2942,12 @@ flow_provider_pool_model_identity() {
     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'
       ;;
@@ -1810,6 +2987,10 @@ flow_provider_pool_state_get() {
   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}")"
@@ -1829,6 +3010,10 @@ flow_provider_pool_state_get() {
   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
@@ -1847,6 +3032,12 @@ flow_provider_pool_state_get() {
     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"
       ;;
@@ -1905,6 +3096,10 @@ flow_provider_pool_state_get() {
   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() {
@@ -2118,6 +3313,10 @@ flow_export_execution_env() {
   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}")"
@@ -2157,6 +3356,10 @@ flow_export_execution_env() {
     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"
@@ -2180,6 +3383,10 @@ flow_export_execution_env() {
     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
@@ -2287,6 +3494,22 @@ flow_export_execution_env() {
     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