agent-control-plane 0.1.12 → 0.1.14

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")"
@@ -727,38 +759,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/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,13 +66,15 @@ 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
@@ -200,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
 }
 

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/templates/issue-prompt-template.md

@@ -22,7 +22,10 @@ Follow this order:
    bash "$ACP_FLOW_TOOLS_DIR/create-follow-up-issue.sh" --parent {ISSUE_ID} --title "..." --body-file /tmp/follow-up.md
    ```
 3. Implement the smallest root-cause fix in this worktree only.
-4. Run verification and record every successful command with `record-verification.sh`.
+4. Run the narrowest relevant local verification for the files you changed, and record every successful command with `record-verification.sh`.
+
+- Do not default to repo-wide verification such as `pnpm test` unless the issue body explicitly requires it.
+- If unrelated repo-wide suites are already red, keep the cycle focused on targeted verification for your slice and let the host verification guard decide whether publication is safe.
 
 ```bash
 {ISSUE_VERIFICATION_COMMAND_SNIPPET}

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())