agent-control-plane 0.1.16 → 0.2.0

package/README.md

@@ -94,7 +94,7 @@ it had a supervisor."
 | Get real value out of free-tier models | Quota cooldowns, stall detection, provider failover, and retry backoff that free-tier models need to be actually useful |
 | Manage multiple repos cleanly | One profile per repo with isolated runtime state, each with its own identity and status |
 | Observe what is happening without digging through files | Dashboard and `runtime status` that show the real state without spelunking through `tmux` or temp folders |
-| Compare worker backends on real workloads | Swap between `codex`, `claude`, and `openclaw` without rebuilding your runtime habits |
+| Compare worker backends on real workloads | Swap between `codex`, `claude`, `openclaw`, `ollama`, `pi`, `opencode`, and `kilo` without rebuilding your runtime habits |
 | Run reproducible agent research cheaply | Cost-controlled execution harness for studying agent behavior, output quality, or prompting strategies |
 | Enforce safety by architecture, not by hope | Launch limits, reconcile gates, and cooldowns that are built into the runtime, not left to chance |
 
@@ -130,19 +130,61 @@ Windows.
 | `codex` | Production-ready | Full ACP workflow support today. |
 | `claude` | Production-ready | Full ACP workflow support today. |
 | `openclaw` | Production-ready | Full ACP workflow support, including resident-style runs. |
