@orkestrel/scaffold 0.0.30 → 0.0.32

package/dist/host/claude/agents/grok.md

@@ -16,10 +16,10 @@ Require a bounded question and an exact scope.
 ## Model
 
 ```text
-CURSOR_GROK_MODEL=cursor-grok-4.5-high
+CURSOR_GROK_MODEL=cursor-grok-4.6-high
 ```
 
-That id was read from `agent models` on 2026-08-09. Resolve the model from the variable at
+That id was read from `agent models` on 2026-08-13. Resolve the model from the variable at
 dispatch. Re-read `agent models` and update this line when the id changes. Never guess or
 substitute a model id.
 
@@ -27,12 +27,20 @@ substitute a model id.
 
 Resolve the CLI in this order, verifying with `--version` before first use:
 
-1. bare `agent`;
-2. `agent.cmd` — Windows installs ship only `.cmd` and `.ps1` shims, so bare `agent` does
-   not resolve in Bash;
-3. the absolute `"$LOCALAPPDATA/cursor-agent/agent.cmd"`.
+1. bare `agent`, on a POSIX host;
+2. on Windows, the versioned entry under `"$LOCALAPPDATA/cursor-agent/versions/"` — take the
+   newest directory and invoke its own `node.exe` against its `index.js` directly.
 
-If none responds the bench is dark. Stop with a deviation naming the fallback: hand the
+Launch an unattended run through the versioned entry, never through `agent`, `agent.cmd`, or
+`agent.ps1` on Windows. Those shims delegate to `cursor-agent.ps1`, which sets the console window
+title and can abort with Win32 `0xE9` when no console is attached. The failure is intermittent, so a
+shim that answered once does not clear it, and when it does fire it leaves only a PowerShell
+`SetConsoleWindowTitle` trace — which reads as a bench that returned nothing rather than as a launch
+that never happened. The versioned entry has no console dependency and no such failure mode.
+
+Read an empty shim run as a launch failure until its log is checked for that trace.
+
+If nothing responds the bench is dark. Stop with a deviation naming the fallback: hand the
 reading to the Orchestrator, `planner`, or `analyst` directly. Never install or authenticate.
 
 Create `tmp/cursor/` first. Write any brief longer than a couple of sentences to
@@ -40,7 +48,10 @@ Create `tmp/cursor/` first. Write any brief longer than a couple of sentences to
 fragile shell arguments. Every run journals its output, so the user can tail progress live
 and an interrupted run leaves its partial distillate on disk:
 
-`<agent-cli> -p --trust --mode=ask --model "$CURSOR_GROK_MODEL" "<brief or pointer>" | tee tmp/cursor/<unit>.log`
+`<resolved-entry> -p --trust --mode=ask --model "$CURSOR_GROK_MODEL" "<brief or pointer>" | tee tmp/cursor/<unit>.log`
+
+Write that chain to `tmp/cursor/run.sh` and run the file, so the resolution, the model, and the
+journalling are one artifact the next run reuses.
 
 Run that yourself only for a short bounded ask finishing in about two minutes. For anything
 longer your job ends at drafting: return the brief path, the exact resolved command, the

package/dist/host/claude/rules/architecture.md

@@ -49,6 +49,7 @@ Use only the centralized files an environment needs.
 - Extract local declarations by kind. “Only used here” and “not exported” are not exemptions.
 - Every declaration in a centralized file is exported. Fold away a trivial single-use declaration or export/test it; never leave it hidden.
 - The only permitted non-exported module-scope declarations are in a runtime entrypoint that must be self-contained and cannot import siblings, such as raw source loaded in a worker. Explain that necessity in a comment.
+- A runtime entry—`src/bin/main.ts`, `app/browser/main.ts`, `app/server/main.ts`—is a fixed name, not a centralized kind file. Both the data rule and the function rule reach it, so it declares no module-scope constant and no module-scope function: it imports what it needs and runs. The self-contained exception above covers only an entrypoint that cannot import siblings.
 - Perform a cleanup sweep after implementation: no stray implementation-file declarations, non-exported/wrong-kind centralized declarations, prohibited nested declarations, duplicate implementations, compatibility aliases, superfluous wrappers, stale imports/barrel rows, or untested extracted functions.
 
 ## Kind purity
