autorevert: dispatch advisor on born-red test signals (#8107)

## Summary

Closes a structural blind spot in the autorevert lambda: a test
introduced by the same commit that breaks it (or by a recent commit that
re-enabled / moved / unsharded it) has no green observations in the
lookback window, so the existing green→red partition path returns
`Ineligible(NO_SUCCESSES)` and never asks the advisor.

This PR adds a "born-red" detection path that hands these cases to the
AI advisor with framing tailored for the introduction question.

## Motivation


[pytorch/pytorch#184104](pytorch/pytorch#184104)
(2026-05-21, "[Inductor] Fix flip on 0-d tensors in prims.rev lowering")
added two new tests to inductor codegen-dynamic-shapes and registered
them as `expectedFailure` on cuda/xpu. The lowering fix actually worked
on cuda → "Unexpected success" → FAILED. The lambda saw the failures on
every trunk run from the PR landing onward but emitted
`Ineligible(NO_SUCCESSES, "no successful commits present in window")`
for ~9h until a human revert. Verified from
`misc.autorevert_state.outcomes` JSON:

```
trunk:inductor/test_torchinductor_codegen_dynamic_shapes.py::test_flip_zero_dim_dynamic_shapes_cuda
  → Ineligible / reason="no_successes" / "no successful commits present in window"
```

The lambda was healthy on the same tick — it emitted an
`AutorevertPattern` (advisor verdict=revert, confidence=0.97) for an
unrelated `linux-jammy-cuda13.0-py3.10-gcc11` job-track signal. The
blind spot is per-signal, not lambda-wide.

## Approach

Three primitives, all reusing the existing data model:

1. **`Signal.partition_born_red()`** — returns a `PartitionedCommits`
only when the signal shape (newest→oldest) is exactly
`[FAIL...][EMPTY...]`. No interleaving, no pending-only commits in
between. The trailing empty-events commits act as the implicit baseline
("commits where this test signal was not observed").

2. **`Signal._handle_no_successes()`** — called from the existing
early-exit point in `process_valid_autorevert_pattern`. For test-track
signals where `partition_born_red()` succeeds and there are ≥2 distinct
failing commits (counted by commits, not events — retries / multiple
shards on a single commit are still one trunk observation), it either
lifts an existing advisor verdict into an `AutorevertPattern`
(revert/related) or dispatches a fresh advisor request alongside the
`Ineligible(NO_SUCCESSES)` outcome. Job-track no-success signals stay on
the original path (likely persistent infra or warm-up).

3. **`DispatchAdvisor.is_born_red` flag** — tells
`_build_signal_pattern_json` to relabel the SUCCESSFUL partition. The
new label asks the advisor to distinguish four causes from the suspect's
diff: (a) ADDED the test, (b) ENABLED / un-skipped / removed a TD
filter, (c) MOVED / RENAMED so the test identity is newly visible, (d)
sharding / job-selection change. Recommend revert only when the suspect
explicitly introduces or enables the failing test (cases a/b/c).

Reused infrastructure:
- `_check_advisor_verdict()` and `_build_autorevert_pattern()` from the
existing partition path — the born-red partition slots in cleanly.
- Advisor de-dup (`prior_advisor_exists`) and per-(workflow, commit) cap
of 8 in `SignalActionsLogger` — no new infra.

## What changes for the advisor prompt

When `is_born_red=True`, the SUCCESSFUL partition in
`signal_pattern.json` is labeled:

> **no_signal**: baseline commits where this test signal was NOT
OBSERVED (no extracted events). The suspect commit is the first commit
on which the test signal appears, and it fails. Possible causes —
distinguish from the suspect commit's diff: (a) the suspect ADDED this
test; (b) the suspect ENABLED/UN-SKIPPED an existing test or removed a
TD/skipping filter that previously masked it; (c) the suspect MOVED or
RENAMED the test so its identity is newly visible; (d) the suspect
changed sharding / job selection so an existing already-failing test
became visible. Recommend revert only if the suspect's diff explicitly
introduces or enables the failing test (cases a/b/c).

A top-level `is_born_red: true` flag is also surfaced in the JSON so the
advisor workflow can branch on it cleanly.

## Test plan

- [x] `pytorch_auto_revert/tests/test_signal.py::TestBornRedTestSignal`
— 11 new tests covering:
  - canonical `[FAIL][EMPTY]` shape
- rejection of shapes that aren't born-red (has successes, no empty
tail, no failures, interleaved empty→fail, pending-only between, single
commit)
  - end-to-end dispatch on the 2-failing-commits + 1-empty case
- threshold counts distinct commits, not raw events (single commit with
3 retries doesn't dispatch)
  - job-track signals don't get the born-red path
- chronic `[FAIL...]` without empty tail stays on the original
`NO_SUCCESSES` path
- existing advisor verdict (revert) lifts the born-red partition into
`AutorevertPattern` with the right `suspected_commit` and
`older_successful_commit`
  - `NOT_RELATED` verdict blocks (returns `ADVISOR_NOT_RELATED`)
- [x]
`pytorch_auto_revert/tests/test_signal_actions.py::test_born_red_relabels_baseline_partition`
— verifies the JSON relabel and the `is_born_red` top-level flag,
including all four ambiguity-cause cues.
- [x] Full local suite: `./venv/bin/python -m unittest discover -s
pytorch_auto_revert/tests -p "test_*.py"` — 175 tests, all pass.

## Notes

- Cross-model adversarial review (`gpt-5.5` via Codex CLI) flagged three
MEDIUM concerns; all three were addressed in this PR before submission:
the introduction-vs-enable framing in the JSON label, gating on distinct
failing commits (not raw events), and the verdict-key check (already
keyed by `signal_key + suspect_commit`, no fix needed).
- The advisor prompt template
(`.github/workflows/claude-autorevert-advisor.yml`) is not touched here
— the existing prompt already consumes the partition labels, so the
relabel propagates through without a workflow change. If the upstream
prompt benefits from explicitly branching on `is_born_red`, that can be
a follow-up.

Author: izaitsevfb

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

@@ -86,6 +86,11 @@ class DispatchAdvisor:
     suspect_commit: str
     failed_commits: Tuple[str, ...]  # SHAs in failed partition (newest first)
     successful_commits: Tuple[str, ...]  # SHAs in successful partition (newest first)
+    # When True, `successful_commits` are baseline commits where this signal
+    # did NOT exist (test-track born-red case), not green observations.
+    # The advisor JSON layer relabels them so the model is asked "did the
+    # suspect commit introduce this failing test?".
+    is_born_red: bool = False
 
 
 @dataclass
@@ -496,9 +501,61 @@ def partition_by_autorevert_pattern(self) -> Optional[PartitionedCommits]:
 
         return PartitionedCommits(failed=failed, unknown=unknown, successful=successful)
 
+    def partition_born_red(self) -> Optional[PartitionedCommits]:
+        """Partition for the test-track "born-red" pattern: failing head + empty-events tail.
+
+        Returns a partition only when the signal shape is `[FAIL...][EMPTY...]`
+        (newest → oldest) with no interleaving:
+        - At least 2 commits in window
+        - No commits with success events (otherwise the main partition path applies)
+        - At least 1 commit with failure events at the head
+        - At least 1 trailing commit with no events — these are commits where this
+          test did not run or did not yet exist, used as the implicit baseline
+          ("commits without the signal")
+        - No pending-only or other-shape commits in between
+
+        Trailing empty-events commits are placed in `successful` so the advisor
+        check / pattern construction can reuse the standard primitives. The
+        advisor JSON layer relabels them via `DispatchAdvisor.is_born_red` so
+        the model is asked about test introduction, not green→red transition.
+        `unknown` is always empty — there is no gap to bisect.
+        """
+        if len(self.commits) < 2 or self.has_successes():
+            return None
+
+        failed: List[SignalCommit] = []
+        baseline: List[SignalCommit] = []
+        for c in self.commits:
+            if c.has_failure:
+                if baseline:
+                    # Failure after an empty-events commit (newer→older order) —
+                    # out of shape.
+                    return None
+                failed.append(c)
+            elif not c.events:
+                baseline.append(c)
+            else:
+                # Pending-only or other shape — bail; the advisor needs a clean
+                # introduction-vs-baseline split.
+                return None
+
+        if not failed or not baseline:
+            return None
+
+        return PartitionedCommits(failed=failed, unknown=[], successful=baseline)
+
     # Minimum confidence threshold for acting on advisor verdicts
     ADVISOR_CONFIDENCE_THRESHOLD = 0.89
 
+    # Minimum number of *distinct failing commits* required before dispatching
+    # an advisor on a born-red test signal. Counting distinct commits (rather
+    # than events) is deliberate: multiple FAILURE events on the same commit
+    # (retries, multiple shards / variants of the same test, etc.) describe
+    # one trunk observation, not two. Requiring two failing commits means the
+    # failure has persisted across at least one trunk advance — strong enough
+    # to justify the advisor cost without waiting indefinitely.
+    REQUIRE_FAILED_COMMITS_BORN_RED = 2
+
     def _build_autorevert_pattern(
         self,
         partition: "PartitionedCommits",
@@ -571,6 +628,64 @@ def _check_advisor_verdict(
         # "unsure" or expired garbage → continue normally
         return None
 
+    def _handle_no_successes(self) -> Union[AutorevertPattern, Ineligible]:
+        """Handle the `not has_successes()` branch.
+
+        Default behavior: emit `Ineligible(NO_SUCCESSES)` with no advisor — the
+        standard green→red partition has no anchor to work from.
+
+        Test-track exception (born-red detection): when the signal shape matches
+        `[FAIL...][EMPTY...]` (`partition_born_red` returns a partition), the
+        suspect commit is likely the one that introduced the test. Defer to the
+        AI advisor:
+        - If a prior advisor verdict exists on the suspect, act on it
+          (revert/related → `AutorevertPattern`; not_related/garbage → blocked).
+        - Otherwise, dispatch a fresh advisor request alongside the `Ineligible`
+          response. Next tick can act on the verdict.
+
+        Advisor dedup + the per-(workflow, commit) cap of 8 are handled by
+        `SignalActionsLogger`; this method just emits the request.
+        """
+        born_red = (
+            self.partition_born_red() if self.source == SignalSource.TEST else None
+        )
+        if born_red is None:
+            return Ineligible(
+                IneligibleReason.NO_SUCCESSES,
+                "no successful commits present in window",
+            )
+
+        if len(born_red.failed) < self.REQUIRE_FAILED_COMMITS_BORN_RED:
+            # Not enough distinct failing commits to justify advisor cost —
+            # wait for the next trunk advance. Retries / multiple shards on a
+            # single commit do not count as independent observations.
+            return Ineligible(
+                IneligibleReason.NO_SUCCESSES,
+                f"born-red test signal: need ≥{self.REQUIRE_FAILED_COMMITS_BORN_RED} "
+                f"failing commits before advisor dispatch (have "
+                f"{len(born_red.failed)})",
+            )
+
+        # If the advisor already weighed in on the suspect, use that verdict.
+        advisor_decision = self._check_advisor_verdict(born_red)
+        if advisor_decision is not None:
+            return advisor_decision
+
+        # No verdict yet — request one. `successful_commits` carry the implicit
+        # baseline (commits where the signal didn't exist); `is_born_red=True`
+        # tells the advisor JSON builder to relabel them accordingly.
+        advisor = DispatchAdvisor(
+            suspect_commit=born_red.failed[-1].head_sha,
+            failed_commits=tuple(c.head_sha for c in born_red.failed),
+            successful_commits=tuple(c.head_sha for c in born_red.successful),
+            is_born_red=True,
+        )
+        return Ineligible(
+            IneligibleReason.NO_SUCCESSES,
+            "born-red test signal: no successful commits in window — advisor dispatched",
+            advisor=advisor,
+        )
+
     def process_valid_autorevert_pattern(
         self, *, bisection_limit: Optional[int] = None
     ) -> Union[AutorevertPattern, RestartCommits, Ineligible]:
@@ -591,9 +706,7 @@ def process_valid_autorevert_pattern(
                 IneligibleReason.FIXED, "signal appears recovered at head"
             )
         if not self.has_successes():
-            return Ineligible(
-                IneligibleReason.NO_SUCCESSES, "no successful commits present in window"
-            )
+            return self._handle_no_successes()
 
         partition = self.partition_by_autorevert_pattern()
         if partition is None:

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

@@ -35,6 +35,33 @@
 SignalProcOutcome = Union[AutorevertPattern, RestartCommits, Ineligible]
 
 
+# Top-level natural-language framing attached to the advisor's
+# `signal_pattern.json` payload when `DispatchAdvisor.is_born_red` is set.
+# Said once at the top level rather than duplicated into every baseline
+# commit's `partition` label.
+_BORN_RED_PATTERN_CONTEXT = (
+    "born-red / newly-observed-red test signal: this test signal has NO "
+    "observations on any commit older than the suspect in the lookback "
+    "window. The suspect commit is the first commit on which the signal "
+    "appears, and it fails. Older commits in the `no_signal` partition "
+    "have empty events because the test was not extracted there — this "
+    "is ambiguous and could mean any of:\n"
+    "  (a) the suspect ADDED this test;\n"
+    "  (b) the suspect ENABLED / un-skipped an existing test or removed a "
+    "TD / skipping filter that previously masked it;\n"
+    "  (c) the suspect MOVED or RENAMED the test so its identity is newly "
+    "visible;\n"
+    "  (d) the suspect changed sharding / job selection so an existing "
+    "already-failing test became visible.\n"
+    "Read the suspect commit's diff and decide which of (a)-(d) applies. "
+    "Recommend `revert` only if the suspect's diff explicitly introduces "
+    "or enables the failing test (cases a / b / c). For (d) — sharding "
+    "or job-selection change exposing a pre-existing failure — recommend "
+    "`not_related` because the suspect did not cause the test to fail, "
+    "only made it observable."
+)
+
+
 class CommitPRSourceAction(Enum):
     MERGE = "merge"
     REVERT = "revert"
@@ -736,15 +763,28 @@ def _build_signal_pattern_json(
             "unknown: commits between failed and successful partitions "
             "with no resolved events (pending or missing data)"
         )
-        LABEL_SUCCESSFUL = (
-            "successful: baseline commits where this signal was GREEN "
-            "before the suspect commit"
-        )
-        LABEL_PRIOR = (
-            "prior: older commits before the successful baseline. "
-            "Important: the signal may have been fixed and then failed again. "
-            "Don't make assumptions just based on the presence of failures here."
-        )
+        # Born-red / newly-observed-red case: a test-track signal with no green
+        # observations in the lookback window. The "successful" set actually
+        # carries commits where this test signal was NOT OBSERVED (no extracted
+        # events). The label stays short — the natural-language framing of what
+        # the advisor needs to figure out lives in `pattern_context` at the
+        # top level (so it's said once, not duplicated per commit).
+        if dispatch_advisor.is_born_red:
+            LABEL_SUCCESSFUL = (
+                "no_signal: baseline commits where this test signal was not "
+                "observed (no extracted events). See top-level pattern_context."
+            )
+            LABEL_PRIOR = "prior: even older commits with no signal observation"
+        else:
+            LABEL_SUCCESSFUL = (
+                "successful: baseline commits where this signal was GREEN "
+                "before the suspect commit"
+            )
+            LABEL_PRIOR = (
+                "prior: older commits before the successful baseline. "
+                "Important: the signal may have been fixed and then failed again. "
+                "Don't make assumptions just based on the presence of failures here."
+            )
 
         def _fmt_ts(dt: Optional[datetime]) -> str:
             if dt is None:
@@ -823,17 +863,18 @@ def _partition_label(sha: str) -> str:
                 }
             )
 
-        return json.dumps(
-            {
-                "signal_key": signal.key,
-                "signal_source": signal.source.value if signal.source else "unknown",
-                "workflow_name": signal.workflow_name,
-                "job_base_name": signal.job_base_name,
-                "commit_order": "newest_first",
-                "suspect_commit": dispatch_advisor.suspect_commit,
-                "commits": commits_json,
-            }
-        )
+        payload = {
+            "signal_key": signal.key,
+            "signal_source": signal.source.value if signal.source else "unknown",
+            "workflow_name": signal.workflow_name,
+            "job_base_name": signal.job_base_name,
+            "commit_order": "newest_first",
+            "suspect_commit": dispatch_advisor.suspect_commit,
+            "commits": commits_json,
+        }
+        if dispatch_advisor.is_born_red:
+            payload["pattern_context"] = _BORN_RED_PATTERN_CONTEXT
+        return json.dumps(payload)
 
     def _commit_message_check_pr_is_revert(
         self, commit_message: str, ctx: RunContext