diff --git a/.changeset/code-quality-test-discipline.md b/.changeset/code-quality-test-discipline.md
new file mode 100644
index 0000000..c4b11aa
--- /dev/null
+++ b/.changeset/code-quality-test-discipline.md
@@ -0,0 +1,17 @@
+---
+'@noctcore/eslint-plugin-code-quality': minor
+---
+
+Four new opt-in test-discipline rules and two stricter existing rules.
+
+**A project that spreads `recommended` sees new errors from two rules it already runs:**
+
+- `no-vacuous-expect` now reports a test whose only assertion is that the render root is present (`soleRenderRootExpect`): `expect(container).not.toBeEmptyDOMElement()`, `expect(container.firstChild).toBeInTheDocument()`, `expect(container.innerHTML).not.toBe('')` and the like, on a `container` or `baseElement` bound from a call (`const { container } = render(...)`, `view.container`, `render(...).container`). Such a test passes for anything that renders, an error fallback included. Assert on a role, a label or a text instead, or set the new `renderRoots` option to `[]` to keep the old behaviour.
+- `skipped-tests-need-tracking` now also reads `node:test` skips: a `skip` or `todo` option whose value is a truthy literal (`{ skip: true }`, `{ skip: 'reason' }`, `{ todo: 1 }`) on `test` / `it` / `describe` / `suite` (and a `t.test` subtest), and `t.skip()` / `t.todo()` (awaited or not) as a statement of the test callback's own body. Only unconditional skips are reported: a computed value (`{ skip: process.platform === 'win32' }`, `{ skip: !ready }`) or a `t.skip(...)` inside an `if` is a platform guard and stays silent. Add an issue URL or `TODO(@owner)` near the skip, as for `.skip(`.
+
+**New rules, left out of `recommended`** (each needs a per-project fact; enabling them is up to you):
+
+- `no-message-only-throw-assertion`: `toThrow()` / `toThrowError()` with no argument, or with only a string, template or regex, and the message snapshots `toThrowErrorMatchingSnapshot()` / `toThrowErrorMatchingInlineSnapshot()`, sync or after `.rejects`. Any error passes those, including a `TypeError` from a broken mock. A class argument, an asymmetric matcher, `.rejects.toMatchObject(...)` and `.not.toThrow()` are fine, and a message-only assertion is accepted when the same test pins the class of the same subject in the same or an enclosing block (a bare `toThrow()` is never excused that way). Options: `throwMatchers`, `allowMessageOnly` (report only the argless form), `trustErrorInstances` (set `false` under Jest, where `toThrow(new X('m'))` and `.rejects.toEqual(new X('m'))` compare only the message; a `.rejects.toMatchObject({ message })` or `toHaveProperty('message')` is never a class pin) and `assertionHelpers`.
+- `no-sleep-in-unit-tests`: a real sleep in a unit test file: `new Promise((r) => setTimeout(r, n))`, `setTimeout` from `timers/promises`, and `promisify(setTimeout)`. A zero or omitted delay (`allowZeroDelay`, on by default) a reject-only timeout guard and a deadline whose kept handle the file passes to `clearTimeout` are not sleeps, and a file that installs fake timers (`fakeTimerMethods`, default `useFakeTimers`) is not checked, since its waits are virtual. Same `testFileSuffixes` / `integrationMarkers` options as `no-real-network-in-unit-tests`.
+- `no-real-clock-in-unit-tests`: `Date.now()`, an argless `new Date()` and `Date()` in a unit test file that never fakes the clock (`useFakeTimers`, `setSystemTime`, a `Date.now` spy, a stubbed or replaced global `Date`, or a mocked module matching `clockModules`). An offset from now (`Date.now() + 60_000`, `new Date().getTime() - 1000`) is allowed.
+- `typed-mock-over-double-cast`: an object literal containing `jest.fn()` / `vi.fn()` cast `as unknown as T` (or through `any` or `never`, in `as` or angle-bracket form). Type it as `jest.Mocked<Pick<T, ...>>` or check it with `satisfies`. Options: `mockFactories`, `allowTargets` for types too wide to `Pick` from.
diff --git a/packages/eslint-plugin-code-quality/README.md b/packages/eslint-plugin-code-quality/README.md
index 23480f0..45f4a0d 100644
--- a/packages/eslint-plugin-code-quality/README.md
+++ b/packages/eslint-plugin-code-quality/README.md
@@ -46,7 +46,10 @@ export default [
 
 ## Opt-in rules
 
-Two rules are exported but left out of `recommended`: they are house style, not correctness.
+Some rules are exported but left out of `recommended`. `interface-prefix-i` and
+`no-template-trim-empty-ternary` are house style, not correctness. The test-discipline rules in the
+second block need a per-project fact before they are precise, such as which files are unit tests,
+so each one takes its options from your project.
 
 ```js
 // eslint.config.js
@@ -60,6 +63,24 @@ export default [
       'noctcore-code-quality/no-template-trim-empty-ternary': 'error',
     },
   },
+  {
+    files: ['**/*.{test,spec}.{ts,tsx}'],
+    languageOptions: { parser: tsParser },
+    rules: {
+      'noctcore-code-quality/no-message-only-throw-assertion': ['error', {
+        assertionHelpers: ['^expectRejectsDomainError$'],
+      }],
+      'noctcore-code-quality/no-sleep-in-unit-tests': ['error', {
+        integrationMarkers: ['.integration.', '/e2e/'],
+      }],
+      'noctcore-code-quality/no-real-clock-in-unit-tests': ['error', {
+        clockModules: ['**/common/clock'],
+      }],
+      'noctcore-code-quality/typed-mock-over-double-cast': ['error', {
+        allowTargets: ['PrismaService'],
+      }],
+    },
+  },
 ];
 ```
 
@@ -79,15 +100,19 @@ export default [
 | [`no-elided-code-comments`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-elided-code-comments/) | Disallow comments that stand in for elided code ('// ... existing code ...', '// rest of the function unchanged', '// your code here'). They are what an agent leaves when it rewrites a file from an abbreviated draft, and the code they replaced has usually been deleted. | ✅ |  |  |  |  |
 | [`no-focused-tests`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-focused-tests/) | Ban focused tests (it.only / describe.only / test.only, fdescribe / fit / ddescribe) so a focused test never silently lands in CI. | ✅ |  |  |  |  |
 | [`no-historical-comments`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-historical-comments/) | Disallow comments that frame code relative to what it used to do or to a past incident ('before the fix', 'after the refactor', 'we used to', 'no longer'). Source comments describe the current invariant; history belongs in the commit message or PR description, where it does not rot when the code changes again. | ✅ |  |  |  |  |
+| [`no-message-only-throw-assertion`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-message-only-throw-assertion/) | Disallow `toThrow()` with no argument or with only a message: any error passes, including a `TypeError` from a broken mock. Pin the error class. | 🔘 |  |  |  |  |
 | [`no-narration-comments`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-narration-comments/) | Disallow narrative comments like 'Here we...', 'Now we...', 'First, we...'. These read as step-by-step prose and add no information a future reader cannot get from the code itself. Often a tell that the comment was generated by an agent describing its own changes. | ✅ |  |  |  |  |
 | [`no-pr-reference-comments`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-pr-reference-comments/) | Disallow PR/issue references in comments. They belong in commit messages and PR descriptions, where they do not rot when the repo moves, the issue tracker migrates, or the numbering changes. | ✅ |  |  |  |  |
 | [`no-process-exit`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-process-exit/) | Disallow `process.exit()` outside bootstrap/shutdown paths and standalone CLIs. Application and service code must throw or reject so the lifecycle can shut down gracefully. | ✅ |  |  |  |  |
+| [`no-real-clock-in-unit-tests`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-real-clock-in-unit-tests/) | Unit tests must not read the real clock (`Date.now()`, `new Date()`) unless the file fakes it; an offset from now (`Date.now() + 60_000`) is allowed. | 🔘 |  |  |  |  |
 | [`no-real-network-in-unit-tests`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-real-network-in-unit-tests/) | Unit tests must not perform real network I/O: mock the HTTP client, or move the test to an integration suite. | ✅ |  |  |  |  |
+| [`no-sleep-in-unit-tests`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-sleep-in-unit-tests/) | Unit tests must not sleep on the real clock (`new Promise((r) => setTimeout(r, n))`, `timers/promises`): fake the timers or wait for the condition. | 🔘 |  |  |  |  |
 | [`no-swallowed-assertion`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-swallowed-assertion/) | Disallow assertions inside a `try` whose `catch` neither rethrows nor asserts, and `.catch()` handlers that swallow an `expect(...).rejects`/`.resolves` failure: the assertion fails, the error is dropped, and the test passes. | ✅ |  |  |  |  |
 | [`no-template-trim-empty-ternary`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-template-trim-empty-ternary/) | Disallow inline `<template>.trim() === '' ? fallback : <template>.trim()` patterns. Extract to a named utility so the expression is built once and is unit-testable in one place. | 🔘 |  |  |  |  |
-| [`no-vacuous-expect`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-vacuous-expect/) | Disallow vacuous expects (`typeof` checks, literal tautologies, a sole `toBeDefined`/`toBeTruthy`): a test must assert behaviour that a real regression would break. | ✅ |  |  |  |  |
+| [`no-vacuous-expect`](https://noctcore.github.io/eslint-plugins/rules/code-quality/no-vacuous-expect/) | Disallow vacuous expects (`typeof` checks, literal tautologies, a sole `toBeDefined`/`toBeTruthy`, a sole presence check on the render root): a test must assert behaviour that a real regression would break. | ✅ |  |  |  |  |
 | [`prefer-early-return`](https://noctcore.github.io/eslint-plugins/rules/code-quality/prefer-early-return/) | Prefer guard clauses (early return) over wrapping the whole function body in a multi-statement `if` without an `else`. | ✅ |  |  |  |  |
-| [`skipped-tests-need-tracking`](https://noctcore.github.io/eslint-plugins/rules/code-quality/skipped-tests-need-tracking/) | Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently. | ✅ |  |  |  |  |
+| [`skipped-tests-need-tracking`](https://noctcore.github.io/eslint-plugins/rules/code-quality/skipped-tests-need-tracking/) | Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`, and unconditional `node:test` `{ skip }` / `{ todo }` / `t.skip()`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently. | ✅ |  |  |  |  |
+| [`typed-mock-over-double-cast`](https://noctcore.github.io/eslint-plugins/rules/code-quality/typed-mock-over-double-cast/) | Disallow an object literal of `jest.fn()` / `vi.fn()` mocks cast `as unknown as T`: the double cast switches type checking off, so a mock of a renamed or removed method keeps passing. | 🔘 |  |  |  |  |
 <!-- end generated rules -->
 
 ## Severity policy
diff --git a/packages/eslint-plugin-code-quality/docs/rules/no-message-only-throw-assertion.md b/packages/eslint-plugin-code-quality/docs/rules/no-message-only-throw-assertion.md
new file mode 100644
index 0000000..1225f63
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/docs/rules/no-message-only-throw-assertion.md
@@ -0,0 +1,198 @@
+# `noctcore-code-quality/no-message-only-throw-assertion`
+
+> A throw assertion must pin the error class, not accept any error or only its wording.
+
+<!-- begin generated rule header -->
+🔘 Opt-in: not in `recommended` · 💭 Type information: not needed
+<!-- end generated rule header -->
+
+## Why
+
+`expect(fn).toThrow()` passes for any error. When the code under test breaks in a way that throws
+something else, most often a `TypeError` from a mock that returns `undefined` where an object was
+expected, the assertion still passes and the test stays green on a broken path.
+
+A message alone is not much better. `toThrow('Employee not found.')` passes for any error class
+carrying that sentence. When two refusals share their wording but differ in class (a `NotFoundError`
+that says nothing about whether the record exists, and a `ForbiddenError` that confirms it does), the
+difference between them is exactly what the test exists to defend, and a message check cannot see it.
+
+```ts bad filename=src/employees/employee.service.test.ts reports=2
+it('refuses an unknown employee', async () => {
+  await expect(service.find('e-404')).rejects.toThrow();
+});
+
+it('refuses another tenant', async () => {
+  await expect(service.find('e-other')).rejects.toThrow('Employee not found.');
+});
+```
+
+```ts good filename=src/employees/employee.service.test.ts
+it('refuses an unknown employee', async () => {
+  await expect(service.find('e-404')).rejects.toThrow(NotFoundError);
+});
+
+it('refuses another tenant', async () => {
+  await expect(service.find('e-other')).rejects.toThrow(NotFoundError);
+  await expect(service.find('e-other')).rejects.toThrow('Employee not found.');
+});
+```
+
+## What it flags
+
+A `toThrow` / `toThrowError` matcher on an `expect(...)` chain, sync or after `.rejects`, that is not
+negated and whose argument:
+
+- `bareThrow`: is missing: `toThrow()`, `.rejects.toThrowError()`;
+- `messageOnlyThrow`: checks only the message: a string, a template literal, a regex literal, a
+  `RegExp` built with `new RegExp(...)`, or `expect.objectContaining({ message: ... })`. A
+  snapshot of the error (`toThrowErrorMatchingSnapshot()`, `toThrowErrorMatchingInlineSnapshot()`)
+  records only its message, so it is a message check too, whatever its argument.
+
+It reports inside and outside test callbacks, so a shared helper that asserts `.rejects.toThrow()`
+is reported where it is written.
+
+```ts bad filename=src/lib/api-path.test.ts reports=3
+it('rejects an absolute url', () => {
+  expect(() => toApiPath('https://evil.test')).toThrow('Refusing a non-relative api path');
+});
+
+it('rejects an unknown queue', () => {
+  expect(() => metrics.onModuleInit()).toThrow(new RegExp(`Queue "${missing}" is declared`));
+});
+
+export async function expectRefusal(promise: Promise<unknown>) {
+  await expect(promise).rejects.toThrow();
+}
+```
+
+```ts good filename=src/lib/api-path.test.ts
+it('rejects an absolute url', () => {
+  expect(() => toApiPath('https://evil.test')).toThrow(UnsafePathError);
+});
+
+it('rejects an unknown queue', () => {
+  expect(() => metrics.onModuleInit()).toThrow(
+    expect.objectContaining({ name: 'QueueConfigError', queue: missing }),
+  );
+});
+
+export async function expectRefusal(promise: Promise<unknown>) {
+  await expect(promise).rejects.toBeInstanceOf(DomainError);
+}
+```
+
+### Class and message asserted separately
+
+A message-only assertion is accepted when the same test also pins the class of the same subject (the
+same source text inside `expect(...)`) with a class-pinning throw matcher, a `.rejects` matcher that
+checks more than the message, or a configured `assertionHelpers` call whose first argument is that
+subject. The `.rejects` matchers that count:
+
+- `toBeInstanceOf(X)`;
+- `toMatchObject(...)`, unless its argument is an object with no key but `message` (`{ message: 'm' }`
+  pins nothing else), or an error instance while `trustErrorInstances` is off;
+- `toHaveProperty(path, ...)`, unless the path is `'message'` or `['message']`;
+- `toEqual(...)` / `toStrictEqual(...)`, unless the argument is an error instance while
+  `trustErrorInstances` is off: Jest's `equals()` compares two errors by their message alone. Some refusals differ
+only in wording, and there the sentence is the assertion; the class next to it keeps it honest.
+
+The pin must run whenever the message check runs: it has to sit in the same block as the message
+check or in a block that encloses it. A class pinned in one branch of an `if` does not excuse a
+message check in the other branch, or one after the `if`. A bare `toThrow()` is never excused by a
+pin: a later call on the same subject is usually a different scenario, and any error satisfies it.
+
+```ts bad filename=src/employees/employee.service.test.ts reports=2
+it('refuses', async () => {
+  if (strict) {
+    await expect(service.find('e-other')).rejects.toThrow(NotFoundError);
+  } else {
+    await expect(service.find('e-other')).rejects.toThrow('Employee not found.');
+  }
+  repository.find.mockResolvedValue({ deleted: true });
+  await expect(service.find('e-other')).rejects.toThrow();
+});
+```
+
+```ts good filename=src/employees/employee.service.test.ts
+it('refuses', async () => {
+  await expect(service.find('e-other')).rejects.toThrow(NotFoundError);
+  if (!strict) {
+    await expect(service.find('e-other')).rejects.toThrow('Employee not found.');
+  }
+  repository.find.mockResolvedValue({ deleted: true });
+  await expect(service.find('e-other')).rejects.toThrow(GoneError);
+});
+```
+
+## What it does not flag
+
+- A class argument (`toThrow(NotFoundError)`, `toThrow(errors.Forbidden)`), an asymmetric matcher
+  (`toThrow(expect.objectContaining({ code: 'E_LOCKED' }))`) or any other value that is not a string,
+  template or regex.
+- An error instance (`toThrow(new ForbiddenError('No access'))`) while `trustErrorInstances` is on:
+  Vitest compares it like `toEqual`, so its class name takes part. See Options for Jest.
+- `.not.toThrow()` and `.resolves.not.toThrow()`: a negated throw assertion has no class to pin.
+- `.rejects.toMatchObject(...)` and the other value matchers on their own.
+- A message held in a variable (`toThrow(expectedMessage)`): the rule reads syntax, not values, and
+  treats it as it would an error class.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `throwMatchers` | `string[]` | `["toThrow", "toThrowError", "toThrowErrorMatchingSnapshot", "toThrowErrorMatchingInlineSnapshot"]` | Matchers that assert a throw or a rejection. A name ending in `MatchingSnapshot` or `MatchingInlineSnapshot` is always a message check. |
+| `allowMessageOnly` | `boolean` | `false` | Report only the argless form. For adopting the rule in two steps. |
+| `trustErrorInstances` | `boolean` | `true` | Count an error instance argument as pinning the class. Set `false` under Jest, whose `toThrow(new X('m'))` and `.rejects.toEqual(new X('m'))` compare only the message. |
+| `assertionHelpers` | `string[]` (regex sources) | `[]` | Helpers that pin the error class, such as `expectRejectsDomainError(promise, {...})`. A call on the same subject in the same test accepts a message-only assertion. Matched against `name` or `obj.name`. |
+
+```js
+'noctcore-code-quality/no-message-only-throw-assertion': ['error', {
+  // Jest compares an error instance by its message only.
+  trustErrorInstances: false,
+  assertionHelpers: ['^expect(Throws|Rejects)DomainError$'],
+}]
+```
+
+Under `trustErrorInstances: false` an instance is a message check:
+
+```ts bad filename=src/auth/guard.spec.ts options={"trustErrorInstances":false}
+it('refuses a guest', () => {
+  expect(() => guard.check(guest)).toThrow(new ForbiddenError('No access'));
+});
+```
+
+```ts good filename=src/auth/guard.spec.ts options={"trustErrorInstances":false}
+it('refuses a guest', () => {
+  expect(() => guard.check(guest)).toThrow(ForbiddenError);
+  expect(() => guard.check(guest)).toThrow('No access');
+});
+```
+
+The same goes for a `.rejects` equality check used as the pin:
+
+```ts bad filename=src/auth/guard.spec.ts options={"trustErrorInstances":false}
+it('refuses a guest', async () => {
+  await expect(guard.load(guest)).rejects.toEqual(new ForbiddenError('No access'));
+  await expect(guard.load(guest)).rejects.toThrow('No access');
+});
+```
+
+```ts good filename=src/auth/guard.spec.ts options={"trustErrorInstances":false}
+it('refuses a guest', async () => {
+  await expect(guard.load(guest)).rejects.toMatchObject({ name: 'ForbiddenError', code: 'E_FORBIDDEN' });
+  await expect(guard.load(guest)).rejects.toThrow('No access');
+});
+```
+
+## When not to use it
+
+In a codebase that throws one plain `Error` class everywhere, where the message is the only thing
+that tells refusals apart. Start with `allowMessageOnly: true` there: the argless form is still a
+defect.
+
+## Related
+
+- [`no-swallowed-assertion`](./no-swallowed-assertion.md): an assertion whose failure is caught and
+  dropped.
+- [`no-vacuous-expect`](./no-vacuous-expect.md): assertions that pass for almost any implementation.
diff --git a/packages/eslint-plugin-code-quality/docs/rules/no-real-clock-in-unit-tests.md b/packages/eslint-plugin-code-quality/docs/rules/no-real-clock-in-unit-tests.md
new file mode 100644
index 0000000..ffe1b9d
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/docs/rules/no-real-clock-in-unit-tests.md
@@ -0,0 +1,133 @@
+# `noctcore-code-quality/no-real-clock-in-unit-tests`
+
+> A unit test that reads the real clock must fake it; an offset from now is allowed.
+
+<!-- begin generated rule header -->
+🔘 Opt-in: not in `recommended` · 💭 Type information: not needed
+<!-- end generated rule header -->
+
+## Why
+
+A fixture built from `new Date()` is a different fixture on every run. The test passes at noon and
+fails at midnight, on the last day of the month, across a DST change or on a runner in another time
+zone, and nobody can reproduce the failure the next morning. An exact-now value compared with a
+value the code computed a moment later is also a race.
+
+Fake the clock for the file (`vi.useFakeTimers()` plus `vi.setSystemTime(...)`, or Jest's
+equivalent), mock the project's clock module, or write the date down.
+
+```ts bad filename=src/auth/token.service.spec.ts
+it('expires a token issued now', () => {
+  const token = issue({ issuedAt: new Date() });
+  expect(isExpired(token)).toBe(false);
+});
+```
+
+```ts good filename=src/auth/token.service.spec.ts
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2026-01-15T10:00:00Z'));
+});
+afterEach(() => vi.useRealTimers());
+
+it('expires a token issued now', () => {
+  const token = issue({ issuedAt: new Date() });
+  expect(isExpired(token)).toBe(false);
+});
+```
+
+## What it flags
+
+In a unit test file (a path ending in one of `testFileSuffixes`, and not containing any
+`integrationMarkers`) that never fakes the clock:
+
+- `Date.now()`;
+- an argless `new Date()`, and `Date()` called as a function;
+
+unless the value is an offset from now (below).
+
+```ts bad filename=src/auth/session.service.spec.ts reports=3
+const started = Date.now();
+const row = { deletedAt: new Date(), stamp: new Date().toISOString() };
+```
+
+```ts good filename=src/auth/session.service.spec.ts
+const started = new Date('2026-01-15T10:00:00Z').getTime();
+const row = { deletedAt: new Date('2026-01-15T10:00:00Z'), stamp: '2026-01-15T10:00:00.000Z' };
+```
+
+### Offsets from now are allowed
+
+A value that only needs to be "later than now" or "earlier than now" is robust against the real
+clock, because the code under test reads the same clock: a token that expires in a minute is still
+valid when the assertion runs. So a `Date.now()` that is a direct operand of `+` or `-`
+(`Date.now() + 60_000`, `Date.now() - 2 * MINUTE`) is not reported, and neither is an argless
+`new Date()` turned into a number that is offset (`new Date().getTime() + 1000`, `+new Date() - 1000`).
+
+```ts good filename=src/auth/session.service.spec.ts
+const lockedUntil = new Date(Date.now() + 60_000);
+const createdAt = new Date(Date.now() - 2 * 60 * 60 * 1000);
+```
+
+A comparison (`Date.now() < deadline`) or an exact-now fixture is not an offset and is reported, and
+so is a date built from now and then mutated (`d.setDate(d.getDate() + 1)`): write it as an offset.
+
+### What fakes the clock
+
+The rule reads the whole file. Any one of these, anywhere in it, turns the rule off for that file:
+
+- a call to a `fakeClockMethods` method (`vi.useFakeTimers()`, `jest.setSystemTime(...)`);
+- a spy or stub that replaces `Date.now` or the global `Date` (`jest.spyOn(Date, 'now')`,
+  `vi.spyOn(globalThis, 'Date')`, `jest.replaceProperty(global, 'Date', ...)`,
+  `vi.stubGlobal('Date', ...)`), or an assignment to `Date.now`;
+- a module mock (`jest.mock`, `vi.mock`, `doMock`, `unstable_mockModule`) of a module matching
+  `clockModules`.
+
+## What it does not flag
+
+- `new Date(value)` with an argument, and `Date.parse(...)`.
+- A clock faked through a library call the rule does not know, such as `MockDate.set(...)`: the rule
+  reports that file. Add the method to `fakeClockMethods` only if its name is specific enough (a
+  method name matches on any receiver, so `set` would also match `map.set`), or mock the module
+  that reads the clock and list it in `clockModules`.
+- `performance.now()`: it measures a duration, not a date. A test that asserts on elapsed time has a
+  different problem (a timing assertion) that this rule does not judge.
+- Files that are not unit tests, or whose path contains an `integrationMarkers` entry.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `testFileSuffixes` | `string[]` | `.test` / `.spec` with `.ts`, `.tsx`, `.js`, `.jsx` | A file is a unit test when its path ends with one of these. |
+| `integrationMarkers` | `string[]` | `.integration.test.`, `.integration.spec.`, `.e2e.test.`, `.e2e.spec.`, `.e2e-spec.`, `/integration/`, `/e2e/` | A test file whose path, relative to the ESLint working directory, contains one of these is skipped. |
+| `fakeClockMethods` | `string[]` | `["useFakeTimers", "setSystemTime"]` | Methods that fake the clock for the file, on any receiver. |
+| `clockModules` | `string[]` (globs) | `[]` | Module specifiers whose mock controls the clock, matched against the specifier as written (`**/common/clock` matches `'../../common/clock'`). |
+
+```js
+'noctcore-code-quality/no-real-clock-in-unit-tests': ['error', {
+  clockModules: ['**/common/clock', '@acme/shared/clock'],
+}]
+```
+
+```ts good filename=src/auth/token.service.spec.ts reconfigured options={"clockModules":["**/common/clock"]}
+jest.mock('../../common/clock', () => ({ nowMs: () => 1_700_000_000_000 }));
+
+it('expires a token issued now', () => {
+  const token = issue({ issuedAt: new Date() });
+  expect(isExpired(token)).toBe(false);
+});
+```
+
+## When not to use it
+
+In a suite that tests against a real database whose own timestamps are the real clock; name it with
+an integration marker instead of turning the rule off everywhere.
+
+## Related
+
+- [`no-bare-date-now`](./no-bare-date-now.md): the same clock seam in application code.
+- [`fake-timers-must-be-restored`](./fake-timers-must-be-restored.md): the fake clock has to be
+  restored for the next test.
+- [`no-sleep-in-unit-tests`](./no-sleep-in-unit-tests.md) and
+  [`no-real-network-in-unit-tests`](./no-real-network-in-unit-tests.md): the other real-world inputs a
+  unit test should not depend on.
diff --git a/packages/eslint-plugin-code-quality/docs/rules/no-sleep-in-unit-tests.md b/packages/eslint-plugin-code-quality/docs/rules/no-sleep-in-unit-tests.md
new file mode 100644
index 0000000..d081356
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/docs/rules/no-sleep-in-unit-tests.md
@@ -0,0 +1,146 @@
+# `noctcore-code-quality/no-sleep-in-unit-tests`
+
+> Unit tests must not sleep on the real clock.
+
+<!-- begin generated rule header -->
+🔘 Opt-in: not in `recommended` · 💭 Type information: not needed
+<!-- end generated rule header -->
+
+## Why
+
+A unit test that waits `100` ms for something to happen is guessing. On a fast machine the wait is
+wasted time; on a loaded CI runner it is not long enough and the test fails for no reason. Either
+way the sleep hides what the test is actually waiting for. Fake the timers and advance them, or wait
+for the condition itself: the promise under test, a Testing Library `waitFor` / `findBy*`, an event.
+
+```ts bad filename=src/hooks/use-route-announcer.test.tsx
+it('announces the new route', async () => {
+  navigate('/settings');
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  expect(screen.getByRole('status')).toHaveTextContent('Settings');
+});
+```
+
+```ts good filename=src/hooks/use-route-announcer.test.tsx
+it('announces the new route', async () => {
+  navigate('/settings');
+  expect(await screen.findByRole('status')).toHaveTextContent('Settings');
+});
+```
+
+## What it flags
+
+In a unit test file (a path ending in one of `testFileSuffixes`, and not containing any
+`integrationMarkers`) that never installs fake timers:
+
+- a `new Promise` whose executor calls `setTimeout` (or `globalThis.setTimeout`) with a callback
+  that resolves it: `setTimeout(resolve, n)` or `setTimeout(() => resolve(value), n)`, in an
+  expression or a block body, including a `sleep` helper written that way in the same file;
+- `setTimeout` imported from `timers/promises` or `node:timers/promises`, by name, renamed or
+  through a namespace import (`timers.setTimeout(n)`);
+- a function made with `promisify(setTimeout)` or `util.promisify(setTimeout)`, where it is called.
+
+```ts bad filename=tools/verify/exec.test.ts reports=3
+import { setTimeout as delay } from 'node:timers/promises';
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+it('stops the child', async () => {
+  const child = start();
+  await delay(200);
+  child.stop();
+  const late = new Promise((resolve) => setTimeout(() => resolve('late'), 100));
+  expect(await Promise.race([child.exited, late])).toBe(0);
+});
+```
+
+```ts good filename=tools/verify/exec.test.ts
+it('stops the child', async () => {
+  vi.useFakeTimers();
+  const child = start();
+  await vi.advanceTimersByTimeAsync(200);
+  child.stop();
+  expect(await child.exited).toBe(0);
+  vi.useRealTimers();
+});
+```
+
+## What it does not flag
+
+- A zero or omitted delay while `allowZeroDelay` is on: `setTimeout(resolve, 0)` yields one
+  macrotask, the idiomatic flush inside `act(...)`.
+- A timer whose callback only rejects: `new Promise((_, reject) => setTimeout(() => reject(err), ms))`
+  is a timeout guard for a race, not a sleep.
+- A timer whose handle is kept (`timer = setTimeout(...)`, `const t = setTimeout(...)`) and passed to
+  `clearTimeout` or `clearInterval` somewhere in the file: that is a deadline raced against real work,
+  not a sleep, and costs wall-clock time only when the work is late. A kept handle that is never
+  cleared is still reported.
+- `setImmediate`, `process.nextTick` and `queueMicrotask` inside a promise.
+- A `setTimeout` that is not a promise executor's resolve, such as a timer the code under test
+  schedules.
+- Any timer promise in a file that calls a `fakeTimerMethods` method anywhere (`vi.useFakeTimers()`,
+  `jest.useFakeTimers()`, in a `beforeEach` or a test). Under fake timers the wait is virtual and the
+  test drives it with `advanceTimersByTimeAsync`, so it costs no wall-clock time.
+- Files that are not unit tests, or whose path contains an `integrationMarkers` entry.
+- A sleep helper imported from another module (`import { sleep } from './test-utils'`): the rule
+  reads one file at a time, so it reports the helper where it is defined, if that file is a unit
+  test, and not the calls to it.
+
+```ts good filename=src/hooks/use-route-announcer.test.tsx
+const settle = () => act(() => new Promise<void>((resolve) => setTimeout(resolve, 0)));
+
+const withTimeout = <T,>(work: Promise<T>, ms: number) =>
+  Promise.race([work, new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), ms))]);
+```
+
+```ts good filename=src/hooks/use-route-announcer.test.tsx
+function trickle(chunks: string[], gapMs: number) {
+  return new ReadableStream({
+    async pull(controller) {
+      await new Promise((resolve) => setTimeout(resolve, gapMs));
+      controller.enqueue(chunks.shift());
+    },
+  });
+}
+
+beforeEach(() => vi.useFakeTimers());
+afterEach(() => vi.useRealTimers());
+
+it('reads a slow body', async () => {
+  const body = trickle(['a'], 5_000);
+  await vi.advanceTimersByTimeAsync(5_000);
+  expect(await read(body)).toBe('a');
+});
+```
+
+The file-level check is coarse: one `useFakeTimers()` call anywhere exempts every timer promise in
+the file, including one in a test that runs on real timers.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `testFileSuffixes` | `string[]` | `.test` / `.spec` with `.ts`, `.tsx`, `.js`, `.jsx` | A file is a unit test when its path ends with one of these. |
+| `integrationMarkers` | `string[]` | `.integration.test.`, `.integration.spec.`, `.e2e.test.`, `.e2e.spec.`, `.e2e-spec.`, `/integration/`, `/e2e/` | A test file whose path, relative to the ESLint working directory, contains one of these is skipped. |
+| `allowZeroDelay` | `boolean` | `true` | Accept a zero or omitted delay. |
+| `fakeTimerMethods` | `string[]` | `["useFakeTimers"]` | Methods (on any receiver) that install fake timers. A file that calls one is not checked. |
+
+```js
+'noctcore-code-quality/no-sleep-in-unit-tests': ['error', {
+  // Suites that drive real processes or a real database wait on them on purpose.
+  integrationMarkers: ['.integration.', '.isolation.', '/e2e/'],
+}]
+```
+
+## When not to use it
+
+In test files that drive real child processes, servers or databases and are named like unit tests.
+Name them with an integration marker, or leave the rule off for that directory.
+
+## Related
+
+- [`fake-timers-must-be-restored`](./fake-timers-must-be-restored.md): fake timers that leak into
+  later tests.
+- [`no-real-clock-in-unit-tests`](./no-real-clock-in-unit-tests.md) and
+  [`no-real-network-in-unit-tests`](./no-real-network-in-unit-tests.md): the other real-world inputs a
+  unit test should not depend on.
diff --git a/packages/eslint-plugin-code-quality/docs/rules/no-vacuous-expect.md b/packages/eslint-plugin-code-quality/docs/rules/no-vacuous-expect.md
index f58422a..a194478 100644
--- a/packages/eslint-plugin-code-quality/docs/rules/no-vacuous-expect.md
+++ b/packages/eslint-plugin-code-quality/docs/rules/no-vacuous-expect.md
@@ -22,6 +22,8 @@ The rule matches on method names, not on a runner import, so it covers Jest, Vit
 - `tautologyExpect`: `expect(<literal>).toBe(<same literal>)`, also with `toEqual` / `toStrictEqual`.
 - `soleWeakExpect`: a test (`it` / `test`, including `.concurrent`, `.each` and other modifiers)
   whose only assertion is a weak matcher.
+- `soleRenderRootExpect`: a test whose only assertion is that the render root is present (see
+  below).
 
 ```ts bad filename=src/token.test.ts reports=3
 it('should be defined', () => {
@@ -55,12 +57,62 @@ it('clears the key', () => {
 });
 ```
 
+### A render root that is only present
+
+A DOM render (Testing Library's `render`) always returns a `container` and a `baseElement`. A test
+whose only assertion is that the root, its first child or its HTML exists passes for anything that
+renders at all: the wrong component, an empty wrapper, an error boundary's fallback. It is the
+"renders without crashing" test with an assertion added to look real.
+
+The subject is a render root, or its `firstChild`, `firstElementChild`, `lastChild`, `innerHTML`,
+`outerHTML` or `textContent`. A render root is a name in `renderRoots` that comes from a call:
+destructured from one (`const { container } = render(...)`, also after `await`), read off one
+(`render(...).container`, `view.container` where `view` is bound to a call, or
+`const container = render(...).container`), or returned by a `render*` function
+(`const container = renderIntoDocument(...)`). The
+matcher is a presence check: `toBeInTheDocument`, `toBeTruthy`, `toBeDefined`, `toBeVisible`,
+`not.toBeNull`, `not.toBeUndefined`, `not.toBeFalsy`, `not.toBeEmptyDOMElement`, or `not.toBe('')`
+(also `not.toEqual('')` / `not.toStrictEqual('')`).
+
+```tsx bad filename=src/TurnstileField.test.tsx reports=2
+it('renders without crashing', () => {
+  const { container } = render(<TurnstileField form={form} />);
+  expect(container).not.toBeEmptyDOMElement();
+});
+
+it('renders the card', () => {
+  const { container } = render(<Card title="Q3" />);
+  expect(container.firstChild).toBeInTheDocument();
+});
+```
+
+```tsx good filename=src/TurnstileField.test.tsx
+it('renders the captcha widget', () => {
+  render(<TurnstileField form={form} />);
+  expect(screen.getByTitle('Captcha challenge')).toBeVisible();
+});
+
+it('renders the card', () => {
+  render(<Card title="Q3" />);
+  expect(screen.getByRole('heading', { name: 'Q3' })).toBeInTheDocument();
+});
+```
+
 ## What it does not flag
 
 - A weak matcher next to any other assertion. A test counts every `expect(...)` matcher plus any call
   matching `assertionCallees`, so a weak `expect` next to `assert.equal(...)`, `expectValidUser(...)`
   or supertest's `.expect(200)` is fine.
 - `toBeUndefined`, `toBeNull` and `not.toBeNull`, unless you add them to `weakMatchers` (see Options).
+- A `container` or `baseElement` that is not bound from a call: a parameter, an object property
+  (`ship.container`), or a binding initialised from something other than a `render*` call
+  (`const container = await docker.inspect(id)`). A binding assigned later
+  (`let container; beforeEach(() => ({ container } = render(...)))`) is not followed either.
+  The reverse also holds: a `container` destructured from a call that is not a render
+  (`const { container } = await docker.inspect(id)`) is treated as a render root; set `renderRoots`
+  for such a suite.
+- A render root checked for real content (`expect(container.textContent).toBe('Hello')`), a query
+  on the root (`container.querySelector('nav')`), or a presence check next to another assertion.
 
 ### Limitations
 
@@ -75,6 +127,7 @@ with a matcher that states the intent instead.
 | --- | --- | --- | --- |
 | `weakMatchers` | `string[]` | `["toBeDefined", "toBeTruthy", "toBeFalsy", "not.toBeUndefined"]` | Matchers that cannot carry a test alone. Prefix `not.` for the negated form. |
 | `assertionCallees` | `string[]` (regex sources) | `["^assert", "^expect\\w", "\\.expect$"]` | Calls that also count as an assertion. Matched against `name`, `obj.name` (member on an identifier) or `.name` (any other member). |
+| `renderRoots` | `string[]` | `["container", "baseElement"]` | Names of the render root, as a binding or a member (`view.container`). A sole presence check on one is reported. `[]` turns that check off. |
 
 `toBeUndefined`, `toBeNull` and `not.toBeNull` are not weak by default: each pins one specific
 value, and `expect(container.querySelector('nav')).not.toBeNull()` is a real presence check.
@@ -84,6 +137,8 @@ value, and `expect(container.querySelector('nav')).not.toBeNull()` is a real pre
 'noctcore-code-quality/no-vacuous-expect': ['error', {
   weakMatchers: ['toBeDefined', 'toBeTruthy', 'toBeFalsy', 'toBeUndefined'],
   assertionCallees: ['^assert', '^expect\\w', '\\.expect$', '^verifySnapshot$'],
+  // A custom mount helper returns its root as `root`.
+  renderRoots: ['container', 'baseElement', 'root'],
 }]
 ```
 
diff --git a/packages/eslint-plugin-code-quality/docs/rules/skipped-tests-need-tracking.md b/packages/eslint-plugin-code-quality/docs/rules/skipped-tests-need-tracking.md
index bdcffb4..ad142dc 100644
--- a/packages/eslint-plugin-code-quality/docs/rules/skipped-tests-need-tracking.md
+++ b/packages/eslint-plugin-code-quality/docs/rules/skipped-tests-need-tracking.md
@@ -39,11 +39,55 @@ it.skip('later', () => {});
 it.skip('later', () => {}); // https://github.com/org/repo/issues/1
 ```
 
+### `node:test` skips
+
+`node:test` skips through the test's options or its context, which a line scan cannot tell apart
+from a platform guard. These forms are read from the syntax, and only an unconditional skip is
+reported, from the line of the option or the call:
+
+- a `skip` or `todo` option on `test` / `it` / `describe` / `suite` (and a `t.test` subtest) whose
+  value is a truthy literal: `{ skip: true }`, `{ skip: 1 }`, `{ todo: 'write it' }`;
+- `t.skip()` / `t.todo()` (or `await t.skip()`) as a statement of the test callback's own body,
+  where `t` is the callback's context parameter.
+
+```ts bad filename=scripts/release.test.ts reports=2
+test('publishes the tarball', { skip: 'broken on the new registry' }, async () => {});
+
+test('signs the release', (t) => {
+  t.todo('needs the new key');
+});
+```
+
+```ts good filename=scripts/release.test.ts
+// TODO(@alice): the new registry rejects the tarball
+test('publishes the tarball', { skip: 'broken on the new registry' }, async () => {});
+
+test('signs the release', (t) => {
+  t.todo('needs the new key, https://github.com/org/repo/issues/12');
+});
+```
+
 ## What it does not flag
 
 - A test that is not skipped.
 - A skip with a `markers` match on its own line or within the `lookback` lines above it.
 - `.only`: [`no-focused-tests`](./no-focused-tests.md) bans it outright.
+- A conditional `node:test` skip: an option whose value is computed
+  (`{ skip: process.platform === 'win32' }`, `{ skip: !ready }`, shorthand `{ skip }`), or a
+  `t.skip(...)` inside an `if`, a loop or a helper. Those are platform or environment guards.
+- A `skip` / `todo` key in an object passed to anything that is not a test runner, and a `skip`
+  method on a receiver that is not the test's context (`query.skip(10)`).
+
+```ts good filename=scripts/release.test.ts
+test('uses POSIX signals', { skip: process.platform === 'win32' }, () => {});
+
+test('kills the process group', (t) => {
+  if (process.platform === 'win32') {
+    t.skip('taskkill ends a Windows tree at once');
+    return;
+  }
+});
+```
 
 ## Options
 
diff --git a/packages/eslint-plugin-code-quality/docs/rules/typed-mock-over-double-cast.md b/packages/eslint-plugin-code-quality/docs/rules/typed-mock-over-double-cast.md
new file mode 100644
index 0000000..4ba56d5
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/docs/rules/typed-mock-over-double-cast.md
@@ -0,0 +1,89 @@
+# `noctcore-code-quality/typed-mock-over-double-cast`
+
+> An object of mocks must be typed against the real interface, not double-cast past the checker.
+
+<!-- begin generated rule header -->
+🔘 Opt-in: not in `recommended` · 💭 Type information: not needed
+<!-- end generated rule header -->
+
+## Why
+
+`{ get: jest.fn() } as unknown as ConfigService` tells TypeScript to stop checking. When the real
+service renames `get` to `getOrThrow`, the test still mocks `get`, the code under test calls
+`getOrThrow` on an object that does not have it, and the failure (if the test fails at all) is a
+`TypeError` far from the cause. Worse, a mock that returns the wrong shape keeps compiling forever.
+
+Type the double against the members the test uses. `jest.Mocked<Pick<T, 'a' | 'b'>>` (or Vitest's
+`Mocked<Pick<...>>`) keeps every mocked member checked against `T`, and `satisfies Partial<T>`
+checks the literal without widening it.
+
+```ts bad filename=src/metrics/basic-auth.guard.spec.ts
+const config = {
+  get: jest.fn((key: string) => (key === 'METRICS_BASIC_AUTH' ? basicAuth : undefined)),
+} as unknown as ConfigService;
+```
+
+```ts good filename=src/metrics/basic-auth.guard.spec.ts
+const config: jest.Mocked<Pick<ConfigService, 'get'>> = {
+  get: jest.fn((key: string) => (key === 'METRICS_BASIC_AUTH' ? basicAuth : undefined)),
+};
+```
+
+## What it flags
+
+An object literal cast `as unknown as T` (or `as any as T`, `as never as T`, and the angle-bracket
+forms `<T><unknown>{ ... }` and `<T>({ ... } as unknown)`) that contains a mock-function call
+(`jest.fn()` / `vi.fn()` by default) anywhere inside it: as a property, nested in another object,
+at the start of a chain (`jest.fn().mockResolvedValue(...)`) or inside a function property.
+
+```ts bad filename=src/common/rate-limit.spec.ts reports=2
+const opts = { ctx: { res: { setHeader: jest.fn() } } } as unknown as OnErrorOptions;
+
+const host = {
+  switchToHttp: () => ({ getResponse: () => ({ status: jest.fn() }) }),
+} as unknown as ArgumentsHost;
+```
+
+```ts good filename=src/common/rate-limit.spec.ts
+const opts = { ctx: { res: { setHeader: jest.fn() } } } satisfies DeepPartial<OnErrorOptions>;
+
+const host: jest.Mocked<Pick<ArgumentsHost, 'switchToHttp'>> = {
+  switchToHttp: jest.fn(() => ({ getResponse: () => ({ status: jest.fn() }) })),
+};
+```
+
+## What it does not flag
+
+- A single cast (`as jest.Mocked<Pick<T, 'get'>>`): TypeScript still checks that the two types
+  overlap.
+- A double cast of an object with no mock in it (a data fixture), or of something that is not an
+  object literal (`existingDouble as unknown as T`).
+- `as unknown` on its own.
+- A target matching `allowTargets`.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `mockFactories` | `string[]` | `["jest.fn", "vi.fn"]` | Callees that create a mock function, as `name` or `obj.name`. |
+| `allowTargets` | `string[]` (globs) | `[]` | Cast targets that may be double-cast, matched against the type name (`PrismaService`, `Prisma.TransactionClient`) and the full type text (`Parameters<Guard['canActivate']>[0]`). For types too wide to `Pick` from. |
+
+```js
+'noctcore-code-quality/typed-mock-over-double-cast': ['error', {
+  // An ORM client and its transaction are too wide to Pick from.
+  allowTargets: ['PrismaService', 'Prisma.TransactionClient'],
+}]
+```
+
+```ts good filename=src/metrics/basic-auth.guard.spec.ts reconfigured options={"allowTargets":["PrismaService"]}
+const prisma = { user: { findMany: jest.fn() } } as unknown as PrismaService;
+```
+
+## When not to use it
+
+In a codebase without strict types in its tests, where a double cast is the norm and a typed double
+would need a helper type library first.
+
+## Related
+
+- [`no-vacuous-expect`](./no-vacuous-expect.md): assertions that pass for almost any implementation.
diff --git a/packages/eslint-plugin-code-quality/src/configs/recommended.ts b/packages/eslint-plugin-code-quality/src/configs/recommended.ts
index ee7dd25..1d70b28 100644
--- a/packages/eslint-plugin-code-quality/src/configs/recommended.ts
+++ b/packages/eslint-plugin-code-quality/src/configs/recommended.ts
@@ -6,6 +6,18 @@
  * convention) and `no-template-trim-empty-ternary` (a very specific inline
  * shape) — are intentionally omitted. They are exported and documented, so a
  * consumer can enable them explicitly, but they are not on by default.
+ *
+ * The test-discipline rules below are omitted because each needs a
+ * per-project fact before it is precise at `error`:
+ * - `no-message-only-throw-assertion`: whether an error instance pins its class
+ *   depends on the runner (Vitest compares it, Jest only its message), and a
+ *   project's own class-pinning assertion helpers are configured by name.
+ * - `no-sleep-in-unit-tests`: which test files are unit tests, not suites that
+ *   drive real processes or databases, is a naming convention.
+ * - `no-real-clock-in-unit-tests`: the same naming convention, plus the clock
+ *   module the project mocks, which is its own.
+ * - `typed-mock-over-double-cast`: some targets are too wide to `Pick` from
+ *   (an ORM client, a framework request), and only the project can list them.
  */
 export const recommended = {
   'noctcore-code-quality/prefer-early-return': 'error',
diff --git a/packages/eslint-plugin-code-quality/src/rules/index.ts b/packages/eslint-plugin-code-quality/src/rules/index.ts
index 7998954..1559187 100644
--- a/packages/eslint-plugin-code-quality/src/rules/index.ts
+++ b/packages/eslint-plugin-code-quality/src/rules/index.ts
@@ -5,15 +5,19 @@ import { noConditionalExpectRule } from './no-conditional-expect';
 import { noElidedCodeCommentsRule } from './no-elided-code-comments';
 import { noFocusedTestsRule } from './no-focused-tests';
 import { noHistoricalCommentsRule } from './no-historical-comments';
+import { noMessageOnlyThrowAssertionRule } from './no-message-only-throw-assertion';
 import { noNarrationCommentsRule } from './no-narration-comments';
 import { noPrReferenceCommentsRule } from './no-pr-reference-comments';
 import { noProcessExitRule } from './no-process-exit';
+import { noRealClockInUnitTestsRule } from './no-real-clock-in-unit-tests';
 import { noRealNetworkInUnitTestsRule } from './no-real-network-in-unit-tests';
+import { noSleepInUnitTestsRule } from './no-sleep-in-unit-tests';
 import { noSwallowedAssertionRule } from './no-swallowed-assertion';
 import { noTemplateTrimEmptyTernaryRule } from './no-template-trim-empty-ternary';
 import { preferEarlyReturnRule } from './prefer-early-return';
 import { noVacuousExpectRule } from './no-vacuous-expect';
 import { skippedTestsNeedTrackingRule } from './skipped-tests-need-tracking';
+import { typedMockOverDoubleCastRule } from './typed-mock-over-double-cast';
 
 /** Every rule this plugin exposes, keyed by its (unprefixed) rule id. */
 export const rules = {
@@ -34,4 +38,9 @@ export const rules = {
   // Available but omitted from `recommended` (opinionated / niche).
   'interface-prefix-i': interfacePrefixIRule,
   'no-template-trim-empty-ternary': noTemplateTrimEmptyTernaryRule,
+  // Available but omitted from `recommended` (they need per-project facts).
+  'no-message-only-throw-assertion': noMessageOnlyThrowAssertionRule,
+  'no-sleep-in-unit-tests': noSleepInUnitTestsRule,
+  'no-real-clock-in-unit-tests': noRealClockInUnitTestsRule,
+  'typed-mock-over-double-cast': typedMockOverDoubleCastRule,
 };
diff --git a/packages/eslint-plugin-code-quality/src/rules/no-message-only-throw-assertion.ts b/packages/eslint-plugin-code-quality/src/rules/no-message-only-throw-assertion.ts
new file mode 100644
index 0000000..6ef3993
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/src/rules/no-message-only-throw-assertion.ts
@@ -0,0 +1,442 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+
+import { createRule } from '../createRule';
+
+const RULE_NAME = 'no-message-only-throw-assertion';
+
+export interface NoMessageOnlyThrowAssertionOptions {
+  /** Matchers that assert a throw or a rejection (`toThrow`, `toThrowError`). */
+  readonly throwMatchers?: readonly string[];
+  /**
+   * Report only the argless form (`toThrow()`), and accept a string or regex
+   * argument. For adopting the rule in two steps.
+   */
+  readonly allowMessageOnly?: boolean;
+  /**
+   * Treat an error instance argument (`toThrow(new NotFoundError('x'))`) as
+   * pinning the class. True for Vitest, which compares the instance like
+   * `toEqual`; set false under Jest, which compares only the message.
+   */
+  readonly trustErrorInstances?: boolean;
+  /**
+   * Regex sources (compiled with the `u` flag) for assertion helpers that pin
+   * the error class, such as `expectRejectsDomainError(promise, {...})`. A
+   * message-only assertion is accepted when a matching helper is called on the
+   * same subject in the same test. Matched against `name` for a bare call and
+   * `obj.name` for a member call on an identifier.
+   */
+  readonly assertionHelpers?: readonly string[];
+}
+
+type RuleOptions = [NoMessageOnlyThrowAssertionOptions];
+type MessageIds = 'bareThrow' | 'messageOnlyThrow';
+
+const DEFAULT_THROW_MATCHERS: readonly string[] = [
+  'toThrow',
+  'toThrowError',
+  'toThrowErrorMatchingSnapshot',
+  'toThrowErrorMatchingInlineSnapshot',
+];
+
+/** A throw matcher that snapshots the error records only its message, whatever its argument. */
+const SNAPSHOT_THROW_MATCHER = /MatchingSnapshot$|MatchingInlineSnapshot$/u;
+const DEFAULT_ALLOW_MESSAGE_ONLY = false;
+const DEFAULT_TRUST_ERROR_INSTANCES = true;
+const DEFAULT_ASSERTION_HELPERS: readonly string[] = [];
+
+/**
+ * Matchers on a `.rejects` chain that can pin the rejection beyond its
+ * message. Each is checked against its argument in `rejectsPinsClass`: Jest's
+ * `equals()` compares two errors by message only, and `{ message }` alone is
+ * a message check whatever the matcher.
+ */
+const REJECTS_PINNING_MATCHERS = new Set([
+  'toBeInstanceOf',
+  'toMatchObject',
+  'toEqual',
+  'toStrictEqual',
+  'toHaveProperty',
+]);
+
+const MESSAGE_KEY = 'message';
+
+const TEST_RUNNERS = new Set(['it', 'test']);
+
+const optionSchema: JSONSchema4 = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    throwMatchers: {
+      type: 'array',
+      items: { type: 'string', minLength: 1 },
+      uniqueItems: true,
+      minItems: 1,
+    },
+    allowMessageOnly: { type: 'boolean' },
+    trustErrorInstances: { type: 'boolean' },
+    assertionHelpers: {
+      type: 'array',
+      items: { type: 'string', minLength: 1 },
+      uniqueItems: true,
+    },
+  },
+};
+
+type FunctionNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+
+interface MatcherChain {
+  /** The `expect(...)` call at the root of the chain. */
+  readonly root: TSESTree.CallExpression;
+  readonly matcher: string;
+  readonly negated: boolean;
+  readonly rejects: boolean;
+}
+
+interface Finding {
+  readonly node: TSESTree.CallExpression;
+  readonly messageId: MessageIds;
+  readonly matcher: string;
+  readonly subject: string;
+  /** The block the assertion runs in. */
+  readonly block: TSESTree.Node;
+}
+
+interface TestFrame {
+  readonly node: FunctionNode | null;
+  readonly findings: Finding[];
+  /** Source text of every subject whose error class is pinned in this test, to the blocks that pin it. */
+  readonly pinned: Map<string, TSESTree.Node[]>;
+}
+
+/** The nearest enclosing block: a block statement, a function (expression body) or the program. */
+function enclosingBlock(node: TSESTree.Node): TSESTree.Node {
+  let current: TSESTree.Node = node;
+  // `parent` is null on the Program node at runtime, whatever the types say.
+  while (current.parent) {
+    current = current.parent;
+    if (
+      current.type === AST_NODE_TYPES.BlockStatement ||
+      current.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+      current.type === AST_NODE_TYPES.FunctionExpression
+    ) {
+      return current;
+    }
+  }
+  return current;
+}
+
+/** True when `ancestor` is `node` or contains it. */
+function isSelfOrAncestor(ancestor: TSESTree.Node, node: TSESTree.Node): boolean {
+  for (let current: TSESTree.Node | undefined = node; current; current = current.parent) {
+    if (current === ancestor) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Decompose `expect(x).rejects.not.toThrow(y)` into its parts, or null. */
+function matcherChain(node: TSESTree.CallExpression): MatcherChain | null {
+  const callee = node.callee;
+  if (
+    callee.type !== AST_NODE_TYPES.MemberExpression ||
+    callee.computed ||
+    callee.property.type !== AST_NODE_TYPES.Identifier
+  ) {
+    return null;
+  }
+  let negated = false;
+  let rejects = false;
+  let current: TSESTree.Expression = callee.object;
+  while (current.type === AST_NODE_TYPES.MemberExpression) {
+    if (!current.computed && current.property.type === AST_NODE_TYPES.Identifier) {
+      if (current.property.name === 'not') {
+        negated = !negated;
+      } else if (current.property.name === 'rejects') {
+        rejects = true;
+      }
+    }
+    current = current.object;
+  }
+  if (
+    current.type !== AST_NODE_TYPES.CallExpression ||
+    current.callee.type !== AST_NODE_TYPES.Identifier ||
+    current.callee.name !== 'expect'
+  ) {
+    return null;
+  }
+  return { root: current, matcher: callee.property.name, negated, rejects };
+}
+
+/** `name` or `obj.name` for a callee, used to match `assertionHelpers`. */
+function calleePath(callee: TSESTree.Expression): string | null {
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    !callee.computed &&
+    callee.property.type === AST_NODE_TYPES.Identifier
+  ) {
+    const owner = callee.object.type === AST_NODE_TYPES.Identifier ? callee.object.name : '';
+    return `${owner}.${callee.property.name}`;
+  }
+  return null;
+}
+
+/** Root identifier of a test callee: `it`, `test.concurrent`, `it.each(table)`. */
+function runnerName(callee: TSESTree.Node): string | null {
+  let current: TSESTree.Node = callee;
+  for (;;) {
+    if (current.type === AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+    } else if (current.type === AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+    } else if (current.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+      current = current.tag;
+    } else {
+      break;
+    }
+  }
+  return current.type === AST_NODE_TYPES.Identifier ? current.name : null;
+}
+
+function isTestCallback(node: FunctionNode): boolean {
+  const parent = node.parent;
+  if (parent.type !== AST_NODE_TYPES.CallExpression || !parent.arguments.includes(node)) {
+    return false;
+  }
+  const name = runnerName(parent.callee);
+  return name !== null && TEST_RUNNERS.has(name);
+}
+
+/** True for `new RegExp(...)` / `RegExp(...)`: a pattern, so a message check. */
+function isRegExpConstruction(node: TSESTree.Node): boolean {
+  return (
+    (node.type === AST_NODE_TYPES.NewExpression || node.type === AST_NODE_TYPES.CallExpression) &&
+    node.callee.type === AST_NODE_TYPES.Identifier &&
+    node.callee.name === 'RegExp'
+  );
+}
+
+/** True for an object literal with no key but `message`: `{ message: 'm' }`, or `{}`. */
+function isMessageOnlyObject(node: TSESTree.Node | undefined): boolean {
+  return (
+    node?.type === AST_NODE_TYPES.ObjectExpression &&
+    node.properties.every(
+      (property) =>
+        property.type === AST_NODE_TYPES.Property &&
+        !property.computed &&
+        ((property.key.type === AST_NODE_TYPES.Identifier && property.key.name === MESSAGE_KEY) ||
+          (property.key.type === AST_NODE_TYPES.Literal && property.key.value === MESSAGE_KEY)),
+    )
+  );
+}
+
+/** True for `expect.objectContaining({ message: ... })`: an asymmetric message check. */
+function isMessageOnlyMatcher(node: TSESTree.Node): boolean {
+  return (
+    node.type === AST_NODE_TYPES.CallExpression &&
+    node.callee.type === AST_NODE_TYPES.MemberExpression &&
+    !node.callee.computed &&
+    node.callee.object.type === AST_NODE_TYPES.Identifier &&
+    node.callee.object.name === 'expect' &&
+    node.callee.property.type === AST_NODE_TYPES.Identifier &&
+    node.callee.property.name === 'objectContaining' &&
+    isMessageOnlyObject(node.arguments[0])
+  );
+}
+
+/** True for a `toHaveProperty` path that names only the message: `'message'`, `['message']`. */
+function isMessagePath(node: TSESTree.Node | undefined): boolean {
+  if (node?.type === AST_NODE_TYPES.Literal) {
+    return node.value === MESSAGE_KEY;
+  }
+  return (
+    node?.type === AST_NODE_TYPES.ArrayExpression &&
+    node.elements.length === 1 &&
+    node.elements[0]?.type === AST_NODE_TYPES.Literal &&
+    node.elements[0].value === MESSAGE_KEY
+  );
+}
+
+/** True for an argument that checks only the message: a string, a template, a regex or `{ message }`. */
+function isMessageArgument(node: TSESTree.Node): boolean {
+  if (node.type === AST_NODE_TYPES.Literal) {
+    return typeof node.value === 'string' || 'regex' in node;
+  }
+  return (
+    node.type === AST_NODE_TYPES.TemplateLiteral ||
+    isRegExpConstruction(node) ||
+    isMessageOnlyMatcher(node)
+  );
+}
+
+export const noMessageOnlyThrowAssertionRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow `toThrow()` with no argument or with only a message: any error passes, including a `TypeError` from a broken mock. Pin the error class.',
+    },
+    schema: [optionSchema],
+    messages: {
+      bareThrow:
+        '`{{matcher}}()` with no argument passes for any error, including a `TypeError` from a broken mock. Pass the error class, or assert the error with `.rejects.toMatchObject(...)`.',
+      messageOnlyThrow:
+        '`{{matcher}}(...)` with only a message passes for any error class with that wording. Pass the error class, or pin it with a second assertion on the same subject.',
+    },
+  },
+  defaultOptions: [
+    {
+      throwMatchers: [...DEFAULT_THROW_MATCHERS],
+      allowMessageOnly: DEFAULT_ALLOW_MESSAGE_ONLY,
+      trustErrorInstances: DEFAULT_TRUST_ERROR_INSTANCES,
+      assertionHelpers: [...DEFAULT_ASSERTION_HELPERS],
+    },
+  ],
+  create(context, [options]) {
+    const throwMatchers = new Set(options.throwMatchers ?? DEFAULT_THROW_MATCHERS);
+    const allowMessageOnly = options.allowMessageOnly ?? DEFAULT_ALLOW_MESSAGE_ONLY;
+    const trustErrorInstances = options.trustErrorInstances ?? DEFAULT_TRUST_ERROR_INSTANCES;
+    const assertionHelpers = (options.assertionHelpers ?? DEFAULT_ASSERTION_HELPERS).map(
+      (source) => new RegExp(source, 'u'),
+    );
+    const stack: TestFrame[] = [{ node: null, findings: [], pinned: new Map() }];
+
+    function textOf(node: TSESTree.Node | undefined): string | null {
+      return node === undefined ? null : context.sourceCode.getText(node);
+    }
+
+    /**
+     * True when the frame pins `finding`'s subject in the finding's block or an
+     * enclosing one, so the pin runs whenever the message check does. A bare
+     * throw is never excused: a later call on the same subject is often a
+     * different scenario, and any error satisfies it.
+     */
+    function isPaired(frame: TestFrame, finding: Finding): boolean {
+      if (finding.messageId === 'bareThrow') {
+        return false;
+      }
+      const blocks = frame.pinned.get(finding.subject) ?? [];
+      return blocks.some((block) => isSelfOrAncestor(block, finding.block));
+    }
+
+    function pin(frame: TestFrame, subject: string, node: TSESTree.Node): void {
+      const blocks = frame.pinned.get(subject) ?? [];
+      blocks.push(enclosingBlock(node));
+      frame.pinned.set(subject, blocks);
+    }
+
+    /** Report what the frame holds, minus message checks the same test pairs with a class pin. */
+    function flush(frame: TestFrame): void {
+      for (const finding of frame.findings) {
+        if (isPaired(frame, finding)) {
+          continue;
+        }
+        context.report({
+          node: finding.node,
+          messageId: finding.messageId,
+          data: { matcher: finding.matcher },
+        });
+      }
+    }
+
+    function enter(node: FunctionNode): void {
+      if (isTestCallback(node)) {
+        stack.push({ node, findings: [], pinned: new Map() });
+      }
+    }
+
+    function exit(node: FunctionNode): void {
+      const frame = stack.at(-1);
+      if (frame?.node === node) {
+        stack.pop();
+        flush(frame);
+      }
+    }
+
+    /** True when `.rejects.<matcher>(argument)` pins more than the message. */
+    function rejectsPinsClass(matcher: string, argument: TSESTree.Node | undefined): boolean {
+      const comparesInstance =
+        argument?.type === AST_NODE_TYPES.NewExpression && !trustErrorInstances;
+      switch (matcher) {
+        case 'toEqual':
+        case 'toStrictEqual':
+          return !comparesInstance;
+        case 'toMatchObject':
+          return !comparesInstance && !isMessageOnlyObject(argument);
+        case 'toHaveProperty':
+          return !isMessagePath(argument);
+        default:
+          return true;
+      }
+    }
+
+    /** Classify a throw matcher call by its argument: null when it pins the class. */
+    function classify(matcher: string, argument: TSESTree.Node | undefined): MessageIds | null {
+      if (SNAPSHOT_THROW_MATCHER.test(matcher)) {
+        return allowMessageOnly ? null : 'messageOnlyThrow';
+      }
+      if (argument === undefined) {
+        return 'bareThrow';
+      }
+      if (isMessageArgument(argument)) {
+        return allowMessageOnly ? null : 'messageOnlyThrow';
+      }
+      if (argument.type === AST_NODE_TYPES.NewExpression && !trustErrorInstances) {
+        return allowMessageOnly ? null : 'messageOnlyThrow';
+      }
+      return null;
+    }
+
+    return {
+      ArrowFunctionExpression: enter,
+      FunctionExpression: enter,
+      'ArrowFunctionExpression:exit': exit,
+      'FunctionExpression:exit': exit,
+      CallExpression(node: TSESTree.CallExpression): void {
+        const frame = stack.at(-1);
+        if (frame === undefined) {
+          return;
+        }
+        const chain = matcherChain(node);
+        if (chain === null) {
+          const path = calleePath(node.callee);
+          const subject = textOf(node.arguments[0]);
+          if (path !== null && subject !== null && assertionHelpers.some((re) => re.test(path))) {
+            pin(frame, subject, node);
+          }
+          return;
+        }
+        const subject = textOf(chain.root.arguments[0]);
+        if (chain.negated || subject === null) {
+          return;
+        }
+        if (throwMatchers.has(chain.matcher)) {
+          const messageId = classify(chain.matcher, node.arguments[0]);
+          if (messageId === null) {
+            pin(frame, subject, node);
+          } else {
+            const block = enclosingBlock(node);
+            frame.findings.push({ node, messageId, matcher: chain.matcher, subject, block });
+          }
+        } else if (
+          chain.rejects &&
+          REJECTS_PINNING_MATCHERS.has(chain.matcher) &&
+          rejectsPinsClass(chain.matcher, node.arguments[0])
+        ) {
+          pin(frame, subject, node);
+        }
+      },
+      'Program:exit'(): void {
+        const root = stack[0];
+        if (root !== undefined) {
+          flush(root);
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin-code-quality/src/rules/no-real-clock-in-unit-tests.ts b/packages/eslint-plugin-code-quality/src/rules/no-real-clock-in-unit-tests.ts
new file mode 100644
index 0000000..cb646b5
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/src/rules/no-real-clock-in-unit-tests.ts
@@ -0,0 +1,259 @@
+import path from 'node:path';
+
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+
+import { createRule } from '../createRule';
+import { matchesAny } from '../utils/allowMatch';
+
+const RULE_NAME = 'no-real-clock-in-unit-tests';
+
+export interface NoRealClockInUnitTestsOptions {
+  /** A file is a unit test when its path ends with one of these. */
+  readonly testFileSuffixes?: readonly string[];
+  /** A test file whose project-relative path contains one of these is an integration test and is skipped. */
+  readonly integrationMarkers?: readonly string[];
+  /** Method names that fake the clock for the file (`vi.useFakeTimers()`, `vi.setSystemTime(...)`). */
+  readonly fakeClockMethods?: readonly string[];
+  /**
+   * Globs matched against module specifiers. A file that mocks a matching
+   * module (`vi.mock('../common/clock')`) controls its clock through that seam.
+   */
+  readonly clockModules?: readonly string[];
+}
+
+type RuleOptions = [NoRealClockInUnitTestsOptions];
+type MessageIds = 'realClockInUnitTest';
+
+const DEFAULT_TEST_FILE_SUFFIXES: readonly string[] = [
+  '.test.ts',
+  '.test.tsx',
+  '.spec.ts',
+  '.spec.tsx',
+  '.test.js',
+  '.test.jsx',
+  '.spec.js',
+  '.spec.jsx',
+];
+
+const DEFAULT_INTEGRATION_MARKERS: readonly string[] = [
+  '.integration.test.',
+  '.integration.spec.',
+  '.e2e.test.',
+  '.e2e.spec.',
+  '.e2e-spec.',
+  '/integration/',
+  '/e2e/',
+];
+
+const DEFAULT_FAKE_CLOCK_METHODS: readonly string[] = ['useFakeTimers', 'setSystemTime'];
+const DEFAULT_CLOCK_MODULES: readonly string[] = [];
+
+/** Test-double APIs that replace a module for the whole file. */
+const MODULE_MOCKERS = new Set(['mock', 'doMock', 'unstable_mockModule']);
+/** Receivers whose `Date` a spy can replace: `vi.spyOn(globalThis, 'Date')`. */
+const GLOBAL_RECEIVERS = new Set(['globalThis', 'window', 'self', 'global']);
+/** Methods that turn a `new Date()` into a number, so it can be an offset operand. */
+const DATE_TO_NUMBER = new Set(['getTime', 'valueOf']);
+
+const stringList: JSONSchema4 = {
+  type: 'array',
+  items: { type: 'string', minLength: 1 },
+  uniqueItems: true,
+};
+
+const optionSchema: JSONSchema4 = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    testFileSuffixes: stringList,
+    integrationMarkers: stringList,
+    fakeClockMethods: { ...stringList, minItems: 1 },
+    clockModules: stringList,
+  },
+};
+
+function toPosixRelative(filename: string, cwd: string): string {
+  const relative = path.isAbsolute(filename) ? path.relative(cwd, filename) : filename;
+  return `/${relative.split(path.sep).join('/')}`;
+}
+
+function staticPropertyName(member: TSESTree.MemberExpression): string | null {
+  if (!member.computed && member.property.type === AST_NODE_TYPES.Identifier) {
+    return member.property.name;
+  }
+  if (member.property.type === AST_NODE_TYPES.Literal && typeof member.property.value === 'string') {
+    return member.property.value;
+  }
+  return null;
+}
+
+function stringArgument(node: TSESTree.CallExpression, index: number): string | null {
+  const argument = node.arguments[index];
+  return argument?.type === AST_NODE_TYPES.Literal && typeof argument.value === 'string'
+    ? argument.value
+    : null;
+}
+
+function isIdentifier(node: TSESTree.Node, name: string): boolean {
+  return node.type === AST_NODE_TYPES.Identifier && node.name === name;
+}
+
+/** The called method name for `name()` or `obj.name()`, else null. */
+function calledMethodName(node: TSESTree.CallExpression): string | null {
+  const callee = node.callee;
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  return callee.type === AST_NODE_TYPES.MemberExpression ? staticPropertyName(callee) : null;
+}
+
+/** True for `Date.now()`. */
+function isDateNow(node: TSESTree.CallExpression): boolean {
+  const callee = node.callee;
+  return (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    isIdentifier(callee.object, 'Date') &&
+    staticPropertyName(callee) === 'now'
+  );
+}
+
+/** True when `node` is a direct operand of `+` or `-`: an offset from now. */
+function isOffsetOperand(node: TSESTree.Node): boolean {
+  const parent = node.parent;
+  return (
+    parent?.type === AST_NODE_TYPES.BinaryExpression &&
+    (parent.operator === '+' || parent.operator === '-')
+  );
+}
+
+/** True when an argless `new Date()` is only turned into a number that is offset: `new Date().getTime() + 1000`. */
+function isOffsetDate(node: TSESTree.NewExpression): boolean {
+  const member = node.parent;
+  if (member?.type === AST_NODE_TYPES.UnaryExpression && member.operator === '+') {
+    return isOffsetOperand(member);
+  }
+  if (member?.type !== AST_NODE_TYPES.MemberExpression || member.object !== node) {
+    return false;
+  }
+  const name = staticPropertyName(member);
+  const call = member.parent;
+  return (
+    name !== null &&
+    DATE_TO_NUMBER.has(name) &&
+    call.type === AST_NODE_TYPES.CallExpression &&
+    call.callee === member &&
+    isOffsetOperand(call)
+  );
+}
+
+export const noRealClockInUnitTestsRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Unit tests must not read the real clock (`Date.now()`, `new Date()`) unless the file fakes it; an offset from now (`Date.now() + 60_000`) is allowed.',
+    },
+    schema: [optionSchema],
+    messages: {
+      realClockInUnitTest:
+        '`{{call}}` reads the real clock in a unit test that never fakes it, so the value changes on every run (midnight, month end, DST). Fake the clock (`useFakeTimers()` plus `setSystemTime(...)`), mock the clock module, or use a fixed date. An offset from now (`Date.now() + 60_000`) is allowed.',
+    },
+  },
+  defaultOptions: [
+    {
+      testFileSuffixes: [...DEFAULT_TEST_FILE_SUFFIXES],
+      integrationMarkers: [...DEFAULT_INTEGRATION_MARKERS],
+      fakeClockMethods: [...DEFAULT_FAKE_CLOCK_METHODS],
+      clockModules: [...DEFAULT_CLOCK_MODULES],
+    },
+  ],
+  create(context, [options]) {
+    const testSuffixes = options.testFileSuffixes ?? DEFAULT_TEST_FILE_SUFFIXES;
+    const integrationMarkers = options.integrationMarkers ?? DEFAULT_INTEGRATION_MARKERS;
+    const fakeClockMethods = new Set(options.fakeClockMethods ?? DEFAULT_FAKE_CLOCK_METHODS);
+    const clockModules = options.clockModules ?? DEFAULT_CLOCK_MODULES;
+    const relPath = toPosixRelative(context.filename, context.cwd);
+
+    if (!testSuffixes.some((suffix) => relPath.endsWith(suffix))) {
+      return {};
+    }
+    if (integrationMarkers.some((marker) => relPath.includes(marker))) {
+      return {};
+    }
+
+    const findings: { node: TSESTree.Node; call: string }[] = [];
+    let faked = false;
+
+    /** True when `node` fakes the clock: fake timers, a `Date` spy or stub, or a mocked clock module. */
+    function fakesClock(node: TSESTree.CallExpression): boolean {
+      const method = calledMethodName(node);
+      if (method === null) {
+        return false;
+      }
+      if (fakeClockMethods.has(method)) {
+        return true;
+      }
+      if (method === 'stubGlobal') {
+        return stringArgument(node, 0) === 'Date';
+      }
+      if (method === 'spyOn' || method === 'replaceProperty') {
+        const target = node.arguments[0];
+        const property = stringArgument(node, 1);
+        if (target === undefined || property === null) {
+          return false;
+        }
+        const spiesDateNow = isIdentifier(target, 'Date') && property === 'now';
+        const replacesDate =
+          target.type === AST_NODE_TYPES.Identifier &&
+          GLOBAL_RECEIVERS.has(target.name) &&
+          property === 'Date';
+        return spiesDateNow || replacesDate;
+      }
+      if (MODULE_MOCKERS.has(method) && node.callee.type === AST_NODE_TYPES.MemberExpression) {
+        const specifier = stringArgument(node, 0);
+        return specifier !== null && matchesAny(specifier, clockModules);
+      }
+      return false;
+    }
+
+    return {
+      CallExpression(node: TSESTree.CallExpression): void {
+        if (fakesClock(node)) {
+          faked = true;
+          return;
+        }
+        if (isDateNow(node) && !isOffsetOperand(node)) {
+          findings.push({ node, call: 'Date.now()' });
+        } else if (isIdentifier(node.callee, 'Date') && node.arguments.length === 0) {
+          findings.push({ node, call: 'Date()' });
+        }
+      },
+      NewExpression(node: TSESTree.NewExpression): void {
+        if (isIdentifier(node.callee, 'Date') && node.arguments.length === 0 && !isOffsetDate(node)) {
+          findings.push({ node, call: 'new Date()' });
+        }
+      },
+      AssignmentExpression(node: TSESTree.AssignmentExpression): void {
+        // `Date.now = () => 0` swaps the clock for the file.
+        const target = node.left;
+        if (
+          target.type === AST_NODE_TYPES.MemberExpression &&
+          isIdentifier(target.object, 'Date') &&
+          staticPropertyName(target) === 'now'
+        ) {
+          faked = true;
+        }
+      },
+      'Program:exit'(): void {
+        if (faked) {
+          return;
+        }
+        for (const { node, call } of findings) {
+          context.report({ node, messageId: 'realClockInUnitTest', data: { call } });
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin-code-quality/src/rules/no-sleep-in-unit-tests.ts b/packages/eslint-plugin-code-quality/src/rules/no-sleep-in-unit-tests.ts
new file mode 100644
index 0000000..86976ba
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/src/rules/no-sleep-in-unit-tests.ts
@@ -0,0 +1,356 @@
+import path from 'node:path';
+
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+
+import { createRule } from '../createRule';
+import { type VisitorKeys, walkSome } from '../utils/ast';
+
+const RULE_NAME = 'no-sleep-in-unit-tests';
+
+export interface NoSleepInUnitTestsOptions {
+  /** A file is a unit test when its path ends with one of these. */
+  readonly testFileSuffixes?: readonly string[];
+  /** A test file whose project-relative path contains one of these is an integration test and is skipped. */
+  readonly integrationMarkers?: readonly string[];
+  /**
+   * Accept a zero or omitted delay (`setTimeout(resolve, 0)`): it yields one
+   * macrotask, which is the idiomatic flush inside `act(...)`, not a wait on
+   * the clock.
+   */
+  readonly allowZeroDelay?: boolean;
+  /**
+   * Method names that install fake timers (`vi.useFakeTimers()`,
+   * `jest.useFakeTimers()`). A file that calls one anywhere drives its timers
+   * virtually, so its timer promises cost no wall-clock time.
+   */
+  readonly fakeTimerMethods?: readonly string[];
+}
+
+type RuleOptions = [NoSleepInUnitTestsOptions];
+type MessageIds = 'sleepInUnitTest';
+
+const DEFAULT_TEST_FILE_SUFFIXES: readonly string[] = [
+  '.test.ts',
+  '.test.tsx',
+  '.spec.ts',
+  '.spec.tsx',
+  '.test.js',
+  '.test.jsx',
+  '.spec.js',
+  '.spec.jsx',
+];
+
+const DEFAULT_INTEGRATION_MARKERS: readonly string[] = [
+  '.integration.test.',
+  '.integration.spec.',
+  '.e2e.test.',
+  '.e2e.spec.',
+  '.e2e-spec.',
+  '/integration/',
+  '/e2e/',
+];
+
+const DEFAULT_ALLOW_ZERO_DELAY = true;
+const DEFAULT_FAKE_TIMER_METHODS: readonly string[] = ['useFakeTimers'];
+
+const TIMERS_PROMISES_MODULES = new Set(['timers/promises', 'node:timers/promises']);
+/** Exports of `timers/promises` that wait for a delay given as the first argument. */
+const TIMERS_PROMISES_SLEEPS = new Set(['setTimeout']);
+const TIMER_RECEIVERS = new Set(['globalThis', 'window', 'self', 'global']);
+const CLEAR_TIMERS = new Set(['clearTimeout', 'clearInterval']);
+
+const stringList: JSONSchema4 = {
+  type: 'array',
+  items: { type: 'string', minLength: 1 },
+  uniqueItems: true,
+};
+
+const optionSchema: JSONSchema4 = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    testFileSuffixes: stringList,
+    integrationMarkers: stringList,
+    allowZeroDelay: { type: 'boolean' },
+    fakeTimerMethods: { ...stringList, minItems: 1 },
+  },
+};
+
+type FunctionNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+
+function toPosixRelative(filename: string, cwd: string): string {
+  const relative = path.isAbsolute(filename) ? path.relative(cwd, filename) : filename;
+  return `/${relative.split(path.sep).join('/')}`;
+}
+
+function isFunction(node: TSESTree.Node): node is FunctionNode {
+  return (
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === AST_NODE_TYPES.FunctionExpression
+  );
+}
+
+function staticPropertyName(member: TSESTree.MemberExpression): string | null {
+  if (!member.computed && member.property.type === AST_NODE_TYPES.Identifier) {
+    return member.property.name;
+  }
+  if (member.property.type === AST_NODE_TYPES.Literal && typeof member.property.value === 'string') {
+    return member.property.value;
+  }
+  return null;
+}
+
+/** True for `setTimeout` and `globalThis.setTimeout` (and the other global receivers). */
+function isGlobalSetTimeout(callee: TSESTree.Node): boolean {
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name === 'setTimeout';
+  }
+  return (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    callee.object.type === AST_NODE_TYPES.Identifier &&
+    TIMER_RECEIVERS.has(callee.object.name) &&
+    staticPropertyName(callee) === 'setTimeout'
+  );
+}
+
+/** The nearest enclosing function of `node`, or null at the top level. */
+function enclosingFunction(node: TSESTree.Node): TSESTree.Node | null {
+  let current: TSESTree.Node | undefined = node.parent;
+  while (current !== undefined) {
+    if (isFunction(current) || current.type === AST_NODE_TYPES.FunctionDeclaration) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+/** The executor's `resolve` parameter name when `fn` is `new Promise(fn)`'s executor. */
+function promiseResolveName(fn: TSESTree.Node | null): string | null {
+  if (fn === null || !isFunction(fn)) {
+    return null;
+  }
+  const parent = fn.parent;
+  if (
+    parent.type !== AST_NODE_TYPES.NewExpression ||
+    parent.callee.type !== AST_NODE_TYPES.Identifier ||
+    parent.callee.name !== 'Promise' ||
+    parent.arguments[0] !== fn
+  ) {
+    return null;
+  }
+  const resolve = fn.params[0];
+  return resolve?.type === AST_NODE_TYPES.Identifier ? resolve.name : null;
+}
+
+/** True when the timer callback settles the promise by resolving it (not a reject-only timeout guard). */
+function resolvesPromise(
+  callback: TSESTree.Node | undefined,
+  resolveName: string,
+  keys: VisitorKeys,
+): boolean {
+  if (callback === undefined) {
+    return false;
+  }
+  if (callback.type === AST_NODE_TYPES.Identifier) {
+    return callback.name === resolveName;
+  }
+  return (
+    isFunction(callback) &&
+    walkSome(
+      callback.body,
+      keys,
+      (node) =>
+        node.type === AST_NODE_TYPES.CallExpression &&
+        node.callee.type === AST_NODE_TYPES.Identifier &&
+        node.callee.name === resolveName,
+    )
+  );
+}
+
+/**
+ * The node the timer's handle is kept in (`timer = setTimeout(...)`,
+ * `const t = setTimeout(...)`), or null. A kept handle that the file later
+ * passes to `clearTimeout` is a deadline raced against real work, not a sleep.
+ */
+function handleTarget(node: TSESTree.CallExpression): TSESTree.Node | null {
+  const parent = node.parent;
+  if (parent.type === AST_NODE_TYPES.AssignmentExpression && parent.right === node) {
+    return parent.left;
+  }
+  if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init === node) {
+    return parent.id;
+  }
+  return null;
+}
+
+/** True for `clearTimeout` / `clearInterval`, also on a global receiver. */
+function isClearTimer(callee: TSESTree.Node): boolean {
+  const name =
+    callee.type === AST_NODE_TYPES.Identifier
+      ? callee.name
+      : callee.type === AST_NODE_TYPES.MemberExpression &&
+          callee.object.type === AST_NODE_TYPES.Identifier &&
+          TIMER_RECEIVERS.has(callee.object.name)
+        ? staticPropertyName(callee)
+        : null;
+  return name !== null && CLEAR_TIMERS.has(name);
+}
+
+/** True for an omitted delay or a literal `0`. */
+function isZeroDelay(delay: TSESTree.Node | undefined): boolean {
+  return delay === undefined || (delay.type === AST_NODE_TYPES.Literal && delay.value === 0);
+}
+
+/** True when `init` is `promisify(setTimeout)` or `util.promisify(setTimeout)`. */
+function isPromisifiedSetTimeout(init: TSESTree.Expression | null): boolean {
+  if (init?.type !== AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  const callee = init.callee;
+  const name =
+    callee.type === AST_NODE_TYPES.Identifier
+      ? callee.name
+      : callee.type === AST_NODE_TYPES.MemberExpression
+        ? staticPropertyName(callee)
+        : null;
+  const target = init.arguments[0];
+  return name === 'promisify' && target !== undefined && isGlobalSetTimeout(target);
+}
+
+export const noSleepInUnitTestsRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Unit tests must not sleep on the real clock (`new Promise((r) => setTimeout(r, n))`, `timers/promises`): fake the timers or wait for the condition.',
+    },
+    schema: [optionSchema],
+    messages: {
+      sleepInUnitTest:
+        'This unit test sleeps on the real clock (delay `{{delay}}`), so it is slow and flaky under load. Fake the timers and advance them, or wait for the condition itself (`waitFor`, `findBy*`, the promise under test).',
+    },
+  },
+  defaultOptions: [
+    {
+      testFileSuffixes: [...DEFAULT_TEST_FILE_SUFFIXES],
+      integrationMarkers: [...DEFAULT_INTEGRATION_MARKERS],
+      allowZeroDelay: DEFAULT_ALLOW_ZERO_DELAY,
+      fakeTimerMethods: [...DEFAULT_FAKE_TIMER_METHODS],
+    },
+  ],
+  create(context, [options]) {
+    const testSuffixes = options.testFileSuffixes ?? DEFAULT_TEST_FILE_SUFFIXES;
+    const integrationMarkers = options.integrationMarkers ?? DEFAULT_INTEGRATION_MARKERS;
+    const allowZeroDelay = options.allowZeroDelay ?? DEFAULT_ALLOW_ZERO_DELAY;
+    const fakeTimerMethods = new Set(options.fakeTimerMethods ?? DEFAULT_FAKE_TIMER_METHODS);
+    const relPath = toPosixRelative(context.filename, context.cwd);
+
+    if (!testSuffixes.some((suffix) => relPath.endsWith(suffix))) {
+      return {};
+    }
+    if (integrationMarkers.some((marker) => relPath.includes(marker))) {
+      return {};
+    }
+
+    /** Local names that sleep for their first argument: `timers/promises` imports and promisified timers. */
+    const sleepFunctions = new Set<string>();
+    /** Namespace imports of `timers/promises`: `timers.setTimeout(ms)`. */
+    const timerNamespaces = new Set<string>();
+    /** Each sleep found, with the source text of the handle it is kept in, if any. */
+    const findings: { node: TSESTree.Node; delay: string; handle: string | null }[] = [];
+    /** Source text of every handle passed to `clearTimeout` / `clearInterval` in the file. */
+    const clearedHandles = new Set<string>();
+    let fakesTimers = false;
+
+    function record(
+      node: TSESTree.Node,
+      delay: TSESTree.Node | undefined,
+      handle: TSESTree.Node | null = null,
+    ): void {
+      if (allowZeroDelay && isZeroDelay(delay)) {
+        return;
+      }
+      const text = delay === undefined ? '0' : context.sourceCode.getText(delay);
+      const handleText = handle === null ? null : context.sourceCode.getText(handle);
+      findings.push({ node, delay: text, handle: handleText });
+    }
+
+    return {
+      ImportDeclaration(node: TSESTree.ImportDeclaration): void {
+        if (!TIMERS_PROMISES_MODULES.has(node.source.value)) {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            timerNamespaces.add(specifier.local.name);
+          } else if (
+            specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+            specifier.imported.type === AST_NODE_TYPES.Identifier &&
+            TIMERS_PROMISES_SLEEPS.has(specifier.imported.name)
+          ) {
+            sleepFunctions.add(specifier.local.name);
+          }
+        }
+      },
+      VariableDeclarator(node: TSESTree.VariableDeclarator): void {
+        if (node.id.type === AST_NODE_TYPES.Identifier && isPromisifiedSetTimeout(node.init)) {
+          sleepFunctions.add(node.id.name);
+        }
+      },
+      CallExpression(node: TSESTree.CallExpression): void {
+        const callee = node.callee;
+        if (
+          callee.type === AST_NODE_TYPES.MemberExpression &&
+          fakeTimerMethods.has(staticPropertyName(callee) ?? '')
+        ) {
+          fakesTimers = true;
+          return;
+        }
+        if (callee.type === AST_NODE_TYPES.Identifier && sleepFunctions.has(callee.name)) {
+          record(node, node.arguments[0]);
+          return;
+        }
+        if (
+          callee.type === AST_NODE_TYPES.MemberExpression &&
+          callee.object.type === AST_NODE_TYPES.Identifier &&
+          timerNamespaces.has(callee.object.name)
+        ) {
+          const method = staticPropertyName(callee);
+          if (method !== null && TIMERS_PROMISES_SLEEPS.has(method)) {
+            record(node, node.arguments[0]);
+          }
+          return;
+        }
+        if (isClearTimer(callee)) {
+          const handle = node.arguments[0];
+          if (handle !== undefined) {
+            clearedHandles.add(context.sourceCode.getText(handle));
+          }
+          return;
+        }
+        if (!isGlobalSetTimeout(callee)) {
+          return;
+        }
+        const resolveName = promiseResolveName(enclosingFunction(node));
+        const keys = context.sourceCode.visitorKeys;
+        if (resolveName !== null && resolvesPromise(node.arguments[0], resolveName, keys)) {
+          record(node, node.arguments[1], handleTarget(node));
+        }
+      },
+      'Program:exit'(): void {
+        if (fakesTimers) {
+          return;
+        }
+        for (const { node, delay, handle } of findings) {
+          if (handle !== null && clearedHandles.has(handle)) {
+            continue;
+          }
+          context.report({ node, messageId: 'sleepInUnitTest', data: { delay } });
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin-code-quality/src/rules/no-vacuous-expect.ts b/packages/eslint-plugin-code-quality/src/rules/no-vacuous-expect.ts
index 04de0a7..6d3f550 100644
--- a/packages/eslint-plugin-code-quality/src/rules/no-vacuous-expect.ts
+++ b/packages/eslint-plugin-code-quality/src/rules/no-vacuous-expect.ts
@@ -25,10 +25,17 @@ export interface NoVacuousExpectOptions {
    * `.name` for any other member call.
    */
   readonly assertionCallees?: readonly string[];
+  /**
+   * Names of the render root a DOM test render returns (`container`,
+   * `baseElement`, also as `view.container`). A test whose only assertion is
+   * that the root, its first child or its HTML is present is reported. An
+   * empty list turns the check off.
+   */
+  readonly renderRoots?: readonly string[];
 }
 
 type RuleOptions = [NoVacuousExpectOptions];
-type MessageIds = 'typeofExpect' | 'tautologyExpect' | 'soleWeakExpect';
+type MessageIds = 'typeofExpect' | 'tautologyExpect' | 'soleWeakExpect' | 'soleRenderRootExpect';
 
 const DEFAULT_WEAK_MATCHERS: readonly string[] = [
   'toBeDefined',
@@ -39,6 +46,33 @@ const DEFAULT_WEAK_MATCHERS: readonly string[] = [
 
 const DEFAULT_ASSERTION_CALLEES: readonly string[] = ['^assert', '^expect\\w', '\\.expect$'];
 
+const DEFAULT_RENDER_ROOTS: readonly string[] = ['container', 'baseElement'];
+
+/** Members of a render root that only say something rendered: `container.firstChild`. */
+const RENDER_ROOT_MEMBERS = new Set([
+  'firstChild',
+  'firstElementChild',
+  'lastChild',
+  'innerHTML',
+  'outerHTML',
+  'textContent',
+]);
+
+/** Matchers that, on a render root, only prove the render produced something. */
+const RENDER_ROOT_PRESENCE_MATCHERS = new Set([
+  'toBeInTheDocument',
+  'toBeTruthy',
+  'toBeDefined',
+  'toBeVisible',
+  'not.toBeNull',
+  'not.toBeUndefined',
+  'not.toBeFalsy',
+  'not.toBeEmptyDOMElement',
+]);
+
+/** Negated equality matchers that are presence checks when compared with `''`. */
+const EMPTY_STRING_PRESENCE_MATCHERS = new Set(['not.toBe', 'not.toEqual', 'not.toStrictEqual']);
+
 const TYPEOF_RESULTS = new Set([
   'undefined',
   'object',
@@ -64,6 +98,7 @@ const optionSchema: JSONSchema4 = {
       items: { type: 'string', minLength: 1 },
       uniqueItems: true,
     },
+    renderRoots: { type: 'array', items: { type: 'string', minLength: 1 }, uniqueItems: true },
   },
 };
 
@@ -72,7 +107,7 @@ type TestCallback = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpressi
 interface TestFrame {
   readonly node: TestCallback;
   assertions: number;
-  weak: { node: TSESTree.CallExpression; matcher: string } | null;
+  weak: { node: TSESTree.CallExpression; matcher: string; messageId: MessageIds } | null;
 }
 
 interface MatcherCall {
@@ -119,6 +154,47 @@ function matcherCall(node: TSESTree.CallExpression): MatcherCall | null {
   return { root: current, matcher: negated ? `not.${name}` : name };
 }
 
+function memberName(node: TSESTree.MemberExpression): string | null {
+  return !node.computed && node.property.type === AST_NODE_TYPES.Identifier
+    ? node.property.name
+    : null;
+}
+
+/** `x` for `await x`, else the node itself. */
+function unwrapAwait(node: TSESTree.Node | null | undefined): TSESTree.Node | null {
+  if (node === null || node === undefined) {
+    return null;
+  }
+  return node.type === AST_NODE_TYPES.AwaitExpression ? node.argument : node;
+}
+
+/** True for a call to a `render*` function: `render(...)`, `renderIntoDocument(...)`, `rtl.render(...)`. */
+function isRenderCall(node: TSESTree.Node | null): boolean {
+  if (node?.type !== AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  const callee = node.callee;
+  const name =
+    callee.type === AST_NODE_TYPES.Identifier
+      ? callee.name
+      : callee.type === AST_NODE_TYPES.MemberExpression
+        ? memberName(callee)
+        : null;
+  return name !== null && name.startsWith('render');
+}
+
+/** True when `matcher(expected)` only proves the subject is present or non-empty. */
+function isPresenceMatcher(matcher: string, expected: TSESTree.Node | undefined): boolean {
+  if (RENDER_ROOT_PRESENCE_MATCHERS.has(matcher)) {
+    return true;
+  }
+  return (
+    EMPTY_STRING_PRESENCE_MATCHERS.has(matcher) &&
+    expected?.type === AST_NODE_TYPES.Literal &&
+    expected.value === ''
+  );
+}
+
 /** `name`, `obj.name` or `.name` for a callee, used to match `assertionCallees`. */
 function calleePath(callee: TSESTree.Expression): string | null {
   if (callee.type === AST_NODE_TYPES.Identifier) {
@@ -192,7 +268,7 @@ export const noVacuousExpectRule = createRule<RuleOptions, MessageIds>({
     type: 'problem',
     docs: {
       description:
-        'Disallow vacuous expects (`typeof` checks, literal tautologies, a sole `toBeDefined`/`toBeTruthy`): a test must assert behaviour that a real regression would break.',
+        'Disallow vacuous expects (`typeof` checks, literal tautologies, a sole `toBeDefined`/`toBeTruthy`, a sole presence check on the render root): a test must assert behaviour that a real regression would break.',
     },
     schema: [optionSchema],
     messages: {
@@ -202,12 +278,15 @@ export const noVacuousExpectRule = createRule<RuleOptions, MessageIds>({
         'This expect compares a literal with itself and can never fail. Assert something a real regression would break.',
       soleWeakExpect:
         'A sole `{{matcher}}` does not pin behaviour. Assert on the value or the outcome, or delete the test.',
+      soleRenderRootExpect:
+        'The only assertion is that the render root is present (`{{matcher}}`), which passes for anything that renders, an error fallback included. Assert on what the user sees: a role, a label or a text.',
     },
   },
   defaultOptions: [
     {
       weakMatchers: [...DEFAULT_WEAK_MATCHERS],
       assertionCallees: [...DEFAULT_ASSERTION_CALLEES],
+      renderRoots: [...DEFAULT_RENDER_ROOTS],
     },
   ],
   create(context, [options]) {
@@ -215,8 +294,75 @@ export const noVacuousExpectRule = createRule<RuleOptions, MessageIds>({
     const assertionCallees = (options.assertionCallees ?? DEFAULT_ASSERTION_CALLEES).map(
       (source) => new RegExp(source, 'u'),
     );
+    const renderRoots = new Set(options.renderRoots ?? DEFAULT_RENDER_ROOTS);
     const stack: TestFrame[] = [];
 
+    /** The declarator that binds `identifier`, when it is a `const` / `let` / `var` binding. */
+    function declaratorOf(identifier: TSESTree.Identifier): TSESTree.VariableDeclarator | null {
+      let scope: ReturnType<typeof context.sourceCode.getScope> | null =
+        context.sourceCode.getScope(identifier);
+      while (scope !== null) {
+        const variable = scope.set.get(identifier.name);
+        if (variable !== undefined) {
+          const node = variable.defs[0]?.node;
+          return node?.type === AST_NODE_TYPES.VariableDeclarator ? node : null;
+        }
+        scope = scope.upper;
+      }
+      return null;
+    }
+
+    /** True for a value that is a render result: a call, or a binding initialised from one. */
+    function isRenderResult(node: TSESTree.Node): boolean {
+      if (unwrapAwait(node)?.type === AST_NODE_TYPES.CallExpression) {
+        return true;
+      }
+      if (node.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+      }
+      const init = unwrapAwait(declaratorOf(node)?.init);
+      return init?.type === AST_NODE_TYPES.CallExpression;
+    }
+
+    /**
+     * True for a render root that comes from a render: `const { container } = render(...)`,
+     * `const container = render(...).container`, `const container = renderIntoDocument(...)`,
+     * `view.container` where `view = render(...)`, or `render(...).container`.
+     */
+    function isRenderRoot(node: TSESTree.Node): boolean {
+      if (node.type === AST_NODE_TYPES.MemberExpression) {
+        const name = memberName(node);
+        return name !== null && renderRoots.has(name) && isRenderResult(node.object);
+      }
+      if (node.type !== AST_NODE_TYPES.Identifier || !renderRoots.has(node.name)) {
+        return false;
+      }
+      const declarator = declaratorOf(node);
+      const init = unwrapAwait(declarator?.init);
+      if (declarator === null || init === null) {
+        return false;
+      }
+      if (declarator.id.type === AST_NODE_TYPES.ObjectPattern) {
+        return init.type === AST_NODE_TYPES.CallExpression;
+      }
+      return isRenderCall(init) || (init.type === AST_NODE_TYPES.MemberExpression && isRenderRoot(init));
+    }
+
+    /** True for an expect subject that is the render root or a presence-only member of it. */
+    function isRenderRootSubject(node: TSESTree.Node | undefined): boolean {
+      if (node === undefined) {
+        return false;
+      }
+      if (isRenderRoot(node)) {
+        return true;
+      }
+      if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      const name = memberName(node);
+      return name !== null && RENDER_ROOT_MEMBERS.has(name) && isRenderRoot(node.object);
+    }
+
     function enter(node: TestCallback): void {
       if (isTestCallback(node)) {
         stack.push({ node, assertions: 0, weak: null });
@@ -232,7 +378,7 @@ export const noVacuousExpectRule = createRule<RuleOptions, MessageIds>({
       if (frame.assertions === 1 && frame.weak !== null) {
         context.report({
           node: frame.weak.node,
-          messageId: 'soleWeakExpect',
+          messageId: frame.weak.messageId,
           data: { matcher: frame.weak.matcher },
         });
       }
@@ -256,8 +402,13 @@ export const noVacuousExpectRule = createRule<RuleOptions, MessageIds>({
 
         if (frame !== undefined) {
           frame.assertions += 1;
-          if (weakMatchers.has(call.matcher)) {
-            frame.weak = { node, matcher: call.matcher };
+          if (
+            isRenderRootSubject(call.root.arguments[0]) &&
+            isPresenceMatcher(call.matcher, node.arguments[0])
+          ) {
+            frame.weak = { node, matcher: call.matcher, messageId: 'soleRenderRootExpect' };
+          } else if (weakMatchers.has(call.matcher)) {
+            frame.weak = { node, matcher: call.matcher, messageId: 'soleWeakExpect' };
           }
         }
 
diff --git a/packages/eslint-plugin-code-quality/src/rules/skipped-tests-need-tracking.ts b/packages/eslint-plugin-code-quality/src/rules/skipped-tests-need-tracking.ts
index 342a156..60433d6 100644
--- a/packages/eslint-plugin-code-quality/src/rules/skipped-tests-need-tracking.ts
+++ b/packages/eslint-plugin-code-quality/src/rules/skipped-tests-need-tracking.ts
@@ -1,3 +1,4 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
 
 import { createRule } from '../createRule';
@@ -26,6 +27,13 @@ type MessageIds = 'needsTracking';
  * line by line rather than through the AST, so a marker in a trailing or
  * preceding comment (or anywhere in the lookback window) is honoured exactly as
  * a human reviewer would read it.
+ *
+ * `node:test` skips a test through its options (`test('x', { skip: true })`,
+ * `{ todo: 'reason' }`) or its context (`t.skip()`, `t.todo()`). Those are read
+ * from the AST, because only an UNCONDITIONAL skip is debt: `{ skip:
+ * process.platform === 'win32' }` or a `t.skip('POSIX only')` inside an `if` is
+ * a platform guard, not a test someone meant to come back to. The marker is
+ * looked up the same way, from the line of the option or the call.
  */
 const SKIP_PATTERNS: readonly { pattern: RegExp; label: string }[] = [
   { pattern: /\b(?:it|test|describe)\.skip\s*\(/u, label: '.skip(' },
@@ -35,6 +43,11 @@ const SKIP_PATTERNS: readonly { pattern: RegExp; label: string }[] = [
   { pattern: /\bxtest\s*\(/u, label: 'xtest(' },
 ];
 
+/** Runners whose options object may carry `skip` / `todo` (`node:test`, and `t.test` subtests). */
+const NODE_TEST_RUNNERS = new Set(['test', 'it', 'describe', 'suite']);
+/** Option keys and context methods that skip a `node:test` test. */
+const NODE_TEST_SKIPS = new Set(['skip', 'todo']);
+
 const DEFAULT_MARKERS: readonly string[] = ['https?://\\S+', 'TODO\\(@?\\S+\\)'];
 const DEFAULT_LOOKBACK = 30;
 
@@ -52,13 +65,92 @@ const optionSchema: JSONSchema4 = {
   },
 };
 
+/** Root identifier of a test callee: `test`, `describe.skip`, `test.each(table)`. */
+function runnerName(callee: TSESTree.Node): string | null {
+  let current: TSESTree.Node = callee;
+  while (
+    current.type === AST_NODE_TYPES.MemberExpression ||
+    current.type === AST_NODE_TYPES.CallExpression
+  ) {
+    current = current.type === AST_NODE_TYPES.MemberExpression ? current.object : current.callee;
+  }
+  return current.type === AST_NODE_TYPES.Identifier ? current.name : null;
+}
+
+/** True for a call to a test runner, including a subtest (`t.test(...)`). */
+function isRunnerCall(node: TSESTree.CallExpression): boolean {
+  const callee = node.callee;
+  const root = runnerName(callee);
+  if (root !== null && NODE_TEST_RUNNERS.has(root)) {
+    return true;
+  }
+  return (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    !callee.computed &&
+    callee.property.type === AST_NODE_TYPES.Identifier &&
+    NODE_TEST_RUNNERS.has(callee.property.name)
+  );
+}
+
+function propertyKey(property: TSESTree.Property): string | null {
+  if (property.computed) {
+    return null;
+  }
+  if (property.key.type === AST_NODE_TYPES.Identifier) {
+    return property.key.name;
+  }
+  return property.key.type === AST_NODE_TYPES.Literal && typeof property.key.value === 'string'
+    ? property.key.value
+    : null;
+}
+
+/**
+ * True when an option value always skips: any truthy literal (`true`, `1`, a
+ * non-empty string). A computed value is a guard.
+ */
+function isUnconditionalSkip(value: TSESTree.Node): boolean {
+  if (value.type === AST_NODE_TYPES.Literal) {
+    return 'regex' in value || Boolean(value.value);
+  }
+  return (
+    value.type === AST_NODE_TYPES.TemplateLiteral &&
+    value.expressions.length === 0 &&
+    value.quasis.some((quasi) => quasi.value.cooked !== '')
+  );
+}
+
+/**
+ * The context parameter name when `node` is a statement of a test callback's
+ * own body (`async (t) => { t.skip(); ... }`), else null. A call nested in an
+ * `if`, a loop or a helper is conditional.
+ */
+function unconditionalContextName(node: TSESTree.CallExpression): string | null {
+  // `await t.skip()` is the same statement as `t.skip()`.
+  const statement = node.parent.type === AST_NODE_TYPES.AwaitExpression ? node.parent.parent : node.parent;
+  const body = statement.type === AST_NODE_TYPES.ExpressionStatement ? statement.parent : statement;
+  const fn = body?.type === AST_NODE_TYPES.BlockStatement ? body.parent : body;
+  if (
+    fn === undefined ||
+    (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+      fn.type !== AST_NODE_TYPES.FunctionExpression)
+  ) {
+    return null;
+  }
+  const runner = fn.parent;
+  if (runner.type !== AST_NODE_TYPES.CallExpression || !isRunnerCall(runner)) {
+    return null;
+  }
+  const context = fn.params[0];
+  return context?.type === AST_NODE_TYPES.Identifier ? context.name : null;
+}
+
 export const skippedTestsNeedTrackingRule = createRule<RuleOptions, MessageIds>({
   name: RULE_NAME,
   meta: {
     type: 'problem',
     docs: {
       description:
-        'Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently.',
+        'Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`, and unconditional `node:test` `{ skip }` / `{ todo }` / `t.skip()`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently.',
     },
     schema: [optionSchema],
     messages: {
@@ -78,7 +170,52 @@ export const skippedTestsNeedTrackingRule = createRule<RuleOptions, MessageIds>(
       return markers.some((marker) => marker.test(window));
     }
 
+    /** Report `label` on the 1-based `line` unless a marker sits in its lookback window. */
+    function checkLine(line: number, label: string): void {
+      const index = line - 1;
+      if (hasTrackingMarker(Math.max(0, index - lookback), index)) {
+        return;
+      }
+      const text = lines[index] ?? '';
+      context.report({
+        loc: { start: { line, column: 0 }, end: { line, column: text.length } },
+        messageId: 'needsTracking',
+        data: { label },
+      });
+    }
+
     return {
+      CallExpression(node: TSESTree.CallExpression): void {
+        if (isRunnerCall(node)) {
+          for (const argument of node.arguments) {
+            if (argument.type !== AST_NODE_TYPES.ObjectExpression) {
+              continue;
+            }
+            for (const property of argument.properties) {
+              if (property.type !== AST_NODE_TYPES.Property) {
+                continue;
+              }
+              const key = propertyKey(property);
+              if (key !== null && NODE_TEST_SKIPS.has(key) && isUnconditionalSkip(property.value)) {
+                checkLine(property.loc.start.line, `{ ${key} }`);
+              }
+            }
+          }
+        }
+        const callee = node.callee;
+        if (
+          callee.type !== AST_NODE_TYPES.MemberExpression ||
+          callee.computed ||
+          callee.property.type !== AST_NODE_TYPES.Identifier ||
+          !NODE_TEST_SKIPS.has(callee.property.name) ||
+          callee.object.type !== AST_NODE_TYPES.Identifier
+        ) {
+          return;
+        }
+        if (unconditionalContextName(node) === callee.object.name) {
+          checkLine(node.loc.start.line, `${callee.object.name}.${callee.property.name}(`);
+        }
+      },
       Program(): void {
         for (let i = 0; i < lines.length; i++) {
           const line = lines[i] ?? '';
diff --git a/packages/eslint-plugin-code-quality/src/rules/typed-mock-over-double-cast.ts b/packages/eslint-plugin-code-quality/src/rules/typed-mock-over-double-cast.ts
new file mode 100644
index 0000000..34cde27
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/src/rules/typed-mock-over-double-cast.ts
@@ -0,0 +1,153 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+
+import { createRule } from '../createRule';
+import { matchesAny } from '../utils/allowMatch';
+import { walkSome } from '../utils/ast';
+
+const RULE_NAME = 'typed-mock-over-double-cast';
+
+export interface TypedMockOverDoubleCastOptions {
+  /** Callees that create a mock function (`jest.fn`, `vi.fn`), as `name` or `obj.name`. */
+  readonly mockFactories?: readonly string[];
+  /**
+   * Globs matched against the cast target: its type name (`PrismaService`,
+   * `Prisma.TransactionClient`) and its full source text
+   * (`Parameters<Guard['canActivate']>[0]`). A matching target may be
+   * double-cast, for types too wide to `Pick` from.
+   */
+  readonly allowTargets?: readonly string[];
+}
+
+type RuleOptions = [TypedMockOverDoubleCastOptions];
+type MessageIds = 'doubleCastMock';
+
+const DEFAULT_MOCK_FACTORIES: readonly string[] = ['jest.fn', 'vi.fn'];
+const DEFAULT_ALLOW_TARGETS: readonly string[] = [];
+
+const optionSchema: JSONSchema4 = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    mockFactories: {
+      type: 'array',
+      items: { type: 'string', minLength: 1 },
+      uniqueItems: true,
+      minItems: 1,
+    },
+    allowTargets: { type: 'array', items: { type: 'string', minLength: 1 }, uniqueItems: true },
+  },
+};
+
+/** `name` or `obj.name` for a callee, else null. */
+function calleePath(callee: TSESTree.Expression): string | null {
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    !callee.computed &&
+    callee.property.type === AST_NODE_TYPES.Identifier &&
+    callee.object.type === AST_NODE_TYPES.Identifier
+  ) {
+    return `${callee.object.name}.${callee.property.name}`;
+  }
+  return null;
+}
+
+/** The dotted name of a type reference (`Prisma.TransactionClient`), else null. */
+function typeName(node: TSESTree.TypeNode): string | null {
+  if (node.type !== AST_NODE_TYPES.TSTypeReference) {
+    return null;
+  }
+  const parts: string[] = [];
+  let current: TSESTree.EntityName = node.typeName;
+  while (current.type === AST_NODE_TYPES.TSQualifiedName) {
+    parts.unshift(current.right.name);
+    current = current.left;
+  }
+  if (current.type !== AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  parts.unshift(current.name);
+  return parts.join('.');
+}
+
+/** True for `unknown`, `any` and `never`, the cast targets that switch the checker off. */
+function isEscapeType(node: TSESTree.TypeNode): boolean {
+  return (
+    node.type === AST_NODE_TYPES.TSUnknownKeyword ||
+    node.type === AST_NODE_TYPES.TSAnyKeyword ||
+    node.type === AST_NODE_TYPES.TSNeverKeyword
+  );
+}
+
+type Cast = TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+
+/** True for a cast written either way: `x as T` or `<T>x`. */
+function isCast(node: TSESTree.Node): node is Cast {
+  return node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
+}
+
+export const typedMockOverDoubleCastRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow an object literal of `jest.fn()` / `vi.fn()` mocks cast `as unknown as T`: the double cast switches type checking off, so a mock of a renamed or removed method keeps passing.',
+    },
+    schema: [optionSchema],
+    messages: {
+      doubleCastMock:
+        'This object of mocks is cast `as unknown as {{target}}`, so the checker no longer sees it: a mock of a renamed or removed method keeps passing. Type it as `jest.Mocked<Pick<{{target}}, ...>>` (`Mocked<Pick<...>>` in Vitest), or check it with `satisfies Partial<{{target}}>`.',
+    },
+  },
+  defaultOptions: [
+    {
+      mockFactories: [...DEFAULT_MOCK_FACTORIES],
+      allowTargets: [...DEFAULT_ALLOW_TARGETS],
+    },
+  ],
+  create(context, [options]) {
+    const mockFactories = new Set(options.mockFactories ?? DEFAULT_MOCK_FACTORIES);
+    const allowTargets = options.allowTargets ?? DEFAULT_ALLOW_TARGETS;
+    const keys = context.sourceCode.visitorKeys;
+
+    function isMockCall(node: TSESTree.Node): boolean {
+      if (node.type !== AST_NODE_TYPES.CallExpression) {
+        return false;
+      }
+      const path = calleePath(node.callee);
+      return path !== null && mockFactories.has(path);
+    }
+
+    /** Report an object of mocks cast through `unknown` / `any` / `never` to a real type. */
+    function checkCast(node: Cast): void {
+      const inner = node.expression;
+      if (
+        isEscapeType(node.typeAnnotation) ||
+        !isCast(inner) ||
+        !isEscapeType(inner.typeAnnotation) ||
+        inner.expression.type !== AST_NODE_TYPES.ObjectExpression
+      ) {
+        return;
+      }
+      if (!walkSome(inner.expression, keys, isMockCall)) {
+        return;
+      }
+      const text = context.sourceCode.getText(node.typeAnnotation);
+      const name = typeName(node.typeAnnotation);
+      const candidates = name === null ? [text] : [name, text];
+      if (candidates.some((candidate) => matchesAny(candidate, allowTargets))) {
+        return;
+      }
+      context.report({ node, messageId: 'doubleCastMock', data: { target: text } });
+    }
+
+    return {
+      TSAsExpression: checkCast,
+      TSTypeAssertion: checkCast,
+    };
+  },
+});
diff --git a/packages/eslint-plugin-code-quality/src/utils/ast.ts b/packages/eslint-plugin-code-quality/src/utils/ast.ts
index 7d6058e..d1300d2 100644
--- a/packages/eslint-plugin-code-quality/src/utils/ast.ts
+++ b/packages/eslint-plugin-code-quality/src/utils/ast.ts
@@ -27,3 +27,40 @@ export function isStaticMemberAccess(
   }
   return node.property.type === AST_NODE_TYPES.Identifier && node.property.name === propertyName;
 }
+
+/** Child keys per node type, from the parser (`context.sourceCode.visitorKeys`). */
+export type VisitorKeys = Readonly<Record<string, readonly string[] | undefined>>;
+
+function isNode(value: unknown): value is TSESTree.Node {
+  return typeof value === 'object' && value !== null && 'type' in value;
+}
+
+/**
+ * True when any node in the subtree satisfies `predicate`. Walks the parser's
+ * visitor keys, so `parent` back-links are never followed.
+ */
+export function walkSome(
+  root: TSESTree.Node,
+  keys: VisitorKeys,
+  predicate: (node: TSESTree.Node) => boolean,
+): boolean {
+  const stack: TSESTree.Node[] = [root];
+  for (let node = stack.pop(); node !== undefined; node = stack.pop()) {
+    if (predicate(node)) {
+      return true;
+    }
+    for (const key of keys[node.type] ?? []) {
+      const value: unknown = Reflect.get(node, key);
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (isNode(child)) {
+            stack.push(child);
+          }
+        }
+      } else if (isNode(value)) {
+        stack.push(value);
+      }
+    }
+  }
+  return false;
+}
diff --git a/packages/eslint-plugin-code-quality/tests/configs/recommended.test.ts b/packages/eslint-plugin-code-quality/tests/configs/recommended.test.ts
index 6061d48..82d5677 100644
--- a/packages/eslint-plugin-code-quality/tests/configs/recommended.test.ts
+++ b/packages/eslint-plugin-code-quality/tests/configs/recommended.test.ts
@@ -12,6 +12,10 @@ function severityOf(entry: unknown): unknown {
 const OMITTED_FROM_PRESETS = [
   'interface-prefix-i',
   'no-template-trim-empty-ternary',
+  'no-message-only-throw-assertion',
+  'no-sleep-in-unit-tests',
+  'no-real-clock-in-unit-tests',
+  'typed-mock-over-double-cast',
 ];
 
 describe('presets', () => {
diff --git a/packages/eslint-plugin-code-quality/tests/rules/no-message-only-throw-assertion.test.ts b/packages/eslint-plugin-code-quality/tests/rules/no-message-only-throw-assertion.test.ts
new file mode 100644
index 0000000..8f11e5f
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/tests/rules/no-message-only-throw-assertion.test.ts
@@ -0,0 +1,301 @@
+import { ruleTester } from '@noctcore/eslint-test-utils';
+
+import { noMessageOnlyThrowAssertionRule } from '../../src/rules/no-message-only-throw-assertion';
+
+ruleTester.run('no-message-only-throw-assertion', noMessageOnlyThrowAssertionRule, {
+  valid: [
+    // An error class argument pins the type.
+    { code: "it('refuses', () => { expect(() => parse('x')).toThrow(ValidationError); });" },
+    { code: "it('refuses', async () => { await expect(load(1)).rejects.toThrowError(NotFoundError); });" },
+    { code: "it('refuses', () => { expect(() => run()).toThrow(errors.Forbidden); });" },
+    // A structural rejection assertion instead of a throw matcher.
+    {
+      code: "it('refuses', async () => { await expect(load(1)).rejects.toMatchObject({ code: 'NOT_FOUND' }); });",
+    },
+    // An asymmetric matcher argument checks the shape, not only the wording.
+    {
+      code: "it('refuses', () => { expect(() => run()).toThrow(expect.objectContaining({ code: 'E_LOCKED' })); });",
+    },
+    // A negated throw assertion says nothing about the class.
+    { code: "it('stays quiet', () => { expect(() => writePrompt('user-1:a')).not.toThrow(); });" },
+    { code: "it('resolves', async () => { await expect(load(1)).resolves.not.toThrow(); });" },
+    // An error instance pins the class under Vitest semantics (the default).
+    { code: "it('refuses', () => { expect(() => run()).toThrow(new ForbiddenError('No access')); });" },
+    // Class and message asserted separately on the same subject.
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(service.find(id)).rejects.toThrow(NotFoundError);
+          await expect(service.find(id)).rejects.toThrow('Employee not found.');
+        });
+      `,
+    },
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(service.find(id)).rejects.toBeInstanceOf(NotFoundError);
+          await expect(service.find(id)).rejects.toThrow('Employee not found.');
+        });
+      `,
+    },
+    // A class pinned in an enclosing block covers a message check in a nested one.
+    {
+      code: `
+        it('refuses every role', async () => {
+          await expect(service.find(id)).rejects.toThrow(NotFoundError);
+          for (const role of roles) {
+            await expect(service.find(id)).rejects.toThrow('Employee not found.');
+          }
+        });
+      `,
+    },
+    // Rejects matchers that check more than the message pin the class.
+    { code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toMatchObject({ name: 'ForbiddenError', message: 'No access' });
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      ` },
+    { code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toHaveProperty('code', 'E_FORBIDDEN');
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      ` },
+    { code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toMatchObject(expect.any(ForbiddenError));
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      ` },
+    // Under Vitest semantics (the default) an error instance compares its name too.
+    { code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toEqual(new ForbiddenError('No access'));
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      ` },
+    // A message snapshot next to a class pin on the same subject.
+    {
+      code: `
+        it('refuses', () => {
+          expect(() => guard.check(guest)).toThrow(ForbiddenError);
+          expect(() => guard.check(guest)).toThrowErrorMatchingInlineSnapshot(\`"No access"\`);
+        });
+      `,
+    },
+    // A configured helper that pins the class, called on the same subject.
+    {
+      code: `
+        it('refuses', async () => {
+          await expectRejectsDomainError(service.find(id), { type: NotFoundError, appCode: 'EMPLOYEE_NOT_FOUND' });
+          await expect(service.find(id)).rejects.toThrow('Employee not found.');
+        });
+      `,
+      options: [{ assertionHelpers: ['^expectRejectsDomainError$'] }],
+    },
+    // allowMessageOnly keeps only the argless form in scope.
+    {
+      code: "it('refuses', () => { expect(() => toApiPath(url)).toThrow('Refusing a non-relative api path'); });",
+      options: [{ allowMessageOnly: true }],
+    },
+    // A matcher outside the configured list is not a throw assertion.
+    {
+      code: "it('refuses', () => { expect(() => run()).toThrowError(); });",
+      options: [{ throwMatchers: ['toThrow'] }],
+    },
+    // Not an expect chain.
+    { code: 'emitter.toThrow();' },
+  ],
+  invalid: [
+    // Settly shape: a Prisma rejection asserted with no argument.
+    {
+      code: `
+        it('blocks the cross-tenant delete', async () => {
+          await expect(client.firma.delete({ where: { id: firmaA.id } })).rejects.toThrow();
+        });
+      `,
+      errors: [{ messageId: 'bareThrow', data: { matcher: 'toThrow' } }],
+    },
+    {
+      code: "it('throws', () => { expect(() => parse('x')).toThrowError(); });",
+      errors: [{ messageId: 'bareThrow', data: { matcher: 'toThrowError' } }],
+    },
+    // Settly shape: a string message only.
+    {
+      code: "it('refuses', () => { expect(() => toApiPath(url)).toThrow('Refusing a non-relative api path'); });",
+      errors: [{ messageId: 'messageOnlyThrow', data: { matcher: 'toThrow' } }],
+    },
+    {
+      code: "it('bubbles', async () => { await expect(run()).rejects.toThrow('boom'); });",
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    // A regex, a template and a built RegExp are all message checks.
+    {
+      code: "it('refuses', () => { expect(() => run()).toThrow(/not in stock/); });",
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    {
+      code: 'it(\'refuses\', () => { expect(() => run()).toThrow(`Queue ${name} missing`); });',
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    {
+      code: 'it(\'refuses\', () => { expect(() => service.onModuleInit()).toThrow(new RegExp(`Queue "${missing}" is declared`)); });',
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    // Under Jest semantics an error instance compares only its message.
+    {
+      code: "it('refuses', () => { expect(() => run()).toThrow(new ForbiddenError('No access')); });",
+      options: [{ trustErrorInstances: false }],
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    // allowMessageOnly still reports the argless form.
+    {
+      code: "it('throws', async () => { await expect(load()).rejects.toThrow(); });",
+      options: [{ allowMessageOnly: true }],
+      errors: [{ messageId: 'bareThrow' }],
+    },
+    // Pinning a DIFFERENT subject does not pair.
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(service.find(a)).rejects.toThrow(NotFoundError);
+          await expect(service.find(b)).rejects.toThrow('Employee not found.');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    // A pin in another test does not pair.
+    {
+      code: `
+        it('pins', async () => { await expect(service.find(id)).rejects.toThrow(NotFoundError); });
+        it('words', async () => { await expect(service.find(id)).rejects.toThrow('Employee not found.'); });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 3 }],
+    },
+    // A pinned class never excuses a bare throw: the second call is another scenario.
+    {
+      code: `
+        it('refuses deleted records', async () => {
+          await expect(svc.get(id)).rejects.toThrow(NotFound);
+          repo.find.mockResolvedValue({ deleted: true });
+          await expect(svc.get(id)).rejects.toThrow();
+        });
+      `,
+      errors: [{ messageId: 'bareThrow', line: 5 }],
+    },
+    // A pin in one branch does not cover a message check in the other.
+    {
+      code: `
+        it('refuses', async () => {
+          if (strict) {
+            await expect(service.find(id)).rejects.toThrow(NotFoundError);
+          } else {
+            await expect(service.find(id)).rejects.toThrow('Employee not found.');
+          }
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 6 }],
+    },
+    // A pin nested deeper than the message check may not run.
+    {
+      code: `
+        it('refuses', async () => {
+          if (strict) {
+            await expect(service.find(id)).rejects.toThrow(NotFoundError);
+          }
+          await expect(service.find(id)).rejects.toThrow('Employee not found.');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 6 }],
+    },
+    // Under Jest semantics toEqual / toStrictEqual compare two errors by message only.
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toEqual(new ForbiddenError('No access'));
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      options: [{ trustErrorInstances: false }],
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toStrictEqual(new ForbiddenError('No access'));
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      options: [{ trustErrorInstances: false }],
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toMatchObject(new ForbiddenError('No access'));
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      options: [{ trustErrorInstances: false }],
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    // A message-only object or property is not a class pin.
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toMatchObject({ message: 'No access' });
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toHaveProperty('message', 'No access');
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    {
+      code: `
+        it('refuses', async () => {
+          await expect(load(id)).rejects.toHaveProperty(['message'], 'No access');
+          await expect(load(id)).rejects.toThrow('No access');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow', line: 4 }],
+    },
+    // An asymmetric matcher on the message alone is a message check.
+    {
+      code: "it('refuses', () => { expect(() => run()).toThrow(expect.objectContaining({ message: 'No access' })); });",
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    // A snapshot of the error records its message only.
+    {
+      code: "it('refuses', () => { expect(() => guard.check(guest)).toThrowErrorMatchingInlineSnapshot(`No access`); });",
+      errors: [{ messageId: 'messageOnlyThrow', data: { matcher: 'toThrowErrorMatchingInlineSnapshot' } }],
+    },
+    {
+      code: "it('refuses', async () => { await expect(load(id)).rejects.toThrowErrorMatchingSnapshot(); });",
+      errors: [{ messageId: 'messageOnlyThrow', data: { matcher: 'toThrowErrorMatchingSnapshot' } }],
+    },
+    // An unconfigured helper does not pin.
+    {
+      code: `
+        it('refuses', async () => {
+          await expectRejectsDomainError(service.find(id), { type: NotFoundError, appCode: 'EMPLOYEE_NOT_FOUND' });
+          await expect(service.find(id)).rejects.toThrow('Employee not found.');
+        });
+      `,
+      errors: [{ messageId: 'messageOnlyThrow' }],
+    },
+    // Outside a test callback (a shared helper) it still reports.
+    {
+      code: 'export async function expectRefusal(p) { await expect(p).rejects.toThrow(); }',
+      errors: [{ messageId: 'bareThrow' }],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin-code-quality/tests/rules/no-real-clock-in-unit-tests.test.ts b/packages/eslint-plugin-code-quality/tests/rules/no-real-clock-in-unit-tests.test.ts
new file mode 100644
index 0000000..0539da3
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/tests/rules/no-real-clock-in-unit-tests.test.ts
@@ -0,0 +1,109 @@
+import { ruleTester } from '@noctcore/eslint-test-utils';
+
+import { noRealClockInUnitTestsRule } from '../../src/rules/no-real-clock-in-unit-tests';
+
+const SPEC = 'src/modules/auth/services/token.service.spec.ts';
+
+ruleTester.run('no-real-clock-in-unit-tests', noRealClockInUnitTestsRule, {
+  valid: [
+    // Settly shapes: an offset from now is robust against the real clock.
+    { code: 'const future = () => new Date(Date.now() + 60_000);', filename: SPEC },
+    { code: 'const pastDate = new Date(Date.now() - 60_000);', filename: SPEC },
+    {
+      code: 'const row = { lockedUntil: new Date(Date.now() - LOCKOUT_QUIET_PERIOD_MS - MINUTE) };',
+      filename: SPEC,
+    },
+    { code: 'const graceEndsAt = new Date(Date.now() + 3 * 24 * 60 * 60 * 1000);', filename: SPEC },
+    { code: 'const later = new Date().getTime() + 1000;', filename: SPEC },
+    { code: 'const earlier = +new Date() - 1000;', filename: SPEC },
+    // A fixed date is not the real clock.
+    { code: "const createdAt = new Date('2026-01-15T10:00:00Z');", filename: SPEC },
+    // The file fakes the clock.
+    {
+      code: `
+        beforeEach(() => { vi.useFakeTimers(); vi.setSystemTime(new Date('2026-01-15')); });
+        afterEach(() => vi.useRealTimers());
+        it('stamps', () => { expect(stamp().at).toEqual(new Date()); });
+      `,
+      filename: SPEC,
+    },
+    { code: "jest.spyOn(Date, 'now').mockReturnValue(1_000); const t = Date.now();", filename: SPEC },
+    { code: "vi.spyOn(globalThis, 'Date'); const d = new Date();", filename: SPEC },
+    { code: 'Date.now = () => 0; const t = Date.now();', filename: SPEC },
+    // A stubbed or replaced global Date fakes the clock.
+    { code: "vi.stubGlobal('Date', FakeDate); const d = new Date();", filename: SPEC },
+    { code: "jest.replaceProperty(global, 'Date', FakeDate); const d = new Date();", filename: SPEC },
+    // Settly shape: the file mocks the project's clock module.
+    {
+      code: `
+        jest.mock('../../../common/clock', () => ({ nowMs: () => 1_000 }));
+        const row = { deletedAt: new Date() };
+      `,
+      filename: SPEC,
+      options: [{ clockModules: ['**/common/clock'] }],
+    },
+    // Not a unit test file, or an integration suite.
+    { code: 'const now = new Date();', filename: 'src/modules/auth/services/token.service.ts' },
+    { code: 'const now = new Date();', filename: 'src/modules/mail/email.integration.spec.ts' },
+    // performance.now() measures a duration and is left alone.
+    { code: 'const began = performance.now();', filename: SPEC },
+  ],
+  invalid: [
+    // Settly shape: an exact-now fixture.
+    {
+      code: 'const row = { expiresAt: new Date() };',
+      filename: 'src/modules/auth/services/auth-shared.service.spec.ts',
+      errors: [{ messageId: 'realClockInUnitTest', data: { call: 'new Date()' } }],
+    },
+    {
+      code: "repository.findInviteCandidate.mockResolvedValue({ ...CANDIDATE, deletedAt: new Date() });",
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    // Settly shape: a bare Date.now() start mark.
+    {
+      code: 'const started = Date.now();',
+      filename: 'src/common/redis/redis-client.spec.ts',
+      errors: [{ messageId: 'realClockInUnitTest', data: { call: 'Date.now()' } }],
+    },
+    // Settly shape: a stale blob built from now; only the bare call is reported.
+    {
+      code: 'const blob = { lastActive: Date.now(), stale: Date.now() - 5 * 60 * 1000 };',
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    // A comparison is not an offset.
+    {
+      code: 'while (Date.now() < deadline) { await tick(); }',
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    { code: 'const label = Date();', filename: SPEC, errors: [{ messageId: 'realClockInUnitTest', data: { call: 'Date()' } }] },
+    { code: 'const iso = new Date().toISOString();', filename: SPEC, errors: [{ messageId: 'realClockInUnitTest' }] },
+    // A mocked module that is not a configured clock module does not count.
+    {
+      code: "jest.mock('../../../common/clock'); const at = new Date();",
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    // Stubbing another global does not fake the clock.
+    {
+      code: "vi.stubGlobal('fetch', vi.fn()); const at = new Date();",
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    // Spying on something else does not fake the clock.
+    {
+      code: "vi.spyOn(Date.prototype, 'toLocaleString'); const at = new Date();",
+      filename: SPEC,
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+    // A custom fake-clock method list replaces the default one.
+    {
+      code: 'vi.useFakeTimers(); const at = new Date();',
+      filename: SPEC,
+      options: [{ fakeClockMethods: ['installClock'] }],
+      errors: [{ messageId: 'realClockInUnitTest' }],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin-code-quality/tests/rules/no-sleep-in-unit-tests.test.ts b/packages/eslint-plugin-code-quality/tests/rules/no-sleep-in-unit-tests.test.ts
new file mode 100644
index 0000000..9f2491d
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/tests/rules/no-sleep-in-unit-tests.test.ts
@@ -0,0 +1,208 @@
+import { ruleTester } from '@noctcore/eslint-test-utils';
+
+import { noSleepInUnitTestsRule } from '../../src/rules/no-sleep-in-unit-tests';
+
+const TEST_FILE = 'src/lib/download.test.ts';
+
+ruleTester.run('no-sleep-in-unit-tests', noSleepInUnitTestsRule, {
+  valid: [
+    // A zero delay is the idiomatic flush inside act(...).
+    {
+      code: 'const settle = () => act(() => new Promise<void>((resolve) => setTimeout(resolve, 0)));',
+      filename: 'src/features/firma/FirmaFormDialog.hooks.test.tsx',
+    },
+    {
+      code: "it('flushes', async () => { await new Promise((resolve) => setTimeout(resolve)); });",
+      filename: TEST_FILE,
+    },
+    // A reject-only timer is a timeout guard for a race, not a sleep.
+    {
+      code: "const timeout = (ms) => new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), ms));",
+      filename: 'packages/config/tests/wiring.test.ts',
+    },
+    {
+      code: 'const timeout = (ms: number) => new Promise<never>((_, reject) => setTimeout(reject, ms));',
+      filename: TEST_FILE,
+    },
+    // Settly shape: a cancellable deadline raced against real work keeps its handle.
+    {
+      code: `
+        async function within<T>(promise: Promise<T>, ms: number): Promise<T | typeof PENDING> {
+          let timer: NodeJS.Timeout | undefined;
+          try {
+            return await Promise.race([
+              promise,
+              new Promise<typeof PENDING>((resolve) => {
+                timer = setTimeout(() => resolve(PENDING), ms);
+              }),
+            ]);
+          } finally {
+            clearTimeout(timer);
+          }
+        }
+      `,
+      filename: 'tools/verify/e2e-runtime.test.ts',
+    },
+    {
+      code: 'const deadline = new Promise((resolve) => { const t = setTimeout(resolve, waitMs); cancel = () => clearTimeout(t); });',
+      filename: TEST_FILE,
+    },
+    // clearInterval and a global receiver count as clearing too.
+    {
+      code: "let t; const d = new Promise((resolve) => { t = setTimeout(resolve, 50); }); afterEach(() => globalThis.clearInterval(t));",
+      filename: TEST_FILE,
+    },
+    // Yielding to the event loop without a delay.
+    {
+      code: "it('ticks', async () => { await new Promise((resolve) => setImmediate(resolve)); });",
+      filename: TEST_FILE,
+    },
+    // A timer that is not the executor's resolve (a debounced callback under test).
+    {
+      code: "it('debounces', () => { setTimeout(onSave, 300); vi.advanceTimersByTime(300); expect(onSave).toHaveBeenCalled(); });",
+      filename: TEST_FILE,
+    },
+    // Settly shape: a fake slow stream in a file that fakes timers, so the wait is virtual.
+    {
+      code: `
+        function trickle(chunks: readonly string[], gapMs: number) {
+          return new ReadableStream({
+            async pull(controller) {
+              await new Promise((resolve) => setTimeout(resolve, gapMs));
+              controller.enqueue(chunks.shift());
+            },
+          });
+        }
+        beforeEach(() => { vi.useFakeTimers(); });
+        afterEach(() => { vi.useRealTimers(); });
+        it('stalls', async () => {
+          const body = trickle(['a'], 5_000);
+          await vi.advanceTimersByTimeAsync(5_000);
+          expect(await read(body)).toBe('a');
+        });
+      `,
+      filename: 'src/lib/document-download.test.ts',
+    },
+    {
+      code: "jest.useFakeTimers(); it('x', async () => { const p = new Promise((r) => setTimeout(r, 1000)); jest.advanceTimersByTime(1000); await p; });",
+      filename: TEST_FILE,
+    },
+    // Not a unit test file.
+    {
+      code: "it('waits', async () => { await new Promise((resolve) => setTimeout(resolve, 100)); });",
+      filename: 'src/lib/download.ts',
+    },
+    // Integration suites wait on real systems on purpose.
+    {
+      code: "it('delivers', async () => { await new Promise((resolve) => setTimeout(resolve, 100)); });",
+      filename: 'src/modules/mail/email-delivery.integration.spec.ts',
+    },
+    // A `setTimeout` from somewhere else is not the timers/promises sleep.
+    {
+      code: "import { setTimeout } from './fake-timers'; it('x', async () => { await setTimeout(100); });",
+      filename: TEST_FILE,
+    },
+    // allowZeroDelay also covers timers/promises.
+    {
+      code: "import { setTimeout as tick } from 'node:timers/promises'; it('x', async () => { await tick(0); });",
+      filename: TEST_FILE,
+    },
+  ],
+  invalid: [
+    // Settly shape: a fixed real sleep in a unit spec.
+    {
+      code: "it('reports late', async () => { await new Promise((resolve) => setTimeout(resolve, 100)); });",
+      filename: 'src/hooks/use-route-announcer.focus.test.tsx',
+      errors: [{ messageId: 'sleepInUnitTest', data: { delay: '100' } }],
+    },
+    // Settly shape: a delay from a variable.
+    {
+      code: "it('spaces clicks', async () => { await new Promise((resolve) => setTimeout(resolve, gapMs)); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest', data: { delay: 'gapMs' } }],
+    },
+    // Settly shape: a shared sleep helper.
+    {
+      code: 'const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));',
+      filename: 'src/modules/auth/password-reset-request.isolation.spec.ts',
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // Settly shape: a delayed resolve with a value.
+    {
+      code: "const held = runner.hold(new Promise((resolve) => setTimeout(() => resolve('late'), 100)));",
+      filename: 'tools/verify/interruptible.test.ts',
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // A kept handle that is never cleared is still a sleep.
+    {
+      code: "it('x', async () => { await new Promise((resolve) => { const t = setTimeout(resolve, 100); }); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest', data: { delay: '100' } }],
+    },
+    {
+      code: "it('x', async () => { let t; await new Promise((resolve) => { t = setTimeout(resolve, 100); }); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // Clearing a different handle does not count.
+    {
+      code: "it('x', async () => { let t; let other; await new Promise((resolve) => { t = setTimeout(resolve, 100); }); clearTimeout(other); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // A block body.
+    {
+      code: 'it(\'x\', async () => { await new Promise((r) => { setTimeout(r, 50); }); });',
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    {
+      code: "it('x', async () => { await new Promise(function (done) { globalThis.setTimeout(done, 50); }); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // timers/promises, named, renamed and namespaced.
+    {
+      code: "import { setTimeout } from 'node:timers/promises'; it('x', async () => { await setTimeout(200); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest', data: { delay: '200' } }],
+    },
+    {
+      code: "import { setTimeout as sleep } from 'timers/promises'; it('x', async () => { await sleep(20); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    {
+      code: "import * as timers from 'node:timers/promises'; it('x', async () => { await timers.setTimeout(20); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // A promisified setTimeout.
+    {
+      code: "const wait = util.promisify(setTimeout); it('x', async () => { await wait(10); });",
+      filename: TEST_FILE,
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // With allowZeroDelay off, the flush is reported too.
+    {
+      code: 'const settle = () => act(() => new Promise<void>((resolve) => setTimeout(resolve, 0)));',
+      filename: 'src/features/firma/FirmaFormDialog.hooks.test.tsx',
+      options: [{ allowZeroDelay: false }],
+      errors: [{ messageId: 'sleepInUnitTest', data: { delay: '0' } }],
+    },
+    // A custom fake-timer method list replaces the default one.
+    {
+      code: "vi.useFakeTimers(); it('x', async () => { await new Promise((r) => setTimeout(r, 5)); });",
+      filename: TEST_FILE,
+      options: [{ fakeTimerMethods: ['installClock'] }],
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+    // A custom suffix brings a file into scope.
+    {
+      code: "it('x', async () => { await new Promise((r) => setTimeout(r, 5)); });",
+      filename: 'tests/unit/queue.check.ts',
+      options: [{ testFileSuffixes: ['.check.ts'] }],
+      errors: [{ messageId: 'sleepInUnitTest' }],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin-code-quality/tests/rules/no-vacuous-expect.test.ts b/packages/eslint-plugin-code-quality/tests/rules/no-vacuous-expect.test.ts
index 60542d2..c8d7961 100644
--- a/packages/eslint-plugin-code-quality/tests/rules/no-vacuous-expect.test.ts
+++ b/packages/eslint-plugin-code-quality/tests/rules/no-vacuous-expect.test.ts
@@ -39,6 +39,41 @@ ruleTester.run('no-vacuous-expect', noVacuousExpectRule, {
       code: "it('truthy', () => { expect(isReady()).toBeTruthy(); });",
       options: [{ weakMatchers: ['toBeDefined'] }],
     },
+    // A render root assertion on real content pins behaviour.
+    {
+      code: "it('greets', () => { const { container } = render(<Hello />); expect(container.textContent).toBe('Hello'); });",
+      filename: 'src/Hello.test.tsx',
+    },
+    {
+      code: "it('renders', () => { const { container } = render(<Nav />); expect(container.querySelector('nav')).toBeInTheDocument(); });",
+      filename: 'src/Nav.test.tsx',
+    },
+    // A presence check next to a real assertion.
+    {
+      code: `
+        it('renders the field', () => {
+          const { container } = render(<Harness />);
+          expect(container).not.toBeEmptyDOMElement();
+          expect(screen.getByRole('textbox', { name: 'Captcha' })).toBeVisible();
+        });
+      `,
+      filename: 'src/TurnstileField.test.tsx',
+    },
+    // A screen query is not the render root.
+    { code: "it('shows', () => { render(<Hello />); expect(screen.getByText('Hello')).toBeInTheDocument(); });", filename: 'src/Hello.test.tsx' },
+    // A `container` that is not a render result is not a render root.
+    {
+      code: "it('inspects', async () => { const container = await docker.inspect(id); expect(container).not.toBeNull(); });",
+    },
+    { code: "it('ships', () => { expect(ship.container).toBeVisible(); });" },
+    { code: "it('loads', () => { const { container } = fixtures; expect(container).not.toBeEmptyDOMElement(); });" },
+    { code: "it('packs', ({ container }) => { expect(container).not.toBeEmptyDOMElement(); });" },
+    // renderRoots: [] turns the render-root check off.
+    {
+      code: "it('renders', () => { const { container } = render(<Harness />); expect(container).not.toBeEmptyDOMElement(); });",
+      filename: 'src/TurnstileField.test.tsx',
+      options: [{ renderRoots: [] }],
+    },
   ],
   invalid: [
     {
@@ -90,5 +125,62 @@ ruleTester.run('no-vacuous-expect', noVacuousExpectRule, {
       options: [{ assertionCallees: [] }],
       errors: [{ messageId: 'soleWeakExpect' }],
     },
+    // Settly shape: a smoke-only render test.
+    {
+      code: `
+        describe('TurnstileField', () => {
+          it('renders without crashing', () => {
+            const { container } = render(<Harness />);
+            expect(container).not.toBeEmptyDOMElement();
+          });
+        });
+      `,
+      filename: 'src/TurnstileField.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect', data: { matcher: 'not.toBeEmptyDOMElement' } }],
+    },
+    {
+      code: "it('renders', () => { const { container } = render(<Card />); expect(container.firstChild).toBeInTheDocument(); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect', data: { matcher: 'toBeInTheDocument' } }],
+    },
+    {
+      code: "it('renders', () => { const { container } = render(<Card />); expect(container.innerHTML).not.toBe(''); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect', data: { matcher: 'not.toBe' } }],
+    },
+    {
+      code: "it('renders', () => { const view = render(<Card />); expect(view.baseElement).toBeInTheDocument(); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect' }],
+    },
+    // A weak matcher on the root reports as a render-root smoke, once.
+    {
+      code: "it('renders', () => { expect(render(<Card />).container.firstChild).toBeTruthy(); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect', data: { matcher: 'toBeTruthy' } }],
+    },
+    // Render results through await, a member of the result, and a render* helper.
+    {
+      code: "it('renders', async () => { const { container } = await renderAsync(<Card />); expect(container).toBeInTheDocument(); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect' }],
+    },
+    {
+      code: "it('renders', () => { const container = render(<Card />).container; expect(container.innerHTML).not.toEqual(''); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect' }],
+    },
+    {
+      code: "it('renders', () => { const container = renderIntoDocument(<Card />); expect(container).not.toBeEmptyDOMElement(); });",
+      filename: 'src/Card.test.tsx',
+      errors: [{ messageId: 'soleRenderRootExpect' }],
+    },
+    // A custom root name.
+    {
+      code: "it('mounts', () => { const { root } = mount(Card); expect(root).toBeInTheDocument(); });",
+      filename: 'src/Card.test.ts',
+      options: [{ renderRoots: ['root'] }],
+      errors: [{ messageId: 'soleRenderRootExpect' }],
+    },
   ],
 });
diff --git a/packages/eslint-plugin-code-quality/tests/rules/skipped-tests-need-tracking.test.ts b/packages/eslint-plugin-code-quality/tests/rules/skipped-tests-need-tracking.test.ts
index 51a0a97..85c253e 100644
--- a/packages/eslint-plugin-code-quality/tests/rules/skipped-tests-need-tracking.test.ts
+++ b/packages/eslint-plugin-code-quality/tests/rules/skipped-tests-need-tracking.test.ts
@@ -23,6 +23,46 @@ ruleTester.run('skipped-tests-need-tracking', skippedTestsNeedTrackingRule, {
       code: "it.skip('later', () => {}); // ISSUE-42",
       options: [{ markers: ['ISSUE-\\d+'] }],
     },
+    // node:test: a platform guard is not debt.
+    { code: "describe('sandbox:inspect --refresh exit codes', { skip: process.platform === 'win32' }, () => {});" },
+    { code: "it('blocks with decision:block', { skip: !ready }, () => {});" },
+    { code: "test('needs docker', { skip }, () => {});" },
+    { code: "test('runs', { skip: false, todo: '' }, () => {});" },
+    { code: "test('runs', { skip: 0, todo: null }, () => {});" },
+    {
+      code: "test('guarded', async (t) => {\n  if (!posix) {\n    await t.skip('POSIX only');\n    return;\n  }\n});",
+    },
+    {
+      code: `
+        it('waits for the rest of the group', async (t) => {
+          if (!posix) {
+            t.skip('POSIX process groups; taskkill /t /f ends a Windows tree at once');
+            return;
+          }
+          await run();
+        });
+      `,
+    },
+    {
+      code: `
+        for (const signal of ['SIGINT', 'SIGTERM']) {
+          it(\`dies of \${signal}\`, async (t) => {
+            if (process.platform === 'win32' && signal !== 'SIGINT') {
+              t.skip('Windows delivers no catchable SIGTERM');
+              return;
+            }
+          });
+        }
+      `,
+    },
+    // node:test: an unconditional skip with a tracking marker.
+    { code: "test('later', { skip: 'https://github.com/noctcore/eslint-plugins/issues/1' }, () => {});" },
+    { code: "// TODO(@alice): flaky on the runner\ntest('later', { todo: true }, () => {});" },
+    { code: "test('later', async (t) => {\n  // https://example.com/issue/9\n  t.skip();\n});" },
+    // An options object passed to something that is not a runner (a report fixture).
+    { code: "const report = pass(FILE_A, 'later', 0, { skip: true });" },
+    // `skip` on a non-context receiver (a query builder) is not a test skip.
+    { code: "it('pages', (t) => { const q = query.skip(10); assert.equal(q.offset, 10); });" },
   ],
   invalid: [
     {
@@ -49,5 +89,45 @@ ruleTester.run('skipped-tests-need-tracking', skippedTestsNeedTrackingRule, {
       options: [{ markers: ['ISSUE-\\d+'] }],
       errors: [{ messageId: 'needsTracking', line: 1 }],
     },
+    // node:test options: unconditional skip and todo.
+    {
+      code: "test('later', { skip: true }, () => {});",
+      errors: [{ messageId: 'needsTracking', line: 1, data: { label: '{ skip }' } }],
+    },
+    {
+      code: "describe('someday', { todo: 'write it' }, () => {});",
+      errors: [{ messageId: 'needsTracking', line: 1, data: { label: '{ todo }' } }],
+    },
+    {
+      code: "test({ 'skip': `not yet` }, () => {});",
+      errors: [{ messageId: 'needsTracking', line: 1 }],
+    },
+    // A subtest through the context.
+    {
+      code: "test('outer', async (t) => {\n  await t.test('inner', { skip: true }, () => {});\n});",
+      errors: [{ messageId: 'needsTracking', line: 2 }],
+    },
+    // node:test context: an unconditional t.skip() / t.todo().
+    {
+      code: "test('later', (t) => {\n  t.skip('not ready');\n  run();\n});",
+      errors: [{ messageId: 'needsTracking', line: 2, data: { label: 't.skip(' } }],
+    },
+    {
+      code: "it('later', function (ctx) { ctx.todo(); });",
+      errors: [{ messageId: 'needsTracking', line: 1, data: { label: 'ctx.todo(' } }],
+    },
+    {
+      code: "test('later', (t) => t.skip());",
+      errors: [{ messageId: 'needsTracking', line: 1 }],
+    },
+    // An awaited context skip, and any truthy literal option value.
+    {
+      code: "test('later', async (t) => {\n  await t.skip('not ready');\n});",
+      errors: [{ messageId: 'needsTracking', line: 2, data: { label: 't.skip(' } }],
+    },
+    {
+      code: "test('later', { skip: 1 }, () => {});",
+      errors: [{ messageId: 'needsTracking', line: 1, data: { label: '{ skip }' } }],
+    },
   ],
 });
diff --git a/packages/eslint-plugin-code-quality/tests/rules/typed-mock-over-double-cast.test.ts b/packages/eslint-plugin-code-quality/tests/rules/typed-mock-over-double-cast.test.ts
new file mode 100644
index 0000000..68cec95
--- /dev/null
+++ b/packages/eslint-plugin-code-quality/tests/rules/typed-mock-over-double-cast.test.ts
@@ -0,0 +1,99 @@
+import { ruleTester } from '@noctcore/eslint-test-utils';
+
+import { typedMockOverDoubleCastRule } from '../../src/rules/typed-mock-over-double-cast';
+
+ruleTester.run('typed-mock-over-double-cast', typedMockOverDoubleCastRule, {
+  valid: [
+    // A typed double: the checker still sees every member.
+    { code: 'const config: jest.Mocked<Pick<ConfigService, "get">> = { get: jest.fn() };' },
+    { code: 'const config = { get: vi.fn() } satisfies Partial<ConfigService>;' },
+    { code: 'const config = { get: jest.fn() } as jest.Mocked<Pick<ConfigService, "get">>;' },
+    // No mock inside: a plain data fixture.
+    { code: "const input = { id: 1, name: 'ada' } as unknown as CreateUserDto;" },
+    // Settly shape: an existing double passed on, not an object of mocks.
+    {
+      code: 'new EteczkaRetentionService(prisma, eteczkaService as unknown as ConstructorParameters<typeof EteczkaRetentionService>[1]);',
+    },
+    // A single angle-bracket cast still lets the checker compare the types.
+    { code: 'const svc = <jest.Mocked<Pick<MailService, "run">>>{ run: jest.fn() };', filename: 'src/mail.service.spec.ts' },
+    // A single cast to unknown is not a double cast.
+    { code: 'const raw = { get: jest.fn() } as unknown;' },
+    // Allowed targets, by type name and by source text.
+    {
+      code: 'const prisma = { user: { findMany: jest.fn() } } as unknown as PrismaService;',
+      options: [{ allowTargets: ['PrismaService'] }],
+    },
+    {
+      code: 'const tx = { user: { update: vi.fn() } } as unknown as Prisma.TransactionClient;',
+      options: [{ allowTargets: ['Prisma.*'] }],
+    },
+    {
+      code: "const opts = { ctx: { res: { setHeader: jest.fn() } } } as unknown as Parameters<AppErrorHandler['onError']>[0];",
+      options: [{ allowTargets: ['Parameters<*'] }],
+    },
+    // A factory outside the configured list.
+    {
+      code: 'const repo = { find: sinon.stub() } as unknown as Repository;',
+    },
+  ],
+  invalid: [
+    // Settly shape: a NestJS ConfigService double.
+    {
+      code: `
+        const config = {
+          get: jest.fn((key: string) => (key === 'METRICS_BASIC_AUTH' ? basicAuth : undefined)),
+        } as unknown as ConfigService;
+      `,
+      errors: [{ messageId: 'doubleCastMock', data: { target: 'ConfigService' }, line: 2 }],
+    },
+    // Settly shape: a nested mock inside a request-context stub.
+    {
+      code: "const opts = { ctx: { res: { setHeader: jest.fn() } } } as unknown as Parameters<AppErrorHandler['onError']>[0];",
+      errors: [{ messageId: 'doubleCastMock', data: { target: "Parameters<AppErrorHandler['onError']>[0]" } }],
+    },
+    // Settly shape: a chained mock value.
+    {
+      code: "const mw = { getRawInput: jest.fn().mockResolvedValue({ foo: 'bar' }), next: jest.fn() } as unknown as MwOpts;",
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+    // Vitest, inside a call, and through `as any`.
+    {
+      code: 'render(<Form api={{ submit: vi.fn() } as unknown as FormApi} />);',
+      filename: 'src/Form.test.tsx',
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+    { code: 'const repo = { find: vi.fn() } as any as Repository;', errors: [{ messageId: 'doubleCastMock' }] },
+    // A mock inside a getter function body still counts.
+    {
+      code: 'const host = { switchToHttp: () => ({ getResponse: () => ({ status: jest.fn() }) }) } as unknown as ArgumentsHost;',
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+    // Through `as never` and the angle-bracket assertion (not valid in .tsx).
+    {
+      code: 'const svc = { run: jest.fn() } as never as MailService;',
+      errors: [{ messageId: 'doubleCastMock', data: { target: 'MailService' } }],
+    },
+    {
+      code: 'const svc = <MailService><unknown>{ run: jest.fn() };',
+      filename: 'src/mail.service.spec.ts',
+      errors: [{ messageId: 'doubleCastMock', data: { target: 'MailService' } }],
+    },
+    {
+      code: 'const svc = <MailService>({ run: vi.fn() } as unknown);',
+      filename: 'src/mail.service.spec.ts',
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+    // A custom factory list.
+    {
+      code: 'const repo = { find: sinon.stub() } as unknown as Repository;',
+      options: [{ mockFactories: ['sinon.stub'] }],
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+    // An allow glob for one type does not cover another.
+    {
+      code: 'const svc = { run: jest.fn() } as unknown as MailService;',
+      options: [{ allowTargets: ['PrismaService'] }],
+      errors: [{ messageId: 'doubleCastMock' }],
+    },
+  ],
+});
diff --git a/site/scripts/parity.test.ts b/site/scripts/parity.test.ts
index 03beb80..8e55ddb 100644
--- a/site/scripts/parity.test.ts
+++ b/site/scripts/parity.test.ts
@@ -21,7 +21,7 @@ import { describe, expect, test } from 'bun:test';
 
 import { listRuleDocs, loadInventory } from './inventory';
 
-const EXPECTED_RULE_COUNT = 113;
+const EXPECTED_RULE_COUNT = 117;
 
 // Source, not dist: a rule added and not yet built must still fail here.
 const inventory = await loadInventory('src');