@@ -112,9 +113,22 @@ kind. It reads declaration syntax and file name, never meaning.
   `middlewares.ts`, `parsers.ts`, `relations.ts`, `schemas.ts`, `seeders.ts`, `shapers.ts`, and
   `validators.ts`. That list is exhaustive, a new function kind joins it, and no later version of
   the sweep claims more.
+- It reports no `data` violation in `helpers.ts`. The kind rules place a camelCase namespace of
+  functions there, and a namespace of callables is not separable from a data table by declaration
+  syntax, so `DATA_EXEMPT_FILES` in `tests/setupPolicy.ts` excludes the file. Ordinary module data
+  there — `export const RETRIES = 3` — is unreported; the constants rule above binds regardless.
+- It inspects no ambient declaration file: `.d.ts`, `.d.mts`, and `.d.cts` are all outside its
+  reach. An ambient declaration file is not a module in the kind table, so it sits outside the
+  parsed population entirely rather than being exempted from the `type` rule.
+- It does not inspect class-expression members. A function assigned inside a class-expression
+  method is unreported; the functions rule above still binds, and cleanup and review enforce it.
 - The cleanup sweep and independent review prove kind purity across those files. A helper misfiled
   as a parser, a coercer misfiled as a guard, a compiler misfiled as a factory, and a shaper
   misfiled as a cloner are review findings, not red tests.
+- It does not decide barrel membership. It parses each file alone and resolves no module, so it
+  cannot tell whether a declaration is reachable from its barrel. That question belongs to each
+  package's `tests/guides.test.ts`, which imports the barrel and gets real resolution. Do not add
+  module resolution here to duplicate it.
 - The kind table is mandatory whether or not a test can see the violation.
 
 ## Wrapper test
@@ -190,6 +204,8 @@ Store child managers in `#` fields and expose readonly getters typed as their in
   fixes the declaration shape checked there; it judges nothing about what a module does.
 - Never infer a function domain from a folder's name; a camelCase module inside an unregistered
   folder is misplaced.
+- Register a folder only when its direct modules are camelCase single-function `.ts` modules. A
+  folder of PascalCase single-file components, or of entity classes, never qualifies.
 - Request a new domain through a fleet-canon change. There is no workspace-local registration path.
 
 ### Extension categories
@@ -231,6 +247,15 @@ Both obey:
 - If a declaration should not be public, make it a true local or runtime-private detail, or remove
   the capability for a substantive reason. Never leave an intentional reusable export stranded
   outside the barrel.
+- One-class-per-file evicts some classes from their only caller, and `export` on such a file is
+  structural rather than a statement of intent. Barrel that class when a consumer can construct it
+  from values they already hold. Intern it — out of the barrel, and named in the package's parity
+  `INTERNAL` list — when its constructor requires a value only its owner produces, or when the
+  public value is a projection of the instance rather than the instance. A class named in a public
+  signature is always barrelled.
+- Delete a barrel row whose class no consumer can construct, and delete its `@example` with it. A
+  row obliges a documented, runnable example, so a class kept public without one is drift that
+  parity cannot see.
 - When a symbol moves, update every import; never leave a compatibility re-export.
 
 ```ts

package/dist/host/claude/rules/documentation.md

@@ -21,7 +21,7 @@ Documentation is an enforced contract, not explanatory decoration. The Writing r
 
 - Read the matching spec/guide before code, form the intended design, then compare implementation. Existing code is a verification target, not ground truth.
 - `AGENTS.md` and its linked rules are the sole convention source. Do not create competing instruction copies in guides.
-- `guides/README.md` is the map: maintain both a concept index (`spec ↔ source ↔ tests ↔ showcase`) and directory index.
+- `guides/README.md` is the map: maintain both a concept index and a directory index. The concept index runs `spec ↔ source ↔ tests ↔ showcase` minus every column whose subject this workspace lacks, so an app-only workspace that publishes no library and builds no showcase still owes a full index over the columns it has.
 - `ROADMAP.md` is the sequenced plan of record. Each chunk reaches green before the next.
 - A showcase is executable proof of public API. A missing demonstration is a missing feature, detectable by parity.
 - An integration surface's guide documents the validated hookup for each supported client: the exact commands run, the authentication and approval model that client needs, and the honest limit wherever a client cannot reach part of the surface.
@@ -32,6 +32,7 @@ Documentation is an enforced contract, not explanatory decoration. The Writing r
 - Every public export is documented.
 - TypeScript, SCSS, Markdown, tests, and showcase remain aligned.
 - A parity failure identifies drift; never suppress or weaken the test.
+- A vendored dependency guide is a mirror. Its relative links address the upstream tree and resolve to nothing here, so they are outside local-link parity. Refresh a mirror rather than rewriting it: a rewritten copy is a translation, and no comparison against the fetched bytes can check it.
 - Falsify a prose claim the way you falsify a code claim. The parity test proves a name exists, never that a sentence about behavior is true, so run the example and read what it returns. A `// false` beside a call that returns `true` is a defect of the same kind as a wrong return value, and it reaches every consumer who installs the package.
 - Re-read the prose last, against what actually shipped. Where a change chose to document a limit rather than close it, the sentence was often drafted for the option that lost, or written more confidently than the code earns. Code rulings survive review because a test can break them; prose rulings survive because nothing tries.
 

