agent-control-plane 0.1.8 → 0.1.12

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

@@ -153,6 +153,54 @@ reap_stale_run_dir() {
   mv "$RUN_DIR" "${HISTORY_ROOT}/${SESSION}-stale-$(date +%Y%m%d-%H%M%S)"
 }
 
+find_archived_issue_session_dir() {
+  local root="${1:-}"
+  local target_session="${2:-}"
+  [[ -n "$root" && -d "$root" && -n "$target_session" ]] || return 1
+
+  find "$root" -mindepth 1 -maxdepth 1 -type d -name "${target_session}-*" ! -name "${target_session}-stale-*" 2>/dev/null \
+    | sort -r \
+    | head -n 1
+}
+
+issue_retry_state_value() {
+  local key="${1:?retry-state key required}"
+  awk -F= -v target_key="$key" '$1 == target_key { print substr($0, index($0, "=") + 1); exit }' <<<"${ISSUE_RETRY_STATE:-}"
+}
+
+issue_host_publish_replay_dir() {
+  local last_reason=""
+  local archived_dir=""
+  local runner_state=""
+  local result_outcome=""
+  local result_action=""
+
+  last_reason="$(issue_retry_state_value LAST_REASON)"
+  case "${last_reason}" in
+    host-publish-failed|issue-worker-blocked) ;;
+    *) return 1 ;;
+  esac
+
+  archived_dir="$(find_archived_issue_session_dir "$HISTORY_ROOT" "$SESSION" || true)"
+  [[ -n "${archived_dir}" && -f "${archived_dir}/run.env" && -f "${archived_dir}/runner.env" && -f "${archived_dir}/result.env" ]] || return 1
+
+  runner_state="$(awk -F= '/^RUNNER_STATE=/{print $2; exit}' "${archived_dir}/runner.env")"
+  result_outcome="$(awk -F= '/^OUTCOME=/{print $2; exit}' "${archived_dir}/result.env")"
+  result_action="$(awk -F= '/^ACTION=/{print $2; exit}' "${archived_dir}/result.env")"
+
+  [[ "${runner_state}" == "succeeded" ]] || return 1
+  [[ "${result_outcome}" == "implemented" ]] || return 1
+  [[ "${result_action}" == "host-publish-issue-pr" ]] || return 1
+
+  printf '%s\n' "${archived_dir}"
+}
+
+replay_issue_host_publish_retry() {
+  local archived_dir="${1:?archived dir required}"
+  printf 'ISSUE_HOST_PUBLISH_REPLAY=session=%s archived_run_dir=%s\n' "${SESSION}" "${archived_dir}" >&2
+  bash "${WORKSPACE_DIR}/bin/reconcile-issue-worker.sh" "${SESSION}"
+}
+
 if tmux has-session -t "$SESSION" 2>/dev/null; then
   echo "worker session already exists: $SESSION" >&2
   exit 1
@@ -180,6 +228,9 @@ EOF
 ISSUE_REQUIRES_LOCAL_WORKSPACE_INSTALL="$(
   ISSUE_BODY="$ISSUE_BODY" bash "$LOCAL_INSTALL_POLICY_BIN"
 )"
+ISSUE_RETRY_STATE="$(
+  bash "${WORKSPACE_DIR}/bin/retry-state.sh" issue "$ISSUE_ID" get 2>/dev/null || true
+)"
 if [[ "${ISSUE_SCHEDULE_INTERVAL_SECONDS}" =~ ^[1-9][0-9]*$ ]]; then
   TEMPLATE_FILE="${SCHEDULED_TEMPLATE_FILE}"
 fi
@@ -227,6 +278,16 @@ if [[ -d "$RUN_DIR" ]]; then
   reap_stale_run_dir
 fi
 
+ISSUE_HOST_PUBLISH_REPLAY_DIR="$(issue_host_publish_replay_dir || true)"
+if [[ -n "${ISSUE_HOST_PUBLISH_REPLAY_DIR}" ]]; then
+  if ! replay_issue_host_publish_retry "${ISSUE_HOST_PUBLISH_REPLAY_DIR}"; then
+    echo "host publish replay failed for session ${SESSION}" >&2
+    exit 1
+  fi
+  launch_success="yes"
+  exit 0
+fi
+
 block_if_recurring_checklist_complete
 
 mkdir -p "$RUN_DIR"
