agent-control-plane 0.1.9 → 0.1.13

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 || '{}');
@@ -401,6 +459,9 @@ const inferCommentReason = (bodyText) => {
   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';
   }
@@ -468,6 +529,8 @@ if (effectiveLastReason === 'scope-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);
@@ -579,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}"
@@ -590,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
@@ -599,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
@@ -657,38 +727,48 @@ for (const line of body.split(/\r?\n/).slice(0, 40)) {
   }
 }
 
-if (commands.length === 0 && repoRoot) {
-  const packageJsonPath = path.join(repoRoot, 'package.json');
-  if (fs.existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-      if (packageJson?.scripts?.test) {
-        if (fs.existsSync(path.join(repoRoot, 'pnpm-lock.yaml'))) {
-          addCommand('pnpm test');
-        } else if (fs.existsSync(path.join(repoRoot, 'yarn.lock'))) {
-          addCommand('yarn test');
-        } else {
-          addCommand('npm test');
+  if (commands.length === 0 && repoRoot) {
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson?.scripts?.smoke) {
+          addCommand('# If this cycle changes smoke runners, CLI entrypoints, or operator commands, also run the matching smoke command from the repo instructions.');
         }
+      } catch (_error) {
+        // Ignore parse errors and fall through to generic guidance.
       }
-    } catch (_error) {
-      // Ignore parse errors and fall through to generic guidance.
     }
   }
-}
 
-if (commands.length === 0) {
-  addCommand('pnpm test');
-}
+  if (commands.length === 0) {
+    addCommand('# Pick the narrowest relevant local verification for the files you touch.');
+    addCommand('# Do not default to repo-wide pnpm test unless the issue body explicitly requires it.');
+    addCommand('# Examples:');
+    addCommand('# pnpm --filter @<repo>/api test -- --runInBand <target-spec>');
+    addCommand('# pnpm --filter @<repo>/api typecheck');
+    addCommand('# pnpm --filter @<repo>/web test -- --run <target-spec>');
+    addCommand('# pnpm --filter @<repo>/web typecheck');
+    addCommand('# pnpm --filter @<repo>/mobile test -- --runInBand <target-spec>');
+    addCommand('# pnpm --filter @<repo>/mobile typecheck');
+    addCommand('# pnpm --filter @<repo>/<package> test -- --run <target-spec>');
+    addCommand('# pnpm --filter @<repo>/<package> typecheck');
+    addCommand('# After each successful command, record it with record-verification.sh exactly as shown below.');
+  }
 
 const escapeDoubleQuotes = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 const snippet = commands
-  .map((command) =>
-    command + '\n' +
-    'bash "$ACP_FLOW_TOOLS_DIR/record-verification.sh" --run-dir "$ACP_RUN_DIR" --status pass --command "' +
-    escapeDoubleQuotes(command) +
-    '"',
-  )
+  .map((command) => {
+    if (command.startsWith('#')) {
+      return command;
+    }
+    return (
+      command + '\n' +
+      'bash "$ACP_FLOW_TOOLS_DIR/record-verification.sh" --run-dir "$ACP_RUN_DIR" --status pass --command "' +
+      escapeDoubleQuotes(command) +
+      '"'
+    );
+  })
   .join('\n\n');
 
 process.stdout.write(snippet);

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

@@ -32,12 +32,21 @@ if [[ ! -d "${FLOW_SKILL_SOURCE}" && -n "${COMPAT_FLOW_SKILL_ALIAS}" ]]; then
 fi
 
 FLOW_SKILL_SOURCE="$(cd "${FLOW_SKILL_SOURCE}" && pwd -P)"