package/dist/host/claude/rules/tests.md

@@ -10,8 +10,15 @@ paths:
 
 ## Test contract
 
-- Mirror source/application structure:
-  `tests/{src,app}/[environment]/[domain]/[source].test.ts`.
+- Mirror module/application structure:
+  `tests/{src,app}/[environment]/[domain]/[module].test.ts`.
+- The mirrored population is `src` and `app` alone. `configs/` is a source directory and is
+  deliberately not a mirrored root: its leaves produce the workspace's configuration rather than ship
+  in it, and they are proved from `tests/config.test.ts` beside the configuration they produce. Do
+  not add `tests/configs/`.
+- Resolve a mirrored module through `.ts`, `.tsx`, `.mts`, `.cts`, `.vue`, `.scss`, or `.css`.
+- Resolve a Sass or CSS partial through the module's leading underscore.
+- Resolve a `setup*` module test against its sibling `setup*.ts` module inside `tests/`.
 - Prefer test filenames matching entrypoints: `index.test.ts` for `index.ts`, `main.test.ts` for `main.ts`.
 - Tests are deterministic: identical inputs produce identical results.
 - Keep default suites fast: timers normally use 10–50 ms and tests make no network calls.
@@ -25,6 +32,7 @@ paths:
 - Never assert an implementation against itself. Compare the answer to a declaration, a fixture, or a second mechanism that could disagree with it. Re-deriving the answer the same way the source derives it produces a test that passes for every value the source ever returns, and it reads exactly like a real one.
 - Probe a host-varying property at runtime, on the host the test is running on, and assert against what the probe returned. Filesystem case folding, path separators, permission bits, and rename semantics differ per host, so a fixture built on one host describes that host and silently measures something else on the next.
 - Assert a runtime-chosen result as the property it must have, not as the number one run produced. Compression, timing, and buffer sizing are the runtime's choice, so pin the relationship the test depends on — that the encoded form is larger, that the second call is faster — and let the assertion fail when the input drifts out of the range where that relationship holds.
+- Measure an elapsed interval with `performance.now()`, never `Date.now()`. `Date.now()` returns whole milliseconds, so an interval built from two of its readings truncates at both ends and can under-report by a millisecond — enough to fail a boundary assertion against a timer that behaved correctly. `performance.now()` is monotonic and sub-millisecond, and it does not move when the wall clock does.
 - Give a conditional skip the mechanism that makes it inapplicable, cited, not the platform name alone. A test skipped on a platform is a test nobody re-examines; a test skipped because a named API rejects a named case is one anybody can re-check.
 - A regression test records the exact command and its failing count before the fix, and the same command's passing count after.
 - Use `it.todo()` only for explicitly out-of-scope roadmap work, never to complete the current request. Every `.skip` or conditional skip has a narrow verifiable applicability reason.
@@ -36,16 +44,20 @@ paths:
 A proof that covers the workspace instead of one module has a fixed location, so no package invents
 its own:
 
