diff --git a/doc/api/test.md b/doc/api/test.md
index c58d59d6717812..803ff2d5983a41 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -351,6 +351,85 @@ it.todo('should do the thing', { expectFailure: true }, () => {
 });
 ```
 
+## Flaky tests
+
+This flag causes a test or suite to be re-run a number of times until it
+either passes or has not passed after the final re-try.
+
+When `flaky` is `true`, the test harness re-tries the test up to the default
+number of times (20), inclusive.
+
+When `flaky` is a positive integer, the test harness re-tries the test up to
+the specified number of times, inclusive.
+
+When `flaky` is falsy (the default), the test harness does not re-try the test.
+
+When both a suite and an included test specify the `flaky` flag, the
+test's `flaky` value wins.
+
+```js
+it.flaky('should do something', () => {
+  // This test will be retried up to 20 times if it fails
+});
+
+it('may take several times', { flaky: true }, () => {
+  // Also retries up to 20 times
+});
+
+it('may also take several times', { flaky: 5 }, () => {
+  // Retries up to 5 times
+});
+
+describe.flaky('flaky suite', () => {
+  it('inherits flaky from suite', () => {
+    // Retried up to 20 times (inherited from suite)
+  });
+
+  it('not flaky', { flaky: false }, () => {
+    // Not retried, overrides suite setting
+  });
+});
+```
+
+When a test marked `flaky` passes after retries, the number of re-tries taken
+is reported with that test.
+
+`skip` and `todo` take precedence over `flaky`.
+
+## `describe()` and `it()` aliases
+
+Suites and tests can also be written using the `describe()` and `it()`
+functions. [`describe()`][] is an alias for [`suite()`][], and [`it()`][] is an
+alias for [`test()`][].
+
+```js
+describe('A thing', () => {
+  it('should work', () => {
+    assert.strictEqual(1, 1);
+  });
+
+  it('should be ok', () => {
+    assert.strictEqual(2, 2);
+  });
+
+  describe('a nested thing', () => {
+    it('should work', () => {
+      assert.strictEqual(3, 3);
+    });
+  });
+});
+```
+
+`describe()` and `it()` are imported from the `node:test` module.
+
+```mjs
+import { describe, it } from 'node:test';
+```
+
+```cjs
+const { describe, it } = require('node:test');
+```
+
 ## `only` tests
 
 If Node.js is started with the [`--test-only`][] command-line option, or test
@@ -1793,6 +1872,16 @@ added:
 Shorthand for marking a suite as `only`. This is the same as
 [`suite([name], { only: 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].
+
 ## `test([name][, options][, fn])`
 
 <!-- YAML
@@ -1828,6 +1917,10 @@ changes:
     thread. If `false`, only one test runs at a time.
     If unspecified, subtests inherit this value from their parent.
     **Default:** `false`.
+  * `flaky` {boolean|number} If truthy, the test is re-tried up to the
+    specified number of times (or `20` if `true`) until it passes. If the test
+    passes after retries, the number of retries taken is reported. When both a
+    suite and an included test specify the `flaky` flag, the test's value wins.
   * `expectFailure` {boolean|string|RegExp|Function|Object|Error} If truthy, the
     test is expected to fail. If a non-empty string is provided, that string is displayed
     in the test results as the reason why the test is expected to fail. If a {RegExp|Function|Object|Error}
@@ -1907,6 +2000,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()`][].
@@ -1934,6 +2037,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
@@ -1973,6 +2086,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
@@ -3527,6 +3650,8 @@ 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 taken for a
+    flaky test. Present when a test is marked as flaky.
 
 Emitted when a test fails.
 This event is guaranteed to be emitted in the same order as the tests are
@@ -3586,6 +3711,8 @@ 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 taken for a
+    flaky test. Present when a test is marked as flaky and passed after retries.
 
 Emitted when a test passes.
 This event is guaranteed to be emitted in the same order as the tests are
@@ -4362,6 +4489,9 @@ changes:
     If `false`, it would only run one test at a time.
     If unspecified, subtests inherit this value from their parent.
     **Default:** `null`.
+  * `flaky` {boolean|number} If truthy, the test is re-tried up to the
+    specified number of times (or `20` if `true`) until it passes.
+    **Default:** `false`.
   * `only` {boolean} If truthy, and the test context is configured to run
     `only` tests, then this test will be run. Otherwise, the test is skipped.
     **Default:** `false`.
diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js
index fed3d3a49a241f..1527e2700954d1 100644
--- a/lib/internal/test_runner/harness.js
+++ b/lib/internal/test_runner/harness.js
@@ -62,6 +62,7 @@ function createTestTree(rootTestOptions, globalOptions) {
         failed: 0,
         passed: 0,
         cancelled: 0,
+        flaky: 0,
         skipped: 0,
         todo: 0,
         topLevel: 0,
@@ -404,7 +405,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..ceaa749babcaf9 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}`;
+      if (data.retryCount > 0) {
+        yield `${colors.yellow}F${colors.reset}`;
+      } else {
+        yield `${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..cdefc9e88078e1 100644
--- a/lib/internal/test_runner/reporter/junit.js
+++ b/lib/internal/test_runner/reporter/junit.js
@@ -131,6 +131,26 @@ 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..a048cd657fde25 100644
--- a/lib/internal/test_runner/reporter/tap.js
+++ b/lib/internal/test_runner/reporter/tap.js
@@ -33,12 +33,12 @@ 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 +75,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 +88,9 @@ 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 !== undefined && retryCount > 0) {
+    const retryText = retryCount === 1 ? 're-try' : 're-tries';
+    line += ` # FLAKY ${retryCount} ${retryText}`;
   }
 
   line += '\n';
diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
index d90040b9727aa2..990bcfaf55d693 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}` : '';
   let title = `${data.name}${duration_ms}`;
 
@@ -87,6 +87,9 @@ function formatTestReport(type, data, showErrorDetails = true, prefix = '', inde
     }
   } else if (expectFailure !== undefined) {
     title += ` # EXPECTED FAILURE`;