+SOURCE_HOME="$(cd "${SOURCE_HOME}" && pwd -P)"
+
+remove_tree_force() {
+  local target="${1:-}"
+  [[ -n "${target}" ]] || return 0
+  [[ -e "${target}" || -L "${target}" ]] || return 0
+  chmod -R u+w "${target}" 2>/dev/null || true
+  rm -rf "${target}" 2>/dev/null || true
+}
 
 sync_tree_copy_mode() {
   local source_dir="${1:?source dir required}"
   local target_dir="${2:?target dir required}"
   [[ -d "${source_dir}" ]] || return 0
-  rm -rf "${target_dir}"
+  remove_tree_force "${target_dir}"
   mkdir -p "${target_dir}"
   (
     cd "${source_dir}"
@@ -57,18 +66,45 @@ sync_tree_into_target() {
 }
 
 sync_skill_copies() {
-  sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${SOURCE_FLOW_CANONICAL_ALIAS}"
-  sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${FLOW_SKILL_TARGET}"
-
-  if [[ -n "${SOURCE_FLOW_COMPAT_ALIAS}" ]]; then
-    sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${SOURCE_FLOW_COMPAT_ALIAS}"
+  if ! flow_is_skill_root "${SOURCE_HOME}"; then
+    sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${SOURCE_FLOW_CANONICAL_ALIAS}"
+    if [[ -n "${SOURCE_FLOW_COMPAT_ALIAS}" ]]; then
+      sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${SOURCE_FLOW_COMPAT_ALIAS}"
+    fi
   fi
 
+  sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${FLOW_SKILL_TARGET}"
+
   if [[ -n "${TARGET_FLOW_COMPAT_ALIAS}" ]]; then
     sync_tree_into_target "${FLOW_SKILL_SOURCE}" "${TARGET_FLOW_COMPAT_ALIAS}"
   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=""
 
@@ -175,18 +211,21 @@ sync_tree_rsync() {
 }
 
 reset_runtime_skill_targets() {
-  rm -rf "${FLOW_SKILL_TARGET}"
+  remove_tree_force "${FLOW_SKILL_TARGET}"
   if [[ -n "${TARGET_FLOW_COMPAT_ALIAS}" ]]; then
-    rm -rf "${TARGET_FLOW_COMPAT_ALIAS}"
+    remove_tree_force "${TARGET_FLOW_COMPAT_ALIAS}"
   fi
 }
 
 reset_source_skill_targets() {
+  if flow_is_skill_root "${SOURCE_HOME}"; then
+    return 0
+  fi
   if [[ "${FLOW_SKILL_SOURCE}" != "${SOURCE_FLOW_CANONICAL_ALIAS}" ]]; then
-    rm -rf "${SOURCE_FLOW_CANONICAL_ALIAS}"
+    remove_tree_force "${SOURCE_FLOW_CANONICAL_ALIAS}"
   fi
   if [[ -n "${SOURCE_FLOW_COMPAT_ALIAS}" && "${FLOW_SKILL_SOURCE}" != "${SOURCE_FLOW_COMPAT_ALIAS}" ]]; then
-    rm -rf "${SOURCE_FLOW_COMPAT_ALIAS}"
+    remove_tree_force "${SOURCE_FLOW_COMPAT_ALIAS}"
   fi
 }
 
@@ -210,5 +249,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";
@@ -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>` : "",
@@ -125,6 +159,7 @@ function renderProfile(profile) {
     ["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],
@@ -240,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>
@@ -275,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 {
@@ -286,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,6 +287,8 @@ 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
 
@@ -430,6 +498,7 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
     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,
@@ -471,8 +540,10 @@ def build_profile_snapshot(profile_id: str, registry_root: Path) -> dict[str, An
             "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,
@@ -485,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,
     }
 

package/tools/dashboard/styles.css

@@ -230,6 +230,49 @@ button:hover {
   font-size: 14px;
 }
 
+.alert-list {
+  display: grid;
+  gap: 12px;
+}
+
+.alert-card {
+  padding: 14px 16px;
+  border-radius: 18px;
+  border: 1px solid var(--line);
+  background: var(--panel-strong);
+}
+
+.alert-card.warn {
+  border-color: #e7c76d;
+  background: #fff6dd;
+}
+
+.alert-card h4 {
+  margin: 0;
+  font-size: 17px;
+}
+
+.alert-card p {
+  margin: 10px 0 0;
+  line-height: 1.5;
+}
+
+.alert-header {
+  display: flex;
+  gap: 12px;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.alert-meta {
+  margin-top: 10px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+  color: var(--muted);
+  font-size: 13px;
+}
+
 .table-wrap {
   overflow-x: auto;
 }