-| Path                         | Proves                                                              |
-| ---------------------------- | ------------------------------------------------------------------- |
-| `tests/policy.test.ts`       | Every source file obeys the syntactic coding and placement law      |
-| `tests/config.test.ts`       | Root configuration resolves its aliases, projects, and outputs      |
-| `tests/guides.test.ts`       | Every documented API exists and every public API is documented      |
-| `tests/conformance.test.ts`  | Where this package drifts from the official tooling it tracks       |
-| `tests/integration.test.ts`  | The package's features work together end to end across environments |
-| `tests/service/**/*.test.ts` | The live external services this package drives, driven for real     |
+| Path                         | Proves                                                                                                |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `tests/policy.test.ts`       | Every source file obeys the syntactic coding and placement law                                        |
+| `tests/config.test.ts`       | Root configuration resolves its aliases, projects, and outputs, and the `configs/` leaves behind them |
+| `tests/guides.test.ts`       | Every documented API exists and every public API is documented                                        |
+| `tests/conformance.test.ts`  | Where this package drifts from the official tooling it tracks                                         |
+| `tests/distribution.test.ts` | The packed package installs and resolves through its public exports                                   |
+| `tests/integration.test.ts`  | The package's features work together end to end across environments                                   |
+| `tests/service/**/*.test.ts` | The live external services this package drives, driven for real                                       |
 
 - `.claude/rules/workspace.md` names the Vitest project each location belongs to.
+- The `guides` project runs in Node with the browser disabled. Its subject is
+  documented-name-to-real-export. A proof that renders a component and compares it against a
+  definition is a composition and belongs in an `integration.test.ts` scoped to its directory.
 - `integration.test.ts` is a reserved filename at any level. It names a scope rather than a module,
   so the mirror rule does not reach it; its scope is the directory it sits in.
 - An integration test is an end-to-end test: it composes the package's own features and drives them
@@ -57,9 +69,13 @@ its own:
 - Do not put a packaging, install, or distribution check in an integration test. What the tarball
   contains is a different question from whether the features compose.
 - A test the mirror rule flags is a misplaced test until its placement is checked. Move it to the
-  location its scope names. Never widen the rule to accept it.
-- Give every nested `integration.test.ts` its own exact-path project entry. A glob such as
-  `tests/src/**/integration.test.ts` double-claims a file another project already owns.
+  location its scope names. Widen the rule only when that check shows the test already sits at the
+  location its scope names and the rule's population omits a module this ruleset mandates, and then
+  widen the population rather than admitting the individual case.
+- A nested `tests/{src,app}/<environment>/**/integration.test.ts` runs in that environment's project,
+  whose existing glob collects it exactly once. Give it a separate exact-path project entry only when
+  the proof needs different setup or a different runtime, and exclude that exact path from the
+  environment project when you do.
 
 ## Probes
 
@@ -95,7 +111,8 @@ Live external services/models are the deliberate exception to fast hermetic defa
 - Put them in the `service` project, under `tests/service/`, with `tests/setupService.ts` for setup
   and a longer timeout. That module's presence is what registers the project, so a live proof with
   no readiness setup is a project nothing configures.
-- Keep them out of the default run.
+- `.claude/rules/workspace.md` fixes which gate runs the `service` project, and that gate is not the
+  same one in a publishing and a `private: true` workspace.
 - Warm and verify service readiness in `tests/setupService.ts`.
 - Hard-require readiness: throw loudly; never silently skip.
 - Verify service-dependent logic through that service's project, not unrelated module tests or scattered conditional skips.
@@ -107,7 +124,13 @@ Live external services/models are the deliberate exception to fast hermetic defa
 A test that spawns a process, packs, installs, or drives a real build is a proof, not a unit test.
 
 - Give it its own Vitest project with its own setup and timeout.
-- Keep it out of the default run and require it in `prepublishOnly`.
+- Keep it out of the default run where the workspace has a gate that can hold it.
+  `.claude/rules/workspace.md` fixes which gate each isolated project runs from, and that placement
+  differs between a publishing and a `private: true` workspace.
+- The fixed expensive-proof projects are `distribution` and `service`.
+- A `distribution` proof reads `import.meta.env.MODE` and fails, rather than skips, on an unreachable
+  registry under `--mode release`. The publish gate invokes it that way, so a proof that skips there
+  passes the gate without ever proving the artifact installs. An ordinary local run may still skip.
 - Slow and hermetic is reason enough to isolate a proof; it need not touch an external service.
 - Where such a proof stays in a shared project, size its budget from a full contended run rather than from an isolated one. A budget that clears the isolated cost by a thin margin turns contention into a red gate reporting a timeout, which carries no diagnostic about the code and costs a full investigation to dismiss.
 
