agent-control-plane 0.1.13 → 0.1.14

package/SKILL.md

@@ -22,7 +22,7 @@ external profile registry, not inside this repository.
 - installed project profiles in `~/.agent-runtime/control-plane/profiles/*/control-plane.yaml`
 - installed profile notes in `~/.agent-runtime/control-plane/profiles/*/README.md`
 - workflow catalog in `assets/workflow-catalog.json`
-- worker dashboard in `tools/dashboard/` with launchers in `tools/bin/render-dashboard-snapshot.py`
+- worker dashboard in `tools/dashboard/` with launcher at `tools/dashboard/dashboard_snapshot.py`
   and `tools/bin/serve-dashboard.sh`
 - dashboard autostart helpers in `tools/bin/dashboard-launchd-bootstrap.sh` and
   `tools/bin/install-dashboard-launchd.sh`

package/hooks/heartbeat-hooks.sh

@@ -95,6 +95,7 @@ heartbeat_open_agent_pr_issue_ids() {
   local pr_issue_ids_json=""
   pr_issue_ids_json="$(
     flow_github_pr_list_json "$REPO_SLUG" open 100 \
+      2>/dev/null \
       | jq --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" --arg branchIssueRegex "${AGENT_PR_ISSUE_CAPTURE_REGEX}" '
         map(
           . as $pr
@@ -119,7 +120,7 @@ heartbeat_open_agent_pr_issue_ids() {
           | select(. != null and . != "")
         )
         | unique
-      '
+      ' 2>/dev/null || true
   )"
 
   if [[ -z "${pr_issue_ids_json:-}" ]]; then
@@ -136,6 +137,7 @@ heartbeat_list_ready_issue_ids() {
 
   ready_issue_rows="$(
     flow_github_issue_list_json "$REPO_SLUG" open 100 \
+    2>/dev/null \
     | jq -r --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           (any(.labels[]?; .name == "agent-running") | not)
@@ -145,7 +147,7 @@ heartbeat_list_ready_issue_ids() {
         | .[]
         | [.number, (any(.labels[]?; .name == "agent-blocked"))]
         | @tsv
-      '
+      ' 2>/dev/null || true
   )"
 
   while IFS=$'\t' read -r issue_id is_blocked; do
@@ -170,6 +172,7 @@ heartbeat_list_blocked_recovery_issue_ids() {
 
   blocked_issue_rows="$(
     flow_github_issue_list_json "$REPO_SLUG" open 100 \
+    2>/dev/null \
     | jq -r --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           any(.labels[]?; .name == "agent-blocked")
@@ -178,7 +181,7 @@ heartbeat_list_blocked_recovery_issue_ids() {
         ))
         | sort_by(.createdAt, .number)
         | .[].number
-      '
+      ' 2>/dev/null || true
   )"
 
   while IFS= read -r issue_id; do
@@ -268,6 +271,7 @@ heartbeat_list_exclusive_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 \
     | jq -r --arg exclusiveLabel "${AGENT_EXCLUSIVE_LABEL}" --argjson openAgentPrIssueIds "${open_agent_pr_issue_ids}" '
         map(select(
           any(.labels[]?; .name == $exclusiveLabel)
@@ -277,20 +281,22 @@ heartbeat_list_exclusive_issue_ids() {
         ))
         | sort_by(.createdAt, .number)
         | .[].number
-      '
+      ' 2>/dev/null || true
 }
 
 heartbeat_list_running_issue_ids() {
   flow_github_issue_list_json "$REPO_SLUG" open 100 \
+    2>/dev/null \
     | jq -r '
         map(select(any(.labels[]?; .name == "agent-running")))
         | sort_by(.createdAt, .number)
         | .[].number
-      '
+      ' 2>/dev/null || true
 }
 
 heartbeat_list_open_agent_pr_ids() {
   flow_github_pr_list_json "$REPO_SLUG" open 100 \
+    2>/dev/null \
     | jq -r --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" '
         map(select(
           . as $pr
@@ -302,11 +308,12 @@ heartbeat_list_open_agent_pr_ids() {
         ))
         | sort_by(.createdAt)
         | .[].number
-      '
+      ' 2>/dev/null || true
 }
 
 heartbeat_list_exclusive_pr_ids() {
   flow_github_pr_list_json "$REPO_SLUG" open 100 \
+    2>/dev/null \
     | jq -r --argjson agentPrPrefixes "${AGENT_PR_PREFIXES_JSON}" --arg handoffLabel "${AGENT_PR_HANDOFF_LABEL}" --arg exclusiveLabel "${AGENT_EXCLUSIVE_LABEL}" '
         map(select(
           . as $pr
@@ -319,7 +326,7 @@ heartbeat_list_exclusive_pr_ids() {
         ))
         | sort_by(.createdAt)
         | .[].number
-      '
+      ' 2>/dev/null || true
 }
 
 heartbeat_issue_is_heavy() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-control-plane",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Help a repo keep GitHub-driven coding agents running reliably without constant human babysitting",
   "homepage": "https://github.com/ducminhnguyen0319/agent-control-plane",
   "bugs": {
@@ -32,12 +32,14 @@
     "tools/bin",
     "!tools/bin/audit-*.sh",
     "!tools/bin/check-skill-contracts.sh",
+    "!tools/bin/render-dashboard-snapshot.py",
     "tools/dashboard/app.js",
     "tools/dashboard/dashboard_snapshot.py",
     "tools/dashboard/index.html",
     "tools/dashboard/server.py",
     "tools/dashboard/styles.css",
     "tools/templates",
+    "!tools/templates/legacy/",
     "tools/vendor/codex-quota/LICENSE",
     "tools/vendor/codex-quota/codex-quota.js",
     "tools/vendor/codex-quota/lib",

package/references/commands.md

@@ -85,7 +85,7 @@ tools/bin/uninstall-project-launchd.sh --profile-id <id>
 tools/bin/project-remove.sh --profile-id <id>
 tools/bin/project-remove.sh --profile-id <id> --purge-paths
 tools/bin/sync-shared-agent-home.sh
-python3 tools/bin/render-dashboard-snapshot.py --pretty
+python3 tools/dashboard/dashboard_snapshot.py --pretty
 bash tools/bin/serve-dashboard.sh --host 127.0.0.1 --port 8765
 bash tools/bin/install-dashboard-launchd.sh --host 127.0.0.1 --port 8765
 ```
@@ -97,7 +97,7 @@ prompts live under `tools/templates/`.
 ## Dashboard
 
 ```bash
-python3 tools/bin/render-dashboard-snapshot.py --pretty
+python3 tools/dashboard/dashboard_snapshot.py --pretty
 bash tools/bin/serve-dashboard.sh --host 127.0.0.1 --port 8765
 bash tools/bin/install-dashboard-launchd.sh --host 127.0.0.1 --port 8765
 ```

package/references/control-plane-map.md

@@ -64,7 +64,7 @@ roots, labels, worker preferences, prompts, and project-specific guardrails.
   before scheduler use.
 - `tools/bin/test-smoke.sh`
   Runs the main shared-package smoke gates in one operator-facing command.
-- `tools/bin/render-dashboard-snapshot.py`
+- `tools/dashboard/dashboard_snapshot.py`
   Emits a JSON snapshot of active runs, resident controllers, cooldown state,
   queue depth, and scheduled issues across installed profiles.
 - `tools/bin/serve-dashboard.sh`

package/tools/bin/agent-project-reconcile-issue-session

@@ -307,12 +307,14 @@ schedule_provider_quota_cooldown() {
   local reason="${1:-provider-quota-limit}"
   [[ "${reason}" == "provider-quota-limit" ]] || return 0
   [[ -x "${provider_cooldown_script}" ]] || return 0
+  [[ "${CODING_WORKER:-}" == "codex" ]] && return 0
 
   "${provider_cooldown_script}" schedule "${reason}" >/dev/null || true
 }
 
 clear_provider_quota_cooldown() {
   [[ -x "${provider_cooldown_script}" ]] || return 0
+  [[ "${CODING_WORKER:-}" == "codex" ]] && return 0
 
   "${provider_cooldown_script}" clear >/dev/null || true
 }

package/tools/bin/agent-project-reconcile-pr-session

@@ -227,23 +227,30 @@ schedule_provider_quota_cooldown() {
   local reason="${1:-provider-quota-limit}"
   [[ "${failure_reason:-}" == "provider-quota-limit" ]] || return 0
   [[ -x "${provider_cooldown_script}" ]] || return 0
+  [[ "${CODING_WORKER:-}" == "codex" ]] && return 0
 
   "${provider_cooldown_script}" schedule "${reason}" >/dev/null || true
 }
 
 clear_provider_quota_cooldown() {
   [[ -x "${provider_cooldown_script}" ]] || return 0
+  [[ "${CODING_WORKER:-}" == "codex" ]] && return 0
 
   "${provider_cooldown_script}" clear >/dev/null || true
 }
 
 blocked_runtime_reason=""
+host_github_rate_limited="no"
+host_github_rate_limit_detail=""
 
 owner="${repo_slug%%/*}"
 repo="${repo_slug#*/}"
 pr_view_json="$(flow_github_pr_view_json "$repo_slug" "$pr_number")"
 pr_state="$(jq -r '.state' <<<"$pr_view_json")"
-pr_base_ref="$(jq -r '.baseRefName // "main"' <<<"$pr_view_json")"
+pr_base_ref="$(jq -r '.baseRefName // empty' <<<"$pr_view_json")"
+if [[ -z "${pr_base_ref}" ]]; then
+  pr_base_ref="main"
+fi
 
 if [[ "$status" == "RUNNING" && "$pr_state" != "MERGED" && "$pr_state" != "CLOSED" ]]; then
   printf 'STATUS=%s\n' "$status"
@@ -395,7 +402,9 @@ post_pr_comment_if_present() {
   if pr_comment_already_posted; then
     return 0
   fi
-  flow_github_api_repo "${repo_slug}" "issues/${pr_number}/comments" --method POST -f body="$(cat "$comment_file")" >/dev/null
+  if ! host_github_post_issue_comment "${pr_number}" "$(cat "$comment_file")"; then
+    return 1
+  fi
 }
 
 pr_comment_already_posted() {
@@ -408,6 +417,120 @@ pr_comment_already_posted() {
   jq -e --arg body "$comment_body" 'any(.comments[]?; .body == $body)' >/dev/null <<<"$comments_json"
 }
 
+host_github_output_indicates_rate_limit() {
+  grep -Eiq 'API rate limit exceeded|secondary rate limit|rate limit exceeded|HTTP 403' <<<"${1:-}"
+}
+
+record_host_github_rate_limit() {
+  local output="${1:-}"
+  local detail_file="${run_dir}/host-github-rate-limit.log"
+  host_github_rate_limited="yes"
+  host_github_rate_limit_detail="${output}"
+  printf '%s\n' "${output}" >"${detail_file}"
+}
+
+host_github_post_issue_comment() {
+  local issue_number="${1:?issue number required}"
+  local body="${2:-}"
+  local output=""
+
+  flow_export_github_cli_auth_env "${repo_slug}"
+  if output="$(
+    gh api "repos/${repo_slug}/issues/${issue_number}/comments" \
+      --method POST \
+      -f body="${body}" 2>&1
+  )"; then
+    return 0
+  fi
+
+  if host_github_output_indicates_rate_limit "${output}"; then
+    record_host_github_rate_limit "${output}"
+    return 1
+  fi
+
+  printf '%s\n' "${output}" >&2
+  return 1
+}
+
+host_github_submit_pr_approval() {
+  local output=""
+
+  flow_export_github_cli_auth_env "${repo_slug}"
+  if output="$(
+    gh api "repos/${repo_slug}/pulls/${pr_number}/reviews" \
+      --method POST \
+      -f event=APPROVE \
+      -f body="Automated final review passed. Safe low-risk scope, green checks, and host-side merge approved." \
+      2>&1
+  )"; then
+    return 0
+  fi
+
+  if grep -q "Can not approve your own pull request" <<<"${output}"; then
+    return 0
+  fi
+
+  if host_github_output_indicates_rate_limit "${output}"; then
+    record_host_github_rate_limit "${output}"
+    return 1
+  fi
+
+  printf '%s\n' "${output}" >&2
+  return 1
+}
+
+append_host_rate_limit_comment() {
+  local detail="${1:-GitHub API rate limit blocked host actions.}"
+  local reset_line=""
+
+  if grep -Eiq 'resets at ' <<<"${detail}"; then
+    reset_line="$(grep -Eio 'resets at [^.]+' <<<"${detail}" | head -n 1 || true)"
+  fi
+
+  {
+    if [[ -s "${pr_comment_file}" ]]; then
+      printf '\n\n'
+    fi
+    printf '## Host action blocked\n\n'
+    printf 'GitHub API rate limit blocked ACP from posting the PR review outcome or merge action.\n'
+    if [[ -n "${reset_line}" ]]; then
+      printf '\n- %s\n' "${reset_line}"
+    fi
+    printf -- '- ACP kept the local review artifacts and scheduled an automatic retry for the host action.\n'
+  } >>"${pr_comment_file}"
+}
+
+handle_host_github_rate_limit_retry() {
+  local reason="${1:-github-api-rate-limit}"
+  local result_action_override="${2:-host-rate-limit-retry}"
+
+  append_host_rate_limit_comment "${host_github_rate_limit_detail:-}"
+  require_transition "pr_schedule_retry" pr_schedule_retry "${reason}"
+  require_transition "pr_after_blocked" pr_after_blocked "${pr_number}"
+  cleanup_pr_session
+  result_outcome="blocked"
+  result_action="${result_action_override}"
+  failure_reason="${reason}"
+  notify_pr_reconciled
+  mark_reconciled
+  printf 'STATUS=FAILED\n'
+  printf 'PR_NUMBER=%s\n' "${pr_number}"
+  printf 'PR_STATE=%s\n' "${pr_state}"
+  printf 'OUTCOME=%s\n' "${result_outcome}"
+  printf 'ACTION=%s\n' "${result_action}"
+  printf 'FAILURE_REASON=%s\n' "${failure_reason}"
+  exit 0
+}
+
+maybe_handle_host_github_rate_limit() {
+  local reason="${1:-github-api-rate-limit}"
+  local result_action_override="${2:-host-rate-limit-retry}"
+  if [[ "${host_github_rate_limited}" == "yes" ]]; then
+    handle_host_github_rate_limit_retry "${reason}" "${result_action_override}"
+  fi
+  return 1
+}
+
 blocked_result_indicates_local_bind_failure() {
   local candidate_file
   for candidate_file in "$pr_comment_file" "$session_log_file"; do
@@ -774,23 +897,38 @@ pr_remote_already_has_final_head() {
 }
 
 approve_and_merge() {
-  local approve_output
   if ! pr_is_self_authored_for_current_actor; then
-    if ! approve_output="$(
-      flow_github_api_repo "${repo_slug}" "pulls/${pr_number}/reviews" \
-        --method POST \
-        -f event=APPROVE \
-        -f body="Automated final review passed. Safe low-risk scope, green checks, and host-side merge approved." \
-        2>&1
-    )"; then
-      if ! grep -q "Can not approve your own pull request" <<<"$approve_output"; then
-        printf '%s\n' "$approve_output" >&2
-        return 1
+    if ! host_github_submit_pr_approval; then
+      if [[ "${host_github_rate_limited}" == "yes" ]]; then
+        return 2
       fi
+      return 1
     fi
   fi
 
-  flow_github_pr_merge "$repo_slug" "$pr_number" "squash" "yes"
+  flow_export_github_cli_auth_env "${repo_slug}"
+  if ! gh pr merge "${pr_number}" -R "${repo_slug}" --squash --delete-branch --admin >"${run_dir}/host-github-merge.out" 2>"${run_dir}/host-github-merge.err"; then
+    local merge_output=""
+    merge_output="$(cat "${run_dir}/host-github-merge.err" 2>/dev/null || true)"
+    if host_github_output_indicates_rate_limit "${merge_output}"; then
+      record_host_github_rate_limit "${merge_output}"
+      return 2
+    fi
+    if flow_github_pr_merge "$repo_slug" "$pr_number" "squash" "yes" 2>"${run_dir}/host-github-merge.err"; then
+      return 0
+    fi
+    merge_output="$(cat "${run_dir}/host-github-merge.err" 2>/dev/null || true)"
+    if host_github_output_indicates_rate_limit "${merge_output}"; then
+      record_host_github_rate_limit "${merge_output}"
+      return 2
+    fi
+    if [[ -n "${merge_output}" ]]; then
+      printf '%s\n' "${merge_output}" >&2
+    fi
+    return 1
+  fi
+
+  return 0
 }
 
 cleanup_pr_session() {
@@ -829,7 +967,7 @@ handle_linked_issue_merge_cleanup() {
 handle_updated_branch_result() {
   if [[ -z "$pr_worktree" || ! -d "$pr_worktree" ]]; then
     if pr_remote_already_has_final_head; then
-      post_pr_comment_if_present
+      post_pr_comment_if_present || maybe_handle_host_github_rate_limit "github-api-rate-limit" "host-comment-rate-limit-retry"
       require_transition "pr_clear_retry" pr_clear_retry
       require_transition "pr_after_updated_branch" pr_after_updated_branch "$pr_number"
       cleanup_pr_session
@@ -895,7 +1033,7 @@ handle_updated_branch_result() {
   fi
 
   push_pr_branch
-  post_pr_comment_if_present
+  post_pr_comment_if_present || maybe_handle_host_github_rate_limit "github-api-rate-limit" "host-comment-rate-limit-retry"
   require_transition "pr_clear_retry" pr_clear_retry
   require_transition "pr_after_updated_branch" pr_after_updated_branch "$pr_number"
   cleanup_pr_session
@@ -936,7 +1074,7 @@ elif [[ "$pr_state" == "CLOSED" ]]; then
   result_action="${result_action:-cleaned-closed-pr}"
   notify_pr_reconciled
 elif [[ "$status" == "SUCCEEDED" && "$result_outcome" == "approved-local-review-passed" ]]; then
-  if ! review_pass_action="$(review_pass_action_from_result_action "${result_action:-}" 2>/dev/null)"; then
+      if ! review_pass_action="$(review_pass_action_from_result_action "${result_action:-}" 2>/dev/null)"; then
     review_pass_action="$(pr_review_pass_action "$pr_number")"
   fi
   case "$review_pass_action" in
@@ -963,8 +1101,13 @@ elif [[ "$status" == "SUCCEEDED" && "$result_outcome" == "approved-local-review-
       fi
 
       require_transition "pr_clear_retry" pr_clear_retry
-      approve_and_merge
-      pr_state="$(flow_github_pr_view_json "$repo_slug" "$pr_number" | jq -r '.state')"
+      if ! approve_and_merge; then
+        if [[ "${host_github_rate_limited}" == "yes" ]]; then
+          handle_host_github_rate_limit_retry "github-api-rate-limit" "host-merge-rate-limit-retry"
+        fi
+        exit 1
+      fi
+      pr_state="MERGED"
       if [[ "$pr_state" != "MERGED" ]]; then
         echo "PR ${pr_number} did not merge successfully" >&2
         exit 1
@@ -1018,7 +1161,7 @@ elif [[ "$status" == "SUCCEEDED" && "$result_outcome" == "no-change-needed" ]];
           result_action="host-rejected-noop-promotion"
         else
           push_pr_branch
-          post_pr_comment_if_present
+          post_pr_comment_if_present || maybe_handle_host_github_rate_limit "github-api-rate-limit" "host-comment-rate-limit-retry"
           require_transition "pr_clear_retry" pr_clear_retry
           require_transition "pr_after_updated_branch" pr_after_updated_branch "$pr_number"
           cleanup_pr_session
@@ -1041,7 +1184,7 @@ elif [[ "$status" == "SUCCEEDED" && "$result_outcome" == "no-change-needed" ]];
       result_action="host-rejected-no-change-needed"
       notify_pr_reconciled
     else
-      post_pr_comment_if_present
+      post_pr_comment_if_present || maybe_handle_host_github_rate_limit "github-api-rate-limit" "host-comment-rate-limit-retry"
       require_transition "pr_clear_retry" pr_clear_retry
       require_transition "pr_after_succeeded" pr_after_succeeded "$pr_number"
       cleanup_pr_session
@@ -1062,7 +1205,7 @@ elif [[ "$status" == "SUCCEEDED" && "$result_outcome" == "blocked" ]]; then
   elif attempt_blocked_pr_host_verification_recovery; then
     handle_updated_branch_result
   else
-    post_pr_comment_if_present
+    post_pr_comment_if_present || maybe_handle_host_github_rate_limit "github-api-rate-limit" "host-comment-rate-limit-retry"
     require_transition "pr_clear_retry" pr_clear_retry
     require_transition "pr_after_blocked" pr_after_blocked "$pr_number"
     cleanup_pr_session
@@ -1079,6 +1222,7 @@ elif [[ "$status" == "FAILED" ]]; then
   schedule_provider_quota_cooldown "${failure_reason:-worker-exit-failed}"
   require_transition "pr_schedule_retry" pr_schedule_retry "${failure_reason:-worker-exit-failed}"
   require_transition "pr_after_failed" pr_after_failed "$pr_number"
+  cleanup_pr_session
   notify_pr_reconciled
 fi
 

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

@@ -345,24 +345,28 @@ PY
   local effective_pools=""
   healthy_pools="$(
     jq -r --argjson primaryThresh "${CODEX_QUOTA_THRESHOLD}" --argjson weeklyThresh "${CODEX_QUOTA_WEEKLY_THRESHOLD}" '
-      group_by(.accountId)
+      map(. + {poolKey: (.label // .trackedLabel // .email // .accountId // "")})
       | map(select(
-          ((.[0].usage.rate_limit.limit_reached // false) | not)
-          and ((.[0].usage.rate_limit.primary_window.used_percent // 100) < $primaryThresh)
-          and ((.[0].usage.rate_limit.secondary_window.used_percent // 100) < $weeklyThresh)
-        ))
+          (.poolKey != "")
+          and ((.usage.rate_limit.limit_reached // false) | not)
+          and ((.usage.rate_limit.primary_window.used_percent // 100) < $primaryThresh)
+          and ((.usage.rate_limit.secondary_window.used_percent // 100) < $weeklyThresh)
+        ) | .poolKey)
+      | unique
       | length
     ' "${CODEX_QUOTA_FULL_CACHE_FILE}" 2>/dev/null || true
   )"
 
   rotation_pools="$(
     jq -r --argjson weeklyThresh "${CODEX_QUOTA_WEEKLY_THRESHOLD}" '
-      group_by(.accountId)
+      map(. + {poolKey: (.label // .trackedLabel // .email // .accountId // "")})
       | map(select(
-          ((.[0].usage.rate_limit.limit_reached // false) | not)
-          and ((.[0].usage.rate_limit.secondary_window.used_percent // 100) < $weeklyThresh)
-          and ((.[0].planType // "") != "free")
-        ))
+          (.poolKey != "")
+          and ((.usage.rate_limit.limit_reached // false) | not)
+          and ((.usage.rate_limit.secondary_window.used_percent // 100) < $weeklyThresh)
+          and ((.planType // "") != "free")
+        ) | .poolKey)
+      | unique
       | length
     ' "${CODEX_QUOTA_FULL_CACHE_FILE}" 2>/dev/null || true
   )"
@@ -471,6 +475,12 @@ fi
 
 run_codex_quota_preflight
 
+# Sync skill files to runtime-home if source has changed since last sync.
+# This ensures start-issue-worker.sh and other scripts are always up to date.
+if [[ -x "${FLOW_TOOLS_DIR}/ensure-runtime-sync.sh" ]]; then
+  "${FLOW_TOOLS_DIR}/ensure-runtime-sync.sh" --quiet 2>/dev/null || true
+fi
+
 acquire_lock
 
 reap_orphan_shared_loop_groups

package/tools/bin/provider-cooldown-state.sh

@@ -20,6 +20,7 @@ backend=""
 model=""
 action=""
 reason=""
+label=""
 
 case "$#" in
   1)
@@ -77,6 +78,33 @@ resolve_backend() {
   flow_config_get "${CONFIG_YAML}" "execution.coding_worker"
 }
 
+resolve_codex_label() {
+  local configured_label="${ACP_ACTIVE_PROVIDER_LABEL:-${F_LOSNING_ACTIVE_PROVIDER_LABEL:-}}"
+  local codex_quota_bin=""
+  local active_label=""
+
+  if [[ -n "${configured_label}" ]]; then
+    printf '%s\n' "${configured_label}"
+    return 0
+  fi
+
+  if [[ -n "${ACP_CODEX_QUOTA_LABEL:-${F_LOSNING_CODEX_QUOTA_LABEL:-}}" ]]; then
+    printf '%s\n' "${ACP_CODEX_QUOTA_LABEL:-${F_LOSNING_CODEX_QUOTA_LABEL:-}}"
+    return 0
+  fi
+
+  codex_quota_bin="$(flow_resolve_codex_quota_bin "${SCRIPT_DIR}")"
+  if [[ -n "${codex_quota_bin}" && -x "${codex_quota_bin}" ]]; then
+    active_label="$("${codex_quota_bin}" codex list --json 2>/dev/null | jq -r '.activeInfo.trackedLabel // .activeInfo.activeLabel // empty' 2>/dev/null || true)"
+    if [[ -n "${active_label}" ]]; then
+      printf '%s\n' "${active_label}"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
 resolve_model() {
   local resolved_backend="${1:?backend required}"
   local raw_model="${2:-}"
@@ -147,7 +175,16 @@ case "${action}" in
     ;;
 esac
 
-provider_key="$(flow_sanitize_provider_key "${backend}-${model}")"
+if [[ "${backend}" == "codex" ]]; then
+  label="$(resolve_codex_label || true)"
+fi
+
+provider_key_source="${backend}-${model}"
+if [[ "${backend}" == "codex" && -n "${label}" ]]; then
+  provider_key_source="${provider_key_source}-${label}"
+fi
+
+provider_key="$(flow_sanitize_provider_key "${provider_key_source}")"
 out="$(
   ACP_STATE_ROOT="${STATE_ROOT}" \
   ACP_PROVIDER_QUOTA_COOLDOWNS="${COOLDOWNS}" \
@@ -162,5 +199,6 @@ out="$(
 
 printf 'BACKEND=%s\n' "${backend}"
 printf 'MODEL=%s\n' "${model}"
+printf 'LABEL=%s\n' "${label}"
 printf 'PROVIDER_KEY=%s\n' "${provider_key}"
 printf '%s\n' "${out}"

package/tools/bin/start-issue-worker.sh

@@ -377,6 +377,30 @@ const recentPrs = recentNumbers.map((number) => {
 const activePrs = recentPrs.filter((pr) => pr.state === 'open' || pr.state === 'draft');
 const completedPrs = recentPrs.filter((pr) => pr.state !== 'open' && pr.state !== 'draft');
 
+const recentCycleNotes = [];
+for (const comment of [...(issue.comments || [])].reverse()) {
+  const body = String(comment?.body || '').trim();
+  if (!body) {
+    continue;
+  }
+  if (!/^(Completed|Blocked on|# Blocker:|Host-side publish blocked|Host-side publish failed)/im.test(body)) {
+    continue;
+  }
+  const summaryLines = body
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 6);
+  if (summaryLines.length === 0) {
+    continue;
+  }
+  const summary = summaryLines.join(' | ');
+  recentCycleNotes.push(summary.length > 420 ? `${summary.slice(0, 417)}...` : summary);
+  if (recentCycleNotes.length >= 3) {
+    break;
+  }
+}
+
 const formatPr = (pr) => {
   const suffix = pr.url ? ` ${pr.url}` : '';
   return `- #${pr.number} (${pr.state}): ${pr.title}${suffix}`;
@@ -389,6 +413,7 @@ const lines = [
   '- Before editing, choose exactly one concrete target module, screen, or flow and keep the cycle limited to that target.',
   '- Do not work on a target already covered by an open or draft PR for this issue, or by the most recent completed cycles listed below, unless you are explicitly fixing a regression introduced there.',
   '- If you cannot identify a small non-overlapping target after reviewing recent cycle history, stop blocked using the blocker contract instead of forcing another PR.',
+  '- Prefer the recent cycle notes below over repeating broad web research; only fetch outside context when the local baseline or linked advisories materially changed.',
   '- In your final worker output, start with `Target:` and `Why now:` lines before the changed-files list.',
 ];
 
@@ -406,6 +431,13 @@ if (completedPrs.length > 0) {
   }
 }
 
+if (recentCycleNotes.length > 0) {
+  lines.push('', '### Recent cycle notes from issue comments');
+  for (const note of recentCycleNotes) {
+    lines.push(`- ${note}`);
+  }
+}
+
 process.stdout.write(`${lines.join('\n')}\n`);
 EOF
 ISSUE_RECURRING_CONTEXT="$(cat "$ISSUE_RECURRING_CONTEXT_FILE")"

package/tools/dashboard/app.js

@@ -138,6 +138,33 @@ function renderAlerts(alerts) {
   `;
 }
 
+function renderCodexRotation(rotation) {
+  if (!rotation || !rotation.active_label) {
+    return `<div class="empty-state">Codex rotation data is not available yet for this Codex profile.</div>`;
+  }
+  const candidates = (rotation.candidate_labels || []).length ? rotation.candidate_labels.join(", ") : "n/a";
+  const ready = (rotation.ready_candidates || []).length ? rotation.ready_candidates.join(", ") : "none";
+  const nextRetry = rotation.next_retry_at
+    ? `${rotation.next_retry_label || "n/a"} · ${relativeTime(rotation.next_retry_at)}<div class="muted">${rotation.next_retry_at}</div>`
+    : "n/a";
+  const lastSwitch = rotation.last_switch_label
+    ? `${rotation.last_switch_label}${rotation.last_switch_reason ? ` · ${rotation.last_switch_reason}` : ""}`
+    : "n/a";
+
+  return renderTable(
+    [
+      { label: "Current", render: () => `<div class="mono">${rotation.active_label}</div>` },
+      { label: "Decision", render: () => `<span class="status-pill ${statusClass(rotation.switch_decision || "unknown")}">${rotation.switch_decision || "unknown"}</span>` },
+      { label: "Candidates", render: () => `<div class="mono">${candidates}</div>` },
+      { label: "Ready now", render: () => `<div class="mono">${ready}</div>` },
+      { label: "Next retry", render: () => nextRetry },
+      { label: "Last switch", render: () => `<div class="mono">${lastSwitch}</div>` },
+    ],
+    [{}],
+    "No Codex rotation data for this profile.",
+  );
+}
+
 function renderProfile(profile) {
   const providerBadges = [
     profile.coding_worker ? `<span class="badge good">${profile.coding_worker}</span>` : "",
@@ -153,6 +180,7 @@ function renderProfile(profile) {
   const summaryCards = [
     ["Run sessions", profile.counts.active_runs],
     ["Running", profile.counts.running_runs],
+    ["Recent completed", profile.counts.recent_history_runs || 0],
     ["Implemented", profile.counts.implemented_runs],
     ["Reported", profile.counts.reported_runs],
     ["Blocked", profile.counts.blocked_runs],
@@ -188,6 +216,19 @@ function renderProfile(profile) {
     "No active run directories for this profile.",
   );
 
+  const recentHistoryTable = renderTable(
+    [
+      { label: "Session", render: (row) => `<div class="mono">${row.session}</div>` },
+      { label: "Task", render: (row) => `${row.task_kind || "n/a"} ${row.task_id || ""}`.trim() },
+      { label: "Lifecycle", render: renderLifecycle },
+      { label: "Worker", key: "coding_worker" },
+      { label: "Result", render: renderResult },
+      { label: "Updated", render: (row) => row.updated_at ? `${relativeTime(row.updated_at)}<div class="muted">${row.updated_at}</div>` : "n/a" },
+    ],
+    profile.recent_history || [],
+    "No recently archived runs.",
+  );
+
   const controllerTable = renderTable(
     [
       { label: "Issue", key: "issue_id" },
@@ -214,6 +255,18 @@ function renderProfile(profile) {
     "No issue retries recorded.",
   );
 
+  const prRetryTable = renderTable(
+    [
+      { label: "PR", key: "pr_number" },
+      { label: "Status", render: (row) => `<span class="status-pill ${row.ready ? "" : "waiting-provider"}">${row.ready ? "ready" : "retrying"}</span>` },
+      { label: "Reason", render: (row) => row.last_reason || "n/a" },
+      { label: "Attempts", key: "attempts" },
+      { label: "Next attempt", render: (row) => row.next_attempt_at ? `${relativeTime(row.next_attempt_at)}<div class="muted">${row.next_attempt_at}</div>` : "n/a" },
+    ],
+    profile.pr_retries || [],
+    "No PR retries recorded.",
+  );
+
   const workerTable = renderTable(
     [
       { label: "Key", render: (row) => `<div class="mono">${row.key}</div>` },
@@ -261,6 +314,17 @@ function renderProfile(profile) {
     "No pending leased issues.",
   );
 
+  const codexRotationPanel =
+    profile.coding_worker === "codex"
+      ? `
+        <section class="panel">
+          <h3>Codex Rotation</h3>
+          <p class="panel-subtitle">Shows the active Codex label, candidate labels, and whether failover is ready or deferred.</p>
+          ${renderCodexRotation(profile.codex_rotation)}
+        </section>
+      `
+      : "";
+
   return `
     <article class="profile">
       <header class="profile-header">
@@ -285,15 +349,25 @@ function renderProfile(profile) {
           <p class="panel-subtitle">Lifecycle shows technical session completion. Result shows what the run achieved: implemented, reported, or blocked.</p>
           ${runsTable}
         </section>
+        <section class="panel">
+          <h3>Recent Completed Runs</h3>
+          <p class="panel-subtitle">Recently archived runs so they do not disappear from the dashboard immediately after completion.</p>
+          ${recentHistoryTable}
+        </section>
         <section class="panel">
           <h3>Resident Controllers</h3>
           <p class="panel-subtitle">Includes provider wait and failover telemetry. Stale controllers show a warning.</p>
           ${controllerTable}
         </section>
+        ${codexRotationPanel}
         <section class="panel half">
           <h3>Issue Retries</h3>
           ${retryTable}
         </section>
+        <section class="panel half">
+          <h3>PR Retries</h3>
+          ${prRetryTable}
+        </section>
         <section class="panel">
           <h3>Resident Worker Metadata</h3>
           ${workerTable}

package/tools/dashboard/dashboard_snapshot.py

@@ -143,6 +143,15 @@ def file_mtime_iso(path: Path) -> str:
     return datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
+def read_json_file(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    except Exception:
+        return {}
+
+
 def read_tail_text(path: Path, max_bytes: int = 65536) -> str:
     if not path.is_file():
         return ""
@@ -293,6 +302,64 @@ def collect_runs(runs_root: Path) -> list[dict[str, Any]]:
     return runs
 
 
+def collect_recent_history(history_root: Path, limit: int = 8) -> list[dict[str, Any]]:
+    if not history_root.is_dir():
+        return []
+
+    items: list[dict[str, Any]] = []
+    seen_sessions: set[str] = set()
+    for run_dir in sorted(
+        [entry for entry in history_root.iterdir() if entry.is_dir()],
+        key=lambda item: item.stat().st_mtime,
+        reverse=True,
+    ):
+        run_env = read_env_file(run_dir / "run.env")
+        runner_env = read_env_file(run_dir / "runner.env")
+        result_env = read_env_file(run_dir / "result.env")
+        session = run_env.get("SESSION", "")
+        if not session:
+            name = run_dir.name
+            parts = name.split("-")
+            session = "-".join(parts[:-2]) if len(parts) > 2 else name
+        if session in seen_sessions:
+            continue
+        lifecycle_status = (runner_env.get("RUNNER_STATE", "") or "").strip().upper()
+        if lifecycle_status == "SUCCEEDED":
+            lifecycle_status = "SUCCEEDED"
+        elif lifecycle_status == "FAILED":
+            lifecycle_status = "FAILED"
+        elif lifecycle_status:
+            lifecycle_status = lifecycle_status.upper()
+        else:
+            lifecycle_status = "UNKNOWN"
+        outcome = result_env.get("OUTCOME", "")
+        failure_reason = runner_env.get("LAST_FAILURE_REASON", "")
+        result_kind, result_label = classify_run_result(lifecycle_status, outcome, failure_reason)
+        item = {
+            "session": session,
+            "task_kind": run_env.get("TASK_KIND", ""),
+            "task_id": run_env.get("TASK_ID", ""),
+            "status": lifecycle_status,
+            "lifecycle_status": lifecycle_status,
+            "updated_at": result_env.get("UPDATED_AT", "") or runner_env.get("UPDATED_AT", "") or file_mtime_iso(run_dir),
+            "coding_worker": run_env.get("CODING_WORKER", ""),
+            "failure_reason": failure_reason,
+            "outcome": outcome,
+            "action": result_env.get("ACTION", ""),
+            "result_kind": result_kind,
+            "result_label": result_label,
+            "run_dir": str(run_dir),
+            "archived": True,
+        }
+        alert = extract_github_rate_limit_alert(run_dir, item)
+        item["alerts"] = [alert] if alert else []
+        items.append(item)
+        seen_sessions.add(session)
+        if len(items) >= limit:
+            break
+    return items
+
+
 def controller_is_stale(env: dict[str, str], controller_path: Path) -> bool:
     """A controller is stale if it claims to be running but its PID is dead or its
     UPDATED_AT file mtime is older than 10 minutes."""
@@ -408,6 +475,94 @@ def collect_provider_cooldowns(state_root: Path) -> list[dict[str, Any]]:
     return items
 
 
+def collect_codex_rotation(profile: dict[str, str]) -> dict[str, Any]:
+    coding_worker = profile.get("EFFECTIVE_CODING_WORKER", "")
+    if coding_worker != "codex":
+        return {}
+
+    cache_root = Path(os.environ.get("XDG_CACHE_HOME", str(Path.home() / ".cache"))) / "codex-quota-manager"
+    state_file = cache_root / "rotation-state.json"
+    switch_file = cache_root / "last-switch.env"
+    state_json = read_json_file(state_file)
+    state_accounts = state_json.get("accounts", {}) if isinstance(state_json, dict) else {}
+    now_epoch = int(datetime.now(timezone.utc).timestamp())
+
+    active_label = ""
+    candidate_labels: list[str] = []
+    list_json: dict[str, Any] = {}
+    quota_bin_override = os.environ.get("CODEX_QUOTA_BIN", "").strip()
+    quota_bin = Path(quota_bin_override) if quota_bin_override else TOOLS_BIN_DIR / "codex-quota"
+    if quota_bin.is_file():
+        try:
+            raw = subprocess.check_output(
+                [str(quota_bin), "codex", "list", "--json"],
+                cwd=str(ROOT_DIR),
+                env=os.environ.copy(),
+                text=True,
+                stderr=subprocess.DEVNULL,
+                timeout=20,
+            )
+            list_json = json.loads(raw)
+        except Exception:
+            list_json = {}
+
+    if isinstance(list_json, dict):
+        active_info = list_json.get("activeInfo", {}) or {}
+        active_label = str(active_info.get("trackedLabel") or active_info.get("activeLabel") or "")
+        seen: set[str] = set()
+        for account in list_json.get("accounts", []) or []:
+            label = str(account.get("label") or "").strip()
+            if not label or label == active_label or label in seen:
+                continue
+            candidate_labels.append(label)
+            seen.add(label)
+
+    next_retry_label = ""
+    next_retry_epoch = 0
+    for label in candidate_labels:
+        entry = state_accounts.get(label, {}) if isinstance(state_accounts, dict) else {}
+        retry_epoch = safe_int(str(entry.get("next_retry_at", "")))
+        removed = bool(entry.get("removed", False))
+        if removed or not retry_epoch or retry_epoch <= now_epoch:
+            continue
+        if next_retry_epoch == 0 or retry_epoch < next_retry_epoch:
+            next_retry_epoch = retry_epoch
+            next_retry_label = label
+
+    ready_candidates = []
+    for label in candidate_labels:
+        entry = state_accounts.get(label, {}) if isinstance(state_accounts, dict) else {}
+        retry_epoch = safe_int(str(entry.get("next_retry_at", ""))) or 0
+        removed = bool(entry.get("removed", False))
+        if not removed and retry_epoch <= now_epoch:
+            ready_candidates.append(label)
+
+    last_switch = read_env_file(switch_file)
+    switch_decision = "unknown"
+    if ready_candidates:
+        switch_decision = "ready-candidate"
+    elif next_retry_label:
+        switch_decision = "deferred"
+    elif last_switch.get("LAST_SWITCH_LABEL"):
+        switch_decision = "switched"
+    elif candidate_labels:
+        switch_decision = "failed"
+
+    return {
+        "active_label": active_label,
+        "candidate_labels": candidate_labels,
+        "ready_candidates": ready_candidates,
+        "next_retry_label": next_retry_label,
+        "next_retry_epoch": next_retry_epoch,
+        "next_retry_at": datetime.fromtimestamp(next_retry_epoch, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") if next_retry_epoch else "",
+        "switch_decision": switch_decision,
+        "last_switch_label": last_switch.get("LAST_SWITCH_LABEL", ""),
+        "last_switch_reason": last_switch.get("LAST_SWITCH_REASON", ""),
+        "last_switch_epoch": safe_int(last_switch.get("LAST_SWITCH_EPOCH")),
+        "state_file": str(state_file),
+    }
+
+
 def collect_scheduled_issues(state_root: Path) -> list[dict[str, Any]]:
     scheduled_root = state_root / "scheduled-issues"
     if not scheduled_root.is_dir():
@@ -455,6 +610,43 @@ def collect_issue_retries(state_root: Path) -> list[dict[str, Any]]:
     return items
 
 
+def collect_pr_retries(state_root: Path) -> list[dict[str, Any]]:
+    retries_root = state_root / "retries" / "prs"
+    if not retries_root.is_dir():
+        return []
+
+    now_epoch = int(datetime.now(timezone.utc).timestamp())
+    items: list[dict[str, Any]] = []
+    for path in sorted(retries_root.glob("*.env"), key=lambda item: item.stat().st_mtime, reverse=True):
+        env = read_env_file(path)
+        next_attempt_epoch = safe_int(env.get("NEXT_ATTEMPT_EPOCH"))
+        items.append(
+            {
+                "pr_number": path.stem,
+                "attempts": safe_int(env.get("ATTEMPTS")) or 0,
+                "next_attempt_epoch": next_attempt_epoch,
+                "next_attempt_at": env.get("NEXT_ATTEMPT_AT", ""),
+                "last_reason": env.get("LAST_REASON", ""),
+                "updated_at": env.get("UPDATED_AT", "") or file_mtime_iso(path),
+                "ready": not bool(next_attempt_epoch and next_attempt_epoch > now_epoch),
+                "state_file": str(path),
+            }
+        )
+    return items
+
+
+def resolve_history_root(render_env: dict[str, str], yaml_env: dict[str, str], runs_root: Path) -> Path:
+    configured = (
+        render_env.get("EFFECTIVE_HISTORY_ROOT", "").strip()
+        or yaml_env.get("runtime.history_root", "").strip()
+    )
+    if configured and configured != ".":
+        return Path(configured)
+    if runs_root.name == "runs":
+        return runs_root.parent / "history"
+    return Path(".")
+
+
 def collect_issue_queue(state_root: Path) -> dict[str, list[dict[str, Any]]]:
     queue_root = state_root / "resident-workers" / "issue-queue"
     pending_root = queue_root / "pending"
@@ -491,14 +683,18 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
 
     runs_root = Path(render_env.get("EFFECTIVE_RUNS_ROOT", ""))
     state_root = Path(render_env.get("EFFECTIVE_STATE_ROOT", ""))
+    history_root = resolve_history_root(render_env, yaml_env, runs_root)
     runs = collect_runs(runs_root)
+    recent_history = collect_recent_history(history_root)
     controllers = collect_resident_controllers(state_root)
     resident_workers = collect_resident_workers(state_root)
     cooldowns = collect_provider_cooldowns(state_root)
     scheduled = collect_scheduled_issues(state_root)
     retries = collect_issue_retries(state_root)
+    pr_retries = collect_pr_retries(state_root)
     queue = collect_issue_queue(state_root)
-    alerts = [alert for run in runs for alert in run.get("alerts", [])]
+    alerts = [alert for run in (runs + recent_history) for alert in run.get("alerts", [])]
+    codex_rotation = collect_codex_rotation(render_env)
 
     return {
         "id": profile_id,
@@ -506,6 +702,7 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
         "repo_root": render_env.get("EFFECTIVE_REPO_ROOT", ""),
         "runs_root": str(runs_root),
         "state_root": str(state_root),
+        "history_root": str(history_root),
         "issue_prefix": yaml_env.get("session_naming.issue_prefix", ""),
         "pr_prefix": yaml_env.get("session_naming.pr_prefix", ""),
         "coding_worker": render_env.get("EFFECTIVE_CODING_WORKER", ""),
@@ -520,6 +717,7 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
             "last_reason": render_env.get("EFFECTIVE_PROVIDER_POOL_LAST_REASON", ""),
             "pools_exhausted": render_env.get("EFFECTIVE_PROVIDER_POOLS_EXHAUSTED", ""),
         },
+        "codex_rotation": codex_rotation,
         "counts": {
             "active_runs": len(runs),
             "running_runs": sum(1 for item in runs if item["status"] == "RUNNING"),
@@ -531,6 +729,7 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
             "completed_runs": sum(
                 1 for item in runs if item["status"] == "SUCCEEDED" and item["result_kind"] not in {"implemented", "reported", "blocked"}
             ),
+            "recent_history_runs": len(recent_history),
             "resident_controllers": len(controllers),
             "live_resident_controllers": sum(1 for item in controllers if item["state"] != "stopped" and item["controller_live"]),
             "stale_resident_controllers": sum(1 for item in controllers if item.get("controller_stale", False)),
@@ -543,12 +742,14 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
             "alerts": len(alerts),
         },
         "runs": runs,
+        "recent_history": recent_history,
         "alerts": alerts,
         "resident_controllers": controllers,
         "resident_workers": resident_workers,
         "provider_cooldowns": cooldowns,
         "scheduled_issues": scheduled,
         "issue_retries": retries,
+        "pr_retries": pr_retries,
         "issue_queue": queue,
     }
 

package/tools/vendor/codex-quota-manager/scripts/auto-switch.sh

@@ -410,12 +410,6 @@ for label in "${CANDIDATE_LABELS[@]}"; do
     continue
   fi
 
-  retry_at="$(state_next_retry_at "$label")"
-  if [[ "$retry_at" =~ ^[0-9]+$ ]] && (( retry_at > now_epoch )); then
-    note_candidate_retry "$label" "$retry_at"
-    continue
-  fi
-
   quota_output="$(load_account_quota_json "$label" 2>&1 || true)"
   if ! jq -e 'type == "array" and length > 0' >/dev/null 2>&1 <<<"$quota_output"; then
     if is_auth_401_output "$quota_output"; then
@@ -436,6 +430,14 @@ for label in "${CANDIDATE_LABELS[@]}"; do
     continue
   fi
 
+  retry_at="$(state_next_retry_at "$label")"
+  if [[ "$retry_at" =~ ^[0-9]+$ ]] && (( retry_at > now_epoch )) && account_is_eligible "$label" "$quota_output"; then
+    state_mark_ready "$label" "quota-revalidated" "$now_epoch"
+  elif [[ "$retry_at" =~ ^[0-9]+$ ]] && (( retry_at > now_epoch )); then
+    note_candidate_retry "$label" "$retry_at"
+    continue
+  fi
+
   if ! account_is_eligible "$label" "$quota_output"; then
     retry_at="$(account_retry_epoch "$label" "$quota_output")"
     if [[ "$retry_at" =~ ^[0-9]+$ ]] && (( retry_at > now_epoch )); then

package/tools/bin/render-dashboard-snapshot.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import pathlib
-import sys
-
-
-ROOT = pathlib.Path(__file__).resolve().parents[1] / "dashboard"
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-from dashboard_snapshot import main
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/tools/templates/legacy/issue-prompt-template-pre-slim.md

@@ -1,109 +0,0 @@
-# Task
-
-Implement issue #{ISSUE_ID} in `{REPO_SLUG}`.
-
-# Issue Context
-
-- Title: {ISSUE_TITLE}
-- URL: {ISSUE_URL}
-- Auto-merge requested: {ISSUE_AUTOMERGE}
-
-{ISSUE_BODY}
-{ISSUE_RECURRING_CONTEXT}
-{ISSUE_BLOCKER_CONTEXT}
-
-# MANDATORY WORKFLOW (follow in order, no skipping)
-
-You MUST complete ALL 5 phases in order. Do not skip any phase. Do not commit until Phase 4 passes.
-
-## Phase 1: READ & SCOPE
-
-- Read the repo instructions: `AGENTS.md`, relevant spec or design docs, and any repo conventions tied to this issue.
-- Identify the single primary product surface you will touch.
-- If the issue spans multiple surfaces, pick ONE and create follow-up issues for the rest using:
-  ```bash
-  bash "$ACP_FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent {ISSUE_ID} --title "..." --body-file /tmp/follow-up.md
-  ```
-- Treat a broad umbrella issue as a coordination brief rather than permission to ship every slice in one PR.
-- Write down your scope decision before coding.
-
-## Phase 2: IMPLEMENT
-
-- Make the smallest root-cause fix that satisfies the issue.
-- Work only inside the dedicated worktree.
-- Add or update tests when feasible.
-- STOP after implementation. Do not commit yet.
-
-## Phase 3: VERIFY (MANDATORY)
-
-After implementing, you MUST run verification commands and record each one.
-Every successful command must be recorded or the host publish will fail.
-After each successful verification command, record it with `record-verification.sh`.
-
-```bash
-{ISSUE_VERIFICATION_COMMAND_SNIPPET}
-```
-
-Required verification coverage:
-- Run the narrowest repo-supported `typecheck`, `build`, `test`, or `lint` command that proves the touched surface is safe.
-- If you changed tests only, run the most relevant targeted test command and record it.
-- If you changed localization resources or user-facing copy, run repo locale validation or hardcoded-copy scans if the repo provides them.
-- If a verification command fails, fix the issue and rerun until it passes.
-
-CRITICAL: `verification.jsonl` must exist in `$ACP_RUN_DIR` with at least one `pass` entry before you can write `OUTCOME=implemented`.
-
-## Phase 4: SELF-REVIEW (MANDATORY)
-
-Before committing, perform this checklist:
-
-- [ ] Run `git diff --check`.
-- [ ] Count non-test product files: if the change is broad, stop and split scope instead of publishing one large PR.
-- [ ] If you touched auth, login, session, or reset flows, verify existing users and legacy data still behave correctly.
-- [ ] If you touched public endpoints, public routes, or operator workflows, search downstream consumers in `scripts/`, `docs/`, and specs.
-- [ ] If you changed localization resources or user-facing copy, confirm localization coverage and scanning are still valid.
-- [ ] If you touched mobile routes or screens, keep route scope narrow and verify loading, empty, and error states.
-
-Before committing, verify the journal exists:
-```bash
-test -s "$ACP_RUN_DIR/verification.jsonl" && echo "OK: verification.jsonl exists" || echo "BLOCKED: missing verification.jsonl"
-```
-
-## Phase 5: COMMIT & REPORT
-
-- Commit with a conventional commit message.
-- Do NOT push or open a PR; the host handles that.
-- Write `$ACP_RESULT_FILE`:
-  ```bash
-  cat > "$ACP_RESULT_FILE" <<'OUTER_EOF'
-  OUTCOME=implemented
-  ACTION=host-publish-issue-pr
-  ISSUE_ID={ISSUE_ID}
-  OUTER_EOF
-  ```
-- In your final output, include the changed files, verification commands actually run, and one short self-review note naming the main regression risk you checked.
-
-# STOP CONDITIONS
-
-Stop and report blocked if:
-- The issue is ambiguous, blocked by missing credentials, or expands into high-risk scope.
-- You cannot complete verification successfully.
-- The issue needs full decomposition into focused follow-up issues.
-
-If stopped blocked, write `$ACP_RUN_DIR/issue-comment.md` with a blocker summary, then:
-```bash
-cat > "$ACP_RESULT_FILE" <<'OUTER_EOF'
-OUTCOME=blocked
-ACTION=host-comment-blocker
-ISSUE_ID={ISSUE_ID}
-OUTER_EOF
-```
-
-If fully decomposed into follow-up issues, start the first line of `issue-comment.md` with exactly:
-`Superseded by focused follow-up issues: #...`
-
-# Git Rules
-
-- Do NOT push the branch from inside the worker.
-- Do NOT open a PR from inside the worker.
-- Do NOT comment on the source issue with a PR URL from inside the worker.
-- Exit successfully after writing the result file.