feat: propagate advisor verdict through revert flow and render in HUD

1. AutorevertPattern carries optional advisor_verdict field.
   When a revert is advisor-accelerated, the revert comment includes
   "Note: This revert was accelerated by the AI advisor" with verdict
   and confidence.

2. State JSON includes advisor data in two places (both forward/backward
   compatible — absent in older states, gracefully ignored):
   - outcomes: advisor_verdict on AutorevertPattern data
   - columns: advisor_results map per (commit_sha → verdict/confidence)

3. HUD renderer shows:
   - "AI:revert" / "AI:not_related" / etc badges in table cells
   - "[AI: revert @95%]" in outcome notes for advisor-accelerated reverts

Author: izaitsevfb

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/hud_renderer.py

@@ -2,7 +2,7 @@
 
 import re
 from datetime import datetime
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Union
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
 
 from .signal import SignalStatus
 from .utils import build_pytorch_hud_url
@@ -53,6 +53,13 @@
     td.cell.hl-baseline { background: #e6f7ff; }
     td.cell.hl-newer-fail { background: #fdecea; }
     td.cell.hl-restart { outline: 2px dashed #888; outline-offset: -2px; }
+    .advisor-cell { font-size: 10px; display: block; margin-top: 2px; }
+    .advisor-cell.adv-revert { color: #a40000; }
+    .advisor-cell.adv-not_related { color: #1a73e8; }
+    .advisor-cell.adv-garbage { color: #7a5a00; }
+    .advisor-cell.adv-unsure { color: #555; }
+    .advisor-dispatch { font-size: 10px; display: block; margin-top: 2px;
+        color: #1a73e8; font-style: italic; }
 """
 
 HUD_JS = (
@@ -285,10 +292,15 @@ def _note_from_outcome(outcome: Optional[Mapping[str, Any]]) -> str:
         newer = data.get("newer_failing_commits", []) or []
         suspected = data.get("suspected_commit") or "?"
         baseline = data.get("older_successful_commit") or "?"
-        return (
+        note = (
             f"Pattern: newer fail {len(newer)}; suspect {suspected[:7]}"
             f" vs baseline {baseline[:7]}"
         )
+        # Forward-compatible: advisor_verdict may not exist in older states
+        adv = data.get("advisor_verdict")
+        if adv:
+            note += f" [AI: {adv.get('verdict', '?')} @{adv.get('confidence', 0):.0%}]"
+        return note
     if outcome_type == "RestartCommits":
         commits = data.get("commit_shas", []) or []
         if commits:
@@ -316,12 +328,18 @@ def render_html_from_state(
     advisor_dispatches: Sequence[Mapping[str, Any]] = (
         state.get("advisor_dispatches", []) or []
     )
-    # Build lookup: signal_key -> advisor dispatch info
+    # Build lookups for advisor dispatches
+    # signal_key -> dispatch info (for outcome badges)
     advisor_by_signal: Dict[str, Mapping[str, Any]] = {}
+    # (signal_key, commit_sha) -> dispatch info (for in-cell rendering)
+    advisor_by_cell: Dict[Tuple[str, str], Mapping[str, Any]] = {}
     for ad in advisor_dispatches:
         sk = ad.get("signal_key", "")
+        sha = ad.get("commit_sha", "")
         if sk:
             advisor_by_signal[sk] = ad
+        if sk and sha:
+            advisor_by_cell[(sk, sha)] = ad
 
     raw_outcomes = (
         state.get("outcomes") if isinstance(state.get("outcomes"), dict) else None
@@ -446,12 +464,37 @@ def render_html_from_state(
         for col in columns:
             cells_map = col.get("cells", {}) or {}
             events = cells_map.get(sha, []) or []
+            # Forward-compatible: advisor_results may not exist in older states
+            advisor_results = col.get("advisor_results", {}) or {}
             workflow = str(col.get("workflow", ""))
             key = str(col.get("key", ""))
             sig_key = f"{workflow}:{key}" if key else workflow
             highlights_map = highlight_lookup.get(sig_key, {})
             cell_classes = " ".join(sorted(highlights_map.get(sha, [])))
-            if not events:
+
+            # Render advisor verdict badge for this cell (if available)
+            advisor_badge = ""
+            adv = advisor_results.get(sha)
+            if adv:
+                adv_verdict = adv.get("verdict", "")
+                adv_conf = adv.get("confidence", 0)
+                adv_class = f"adv-{adv_verdict}" if adv_verdict else ""
+                advisor_badge = (
+                    f'<span class="advisor-cell {adv_class}" '
+                    f'title="AI advisor: {adv_verdict} ({adv_conf:.0%})">'
+                    f"AI:{adv_verdict}</span>"
+                )
+
+            # Render advisor dispatch indicator (from advisor_dispatches)
+            dispatch = advisor_by_cell.get((sig_key, sha))
+            if dispatch and not advisor_badge:
+                # Show dispatch indicator only if no verdict badge already shown
+                advisor_badge = (
+                    '<span class="advisor-dispatch" '
+                    'title="AI advisor dispatched">AI:pending</span>'
+                )
+
+            if not events and not advisor_badge:
                 html_parts.append(f'<td class="cell {cell_classes}"></td>')
                 continue
 
@@ -484,7 +527,8 @@ def render_html_from_state(
                         f'<span class="ev" title="{title_attr}">{icon}</span>'
                     )
             html_parts.append(
-                f'<td class="cell {cell_classes}">{"".join(cell_parts)}</td>'
+                f'<td class="cell {cell_classes}">'
+                f'{"".join(cell_parts)}{advisor_badge}</td>'
             )
         html_parts.append("</tr>")
     html_parts.append("</tbody>")

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/run_state_logger.py

@@ -78,6 +78,11 @@ def _build_state_json(
                     data["wf_run_id"] = outcome.wf_run_id
                 if outcome.job_id is not None:
                     data["job_id"] = outcome.job_id
+                if outcome.advisor_verdict is not None:
+                    data["advisor_verdict"] = {
+                        "verdict": outcome.advisor_verdict.verdict.value,
+                        "confidence": outcome.advisor_verdict.confidence,
+                    }
                 serialized = {
                     "type": "AutorevertPattern",
                     "data": data,
@@ -105,8 +110,9 @@ def _build_state_json(
                     },
                 }
 
-            # Per-commit events for this signal
+            # Per-commit events and advisor results for this signal
             cells: Dict[str, List[Dict]] = {}
+            advisor_results_map: Dict[str, Dict] = {}
             for c in sig.commits:
                 evs = []
                 for e in c.events:
@@ -124,6 +130,13 @@ def _build_state_json(
                     evs.append(ev)
                 if evs:
                     cells[c.head_sha] = evs
+                # Capture advisor result if present (forward-compatible: absent in old states)
+                if c.advisor_result is not None:
+                    advisor_results_map[c.head_sha] = {
+                        "verdict": c.advisor_result.verdict.value,
+                        "confidence": c.advisor_result.confidence,
+                        "signal_key": c.advisor_result.signal_key,
+                    }
 
             col = {
                 "workflow": sig.workflow_name,
@@ -135,6 +148,9 @@ def _build_state_json(
                 col["job_base_name"] = sig.job_base_name
             if ineligible is not None:
                 col["ineligible"] = ineligible
+            # Optional: per-commit advisor results (forward-compatible)
+            if advisor_results_map:
+                col["advisor_results"] = advisor_results_map
             cols.append(col)
 
             sig_key = f"{sig.workflow_name}:{sig.key}"

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/signal.py

@@ -50,9 +50,9 @@ class AutorevertPattern:
     - suspected_commit: the oldest commit that first started to fail.
     - older_successful_commit: the most recent successful commit before
       failures started (direct parent of the suspected commit for this signal).
-    - job_base_name: optional job base name for the signal
     - wf_run_id: optional workflow run ID from a failing event on suspected commit
     - job_id: optional job ID from a failing event on suspected commit
+    - advisor_verdict: optional AI advisor verdict that accelerated this decision
     """
 
     workflow_name: str
@@ -61,6 +61,7 @@ class AutorevertPattern:
     older_successful_commit: str
     wf_run_id: Optional[int] = None
     job_id: Optional[int] = None
+    advisor_verdict: Optional["AIAdvisorResult"] = None
 
 
 @dataclass
@@ -448,7 +449,9 @@ def partition_by_autorevert_pattern(self) -> Optional[PartitionedCommits]:
     ADVISOR_CONFIDENCE_THRESHOLD = 0.9
 
     def _build_autorevert_pattern(
-        self, partition: "PartitionedCommits"
+        self,
+        partition: "PartitionedCommits",
+        advisor_result: Optional[AIAdvisorResult] = None,
     ) -> AutorevertPattern:
         """Build an AutorevertPattern from a validated partition."""
         suspected = partition.failed[-1]
@@ -464,6 +467,7 @@ def _build_autorevert_pattern(
             older_successful_commit=partition.successful[0].head_sha,
             wf_run_id=failure_event.wf_run_id if failure_event else None,
             job_id=failure_event.job_id if failure_event else None,
+            advisor_verdict=advisor_result,
         )
 
     def _check_advisor_verdict(
@@ -490,7 +494,7 @@ def _check_advisor_verdict(
             return None
 
         if result.verdict == AdvisorVerdict.REVERT:
-            return self._build_autorevert_pattern(partition)
+            return self._build_autorevert_pattern(partition, advisor_result=result)
 
         if result.verdict == AdvisorVerdict.NOT_RELATED:
             return Ineligible(

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/signal_actions.py

@@ -50,6 +50,7 @@ class SignalMetadata:
     test_module: Optional[str] = None
     wf_run_id: Optional[int] = None
     job_id: Optional[int] = None
+    advisor_summary: Optional[str] = None  # short AI advisor verdict summary
 
 
 def _derive_job_filter(job_base_name: Optional[str]) -> Optional[str]:
@@ -293,9 +294,16 @@ def group_actions(
             # Extract fields for job/HUD links from AutorevertPattern
             wf_run_id = None
             job_id = None
+            advisor_summary = None
             if isinstance(outcome, AutorevertPattern):
                 wf_run_id = outcome.wf_run_id
                 job_id = outcome.job_id
+                if outcome.advisor_verdict is not None:
+                    av = outcome.advisor_verdict
+                    advisor_summary = (
+                        f"AI advisor: {av.verdict.value} "
+                        f"(confidence={av.confidence:.2f})"
+                    )
 
             meta = SignalMetadata(
                 workflow_name=sig.workflow_name,
@@ -304,6 +312,7 @@ def group_actions(
                 test_module=sig.test_module,
                 wf_run_id=wf_run_id,
                 job_id=job_id,
+                advisor_summary=advisor_summary,
             )
             if isinstance(outcome, AutorevertPattern):
                 sha = outcome.suspected_commit
@@ -1064,6 +1073,15 @@ def _comment_issue_pr_revert(
             all_signals = ", ".join(all_signals_urls)
             breaking_notification_msg += f"- {workflow_name}: {all_signals}\n"
 
+        # Add AI advisor info if any signal was advisor-accelerated
+        advisor_summaries = [s.advisor_summary for s in sources if s.advisor_summary]
+        if advisor_summaries:
+            breaking_notification_msg += (
+                "\n**Note:** This revert was accelerated by the AI advisor: "
+                + "; ".join(advisor_summaries)
+                + "\n"
+            )
+
         try:
             if should_do_revert_on_pr:
                 for attempt in RetryWithBackoff():