@@ -115,6 +138,8 @@ A test that spawns a process, packs, installs, or drives a real build is a proof
 
 Test helpers are shared infrastructure, not local test-file clutter.
 
+`@orkestrel/test` owns the helpers every workspace repeats: the call recorder, the real delay, the JSON and async collectors, and the owned scratch directory. Import them from `@orkestrel/test`, and its Node-only helpers from `@orkestrel/test/server`. Write a helper of your own only where the package exports none for the job. The shapes below are the contract a workspace codes against, not source to copy.
+
 - Extract a fixture, recorder, event factory, async wait, renderer, scenario/data builder, protocol fixture, or DOM builder as soon as it could serve another test.
 - Any duplicate or near-duplicate helper is a defect; consolidate it into one general form.
 - Export every reusable helper, fixture type, factory, constant, and guard from setup files.
@@ -123,7 +148,7 @@ Test helpers are shared infrastructure, not local test-file clutter.
 - Test files import shared infrastructure rather than declaring local fixture factories.
 - Never reimplement a framework helper in tests or fixtures; import the real parser, signer, flattener, or other helper.
 - Prefer small customizable factories/stubs that seed inert data for a real scenario over repeated inline setup.
-- Helper names follow module-helper naming: `createRecorder`, `buildElement`, `appendItems`, `renderRows`, `waitForDelay`, `extractDetail`.
+- Helper names follow module-helper naming: `createFixtureServer`, `buildElement`, `appendItems`, `renderRows`, `waitForReady`, `extractDetail`.
 
 Place helpers by environment:
 
@@ -134,10 +159,10 @@ Place helpers by environment:
 
 ### Recorder
 
-Use a real recorder callback instead of a framework spy when only calls/arguments matter:
+Import `createRecorder` from `@orkestrel/test` instead of a framework spy when only calls and arguments matter. It returns:
 
 ```ts
-interface TestRecorderInterface<TArgs extends readonly unknown[]> {
+interface RecorderInterface<TArgs extends readonly unknown[]> {
 	readonly calls: readonly TArgs[]
 	readonly count: number
 	readonly handler: (...args: TArgs) => void
@@ -147,11 +172,23 @@ interface TestRecorderInterface<TArgs extends readonly unknown[]> {
 
 ### Delay
 
-Use the shared delay helper; never repeat inline timeout promises:
+Import `waitForDelay` from `@orkestrel/test`; never repeat an inline timeout promise. It waits for one host timer and defaults to `0`:
+
+```ts
+function waitForDelay(ms?: number): Promise<void>
+```
+
+### Scratch
+
+Import `createScratch` from `@orkestrel/test/server` when a proof needs real files. It allocates a temporary directory it owns, contains every path against escape, and removes the directory on `destroy`:
 
 ```ts
