Add AI advisor manual dispatch to HUD PR page (#7980)

## Summary

Adds the ability to trigger AI advisor analysis for individual failed
jobs on the HUD PR page (hud.pytorch.org).

### New features:
- **Verdict display**: Each failed job on a PR page shows existing AI
advisor verdicts as colored chips (red=revert, green=not_related,
yellow=unsure, grey=garbage)
- **Manual dispatch**: An "AI Analyze" button appears next to failed
jobs with no existing verdict, dispatching the
`claude-autorevert-advisor.yml` workflow
- **Signal pattern**: The dispatch builds a JSON payload with job status
across PR head, merge base, and recent trunk commits from ClickHouse

### Files:
- `clickhouse_queries/advisor_verdicts_for_pr/` — CH query for existing
verdicts
- `pages/api/.../pull/advisor-runs.ts` — API to fetch verdicts for a PR
- `pages/api/.../pull/dispatch-advisor.ts` — API to dispatch advisor
workflow
- `components/job/AiAdvisorIndicator.tsx` — Verdict chip + dispatch
button component
- `components/job/FilteredJobList.tsx` — Integration into failed job
list

## Test plan
- [x] Verify TypeScript compiles
- [x] Test on a PR page with known failed jobs
- [x] Verify dispatch creates workflow run
- [x] Verify verdict display after workflow completes


tested locally on the PRs with failures:
http://localhost:3000/pr/pytorch/pytorch/181449#72961893295

<details>
<summary>screenshot</summary>
<img width="1486" height="1365" alt="image"
src="https://github.com/user-attachments/assets/9b1217b7-117d-465b-b196-5c11f3dafceb"
/>
</details>

Author: izaitsevfb

torchci/clickhouse_queries/advisor_verdicts_for_pr/params.json

@@ -0,0 +1,7 @@
+{
+  "params": {
+    "repo": "String",
+    "prNumber": "Int64"
+  },
+  "tests": []
+}

torchci/clickhouse_queries/advisor_verdicts_for_pr/query.sql

@@ -0,0 +1,20 @@
+-- Fetch AI advisor verdicts for a given PR number
+SELECT
+    suspect_commit AS sha,
+    signal_key,
+    signal_source,
+    workflow_name,
+    verdict,
+    confidence,
+    summary,
+    causal_reasoning,
+    run_id,
+    pr_number,
+    timestamp
+FROM
+    misc.autorevert_advisor_verdicts
+WHERE
+    repo = {repo: String}
+    AND pr_number = {prNumber: Int64}
+ORDER BY
+    timestamp DESC

torchci/components/job/AiAdvisorIndicator.tsx

@@ -0,0 +1,279 @@
+import { Button, Chip, CircularProgress, Tooltip } from "@mui/material";
+import { fetcher } from "lib/GeneralUtils";
+import { AdvisorVerdict, AdvisorVerdictType } from "lib/advisorVerdictUtils";
+import { useSession } from "next-auth/react";
+import { useRouter } from "next/router";
+import { useCallback, useState } from "react";
+import useSWR from "swr";
+import AdvisorSection from "./AdvisorSection";
+
+const DISPATCH_STORAGE_KEY = "ai_advisor_dispatches";
+const DISPATCH_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+interface DispatchEntry {
+  timestamp: number;
+}
+
+function getDispatchKey(
+  prNumber: number,
+  sha: string,
+  signalKey: string
+): string {
+  return `${prNumber}:${sha}:${signalKey}`;
+}
+
+function getDispatches(): Record<string, DispatchEntry> {
+  try {
+    const raw = localStorage.getItem(DISPATCH_STORAGE_KEY);
+    if (!raw) return {};
+    const entries = JSON.parse(raw) as Record<string, DispatchEntry>;
+    const now = Date.now();
+    const valid: Record<string, DispatchEntry> = {};
+    for (const [k, v] of Object.entries(entries)) {
+      if (now - v.timestamp < DISPATCH_TTL_MS) {
+        valid[k] = v;
+      }
+    }
+    if (Object.keys(valid).length !== Object.keys(entries).length) {
+      localStorage.setItem(DISPATCH_STORAGE_KEY, JSON.stringify(valid));
+    }
+    return valid;
+  } catch {
+    return {};
+  }
+}
+
+function markDispatched(
+  prNumber: number,
+  sha: string,
+  signalKey: string
+): void {
+  const dispatches = getDispatches();
+  dispatches[getDispatchKey(prNumber, sha, signalKey)] = {
+    timestamp: Date.now(),
+  };
+  localStorage.setItem(DISPATCH_STORAGE_KEY, JSON.stringify(dispatches));
+}
+
+function isDispatched(
+  prNumber: number,
+  sha: string,
+  signalKey: string
+): boolean {
+  const dispatches = getDispatches();
+  const entry = dispatches[getDispatchKey(prNumber, sha, signalKey)];
+  if (!entry) return false;
+  return Date.now() - entry.timestamp < DISPATCH_TTL_MS;
+}
+
+const VERDICT_CHIP_COLORS: Record<
+  string,
+  "error" | "warning" | "success" | "default"
+> = {
+  revert: "error",
+  unsure: "warning",
+  not_related: "success",
+  garbage: "default",
+};
+
+const VERDICT_LABELS: Record<string, string> = {
+  revert: "Revert",
+  unsure: "Unsure",
+  not_related: "Not Related",
+  garbage: "Garbage Signal",
+};
+
+export default function AiAdvisorIndicator({
+  jobName,
+  sha,
+  prNumber,
+  conclusion,
+  mergeBaseSha,
+  workflowName,
+}: {
+  jobName: string;
+  sha: string;
+  prNumber: number;
+  conclusion?: string;
+  mergeBaseSha?: string;
+  workflowName?: string;
+}) {
+  const isFailed =
+    conclusion === "failure" ||
+    conclusion === "cancelled" ||
+    conclusion === "timed_out";
+  const router = useRouter();
+  const { repoOwner, repoName } = router.query;
+  const session = useSession();
+  const [dispatching, setDispatching] = useState(false);
+  const [error, setError] = useState("");
+
+  // dr_ci_ prefix separates HUD-dispatched verdicts from autorevert-system ones
+  const signalKey = `dr_ci_${jobName}`;
+
+  const { data: verdicts } = useSWR<AdvisorVerdict[]>(
+    prNumber
+      ? `/api/${repoOwner}/${repoName}/pull/advisor-runs?prNumber=${prNumber}`
+      : null,
+    fetcher,
+    { refreshInterval: 60_000 }
+  );
+
+  const matchingVerdict = verdicts?.find(
+    (v) => v.signalKey === signalKey && v.sha === sha
+  );
+
+  const dispatched = !matchingVerdict && isDispatched(prNumber, sha, signalKey);
+
+  const isAuthenticated =
+    session?.data &&
+    session.data["accessToken"] !== undefined &&
+    session.data["user"] !== undefined;
+
+  const [, setTick] = useState(0);
+
+  const handleDispatch = useCallback(async () => {
+    if (!isAuthenticated || dispatching || dispatched) return;
+
+    setDispatching(true);
+    setError("");
+
+    try {
+      const res = await fetch(
+        `/api/${repoOwner}/${repoName}/pull/dispatch-advisor`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: session.data!["accessToken"] as string,
+          },
+          body: JSON.stringify({
+            prNumber,
+            headSha: sha,
+            mergeBaseSha: mergeBaseSha || "",
+            jobName,
+            workflowName: workflowName || "",
+          }),
+        }
+      );
+
+      if (res.status === 409) {
+        // Already dispatched — treat as success so we show "Dispatched"
+        markDispatched(prNumber, sha, signalKey);
+        setTick((t) => t + 1);
+        return;
+      }
+
+      if (!res.ok) {
+        const data = await res.json();
+        throw new Error(data.error || `HTTP ${res.status}`);
+      }
+
+      markDispatched(prNumber, sha, signalKey);
+      setTick((t) => t + 1);
+    } catch (e: any) {
+      setError(e.message || "Failed to dispatch");
+    } finally {
+      setDispatching(false);
+    }
+  }, [
+    isAuthenticated,
+    dispatching,
+    dispatched,
+    repoOwner,
+    repoName,
+    prNumber,
+    sha,
+    mergeBaseSha,
+    jobName,
+    signalKey,
+    workflowName,
+    session.data,
+  ]);
+
+  const chipColor =
+    VERDICT_CHIP_COLORS[matchingVerdict?.verdict as AdvisorVerdictType] ||
+    "default";
+  const chipLabel =
+    VERDICT_LABELS[matchingVerdict?.verdict as AdvisorVerdictType] ||
+    matchingVerdict?.verdict;
+
+  return (
+    <span
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 4,
+      }}
+    >
+      {matchingVerdict && (
+        <Tooltip
+          title={
+            <AdvisorSection
+              verdict={matchingVerdict}
+              repoOwner={repoOwner as string}
+              repoName={repoName as string}
+            />
+          }
+          arrow
+          placement="bottom-start"
+          slotProps={{
+            tooltip: {
+              sx: { maxWidth: 500, fontSize: "inherit", p: 0.5 },
+            },
+          }}
+        >
+          <Chip
+            label={`AI: ${chipLabel}`}
+            color={chipColor}
+            size="small"
+            variant="outlined"
+            sx={{ ml: 1, cursor: "pointer" }}
+          />
+        </Tooltip>
+      )}
+      {!matchingVerdict && !dispatched && isFailed && isAuthenticated && (
+        <Tooltip title="Run AI advisor to analyze this failure">
+          <Button
+            size="small"
+            variant="outlined"
+            onClick={handleDispatch}
+            disabled={dispatching}
+            sx={{
+              ml: 1,
+              textTransform: "none",
+              fontSize: "0.75rem",
+              py: 0,
+              minHeight: 24,
+            }}
+          >
+            {dispatching ? (
+              <CircularProgress size={14} sx={{ mr: 0.5 }} />
+            ) : (
+              "🤖"
+            )}{" "}
+            AI Analyze
+          </Button>
+        </Tooltip>
+      )}
+      {dispatched && (
+        <Chip
+          label="AI: Dispatched"
+          size="small"
+          variant="outlined"
+          color="info"
+          sx={{ ml: 1 }}
+        />
+      )}
+      {error && (
+        <Chip
+          label={`Error: ${error}`}
+          size="small"
+          variant="outlined"
+          color="error"
+          sx={{ ml: 1 }}
+        />
+      )}
+    </span>
+  );
+}

