Auto-dispatch AI CI Advisor on Dr.CI new failures (dark) (#8178)

**⚠️ Stacked on #8195** (the dispatch-extraction refactor) — this PR is
based on `iz/advisor-refactor`, so the diff here is **only the new
functionality**. Review/land #8195 first; this will retarget to `main`
once it lands.

Part 1 of the "auto-run CI Advisor on Dr.CI new failures" workstream,
shipped **dark**: dispatch-only, feature-flagged, and prod-gated, so
merging is inert until `DRCI_ADVISOR_AUTODISPATCH_ENABLED=true` **and**
`VERCEL_ENV=production` **and** an `advisorConfig` entry are all
present.

## What this does
On every Dr.CI pass, after classification, auto-dispatch the AI advisor
on each **NEW failure** (the `FAILED` bucket, cancelled jobs excluded)
for enabled repos — reusing the shared dispatch lib from #8195 plus the
existing advisor workflow + verdict store + PR/HUD verdict UI (which
light up for free via the `dr_ci_${jobName}` signal-key convention).

## Reliable dedup (no dispatch storms)
Dedup keys off a durable **dispatch marker**, not the verdict row (a
verdict-write failure must not cause re-dispatch).
- **`misc.ai_advisor_dispatches`** (new CH table):
`SharedReplacingMergeTree`, `ORDER BY (owner, repo, head_sha,
signal_key)`; the replacing `version` is deliberately **not** in `ORDER
BY` so the pre/post rows collapse. No TTL — `head_sha` rotates on every
push.
- **Two-phase write**: a `dispatching` row is written **before** the
dispatch and gates it (write-path down ⇒ don't dispatch); `dispatched`
on success; a `failed` row supersedes for bounded retry (`retry_count` ≤
`MAX_DISPATCH_RETRIES`).
- **Fails closed**: dedup read throws ⇒ dispatch nothing.

## Outage guard (per-repo)
`AdvisorRepoConfig.maxNewFailures` (default 8): if a PR has more NEW
failures than the max, **bail entirely** — a flood is almost always an
outage, not a PR problem.

## Storm guard
`request: { retries: 0 }` on the dispatch — GitHub's `workflow_dispatch`
POST is non-idempotent and the default Octokit retry would create dup
runs on a 5xx (the 2026-05-08 autorevert storm).

## Per-repo config (manual + auto)
`lib/advisor/advisorConfig.ts` is the single source of truth: gates the
auto loop, the manual endpoint (404 for non-enabled repos), and the
manual button's visibility. Initial config: `pytorch/pytorch`.

## Minimal `drci.ts` change
The auto-dispatch is a single try/catch after the `failures` map is
built; the existing comment / early-return / check-run structure is
untouched.

## ⚠️ Manual steps before enabling
1. Create the `misc.ai_advisor_dispatches` table (`schema.sql`). HUD's
read/write users already hold DB-level access (no committed grants
needed; `hud_user` SELECT verified).
2. Set `DRCI_ADVISOR_AUTODISPATCH_ENABLED=true` in the prod Vercel env.

## Test plan
- `tsc --noEmit` clean; local lintrunner clean (incl. SQLFLUFF).
- Unit tests: env/config gating, dedup skip states, retry bound,
fail-closed read, pre-write-gate abort, dispatch-failure recording,
outage bail (>max) + dispatch-all (=max), cancelled-job exclusion. (jest
runs in CI on node 20.)

## Not in this PR
- Verdicts inline in the Dr.CI comment (part 3); auto-suppress at merge
(part 4); HUD PR-view classification reconcile (part 2).

Co-authored-by: Ivan <izaitsevfb@meta.com>

Author: izaitsevfb

torchci/clickhouse_db_schema/misc.ai_advisor_dispatches/schema.sql

@@ -0,0 +1,34 @@
+-- AI CI Advisor dispatch log.
+--
+-- Durable dedup + retry state for advisor workflow_dispatch runs, written
+-- synchronously by HUD (both the manual "AI Analyze" button and the automatic
+-- Dr.CI dispatch loop). Dedup is keyed on (owner, repo, head_sha, signal_key);
+-- head_sha rotates on every push, so a changed PR re-analyzes automatically and
+-- no TTL is needed.
+--
+-- Two writes per dispatch: 'dispatching' (pre-dispatch, also gates dispatch on
+-- write-path health -- if we cannot record the marker we must not dispatch)
+-- then 'dispatched' (post-dispatch). A 'failed' row supersedes the pre-dispatch
+-- row when the dispatch call throws, re-enabling retry up to retry_count = MAX.
+--
+-- ReplacingMergeTree(version) keeps the latest-version row per ORDER BY key. The
+-- version (a write timestamp) is deliberately NOT part of ORDER BY so the pre-
+-- and post-dispatch rows for a single dispatch collapse into one row (putting
+-- the timestamp in the sort key is the bug that stops misc.autorevert_events_v2
+-- rows from collapsing).
+CREATE TABLE misc.ai_advisor_dispatches
+(
+    `owner` LowCardinality(String),
+    `repo` LowCardinality(String),
+    `head_sha` FixedString(40),
+    `signal_key` String,
+    `state` Enum8('dispatching' = 1, 'dispatched' = 2, 'failed' = 3),
+    `retry_count` UInt8 DEFAULT 0,
+    `pr_number` Int64,
+    `job_name` String,
+    `version` DateTime64(3),
+    `_inserted_at` DateTime MATERIALIZED now()
+)
+ENGINE = SharedReplacingMergeTree('/clickhouse/tables/{uuid}/{shard}', '{replica}', version)
+ORDER BY (owner, repo, head_sha, signal_key)
+SETTINGS index_granularity = 8192

torchci/clickhouse_queries/advisor_dispatch_states/params.json

@@ -0,0 +1,9 @@
+{
+  "params": {
+    "owner": "String",
+    "repo": "String",
+    "headSha": "String",
+    "signalKeys": "Array(String)"
+  },
+  "tests": []
+}

torchci/clickhouse_queries/advisor_dispatch_states/query.sql

@@ -0,0 +1,14 @@
+-- Latest AI advisor dispatch state + retry_count per signal_key for one PR head
+-- commit. Used to dedup auto-dispatch. argMax over the replacing version returns
+-- the latest row; reading (state, retry_count) as one tuple keeps them paired
+-- even if two writes ever share a version timestamp.
+SELECT
+    signal_key,
+    argMax((state, retry_count), version) AS sr
+FROM misc.ai_advisor_dispatches
+WHERE
+    owner = {owner: String}
+    AND repo = {repo: String}
+    AND head_sha = {headSha: String}
+    AND signal_key IN {signalKeys: Array(String)}
+GROUP BY signal_key

torchci/components/job/FilteredJobList.tsx

@@ -1,3 +1,4 @@
+import { isAdvisorEnabled } from "lib/advisor/advisorConfig";
 import { fetcher } from "lib/GeneralUtils";
 import { IssueData, JobAnnotation, JobData } from "lib/types";
 import useScrollTo from "lib/useScrollTo";
@@ -27,15 +28,18 @@ function FailedJobInfo({
   return (
     <li key={job.id} id={job.id}>
       <JobSummary job={job} unstableIssues={unstableIssues} />
-      {prNum > 0 && job.name && job.sha && (
-        <AiAdvisorIndicator
-          jobName={job.name}
-          sha={job.sha}
-          prNumber={prNum}
-          conclusion={job.conclusion}
-          workflowName={job.workflowName}
-        />
-      )}
+      {prNum > 0 &&
+        job.name &&
+        job.sha &&
+        isAdvisorEnabled(repoOwner as string, repoName as string) && (
+          <AiAdvisorIndicator
+            jobName={job.name}
+            sha={job.sha}
+            prNumber={prNum}
+            conclusion={job.conclusion}
+            workflowName={job.workflowName}
+          />
+        )}
       <div>
         <JobLinks job={job} />
       </div>

torchci/lib/advisor/advisorConfig.ts

@@ -0,0 +1,56 @@
+// Per-repo configuration for the AI CI Advisor.
+//
+// Single source of truth shared by:
+//   - the manual "AI Analyze" dispatch endpoint (pull/dispatch-advisor.ts),
+//   - the automatic Dr.CI dispatch loop (lib/advisor/advisorDispatch.ts),
+//   - the frontend (FilteredJobList.tsx) to gate the manual button.
+//
+// It is pure data with no server-only imports, so it can be imported from both
+// API routes and React components.
+
+// If a PR has more than this many NEW failures, auto-dispatch bails for that PR
+// entirely (dispatches nothing) -- a flood of new failures is almost always an
+// outage rather than a PR problem, and we don't want to fan dozens of advisor
+// runs out per PR. Used as the fallback when a repo doesn't set its own.
+export const DEFAULT_MAX_NEW_FAILURES = 8;
+
+export interface AdvisorRepoConfig {
+  // The workflow_dispatch file (on the repo's default branch) that runs the
+  // advisor analysis for this repo.
+  workflowFile: string;
+  // Auto-dispatch bails entirely if a PR has more than this many NEW failures
+  // (outage guard). Falls back to DEFAULT_MAX_NEW_FAILURES when unset.
+  maxNewFailures?: number;
+}
+
+// Repos with the AI advisor enabled, keyed by "owner/repo".
+//
+// Adding a repo here enables BOTH the manual button and -- when the
+// DRCI_ADVISOR_AUTODISPATCH_ENABLED flag is on and VERCEL_ENV is production --
+// automatic dispatch on Dr.CI new failures. Enabling a repo is a deliberate,
+// reviewed action because every dispatch costs an LLM analysis.
+export const ADVISOR_REPOS: Record<string, AdvisorRepoConfig> = {
+  "pytorch/pytorch": {
+    workflowFile: "claude-autorevert-advisor.yml",
+    maxNewFailures: 8,
+  },
+};
+
+export function getAdvisorRepoConfig(
+  owner: string,
+  repo: string
+): AdvisorRepoConfig | undefined {
+  return ADVISOR_REPOS[`${owner}/${repo}`];
+}
+
+export function isAdvisorEnabled(owner: string, repo: string): boolean {
+  return getAdvisorRepoConfig(owner, repo) !== undefined;
+}
+
+// The NEW-failure count above which auto-dispatch bails for a PR, per repo.
+export function getMaxNewFailures(owner: string, repo: string): number {
+  return (
+    getAdvisorRepoConfig(owner, repo)?.maxNewFailures ??
+    DEFAULT_MAX_NEW_FAILURES
+  );
+}