-export function waitForDelay(ms = 0): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms))
+interface ScratchInterface {
+	readonly path: string
+	write(target: string, text: string): void
+	read(target: string): string | undefined
+	exists(target: string): boolean
+	destroy(): void
 }
 ```
 

package/dist/host/claude/rules/workspace.md

@@ -114,21 +114,26 @@ environment:
 The second axis is cross-cutting workspace proofs. Each one covers the whole workspace rather than
 one environment, so each is its own project:
 
-| Project       | Files                        | Proves                                                              | In `test` |
-| ------------- | ---------------------------- | ------------------------------------------------------------------- | --------- |
-| `policy`      | `tests/policy.test.ts`       | Every source file obeys the syntactic coding and placement law      | Yes       |
-| `config`      | `tests/config.test.ts`       | Root configuration resolves its aliases, projects, and outputs      | Yes       |
-| `guides`      | `tests/guides.test.ts`       | Every documented API exists and every public API is documented      | Yes       |
-| `conformance` | `tests/conformance.test.ts`  | Where this package drifts from the official tooling it tracks       | Yes       |
-| `integration` | `tests/integration.test.ts`  | The package's features work together end to end across environments | No        |
-| `service`     | `tests/service/**/*.test.ts` | The live external services this package drives, driven for real     | No        |
-
-`conformance` and `service` are two subjects, not two names for one. `conformance` measures this
-package against an official artifact it stays compatible with and drives nothing external: the
-tooling it measures against is installed, and any server it drives is one the proof starts itself.
-That is what makes it hermetic and keeps it in `test`. `service` drives the real thing, so it takes
-`tests/setupService.ts` for readiness, longer timeouts, and no file parallelism, and it leaves
-`test` for `prepublishOnly`.
+| Project        | Files                        | Proves                                                              | Gate                                  |
+| -------------- | ---------------------------- | ------------------------------------------------------------------- | ------------------------------------- |
+| `policy`       | `tests/policy.test.ts`       | Every source file obeys the syntactic coding and placement law      | `test`                                |
+| `config`       | `tests/config.test.ts`       | Root configuration resolves its aliases, projects, and outputs      | `test`                                |
+| `guides`       | `tests/guides.test.ts`       | Every documented API exists and every public API is documented      | `test`                                |
+| `conformance`  | `tests/conformance.test.ts`  | Where this package drifts from the official tooling it tracks       | `test`                                |
+| `distribution` | `tests/distribution.test.ts` | The packed package installs and resolves through its public exports | `prepublishOnly`; absent when private |
+| `integration`  | `tests/integration.test.ts`  | The package's features work together end to end across environments | `test`                                |
+| `service`      | `tests/service/**/*.test.ts` | The live external services this package drives, driven for real     | `prepublishOnly`; `test` when private |
+
+`conformance`, `integration`, `distribution`, and `service` are four subjects, not four names for
+one.
+Keep `conformance` in `test`: measure this package against an installed official artifact, and start
+any server the proof drives itself. Keep `integration` in `test`: compose the workspace's public
+surfaces without packing, installing, or driving an external service. In a publishing workspace,
+run `distribution` and `service` from `prepublishOnly`: pack and install the package in
+`distribution`, and drive the real service with `tests/setupService.ts`, longer timeouts, and no file
+parallelism in `service`. In a `private: true` workspace, never declare `prepublishOnly`; omit
+`distribution`, reach `service` from `test`, and retain the service project's isolated
+configuration.
 
 One project sits on neither axis. `probe` includes `tmp/probe/**/*.test.ts` so an agent can run a
 throwaway instrument against real sources, aliases and setup. Declare no proof there. Every test
@@ -139,9 +144,9 @@ script names its project, so no gate runs it; its directory is ignored by git; a
 - A live-service project is the fifth kind. It is the `service` project above, `scripts/service.sh`
   provisions what it drives, and `.claude/rules/tests.md` governs it. Name it `service` whatever it
   drives.
-- A project leaves the default run for one of two reasons: it drives a live external service, or it
-  is hermetic but slow — it spawns processes, packs, installs, or drives a real build.
-- Every isolated project has its own script, is excluded from `test`, and runs in `prepublishOnly`.
+- In a publishing workspace, a project leaves the default run when it drives a live external
+  service or is hermetic but slow — it spawns processes, packs, installs, or drives a real build.
+- Give every isolated project its own script, and place that script by the paragraph above.
 
 Setup assets:
 
@@ -151,7 +156,7 @@ Setup assets:
 
 Scope with `test:src`, `test:src:core`, `test:app`, `test:app:server`, and equivalent scripts. Each
 cross-cutting project has its own script too: `test:policy`, `test:config`, `test:guides`,
-`test:conformance`, `test:integration`, `test:service`.
+`test:conformance`, `test:distribution`, `test:integration`, `test:service`.
 
 ## Typechecking and environment isolation
 
@@ -206,7 +211,7 @@ Build/check config alignment:
 | `test`                  | Environment projects plus non-isolated cross-cutting proofs       |
 | `clean`                 | Remove `dist/`                                                    |
 | `copy <from> <to>`      | Copy while creating parent directories                            |
-| `prepublishOnly`        | The gate chain in `AGENTS.md`, then every isolated project        |
+| `prepublishOnly`        | Publishing workspaces only: the gate chain, then isolated proofs  |
 
 Run `show` only **after** formatting. The committed `demo/showcase.html` is generated/minified; formatting after generation would expand its inlined bundle.
 

package/dist/host/dotfiles/oxlintrc.json

@@ -49,6 +49,7 @@
 		"no-debugger": "error",
 		"no-underscore-dangle": "warn",
 
+		"vitest/no-alias-methods": "error",
 		"vitest/warn-todo": "off"
 	},
 	"categories": {