lazycodex-ai 5.1.43 → 5.1.45

package/packages/shared-skills/skills/programming/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: programming
-description: "Applies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, and Go. Use for work on .py, .rs, .ts, or .go files."
+description: "Applies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, JavaScript, and Go. Use for work on .py, .rs, .ts, .js, or .go files."
 ---
 
 # Programming
@@ -22,7 +22,7 @@ This skill is an index. The hard per-language rules live under `references/`. Lo
    |---|---|
    | `.py`, `.pyi`, "Python" | `references/python/README.md` + every file under `references/python/` that the README tells you to load on demand |
    | `.rs`, `Cargo.toml`, "Rust" | `references/rust/README.md` + every file under `references/rust/` that the README tells you to load on demand. **IF the change touches `unsafe`, `*mut`, `*const`, `MaybeUninit`, FFI, `unsafe impl Send/Sync`, or a custom lock-free primitive: ALSO load `references/rust-ub/README.md` plus every file under `references/rust-ub/`.** |
-   | `.ts`, `.tsx`, `.mts`, `.cts`, "TypeScript" | `references/typescript/README.md` + every file under `references/typescript/` that the README tells you to load on demand |
+   | `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`, "TypeScript" / "JavaScript" | `references/typescript/README.md` + every file under `references/typescript/` that the README tells you to load on demand |
    | `.go`, `go.mod`, `go.sum`, `.golangci.yml`, `*.proto` next to a Go module, "Go" / "Golang" | `references/go/README.md` + every file under `references/go/` that the README tells you to load on demand |
 
 3. Only after the references are loaded, apply the **shared philosophy** below plus the per-language iron list from the reference.
