@@ -358,7 +358,10 @@ The CI Coverage job runs the suite through `pnpm test:coverage:ci`
   sink drains it and refuses the rerun. **Any new gate reporter must call `recordRunBlocker`**, and
   must be ordered before the sink in `reporters()`.
 - **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.
+  file are one retry, and count as one. The rerun keeps the first run's execution modes — the same
+  `--project` selection and the same V8 instrumentation (`scripts/lib/contention-retry-args.ts`), so
+  a coverage-job failure is never accepted by a run that could not reproduce it. Its coverage lands
+  in `coverage/contention-retry/`, leaving the first run's report as the changed-line gate's evidence.
 - **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,31 @@
+// Vitest argv for the two runs of the contention retry lane (#1419). The retry
+// must execute the failed files the same way the first run did — same projects,
+// same V8 instrumentation — or a failure the Coverage job produced could be
+// accepted by a run that could not reproduce it.
+
+export type RunModes = { projects: readonly string[]; coverage: boolean };
+
+/** Where the retry's own coverage lands, so the first run's report stays the gate's evidence. */
+export const RETRY_COVERAGE_DIR = 'coverage/contention-retry';
+
+function projectArgs(modes: RunModes): string[] {
+  return modes.projects.flatMap((name) => ['--project', name]);
+}
+
+export function firstRunArgs(modes: RunModes): string[] {
+  return [...projectArgs(modes), ...(modes.coverage ? ['--coverage'] : [])];
+}
+
+export function retryRunArgs(modes: RunModes, files: readonly string[]): string[] {
+  if (!modes.coverage) return [...projectArgs(modes), ...files];
+  // Global thresholds describe the whole suite; a handful of files can never meet
+  // them. A first-run threshold failure is a blocker, so the retry never runs.
+  return [
+    ...projectArgs(modes),
+    '--coverage',
+    `--coverage.reportsDirectory=${RETRY_COVERAGE_DIR}`,
+    '--coverage.thresholds.statements=0',
+    '--coverage.thresholds.lines=0',
+    ...files,
+  ];
+}
@@ -16,6 +16,7 @@ import contentionRetryReporter, {
   writeFailureReport,
 } from './contention-retry-reporter.ts';
 import { RUNNER_TIMEOUT_META, RUNNER_TIMEOUT_TOKEN_ENV } from './runner-timeout-meta.ts';
+import { firstRunArgs, RETRY_COVERAGE_DIR, retryRunArgs } from './contention-retry-args.ts';
 import {
   CONTENTION_RETRY_FILES,
   expiredRetryEntries,
@@ -290,6 +291,41 @@ test('the Coverage lane keeps the configured reporters, failure sink included',
   );
 });
 
+test('the retry reruns the failed files in the first run modes', () => {
+  const modes = { projects: ['unit-core', 'subprocess-stub'], coverage: true };
+  assert.deepEqual(firstRunArgs(modes), [
+    '--project',
+    'unit-core',
+    '--project',
+    'subprocess-stub',
+    '--coverage',
+  ]);
+  const retry = retryRunArgs(modes, [LISTED]);
+  assert.deepEqual(retry, [
+    '--project',
+    'unit-core',
+    '--project',
+    'subprocess-stub',
+    '--coverage',
+    `--coverage.reportsDirectory=${RETRY_COVERAGE_DIR}`,
+    // A subset of files can never meet whole-suite thresholds, and a first-run
+    // threshold failure is a blocker, so the retry never runs after one.
+    '--coverage.thresholds.statements=0',
+    '--coverage.thresholds.lines=0',
+    LISTED,
+  ]);
+  // The gate reads the first run's report; the retry must not overwrite it.
+  assert.notEqual(RETRY_COVERAGE_DIR, 'coverage');
+  assert.deepEqual(retryRunArgs({ projects: [], coverage: false }, [LISTED]), [LISTED]);
+
+  const runner = fs.readFileSync(
+    path.join(repoRoot, 'scripts/lib/contention-retry-run.ts'),
+    'utf8',
+  );
+  assert.match(runner, /runAll: \(\) => runVitest\(firstRunArgs\(modes\)/);
+  assert.match(runner, /runFiles: \(files\) =>\s*runVitest\(retryRunArgs\(modes, files\)/);
+});
+
 test('non-test failures block the retry instead of being rerun away', async () => {
   const covered = processBlockers({
     ok: false,
 
@@ -12,6 +12,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { runCmdStreaming, runCmdSync } from '../../src/utils/exec.ts';
 import { parseScriptArgs } from './cli-args.ts';
+import { firstRunArgs, retryRunArgs, type RunModes } from './contention-retry-args.ts';
 import { runWithContentionRetry, type TestRun } from './contention-retry-lane.ts';
 import { FAILURE_FILE_ENV } from './contention-retry-reporter.ts';
 import { RUNNER_TIMEOUT_TOKEN_ENV } from './runner-timeout-meta.ts';
@@ -95,6 +96,7 @@ function configHash(): string {
   for (const file of [
     'vitest.config.ts',
     'scripts/lib/contention-retry.ts',
+    'scripts/lib/contention-retry-args.ts',
     'scripts/lib/contention-retry-reporter.ts',
     'scripts/lib/contention-retry-blockers.ts',
     'scripts/lib/run-blocker-bus.ts',
@@ -105,16 +107,19 @@ function configHash(): string {
   return `sha256:${hash.digest('hex').slice(0, 16)}`;
 }
 
-const projects = (args.project ?? '')
-  .split(',')
-  .map((entry) => entry.trim())
-  .filter(Boolean)
-  .flatMap((name) => ['--project', name]);
+const modes: RunModes = {
+  projects: (args.project ?? '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean),
+  coverage: args.coverage,
+};
 
 const startedAtMs = Date.now();
 const result = await runWithContentionRetry({
-  runAll: () => runVitest([...projects, ...(args.coverage ? ['--coverage'] : [])], reportPath),
-  runFiles: (files) => runVitest([...files], reportPath.replace(/\.json$/, '.retry.json')),
+  runAll: () => runVitest(firstRunArgs(modes), reportPath),
+  runFiles: (files) =>
+    runVitest(retryRunArgs(modes, files), reportPath.replace(/\.json$/, '.retry.json')),
   commit: runCmdSync('git', ['rev-parse', 'HEAD'], { cwd: repoRoot }).stdout.trim(),
   configHash: configHash(),
   vitestVersion: vitestVersion(),