agent-control-plane 0.1.14 → 0.2.0

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

@@ -1699,6 +1699,48 @@ flow_provider_pool_openclaw_timeout_seconds() {
   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_sanitize_provider_key() {
   local raw_key="${1:?raw key required}"
 
@@ -1723,6 +1765,12 @@ flow_provider_pool_model_identity() {
     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}"
+      ;;
     *)
       printf '\n'
       ;;
@@ -1756,6 +1804,12 @@ flow_provider_pool_state_get() {
   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=""
 
   backend="$(flow_provider_pool_backend "${config_file}" "${pool_name}")"
   safe_profile="$(flow_provider_pool_safe_profile "${config_file}" "${pool_name}")"
@@ -1769,6 +1823,12 @@ flow_provider_pool_state_get() {
   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}")"
   model="$(flow_provider_pool_model_identity "${config_file}" "${pool_name}")"
 
   case "${backend}" in
@@ -1781,6 +1841,12 @@ flow_provider_pool_state_get() {
     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"
+      ;;
     *)
       valid="no"
       ;;
@@ -1833,6 +1899,12 @@ flow_provider_pool_state_get() {
   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}"
 }
 
 flow_selected_provider_pool_env() {
@@ -2039,11 +2111,18 @@ flow_export_execution_env() {
   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=""
 
   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:-${F_LOSNING_CODING_WORKER:-}}"
+  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
@@ -2071,11 +2150,18 @@ flow_export_execution_env() {
     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")"
   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 F_LOSNING_CODING_WORKER" "execution.coding_worker" "")"
+    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" "")"
@@ -2087,10 +2173,16 @@ flow_export_execution_env() {
     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" "")"
   fi
 
   if [[ -n "${coding_worker}" ]]; then
-    export F_LOSNING_CODING_WORKER="${coding_worker}"
     export ACP_CODING_WORKER="${coding_worker}"
   fi
   if [[ -n "${repo_id}" ]]; then
@@ -2167,6 +2259,34 @@ flow_export_execution_env() {
     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
 
   flow_export_github_cli_auth_env "$(flow_resolve_repo_slug "${config_file}")"
   flow_export_project_env_aliases

package/tools/bin/flow-resident-worker-lib.sh

@@ -118,7 +118,7 @@ flow_resident_issue_backend_supported() {
   local backend="${1:-}"
 
   case "${backend}" in
-    codex|openclaw|claude)
+    codex|openclaw|claude|ollama|pi)
       return 0
       ;;
     *)

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

@@ -35,7 +35,6 @@ flow_export_compat_env_aliases() {
   flow_export_env_alias_if_unset F_LOSNING_MEMORY_DIR ACP_MEMORY_DIR
   flow_export_env_alias_if_unset F_LOSNING_RETAINED_REPO_ROOT ACP_RETAINED_REPO_ROOT
   flow_export_env_alias_if_unset F_LOSNING_VSCODE_WORKSPACE_FILE ACP_VSCODE_WORKSPACE_FILE
-  flow_export_env_alias_if_unset F_LOSNING_CODING_WORKER ACP_CODING_WORKER
   flow_export_env_alias_if_unset F_LOSNING_CODEX_PROFILE_SAFE ACP_CODEX_PROFILE_SAFE
   flow_export_env_alias_if_unset F_LOSNING_CODEX_PROFILE_BYPASS ACP_CODEX_PROFILE_BYPASS
   flow_export_env_alias_if_unset F_LOSNING_CLAUDE_MODEL ACP_CLAUDE_MODEL
@@ -52,6 +51,7 @@ flow_export_compat_env_aliases() {
   flow_export_env_alias_if_unset F_LOSNING_OPENCLAW_MODEL ACP_OPENCLAW_MODEL
   flow_export_env_alias_if_unset F_LOSNING_OPENCLAW_THINKING ACP_OPENCLAW_THINKING
   flow_export_env_alias_if_unset F_LOSNING_OPENCLAW_TIMEOUT_SECONDS ACP_OPENCLAW_TIMEOUT_SECONDS
+  flow_export_env_alias_if_unset F_LOSNING_OPENCLAW_STALL_SECONDS ACP_OPENCLAW_STALL_SECONDS
   flow_export_env_alias_if_unset F_LOSNING_ALLOW_INFRA_CI_BYPASS ACP_ALLOW_INFRA_CI_BYPASS
   flow_export_env_alias_if_unset F_LOSNING_LOCAL_FIRST_PR_POLICY ACP_LOCAL_FIRST_PR_POLICY
   flow_export_env_alias_if_unset F_LOSNING_PR_RISK_CACHE_TTL_SECONDS ACP_PR_RISK_CACHE_TTL_SECONDS
@@ -83,7 +83,6 @@ flow_export_canonical_env_aliases() {
   flow_export_env_alias_if_unset ACP_MEMORY_DIR F_LOSNING_MEMORY_DIR
   flow_export_env_alias_if_unset ACP_RETAINED_REPO_ROOT F_LOSNING_RETAINED_REPO_ROOT
   flow_export_env_alias_if_unset ACP_VSCODE_WORKSPACE_FILE F_LOSNING_VSCODE_WORKSPACE_FILE
-  flow_export_env_alias_if_unset ACP_CODING_WORKER F_LOSNING_CODING_WORKER
   flow_export_env_alias_if_unset ACP_CODEX_PROFILE_SAFE F_LOSNING_CODEX_PROFILE_SAFE
   flow_export_env_alias_if_unset ACP_CODEX_PROFILE_BYPASS F_LOSNING_CODEX_PROFILE_BYPASS
   flow_export_env_alias_if_unset ACP_CLAUDE_MODEL F_LOSNING_CLAUDE_MODEL
@@ -100,6 +99,7 @@ flow_export_canonical_env_aliases() {
   flow_export_env_alias_if_unset ACP_OPENCLAW_MODEL F_LOSNING_OPENCLAW_MODEL
   flow_export_env_alias_if_unset ACP_OPENCLAW_THINKING F_LOSNING_OPENCLAW_THINKING
   flow_export_env_alias_if_unset ACP_OPENCLAW_TIMEOUT_SECONDS F_LOSNING_OPENCLAW_TIMEOUT_SECONDS
+  flow_export_env_alias_if_unset ACP_OPENCLAW_STALL_SECONDS F_LOSNING_OPENCLAW_STALL_SECONDS
   flow_export_env_alias_if_unset ACP_ALLOW_INFRA_CI_BYPASS F_LOSNING_ALLOW_INFRA_CI_BYPASS
   flow_export_env_alias_if_unset ACP_LOCAL_FIRST_PR_POLICY F_LOSNING_LOCAL_FIRST_PR_POLICY
   flow_export_env_alias_if_unset ACP_PR_RISK_CACHE_TTL_SECONDS F_LOSNING_PR_RISK_CACHE_TTL_SECONDS
@@ -221,6 +221,11 @@ resolve_shared_agent_home() {
     flow_root="$(resolve_flow_skill_dir "${BASH_SOURCE[1]:-${BASH_SOURCE[0]}}")"
   fi
 
+  if flow_is_skill_root "${flow_root}"; then
+    flow_print_dir "${flow_root}"
+    return 0
+  fi
+
   flow_print_dir "${flow_root}/../../.."
 }
 

package/tools/bin/heartbeat-recovery-preflight.sh

@@ -80,6 +80,7 @@ run_preflight_test "heartbeat-no-tmux-sessions" "${TEST_DIR}/test-heartbeat-safe
 run_preflight_test "heartbeat-static-capacity-without-quota-cache" "${TEST_DIR}/test-heartbeat-safe-auto-static-capacity-without-quota-cache.sh"
 run_preflight_test "heartbeat-openclaw-skips-codex-quota" "${TEST_DIR}/test-heartbeat-safe-auto-openclaw-skips-codex-quota.sh"
 run_preflight_test "heartbeat-empty-schedule-label-sync" "${TEST_DIR}/test-heartbeat-sync-issue-labels-empty-schedule.sh"
+run_preflight_test "heartbeat-open-issue-terminal-sync" "${TEST_DIR}/test-heartbeat-sync-open-agent-issues-terminal-clears-running.sh"
 run_preflight_test "heartbeat-open-pr-terminal-sync" "${TEST_DIR}/test-heartbeat-sync-open-agent-prs-terminal-clears-running.sh"
 run_preflight_test "heartbeat-pr-launch-dedup" "${TEST_DIR}/test-heartbeat-loop-pr-launch-dedup.sh"
 run_preflight_test "heartbeat-auth-wait-capacity" "${TEST_DIR}/test-heartbeat-loop-auth-wait-does-not-consume-capacity.sh"

package/tools/bin/heartbeat-safe-auto.sh

@@ -17,6 +17,8 @@ flow_export_execution_env "${CONFIG_YAML}"
 AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
 RUNS_ROOT="$(flow_resolve_runs_root "${CONFIG_YAML}")"
 STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
+HISTORY_ROOT="$(flow_resolve_history_root "${CONFIG_YAML}")"
+WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
 MEMORY_DIR="${ACP_MEMORY_DIR:-${F_LOSNING_MEMORY_DIR:-${AGENT_CONTROL_PLANE_WORKSPACE:-$HOME/.agent-runtime/control-plane/workspace}/memory}}"
 REPO_SLUG="$(flow_resolve_repo_slug "${CONFIG_YAML}")"
 MAX_CONCURRENT_WORKERS="${ACP_MAX_CONCURRENT_WORKERS:-${F_LOSNING_MAX_CONCURRENT_WORKERS:-20}}"
@@ -29,7 +31,7 @@ MAX_CONCURRENT_BLOCKED_RECOVERY_ISSUE_WORKERS="${ACP_MAX_CONCURRENT_BLOCKED_RECO
 BLOCKED_RECOVERY_COOLDOWN_SECONDS="${ACP_BLOCKED_RECOVERY_COOLDOWN_SECONDS:-${F_LOSNING_BLOCKED_RECOVERY_COOLDOWN_SECONDS:-900}}"
 MAX_OPEN_AGENT_PRS_FOR_RECURRING="${ACP_MAX_OPEN_AGENT_PRS_FOR_RECURRING:-${F_LOSNING_MAX_OPEN_AGENT_PRS_FOR_RECURRING:-12}}"
 MAX_LAUNCHES_PER_HEARTBEAT="${ACP_MAX_LAUNCHES_PER_HEARTBEAT:-${F_LOSNING_MAX_LAUNCHES_PER_HEARTBEAT:-$MAX_CONCURRENT_WORKERS}}"
-CODING_WORKER="${ACP_CODING_WORKER:-${F_LOSNING_CODING_WORKER:-codex}}"
+CODING_WORKER="${ACP_CODING_WORKER:-codex}"
 # The catchup and shared heartbeat passes can legitimately take a few minutes
 # once they reconcile stale sessions, sync labels, and launch multiple workers.
 CATCHUP_TIMEOUT_SECONDS="${ACP_CATCHUP_TIMEOUT_SECONDS:-${F_LOSNING_CATCHUP_TIMEOUT_SECONDS:-180}}"
@@ -67,9 +69,12 @@ AGENT_WORKTREE_AUDIT_TIMEOUT_SECONDS="${ACP_AGENT_WORKTREE_AUDIT_TIMEOUT_SECONDS
 LOCK_DIR="${STATE_ROOT}/heartbeat-loop.lock"
 PID_FILE="${LOCK_DIR}/pid"
 SHARED_LOOP_PID_FILE="${STATE_ROOT}/shared-heartbeat-loop.pid"
+SHARED_LOOP_STATUS_FILE="${STATE_ROOT}/shared-heartbeat-loop.env"
 QUOTA_LOCK_DIR="${STATE_ROOT}/quota-preflight.lock"
 QUOTA_PID_FILE="${QUOTA_LOCK_DIR}/pid"
 
+mkdir -p "${AGENT_ROOT}" "${RUNS_ROOT}" "${STATE_ROOT}" "${HISTORY_ROOT}" "${WORKTREE_ROOT}" "${MEMORY_DIR}"
+
 acquire_lock() {
   mkdir -p "${STATE_ROOT}"
 
@@ -124,6 +129,29 @@ release_quota_lock() {
   rm -rf "${QUOTA_LOCK_DIR}"
 }
 
+write_shared_loop_status() {
+  local state="${1:-}"
+  local status="${2:-}"
+  local timestamp=""
+  local tmp_file=""
+
+  timestamp="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  mkdir -p "${STATE_ROOT}"
+  tmp_file="$(mktemp)"
+  if [[ -f "${SHARED_LOOP_STATUS_FILE}" ]]; then
+    grep -Ev '^(STATE|STATUS|STARTED_AT|UPDATED_AT)=' "${SHARED_LOOP_STATUS_FILE}" >"${tmp_file}" || true
+  fi
+  printf 'STATE=%s\n' "${state}" >>"${tmp_file}"
+  if [[ -n "${status}" ]]; then
+    printf 'STATUS=%s\n' "${status}" >>"${tmp_file}"
+  fi
+  if [[ "${state}" == "running" ]]; then
+    printf 'STARTED_AT=%s\n' "${timestamp}" >>"${tmp_file}"
+  fi
+  printf 'UPDATED_AT=%s\n' "${timestamp}" >>"${tmp_file}"
+  mv "${tmp_file}" "${SHARED_LOOP_STATUS_FILE}"
+}
+
 run_with_timeout() {
   local timeout_seconds="${1:?timeout seconds required}"
   shift
@@ -530,6 +558,7 @@ fi
 derive_dynamic_limits
 
 printf '[%s] shared heartbeat loop start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+write_shared_loop_status "running" ""
   if ACP_TIMEOUT_CHILD_PID_FILE="${SHARED_LOOP_PID_FILE}" \
   F_LOSNING_TIMEOUT_CHILD_PID_FILE="${SHARED_LOOP_PID_FILE}" \
   run_with_timeout "${HEARTBEAT_LOOP_TIMEOUT_SECONDS}" \
@@ -563,9 +592,11 @@ printf '[%s] shared heartbeat loop start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
       --heavy-running-label "E2E_ISSUE" \
       --heavy-deferred-key "E2E_DEFERRED" \
       --heavy-deferred-message "E2E-heavy issues remain queued until the single e2e slot is free."; then
+  write_shared_loop_status "idle" "0"
   printf '[%s] shared heartbeat loop end status=0\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
 else
   loop_status=$?
+  write_shared_loop_status "idle" "${loop_status}"
   if [[ "${loop_status}" -eq 124 ]]; then
     printf 'HEARTBEAT_LOOP_TIMEOUT=yes\n'
   fi
@@ -573,21 +604,78 @@ else
   exit "${loop_status}"
 fi
 
-printf '[%s] merged-pr catchup start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-if run_with_timeout "${CATCHUP_TIMEOUT_SECONDS}" \
-  env \
-    ACP_RUNS_ROOT="$RUNS_ROOT" \
-    F_LOSNING_RUNS_ROOT="$RUNS_ROOT" \
-    bash "${FLOW_TOOLS_DIR}/agent-project-catch-up-merged-prs" \
-      --repo-slug "$REPO_SLUG" \
-      --state-root "$STATE_ROOT" \
-      --hook-file "$HOOK_FILE" \
-      --limit 100; then
-  printf '[%s] merged-pr catchup end status=0\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-else
-  catchup_status=$?
-  if [[ "${catchup_status}" -eq 124 ]]; then
-    printf 'CATCHUP_TIMEOUT=yes\n'
+# ── Throttled catch-up passes ──────────────────────────────────────────────────
+# These scripts fetch merged/closed PRs and linked issues which change rarely.
+# Run them at most once every CATCHUP_INTERVAL_SECONDS (default 300 = 5 min)
+# to avoid burning API quota on every heartbeat cycle.
+CATCHUP_INTERVAL_SECONDS="${ACP_CATCHUP_INTERVAL_SECONDS:-${F_LOSNING_CATCHUP_INTERVAL_SECONDS:-300}}"
+CATCHUP_STAMP_FILE="${STATE_ROOT}/last-catchup-timestamp"
+_catchup_now="$(date +%s)"
+_catchup_last="0"
+if [[ -f "${CATCHUP_STAMP_FILE}" ]]; then
+  _catchup_last="$(cat "${CATCHUP_STAMP_FILE}" 2>/dev/null || echo 0)"
+fi
+_catchup_age=$(( _catchup_now - _catchup_last ))
+
+if [[ "${_catchup_age}" -ge "${CATCHUP_INTERVAL_SECONDS}" ]]; then
+  printf '[%s] merged-pr catchup start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  if run_with_timeout "${CATCHUP_TIMEOUT_SECONDS}" \
+    env \
+      ACP_RUNS_ROOT="$RUNS_ROOT" \
+      F_LOSNING_RUNS_ROOT="$RUNS_ROOT" \
+      bash "${FLOW_TOOLS_DIR}/agent-project-catch-up-merged-prs" \
+        --repo-slug "$REPO_SLUG" \
+        --state-root "$STATE_ROOT" \
+        --hook-file "$HOOK_FILE" \
+        --limit 100; then
+    printf '[%s] merged-pr catchup end status=0\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  else
+    catchup_status=$?
+    if [[ "${catchup_status}" -eq 124 ]]; then
+      printf 'CATCHUP_TIMEOUT=yes\n'
+    fi
+    printf '[%s] merged-pr catchup end status=%s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "${catchup_status}"
+  fi
+
+  printf '[%s] linked-pr issue catchup start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  if run_with_timeout "${CATCHUP_TIMEOUT_SECONDS}" \
+    env \
+      ACP_RUNS_ROOT="$RUNS_ROOT" \
+      F_LOSNING_RUNS_ROOT="$RUNS_ROOT" \
+      bash "${FLOW_TOOLS_DIR}/agent-project-catch-up-issue-pr-links" \
+        --repo-slug "$REPO_SLUG" \
+        --state-root "$STATE_ROOT" \
+        --hook-file "$HOOK_FILE" \
+        --limit 100; then
+    printf '[%s] linked-pr issue catchup end status=0\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  else
+    linked_issue_catchup_status=$?
+    if [[ "${linked_issue_catchup_status}" -eq 124 ]]; then
+      printf 'LINKED_ISSUE_CATCHUP_TIMEOUT=yes\n'
+    fi
+    printf '[%s] linked-pr issue catchup end status=%s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "${linked_issue_catchup_status}"
+  fi
+
+  printf '[%s] scheduled-issue retry catchup start\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  if run_with_timeout "${CATCHUP_TIMEOUT_SECONDS}" \
+    env \
+      ACP_RUNS_ROOT="$RUNS_ROOT" \
+      F_LOSNING_RUNS_ROOT="$RUNS_ROOT" \
+      bash "${FLOW_TOOLS_DIR}/agent-project-catch-up-scheduled-issue-retries" \
+        --repo-slug "$REPO_SLUG" \
+        --state-root "$STATE_ROOT" \
+        --hook-file "$HOOK_FILE" \
+        --limit 100; then
+    printf '[%s] scheduled-issue retry catchup end status=0\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+  else
+    scheduled_issue_catchup_status=$?
+    if [[ "${scheduled_issue_catchup_status}" -eq 124 ]]; then
+      printf 'SCHEDULED_ISSUE_CATCHUP_TIMEOUT=yes\n'
+    fi
+    printf '[%s] scheduled-issue retry catchup end status=%s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "${scheduled_issue_catchup_status}"
   fi
-  printf '[%s] merged-pr catchup end status=%s\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "${catchup_status}"
+
+  printf '%s' "${_catchup_now}" >"${CATCHUP_STAMP_FILE}"
+else
+  printf '[%s] catchup skipped (age=%ss, interval=%ss)\n' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "${_catchup_age}" "${CATCHUP_INTERVAL_SECONDS}"
 fi

package/tools/bin/install-project-launchd.sh

@@ -54,7 +54,7 @@ build_launchd_base_path() {
   local tool_name=""
   local tool_dir=""
 
-  for tool_name in node gh git python3 openclaw codex claude; do
+  for tool_name in node gh git python3 openclaw codex claude ollama pi crush kilo; do
     tool_dir="$(resolved_tool_dir "${tool_name}" || true)"
     append_path_dir path_value "${tool_dir}"
   done
@@ -112,7 +112,14 @@ fi
 PROFILE_ID="$(flow_resolve_adapter_id "${CONFIG_YAML}")"
 profile_slug="$(printf '%s' "${PROFILE_ID}" | tr -c 'A-Za-z0-9._-' '-')"
 HOME_DIR="${ACP_PROJECT_RUNTIME_HOME_DIR:-${HOME:-}}"
-SOURCE_HOME="${ACP_PROJECT_RUNTIME_SOURCE_HOME:-$(cd "${FLOW_SKILL_DIR}/../../.." && pwd)}"
+SOURCE_HOME="${ACP_PROJECT_RUNTIME_SOURCE_HOME:-}"
+if [[ -z "${SOURCE_HOME}" ]]; then
+  if flow_is_skill_root "${FLOW_SKILL_DIR}"; then
+    SOURCE_HOME="${FLOW_SKILL_DIR}"
+  else
+    SOURCE_HOME="$(cd "${FLOW_SKILL_DIR}/../../.." && pwd)"
+  fi
+fi
 RUNTIME_HOME="${ACP_PROJECT_RUNTIME_RUNTIME_HOME:-${HOME_DIR}/.agent-runtime/runtime-home}"
 WORKSPACE_DIR="${ACP_PROJECT_RUNTIME_WORKSPACE_DIR:-${HOME_DIR}/.agent-runtime/control-plane/workspace}"
 PROFILE_REGISTRY_ROOT="${ACP_PROJECT_RUNTIME_PROFILE_REGISTRY_ROOT:-${ACP_PROFILE_REGISTRY_ROOT:-${HOME_DIR}/.agent-runtime/control-plane/profiles}}"
@@ -120,6 +127,7 @@ LAUNCH_AGENTS_DIR="${ACP_PROJECT_RUNTIME_LAUNCH_AGENTS_DIR:-${HOME_DIR}/Library/
 LOG_DIR="${ACP_PROJECT_RUNTIME_LOG_DIR:-${HOME_DIR}/.agent-runtime/logs}"
 LABEL="${label_override:-${ACP_PROJECT_RUNTIME_LAUNCHD_LABEL:-ai.agent.project.${profile_slug}}}"
 BASE_PATH="$(build_launchd_base_path)"
+CODING_WORKER_OVERRIDE="${ACP_PROJECT_RUNTIME_CODING_WORKER:-${ACP_CODING_WORKER:-}}"
 SYNC_SCRIPT="${ACP_PROJECT_RUNTIME_SYNC_SCRIPT:-${FLOW_SKILL_DIR}/tools/bin/sync-shared-agent-home.sh}"
 BOOTSTRAP_SCRIPT="${ACP_PROJECT_RUNTIME_BOOTSTRAP_SCRIPT:-${FLOW_SKILL_DIR}/tools/bin/project-launchd-bootstrap.sh}"
 SUPERVISOR_SCRIPT="${ACP_PROJECT_RUNTIME_SUPERVISOR_SCRIPT:-${FLOW_SKILL_DIR}/tools/bin/project-runtime-supervisor.sh}"
@@ -152,6 +160,15 @@ export AGENT_PROJECT_ID='${PROFILE_ID}'
 export ACP_PROJECT_RUNTIME_PATH='${BASE_PATH}'
 export ACP_PROJECT_RUNTIME_SYNC_SCRIPT='${SYNC_SCRIPT}'
 export ACP_PROFILE_REGISTRY_ROOT='${PROFILE_REGISTRY_ROOT}'
+EOF
+
+if [[ -n "${CODING_WORKER_OVERRIDE}" ]]; then
+  cat >>"${WRAPPER_PATH}" <<EOF
+export ACP_CODING_WORKER='${CODING_WORKER_OVERRIDE}'
+EOF
+fi
+
+cat >>"${WRAPPER_PATH}" <<EOF
 exec bash '${SUPERVISOR_SCRIPT}' --bootstrap-script '${BOOTSTRAP_SCRIPT}' --pid-file '${SUPERVISOR_PID_FILE}' --delay-seconds '${delay_seconds}' --interval-seconds '${interval_seconds}'
 EOF
 chmod +x "${WRAPPER_PATH}"

package/tools/bin/prepare-worktree.sh

@@ -9,10 +9,10 @@ CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
 AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
 CANONICAL_REPO_ROOT="$(flow_resolve_repo_root "${CONFIG_YAML}")"
 DEFAULT_DEPENDENCY_SOURCE_ROOT="$CANONICAL_REPO_ROOT"
-DEPENDENCY_SOURCE_ROOT="${ACP_DEPENDENCY_SOURCE_ROOT:-${F_LOSNING_DEPENDENCY_SOURCE_ROOT:-$DEFAULT_DEPENDENCY_SOURCE_ROOT}}"
-SYNC_DEPENDENCY_BASELINE_SCRIPT="${ACP_SYNC_DEPENDENCY_BASELINE_SCRIPT:-${F_LOSNING_SYNC_DEPENDENCY_BASELINE_SCRIPT:-${SCRIPT_DIR}/sync-dependency-baseline.sh}}"
-PACKAGE_MANAGER_BIN="${ACP_PACKAGE_MANAGER_BIN:-${F_LOSNING_PACKAGE_MANAGER_BIN:-pnpm}}"
-LOCAL_WORKSPACE_INSTALL="${ACP_WORKTREE_LOCAL_INSTALL:-${F_LOSNING_WORKTREE_LOCAL_INSTALL:-false}}"
+DEPENDENCY_SOURCE_ROOT="${ACP_DEPENDENCY_SOURCE_ROOT:-$DEFAULT_DEPENDENCY_SOURCE_ROOT}"
+SYNC_DEPENDENCY_BASELINE_SCRIPT="${ACP_SYNC_DEPENDENCY_BASELINE_SCRIPT:-${SCRIPT_DIR}/sync-dependency-baseline.sh}"
+PACKAGE_MANAGER_BIN="${ACP_PACKAGE_MANAGER_BIN:-pnpm}"
+LOCAL_WORKSPACE_INSTALL="${ACP_WORKTREE_LOCAL_INSTALL:-false}"
 WORKTREE="${1:?usage: prepare-worktree.sh WORKTREE}"
 
 realpath_safe() {

package/tools/bin/profile-activate.sh

@@ -56,8 +56,8 @@ AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
 WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
 RUNS_ROOT="$(flow_resolve_runs_root "${CONFIG_YAML}")"
 STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
-CODING_WORKER="${ACP_CODING_WORKER:-${F_LOSNING_CODING_WORKER:-codex}}"
-ACTIVE_PROVIDER_POOL_NAME="${ACP_ACTIVE_PROVIDER_POOL_NAME:-${F_LOSNING_ACTIVE_PROVIDER_POOL_NAME:-}}"
+CODING_WORKER="${ACP_CODING_WORKER:-codex}"
+ACTIVE_PROVIDER_POOL_NAME="${ACP_ACTIVE_PROVIDER_POOL_NAME:-}"
 
 if [[ "${exports_only}" == "1" ]]; then
   printf 'export ACP_PROJECT_ID=%q

package/tools/bin/profile-adopt.sh

@@ -69,8 +69,8 @@ HISTORY_ROOT="$(flow_resolve_history_root "${CONFIG_YAML}")"
 WORKTREE_ROOT="$(flow_resolve_worktree_root "${CONFIG_YAML}")"
 RETAINED_REPO_ROOT="$(flow_resolve_retained_repo_root "${CONFIG_YAML}")"
 VSCODE_WORKSPACE_FILE="$(flow_resolve_vscode_workspace_file "${CONFIG_YAML}")"
-REMOTE_NAME="${ACP_REMOTE_NAME:-${F_LOSNING_REMOTE_NAME:-origin}}"
-SOURCE_REPO_ROOT="${source_repo_root_override:-${ACP_SOURCE_REPO_ROOT:-${F_LOSNING_SOURCE_REPO_ROOT:-${RETAINED_REPO_ROOT}}}}"
+REMOTE_NAME="${ACP_REMOTE_NAME:-origin}"
+SOURCE_REPO_ROOT="${source_repo_root_override:-${ACP_SOURCE_REPO_ROOT:-${RETAINED_REPO_ROOT}}}"
 PROFILE_LINK="${AGENT_ROOT}/control-plane.yaml"
 WORKSPACE_LINK="${AGENT_ROOT}/workspace.code-workspace"
 INSTALLED_PROFILE_DIR="$(dirname "${CONFIG_YAML}")"

package/tools/bin/project-init.sh

@@ -42,7 +42,7 @@ Common options:
   --worktree-root <path>             Worktree parent root
   --retained-repo-root <path>        Retained/manual checkout root
   --vscode-workspace-file <path>     VS Code workspace file
-  --coding-worker <codex|openclaw|claude>
+  --coding-worker <codex|openclaw|claude|ollama|pi|opencode|kilo>
   --claude-model <model>
   --claude-permission-mode <mode>
   --claude-effort <level>