@@ -176,12 +176,14 @@ A bare default constructor for any of these (no timeouts, no pool tuning, no sch
 |---|---|---|---|---|
 | Package / project manager | **uv** (NEVER pip/poetry/conda) | **cargo** + `cargo-nextest` + `cargo-machete` + `cargo-deny` | **Bun** (runtime + package manager); pnpm if Node is forced | **`go modules`** + `go work` for monorepos |
 | Type checker | **basedpyright** with `typeCheckingMode = "all"` | the Rust compiler with `-D warnings` + clippy `pedantic` + `nursery` + `cargo` groups | `tsc --noEmit` (or `tsgo` when available) with `strict` + `noUncheckedIndexedAccess` + `exactOptionalPropertyTypes` + `verbatimModuleSyntax` | the Go compiler + **`golangci-lint v2`** with the strict bundle + **`nilaway`** (nil-deref static analysis) |
-| Linter + formatter | **ruff** with `select = ["ALL"]` | `clippy` + `rustfmt` | **Biome** (single binary - replaces ESLint + Prettier) | **`gofumpt`** (stricter gofmt) + `goimports -local` + `golangci-lint v2` |
+| Linter + formatter | **ruff** with `select = ["ALL"]` | `clippy` + `rustfmt` | **oxlint + oxfmt**, with the local copy and suppression-reason rules | **`gofumpt`** (stricter gofmt) + `goimports -local` + `golangci-lint v2` |
 | Test runner | **pytest** | **cargo-nextest** | `bun test` / `vitest` | stdlib `go test -race -shuffle=on -count=1` + `goleak` |
 | UB / soundness gate | (n/a) | **nightly miri** with strict provenance + Tree Borrows pass | (n/a) | **`nilaway`** + `-race` detector + `goleak` are the equivalent gate |
 | Disposable scripts | **PEP 723** inline metadata + `uv run script.py` | **rust-script** with inline `Cargo.toml` block | `bun run script.ts` | `//go:build ignore` + `go run script.go` |
 | Bootstrap a new project | `scripts/python/new-project.py` | `scripts/rust/new-project.py` | `scripts/typescript/new-project.ts` | `scripts/go/new-project.py` |
-| Pre-commit / CI gate | `ruff check . && basedpyright && pytest` | `cargo clippy --all-targets -- -D warnings && cargo nextest run && cargo test --doc && cargo +nightly miri nextest run` | `bunx biome check . && bunx tsc --noEmit && bun test` | `gofumpt -l . && golangci-lint run ./... && nilaway ./... && go test -race -shuffle=on -count=1 ./...` |
+| Pre-commit / CI gate | `ruff check . && basedpyright && pytest` | `cargo clippy --all-targets -- -D warnings && cargo nextest run && cargo test --doc && cargo +nightly miri nextest run` | `bunx oxlint --type-aware --deny-warnings && bunx oxfmt --check && bunx tsc --noEmit && bun test` | `gofumpt -l . && golangci-lint run ./... && nilaway ./... && go test -race -shuffle=on -count=1 ./...` |
+
+For TS/JS, **use oxlint + oxfmt with these two rules by default**: `no-em-dash-copy` and `require-suppression-reason`. Strongly prefer this OXC toolchain for new projects; retain ESLint, Prettier, or Biome only when the repository already uses them. Load [`references/typescript/oxc-lint.md`](references/typescript/oxc-lint.md) for the complete configs, plugin, and type-aware support requirements. Rewrite paired em dashes as asides using parentheses or commas, not colon chains.
 
 A `tsconfig.json` with `"strict": true` alone is **not** strict. The reference enumerates the additional flags. Same for `pyproject.toml` and `Cargo.toml` - the references contain the canonical full configuration.
 
@@ -348,13 +350,14 @@ These two skills are not optional cosmetics. They are the recovery path for the
 | Canonical library defaults | `references/rust/libraries.md` |
 | **ANY `unsafe` / FFI / `MaybeUninit` / lock-free work** | **`references/rust-ub/` (full directory)** |
 
-### TypeScript (`.ts`, `.tsx`, `.mts`, `.cts`)
+### TypeScript / JavaScript (`.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`)
 
 **READ `references/typescript/README.md` FIRST.** Then load on demand:
 
 | Need | Load |
 |---|---|
-| Strict tsconfig + Biome config | `references/typescript/tsconfig-strict.md` |
+| Strict tsconfig | `references/typescript/tsconfig-strict.md` |
+| Default oxlint + oxfmt configs and copy rules | `references/typescript/oxc-lint.md` |
 | Type patterns (branded types, `as const`, `satisfies`, narrowing, `assertNever`) | `references/typescript/type-patterns.md` |
 | Data modeling (type vs interface vs Zod, readonly, parse-don't-validate) | `references/typescript/data-modeling.md` |
 | Error handling (Result, typed errors, union vs throw, AbortSignal timeouts) | `references/typescript/error-handling.md` |
@@ -386,6 +389,6 @@ These two skills are not optional cosmetics. They are the recovery path for the
 
 ## Activation
 
-This skill activates whenever you are writing or modifying any `.py`, `.pyi`, `.rs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.go` file, or any project manifest (`pyproject.toml`, `Cargo.toml`, `package.json`, `tsconfig.json`, `biome.json`, `go.mod`, `go.sum`, `.golangci.yml`, `Taskfile.yml`, `buf.yaml`, `sqlc.yaml`). **Even one-off scripts get the full treatment** - that is the whole point of `uv run` + PEP 723, `rust-script`, `bun run`, and `go run` + `//go:build ignore`: production hygiene with throwaway ergonomics.
+This skill activates whenever you are writing or modifying any `.py`, `.pyi`, `.rs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.go` file, or any project manifest (`pyproject.toml`, `Cargo.toml`, `package.json`, `tsconfig.json`, `.oxlintrc.json`, `.oxfmtrc.json`, `go.mod`, `go.sum`, `.golangci.yml`, `Taskfile.yml`, `buf.yaml`, `sqlc.yaml`). **Even one-off scripts get the full treatment** - that is the whole point of `uv run` + PEP 723, `rust-script`, `bun run`, and `go run` + `//go:build ignore`: production hygiene with throwaway ergonomics.
 
 The references contain the recipes. **Read them before writing code. Re-read them when the model drifts.** The post-write review loop is non-negotiable.

package/packages/shared-skills/skills/programming/references/typescript/README.md

@@ -1,5 +1,5 @@
 
-# TypeScript Programmer
+# TypeScript / JavaScript Programmer
 
 Modern TypeScript. Type-strict, stack-first, async-correct.
 
@@ -17,7 +17,7 @@ These are deliberate project choices. Violations are always wrong, not "style pr
 |---|---|---|
 | Runtime | Bun (native TS, single binary) | ts-node, tsx |
 | Package manager | `pnpm` | npm, yarn (unless workspace requires it) |
-| Linter + formatter | Biome | ESLint, Prettier |
+| Linter + formatter | **oxlint + oxfmt**, with both local copy rules | New ESLint, Prettier, or Biome setups; retain them only in repositories already using them |
 | Type checker | `tsc --noEmit` with strict config | skip type checking |
 | Web framework | Hono | Express |
 | Validation | Zod | joi, yup, class-validator |
@@ -125,7 +125,9 @@ bun run ../../scripts/typescript/new-project.ts my-api
 bun run ../../scripts/typescript/new-project.ts my-api --path ./projects
 ```
 
-Creates: `package.json` (Hono + Zod + Biome), `tsconfig.json` (ultra-strict), `biome.json`, `src/index.ts`, `.gitignore`. Works on macOS, Linux, Windows.
+Creates: `package.json` (Hono + Zod + oxlint + oxfmt + oxlint-tsgolint), strict `tsconfig.json`, `.oxlintrc.json`, `.oxfmtrc.json`, `lint/oxlint-plugin/` including its MIT license, `src/index.ts`, and `.gitignore`. Works on macOS, Linux, Windows.
+
+**Use oxlint + oxfmt with `no-em-dash-copy` and `require-suppression-reason` by default for TS and JS.** Load [oxc-lint.md](oxc-lint.md) for the complete setup. Use `--type-aware` with its installed companion where supported; keep `tsc --noEmit` as the type gate. Rewrite paired em dashes as parenthetical or comma-delimited asides, not colon chains.
 
 For manual setup: `bunx tsc --init`, then load `tsconfig-strict.md` for the full strict config.
 
@@ -145,7 +147,8 @@ Load on demand — not all at once.
 
 | Need | Load |
 |---|---|
-| Strict tsconfig + Biome config | `tsconfig-strict.md` |
+| Strict tsconfig | `tsconfig-strict.md` |
+| Default oxlint + oxfmt configs, rule mappings, and local JS plugin | `oxc-lint.md` |
 | Type patterns (branded, as const, satisfies, narrowing, assertNever) | `type-patterns.md` |
 | Data modeling (type vs interface vs Zod, readonly, parse-don't-validate) | `data-modeling.md` |
 | Error handling (Result, typed errors, union vs throw) | `error-handling.md` |
@@ -171,11 +174,11 @@ Violations caught by `../../scripts/typescript/check-no-excuse-rules.ts`. Run af
 | `empty-catch` | `catch { }` or `catch (e) { }` with empty body | `// no-excuse-ok: catch` |
 | `catch-without-narrowing` | `catch (e)` used without `instanceof` or re-throw | `// no-excuse-ok: catch` |
 
-Biome enforces additional rules (noExplicitAny, noNonNullAssertion, noDefaultExport, useImportType). The script catches what Biome cannot.
+Oxlint enforces explicit-any, non-null-assertion, default-export, and type-only-import rules; see [the verified mapping](oxc-lint.md). The audit script retains the checks not covered by those rules, including assertion and enum bans and catch narrowing.
 
 ## In tests
 
-Tests are strict too, with these exceptions (configure in `biome.jsonc` overrides):
+Tests are strict too, with these exceptions (configure in `.oxlintrc.json` overrides):
 
 | In tests you may | Why |
 |---|---|
@@ -192,4 +195,4 @@ When editing an existing file that doesn't follow these rules: **write new code
 
 ## Activation
 
-This skill activates whenever you are writing or modifying any `.ts` or `.tsx` file. Even one-off scripts get the strict treatment.
+This reference applies to `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, and `.cjs`. JavaScript uses the same lint, formatting, and copy rules; TypeScript-only syntax and compiler gates apply to TS or checked JS projects. Even one-off scripts get the strict treatment.

package/packages/shared-skills/skills/programming/references/typescript/bootstrap.md

@@ -91,31 +91,15 @@ bun install
 bun run dev
 ```
 
-## Lint + format — Biome
+## Lint + format: oxlint + oxfmt
 
-Biome replaces ESLint + Prettier with one tool, written in Rust, ~30x faster.
+**Strongly prefer oxlint + oxfmt for new TS/JS projects**, including the local `no-em-dash-copy` and `require-suppression-reason` plugin. Keep ESLint, Prettier, or Biome only when the repository already uses them.
 
 ```bash
-bun add --dev @biomejs/biome
-bun biome init
+bun add --dev oxlint@1.89.0 oxfmt@0.74.0 oxlint-tsgolint@7.0.2005
 ```
 
-`biome.json`:
-
-```json
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
-  "organizeImports": { "enabled": true },
-  "linter": { "enabled": true, "rules": { "recommended": true } },
-  "formatter": { "enabled": true, "indentStyle": "space", "indentWidth": 2 }
-}
-```
-
-Use ESLint only when:
-- You have an ESLint plugin Biome doesn't replicate (rare in 2026)
-- You're contributing to an existing ESLint project
-
-Never run both — pick one.
+Copy `.oxlintrc.json`, `.oxfmtrc.json`, and the plain-JS plugin with its license from [oxc-lint.md](oxc-lint.md), or run the scaffold. The reference explains product-source scoping and verified strict rules. Use `oxlint --type-aware --deny-warnings` where the companion/runtime/project supports it, plus `oxfmt --check` and `tsc --noEmit`. On unsupported targets use syntax lint and keep the compiler gate; do not claim type-aware checks ran.
 
 ## Test runner — bun test or vitest
 
@@ -166,8 +150,8 @@ NEVER Jest for a new project. Jest's CommonJS-first design fights every modern N
 mkdir my-api && cd my-api
 bun init -y
 bun add hono hono-openapi @scalar/hono-api-reference @hono/swagger-ui zod
-bun add --dev @biomejs/biome typescript
-bun biome init
+bun add --dev oxlint@1.89.0 oxfmt@0.74.0 oxlint-tsgolint@7.0.2005 typescript
+# Copy the configs and plugin from oxc-lint.md, including the plugin LICENSE.
 ```
 
 `package.json` scripts:
@@ -179,7 +163,9 @@ bun biome init
     "start": "bun run src/index.ts",
     "build": "bun build src/index.ts --target bun --outdir dist",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check --write src tests",
+    "lint": "oxlint --type-aware --deny-warnings",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
     "test": "bun test"
   }
 }

package/packages/shared-skills/skills/programming/references/typescript/oxc-lint.md

@@ -0,0 +1,130 @@
+# Default TypeScript / JavaScript lint and format setup
+
+**Use oxlint + oxfmt with `no-em-dash-copy` and `require-suppression-reason` by default.** Strongly prefer this OXC toolchain for new projects. Retain ESLint, Prettier, or Biome only when the repository already uses them; do not migrate an existing toolchain as incidental cleanup.
+
+## Install and run
+
+```bash
+bun add --dev oxlint@1.89.0 oxfmt@0.74.0 oxlint-tsgolint@7.0.2005
+bunx oxlint --type-aware --deny-warnings
+bunx oxfmt --check
+bunx tsc --noEmit
+```
+
+The scaffold at `../../scripts/typescript/new-project.ts` copies the configs and plugin below. For manual setup, copy `.oxlintrc.json`, `.oxfmtrc.json`, and `lint/oxlint-plugin/` (including `LICENSE`) from `../../scripts/typescript/oxc/` into the project root. Merge the `tsconfig.json` flags into an existing project's config; copy that file only for a new project. The plugin is plain ESM JavaScript; use `"type": "module"` in `package.json`.
+
+`--type-aware` requires the installed `oxlint-tsgolint` companion and a supported runtime/platform and TS project. Use it wherever supported. For syntax-only JS or an unsupported target, use `oxlint --deny-warnings`; retain the compiler gate for TS/checked JS and report that type-aware rules did not run. Type-aware lint does not replace `tsc --noEmit`. JS plugins are experimental, so keep these tested versions pinned and re-verify upgrades.
+
+## Complete .oxlintrc.json
+
+```json
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["typescript", "import", "oxc"],
+  "jsPlugins": [
+    { "name": "programming", "specifier": "./lint/oxlint-plugin/index.js" }
+  ],
+  "categories": { "correctness": "error", "suspicious": "error" },
+  "rules": {
+    "typescript/no-explicit-any": "error",
+    "typescript/no-non-null-assertion": "error",
+    "typescript/consistent-type-imports": "error",
+    "typescript/ban-ts-comment": [
+      "error",
+      { "ts-expect-error": true, "ts-ignore": true, "ts-nocheck": true, "ts-check": false }
+    ],
+    "typescript/no-empty-object-type": "error",
+    "typescript/no-wrapper-object-types": "error",
+    "typescript/no-floating-promises": "error",
+    "typescript/no-misused-promises": "error",
+    "typescript/switch-exhaustiveness-check": "error",
+    "import/no-default-export": "error",
+    "no-param-reassign": "error",
+    "no-unused-vars": "error",
+    "no-empty": "error",
+    "no-fallthrough": "error",
+    "prefer-const": "error",
+    "programming/require-suppression-reason": "error"
+  },
+  "ignorePatterns": ["node_modules/**", "dist/**", "build/**", "coverage/**", "vendor/**"],
+  "overrides": [
+    {
+      "files": ["src/**/*", "apps/*/src/**/*", "packages/*/src/**/*"],
+      "rules": { "programming/no-em-dash-copy": "error" }
+    },
+    {
+      "files": [
+        "**/*.{test,spec}.*",
+        "**/{test,tests,__tests__,fixtures,__fixtures__,_generated,vendor,vendored}/**",
+        "**/*.{gen,generated}.*"
+      ],
+      "rules": { "programming/no-em-dash-copy": "off" }
+    },
+    {
+      "files": ["src/index.ts", "lint/oxlint-plugin/*.js"],
+      "rules": { "import/no-default-export": "off" }
+    }
+  ]
+}
+```
+
+The final override is for Hono's required entrypoint export and the plugin API's default exports. Remove the `src/index.ts` exception in projects without that framework requirement. Adjust product globs to the repository's real source roots. Tests, fixtures, generated code, and vendored code are exempt from the copy rule, not from type strictness.
+
+## Complete .oxfmtrc.json
+
+```json
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": false,
+  "ignorePatterns": ["node_modules/**", "dist/**", "build/**", "coverage/**", "vendor/**"]
+}
+```
+
+Use `oxfmt` to write formatting and `oxfmt --check` in CI. Keep lint/type suppression directives on their own lines; put a reason on the directive or a separate comment above, never join the directive to the code it covers.
+
+## Local JavaScript plugin
+
+The complete, copyable implementation lives in:
+
+- [`index.js`](../../scripts/typescript/oxc/lint/oxlint-plugin/index.js): registers both rules.
+- [`no-em-dash-copy.js`](../../scripts/typescript/oxc/lint/oxlint-plugin/no-em-dash-copy.js): visits string `Literal`, cooked `TemplateElement`, and `JSXText`. Escaped em dashes are caught; comments and regex literals are exempt.
+- [`require-suppression-reason.js`](../../scripts/typescript/oxc/lint/oxlint-plugin/require-suppression-reason.js): checks oxlint/eslint disable directives and `@ts-expect-error`, `@ts-ignore`, `@ts-nocheck`. A reason follows the directive (`-- reason` for lint directives), or appears in a comment line above. Enable directives are exempt.
+- [`LICENSE`](../../scripts/typescript/oxc/lint/oxlint-plugin/LICENSE): retain alongside copied code.
+
+The copy diagnostic is exactly: "No em dashes in product copy. Use a period, comma, colon, or parentheses instead."
+
+Rewrite paired em dashes as asides using parentheses or commas, not colon chains. Choose punctuation from the whole sentence rather than replacing each dash token mechanically. The rule deliberately does not auto-fix prose.
+
+A reason is necessary, not permission to suppress an error. The strict TS config still bans type suppression directives even when explained. Fix the type; the reason rule additionally protects repositories where a justified exception is already allowed.
+
+## Strictness mapping
+
+Built-in names below were checked against oxlint **1.89.0**'s installed `configuration_schema.json` and by running the generated config. Re-check the installed schema or `oxlint --rules` before adding a rule; do not guess ESLint/Biome translations.
+
+| Intent | Enforcement |
+|---|---|
+| No explicit `any` | `typescript/no-explicit-any` |
+| No non-null assertions | `typescript/no-non-null-assertion` |
+| Explicit type-only imports | `typescript/consistent-type-imports` + `verbatimModuleSyntax` |
+| No TS suppressions | `typescript/ban-ts-comment` with all suppression directives banned |
+| Named exports | `import/no-default-export`, with narrow framework/plugin exceptions |
+| No parameter assignment | `no-param-reassign` |
+| No unused variables or imports | `no-unused-vars` |
+| No empty catches or switch fallthrough | `no-empty`, `no-fallthrough` |
+| Prefer constant bindings | `prefer-const` |
+| Avoid empty object and wrapper types | `typescript/no-empty-object-type`, `typescript/no-wrapper-object-types` |
+| Await promises and avoid async callbacks in synchronous contracts | `typescript/no-floating-promises`, `typescript/no-misused-promises` (`--type-aware`) |
+| Exhaustive discriminated unions | `typescript/switch-exhaustiveness-check` (`--type-aware`) + `assertNever` |
+| No assertion escapes, enums, or catch-without-narrowing | Existing `check-no-excuse-rules.ts` audit; these are not claimed as built-in oxlint rules |
+
+## Provenance and license
+
+Source: **pingdotgg/t3code oxlint plugin at d7f3b72**; `no-em-dash-copy` from **t3code#23799**, `require-suppression-reason` from **t3code#16294**. This plain-JS port uses `sisyphuslabs/omo-relay`'s `lint/oxlint-plugin/{index,no-em-dash-copy,require-suppression-reason}.js`, with the local plugin namespace renamed to `programming`.
+
+The upstream [license at d7f3b72](https://github.com/pingdotgg/t3code/blob/d7f3b72/LICENSE) is **MIT**, copyright (c) 2026 T3 Tools Inc. The full notice is shipped in the plugin's `LICENSE` and copied by the scaffold.
+
+References: [JS plugins](https://oxc.rs/docs/guide/usage/linter/js-plugins.html), [type-aware lint](https://oxc.rs/docs/guide/usage/linter/type-aware.html), [oxlint config](https://oxc.rs/docs/guide/usage/linter/config.html), [oxfmt config](https://oxc.rs/docs/guide/usage/formatter/config.html).

package/packages/shared-skills/skills/programming/references/typescript/tsconfig-strict.md

@@ -1,4 +1,4 @@
-# Strict tsconfig + Biome
+# Strict tsconfig + OXC
 
 The canonical ultra-strict config. Copy-paste, then add your own paths.
 
@@ -72,73 +72,17 @@ For Bun projects, add to `compilerOptions`:
 
 ---
 
-## biome.jsonc
+## oxlint + oxfmt
 
-```jsonc
-{
-  "$schema": "https://biomejs.dev/schemas/2.0.6/schema.json",
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "suspicious": {
-        "noExplicitAny": "error",
-        "noConfusingVoidType": "error",
-        "noFallthroughSwitchClause": "error"
-      },
-      "style": {
-        "noDefaultExport": "error",
-        "useImportType": "error",
-        "noNonNullAssertion": "error",
-        "useEnumInitializers": "off",
-        "noParameterAssign": "error"
-      },
-      "correctness": {
-        "noUnusedVariables": "error",
-        "noUnusedImports": "error"
-      },
-      "complexity": {
-        "noBannedTypes": "error"
-      }
-    }
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "double",
-      "semicolons": "asNeeded"
-    }
-  },
-  "files": {
-    "ignore": ["node_modules", "dist", "build", ".next", ".nuxt", "coverage"]
-  }
-}
-```
-
-### Key Biome rules
-
-| Rule | What |
-|---|---|
-| `noExplicitAny` | `any` in annotations is an error |
-| `noNonNullAssertion` | `x!` is an error |
-| `noDefaultExport` | Forces named exports |
-| `useImportType` | Forces `import type` for type-only imports |
-| `noParameterAssign` | No mutation of function parameters |
+Use [oxc-lint.md](oxc-lint.md) for the complete `.oxlintrc.json`, `.oxfmtrc.json`, and local JS plugin. It maps the strictness intent to verified oxlint rules, adds the two t3code copy rules, and documents type-aware support. Retain ESLint, Prettier, or Biome only in repositories already using them.
 
 ---
 
 ## CI gate
 
 ```bash