+  } else if (retryCount !== undefined && retryCount > 0) {
+    const retryText = retryCount === 1 ? 're-try' : 're-tries';
+    title += ` # FLAKY ${retryCount} ${retryText}`;
   }
 
   const err = showErrorDetails && data.details?.error ? formatError(data.details.error, indent) : '';
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index ca23a94000c4b8..a627907673225c 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -14,6 +14,7 @@ const {
   MathFloor,
   MathMax,
   Number,
+  NumberIsInteger,
   NumberPrototypeToFixed,
   ObjectKeys,
   ObjectSeal,
@@ -92,6 +93,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']);
@@ -554,7 +556,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, timeout, todo, skip, signal, plan } = options;
 
     if (typeof fn !== 'function') {
       fn = noop;
@@ -697,6 +699,24 @@ class Test extends AsyncResource {
     this.expectedAssertions = plan;
     this.cancelled = false;
     this.expectFailure = parseExpectFailure(expectFailure) || this.parent?.expectFailure;
+
+    // Validate and process flaky option
+    if (flaky != null && flaky !== false) {
+      this.flakyRetries = flaky === true ? kDefaultFlakyRetries : flaky;
+      if (!NumberIsInteger(this.flakyRetries) || this.flakyRetries < 1) {
+        throw new ERR_INVALID_ARG_TYPE(
+          'options.flaky',
+          ['boolean', 'positive integer'],
+          flaky,
+        );
+      }
+    } else if (flaky === undefined && this.parent?.flakyRetries > 0) {
+      // Inherit flaky from parent suite
+      this.flakyRetries = this.parent.flakyRetries;
+    } else {
+      this.flakyRetries = 0;
+    }
+    this.retriesTaken = 0;
     this.skipped = skip !== undefined && skip !== false;
     this.isTodo = (todo !== undefined && todo !== false) || this.parent?.isTodo;
     this.startTime = null;
@@ -1278,50 +1298,71 @@ class Test extends AsyncResource {
 
       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);
-        } else {
-          ArrayPrototypePush(promises, PromiseResolve(promise));
+      const maxAttempts = this.flakyRetries > 0 ? this.flakyRetries + 1 : 1;
+
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (attempt > 1) {
+          this.error = null;
+          this.passed = false;
         }
-      } else {
-        // This test is synchronous or using Promises.
-        const promise = ReflectApply(this.runInAsyncScope, this, runArgs);
-        ArrayPrototypePush(promises, PromiseResolve(promise));
-      }
 
-      ArrayPrototypePush(promises, stopPromise);
+        try {
+          const runArgs = ArrayPrototypeSlice(args);
+          ArrayPrototypeUnshift(runArgs, this.fn, 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);
+            } else {
+              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);
 
-      // 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();
+          break;
+        } catch (attemptErr) {
+          if (attempt < maxAttempts) {
+            this.retriesTaken = attempt;
+            continue;
+          }
+          throw attemptErr;
         }
       }