torchci/components/job/FilteredJobList.tsx

@@ -4,6 +4,7 @@ import useScrollTo from "lib/useScrollTo";
 import { useRouter } from "next/router";
 import useSWR from "swr";
 import LogViewer from "../common/log/LogViewer";
+import AiAdvisorIndicator from "./AiAdvisorIndicator";
 import JobAnnotationToggle from "./JobAnnotationToggle";
 import JobLinks from "./JobLinks";
 import JobSummary from "./JobSummary";
@@ -21,10 +22,20 @@ function FailedJobInfo({
 }) {
   const router = useRouter();
   useScrollTo();
-  const { repoOwner, repoName } = router.query;
+  const { repoOwner, repoName, prNumber } = router.query;
+  const prNum = prNumber ? parseInt(prNumber as string, 10) : 0;
   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}
+        />
+      )}
       <div>
         <JobLinks job={job} />
       </div>

torchci/pages/api/[repoOwner]/[repoName]/pull/advisor-runs.ts

@@ -0,0 +1,33 @@
+import {
+  AdvisorVerdictRow,
+  deduplicateVerdicts,
+} from "lib/advisorVerdictUtils";
+import { queryClickhouseSaved } from "lib/clickhouse";
+import type { NextApiRequest, NextApiResponse } from "next";
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  const { repoOwner, repoName, prNumber } = req.query;
+
+  if (!repoOwner || !repoName || !prNumber) {
+    res.status(400).json({ error: "Missing required parameters" });
+    return;
+  }
+
+  try {
+    const rows = (await queryClickhouseSaved("advisor_verdicts_for_pr", {
+      repo: `${repoOwner}/${repoName}`,
+      prNumber: parseInt(prNumber as string, 10),
+    })) as AdvisorVerdictRow[];
+
+    res.status(200).json(deduplicateVerdicts(rows));
+  } catch (error: any) {
+    res.status(500).json({
+      error: "Internal server error",
+      details:
+        process.env.NODE_ENV === "development" ? error.message : undefined,
+    });
+  }
+}