@@ -306,10 +306,18 @@ the retry policy cannot drift apart.
 The CI Coverage job runs the suite through `pnpm test:coverage:ci`
 (`scripts/lib/contention-retry-run.ts`), which applies one rule:
 
-- **Timeouts only.** A rerun happens only when *every* failure in the run is timeout-shaped **and**
-  lands in a listed file. One assertion failure — in a listed file or not — fails the job on the
-  first run, so a real regression can never be papered over by a retry.
-- **One retry, of the failed files only.** Not the suite, and never twice.
+- **Timeouts only, classified structurally.** A rerun happens only when *every* failure in the run is
+  a timeout raised by the runner itself **and** lands in a listed file. The lane's own reporter
+  (`scripts/lib/contention-retry-reporter.ts`) classifies the live error object — Vitest's exact
+  timeout template, a plain `Error`, no `expected`/`actual` — so an assertion whose *message*
+  mentions a timeout cannot opt itself into a retry. One assertion failure — in a listed file or not
+  — fails the job on the first run, so a real regression can never be papered over by a retry.
+- **Anything a rerun cannot re-check blocks the retry.** Unhandled errors, module load/setup errors,
+  a coverage-threshold miss, or a nonzero exit no failed test explains are recorded as blockers
+  (`scripts/lib/contention-retry-blockers.ts`) and fail the job, so a green retry can never erase a
+  second, unrelated failure from the same run.
+- **One retry, of the failed files only.** Not the suite, and never twice. Two timed-out tests in one
+  file are one retry, and count as one.
 - **Retries stay visible.** Every retried file is named in the job summary with its tracking issue
   and review date, and the run writes the shared scheduled-lane envelope
   (`scripts/lib/lane-envelope.ts`, #1430) with the retry count, so a permanently flaky file shows up
 
@@ -0,0 +1,41 @@
+// Process-level blockers for the contention single-retry policy (#1419).
+//
+// The reporter can only see what happened inside the run. Two failure classes
+// live outside it and would otherwise be erased by a green retry: a coverage
+// verdict (computed after the tests, and a whole-suite property a file-scoped
+// rerun cannot re-establish), and any nonzero exit no failed test explains
+// (worker crash, config error, report never written). Both are recorded as
+// blockers, which forbid the retry outright.
+
+import type { RunBlocker } from './contention-retry.ts';
+
+/** Vitest's own coverage verdict lines (`checkCoverages`, vitest 4). */
+const COVERAGE_FAILURE = [
+  /ERROR: Coverage for [a-z]+ \([\d.]+%\) does not meet (?:global )?threshold/i,
+  /ERROR: Coverage for [a-z]+ \([\d.]+%\) does not meet .*minimum threshold/i,
+];
+
+export type ProcessOutcome = {
+  ok: boolean;
+  /** Combined stdout+stderr of the run. */
+  output: string;
+  failureCount: number;
+};
+
+export function processBlockers(outcome: ProcessOutcome): RunBlocker[] {
+  if (outcome.ok) return [];
+  const blockers: RunBlocker[] = [];
+  const coverage = outcome.output
+    .split('\n')
+    .filter((line) => COVERAGE_FAILURE.some((pattern) => pattern.test(line)));
+  for (const line of coverage) {
+    blockers.push({ kind: 'coverage threshold', detail: line.trim() });
+  }
+  if (outcome.failureCount === 0 && blockers.length === 0) {
+    blockers.push({
+      kind: 'unexplained failure',
+      detail: 'the run exited nonzero with no failed test recorded — see the job log',
+    });
+  }
+  return blockers;
+}
@@ -13,18 +13,21 @@ import {
   planContentionRetry,
   type RetryOutcome,
   type RetryPlan,
+  type RunBlocker,
   type TestFailure,
 } from './contention-retry.ts';
 
 export type TestRun = {
   ok: boolean;
   failures: readonly TestFailure[];
+  /** Non-test failures; any of them forbids a retry. */
+  blockers?: readonly RunBlocker[];
 };
 
 /** Telemetry payload for scheduled-lane health (#1430). */
 export type ContentionRetryTelemetry = {
-  /** Files rerun in this job, with the test that timed out. */
-  retried: ReadonlyArray<{ file: string; testName: string; trackingIssue: string }>;
+  /** Files rerun in this job (one entry per file, not per failed test). */
+  retried: ReadonlyArray<{ file: string; testNames: readonly string[]; trackingIssue: string }>;
   retryCount: number;
   retryOutcome: RetryOutcome | null;
   listSize: number;
@@ -81,7 +84,7 @@ export async function runWithContentionRetry(
     return finish(options, { ok: true, summary: '', plan: undefined, outcome: null });
   }
 
-  const plan = planContentionRetry(first.failures);
+  const plan = planContentionRetry(first.failures, first.blockers ?? []);
   if (!plan.retry) {
     return finish(options, {
       ok: false,
@@ -111,16 +114,17 @@ function finish(
   },
 ): ContentionRetryResult {
   const plan = state.plan;
+  // Keyed by file, matching what actually reran: two timed-out tests in one file
+  // are one retry, not two.
   const retried = plan?.retry
-    ? plan.failures.map((failure) => {
-        const file = normalizeTestFile(failure.file);
-        return {
-          file,
-          testName: failure.testName,
-          trackingIssue:
-            CONTENTION_RETRY_FILES.find((entry) => entry.file === file)?.trackingIssue ?? '',
-        };
-      })
+    ? plan.files.map((file) => ({
+        file,
+        testNames: plan.failures
+          .filter((failure) => normalizeTestFile(failure.file) === file)
+          .map((failure) => failure.testName),
+        trackingIssue:
+          CONTENTION_RETRY_FILES.find((entry) => entry.file === file)?.trackingIssue ?? '',
+      }))
     : [];
   return {
     ok: state.ok,