-bunx biome check .
+bunx oxlint --type-aware --deny-warnings
+bunx oxfmt --check
 bunx tsc --noEmit
 bun test
 ```
@@ -148,5 +92,5 @@ bun test
 ## Sources
 
 - TypeScript: [tsconfig reference](https://www.typescriptlang.org/tsconfig)
-- Biome: [configuration](https://biomejs.dev/reference/configuration/)
+- OXC: [oxlint configuration](https://oxc.rs/docs/guide/usage/linter/config.html) and [oxfmt configuration](https://oxc.rs/docs/guide/usage/formatter/config.html)
 - Total TypeScript: [tsconfig cheat sheet](https://www.totaltypescript.com/tsconfig-cheat-sheet)

package/packages/shared-skills/skills/programming/scripts/typescript/check-no-excuse-rules.ts

@@ -180,24 +180,24 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
       const typeText = node.type.getText(sourceFile)
       if (typeText === "any") {
         const p = pos(node)
-        violations.push({ ruleId: "no-any-assertion", filePath, ...p, message: "`as any` — narrow with type guards or redesign the types" })
+        violations.push({ ruleId: "no-any-assertion", filePath, ...p, message: "`as any`: narrow with type guards or redesign the types" })
       }
       if (typeText === "unknown") {
         const p = pos(node)
-        violations.push({ ruleId: "no-unknown-assertion", filePath, ...p, message: "`as unknown` — redesign the types" })
+        violations.push({ ruleId: "no-unknown-assertion", filePath, ...p, message: "`as unknown`: redesign the types" })
       }
     }
 
     // ── enum ──
     if (ts.isEnumDeclaration(node)) {
       const p = pos(node)
-      violations.push({ ruleId: "no-enum", filePath, ...p, message: "`enum` — use `as const` object + literal union type" })
+      violations.push({ ruleId: "no-enum", filePath, ...p, message: "`enum`: use `as const` object + literal union type" })
     }
 
     // ── x! non-null assertion ──
     if (ts.isNonNullExpression(node)) {
       const p = pos(node)
-      violations.push({ ruleId: "no-non-null-assertion", filePath, ...p, message: "`x!` — use narrowing or optional chaining" })
+      violations.push({ ruleId: "no-non-null-assertion", filePath, ...p, message: "`x!`: use narrowing or optional chaining" })
     }
 
     // ── throw "literal" ──
@@ -205,11 +205,11 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
       const expr = node.expression
       if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
         const p = pos(node)
-        violations.push({ ruleId: "no-throw-literal", filePath, ...p, message: "`throw literal` — throw an Error subclass" })
+        violations.push({ ruleId: "no-throw-literal", filePath, ...p, message: "`throw literal`: throw an Error subclass" })
       }
       if (ts.isTemplateExpression(expr)) {
         const p = pos(node)
-        violations.push({ ruleId: "no-throw-literal", filePath, ...p, message: "`throw template` — throw an Error subclass" })
+        violations.push({ ruleId: "no-throw-literal", filePath, ...p, message: "`throw template`: throw an Error subclass" })
       }
     }
 
@@ -220,7 +220,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
         const flags = node.declarationList.flags
         if (!(flags & ts.NodeFlags.Const)) {
           const p = pos(node)
-          violations.push({ ruleId: "no-mutable-export", filePath, ...p, message: "`export let/var` — use `export const`" })
+          violations.push({ ruleId: "no-mutable-export", filePath, ...p, message: "`export let/var`: use `export const`" })
         }
       }
     }
@@ -239,7 +239,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
           ts.isPropertySignature(parent)
         )) {
           const p = pos(node)
-          violations.push({ ruleId: "no-any-annotation", filePath, ...p, message: "`: any` annotation — use `unknown` and narrow" })
+          violations.push({ ruleId: "no-any-annotation", filePath, ...p, message: "`: any` annotation: use `unknown` and narrow" })
         } else if (parent && (
           ts.isFunctionDeclaration(parent) ||
           ts.isMethodDeclaration(parent) ||
@@ -247,7 +247,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
           ts.isFunctionExpression(parent)
         )) {
           const p = pos(node)
-          violations.push({ ruleId: "no-explicit-any-return", filePath, ...p, message: "`(): any` return — use a specific type" })
+          violations.push({ ruleId: "no-explicit-any-return", filePath, ...p, message: "`(): any` return: use a specific type" })
         }
       }
     }
@@ -263,7 +263,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
         if (stmts.length === 0) {
           // Empty catch — swallows everything silently
           const p = pos(node)
-          violations.push({ ruleId: "empty-catch", filePath, ...p, message: "empty `catch` block — handle, re-throw, or remove the try/catch" })
+          violations.push({ ruleId: "empty-catch", filePath, ...p, message: "empty `catch` block: handle, re-throw, or remove the try/catch" })
         } else if (node.variableDeclaration) {
           // Has a bound variable — check if it's narrowed with instanceof
           const varName = node.variableDeclaration.name.getText(sourceFile)
@@ -272,7 +272,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
           const hasRethrow = blockText.includes(`throw ${varName}`) || blockText.includes(`throw new`)
           if (!hasInstanceof && !hasRethrow) {
             const p = pos(node)
-            violations.push({ ruleId: "catch-without-narrowing", filePath, ...p, message: "`catch` without `instanceof` narrowing or re-throw — narrow the error type or re-throw" })
+            violations.push({ ruleId: "catch-without-narrowing", filePath, ...p, message: "`catch` without `instanceof` narrowing or re-throw: narrow the error type or re-throw" })
           }
         }
       }
@@ -298,7 +298,7 @@ function analyzeFile(filePath: string, sourceFile: tsTypes.SourceFile): Violatio
       filePath,
       line: line + 1,
       column: character + 1,
-      message: `\`@ts-${kind}\` — fix the underlying type`,
+      message: `\`@ts-${kind}\`: fix the underlying type`,
     })
   }