diff --git a/doc/api/test.md b/doc/api/test.md
index 2d38f136f28332..7ff55cb2319829 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -1868,6 +1868,16 @@ added:
 Shorthand for marking a suite as `TODO`. This is the same as
 [`suite([name], { todo: true }[, fn])`][suite options].
 
+## `suite.flaky([name][, options][, fn])`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+Shorthand for marking a suite as flaky. This is the same as
+[`suite([name], { flaky: true }[, fn])`][suite options].
+
 ## `suite.only([name][, options][, fn])`
 
 <!-- YAML
@@ -1939,6 +1949,14 @@ changes:
   * `todo` {boolean|string} If truthy, the test marked as `TODO`. If a string
     is provided, that string is displayed in the test results as the reason why
     the test is `TODO`. **Default:** `false`.
+  * `flaky` {boolean|number} If `true`, the test (or, for a suite, each of its
+    test-cases) is retried until it passes, up to a default of 20 retries. If a
+    positive integer is provided, it is retried up to that many times. A
+    non-positive or non-integer value throws. Each retry re-runs the test's
+    `beforeEach` and `afterEach` hooks. A test-case's own value overrides one
+    inherited from its suite; `flaky: false` opts out. Retries are intended for
+    tests that fail intermittently due to transient conditions; be aware that
+    non-idempotent state may leak between attempts. **Default:** `false`.
   * `timeout` {number} A number of milliseconds the test will fail after.
     If unspecified, subtests inherit this value from their parent.
     **Default:** `Infinity`.
@@ -2000,6 +2018,16 @@ same as [`test([name], { todo: true }[, fn])`][it options].
 Shorthand for marking a test as `only`,
 same as [`test([name], { only: true }[, fn])`][it options].
 
+## `test.flaky([name][, options][, fn])`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+Shorthand for marking a test as flaky,
+same as [`test([name], { flaky: true }[, fn])`][it options].
+
 ## `describe([name][, options][, fn])`
 
 Alias for [`suite()`][].
@@ -2027,6 +2055,16 @@ added:
 Shorthand for marking a suite as `only`. This is the same as
 [`describe([name], { only: true }[, fn])`][describe options].
 
+## `describe.flaky([name][, options][, fn])`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+Shorthand for marking a suite as flaky. This is the same as
+[`describe([name], { flaky: true }[, fn])`][describe options].
+
 ## `it([name][, options][, fn])`
 
 <!-- YAML
@@ -2066,6 +2104,16 @@ added:
 Shorthand for marking a test as `only`,
 same as [`it([name], { only: true }[, fn])`][it options].
 
+## `it.flaky([name][, options][, fn])`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+Shorthand for marking a test as flaky,
+same as [`it([name], { flaky: true }[, fn])`][it options].
+
 ## `before([fn][, options])`
 
 <!-- YAML
@@ -3539,6 +3587,9 @@ Emitted when code coverage is enabled and all tests have completed.
   * `testNumber` {number} The ordinal number of the test.
   * `todo` {string|boolean|undefined} Present if [`context.todo`][] is called
   * `skip` {string|boolean|undefined} Present if [`context.skip`][] is called
+  * `retryCount` {number|undefined} The number of retries performed for a test
+    marked `flaky` (`0` if it passed on the first attempt). `undefined` for
+    tests that are not flaky.
 
 Emitted when a test completes its execution.
 This event is not emitted in the same order as the tests are
@@ -3647,6 +3698,9 @@ Emitted when a test is enqueued for execution.
   * `testNumber` {number} The ordinal number of the test.
   * `todo` {string|boolean|undefined} Present if [`context.todo`][] is called
   * `skip` {string|boolean|undefined} Present if [`context.skip`][] is called
+  * `retryCount` {number|undefined} The number of retries performed for a test
+    marked `flaky` (`0` if it passed on the first attempt). `undefined` for
+    tests that are not flaky.
 
 Emitted when a test fails.
 This event is guaranteed to be emitted in the same order as the tests are
@@ -3712,6 +3766,9 @@ since the parent runner only knows about file-level tests. When using
   * `testNumber` {number} The ordinal number of the test.
   * `todo` {string|boolean|undefined} Present if [`context.todo`][] is called
   * `skip` {string|boolean|undefined} Present if [`context.skip`][] is called
+  * `retryCount` {number|undefined} The number of retries performed for a test
+    marked `flaky` (`0` if it passed on the first attempt). `undefined` for
+    tests that are not flaky.
 
 Emitted when a test passes.
 This event is guaranteed to be emitted in the same order as the tests are
@@ -4527,6 +4584,14 @@ changes:
   * `todo` {boolean|string} If truthy, the test marked as `TODO`. If a string
     is provided, that string is displayed in the test results as the reason why
     the test is `TODO`. **Default:** `false`.
+  * `flaky` {boolean|number} If `true`, the test (or, for a suite, each of its
+    test-cases) is retried until it passes, up to a default of 20 retries. If a
+    positive integer is provided, it is retried up to that many times. A
+    non-positive or non-integer value throws. Each retry re-runs the test's
+    `beforeEach` and `afterEach` hooks. A test-case's own value overrides one
+    inherited from its suite; `flaky: false` opts out. Retries are intended for
+    tests that fail intermittently due to transient conditions; be aware that
+    non-idempotent state may leak between attempts. **Default:** `false`.
   * `timeout` {number} A number of milliseconds the test will fail after.
     If unspecified, subtests inherit this value from their parent.
     **Default:** `Infinity`.
diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js
index 16f9392bf7763b..1097cd00be9c07 100644
--- a/lib/internal/test_runner/harness.js
+++ b/lib/internal/test_runner/harness.js
@@ -63,6 +63,7 @@ function createTestTree(rootTestOptions, globalOptions) {
         failed: 0,
         passed: 0,
         cancelled: 0,
+        flaky: 0,
         skipped: 0,
         todo: 0,
         topLevel: 0,
@@ -406,7 +407,7 @@ function runInParentContext(Factory) {
 
     return run(name, options, fn, overrides);
   };
-  ArrayPrototypeForEach(['expectFailure', 'skip', 'todo', 'only'], (keyword) => {
+  ArrayPrototypeForEach(['expectFailure', 'flaky', 'skip', 'todo', 'only'], (keyword) => {
     test[keyword] = (name, options, fn) => {
       const overrides = {
         __proto__: null,
diff --git a/lib/internal/test_runner/reporter/dot.js b/lib/internal/test_runner/reporter/dot.js
index 45ff047bc4e5a0..e07e91ec811d61 100644
--- a/lib/internal/test_runner/reporter/dot.js
+++ b/lib/internal/test_runner/reporter/dot.js
@@ -12,7 +12,11 @@ module.exports = async function* dot(source) {
   const failedTests = [];
   for await (const { type, data } of source) {
     if (type === 'test:pass') {
-      yield `${colors.green}.${colors.reset}`;
+      // A flaky test that needed retries is shown in yellow to distinguish it
+      // from a clean pass, without using 'F' (which reads as a failure).
+      yield data.retryCount > 0 ?
+        `${colors.yellow}.${colors.reset}` :
+        `${colors.green}.${colors.reset}`;
     }
     if (type === 'test:fail') {
       yield `${colors.red}X${colors.reset}`;
diff --git a/lib/internal/test_runner/reporter/junit.js b/lib/internal/test_runner/reporter/junit.js
index 25f5667c59e273..783f78673fa82a 100644
--- a/lib/internal/test_runner/reporter/junit.js
+++ b/lib/internal/test_runner/reporter/junit.js
@@ -131,6 +131,16 @@ module.exports = async function* junitReporter(source) {
               attrs: { __proto__: null, type: 'todo', message: event.data.todo },
             });
           }
+          if (event.data.retryCount > 0) {
+            ArrayPrototypePush(currentTest.children, {
+              __proto__: null, nesting: event.data.nesting + 1, tag: 'properties',
+              attrs: { __proto__: null },
+              children: [{
+                __proto__: null, nesting: event.data.nesting + 2, tag: 'property',
+                attrs: { __proto__: null, name: 'flaky', value: `${event.data.retryCount} retries` },
+              }],
+            });
+          }
           if (event.type === 'test:fail') {
             const error = event.data.details?.error;
             currentTest.children.push({
diff --git a/lib/internal/test_runner/reporter/tap.js b/lib/internal/test_runner/reporter/tap.js
index c3bbd1d144eb35..7e1560843750b6 100644
--- a/lib/internal/test_runner/reporter/tap.js
+++ b/lib/internal/test_runner/reporter/tap.js
@@ -33,12 +33,14 @@ async function * tapReporter(source) {
   for await (const { type, data } of source) {
     switch (type) {
       case 'test:fail': {
-        yield reportTest(data.nesting, data.testNumber, 'not ok', data.name, data.skip, data.todo, data.expectFailure);
+        yield reportTest(data.nesting, data.testNumber, 'not ok', data.name,
+                         data.skip, data.todo, data.expectFailure, data.retryCount);
         const location = data.file ? `${data.file}:${data.line}:${data.column}` : null;
         yield reportDetails(data.nesting, data.details, location);
         break;
       } case 'test:pass':
-        yield reportTest(data.nesting, data.testNumber, 'ok', data.name, data.skip, data.todo, data.expectFailure);
+        yield reportTest(data.nesting, data.testNumber, 'ok', data.name,
+                         data.skip, data.todo, data.expectFailure, data.retryCount);
         yield reportDetails(data.nesting, data.details, null);
         break;
       case 'test:plan':
@@ -75,7 +77,7 @@ async function * tapReporter(source) {
   }
 }
 
-function reportTest(nesting, testNumber, status, name, skip, todo, expectFailure) {
+function reportTest(nesting, testNumber, status, name, skip, todo, expectFailure, retryCount) {
   let line = `${indent(nesting)}${status} ${testNumber}`;
 
   if (name) {
@@ -88,6 +90,11 @@ function reportTest(nesting, testNumber, status, name, skip, todo, expectFailure
     line += ` # TODO${typeof todo === 'string' && todo.length ? ` ${tapEscape(todo)}` : ''}`;
   } else if (expectFailure !== undefined) {
     line += ` # EXPECTED FAILURE${typeof expectFailure === 'string' ? ` ${tapEscape(expectFailure)}` : ''}`;
+  } else if (retryCount > 0) {
+    const word = retryCount === 1 ? 're-try' : 're-tries';
+    line += status === 'ok' ?
+      ` # FLAKY ${retryCount} ${word}` :
+      ` # FLAKY failed after ${retryCount} ${word}`;
   }
 
   line += '\n';
diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
index 67030680019838..c27e3faded072a 100644
--- a/lib/internal/test_runner/reporter/utils.js
+++ b/lib/internal/test_runner/reporter/utils.js
@@ -71,7 +71,7 @@ function formatError(error, indent) {
 function formatTestReport(type, data, showErrorDetails = true, prefix = '', indent = '') {
   let color = reporterColorMap[type] ?? colors.white;
   let symbol = reporterUnicodeSymbolMap[type] ?? ' ';
-  const { skip, todo, expectFailure } = data;
+  const { skip, todo, expectFailure, retryCount } = data;
   const duration_ms = data.details?.duration_ms ? ` ${colors.gray}(${data.details.duration_ms}ms)${colors.white}` : '';
   const replayed = data.details?.passed_on_attempt !== undefined ?
     ` ${colors.gray}(passed on attempt ${data.details.passed_on_attempt})${colors.white}` :
@@ -90,6 +90,11 @@ function formatTestReport(type, data, showErrorDetails = true, prefix = '', inde
     }
   } else if (expectFailure !== undefined) {
     title += ` # EXPECTED FAILURE`;
+  } else if (retryCount > 0) {
+    const word = retryCount === 1 ? 're-try' : 're-tries';
+    title += type === 'test:fail' ?
+      ` # FLAKY failed after ${retryCount} ${word}` :
+      ` # FLAKY ${retryCount} ${word}`;
   }
 
   const err = showErrorDetails && data.details?.error ? formatError(data.details.error, indent) : '';
diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js
index d150943783e975..c72984af8d2a49 100644
--- a/lib/internal/test_runner/runner.js
+++ b/lib/internal/test_runner/runner.js
@@ -313,7 +313,13 @@ class FileTest extends Test {
         skipped: item.data.skip !== undefined,
         isTodo: item.data.todo !== undefined,
         passed: item.type === 'test:pass',
-        cancelled: kCanceledTests.has(item.data.details?.error?.failureType),
+        // A retried timeout that exhausted (retryCount > 0) is a failure, not a
+        // cancellation only an un-retried timeout/abort stays cancelled.
+        cancelled: kCanceledTests.has(item.data.details?.error?.failureType) &&
+          !(item.data.retryCount > 0),
+        // retryCount is present (even 0) only for flaky-marked tests, so it lets
+        // the parent count flaky tests across the process-isolation IPC boundary.
+        flakyRetries: item.data.retryCount !== undefined ? 1 : 0,
         nesting: item.data.nesting,
         reportedType: item.data.details?.type,
       }, this.root.harness);
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index d19d6349f104bf..f1fe6bbc90316a 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -77,6 +77,7 @@ const { isPromise, isRegExp } = require('internal/util/types');
 const {
   validateAbortSignal,
   validateFunction,
+  validateInteger,
   validateNumber,
   validateObject,
   validateOneOf,
@@ -102,6 +103,7 @@ const kTestTimeoutFailure = 'testTimeoutFailure';
 const kExpectedFailure = 'expectedFailure';
 const kHookFailure = 'hookFailed';
 const kDefaultTimeout = null;
+const kDefaultFlakyRetries = 20;
 const noop = FunctionPrototype;
 const kShouldAbort = Symbol('kShouldAbort');
 const kHookNames = ObjectSeal(['before', 'after', 'beforeEach', 'afterEach']);
@@ -328,13 +330,21 @@ class TestContext {
 
   get assert() {
     if (this.#assert === undefined) {
-      const { plan } = this.#test;
+      const test = this.#test;
       const map = lazyAssertObject(this.#test.root.harness);
       const assert = { __proto__: null };
 
+      // A flaky test recreates its plan on each retry, so its assertions must
+      // read `test.plan` live. A non-flaky test captures the plan reference once
+      // (at first `.assert` access), preserving the historical counting behavior
+      // exactly - opting out of `flaky` changes nothing.
+      const capturedPlan = test.plan;
+      const currentPlan = () => (test.flakyRetries > 0 ? test.plan : capturedPlan);
+
       this.#assert = assert;
       map.forEach((method, name) => {
         assert[name] = (...args) => {
+          const plan = currentPlan();
           if (plan !== null) {
             plan.count();
           }
@@ -346,6 +356,7 @@ class TestContext {
         // This is a hack. It allows the innerOk function to collect the
         // stacktrace from the correct starting point.
         function ok(...args) {
+          const plan = currentPlan();
           if (plan !== null) {
             plan.count();
           }
@@ -569,7 +580,7 @@ class Test extends AsyncResource {
     super('Test');
 
     let { fn, name, parent } = options;
-    const { concurrency, entryFile, expectFailure, loc, only, timeout, todo, skip, signal, plan } = options;
+    const { concurrency, entryFile, expectFailure, flaky, loc, only, plan, signal, skip, timeout, todo } = options;
     const rawTags = options.tags;
 
     if (typeof fn !== 'function') {
@@ -732,6 +743,22 @@ class Test extends AsyncResource {
     this.plan = null;
     this.expectedAssertions = plan;
     this.cancelled = false;
+    if (flaky === undefined || flaky === null) {
+      // Inherit flaky only from a suite parent: a suite propagates it to its
+      // test-cases, but a test must not propagate it to its own subtests.
+      this.flakyRetries = this.parent?.reportedType === 'suite' ?
+        (this.parent.flakyRetries ?? 0) : 0;
+    } else if (typeof flaky === 'boolean') {
+      this.flakyRetries = flaky ? kDefaultFlakyRetries : 0;
+    } else if (typeof flaky === 'number') {
+      validateInteger(flaky, 'options.flaky', 1);
+      this.flakyRetries = flaky;
+    } else {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.flaky', ['boolean', 'number'], flaky);
+    }
+    this.retriesTaken = 0;
+
     this.expectFailure = parseExpectFailure(expectFailure) || this.parent?.expectFailure;
     this.skipped = skip !== undefined && skip !== false;
     this.isTodo = (todo !== undefined && todo !== false) || this.parent?.isTodo;
@@ -1322,7 +1349,11 @@ class Test extends AsyncResource {
         await this.runHook('after', hookArgs);
       }
     };
-    const afterEach = runOnce(async () => {
+    // `afterEach` is recreated for each attempt so that it runs again on every
+    // retry of a flaky test (including after a failed attempt). `before`/`after`
+    // remain suite-once: their `hook.run` is wrapped with runOnce in createHook(),
+    // so re-entering them across attempts is a no-op.
+    let afterEach = runOnce(async () => {
       if (this.parent?.hooks.afterEach.length > 0 && !wasSkippedBeforeRun) {
         await this.parent.runHook('afterEach', hookArgs);
       }
@@ -1333,107 +1364,214 @@ class Test extends AsyncResource {
     let publishEnd = () => testChannel.end.publish(channelContext);
     let publishError = (err) => testChannel.error.publish({ __proto__: null, ...channelContext, error: err });
 
-    try {
-      if (this.parent?.hooks.before.length > 0) {
-        // This hook usually runs immediately, we need to wait for it to finish
-        await this.parent.runHook('before', this.parent.getRunArgs());
-      }
-      if (this.parent?.hooks.beforeEach.length > 0 && !this.skipped) {
-        await this.parent.runHook('beforeEach', hookArgs);
+    // A test marked `flaky: N` runs once and is then retried up to N more times
+    // until it passes, for a maximum of N + 1 attempts ("inclusive"). When
+    // the test is not flaky, `flakyRetries` is 0 and exactly one attempt runs,
+    // keeping the behavior byte-identical to a non-flaky test.
+    const maxAttempts = this.flakyRetries > 0 ? this.flakyRetries + 1 : 1;
+    // Diagnostics emitted before the run (e.g. during construction) must survive
+    // retries; only diagnostics produced by a previous attempt are discarded.
+    const baseDiagnosticsCount = this.diagnostics.length;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      if (attempt > 1) {
+        // Reset per-attempt state before retrying a flaky test. Anything
+        // that would otherwise leak between attempts is cleared here so that the
+        // retry starts from a clean slate. `before`/`after` (suite-once) and the
+        // accumulated parent hooks are intentionally left untouched.
+        this.error = null;
+        this.passed = false;
+        this.cancelled = false;
+        // Restore any mocks applied by the previous attempt so the retry starts
+        // clean (the MockTracker is otherwise only reset in postRun).
+        this.mock?.reset();
+        ArrayPrototypeSplice(this.diagnostics, baseDiagnosticsCount);
+        // Reset assertion bookkeeping; re-arm the plan if one was requested via
+        // the `plan` option so that `t.plan(N)` does not accumulate across
+        // attempts.
+        this.plan = null;
+        if (this.expectedAssertions) {
+          ctx.plan(this.expectedAssertions);
+        }
+        // Drop subtests created by the previous attempt so they are not double
+        // counted or double reported. outputSubtestCount must be reset too:
+        // otherwise it accumulates across attempts while `subtests` holds only
+        // the final attempt's children, inflating the plan count and - when the
+        // final attempt creates no subtest - leaving outputSubtestCount > 0 with
+        // an empty `subtests`, which crashed report() (see the guard there).
+        this.subtests = [];
+        this.outputSubtestCount = 0;
+        this.activeSubtests = 0;
+        this.pendingSubtests = [];
+        this.readySubtests = new SafeMap();
+        this.unfinishedSubtests = new SafeSet();
+        this.subtestsPromise = null;
+        this.waitingOn = 0;
+        // Snapshot numbering lives on the shared per-file SnapshotFile and
+        // is resolved by the snapshot manager; it is intentionally not reset from
+        // here because doing so would corrupt sibling tests in the same file. The
+        // final attempt's snapshots win (last-write-wins).
+        // Abort the previous attempt's controller so any signal-bound work it
+        // started (e.g. a timer awaiting t.signal) is torn down instead of
+        // leaking. The retry decision for that attempt has already been made, so
+        // this cannot be misread as an external abort. A fresh controller then
+        // backs the next attempt, preventing the previous abort from being
+        // observed as an external abort by the retry decision below.
+        this.abortController.abort();
+        this.abortController = new AbortController();
+        this.signal = this.abortController.signal;
+        afterEach = runOnce(async () => {
+          if (this.parent?.hooks.afterEach.length > 0 && !wasSkippedBeforeRun) {
+            await this.parent.runHook('afterEach', hookArgs);
+          }
+        }, kRunOnceOptions);
       }
-      stopPromise = stopTest(this.timeout, this.signal);
-      const runArgs = ArrayPrototypeSlice(args);
 
-      // Wrap the test function with runStores if the channel has subscribers.
-      // The wrapped function is what gets passed to runInAsyncScope, ensuring that
-      // the test runs within both the runStores context (for AsyncLocalStorage/bindStore)
-      // AND the AsyncResource scope. It's critical that runStores wraps the function,
-      // not the runInAsyncScope call itself, to maintain AsyncLocalStorage bindings.
-      let testFn = this.fn;
-      if (channelContext !== null && testChannel.start.hasSubscribers) {
-        testFn = (...fnArgs) => testChannel.start.runStores(channelContext, () => {
-          publishEnd = AsyncResource.bind(publishEnd);
-          publishError = AsyncResource.bind(publishError);
-          return ReflectApply(this.fn, this, fnArgs);
-        });
-      }
+      try {
+        if (this.parent?.hooks.before.length > 0) {
+          // This hook usually runs immediately, we need to wait for it to finish
+          await this.parent.runHook('before', this.parent.getRunArgs());
+        }
+        if (this.parent?.hooks.beforeEach.length > 0 && !this.skipped) {
+          await this.parent.runHook('beforeEach', hookArgs);
+        }
+        // A fresh timeout timer is created for each attempt so that a slow
+        // attempt does not consume the budget of subsequent retries.
+        stopPromise = stopTest(this.timeout, this.signal);
+        const runArgs = ArrayPrototypeSlice(args);
+
+        // Wrap the test function with runStores if the channel has subscribers.
+        // The wrapped function is what gets passed to runInAsyncScope, ensuring that
+        // the test runs within both the runStores context (for AsyncLocalStorage/bindStore)
+        // AND the AsyncResource scope. It's critical that runStores wraps the function,
+        // not the runInAsyncScope call itself, to maintain AsyncLocalStorage bindings.
+        let testFn = this.fn;
+        if (channelContext !== null && testChannel.start.hasSubscribers) {
+          testFn = (...fnArgs) => testChannel.start.runStores(channelContext, () => {
+            publishEnd = AsyncResource.bind(publishEnd);
+            publishError = AsyncResource.bind(publishError);
+            return ReflectApply(this.fn, this, fnArgs);
+          });
+        }
 
-      ArrayPrototypeUnshift(runArgs, testFn, ctx);
+        ArrayPrototypeUnshift(runArgs, testFn, ctx);
 
-      const promises = [];
-      if (this.fn.length === runArgs.length - 1) {
-        // This test is using legacy Node.js error-first callbacks.
-        const { promise, cb } = createDeferredCallback();
-        ArrayPrototypePush(runArgs, cb);
-
-        const ret = ReflectApply(this.runInAsyncScope, this, runArgs);
-
-        if (isPromise(ret)) {
-          this.fail(new ERR_TEST_FAILURE(
-            'passed a callback but also returned a Promise',
-            kCallbackAndPromisePresent,
-          ));
-          ArrayPrototypePush(promises, ret);
+        const promises = [];
+        if (this.fn.length === runArgs.length - 1) {
+          // This test is using legacy Node.js error-first callbacks.
+          const { promise, cb } = createDeferredCallback();
+          ArrayPrototypePush(runArgs, cb);
+
+          const ret = ReflectApply(this.runInAsyncScope, this, runArgs);
+
+          if (isPromise(ret)) {
+            this.fail(new ERR_TEST_FAILURE(
+              'passed a callback but also returned a Promise',
+              kCallbackAndPromisePresent,
+            ));
+            ArrayPrototypePush(promises, ret);
+          } else {
+            ArrayPrototypePush(promises, PromiseResolve(promise));
+          }
         } else {
+          // This test is synchronous or using Promises.
+          const promise = ReflectApply(this.runInAsyncScope, this, runArgs);
           ArrayPrototypePush(promises, PromiseResolve(promise));
         }
-      } else {
-        // This test is synchronous or using Promises.
-        const promise = ReflectApply(this.runInAsyncScope, this, runArgs);
-        ArrayPrototypePush(promises, PromiseResolve(promise));
-      }
 
-      ArrayPrototypePush(promises, stopPromise);
+        ArrayPrototypePush(promises, stopPromise);
 
-      // Wait for the race to finish
-      await SafePromiseRace(promises);
+        // Wait for the race to finish
+        await SafePromiseRace(promises);
 
-      this[kShouldAbort]();
+        this[kShouldAbort]();
 
-      if (this.subtestsPromise !== null) {
-        await SafePromiseRace([this.subtestsPromise.promise, stopPromise]);
-      }
+        if (this.subtestsPromise !== null) {
+          await SafePromiseRace([this.subtestsPromise.promise, stopPromise]);
+        }
 
-      if (this.plan !== null) {
-        const planPromise = this.plan?.check();
-        // If the plan returns a promise, it means that it is waiting for more assertions to be made before
-        // continuing.
-        if (planPromise) {
-          await SafePromiseRace([planPromise, stopPromise]);
+        if (this.plan !== null) {
+          const planPromise = this.plan?.check();
+          // If the plan returns a promise, it means that it is waiting for more assertions to be made before
+          // continuing.
+          if (planPromise) {
+            await SafePromiseRace([planPromise, stopPromise]);
+          }
         }
-      }
 
-      this.pass();
-      await afterEach();
-      await after();
-    } catch (err) {
-      if (channelContext !== null && testChannel.error.hasSubscribers) {
-        publishError(err);
-      }
-      if (isTestFailureError(err)) {
-        if (err.failureType === kTestTimeoutFailure) {
-          this.#cancel(err);
+        this.pass();
+        await afterEach();
+        await after();
+      } catch (err) {
+        if (isTestFailureError(err)) {
+          if (err.failureType === kTestTimeoutFailure && this.flakyRetries === 0) {
+            // Non-flaky timeouts are classified as cancelled, unchanged.
+            this.#cancel(err);
+          } else {
+            // A flaky timeout must not flow through #cancel: #cancel aborts the
+            // abort controller, which the retry decision would misread as an
+            // external abort and stop retrying. Record it as a normal failure so
+            // it can be retried, and so that on exhaustion it is counted as a
+            // failure rather than cancelled.
+            this.fail(err);
+          }
         } else {
-          this.fail(err);
+          this.fail(new ERR_TEST_FAILURE(err, kTestCodeFailure));
         }
-      } else {
-        this.fail(new ERR_TEST_FAILURE(err, kTestCodeFailure));
-      }
-      try { await afterEach(); } catch { /* test is already failing, let's ignore the error */ }
-      try { await after(); } catch { /* Ignore error. */ }
-    } finally {
-      stopPromise?.[SymbolDispose]();
-
-      // Do not abort hooks and the root test as hooks instance are shared between tests suite so aborting them will
-      // cause them to not run for further tests.
-      if (this.parent !== null) {
-        this.abortController.abort();
+        // The pass/fail outcome is now known (e.g. an expectFailure throw is a
+        // pass, so it is not retried). Publish to the tracing channel's error
+        // stream and run the test-level `after` hook only on the final attempt;
+        // intermediate retries of a flaky test are silent and keep `after` for
+        // the end. For a non-flaky test (maxAttempts === 1) the error always
+        // publishes, as before.
+        const willRetry = attempt < maxAttempts &&
+          !this.passed &&
+          !this.expectFailure &&
+          !(this.signal.aborted || this.outerSignal?.aborted);
+        if (!willRetry && channelContext !== null && testChannel.error.hasSubscribers) {
+          publishError(err);
+        }
+        try { await afterEach(); } catch { /* test is already failing, let's ignore the error */ }
+        if (!willRetry) {
+          try { await after(); } catch { /* Ignore error. */ }
+        }
+      } finally {
+        stopPromise?.[SymbolDispose]();
       }
 
-      // Publish diagnostics_channel end event if the channel has subscribers (in both success and error cases)
+      // Publish the tracing channel `end` once per attempt so each `start`
+      // (published when the body runs) is paired, keeping spans balanced even
+      // when a flaky test is retried.
       if (channelContext !== null && testChannel.end.hasSubscribers) {
         publishEnd();
       }
+
+      // Decide whether to retry based on the resulting state, not on whether the
+      // attempt threw: a non-throwing failure via this.fail() must also be
+      // retried, and a failure that surfaces only through a subtest (promoted to
+      // the parent later, in postRun) is detected here so the parent still
+      // retries. An external abort and an expectFailure verdict stop retrying
+      // immediately.
+      const subtestsFailed = this.flakyRetries > 0 &&
+        ArrayPrototypeSome(this.subtests, (subtest) => !subtest.passed && !subtest.isTodo);
+      if (this.passed && !subtestsFailed) {
+        break;
+      }
+      const shouldRetry =
+        attempt < maxAttempts &&
+        (!this.passed || subtestsFailed) &&
+        !this.expectFailure &&
+        !(this.signal.aborted || this.outerSignal?.aborted);
+      if (!shouldRetry) {
+        break;
+      }
+      this.retriesTaken = attempt;
+    }
+
+    // Do not abort hooks and the root test as hooks instance are shared between tests suite so aborting them will
+    // cause them to not run for further tests.
+    if (this.parent !== null) {
+      this.abortController.abort();
     }
 
     if (this.parent !== null || typeof this.hookType === 'string') {
@@ -1547,6 +1685,12 @@ class Test extends AsyncResource {
       reporter.diagnostic(nesting, loc, `cancelled ${harness.counters.cancelled}`);
       reporter.diagnostic(nesting, loc, `skipped ${harness.counters.skipped}`);
       reporter.diagnostic(nesting, loc, `todo ${harness.counters.todo}`);
+      // Only surface the flaky counter when there were flaky test-cases, so the
+      // summary is unchanged for runs that do not use the feature (mirrors the
+      // conditional `coverage` summary line).
+      if (harness.counters.flaky > 0) {
+        reporter.diagnostic(nesting, loc, `flaky ${harness.counters.flaky}`);
+      }
       reporter.diagnostic(nesting, loc, `duration_ms ${duration}`);
 
       if (coverage) {
@@ -1638,6 +1782,13 @@ class Test extends AsyncResource {
         this.expectFailure.label :
         this.expectFailure;
       directive = this.reporter.getXFail(message);
+    } else if (this.flakyRetries > 0) {
+      // Emit the flaky directive for every flaky-marked test (retryCount may be
+      // 0 when it passed on the first attempt). Reporters only render `# FLAKY`
+      // when retryCount > 0, but always surfacing retryCount lets the
+      // run() process-isolation parent recognise and count flaky tests and
+      // classify an exhausted retried timeout as a failure, not cancelled.
+      directive = this.reporter.getFlaky(this.retriesTaken);
     }
 
     if (this.reportedType) {
@@ -1659,7 +1810,12 @@ class Test extends AsyncResource {
   report() {
     countCompletedTest(this);
     if (this.outputSubtestCount > 0) {
-      this.reporter.plan(this.subtests[0].nesting, this.loc, this.outputSubtestCount);
+      // `subtests` can be empty here when a flaky retry cleared it even though
+      // outputSubtestCount was non-zero; fall back to this test's own nesting
+      // rather than dereferencing subtests[0] (which would crash the run).
+      const subtestNesting = this.subtests.length ?
+        this.subtests[0].nesting : this.nesting + 1;
+      this.reporter.plan(subtestNesting, this.loc, this.outputSubtestCount);
     } else {
       this.reportStarted();
     }
diff --git a/lib/internal/test_runner/tests_stream.js b/lib/internal/test_runner/tests_stream.js
index 8be33f90dfa0f2..477fc1bb608d87 100644
--- a/lib/internal/test_runner/tests_stream.js
+++ b/lib/internal/test_runner/tests_stream.js
@@ -101,6 +101,10 @@ class TestsStream extends Readable {
     return { __proto__: null, expectFailure: expectation ?? true };
   }
 
+  getFlaky(retriesTaken = 0) {
+    return { __proto__: null, retryCount: retriesTaken };
+  }
+
   enqueue(nesting, loc, name, type, testId, parentId, tags) {
     this[kEmitMessage]('test:enqueue', {
       __proto__: null,
diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js
index 5a29673279311b..1542462c7ef4f6 100644
--- a/lib/internal/test_runner/utils.js
+++ b/lib/internal/test_runner/utils.js
@@ -506,6 +506,11 @@ function countCompletedTest(test, harness = test.root.harness) {
   } else {
     harness.counters.passed++;
   }
+  // `flaky` is an orthogonal counter: it counts every test-case marked flaky
+  // , regardless of whether it ultimately passed, failed, or was retried.
+  if (test.flakyRetries > 0) {
+    harness.counters.flaky++;
+  }
   harness.counters.tests++;
 }
 
diff --git a/test/fixtures/test-runner/flaky/after-final-attempt.js b/test/fixtures/test-runner/flaky/after-final-attempt.js
new file mode 100644
index 00000000000000..eb17935b48b50d
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/after-final-attempt.js
@@ -0,0 +1,20 @@
+'use strict';
+// A test-level `after` hook must run once, after the FINAL attempt - not after
+// the first failing attempt. The hook records the attempt number at which it
+// ran; the harness asserts it ran at the final (passing) attempt.
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { writeFileSync } = require('node:fs');
+
+const stateFile = process.env.FLAKY_STATE;
+let attempt = 0;
+
+test('after runs after the final attempt', { flaky: 3 }, (t) => {
+  attempt++;
+  if (attempt === 1) {
+    t.after(() => { writeFileSync(stateFile, String(attempt)); });
+  }
+  if (attempt < 3) {
+    assert.fail('force retry');
+  }
+});
diff --git a/test/fixtures/test-runner/flaky/api-surface.js b/test/fixtures/test-runner/flaky/api-surface.js
new file mode 100644
index 00000000000000..a1931505601283
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/api-surface.js
@@ -0,0 +1,42 @@
+'use strict';
+const test = require('node:test');
+const { describe, it, suite } = test;
+const assert = require('node:assert');
+
+function counterBody(getN, label) {
+  let n = 0;
+  return () => { n++; assert.strictEqual(n, getN(), label + ' attempt ' + n); };
+}
+
+// Form 1: describe.flaky shorthand suite; members inherit.
+describe.flaky('describe.flaky suite', () => {
+  let n = 0;
+  it('member inherits describe.flaky', () => { n++; assert.strictEqual(n, 2); });
+});
+
+// Form 2: it.flaky shorthand test-case.
+it.flaky('it.flaky case', (() => { let n = 0; return () => { n++; assert.strictEqual(n, 2); }; })());
+
+// Form 3: describe options form { flaky: true }; members inherit.
+describe('describe options suite', { flaky: true }, () => {
+  let n = 0;
+  it('member inherits options flaky', () => { n++; assert.strictEqual(n, 2); });
+});
+
+// Form 4: it options form, boolean.
+it('it options boolean', { flaky: true }, (() => { let n = 0; return () => { n++; assert.strictEqual(n, 2); }; })());
+
+// Form 5: it options form, positive integer.
+it('it options integer', { flaky: 100 }, (() => { let n = 0; return () => { n++; assert.strictEqual(n, 2); }; })());
+
+// Alias: test.flaky shorthand.
+test.flaky('test.flaky case', (() => { let n = 0; return () => { n++; assert.strictEqual(n, 2); }; })());
+
+// Alias: suite.flaky shorthand.
+suite.flaky('suite.flaky suite', () => {
+  let n = 0;
+  it('member inherits suite.flaky', () => { n++; assert.strictEqual(n, 2); });
+});
+
+// Alias: test('name', { flaky: N }, fn).
+test('test options integer', { flaky: 7 }, (() => { let n = 0; return () => { n++; assert.strictEqual(n, 2); }; })());
diff --git a/test/fixtures/test-runner/flaky/assert-before-plan.js b/test/fixtures/test-runner/flaky/assert-before-plan.js
new file mode 100644
index 00000000000000..ea1c4d01eb0715
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/assert-before-plan.js
@@ -0,0 +1,7 @@
+'use strict';
+const { test } = require('node:test');
+test('assert accessed before plan (non-flaky)', (t) => {
+  const a = t.assert;
+  t.plan(0);
+  a.ok(true);
+});
diff --git a/test/fixtures/test-runner/flaky/channel-silence.js b/test/fixtures/test-runner/flaky/channel-silence.js
new file mode 100644
index 00000000000000..664b89740713a2
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/channel-silence.js
@@ -0,0 +1,10 @@
+'use strict';
+const { test } = require('node:test');
+const dc = require('node:diagnostics_channel');
+const fs = require('node:fs');
+const stateFile = process.env.FLAKY_STATE;
+let errors = 0;
+dc.subscribe('tracing:node.test:error', () => { errors++; });
+let n = 0;
+test('eventually passes', { flaky: 5 }, () => { n++; if (n < 3) throw new Error('flaky'); });
+process.on('exit', () => { fs.writeFileSync(stateFile, String(errors)); });
diff --git a/test/fixtures/test-runner/flaky/counter.js b/test/fixtures/test-runner/flaky/counter.js
new file mode 100644
index 00000000000000..a82bdc12c1c6e1
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/counter.js
@@ -0,0 +1,5 @@
+'use strict';
+const { test } = require('node:test');
+test('flaky but passes first try', { flaky: 3 }, () => {});
+test('plain not flaky', () => {});
+test('flaky:true passes first try', { flaky: true }, () => {});
diff --git a/test/fixtures/test-runner/flaky/default-twenty-exhaust.js b/test/fixtures/test-runner/flaky/default-twenty-exhaust.js
new file mode 100644
index 00000000000000..8398c04694f858
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/default-twenty-exhaust.js
@@ -0,0 +1,8 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+let a = 0;
+test('needs 22 attempts', { flaky: true }, () => {
+  a++;
+  assert.strictEqual(a, 22); // 21 retries needed, but default is only 20
+});
diff --git a/test/fixtures/test-runner/flaky/default-twenty.js b/test/fixtures/test-runner/flaky/default-twenty.js
new file mode 100644
index 00000000000000..249e9a68626289
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/default-twenty.js
@@ -0,0 +1,8 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+let a = 0;
+test('passes on attempt 21', { flaky: true }, () => {
+  a++;
+  assert.strictEqual(a, 21);
+});
diff --git a/test/fixtures/test-runner/flaky/eventually-passes.js b/test/fixtures/test-runner/flaky/eventually-passes.js
new file mode 100644
index 00000000000000..810f8f61ab1bbe
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/eventually-passes.js
@@ -0,0 +1,9 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+let attempts = 0;
+test('passes on third attempt', { flaky: 5 }, (t) => {
+  attempts++;
+  t.diagnostic('attempt-' + attempts);
+  assert.strictEqual(attempts, 3, 'still flaky on attempt ' + attempts);
+});
diff --git a/test/fixtures/test-runner/flaky/exhausts.js b/test/fixtures/test-runner/flaky/exhausts.js
new file mode 100644
index 00000000000000..f306edbbe6f0f0
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/exhausts.js
@@ -0,0 +1,5 @@
+'use strict';
+const { test } = require('node:test');
+test('always fails', { flaky: 3 }, () => {
+  throw new Error('boom');
+});
diff --git a/test/fixtures/test-runner/flaky/expect-failure.js b/test/fixtures/test-runner/flaky/expect-failure.js
new file mode 100644
index 00000000000000..6d4a8e8fac8390
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/expect-failure.js
@@ -0,0 +1,8 @@
+'use strict';
+const { test } = require('node:test');
+const fs = require('node:fs');
+const stateFile = process.env.FLAKY_STATE;
+test('expected failure with flaky', { flaky: 5, expectFailure: true }, () => {
+  fs.appendFileSync(stateFile, 'x');
+  throw new Error('this failure is expected');
+});
diff --git a/test/fixtures/test-runner/flaky/expectfailure-no-retry.js b/test/fixtures/test-runner/flaky/expectfailure-no-retry.js
new file mode 100644
index 00000000000000..00cc3fd339fe37
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/expectfailure-no-retry.js
@@ -0,0 +1,12 @@
+'use strict';
+// A flaky + expectFailure test whose body does NOT throw (an unexpected pass)
+// must NOT be retried: expectFailure tests are not retried. The body appends one
+// byte per run; the harness then asserts it ran exactly once.
+const { test } = require('node:test');
+const { appendFileSync } = require('node:fs');
+
+const stateFile = process.env.FLAKY_STATE;
+
+test('flaky expectFailure unexpected pass', { flaky: 5, expectFailure: true }, () => {
+  appendFileSync(stateFile, 'x');
+});
diff --git a/test/fixtures/test-runner/flaky/expectfailure-publish.js b/test/fixtures/test-runner/flaky/expectfailure-publish.js
new file mode 100644
index 00000000000000..c2c32a798b1da5
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/expectfailure-publish.js
@@ -0,0 +1,21 @@
+'use strict';
+// A flaky + expectFailure test that throws (an expected failure, so the test
+// passes) must still publish its error to the `node.test` error channel exactly
+// as a non-flaky expectFailure test does. The fixture counts error publishes and
+// writes the total to the state file.
+const dc = require('node:diagnostics_channel');
+const { test } = require('node:test');
+const { writeFileSync } = require('node:fs');
+
+const stateFile = process.env.FLAKY_STATE;
+const channel = dc.tracingChannel('node.test');
+let errors = 0;
+channel.error.subscribe(() => { errors++; });
+
+test('flaky expectFailure throws', { flaky: 3, expectFailure: true }, () => {
+  throw new Error('this failure is expected');
+});
+
+process.on('exit', () => {
+  writeFileSync(stateFile, String(errors));
+});
diff --git a/test/fixtures/test-runner/flaky/external-abort.js b/test/fixtures/test-runner/flaky/external-abort.js
new file mode 100644
index 00000000000000..c76ba8f11d4093
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/external-abort.js
@@ -0,0 +1,11 @@
+'use strict';
+const { test } = require('node:test');
+const { setTimeout } = require('node:timers/promises');
+const fs = require('node:fs');
+const stateFile = process.env.FLAKY_STATE;
+const ac = new AbortController();
+test('aborted externally not retried', { flaky: 5, signal: ac.signal }, async () => {
+  fs.appendFileSync(stateFile, 'x');
+  ac.abort(); // user-driven cancellation
+  await setTimeout(10000, undefined, { signal: ac.signal });
+});
diff --git a/test/fixtures/test-runner/flaky/flaky-subtest.js b/test/fixtures/test-runner/flaky/flaky-subtest.js
new file mode 100644
index 00000000000000..96a0f5fbcf6927
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/flaky-subtest.js
@@ -0,0 +1,11 @@
+'use strict';
+const { it } = require('node:test');
+let n = 0;
+it.flaky('parent retries, subtest only on first attempt', { flaky: 3 }, async (t) => {
+  n++;
+  if (n < 2) {
+    await t.test('child', () => {});       // subtest passes on attempt 1
+    throw new Error('body fails on attempt 1'); // body throws -> parent retries
+  }
+  // attempt 2: no subtest, no throw -> passes
+});
diff --git a/test/fixtures/test-runner/flaky/hooks.js b/test/fixtures/test-runner/flaky/hooks.js
new file mode 100644
index 00000000000000..8149efdcadddd5
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/hooks.js
@@ -0,0 +1,17 @@
+'use strict';
+const { describe, it, before, after, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const stateFile = process.env.FLAKY_STATE;
+const counts = { before: 0, after: 0, beforeEach: 0, afterEach: 0, body: 0 };
+function dump() { fs.writeFileSync(stateFile, JSON.stringify(counts)); }
+describe('hook suite', () => {
+  before(() => { counts.before++; dump(); });
+  after(() => { counts.after++; dump(); });
+  beforeEach(() => { counts.beforeEach++; dump(); });
+  afterEach(() => { counts.afterEach++; dump(); });
+  it('passes on third attempt', { flaky: 5 }, () => {
+    counts.body++; dump();
+    assert.strictEqual(counts.body, 3);
+  });
+});
diff --git a/test/fixtures/test-runner/flaky/inheritance.js b/test/fixtures/test-runner/flaky/inheritance.js
new file mode 100644
index 00000000000000..082599ea4e6308
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/inheritance.js
@@ -0,0 +1,20 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+let inheritAttempts = 0;
+let overrideAttempts = 0;
+let disabledAttempts = 0;
+describe('flaky suite', { flaky: 5 }, () => {
+  it('inherits suite flaky', () => {
+    inheritAttempts++;
+    assert.strictEqual(inheritAttempts, 3); // needs 2 retries
+  });
+  it('overrides with own flaky', { flaky: 1 }, () => {
+    overrideAttempts++;
+    assert.strictEqual(overrideAttempts, 2); // passes on attempt 2 (1 retry)
+  });
+  it('opted out via flaky:false', { flaky: false }, () => {
+    disabledAttempts++;
+    assert.strictEqual(disabledAttempts, 99); // never reaches; must NOT retry
+  });
+});
diff --git a/test/fixtures/test-runner/flaky/mock-reset.js b/test/fixtures/test-runner/flaky/mock-reset.js
new file mode 100644
index 00000000000000..22338d76507350
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/mock-reset.js
@@ -0,0 +1,21 @@
+'use strict';
+// Each flaky retry must start from a clean MockTracker: a mock applied on a
+// failing attempt must be restored before the next attempt runs. The body reads
+// the method at entry (must be the real implementation) before re-mocking, and
+// fails the first two attempts to force retries.
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+let attempt = 0;
+const obj = { fn() { return 'real'; } };
+
+test('mock is reset between retries', { flaky: 3 }, (t) => {
+  attempt++;
+  const atEntry = obj.fn();
+  t.mock.method(obj, 'fn', () => 'mocked');
+  if (attempt < 3) {
+    assert.fail('force retry');
+  }
+  assert.strictEqual(atEntry, 'real',
+                     `attempt ${attempt} started with obj.fn()='${atEntry}', expected 'real'`);
+});
diff --git a/test/fixtures/test-runner/flaky/non-throw-retry.js b/test/fixtures/test-runner/flaky/non-throw-retry.js
new file mode 100644
index 00000000000000..84a1b6e6df7f7c
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/non-throw-retry.js
@@ -0,0 +1,12 @@
+'use strict';
+const { test } = require('node:test');
+let attempts = 0;
+test('non-throw failure retried', { flaky: 4 }, (t) => {
+  attempts++;
+  t.plan(1);
+  if (attempts < 2) {
+    t.assert.ok(false); // non-throwing assertion failure
+  } else {
+    t.assert.ok(true);
+  }
+});
diff --git a/test/fixtures/test-runner/flaky/parent-subtest-retry.js b/test/fixtures/test-runner/flaky/parent-subtest-retry.js
new file mode 100644
index 00000000000000..bba5f0c1062f94
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/parent-subtest-retry.js
@@ -0,0 +1,17 @@
+'use strict';
+// A flaky parent whose only failure comes from a SUBTEST must be retried: the
+// child fails on attempts 1-2 and passes on attempt 3, so the parent must keep
+// retrying and ultimately pass with retryCount === 2.
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+let attempt = 0;
+
+test('parent retries when subtest fails', { flaky: 3 }, async (t) => {
+  attempt++;
+  await t.test('child', () => {
+    if (attempt < 3) {
+      assert.fail(`child fails on attempt ${attempt}`);
+    }
+  });
+});
diff --git a/test/fixtures/test-runner/flaky/run-parent-summary.js b/test/fixtures/test-runner/flaky/run-parent-summary.js
new file mode 100644
index 00000000000000..9b1d62547e108a
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/run-parent-summary.js
@@ -0,0 +1,10 @@
+'use strict';
+const { test } = require('node:test');
+const { setTimeout } = require('node:timers/promises');
+test('flaky pass first try', { flaky: 3 }, () => {});
+test('flaky timeout exhausts', { flaky: 2, timeout: 200 }, async (t) => {
+  await setTimeout(1500, undefined, { signal: t.signal }).catch(() => {});
+});
+test('non-flaky timeout', { timeout: 200 }, async (t) => {
+  await setTimeout(1500, undefined, { signal: t.signal }).catch(() => {});
+});
diff --git a/test/fixtures/test-runner/flaky/shorthand-equals-options.js b/test/fixtures/test-runner/flaky/shorthand-equals-options.js
new file mode 100644
index 00000000000000..2605ab61277f1d
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/shorthand-equals-options.js
@@ -0,0 +1,7 @@
+'use strict';
+const { it } = require('node:test');
+const assert = require('node:assert');
+let a = 0;
+let b = 0;
+it.flaky('shorthand form', () => { a++; assert.strictEqual(a, 2); });
+it('options form', { flaky: true }, () => { b++; assert.strictEqual(b, 2); });
diff --git a/test/fixtures/test-runner/flaky/subtest-inflight.js b/test/fixtures/test-runner/flaky/subtest-inflight.js
new file mode 100644
index 00000000000000..67aa2c7b34466b
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/subtest-inflight.js
@@ -0,0 +1,17 @@
+'use strict';
+// A flaky parent that creates an unawaited (in-flight) subtest and then throws
+// must not corrupt the run: the in-flight subtest from a discarded attempt must
+// be settled before the retry resets per-attempt state. The parent passes on
+// the final attempt; the harness asserts the run completes with the correct
+// final result (the intermediate-attempt subtest leak is a known limitation).
+const { test } = require('node:test');
+
+let attempt = 0;
+
+test('flaky parent with in-flight subtest', { flaky: 3 }, (t) => {
+  attempt++;
+  t.test('child', () => new Promise((resolve) => setTimeout(resolve, 20)));
+  if (attempt < 3) {
+    throw new Error('retry');
+  }
+});
diff --git a/test/fixtures/test-runner/flaky/subtest-no-inherit.js b/test/fixtures/test-runner/flaky/subtest-no-inherit.js
new file mode 100644
index 00000000000000..7237ceee12c4ed
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/subtest-no-inherit.js
@@ -0,0 +1,9 @@
+'use strict';
+// flaky propagates from a suite to its test-cases, but NOT from a test to its
+// own subtests. Here a single flaky test owns one passing subtest and nothing
+// is retried, so exactly one test-case is flaky-marked => `# flaky 1`.
+const { test } = require('node:test');
+
+test('flaky parent', { flaky: 3 }, async (t) => {
+  await t.test('child', () => {});
+});
diff --git a/test/fixtures/test-runner/flaky/timeout-abort-prev.js b/test/fixtures/test-runner/flaky/timeout-abort-prev.js
new file mode 100644
index 00000000000000..f9c92884880639
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/timeout-abort-prev.js
@@ -0,0 +1,22 @@
+'use strict';
+// A retried flaky attempt must abort the previous attempt's signal so signal-
+// bound work is torn down. Attempt 1 times out (awaits a long signal-bound
+// timer); on the next attempt the body asserts the previous attempt's signal
+// was aborted, then returns to pass.
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { setTimeout } = require('node:timers/promises');
+
+let attempt = 0;
+let previousSignal = null;
+
+test('previous attempt signal is aborted before retry', { flaky: 3, timeout: 200 }, async (t) => {
+  attempt++;
+  if (attempt >= 2) {
+    assert.ok(previousSignal.aborted,
+              'the previous attempt signal must be aborted before the retry runs');
+    return;
+  }
+  previousSignal = t.signal;
+  await setTimeout(3000, undefined, { signal: t.signal }).catch(() => {});
+});
diff --git a/test/fixtures/test-runner/flaky/timeout-exhaust.js b/test/fixtures/test-runner/flaky/timeout-exhaust.js
new file mode 100644
index 00000000000000..82d0baab178405
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/timeout-exhaust.js
@@ -0,0 +1,11 @@
+'use strict';
+const { test } = require('node:test');
+const { setTimeout } = require('node:timers/promises');
+// Both always exceed the 200ms timeout; the wait is bound to the test signal so
+// the timer is torn down when the runner times the attempt out.
+test('flaky timeout exhausts => fail', { flaky: 2, timeout: 200 }, async (t) => {
+  await setTimeout(1500, undefined, { signal: t.signal }).catch(() => {});
+});
+test('non-flaky timeout stays cancelled', { timeout: 200 }, async (t) => {
+  await setTimeout(1500, undefined, { signal: t.signal }).catch(() => {});
+});
diff --git a/test/fixtures/test-runner/flaky/tracing-balance.js b/test/fixtures/test-runner/flaky/tracing-balance.js
new file mode 100644
index 00000000000000..a5e2d241ea30f8
--- /dev/null
+++ b/test/fixtures/test-runner/flaky/tracing-balance.js
@@ -0,0 +1,25 @@
+'use strict';
+// Every `node.test` tracing-channel `start` must be paired with an `end`, even
+// across flaky retries (each attempt is one span). The fixture subscribes to
+// both sub-channels and writes the final counts as "starts,ends".
+const dc = require('node:diagnostics_channel');
+const { test } = require('node:test');
+const { writeFileSync } = require('node:fs');
+
+const stateFile = process.env.FLAKY_STATE;
+const channel = dc.tracingChannel('node.test');
+let starts = 0;
+let ends = 0;
+channel.start.subscribe(() => { starts++; });
+channel.end.subscribe(() => { ends++; });
+
+let attempt = 0;
+test('retries twice then passes', { flaky: 3 }, () => {
+  if (++attempt < 3) {
+    throw new Error('retry');
+  }
+});
+
+process.on('exit', () => {
+  writeFileSync(stateFile, `${starts},${ends}`);
+});
diff --git a/test/fixtures/test-runner/output/flaky.js b/test/fixtures/test-runner/output/flaky.js
new file mode 100644
index 00000000000000..38c4b16e9280c3
--- /dev/null
+++ b/test/fixtures/test-runner/output/flaky.js
@@ -0,0 +1,40 @@
+'use strict';
+require('../../../common');
+const { describe, it, test } = require('node:test');
+const assert = require('node:assert');
+
+// Deterministic, counter-based fixture for the `flaky` snapshot/output test.
+// Each counter lives in module scope; retries happen in-process so the counter
+// advances across attempts without any timing nondeterminism.
+
+// Passes on the 3rd attempt (2 re-tries). Reports `# FLAKY 2 re-tries`.
+let passLate = 0;
+test('eventually passes', { flaky: 5 }, () => {
+  passLate++;
+  assert.strictEqual(passLate, 3);
+});
+
+// Marked flaky but passes on the first try: counted flaky, no re-tries directive.
+test('flaky passes first try', { flaky: 3 }, () => {});
+
+// A flaky suite: members inherit the suite's flaky budget.
+let suiteMember = 0;
+describe('flaky suite', { flaky: 4 }, () => {
+  it('member retried then passes', () => {
+    suiteMember++;
+    assert.strictEqual(suiteMember, 2);
+  });
+  it('member passes immediately', () => {});
+});
+
+// Shorthand form retried then passes.
+let shorthand = 0;
+it.flaky('shorthand retried', () => {
+  shorthand++;
+  assert.strictEqual(shorthand, 2);
+});
+
+// Exhausts its retry budget and fails. Reports `# FLAKY failed after 2 re-tries`.
+test('exhausts and fails', { flaky: 2 }, () => {
+  throw new Error('always boom');
+});
diff --git a/test/fixtures/test-runner/output/flaky.snapshot b/test/fixtures/test-runner/output/flaky.snapshot
new file mode 100644
index 00000000000000..7ee0e89aae9daa
--- /dev/null
+++ b/test/fixtures/test-runner/output/flaky.snapshot
@@ -0,0 +1,61 @@
+TAP version 13
+# Subtest: eventually passes
+ok 1 - eventually passes # FLAKY 2 re-tries
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: flaky passes first try
+ok 2 - flaky passes first try
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: flaky suite
+    # Subtest: member retried then passes
+    ok 1 - member retried then passes # FLAKY 1 re-try
+      ---
+      duration_ms: *
+      type: 'test'
+      ...
+    # Subtest: member passes immediately
+    ok 2 - member passes immediately
+      ---
+      duration_ms: *
+      type: 'test'
+      ...
+    1..2
+ok 3 - flaky suite
+  ---
+  duration_ms: *
+  type: 'suite'
+  ...
+# Subtest: shorthand retried
+ok 4 - shorthand retried # FLAKY 1 re-try
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: exhausts and fails
+not ok 5 - exhausts and fails # FLAKY failed after 2 re-tries
+  ---
+  duration_ms: *
+  type: 'test'
+  location: '<project-root>/test/fixtures/test-runner/output/flaky.js:38:1'
+  failureType: 'testCodeFailure'
+  error: 'always boom'
+  code: 'ERR_TEST_FAILURE'
+  stack: |-
+    TestContext.<anonymous> (<project-root>/test/fixtures/test-runner/output/flaky.js:39:9)
+    <node-internal-frames>
+  ...
+1..5
+# tests 6
+# suites 1
+# pass 5
+# fail 1
+# cancelled 0
+# skipped 0
+# todo 0
+# flaky 6
+# duration_ms *
diff --git a/test/parallel/test-runner-flaky.js b/test/parallel/test-runner-flaky.js
new file mode 100644
index 00000000000000..cd2a791a4fe955
--- /dev/null
+++ b/test/parallel/test-runner-flaky.js
@@ -0,0 +1,437 @@
+'use strict';
+// Tests for the test_runner `flaky` feature (retry-until-pass).
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+const assert = require('node:assert');
+const { writeFileSync } = require('node:fs');
+const { test, run } = require('node:test');
+
+tmpdir.refresh();
+
+let fixtureSeq = 0;
+function writeFixture(source) {
+  const file = tmpdir.resolve(`flaky-fixture-${fixtureSeq++}.js`);
+  writeFileSync(file, source);
+  return file;
+}
+
+// Collect the run() event stream for a fixture file, bucketed by test name.
+async function collectEvents(file, runOptions = {}) {
+  const events = { pass: [], fail: [], diagnostic: [] };
+  const stream = run({ files: [file], ...runOptions });
+  stream.on('test:pass', (data) => events.pass.push(data));
+  stream.on('test:fail', (data) => events.fail.push(data));
+  stream.on('test:diagnostic', (data) => events.diagnostic.push(data));
+  stream.on('test:stderr', common.mustNotCall());
+  // eslint-disable-next-line no-unused-vars
+  for await (const _ of stream);
+  return events;
+}
+
+function byName(list, name) {
+  return list.filter((d) => d.name === name);
+}
+
+async function tap(file) {
+  const { code, stdout, stderr } = await common.spawnPromisified(
+    process.execPath,
+    ['--test-reporter=tap', file],
+  );
+  return { code, stdout, stderr };
+}
+
+// Run a fixture through the run() API under the default 'process' isolation and
+// return the aggregated parent summary counters. Exercises the cross-process
+// path where the parent re-counts the child's serialized events (runner.js).
+async function runSummaryCounts(file, runOptions = {}) {
+  let counts;
+  const stream = run({ files: [file], ...runOptions });
+  stream.on('test:summary', (data) => { counts = data.counts; });
+  // eslint-disable-next-line no-unused-vars
+  for await (const _ of stream);
+  return counts;
+}
+
+function validate(flaky) {
+  return test(`flaky-validate-${String(flaky)}`, { flaky }, () => {});
+}
+
+test('flaky validation: wrong types throw ERR_INVALID_ARG_TYPE', () => {
+  for (const flaky of [Symbol(), {}, [], () => {}, 1n, '1', '5']) {
+    assert.throws(() => validate(flaky), { code: 'ERR_INVALID_ARG_TYPE' });
+  }
+});
+
+test('flaky validation: out-of-range values throw ERR_OUT_OF_RANGE', () => {
+  for (const flaky of [0, -1, -20, 1.5, 2.0001, NaN, Infinity, -Infinity]) {
+    assert.throws(() => validate(flaky), { code: 'ERR_OUT_OF_RANGE' });
+  }
+});
+
+test('flaky validation: true and positive integers are accepted', async () => {
+  for (const flaky of [null, undefined, true, false, 1, 2, 20, 100, 2 ** 20]) {
+    await validate(flaky); // Must not throw / reject for valid values.
+  }
+});
+
+test('flaky: passes after retries, retryCount on pass, silent intermediates', async () => {
+  const file = fixtures.path('test-runner/flaky/eventually-passes.js');
+  const events = await collectEvents(file);
+
+  const passes = byName(events.pass, 'passes on third attempt');
+  const fails = byName(events.fail, 'passes on third attempt');
+
+  assert.strictEqual(passes.length, 1, `expected 1 pass, got ${passes.length}`);
+  assert.strictEqual(fails.length, 0, `expected 0 fail events, got ${fails.length}`);
+  assert.strictEqual(passes[0].retryCount, 2);
+  const messages = events.diagnostic.map((d) => d.message);
+  assert.ok(messages.includes('attempt-3'), `missing final diagnostic; got ${messages}`);
+  assert.ok(!messages.includes('attempt-1'), `leaked intermediate diagnostic attempt-1: ${messages}`);
+  assert.ok(!messages.includes('attempt-2'), `leaked intermediate diagnostic attempt-2: ${messages}`);
+
+  const { code, stdout } = await tap(file);
+  assert.strictEqual(code, 0);
+  assert.match(stdout, /ok 1 - passes on third attempt # FLAKY 2 re-tries/);
+  assert.match(stdout, /# pass 1$/m);
+  assert.match(stdout, /# fail 0$/m);
+  assert.match(stdout, /# flaky 1$/m);
+});
+
+test('flaky: exhaustion => fail with retryCount on fail', async () => {
+  const file = fixtures.path('test-runner/flaky/exhausts.js');
+  const events = await collectEvents(file);
+
+  const fails = byName(events.fail, 'always fails');
+  const passes = byName(events.pass, 'always fails');
+  assert.strictEqual(passes.length, 0);
+  assert.strictEqual(fails.length, 1, `expected 1 fail, got ${fails.length}`);
+  assert.strictEqual(fails[0].retryCount, 3);
+
+  const { code, stdout } = await tap(file);
+  assert.strictEqual(code, 1);
+  assert.match(stdout, /not ok 1 - always fails # FLAKY failed after 3 re-tries/);
+  assert.match(stdout, /# fail 1$/m);
+  assert.match(stdout, /# flaky 1$/m);
+});
+
+test('flaky: non-throwing failure (t.fail/plan) is retried', async () => {
+  const file = fixtures.path('test-runner/flaky/non-throw-retry.js');
+  const events = await collectEvents(file);
+  const passes = byName(events.pass, 'non-throw failure retried');
+  const fails = byName(events.fail, 'non-throw failure retried');
+  assert.strictEqual(fails.length, 0);
+  assert.strictEqual(passes.length, 1);
+  assert.strictEqual(passes[0].retryCount, 1);
+});
+
+// The fixture runs as a spawned child and can't call common.platformTimeout
+// itself, so the budget is computed here and interpolated into the source. The
+// base is deliberately generous: attempt 2 is a no-op that must COMPLETE within
+// a fresh timeout window, and that bound does NOT stretch under load, so a tiny
+// budget could spuriously time out the no-op and break the retryCount === 1
+// equality below. platformTimeout() additionally covers known-slow platforms.
+const RETRY_TIMEOUT = common.platformTimeout(1000);
+// Attempt 1's delay must stay well above the timeout even after scaling; bind it
+// to t.signal so attempt 1 ends at ~timeout with no dangling timer.
+const RETRY_DELAY = RETRY_TIMEOUT * 10;
+const timeoutRetrySrc = `
+'use strict';
+const { test } = require('node:test');
+const { setTimeout } = require('node:timers/promises');
+let attempts = 0;
+test('slow first attempt then fast', { flaky: 3, timeout: ${RETRY_TIMEOUT} }, async (t) => {
+  attempts++;
+  if (attempts < 2) {
+    await setTimeout(${RETRY_DELAY}, undefined, { signal: t.signal }).catch(() => {});
+  }
+});
+`;
+
+test('flaky: timeout on first attempt is retried then passes', async () => {
+  const file = writeFixture(timeoutRetrySrc);
+  const events = await collectEvents(file);
+  const passes = byName(events.pass, 'slow first attempt then fast');
+  const fails = byName(events.fail, 'slow first attempt then fast');
+  assert.strictEqual(fails.length, 0, `timeout should be retried, got fails=${fails.length}`);
+  assert.strictEqual(passes.length, 1);
+  assert.strictEqual(passes[0].retryCount, 1);
+});
+
+test('flaky: exhausted timeout is FAIL, non-flaky timeout stays cancelled', async () => {
+  const file = fixtures.path('test-runner/flaky/timeout-exhaust.js');
+  await collectEvents(file);
+  const { code, stdout } = await tap(file);
+  assert.strictEqual(code, 1);
+  assert.match(stdout, /not ok \d+ - flaky timeout exhausts => fail # FLAKY failed after 2 re-tries/);
+  assert.match(stdout, /# cancelled 1$/m);
+  assert.match(stdout, /# flaky 1$/m);
+});
+
+test('flaky: external abort stops retrying, body runs once', async () => {
+  const file = fixtures.path('test-runner/flaky/external-abort.js');
+  const stateFile = tmpdir.resolve(`abort-state.txt`);
+  const { code, stdout, stderr } = await common.spawnPromisified(
+    process.execPath,
+    ['--test-reporter=tap', file],
+    { env: { ...process.env, FLAKY_STATE: stateFile } },
+  );
+  assert.strictEqual(stderr, '');
+  assert.strictEqual(code, 1);
+  const runs = require('node:fs').readFileSync(stateFile, 'utf8');
+  assert.strictEqual(runs.length, 1, `body ran ${runs.length} times, expected 1`);
+  assert.match(stdout, /# flaky 1$/m);
+  assert.doesNotMatch(stdout, /FLAKY failed after \d+ re-tries/);
+});
+
+test('flaky: beforeEach/afterEach re-run each attempt, before/after once', async () => {
+  const file = fixtures.path('test-runner/flaky/hooks.js');
+  const stateFile = tmpdir.resolve(`hooks-state.json`);
+  const { code, stderr } = await common.spawnPromisified(
+    process.execPath,
+    ['--test-reporter=tap', file],
+    { env: { ...process.env, FLAKY_STATE: stateFile } },
+  );
+  assert.strictEqual(stderr, '');
+  assert.strictEqual(code, 0);
+  const counts = JSON.parse(require('node:fs').readFileSync(stateFile, 'utf8'));
+  assert.strictEqual(counts.body, 3, `body should run once per attempt, got ${counts.body}`);
+  assert.strictEqual(counts.beforeEach, 3, `beforeEach per attempt, got ${counts.beforeEach}`);
+  assert.strictEqual(counts.afterEach, 3, `afterEach per attempt, got ${counts.afterEach}`);
+  assert.strictEqual(counts.before, 1, `before once, got ${counts.before}`);
+  assert.strictEqual(counts.after, 1, `after once, got ${counts.after}`);
+});
+
+test('flaky: suite inheritance, child override, child opt-out', async () => {
+  const file = fixtures.path('test-runner/flaky/inheritance.js');
+  const events = await collectEvents(file);
+
+  const inherit = byName(events.pass, 'inherits suite flaky');
+  assert.strictEqual(inherit.length, 1);
+  assert.strictEqual(inherit[0].retryCount, 2);
+
+  const override = byName(events.pass, 'overrides with own flaky');
+  assert.strictEqual(override.length, 1);
+  assert.strictEqual(override[0].retryCount, 1);
+
+  const disabledFail = byName(events.fail, 'opted out via flaky:false');
+  assert.strictEqual(disabledFail.length, 1);
+  assert.ok(!(disabledFail[0].retryCount > 0),
+            `opted-out test should not retry, got retryCount=${disabledFail[0].retryCount}`);
+
+  const { stdout } = await tap(file);
+  assert.match(stdout, /# flaky 2$/m);
+});
+
+test('flaky: summary counter counts marked-flaky incl. pass-first-try', async () => {
+  const file = fixtures.path('test-runner/flaky/counter.js');
+  const { code, stdout } = await tap(file);
+  assert.strictEqual(code, 0);
+  assert.match(stdout, /# pass 3$/m);
+  assert.match(stdout, /# flaky 2$/m);
+  assert.doesNotMatch(stdout, /flaky but passes first try # FLAKY/);
+});
+
+test('flaky:true defaults to 20 retries', async () => {
+  const file = fixtures.path('test-runner/flaky/default-twenty.js');
+  const events = await collectEvents(file);
+  const passes = byName(events.pass, 'passes on attempt 21');
+  const fails = byName(events.fail, 'passes on attempt 21');
+  assert.strictEqual(fails.length, 0);
+  assert.strictEqual(passes.length, 1);
+  assert.strictEqual(passes[0].retryCount, 20);
+});
+
+test('flaky:true exhausts at 20 retries when more are needed', async () => {
+  const file = fixtures.path('test-runner/flaky/default-twenty-exhaust.js');
+  const events = await collectEvents(file);
+  const fails = byName(events.fail, 'needs 22 attempts');
+  assert.strictEqual(fails.length, 1);
+  assert.strictEqual(fails[0].retryCount, 20);
+});
+
+test('flaky: expectFailure composes => no retry', async () => {
+  const file = fixtures.path('test-runner/flaky/expect-failure.js');
+  const stateFile = tmpdir.resolve(`xfail-state.txt`);
+  const { code, stdout, stderr } = await common.spawnPromisified(
+    process.execPath,
+    ['--test-reporter=tap', file],
+    { env: { ...process.env, FLAKY_STATE: stateFile } },
+  );
+  assert.strictEqual(stderr, '');
+  assert.strictEqual(code, 0);
+  const runs = require('node:fs').readFileSync(stateFile, 'utf8');
+  assert.strictEqual(runs.length, 1, `body ran ${runs.length} times, expected 1 (no retry)`);
+  assert.match(stdout, /# flaky 1$/m);
+  assert.doesNotMatch(stdout, /FLAKY \d+ re-tries/);
+});
+
+test('flaky: all API surface forms retry identically (forms 1-5 + aliases)', async () => {
+  const file = fixtures.path('test-runner/flaky/api-surface.js');
+  const events = await collectEvents(file);
+
+  // Each name maps to one proposal API form; all must behave identically.
+  const names = [
+    'member inherits describe.flaky', // Form 1: describe.flaky suite.
+    'member inherits options flaky',  // Form 3: describe('name', { flaky: true }).
+    'member inherits suite.flaky',    // Alias: suite.flaky suite.
+    'it.flaky case',                  // Form 2: it.flaky test-case.
+    'it options boolean',             // Form 4: it('name', { flaky: true }).
+    'it options integer',             // Form 5: it('name', { flaky: 100 }).
+    'test.flaky case',                // Alias: test.flaky.
+    'test options integer',           // Alias: test('name', { flaky: N }).
+  ];
+  for (const name of names) {
+    const passes = byName(events.pass, name);
+    const fails = byName(events.fail, name);
+    assert.strictEqual(fails.length, 0, `${name}: unexpected fail events`);
+    assert.strictEqual(passes.length, 1, `${name}: expected exactly one pass`);
+    assert.strictEqual(passes[0].retryCount, 1, `${name}: expected retryCount 1`);
+  }
+});
+
+test('flaky: it.flaky(...) === it(..., { flaky: true })', async () => {
+  const file = fixtures.path('test-runner/flaky/shorthand-equals-options.js');
+  const events = await collectEvents(file);
+  const shorthand = byName(events.pass, 'shorthand form');
+  const options = byName(events.pass, 'options form');
+  assert.strictEqual(shorthand.length, 1);
+  assert.strictEqual(options.length, 1);
+  assert.strictEqual(shorthand[0].retryCount, options[0].retryCount);
+  assert.strictEqual(shorthand[0].retryCount, 1);
+});
+
+test('flaky: run() parent counts flaky and promotes exhausted timeout to fail', async () => {
+  const file = fixtures.path('test-runner/flaky/run-parent-summary.js');
+  const counts = await runSummaryCounts(file);
+  assert.strictEqual(counts.failed, 1, `failed=${counts.failed}`);
+  assert.strictEqual(counts.cancelled, 1, `cancelled=${counts.cancelled}`);
+  assert.strictEqual(counts.flaky, 2, `flaky=${counts.flaky}`);
+});
+
+// A non-flaky test reads its plan once at registration, so accessing t.assert
+// before t.plan() must keep the historical counting (plan stays null, the later
+// assertion is not counted, plan(0) is satisfied => PASS). The dynamic plan read
+// added for flaky must not regress this; this guards that boundary.
+test('flaky: non-flaky assert-before-plan counting is unchanged', async () => {
+  const file = fixtures.path('test-runner/flaky/assert-before-plan.js');
+  const events = await collectEvents(file);
+  const name = 'assert accessed before plan (non-flaky)';
+  const fails = byName(events.fail, name);
+  assert.strictEqual(fails.length, 0, `non-flaky assert-before-plan must still pass, got ${fails.length} fail(s)`);
+  const passes = byName(events.pass, name);
+  assert.strictEqual(passes.length, 1);
+  assert.strictEqual(passes[0].retryCount, undefined);
+});
+
+test('flaky: intermediate retries do not publish to the node.test error channel', async () => {
+  const file = fixtures.path('test-runner/flaky/channel-silence.js');
+  const stateFile = tmpdir.resolve(`chan-state.txt`);
+  const { code, stderr } = await common.spawnPromisified(
+    process.execPath,
+    ['--test-reporter=tap', file],
+    { env: { ...process.env, FLAKY_STATE: stateFile } },
+  );
+  assert.strictEqual(stderr, '');
+  assert.strictEqual(code, 0);
+  const errors = require('node:fs').readFileSync(stateFile, 'utf8');
+  assert.strictEqual(errors, '0', `expected 0 channel errors for a passing flaky test, got ${errors}`);
+});
+
+// Flaky + subtests: a flaky test that creates a subtest on an early (failing)
+// attempt and none on the final (passing) attempt used to crash the reporter -
+// outputSubtestCount stayed > 0 while subtests was emptied on retry, so report()
+// dereferenced an empty array and the run aborted with no summary. It must now
+// complete normally.
+//
+// KNOWN LIMITATION: intermediate-attempt subtests are emitted to the reporter
+// stream before the retry decision, so they cannot be recalled - the output
+// still contains leaked intermediate subtest lines and slightly inflated
+// `# tests` counts. Fully fixing that needs buffering each attempt's subtest
+// events and replaying only the surviving attempt; until then this asserts only
+// that the run does not crash and the flaky parent ultimately passes.
+test('flaky+subtest: a retried flaky test with subtests does not crash the run', async () => {
+  const { code, stdout } = await tap(fixtures.path('test-runner/flaky/flaky-subtest.js'));
+  assert.match(stdout, /# tests \d+/, 'a summary must be emitted (no crash)');
+  assert.match(stdout, /^ok 1 - parent retries, subtest only on first attempt/m,
+               'the flaky parent passes after retrying');
+  assert.strictEqual(code, 0, `expected pass exit code, got ${code}`);
+});
+
+// Spawn a fixture under the TAP reporter with a FLAKY_STATE file it can write
+// to, and return the captured output plus the file's final contents.
+async function spawnFlaky(fixture, stateName) {
+  const stateFile = stateName ? tmpdir.resolve(stateName) : undefined;
+  const env = stateName ? { ...process.env, FLAKY_STATE: stateFile } : process.env;
+  const { code, stdout, stderr } = await common.spawnPromisified(
+    process.execPath, ['--test-reporter=tap', fixture], { env },
+  );
+  const state = stateFile ? require('node:fs').readFileSync(stateFile, 'utf8') : undefined;
+  return { code, stdout, stderr, state };
+}
+
+test('flaky: expectFailure that unexpectedly passes is not retried', async () => {
+  const { state } = await spawnFlaky(
+    fixtures.path('test-runner/flaky/expectfailure-no-retry.js'), 'xf-noretry.txt');
+  assert.strictEqual(state.length, 1, `body ran ${state.length}x; expectFailure must not retry`);
+});
+
+test('flaky: parent retries when only a subtest fails', async () => {
+  // The parent body never throws; the failure surfaces only through the child,
+  // which is promoted to the parent in postRun. The fix detects that before the
+  // retry decision, so the parent retries until the child passes (attempt 3) and
+  // its pass carries retryCount === 2. (Leaked intermediate-attempt children are
+  // the separate, documented subtest-output limitation, so this asserts only the
+  // parent's retry outcome via the run() event stream.)
+  const events = await collectEvents(fixtures.path('test-runner/flaky/parent-subtest-retry.js'));
+  const passes = byName(events.pass, 'parent retries when subtest fails');
+  assert.strictEqual(passes.length, 1, `the flaky parent must ultimately pass, got ${passes.length}`);
+  assert.strictEqual(passes[0].retryCount, 2,
+                     `parent retried until the subtest passed; retryCount=${passes[0].retryCount}`);
+});
+
+test('flaky: tracing channel start/end stay balanced across retries', async () => {
+  const { state } = await spawnFlaky(
+    fixtures.path('test-runner/flaky/tracing-balance.js'), 'tracing.txt');
+  const { 0: starts, 1: ends } = state.split(',');
+  assert.strictEqual(starts, ends, `tracing start/end imbalance: starts=${starts} ends=${ends}`);
+});
+
+test('flaky: a flaky test does not propagate flakiness to its subtests', async () => {
+  const { stdout } = await tap(fixtures.path('test-runner/flaky/subtest-no-inherit.js'));
+  assert.match(stdout, /# flaky 1$/m);
+  assert.doesNotMatch(stdout, /# flaky 2$/m);
+});
+
+test('flaky: MockTracker is reset between retries', async () => {
+  const { code, stdout } = await tap(fixtures.path('test-runner/flaky/mock-reset.js'));
+  assert.match(stdout, /^ok 1 - mock is reset between retries/m);
+  assert.strictEqual(code, 0, `mock must be restored each retry, got exit ${code}`);
+});
+
+test('flaky: test-level after hook runs after the final attempt', async () => {
+  const { code, state } = await spawnFlaky(
+    fixtures.path('test-runner/flaky/after-final-attempt.js'), 'after-final.txt');
+  assert.strictEqual(state, '3', `after ran at attempt ${state}; expected the final attempt (3)`);
+  assert.strictEqual(code, 0);
+});
+
+test('flaky: a retried attempt aborts the previous attempt signal', async () => {
+  const { code, stdout } = await tap(fixtures.path('test-runner/flaky/timeout-abort-prev.js'));
+  assert.match(stdout, /^ok 1 - previous attempt signal is aborted before retry/m);
+  assert.strictEqual(code, 0, `previous attempt signal must be aborted, got exit ${code}`);
+});
+
+test('flaky: in-flight subtest on a discarded attempt does not corrupt the run', async () => {
+  const { code, stdout } = await tap(fixtures.path('test-runner/flaky/subtest-inflight.js'));
+  assert.match(stdout, /# tests \d+/, 'a summary must be emitted (no crash/hang)');
+  assert.strictEqual(code, 0, `the flaky parent must ultimately pass, got exit ${code}`);
+});
+
+test('flaky: expectFailure error is still published to the node.test channel', async () => {
+  const { code, state } = await spawnFlaky(
+    fixtures.path('test-runner/flaky/expectfailure-publish.js'), 'xf-publish.txt');
+  assert.ok(Number(state) > 0, `error channel got ${state} publishes; expected > 0`);
+  assert.strictEqual(code, 0, `expectFailure throw => test passes, got exit ${code}`);
+});
diff --git a/test/test-runner/test-output-flaky.mjs b/test/test-runner/test-output-flaky.mjs
new file mode 100644
index 00000000000000..a5f9f78fbfaeba
--- /dev/null
+++ b/test/test-runner/test-output-flaky.mjs
@@ -0,0 +1,12 @@
+// Test that the output of test-runner/output/flaky.js matches
+// test-runner/output/flaky.snapshot
+import '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import { spawnAndAssert, defaultTransform, ensureCwdIsProjectRoot } from '../common/assertSnapshot.js';
+
+ensureCwdIsProjectRoot();
+await spawnAndAssert(
+  fixtures.path('test-runner/output/flaky.js'),
+  defaultTransform,
+  { flags: ['--test-reporter=tap'] },
+);