-| `opencode` | Scaffolded | Routing and docs in place; live execution not yet implemented. |
-| `kilo` | Scaffolded | Routing and docs in place; live execution not yet implemented. |
+| `ollama` | Experimental | Working adapter with Node.js agentic loop. Runs any model served by a local Ollama instance. Output quality depends on model size — 7–9B models handle exploration well but struggle with complex multi-step tasks. |
+| `pi` | Experimental | Working adapter using the [pi CLI](https://github.com/mariozechner/pi) in `--print --no-session` mode. Connects to any OpenRouter-compatible model. Useful as a lightweight alternative to openclaw for free-tier model testing. |
+| `opencode` | Experimental | Working adapter for [Crush](https://github.com/charmbracelet/crush) (formerly opencode). Non-interactive `crush run` with full tool execution. |
+| `kilo` | Experimental | Working adapter for [Kilo Code](https://github.com/Kilo-Org/kilocode). Non-interactive `kilo run --auto` with JSON event stream. |
 | `gemini-cli` | Roadmap | Strong future candidate; not wired into ACP yet. |
-| `ollama` | Research | Candidate local-model substrate for future ACP integrations. |
 | `nanoclaw` | Exploratory | Ecosystem reference for containerized and WSL2-friendly workflows. |
 | `picoclaw` | Exploratory | Ecosystem reference for lightweight Linux and edge-style runtimes. |
 
 If you are trying ACP on a real repo right now, start with `codex`, `claude`,
-or `openclaw`. The other entries show the direction of travel, not finished
-support.
+or `openclaw`. Use `ollama` to run local models — useful for research, offline
+workflows, or comparing local model output against cloud backends without
+incurring API costs. Use `pi` to experiment with OpenRouter-hosted free-tier
+models via the pi CLI. The remaining entries show the direction of travel, not
+finished support.
 
 See [ROADMAP.md](./ROADMAP.md) for the fuller public roadmap.
 
+### Using Ollama (local models)
+
+To run ACP with a local model via [Ollama](https://ollama.com):
+
+```bash
+# 1. Install Ollama and pull a model
+ollama pull qwen3.5:9b
+
+# 2. Init a profile with ollama backend
+npx agent-control-plane@latest init \
+  --profile-id my-repo \
+  --repo-slug owner/my-repo \
+  --repo-root ~/src/my-repo \
+  --agent-root ~/.agent-runtime/projects/my-repo \
+  --worktree-root ~/src/my-repo-worktrees \
+  --coding-worker ollama
+
+# 3. Configure the model in your profile YAML
+#    ~/.agent-runtime/control-plane/profiles/my-repo/control-plane.yaml
+#
+#    execution:
+#      coding_worker: "ollama"
+#      ollama:
+#        model: "qwen3.5:9b"
+#        base_url: "http://localhost:11434"
+#        timeout_seconds: 900
+```
+
+The Ollama adapter runs a Node.js agentic loop that calls the Ollama API with
+tool-use support. It handles both native tool-call responses and models that
+return tool calls as JSON text in the content field.
+
+**Model guidance:** Models in the 7–14B range can explore codebases and run
+commands, but may struggle with complex multi-step repair tasks. Larger models
+(27B+) produce significantly better results if your hardware supports them.
+Thinking mode is disabled by default (`think: false`) and context is set to
+32K tokens to balance speed and capability.
+
 ## See It Running
 
 The dashboard gives you a single view across all active profiles — running
@@ -167,7 +209,7 @@ flowchart LR
   Supervisor --> Heartbeat["heartbeat-safe-auto.sh"]
   Heartbeat --> Scheduler["agent-project-heartbeat-loop"]
   Scheduler --> Workers["issue / PR worker launchers"]
-  Workers --> Backends["codex / claude / openclaw"]
+  Workers --> Backends["codex / claude / openclaw / ollama / pi / opencode / kilo"]
   Backends --> Reconcile["reconcile issue / PR session"]
   Reconcile --> GitHub["issues / PRs / labels / comments"]
   Scheduler --> State["runs + state + history"]
@@ -230,7 +272,11 @@ system.
 | `jq` | yes | Parses JSON from `gh` output and worker metadata throughout. | Missing `jq` will break GitHub-heavy and runtime flows. |
 | `python3` | yes | Powers the dashboard server, snapshot renderer, and config helpers. | Required for both dashboard use and several internal scripts. |
 | `tmux` | yes | Runs long-lived worker sessions and captures their status. | Missing `tmux` means background worker workflows will not launch. |
-| Worker CLI (`codex`, `claude`, or `openclaw`) | depends on backend | The actual coding agent for a profile. | Install and authenticate the backend you plan to use before starting background runs. |
+| Worker CLI (backend-specific) | depends on backend | The coding agent for a profile. Supported: `codex`, `claude`, `openclaw` (production); `ollama`, `pi`, `opencode`, `kilo` (experimental). | Install and authenticate your chosen backend before starting background runs. |
+| `ollama` | for `ollama` backend | Serves local models via OpenAI-compatible API at `http://localhost:11434`. | Install from [ollama.com](https://ollama.com) and pull a model (e.g. `ollama pull qwen3.5:9b`) before use. |
+| `pi` CLI | for `pi` backend | Lightweight coding agent using OpenRouter-compatible APIs. | Install via `npm i -g @mariozechner/pi-coding-agent`. Set `OPENROUTER_API_KEY` before use. |
+| `crush` (opencode) | for `opencode` backend | Go-based coding agent by Charm ([charmbracelet/crush](https://github.com/charmbracelet/crush)). | Install via `brew install charmbracelet/tap/crush`. |
+| `kilo` CLI | for `kilo` backend | TypeScript coding agent ([kilocode/cli](https://github.com/Kilo-Org/kilocode)). | Install via `npm i -g @kilocode/cli`. |
 | Bundled `codex-quota` + ACP quota manager | automatic for Codex | Quota-aware failover and health signals for Codex profiles. | Bundled by default. Override with `ACP_CODEX_QUOTA_BIN` only if you have a custom setup. |
 
 Make sure `gh` and your chosen worker backend are both authenticated for the
@@ -264,9 +310,17 @@ The fastest path is the interactive wizard:
 npx agent-control-plane@latest setup
 ```
 
-The wizard auto-detects the current repo when possible, offers to install
-missing dependencies, prompts for `gh auth login`, scaffolds the profile, runs
-health checks, and optionally starts the runtime — all in one pass.
+The wizard walks you through the full setup in one pass:
+
+1. Detects the current repo and suggests sane defaults
+2. Installs missing dependencies and authenticates `gh`
+3. Checks backend readiness (API keys for openclaw/pi, local server for ollama)
+4. Scaffolds the profile, runs health checks, starts the runtime
+5. Launches the monitoring dashboard in the background
+6. Offers to create recurring starter issues so ACP starts working immediately
+
+After the wizard finishes, your repo has a running agent, a live dashboard,
+and a set of `agent-keep-open` issues that ACP will continuously work through.
 
 To preview exactly what it would do before touching anything:
 
@@ -281,6 +335,8 @@ npx agent-control-plane@latest setup \
   --non-interactive \
   --install-missing-deps \
   --start-runtime \
+  --start-dashboard \
+  --create-starter-issues \
   --json
 ```
 
@@ -325,7 +381,7 @@ npx agent-control-plane@latest init \
 | `--repo-root` | Path to your local checkout |
 | `--agent-root` | Where ACP keeps per-project runtime state |
 | `--worktree-root` | Where ACP places repo worktrees |
-| `--coding-worker` | Backend to orchestrate (`codex`, `claude`, or `openclaw`) |
+| `--coding-worker` | Backend to orchestrate (`codex`, `claude`, `openclaw`, `ollama`, `pi`, `opencode`, or `kilo`) |
 
 **4. Validate before trusting it**
 
@@ -348,6 +404,29 @@ Once `runtime status` returns clean output, ACP is actively managing the
 runtime for that profile. Per-profile state lives under `~/.agent-runtime`,
 grouped and inspectable without digging through scattered temp files.
 
+## Starter Issues
+
+The setup wizard can create a set of recurring `agent-keep-open` issues on your
+repo so ACP starts working immediately after installation. Each issue carries the
+`agent-ready` and `agent-keep-open` labels, and ACP picks them up on its next
+heartbeat cycle.
+
+Built-in templates:
+
+| Issue | What ACP does |
+| --- | --- |
+| Code quality sweep | Fix lint warnings, type errors, and dead code |
+| Test coverage improvement | Add tests for critical untested modules |
+| Documentation refresh | Keep README and inline docs accurate |
+| Dependency audit | Fix vulnerabilities and update safe patches |
+| Refactoring sweep | Reduce complexity and duplication |
+
+You can also create your own recurring issues — just add the `agent-ready` and
+`agent-keep-open` labels to any GitHub issue and ACP will work on it
+continuously.
+
+To skip this step during setup, pass `--no-create-starter-issues`.
+
 ## Everyday Usage
 
 ```bash
@@ -427,7 +506,7 @@ Use `--purge-paths` only when you want ACP-managed directories deleted too.
 | `explicit profile selection required` | Pass `--profile-id <id>` to `runtime`, `launchd-install`, `launchd-uninstall`, and `remove`. |
 | `gh` cannot access the repo | Re-run `gh auth login` and confirm the repo slug in the profile is correct. |
 | Setup deferred anchor repo sync | ACP could not reach the repo remote. Fix Git access or the remote URL, then re-run `setup` or `init` without `--skip-anchor-sync`. |
-| Backend auth failures (`codex`, `claude`, `openclaw`) | Authenticate the backend before starting ACP in the background. |
+| Backend auth failures | Authenticate the backend before starting ACP. For `openclaw`/`pi`, set `OPENROUTER_API_KEY`. For `ollama`, ensure the server is running. For `opencode`/`kilo`, install and authenticate the CLI. |
 | Node older than `18` | Upgrade Node first. ACP's minimum version is `18+`. |
 | Missing `jq` | Install `jq`, then retry the failed command. |
 | Runtime or source drift after an update | Run `sync`, then `doctor`. |
@@ -440,7 +519,7 @@ Use `--purge-paths` only when you want ACP-managed directories deleted too.
 | --- | --- |
 | `help` | Show the full CLI surface. Good first command on a new machine. |
 | `version` | Print the running package version. |
-| `setup [--dry-run] [--json]` | Guided bootstrap wizard. Detects repo, installs deps, scaffolds profile, starts runtime. `--dry-run` previews without writing anything. `--json` emits a structured result. |
+| `setup [--dry-run] [--json]` | Guided bootstrap wizard. Detects repo, installs deps, scaffolds profile, starts runtime and dashboard, creates starter issues. `--dry-run` previews. `--json` emits structured output. |
 | `sync` / `install` | Stage or refresh the packaged runtime into `~/.agent-runtime/runtime-home`. Run after install or upgrade. |
 | `init ...` | Scaffold one repo profile manually. Requires `--profile-id`, `--repo-slug`, `--repo-root`, `--agent-root`, `--worktree-root`, `--coding-worker`. |
 | `doctor` | Inspect runtime and source installation health. |

package/bin/pr-risk.sh

@@ -6,14 +6,15 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../tools/bin/flow-config-lib.sh"
 
 PR_NUMBER="${1:?usage: pr-risk.sh PR_NUMBER}"
+[[ "${PR_NUMBER}" =~ ^[1-9][0-9]*$ ]] || { printf 'pr-risk: PR_NUMBER must be a positive integer, got: %s\n' "${PR_NUMBER}" >&2; exit 1; }
 CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
 MANAGED_PR_PREFIXES_JSON="$(flow_managed_pr_prefixes_json "${CONFIG_YAML}")"
 MANAGED_PR_ISSUE_CAPTURE_REGEX="$(flow_managed_issue_branch_regex "${CONFIG_YAML}")"
 REPO_SLUG="$(flow_resolve_repo_slug "${CONFIG_YAML}")"
 AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
 STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
-ALLOW_INFRA_CI_BYPASS="${ACP_ALLOW_INFRA_CI_BYPASS:-${F_LOSNING_ALLOW_INFRA_CI_BYPASS:-1}}"
-LOCAL_FIRST_PR_POLICY="${ACP_LOCAL_FIRST_PR_POLICY:-${F_LOSNING_LOCAL_FIRST_PR_POLICY:-1}}"
+ALLOW_INFRA_CI_BYPASS="${ACP_ALLOW_INFRA_CI_BYPASS:-1}"
+LOCAL_FIRST_PR_POLICY="${ACP_LOCAL_FIRST_PR_POLICY:-1}"
 PR_LANE_OVERRIDE_FILE="${STATE_ROOT}/pr-lane-overrides/${PR_NUMBER}.env"
 PR_LANE_OVERRIDE=""
 
@@ -37,7 +38,8 @@ gh_api_json_matching_or_fallback() {
   printf '%s\n' "${fallback}"
 }
 
-PR_JSON="$(gh pr view "$PR_NUMBER" -R "$REPO_SLUG" --json number,title,url,body,isDraft,headRefName,headRefOid,baseRefName,labels,files,mergeStateStatus,reviewDecision,reviewRequests,statusCheckRollup,comments)"
+PR_JSON="$(gh pr view "$PR_NUMBER" -R "$REPO_SLUG" --json number,title,url,body,isDraft,headRefName,headRefOid,baseRefName,labels,files,mergeStateStatus,reviewDecision,reviewRequests,statusCheckRollup,comments 2>/dev/null)" \
+  || { printf 'pr-risk: gh pr view failed for PR %s (repo: %s)\n' "$PR_NUMBER" "$REPO_SLUG" >&2; exit 1; }
 PR_HEAD_SHA="$(jq -r '.headRefOid // ""' <<<"$PR_JSON")"
 PR_HEAD_COMMITTED_AT=""
 if [[ -n "${PR_HEAD_SHA}" ]]; then
@@ -51,9 +53,24 @@ fi
 
 PR_JSON="$PR_JSON" PR_HEAD_SHA="$PR_HEAD_SHA" PR_HEAD_COMMITTED_AT="$PR_HEAD_COMMITTED_AT" REVIEW_COMMENTS_JSON="$REVIEW_COMMENTS_JSON" CHECK_RUNS_JSON="$CHECK_RUNS_JSON" PR_LANE_OVERRIDE="${PR_LANE_OVERRIDE:-}" MANAGED_PR_PREFIXES_JSON="$MANAGED_PR_PREFIXES_JSON" MANAGED_PR_ISSUE_CAPTURE_REGEX="$MANAGED_PR_ISSUE_CAPTURE_REGEX" ALLOW_INFRA_CI_BYPASS="$ALLOW_INFRA_CI_BYPASS" LOCAL_FIRST_PR_POLICY="$LOCAL_FIRST_PR_POLICY" node <<'EOF'
 const { execFileSync } = require('node:child_process');
-const data = JSON.parse(process.env.PR_JSON);
-const reviewComments = JSON.parse(process.env.REVIEW_COMMENTS_JSON || '[]');
-const checkRunsPayload = JSON.parse(process.env.CHECK_RUNS_JSON || '{"check_runs":[]}');
+let data;
+try {
+  data = JSON.parse(process.env.PR_JSON);
+} catch (err) {
+  process.stderr.write(`pr-risk: failed to parse PR_JSON: ${err.message}\n`);
+  process.stdout.write(JSON.stringify({ agentLane: 'ignore', error: `parse-error: ${err.message}` }));
+  process.exit(0);
+}
+let reviewComments, checkRunsPayload;
+try {
+  reviewComments = JSON.parse(process.env.REVIEW_COMMENTS_JSON || '[]');
+  checkRunsPayload = JSON.parse(process.env.CHECK_RUNS_JSON || '{"check_runs":[]}');
+} catch (err) {
+  process.stderr.write(`pr-risk: failed to parse auxiliary JSON env: ${err.message}\n`);
+  reviewComments = [];
+  checkRunsPayload = { check_runs: [] };
+}
+try {
 const checkRuns = checkRunsPayload.check_runs || [];
 const files = (data.files || []).map((file) => file.path);
 const labelNames = (data.labels || []).map((label) => label.name);
@@ -573,4 +590,9 @@ const result = {
 };
 
 process.stdout.write(JSON.stringify(result));
+} catch (err) {
+  process.stderr.write(`pr-risk: unexpected error: ${err.message}\n${err.stack || ''}\n`);
+  process.stdout.write(JSON.stringify({ agentLane: 'ignore', error: `runtime-error: ${err.message}` }));
+  process.exit(1);
+}
 EOF

package/hooks/heartbeat-hooks.sh

@@ -18,14 +18,51 @@ REPO_SLUG="$(flow_resolve_repo_slug "${CONFIG_YAML}")"
 AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
 DEFAULT_BRANCH="$(flow_resolve_default_branch "${CONFIG_YAML}")"
 STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
-PENDING_LAUNCH_DIR="${ACP_PENDING_LAUNCH_DIR:-${F_LOSNING_PENDING_LAUNCH_DIR:-${STATE_ROOT}/pending-launches}}"
+PENDING_LAUNCH_DIR="${ACP_PENDING_LAUNCH_DIR:-${STATE_ROOT}/pending-launches}"
 AGENT_PR_PREFIXES_JSON="$(flow_managed_pr_prefixes_json "${CONFIG_YAML}")"
 AGENT_PR_ISSUE_CAPTURE_REGEX="$(flow_managed_issue_branch_regex "${CONFIG_YAML}")"
 AGENT_PR_HANDOFF_LABEL="${AGENT_PR_HANDOFF_LABEL:-agent-handoff}"
 AGENT_EXCLUSIVE_LABEL="${AGENT_EXCLUSIVE_LABEL:-agent-exclusive}"
-CODING_WORKER="${ACP_CODING_WORKER:-${F_LOSNING_CODING_WORKER:-codex}}"
+CODING_WORKER="${ACP_CODING_WORKER:-codex}"
 HEARTBEAT_ISSUE_JSON_CACHE_DIR="${TMPDIR:-/tmp}/heartbeat-issue-json.$$"
 
+# ── Per-heartbeat snapshot cache ──────────────────────────────────────────────
+# Fetch open issues and open PRs once per heartbeat cycle and reuse the
+# snapshot for every list query.  This eliminates 4x issue_list + 3x pr_list
+# redundant GitHub API calls per cycle.
+HEARTBEAT_SNAPSHOT_CACHE_DIR="${TMPDIR:-/tmp}/heartbeat-snapshot.$$"
+
+# Snapshot functions are always called from subshells (command substitution or
+# pipes), so in-memory variables would be lost immediately.  We rely exclusively
+# on the PID-scoped disk cache under HEARTBEAT_SNAPSHOT_CACHE_DIR.
+
+heartbeat_cached_issue_list_json() {
+  mkdir -p "${HEARTBEAT_SNAPSHOT_CACHE_DIR}"
+  local cache_file="${HEARTBEAT_SNAPSHOT_CACHE_DIR}/issues.json"
+  if [[ ! -f "${cache_file}" ]]; then
+    local snapshot
+    snapshot="$(flow_github_issue_list_json "$REPO_SLUG" open 100 2>/dev/null || true)"
+    printf '%s' "${snapshot}" >"${cache_file}"
+  fi
+  cat "${cache_file}"
+}
+
+heartbeat_cached_pr_list_json() {
+  mkdir -p "${HEARTBEAT_SNAPSHOT_CACHE_DIR}"
+  local cache_file="${HEARTBEAT_SNAPSHOT_CACHE_DIR}/prs.json"
+  if [[ ! -f "${cache_file}" ]]; then
+    local snapshot
+    snapshot="$(flow_github_pr_list_json "$REPO_SLUG" open 100 2>/dev/null || true)"
+    printf '%s' "${snapshot}" >"${cache_file}"
+  fi
+  cat "${cache_file}"
+}
+
+heartbeat_invalidate_snapshot_cache() {
+  rm -rf "${HEARTBEAT_SNAPSHOT_CACHE_DIR}" 2>/dev/null || true
+  rm -rf "${HEARTBEAT_ISSUE_JSON_CACHE_DIR}" 2>/dev/null || true
+}
+
 heartbeat_issue_retry_state_file() {
   local issue_id="${1:?issue id required}"
   printf '%s/retries/issues/%s.env\n' "${STATE_ROOT}" "${issue_id}"
@@ -92,10 +129,15 @@ heartbeat_issue_json_cached() {
 }
 
 heartbeat_open_agent_pr_issue_ids() {
+  mkdir -p "${HEARTBEAT_SNAPSHOT_CACHE_DIR}"
+  local cache_file="${HEARTBEAT_SNAPSHOT_CACHE_DIR}/pr_issue_ids.json"
+  if [[ -f "${cache_file}" ]]; then
+    cat "${cache_file}"
+    return 0
+  fi
   local pr_issue_ids_json=""
   pr_issue_ids_json="$(
-    flow_github_pr_list_json "$REPO_SLUG" open 100 \
-      2>/dev/null \
+    heartbeat_cached_pr_list_json \
       | jq --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" --arg branchIssueRegex "${AGENT_PR_ISSUE_CAPTURE_REGEX}" '
         map(
           . as $pr
@@ -124,10 +166,10 @@ heartbeat_open_agent_pr_issue_ids() {
   )"
 
   if [[ -z "${pr_issue_ids_json:-}" ]]; then
-    printf '[]\n'
-  else
-    printf '%s\n' "${pr_issue_ids_json}"
+    pr_issue_ids_json="[]"
   fi
+  printf '%s' "${pr_issue_ids_json}" >"${cache_file}"
+  printf '%s\n' "${pr_issue_ids_json}"
 }
 
 heartbeat_list_ready_issue_ids() {
@@ -136,8 +178,7 @@ heartbeat_list_ready_issue_ids() {
   open_agent_pr_issue_ids="$(heartbeat_open_agent_pr_issue_ids)"
 
   ready_issue_rows="$(
-    flow_github_issue_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+    heartbeat_cached_issue_list_json \
     | jq -r --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           (any(.labels[]?; .name == "agent-running") | not)
@@ -171,8 +212,7 @@ heartbeat_list_blocked_recovery_issue_ids() {
   open_agent_pr_issue_ids="$(heartbeat_open_agent_pr_issue_ids)"
 
   blocked_issue_rows="$(
-    flow_github_issue_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+    heartbeat_cached_issue_list_json \
     | jq -r --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           any(.labels[]?; .name == "agent-blocked")
@@ -270,8 +310,7 @@ heartbeat_list_exclusive_issue_ids() {
   local open_agent_pr_issue_ids
   open_agent_pr_issue_ids="$(heartbeat_open_agent_pr_issue_ids)"
 
-  flow_github_issue_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+  heartbeat_cached_issue_list_json \
     | jq -r --arg exclusiveLabel "${AGENT_EXCLUSIVE_LABEL}" --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           any(.labels[]?; .name == $exclusiveLabel)
@@ -285,8 +324,7 @@ heartbeat_list_exclusive_issue_ids() {
 }
 
 heartbeat_list_running_issue_ids() {
-  flow_github_issue_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+  heartbeat_cached_issue_list_json \
     | jq -r '
         map(select(any(.labels[]?; .name == "agent-running")))
         | sort_by(.createdAt, .number)
@@ -295,8 +333,7 @@ heartbeat_list_running_issue_ids() {
 }
 
 heartbeat_list_open_agent_pr_ids() {
-  flow_github_pr_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+  heartbeat_cached_pr_list_json \
     | jq -r --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" '
         map(select(
           . as $pr
@@ -312,8 +349,7 @@ heartbeat_list_open_agent_pr_ids() {
 }
 
 heartbeat_list_exclusive_pr_ids() {
-  flow_github_pr_list_json "$REPO_SLUG" open 100 \
-    2>/dev/null \
+  heartbeat_cached_pr_list_json \
     | jq -r --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" --arg exclusiveLabel "${AGENT_EXCLUSIVE_LABEL}" '
         map(select(
           . as $pr
@@ -444,16 +480,20 @@ heartbeat_pr_risk_json() {
 heartbeat_mark_issue_running() {
   local issue_id="${1:?issue id required}"
   local is_heavy="${2:-no}"
+  local cached_json
+  cached_json="$(heartbeat_issue_json_cached "$issue_id" 2>/dev/null || true)"
   if [[ "$is_heavy" == "yes" ]]; then
-    bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-ready --remove agent-blocked --add agent-running --add agent-e2e-heavy >/dev/null || true
+    ACP_CACHED_ISSUE_JSON="${cached_json}" bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-ready --remove agent-blocked --add agent-running --add agent-e2e-heavy >/dev/null || true
   else
-    bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-ready --remove agent-blocked --add agent-running >/dev/null || true
+    ACP_CACHED_ISSUE_JSON="${cached_json}" bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-ready --remove agent-blocked --add agent-running >/dev/null || true
   fi
 }
 
 heartbeat_issue_launch_failed() {
   local issue_id="${1:?issue id required}"
-  bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-running >/dev/null || true
+  local cached_json
+  cached_json="$(heartbeat_issue_json_cached "$issue_id" 2>/dev/null || true)"
+  ACP_CACHED_ISSUE_JSON="${cached_json}" bash "${FLOW_TOOLS_DIR}/agent-github-update-labels" --repo-slug "$REPO_SLUG" --number "$issue_id" --remove agent-running >/dev/null || true
 }
 
 heartbeat_ensure_issue_label_exists() {