@@ -348,9 +409,6 @@ if (completedPrs.length > 0) {
 process.stdout.write(`${lines.join('\n')}\n`);
 EOF
 ISSUE_RECURRING_CONTEXT="$(cat "$ISSUE_RECURRING_CONTEXT_FILE")"
-ISSUE_RETRY_STATE="$(
-  bash "${WORKSPACE_DIR}/bin/retry-state.sh" issue "$ISSUE_ID" get 2>/dev/null || true
-)"
 ISSUE_BLOCKER_CONTEXT="$(
   ISSUE_JSON="$ISSUE_JSON" ISSUE_RETRY_STATE="$ISSUE_RETRY_STATE" node <<'EOF'
 const issue = JSON.parse(process.env.ISSUE_JSON || '{}');
@@ -386,6 +444,41 @@ const blockerComment = [...(issue.comments || [])]
     ),
   );
 
+const inferCommentReason = (bodyText) => {
+  const body = String(bodyText || '');
+  const marker = 'Failure reason:';
+  const markerIndex = body.search(/Failure reason:/i);
+  if (markerIndex !== -1) {
+    const backtick = String.fromCharCode(96);
+    const tail = body.slice(markerIndex + marker.length);
+    const firstQuoted = tail.split(backtick)[1];
+    if (firstQuoted) {
+      return firstQuoted.trim();
+    }
+  }
+  if (/^# Blocker: Verification requirements were not satisfied$/im.test(body)) {
+    return 'verification-guard-blocked';
+  }
+  if (/^# Blocker: Localization requirements were not satisfied$/im.test(body)) {
+    return 'localization-guard-blocked';
+  }
+  if (/^# Blocker: (All checklist items already completed|Worker produced no publishable delta)$/im.test(body)) {
+    return 'no-publishable-commits';
+  }
+  if (/scope guard/i.test(body)) {
+    return 'scope-guard-blocked';
+  }
+  if (/^# Blocker: Provider quota is currently exhausted$/im.test(body)) {
+    return 'provider-quota-limit';
+  }
+  return '';
+};
+
+const effectiveLastReason =
+  lastReason && lastReason !== 'issue-worker-blocked'
+    ? lastReason
+    : inferCommentReason(blockerComment?.body || '') || lastReason;
+
 if (!blockerComment || !blockerComment.body) {
   const fallbackLines = [
     '',
@@ -393,13 +486,13 @@ if (!blockerComment || !blockerComment.body) {
     'This issue is being retried after an `agent-blocked` stop.',
     '- First resolve the prior blocker instead of repeating the same broad implementation path.',
   ];
-  if (lastReason) {
-    fallbackLines.push(`- Last recorded blocker: \`${lastReason}\`.`);
+  if (effectiveLastReason) {
+    fallbackLines.push('- Last recorded blocker: `' + effectiveLastReason + '`.');
   }
   if (attempts > 0) {
-    fallbackLines.push(`- Blocked retries so far: ${attempts}.`);
+    fallbackLines.push('- Blocked retries so far: ' + attempts + '.');
   }
-  if (lastReason === 'scope-guard-blocked' && attempts >= 2) {
+  if (effectiveLastReason === 'scope-guard-blocked' && attempts >= 2) {
     fallbackLines.push(
       '- This issue has already hit the scope guard multiple times. Do not attempt another broad multi-surface patch.',
       `- Either ship one focused slice that stays under the scope guard, or create focused follow-up issues with \`bash "$FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent ${issue.number} --title "..." --body-file /tmp/follow-up.md\` and supersede the umbrella.`,
@@ -420,22 +513,24 @@ const lines = [
   '- Address the blocker below before attempting a new implementation/publish cycle.',
 ];
 
-if (lastReason) {
-  lines.push(`- Last recorded blocker: \`${lastReason}\`.`);
+if (effectiveLastReason) {
+  lines.push('- Last recorded blocker: `' + effectiveLastReason + '`.');
 }
 if (attempts > 0) {
-  lines.push(`- Blocked retries so far: ${attempts}.`);
+  lines.push('- Blocked retries so far: ' + attempts + '.');
 }
 if (nextAttemptAt) {
-  lines.push(`- Last scheduled retry target was ${nextAttemptAt}.`);
+  lines.push('- Last scheduled retry target was ' + nextAttemptAt + '.');
 }
-if (lastReason === 'scope-guard-blocked') {
+if (effectiveLastReason === 'scope-guard-blocked') {
   lines.push('- Treat this as a scope problem first: narrow to one safe slice or decompose into focused follow-up issues.');
   if (attempts >= 2) {
     lines.push(`- Because the scope guard has already fired multiple times, do not retry the same umbrella patch. Use \`bash "$FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent ${issue.number} --title "..." --body-file /tmp/follow-up.md\` for the remaining slices, then supersede the umbrella if you covered the full decomposition.`);
   }
-} else if (lastReason === 'verification-guard-blocked') {
+} else if (effectiveLastReason === 'verification-guard-blocked') {
   lines.push('- Add the missing verification or shrink the touched surface before attempting another publish cycle.');
+} else if (effectiveLastReason === 'localization-guard-blocked') {
+  lines.push('- Finish moving the remaining user-facing literals behind translation keys before attempting another publish cycle.');
 }
 
 lines.push('', clippedBody);
@@ -547,10 +642,11 @@ open_or_reuse_issue_worktree() {
       RESIDENT_OPENCLAW_CONFIG_PATH="${current_resident_openclaw_config_path}"
       RESIDENT_TASK_COUNT="$(( ${TASK_COUNT:-0} + 1 ))"
       RESIDENT_WORKTREE_REUSED="yes"
-      if [[ "${CODING_WORKER}" == "openclaw" && -n "${previous_issue_id}" && "${previous_issue_id}" != "${current_issue_id}" ]]; then
+      if [[ "${CODING_WORKER}" == "openclaw" ]]; then
         # Keep the resident lane's warm workspace/agent files, but rotate the
-        # OpenClaw conversation thread when switching issues to reduce context drift.
-        RESIDENT_OPENCLAW_SESSION_ID="$(flow_resident_issue_openclaw_session_id "${CONFIG_YAML}" "${current_issue_id}")"
+        # OpenClaw conversation thread every cycle so a new task does not inherit
+        # stale conversational context from the previous one.
+        RESIDENT_OPENCLAW_SESSION_ID="$(flow_resident_issue_openclaw_session_id "${CONFIG_YAML}" "${current_issue_id}" "${RESIDENT_TASK_COUNT}")"
       fi
       if reuse_output="$("${WORKSPACE_DIR}/bin/reuse-issue-worktree.sh" "${WORKTREE}" "${ISSUE_ID}" "${ISSUE_SLUG}" 2>&1)"; then
         WORKTREE_OUT="${reuse_output}"
@@ -558,6 +654,9 @@ open_or_reuse_issue_worktree() {
         printf 'RESIDENT_REUSE_FALLBACK=issue-%s reason=%s\n' "${ISSUE_ID}" "$(printf '%s' "${reuse_output}" | tr '\n' ' ' | sed 's/  */ /g')" >&2
         RESIDENT_TASK_COUNT="1"
         RESIDENT_WORKTREE_REUSED="no"
+        if [[ "${CODING_WORKER}" == "openclaw" ]]; then
+          RESIDENT_OPENCLAW_SESSION_ID="$(flow_resident_issue_openclaw_session_id "${CONFIG_YAML}" "${current_issue_id}" "${RESIDENT_TASK_COUNT}")"
+        fi
         if [[ "$ISSUE_REQUIRES_LOCAL_WORKSPACE_INSTALL" == "yes" ]]; then
           WORKTREE_OUT="$(ACP_WORKTREE_LOCAL_INSTALL=true F_LOSNING_WORKTREE_LOCAL_INSTALL=true "${WORKSPACE_DIR}/bin/new-worktree.sh" "$ISSUE_ID" "$ISSUE_SLUG")"
         else
@@ -567,6 +666,9 @@ open_or_reuse_issue_worktree() {
     else
       RESIDENT_TASK_COUNT="1"
       RESIDENT_WORKTREE_REUSED="no"
+      if [[ "${CODING_WORKER}" == "openclaw" ]]; then
+        RESIDENT_OPENCLAW_SESSION_ID="$(flow_resident_issue_openclaw_session_id "${CONFIG_YAML}" "${current_issue_id}" "${RESIDENT_TASK_COUNT}")"
+      fi
       if [[ "$ISSUE_REQUIRES_LOCAL_WORKSPACE_INSTALL" == "yes" ]]; then
         WORKTREE_OUT="$(ACP_WORKTREE_LOCAL_INSTALL=true F_LOSNING_WORKTREE_LOCAL_INSTALL=true "${WORKSPACE_DIR}/bin/new-worktree.sh" "$ISSUE_ID" "$ISSUE_SLUG")"
       else

package/tools/bin/start-resident-issue-loop.sh

@@ -785,6 +785,7 @@ while true; do
   controller_refresh_execution_context
   controller_refresh_issue_lane_context "${is_scheduled}" "${schedule_interval_seconds}"
   controller_track_provider_selection "provider-selection"
+  controller_write_state "starting" ""
 
   if controller_yield_to_live_lane_peer; then
     break

package/tools/bin/sync-shared-agent-home.sh

@@ -69,6 +69,31 @@ sync_skill_copies() {
   fi
 }
 
+refresh_legacy_profile_templates() {
+  local profiles_root=""
+  local current_issue_template=""
+  local legacy_issue_template=""
+  local profile_dir=""
+  local profile_issue_template=""
+
+  profiles_root="$(resolve_flow_profile_registry_root)"
+  current_issue_template="${FLOW_SKILL_SOURCE}/tools/templates/issue-prompt-template.md"
+  legacy_issue_template="${FLOW_SKILL_SOURCE}/tools/templates/legacy/issue-prompt-template-pre-slim.md"
+
+  [[ -d "${profiles_root}" ]] || return 0
+  [[ -f "${current_issue_template}" ]] || return 0
+  [[ -f "${legacy_issue_template}" ]] || return 0
+
+  while IFS= read -r profile_dir; do
+    [[ -n "${profile_dir}" ]] || continue
+    profile_issue_template="${profile_dir}/templates/issue-prompt-template.md"
+    [[ -f "${profile_issue_template}" ]] || continue
+    if cmp -s "${profile_issue_template}" "${legacy_issue_template}"; then
+      cp "${current_issue_template}" "${profile_issue_template}"
+    fi
+  done < <(find "${profiles_root}" -mindepth 2 -maxdepth 2 -type f -name 'control-plane.yaml' -exec dirname {} \; 2>/dev/null | sort)
+}
+
 remove_repo_local_profile_dirs() {
   local candidate=""
 
@@ -210,5 +235,6 @@ fi
 sync_skill_copies
 remove_repo_local_profile_dirs
 normalize_script_permissions
+refresh_legacy_profile_templates
 
 printf 'SHARED_AGENT_HOME=%s\n' "${TARGET_HOME}"

package/tools/bin/test-smoke.sh

@@ -58,7 +58,12 @@ run_step() {
   return "${status}"
 }
 
-run_step "check-skill-contracts" bash "${check_contracts_script}"
+if [[ -f "${check_contracts_script}" ]]; then
+  run_step "check-skill-contracts" bash "${check_contracts_script}"
+else
+  printf 'SMOKE_STEP=%s\n' "check-skill-contracts"
+  printf 'SMOKE_STEP_STATUS=%s\n' "skipped"
+fi
 
 run_profile_smoke_fixture() (
   set -euo pipefail

package/tools/dashboard/app.js

@@ -2,6 +2,8 @@ const refreshButton = document.querySelector("#refresh-button");
 const generatedAtNode = document.querySelector("#generated-at");
 const overviewNode = document.querySelector("#overview");
 const profilesNode = document.querySelector("#profiles");
+const seenAlertIds = new Set();
+let notificationPermissionRequested = false;
 
 function relativeTime(input) {
   if (!input) return "n/a";
@@ -45,7 +47,7 @@ function renderResult(row) {
 
 function renderControllerState(row) {
   const state = row.state || "n/a";
-  const stale = state !== "stopped" && row.controller_live === false;
+  const stale = row.controller_stale === true || (state !== "stopped" && row.controller_live === false);
   const label = stale ? `${state} (stale)` : state;
   return `<span class="status-pill ${statusClass(stale ? "stale" : state)}">${label}</span>`;
 }
@@ -61,9 +63,10 @@ function renderOverview(snapshot) {
       acc.controllers += profile.counts.live_resident_controllers;
       acc.cooldowns += profile.counts.provider_cooldowns;
       acc.queue += profile.counts.queued_issues;
+      acc.alerts += profile.counts.alerts || 0;
       return acc;
     },
-    { activeRuns: 0, runningRuns: 0, implementedRuns: 0, reportedRuns: 0, blockedRuns: 0, controllers: 0, cooldowns: 0, queue: 0 },
+    { activeRuns: 0, runningRuns: 0, implementedRuns: 0, reportedRuns: 0, blockedRuns: 0, controllers: 0, cooldowns: 0, queue: 0, alerts: 0 },
   );
 
   overviewNode.innerHTML = [
@@ -75,6 +78,7 @@ function renderOverview(snapshot) {
     ["Blocked", totals.blockedRuns],
     ["Live Controllers", totals.controllers],
     ["Provider Cooldowns", totals.cooldowns],
+    ["Alerts", totals.alerts],
     ["Queued Issues", totals.queue],
   ]
     .map(
@@ -104,6 +108,36 @@ function renderTable(columns, rows, emptyMessage = "No data right now.") {
   return `<div class="table-wrap"><table><thead><tr>${headers}</tr></thead><tbody>${body}</tbody></table></div>`;
 }
 
+function renderAlerts(alerts) {
+  if (!alerts.length) {
+    return `<div class="empty-state">No active alerts for this profile.</div>`;
+  }
+  return `
+    <div class="alert-list">
+      ${alerts
+        .map(
+          (alert) => `
+            <article class="alert-card ${statusClass(alert.severity || "warn")}">
+              <div class="alert-header">
+                <div>
+                  <h4>${alert.title}</h4>
+                  <div class="muted mono">${alert.session || "n/a"} · ${alert.task_kind || "task"} ${alert.task_id || ""}</div>
+                </div>
+                <span class="badge warn">${alert.kind}</span>
+              </div>
+              <p>${alert.message}</p>
+              <div class="alert-meta">
+                <span>${alert.reset_at ? `Reset: ${alert.reset_at}` : "Reset: n/a"}</span>
+                <span>${alert.updated_at ? `${relativeTime(alert.updated_at)} · ${alert.updated_at}` : "updated n/a"}</span>
+              </div>
+            </article>
+          `,
+        )
+        .join("")}
+    </div>
+  `;
+}
+
 function renderProfile(profile) {
   const providerBadges = [
     profile.coding_worker ? `<span class="badge good">${profile.coding_worker}</span>` : "",
@@ -123,7 +157,10 @@ function renderProfile(profile) {
     ["Reported", profile.counts.reported_runs],
     ["Blocked", profile.counts.blocked_runs],
     ["Live controllers", profile.counts.live_resident_controllers],
+    ["Stale controllers", profile.counts.stale_resident_controllers],
     ["Provider cooldowns", profile.counts.provider_cooldowns],
+    ["Alerts", profile.counts.alerts || 0],
+    ["Issue retries", profile.counts.active_retries],
     ["Queued issues", profile.counts.queued_issues],
     ["Scheduled", profile.counts.scheduled_issues],
   ]
@@ -165,6 +202,18 @@ function renderProfile(profile) {
     "No resident controllers recorded for this profile.",
   );
 
+  const retryTable = renderTable(
+    [
+      { label: "Issue", key: "issue_id" },
+      { 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.issue_retries || [],
+    "No issue retries recorded.",
+  );
+
   const workerTable = renderTable(
     [
       { label: "Key", render: (row) => `<div class="mono">${row.key}</div>` },
@@ -226,6 +275,11 @@ function renderProfile(profile) {
       </header>
       <section class="overview">${summaryCards}</section>
       <section class="profile-grid">
+        <section class="panel">
+          <h3>Host Alerts</h3>
+          <p class="panel-subtitle">High-signal operational blockers surfaced from active run logs and comment artifacts.</p>
+          ${renderAlerts(profile.alerts || [])}
+        </section>
         <section class="panel">
           <h3>Active Runs</h3>
           <p class="panel-subtitle">Lifecycle shows technical session completion. Result shows what the run achieved: implemented, reported, or blocked.</p>
@@ -233,9 +287,13 @@ function renderProfile(profile) {
         </section>
         <section class="panel">
           <h3>Resident Controllers</h3>
-          <p class="panel-subtitle">Includes provider wait and failover telemetry.</p>
+          <p class="panel-subtitle">Includes provider wait and failover telemetry. Stale controllers show a warning.</p>
           ${controllerTable}
         </section>
+        <section class="panel half">
+          <h3>Issue Retries</h3>
+          ${retryTable}
+        </section>
         <section class="panel">
           <h3>Resident Worker Metadata</h3>
           ${workerTable}
@@ -257,6 +315,35 @@ function renderProfile(profile) {
   `;
 }
 
+async function maybeNotifyAlerts(snapshot) {
+  const alerts = (snapshot.alerts || []).filter((alert) => alert && alert.id);
+  if (!alerts.length || typeof window.Notification === "undefined") return;
+
+  if (window.Notification.permission === "default" && !notificationPermissionRequested) {
+    notificationPermissionRequested = true;
+    try {
+      await window.Notification.requestPermission();
+    } catch (_error) {
+      return;
+    }
+  }
+
+  if (window.Notification.permission !== "granted") return;
+
+  for (const alert of alerts) {
+    if (seenAlertIds.has(alert.id)) continue;
+    seenAlertIds.add(alert.id);
+    const bodyParts = [];
+    if (alert.session) bodyParts.push(alert.session);
+    if (alert.reset_at) bodyParts.push(`reset ${alert.reset_at}`);
+    if (alert.message) bodyParts.push(alert.message);
+    new window.Notification(alert.title || "ACP alert", {
+      body: bodyParts.join(" · ").slice(0, 240),
+      tag: alert.id,
+    });
+  }
+}
+
 async function loadSnapshot() {
   refreshButton.disabled = true;
   try {
@@ -268,6 +355,7 @@ async function loadSnapshot() {
     generatedAtNode.textContent = `Snapshot: ${snapshot.generated_at}`;
     renderOverview(snapshot);
     profilesNode.innerHTML = snapshot.profiles.map(renderProfile).join("");
+    await maybeNotifyAlerts(snapshot);
   } catch (error) {
     generatedAtNode.textContent = `Snapshot load failed: ${error.message}`;
     profilesNode.innerHTML = `<article class="profile"><div class="empty-state">${error.message}</div></article>`;

package/tools/dashboard/dashboard_snapshot.py

@@ -143,6 +143,19 @@ 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_tail_text(path: Path, max_bytes: int = 65536) -> str:
+    if not path.is_file():
+        return ""
+    try:
+        with path.open("rb") as handle:
+            size = path.stat().st_size
+            if size > max_bytes:
+                handle.seek(size - max_bytes)
+            return handle.read().decode("utf-8", errors="replace")
+    except OSError:
+        return ""
+
+
 def classify_run_result(status: str, outcome: str, failure_reason: str) -> tuple[str, str]:
     normalized_status = (status or "").strip().upper()
     normalized_outcome = (outcome or "").strip()
@@ -167,6 +180,59 @@ def classify_run_result(status: str, outcome: str, failure_reason: str) -> tuple
     return ("unknown", normalized_status or "Unknown")
 
 
+GITHUB_RATE_LIMIT_PATTERNS = [
+    re.compile(
+        r"GitHub core API[^\n]*?rate limit[^\n]*(?:reset(?:s| into)?(?: at)?\s+(?P<reset>[^.\n]+))?",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"gh:\s*API rate limit exceeded[^\n]*(?:reset(?:s| into)?(?: at)?\s+(?P<reset>[^.\n]+))?",
+        re.IGNORECASE,
+    ),
+]
+
+
+def summarize_whitespace(text: str) -> str:
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def extract_github_rate_limit_alert(run_dir: Path, run: dict[str, Any]) -> dict[str, Any] | None:
+    candidate_files = [
+        run_dir / "issue-comment.md",
+        run_dir / "pr-comment.md",
+        run_dir / f"{run['session']}.log",
+    ]
+    for path in candidate_files:
+        text = read_tail_text(path)
+        if not text:
+            continue
+        for pattern in GITHUB_RATE_LIMIT_PATTERNS:
+            match = pattern.search(text)
+            if not match:
+                continue
+            summary = summarize_whitespace(match.group(0))
+            reset_match = re.search(r"reset(?:s| into)?(?: at)?\s+([^.\n]+)", summary, re.IGNORECASE)
+            reset_at = summarize_whitespace((reset_match.group(1) if reset_match else "") or match.groupdict().get("reset") or "")
+            if not summary:
+                summary = "GitHub core API rate limit is blocking host-side actions."
+            if reset_at and reset_at not in summary:
+                summary = f"{summary} Reset: {reset_at}."
+            return {
+                "id": f"github-core-rate-limit:{run['session']}:{reset_at or path.name}",
+                "kind": "github-core-rate-limit",
+                "severity": "warn",
+                "title": "GitHub core API rate limit blocks host actions",
+                "message": summary,
+                "session": run.get("session", ""),
+                "task_kind": run.get("task_kind", ""),
+                "task_id": run.get("task_id", ""),
+                "reset_at": reset_at,
+                "updated_at": run.get("updated_at", "") or file_mtime_iso(path),
+                "source_file": str(path),
+            }
+    return None
+
+
 def collect_runs(runs_root: Path) -> list[dict[str, Any]]:
     if not runs_root.is_dir():
         return []
@@ -221,10 +287,26 @@ def collect_runs(runs_root: Path) -> list[dict[str, Any]]:
             "provider_pool_name": run_env.get("ACTIVE_PROVIDER_POOL_NAME", ""),
             "run_dir": str(run_dir),
         }
+        alert = extract_github_rate_limit_alert(run_dir, item)
+        item["alerts"] = [alert] if alert else []
         runs.append(item)
     return runs
 
 
+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."""
+    if env.get("CONTROLLER_STATE", "") in {"stopped", ""}:
+        return False
+    if not pid_alive(env.get("CONTROLLER_PID", "")):
+        return True
+    try:
+        file_age = datetime.now(timezone.utc).timestamp() - controller_path.stat().st_mtime
+        return file_age > 600
+    except Exception:
+        return False
+
+
 def collect_resident_controllers(state_root: Path) -> list[dict[str, Any]]:
     controllers_root = state_root / "resident-workers" / "issues"
     if not controllers_root.is_dir():
@@ -240,6 +322,7 @@ def collect_resident_controllers(state_root: Path) -> list[dict[str, Any]]:
                 "session": env.get("SESSION", ""),
                 "controller_pid": controller_pid,
                 "controller_live": pid_alive(controller_pid),
+                "controller_stale": controller_is_stale(env, path),
                 "mode": env.get("CONTROLLER_MODE", ""),
                 "loop_count": safe_int(env.get("CONTROLLER_LOOP_COUNT")),
                 "state": env.get("CONTROLLER_STATE", ""),
@@ -346,6 +429,32 @@ def collect_scheduled_issues(state_root: Path) -> list[dict[str, Any]]:
     return items
 
 
+def collect_issue_retries(state_root: Path) -> list[dict[str, Any]]:
+    """Collect retry/backoff state for issues tracked by agent-project-retry-state."""
+    retries_root = state_root / "retries" / "issues"
+    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(
+            {
+                "issue_id": 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 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"
@@ -387,7 +496,9 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
     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)
     queue = collect_issue_queue(state_root)
+    alerts = [alert for run in runs for alert in run.get("alerts", [])]
 
     return {
         "id": profile_id,
@@ -422,17 +533,22 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
             ),
             "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)),
             "resident_workers": len(resident_workers),
             "queued_issues": len(queue["pending"]),
             "claimed_issues": len(queue["claims"]),
             "provider_cooldowns": sum(1 for item in cooldowns if item["active"]),
+            "active_retries": sum(1 for item in retries if not item.get("ready", True)),
             "scheduled_issues": len(scheduled),
+            "alerts": len(alerts),
         },
         "runs": runs,
+        "alerts": alerts,
         "resident_controllers": controllers,
         "resident_workers": resident_workers,
         "provider_cooldowns": cooldowns,
         "scheduled_issues": scheduled,
+        "issue_retries": retries,
         "issue_queue": queue,
     }
 
@@ -440,11 +556,14 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
 def build_snapshot() -> dict[str, Any]:
     registry_root = profile_registry_root()
     profiles = [build_profile_snapshot(profile_id, registry_root) for profile_id in list_profile_ids(registry_root)]
+    alerts = [alert for profile in profiles for alert in profile.get("alerts", [])]
     return {
         "generated_at": utc_now_iso(),
         "flow_skill_dir": str(ROOT_DIR),
         "profile_registry_root": str(registry_root),
         "profile_count": len(profiles),
+        "alert_count": len(alerts),
+        "alerts": alerts,
         "profiles": profiles,
     }