-
-      this.pass();
       await afterEach();
       await after();
     } catch (err) {
@@ -1466,6 +1507,7 @@ 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}`);
+      reporter.diagnostic(nesting, loc, `flaky ${harness.counters.flaky}`);
       reporter.diagnostic(nesting, loc, `duration_ms ${duration}`);
 
       if (coverage) {
@@ -1556,7 +1598,9 @@ class Test extends AsyncResource {
       const message = typeof this.expectFailure === 'object' ?
         this.expectFailure.label :
         this.expectFailure;
-      directive = this.reporter.getXFail(message);
+      directive = this.reporter.getXFail(message); // TODO(@JakobJingleheimer): support specifying failure
+    } else if (this.flakyRetries > 0 && this.retriesTaken > 0 && this.passed) {
+      directive = this.reporter.getFlaky(this.retriesTaken);
     }
 
     if (this.reportedType) {
diff --git a/lib/internal/test_runner/tests_stream.js b/lib/internal/test_runner/tests_stream.js
index 073845829451c3..8e0a22bfdfef1a 100644
--- a/lib/internal/test_runner/tests_stream.js
+++ b/lib/internal/test_runner/tests_stream.js
@@ -94,6 +94,10 @@ class TestsStream extends Readable {
     return { __proto__: null, expectFailure: expectation ?? true };
   }
 
+  getFlaky(retriesTaken = undefined) {
+    return { __proto__: null, retryCount: retriesTaken ?? 0 };
+  }
+
   enqueue(nesting, loc, name, type, testId) {
     this[kEmitMessage]('test:enqueue', {
       __proto__: null,
diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js
index 831cb07d512e93..351131afd680ea 100644
--- a/lib/internal/test_runner/utils.js
+++ b/lib/internal/test_runner/utils.js
@@ -471,6 +471,10 @@ function countCompletedTest(test, harness = test.root.harness) {
   } else {
     harness.counters.passed++;
   }
+
+  if (test.flakyRetries > 0) {
+    harness.counters.flaky++;
+  }
   harness.counters.tests++;
 }
 
diff --git a/test/fixtures/test-runner/output/flaky.js b/test/fixtures/test-runner/output/flaky.js
new file mode 100644
index 00000000000000..69a8973159d5e0
--- /dev/null
+++ b/test/fixtures/test-runner/output/flaky.js
@@ -0,0 +1,68 @@
+// Flags: --test-reporter=tap
+'use strict';
+require('../../../common');
+const { test, describe, it } = require('node:test');
+
+// Track invocation count for flaky tests
+let flakyTestInvocations = 0;
+let flakyTestMethodInvocations = 0;
+let flakyTestAlwaysFails = 0;
+
+// Test that passes after 2 retries (3rd attempt succeeds)
+test('flaky test that passes on retry', { flaky: 5 }, () => {
+  flakyTestInvocations++;
+  if (flakyTestInvocations < 3) {
+    throw new Error('Simulated failure');
+  }
+  // Passes on 3rd attempt
+});
+
+// Test using method syntax
+it.flaky('flaky test using method syntax', () => {
+  flakyTestMethodInvocations++;
+  if (flakyTestMethodInvocations < 2) {
+    throw new Error('Simulated failure');
+  }
+  // Passes on 2nd attempt
+});
+
+// Test that always fails (exhausts retries)
+test('flaky test that always fails', { flaky: 3 }, () => {
+  flakyTestAlwaysFails++;
+  throw new Error(`Always fails (attempt ${flakyTestAlwaysFails})`);
+});
+
+// Test with flaky: true (should use default 20)
+test('flaky test with true value', { flaky: true }, () => {
+  // This one passes immediately
+});
+
+// Suite with flaky option
+describe.flaky('flaky suite', () => {
+  it('inherits flaky from suite', () => {
+    // Passes immediately
+  });
+
+  it('override flaky in test', { flaky: false }, () => {
+    // Not flaky despite suite being flaky
+  });
+});
+
+// Invalid flaky values should error
+try {
+  test('invalid flaky value -1', { flaky: -1 }, () => {});
+} catch (err) {
+  console.log('Expected error for negative flaky:', err.message);
+}
+
+try {
+  test('invalid flaky value 0', { flaky: 0 }, () => {});
+} catch (err) {
+  console.log('Expected error for zero flaky:', err.message);
+}
+
+try {
+  test('invalid flaky value string', { flaky: 'invalid' }, () => {});
+} catch (err) {
+  console.log('Expected error for string flaky:', err.message);
+}
diff --git a/test/fixtures/test-runner/output/flaky.snapshot b/test/fixtures/test-runner/output/flaky.snapshot
new file mode 100644
index 00000000000000..5d2b8aeaf14849
--- /dev/null
+++ b/test/fixtures/test-runner/output/flaky.snapshot
@@ -0,0 +1,69 @@
+TAP version 13
+# Subtest: flaky test that passes on retry
+ok 1 - flaky test that passes on retry # FLAKY 2 re-tries
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: flaky test using method syntax
+ok 2 - flaky test using method syntax # FLAKY 1 re-try
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: flaky test that always fails
+not ok 3 - flaky test that always fails
+  ---
+  duration_ms: *
+  type: 'test'
+  location: '/test/fixtures/test-runner/output/flaky.js:(LINE):1'
+  failureType: 'testCodeFailure'
+  error: 'Always fails (attempt 4)'
+  code: 'ERR_TEST_FAILURE'
+  stack: |-
+    *
+    *
+    *
+    *
+    *
+    *
+    *
+  ...
+# Subtest: flaky test with true value
+ok 4 - flaky test with true value
+  ---
+  duration_ms: *
+  type: 'test'
+  ...
+# Subtest: flaky suite
+    # Subtest: inherits flaky from suite
+    ok 1 - inherits flaky from suite
+      ---
+      duration_ms: *
+      type: 'test'
+      ...
+    # Subtest: override flaky in test
+    ok 2 - override flaky in test
+      ---
+      duration_ms: *
+      type: 'test'
+      ...
+    1..2
+ok 5 - flaky suite
+  ---
+  duration_ms: *
+  type: 'suite'
+  ...
+Expected error for negative flaky: *
+Expected error for zero flaky: *
+Expected error for string flaky: *
+1..5
+# tests 6
+# suites 1
+# pass 5
+# fail 1
+# cancelled 0
+# skipped 0
+# todo 0
+# flaky 5
+# duration_ms *
diff --git a/test/test-runner/test-output-flaky.mjs b/test/test-runner/test-output-flaky.mjs
new file mode 100644
index 00000000000000..55ac25c8dde232
--- /dev/null
+++ b/test/test-runner/test-output-flaky.mjs
@@ -0,0 +1,11 @@
+// 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'] },
+);