claude-toolkit 0.11.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.16.0 (2026-08-08)
+
+`ct-typescript-conventions` now selects a compiler as well as types: prefer the TypeScript 7 native compiler where a project already ships it, fall back cleanly where it does not, and never upgrade a project unprompted. Availability-aware in the same spirit as `ct-esnext-idioms`.
+
+- feat: prioritise the TypeScript 7 native compiler in `ct-typescript-conventions` — TS7 reached GA on 2026-07-08 as `typescript@7.0.2`, with Microsoft reporting 8x–12x faster full builds. The skill detects the *installed* version (`require('typescript/package.json').version`) rather than the declared semver range, which `overrides`/`resolutions`/catalogs routinely defeat, and names the three detection traps: the binary is `tsc` not `tsgo` (that was the pre-GA `@typescript/native-preview` name), range-sniffing is unreliable, and an API probe gives a false negative because TS7 exposes only `version`/`versionMajorMinor`.
+- feat: document when *not* to switch — TS7.0 ships no stable programmatic API, so `typescript-eslint`, `ts-jest`, `ts-node`, `vue-tsc`, `svelte-check`, `@astrojs/check` and `@angular/compiler-cli` break at install or lint time rather than at `tsc --noEmit`, which means a green type-check proves nothing. The skill prescribes the documented side-by-side alias install instead of a downgrade.
+- feat: add the TS7 `tsconfig.json` deltas — the options TS7 rejects outright (`ignoreDeprecations` no longer silences them), plus the two changed defaults behind most real breakage. Verified empirically against 5.9.3 / 6.0.3 / 7.0.2: both defaults land in 6.0 and carry forward, `types` fails `TS2591` even with `@types/node` installed, `rootDir` only bites when an `outDir` is set, and `types: ["*"]` is `TS2688` on 5.x — so no literal value is safe across majors.
+- feat: skill triggers now fire on typecheck, tsconfig, and compiler work — added the `tsc`, `tsgo`, `tsconfig`, `typecheck` and `compiler` keywords, the `**/tsconfig*.json` path pattern, and intents for running a typecheck or upgrading TypeScript.
+- docs: TSConfig cheat sheet gains a TypeScript 7 delta section; the skill's new remit is reflected in the generated skills index, README, and docs index.
+
+## 0.15.0 (2026-07-04)
+
+Two new authoring-convention assets — an opt-in `esnext` stack and an always-on `ct-code-style` core skill — plus Biome enforcement of the mechanically-checkable style rules.
+
+- feat: add the `esnext` stack (skill `ct-esnext-idioms`) — availability-aware guidance on modern ECMAScript runtime features: `Temporal` over `Date`, `using`/`await using` for deterministic cleanup, lazy iterator helpers, `structuredClone`, `Object.groupBy`/`Map.groupBy`, `Promise.withResolvers`, immutable array ops, and ESM hygiene. Detected on tsconfig `target`/`module`/`lib` = ESNext/ES2022+, package.json `"type":"module"`, `engines.node >= 20`, or a `.mjs` file.
+- feat: add the `ct-code-style` core skill (always included) — universal code-structure conventions: guard clauses over nested `else`, object lookup tables over `if/else if` chains, single-level ternaries, full ES6 destructuring, and arrow-only functions with no `class`/`this`. Carve-outs defer to stack skills: never destructure reactive SolidJS `props`, and use `class`/`this` only where a platform mandates it (e.g. Cloudflare Durable Objects).
+- feat: enforce the mechanically-checkable style rules in the scaffolded Biome config — `noUselessElse`, `noNestedTernary`, and `useArrowFunction`. `noMagicNumbers` is kept as skill guidance only (too noisy to enforce).
+- docs: document both assets in the README, `docs/stacks/esnext-idioms.md`, `docs/skills/code-style.md`, and the docs index; cross-link the SolidJS props rule to `ct-code-style`.
+
 ## 0.11.0 (2026-07-04)
 
 Remediation of the 2026-07-04 core audit (46 findings): the skill-eval hook is hardened, stack-owned commands are gated behind their stack, and the `ct-` agents, commands, skills, and reference docs are corrected and aligned.

package/README.md

@@ -107,6 +107,7 @@ Stacks in your config that are no longer detected are reported but left unchange
 | `playwright`      | Playwright E2E testing, Page Objects, fixtures, CI/CD              |
 | `storybook`       | Storybook interaction testing, CSF 3, visual regression            |
 | `capacitor`       | Capacitor 8 runtime, Capgo OTA, channels; webview UI & native feel |
+| `esnext`          | Modern ECMAScript idioms — Temporal, iterator helpers, `using`, structuredClone |
 
 ## Core Features (always included)
 
@@ -120,8 +121,9 @@ Stacks in your config that are no longer detected are reported but left unchange
 
 - `ct-systematic-debugging` — Four-phase debugging methodology
 - `ct-testing-patterns` — TDD workflow and patterns
-- `ct-typescript-conventions` — TypeScript strict mode best practices
+- `ct-typescript-conventions` — TypeScript strict mode best practices, and preferring the TS7 native compiler where available
 - `ct-verification-before-completion` — Evidence-based completion claims
+- `ct-code-style` — Code structure & style: guard clauses, lookup tables, no magic values
 
 ### Core Commands
 

package/core/skills/ct-code-style/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: ct-code-style
+description: Code structure & style — guard clauses, lookup tables, destructuring, no classes, no magic values
+---
+
+# Code Style
+
+Write small, flat, data-driven functions. These conventions apply to all JS/TS. Stack skills override where noted below.
+
+## Guard clauses / early returns
+
+Return early on edge cases; never nest the happy path inside `else`.
+
+```ts
+// Bad — nested, else-heavy
+const price = (user) => {
+  if (user) {
+    if (user.active) {
+      return user.plan.price;
+    } else {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+};
+
+// Good — guard clauses, flat
+const price = (user) => {
+  if (!user) return 0;
+  if (!user.active) return 0;
+  return user.plan.price;
+};
+```
+
+Rule: no `else` / `else if` after a `return`.
+
+## Lookup tables over chained conditionals
+
+```ts
+// Bad
+const getDiscount = (type) => {
+  if (type === "student") return 0.1;
+  else if (type === "senior") return 0.15;
+  else if (type === "employee") return 0.2;
+  else return 0;
+};
+
+// Good
+const getDiscount = (type) => {
+  const discounts = { student: 0.1, senior: 0.15, employee: 0.2 };
+  return discounts[type] ?? 0;
+};
+```
+
+For an exhaustive **typed** union where every case must be handled, prefer an exhaustive `switch` — see `ct-typescript-conventions`.
+
+## Ternaries — one level, never nested
+
+A ternary must not contain another ternary. Nesting → extract a lookup table or guard clauses.
+
+```ts
+// Bad — nested ternary
+const label = a ? "x" : b ? "y" : "z";
+
+// Good — lookup or guards
+const labels = { a: "x", b: "y" };
+const label = labels[key] ?? "z";
+```
+
+## Destructuring — use it fully
+
+```ts
+const { id, name: title, role = "guest", address: { city } = {}, ...rest } = user;
+//       basic  rename        default         nested (+ default)        rest
+const greet = ({ name, lang = "en" }) => `${GREETING[lang]} ${name}`; // in params
+```
+
+**⚠️ Never destructure reactive framework props.** In SolidJS, `const { value } = props` breaks reactivity — read `props.value` at the point of use. This carve-out is authoritative: see `ct-solidjs-patterns`. Destructuring is for plain data objects.
+
+## Functions — arrow-only, no `class`, no `this`
+
+Model behavior as functions and closures over state. No `class`, no `this` in your own code.
+
+```ts
+// Bad — class + this
+class Counter {
+  count = 0;
+  inc() {
+    this.count++;
+  }
+}
+
+// Good — closure
+const makeCounter = () => {
+  let count = 0;
+  return { inc: () => ++count, value: () => count };
+};
+```
+
+**⚠️ Exception:** use `class` / `this` only when a third-party lib or platform leaves no functional alternative — e.g. Cloudflare Durable Objects / `WorkerEntrypoint` (`export class Room extends DurableObject`), or subclassing built-ins (`class AppError extends Error`). See `ct-cloudflare-d1-kv`.
+
+## No magic numbers or strings
+
+Name every literal that carries meaning. User-facing text → i18n keys, never inline strings.
+
+```ts
+// Bad
+if (retries > 3) show("Trop de tentatives");
+
+// Good
+const MAX_RETRIES = 3;
+if (retries > MAX_RETRIES) show(LL.errors.tooManyRetries()); // i18n key, not a literal
+```
+
+User-facing strings belong in the locale layer — see `ct-i18n-typesafe`.
+
+## Anti-Patterns
+
+| Bad | Good |
+| --- | --- |
+| `else` after a `return` | guard clauses |
+| `if/else if` chain on a value | object lookup table + `??` |
+| nested ternary | lookup table or guards |
+| `class` + `this` for your own logic | arrow functions + closures |
+| destructuring SolidJS `props` | read `props.x` (see `ct-solidjs-patterns`) |
+| magic number / inline UI string | named const / i18n key |
+
+## See Also
+
+- `ct-typescript-conventions` — exhaustive `switch` for typed unions; typing destructured params.
+- `ct-esnext-idioms` — modern features these patterns pair with (`??`, `Object.groupBy`).
+- `ct-solidjs-patterns` — props are reactive; do not destructure them.
+- `ct-i18n-typesafe` — where user-facing strings live.

package/core/skills/ct-typescript-conventions/SKILL.md

@@ -1,12 +1,70 @@
 ---
 name: ct-typescript-conventions
-description: Strict TypeScript patterns for type safety, readability, and maintainable codebases. Use when writing or reviewing TypeScript, adding or tightening types, or deciding between type and interface
+description: Strict TypeScript patterns and compiler selection -- prefer the TypeScript 7 native compiler when a project ships it. Use when writing or reviewing TypeScript, running a typecheck, adding or tightening types, or deciding between type and interface
 ---
 
 # TypeScript Conventions
 
 Strict mode enabled. Catch errors at compile time, not runtime.
 
+## Compiler -- prefer TypeScript 7 when the project has it
+
+TypeScript 7 (GA 2026-07-08, `typescript@7.0.2`) is the Go-native compiler; Microsoft reports **8x--12x faster full builds**. In a project that already ships it, use it for every type-check and build. Never install or bump it unprompted.
+
+**Detect the installed version, not the declared range:**
+
+```bash
+node -p "require('typescript/package.json').version"   # major >= 7 -> TS7
+```
+
+Resolve from the directory you are editing -- monorepo workspaces can pin different majors. Three traps:
+
+- The TS7 binary is **`tsc`**. `tsgo` was the pre-GA `@typescript/native-preview` name -- never put it in a script.
+- `package.json` ranges lie: `overrides`, `resolutions`, catalogs, and stale lockfiles all win, and `*` / `latest` / `>=5` resolve to 7.x today.
+- Don't probe the API -- on TS7 `require("typescript")` exposes only `version` and `versionMajorMinor`, so a `ts.createProgram` check gives a false negative.
+
+**Using it** -- same flags as 6.x:
+
+```bash
+tsc --noEmit                  # type-check
+tsc -b                        # build mode / project references
+tsc --checkers 1 --noEmit     # CI: pin the worker count
+```
+
+`--checkers` defaults to 4. Pin it in CI -- Microsoft warns that varying it can surface order-dependent results.
+
+**Stay on 6.x when a tool embeds the compiler.** TS7.0 ships no stable programmatic API (7.1 targets a new one), so `typescript-eslint`, `ts-jest`, `ts-node`, `vue-tsc`, `svelte-check`, `@astrojs/check`, and `@angular/compiler-cli` all break -- at install or lint time, *not* at `tsc --noEmit`. A green type-check proves nothing here. Vite, Bun, `tsx`, Vitest, and Biome are unaffected. Run both rather than downgrading:
+
+```json
+{
+  "devDependencies": {
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2"
+  }
+}
+```
+
+Keep `typescript` pointed at the 6.0 package -- blocked tools import it by peer dependency. Where TS7 is absent, the floor is `typescript@6.0.3`, the bridge release; its readiness gate is a clean build with `"stableTypeOrdering": true` and no `ignoreDeprecations`.
+
+**`tsconfig.json` rules TS7 enforces** -- `ignoreDeprecations` no longer silences any of them:
+
+| Now rejected | Fix |
+|---|---|
+| `baseUrl` | project-root-relative `paths` |
+| `outFile`, `downlevelIteration` | remove |
+| `target: "es5"` | `"es2015"` or later |
+| `module: "amd" \| "umd" \| "system" \| "none" \| "systemjs"` | `"esnext"`, `"preserve"`, or `"nodenext"` |
+| `moduleResolution: "node" \| "node10" \| "classic"` | `"bundler"`, `"node16"`, or `"nodenext"` |
+| `esModuleInterop` / `allowSyntheticDefaultImports` / `alwaysStrict` set to `false` | drop the override |
+| `out`, `charset`, `keyofStringsOnly`, `importsNotUsedAsValues`, `preserveValueImports`, `suppressImplicitAnyIndexErrors`, `suppressExcessPropertyErrors`, `noStrictGenericChecks`, `noImplicitUseStrict` | gone -- `TS5023: Unknown compiler option` |
+
+Two changed defaults cause most real-world breakage. Both arrived in 6.0 and carry forward, so they bite on either major -- verified identical on 6.0.3 and 7.0.2:
+
+- **`types` defaults to `[]`** -- `process`, `Bun` and friends disappear (`TS2591`) *even with `@types/node` installed*. Set `"types": ["node"]` / `["bun"]` explicitly, naming only packages that are actually installed (a missing one is `TS2688`). `"types": ["*"]` restores the old catch-all on 6.x/7.x but is itself `TS2688` on 5.x.
+- **`rootDir` defaults to `./`** -- with sources in `src/` and an `outDir`, emit fails `TS5011`. Set `"rootDir": "./src"`. `--noEmit` does *not* surface this, so type-check CI stays green while the build breaks.
+
+`strict` and `stableTypeOrdering` are on by default; `stableTypeOrdering` cannot be turned off.
+
 ## Rules
 
 - **No `any`** -- Use `unknown` + narrowing, generics, or specific types.

package/docs/README.md

@@ -14,8 +14,9 @@ Skills that are always included regardless of stack configuration.
 | -------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
 | [ct-systematic-debugging](skills/systematic-debugging.md)                     | Four-phase methodology for diagnosing and fixing bugs without guesswork     |
 | [ct-testing-patterns](skills/testing-patterns.md)                             | Framework-agnostic TDD practices, mocking strategies, and test organization |
-| [ct-typescript-conventions](skills/typescript-conventions.md)                 | Strict TypeScript patterns for type safety and maintainability              |
+| [ct-typescript-conventions](skills/typescript-conventions.md)                 | Strict TypeScript patterns, plus TS7 native-compiler selection              |
 | [ct-verification-before-completion](skills/verification-before-completion.md) | Evidence-based completion claims with structured verification checklist     |
+| [ct-code-style](skills/code-style.md)                                         | Code structure & style: guard clauses, lookup tables, no magic values       |
 
 ## Commands
 
@@ -55,3 +56,4 @@ Stack-specific skills activated based on your `claude-toolkit.config.ts` configu
 | [ct-playwright-patterns](stacks/playwright-patterns.md)           | `playwright`      | E2E testing with Page Objects, fixtures, auth, network mocking, CI/CD          |
 | [ct-storybook-patterns](stacks/storybook-patterns.md)             | `storybook`       | Interaction testing, CSF 3, play functions, a11y, visual regression            |
 | [ct-capacitor-ota](stacks/capacitor-ota.md)                       | `capacitor`       | Capacitor 8 native runtime and Capgo OTA live updates, channels, encryption    |
+| [ct-esnext-idioms](stacks/esnext-idioms.md)                       | `esnext`          | Modern ECMAScript runtime idioms: Temporal, iterator helpers, using, structuredClone |

package/docs/best-practices/typescript/tsconfig-cheat-sheet.md

@@ -127,3 +127,34 @@ When a bundler (Vite, esbuild, etc.) handles transpilation:
   }
 }
 ```
+
+## TypeScript 7 Delta
+
+> Not from the source cheat sheet — added for TypeScript 7 (GA 2026-07-08, `typescript@7.0.2`). See [ct-typescript-conventions](../../skills/typescript-conventions.md#tsconfigjson-under-ts7) for the full compiler-selection guidance.
+
+Everything above is TS7-compatible as written, with **two additions** required when the native compiler is in use:
+
+```jsonc
+{
+  "compilerOptions": {
+    // `types` defaults to [] from 6.0 onward. Without this, ambient
+    // globals (`process`, Bun's APIs) fail TS2591 even when
+    // @types/node IS installed. Name only packages you actually have —
+    // a missing one is TS2688.
+    "types": ["node"],
+
+    // `rootDir` defaults to "./" from 6.0 onward. With sources in src/
+    // AND an outDir set, emit fails TS5011 — and `--noEmit` will not
+    // warn you. Without an outDir it does not fire.
+    "rootDir": "./src"
+  }
+}
+```
+
+Both defaults changed in **6.0**, not 7.0 — verified identical on `typescript@6.0.3` and `7.0.2`. `rootDir` matters only when the project emits to an `outDir`; `types` matters always.
+
+`"types": ["*"]` restores the pre-6.0 catch-all behaviour on 6.x and 7.x, but is `TS2688` on 5.x — so it is not a safe value for a config shared across majors.
+
+TS7 also rejects options this sheet never recommends — `baseUrl`, `outFile`, `downlevelIteration`, `target: "es5"`, `module: "amd" | "umd" | "system"`, and `moduleResolution: "node" | "node10" | "classic"`. `ignoreDeprecations` does not silence them.
+
+The TypeScript website's [tsconfig reference](https://www.typescriptlang.org/tsconfig/) has not been updated for TS7 and still documents removed options.

package/docs/skills/code-style.md

@@ -0,0 +1,26 @@
+# Code Style
+
+> Code structure & style: guard clauses, lookup tables, destructuring, no classes, no magic values.
+
+**Type:** Core Skill (always included)
+**Source:** [`core/skills/ct-code-style/SKILL.md`](../../core/skills/ct-code-style/SKILL.md)
+
+## Overview
+
+Universal, target-independent conventions for writing small, flat, data-driven functions. Always active — no stack required. It complements `ct-typescript-conventions` (types) and `ct-esnext-idioms` (modern features). Stack skills win where they overlap.
+
+## Rules
+
+- **Guard clauses / early returns** — no `else`/`else if` after a `return`.
+- **Lookup tables** over `if/else if` chains keyed on a value (`discounts[type] ?? 0`).
+- **Ternaries** — one level, never nested.
+- **Full ES6 destructuring** — basic, renaming, defaults, nested, rest, in parameters.
+- **Arrow-only, no `class`, no `this`** — model behavior as functions + closures.
+- **No magic numbers/strings** — named constants; user-facing text → i18n keys.
+
+## Carve-outs (stack skills win)
+
+- **SolidJS props:** never destructure reactive `props` — it breaks reactivity. See [`ct-solidjs-patterns`](../best-practices/solidjs/props-patterns.md).
+- **Platform classes:** `class`/`this` only where a third-party lib/platform requires it (Cloudflare Durable Objects, `class X extends Error`).
+
+Three of these rules are additionally enforced by Biome in the scaffolded `biome.json` (`noUselessElse`, `noNestedTernary`, `useArrowFunction`). "No magic numbers" stays guidance-only — it is too noisy to enforce mechanically.

package/docs/skills/typescript-conventions.md

@@ -1,6 +1,6 @@
 # TypeScript Conventions
 
-> Strict TypeScript patterns for type safety, readability, and maintainable codebases. Use when writing or reviewing TypeScript, adding or tightening types, or deciding between type and interface
+> Strict TypeScript patterns and compiler selection — prefer the TypeScript 7 native compiler when a project ships it. Use when writing or reviewing TypeScript, running a typecheck, adding or tightening types, or deciding between type and interface
 
 **Type:** Core Skill (always included)
 **Source:** [`core/skills/ct-typescript-conventions/SKILL.md`](../core/skills/ct-typescript-conventions/SKILL.md)
@@ -9,6 +9,98 @@
 
 Rules for writing TypeScript that leverages the type system fully. These assume strict mode is enabled and prioritize catching errors at compile time over runtime.
 
+The skill also covers **which compiler to run**. TypeScript 7 — the Go-native port — reached GA on 2026-07-08 as `typescript@7.0.2`, with Microsoft reporting 8x–12x faster full builds. The guidance is availability-aware in the same spirit as [ct-esnext-idioms](../stacks/esnext-idioms.md): prefer TS7 where a project already has it, fall back cleanly where it doesn't, and never upgrade a project unprompted.
+
+## Compiler Selection
+
+### Detect before you assume
+
+Read the **installed** version, resolved from the directory being edited (monorepo workspaces can pin different majors):
+
+```bash
+node -p "require('typescript/package.json').version"   # major >= 7 -> TS7
+```
+
+`typescript@7.0.2` whitelists `./package.json` in its `exports` map, and 5.x/6.x have no `exports` map at all, so this subpath resolves on every major.
+
+Three detection traps:
+
+| Trap | Why it misleads |
+|---|---|
+| Looking for a `tsgo` binary | TS7's only CLI binary is `tsc`. `tsgo` belonged to the pre-GA `@typescript/native-preview` package, which is frozen at a `7.0.0-dev` nightly. |
+| Reading the `package.json` semver range | `overrides`, `resolutions`, pnpm/bun catalogs and stale lockfiles all override it — and `*`, `latest`, `>=5` all resolve to 7.x today. |
+| Probing the API (`ts.createProgram`) | On TS7 `require("typescript")` exposes only `version` and `versionMajorMinor`, so an API probe reports a false negative. |
+
+### When TS7 is available
+
+Flags are unchanged from 6.x — `tsc --noEmit`, `tsc -p <path>`, `tsc -b`, `tsc --watch`. New in TS7:
+
+| Flag | Meaning |
+|---|---|
+| `--checkers <n>` | Type-checking workers per project (default 4). Microsoft warns that varying it "may surface order-dependent results" — pin it in CI. |
+| `--builders <n>` | Projects built concurrently in build mode (default 4). |
+| `--singleThreaded` | Most deterministic setting. |
+| `--lsp` | Language server over LSP (there is no `tsserver` binary). |
+
+Note that watch mode is labelled a prototype at the GA tag: it rebuilds but does not incrementally recheck.
+
+### When a tool embeds the compiler — do not switch
+
+TypeScript 7.0 ships **no stable programmatic API**; Microsoft targets 7.1 for "a new (and different) API" with no committed date. Anything that embeds the compiler is blocked:
+
+| Tool | Status on TS7 |
+|---|---|
+| `typescript-eslint` | Peer range `<6.1.0`; install fails `ERESOLVE`, and a forced install crashes during lint |
+| `vue-tsc`, `svelte-check`, `@astrojs/check` | Crash on `ERR_PACKAGE_PATH_NOT_EXPORTED` — TS7 has no `./lib/*` export |
+| `ts-node` | Crashes in config load |
+| `ts-jest` | Peer range `>=4.3 <7` |
+| `@angular/compiler-cli` | Peer range `>=6.0 <6.1` (Microsoft suggests a hybrid: TS7 at the CLI, TS6 for editor support) |
+
+Unaffected — these carry no `typescript` dependency at all: Vite, Bun, `tsx`, Vitest, Jest, Biome.
+
+**A type-check smoke test will not catch these failures.** typescript-eslint's breakage surfaces at `npm ci` and at lint time while `tsc --noEmit` still passes. When a blocked tool is present, install both compilers side by side rather than downgrading — this is Microsoft's documented escape hatch:
+
+```json
+{
+  "devDependencies": {
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2"
+  }
+}
+```
+
+The `typescript` key must stay pointed at the 6.0 compatibility package, because blocked tools import from `typescript` by peer dependency.
+
+### When TS7 is absent
+
+The floor is `typescript@6.0.3` — the last 6.x release, and the bridge Microsoft designates between 5.9 and 7.0. It also sits inside every current ecosystem peer range. The readiness gate before moving a project to 7 is a clean 6.0 build with `"stableTypeOrdering": true` and no `ignoreDeprecations` set. That flag is a diagnostic aid only — Microsoft notes it can add up to 25% to type-checking time and is not meant to be left on.
+
+### `tsconfig.json` under TS7
+
+These are rejected outright, and `ignoreDeprecations` no longer silences them (in 6.0 they were silenceable errors; in 7.0 there is no escape hatch):
+
+| Rejected | Replacement |
+|---|---|
+| `baseUrl` | project-root-relative `paths` |
+| `outFile`, `downlevelIteration` | remove |
+| `target: "es5"` | `"es2015"` or later |
+| `module: "amd" \| "umd" \| "system" \| "none" \| "systemjs"` | `"esnext"`, `"preserve"`, or `"nodenext"` |
+| `moduleResolution: "node" \| "node10" \| "classic"` | `"bundler"`, `"node16"`, or `"nodenext"` |
+| `esModuleInterop` / `allowSyntheticDefaultImports` / `alwaysStrict` set to `false` | drop the override |
+
+These are gone entirely — `TS5023: Unknown compiler option`: `out`, `charset`, `keyofStringsOnly`, `suppressImplicitAnyIndexErrors`, `noImplicitUseStrict`, `importsNotUsedAsValues`, `preserveValueImports`, `suppressExcessPropertyErrors`, `noStrictGenericChecks`.
+
+Two changed defaults account for most real-world breakage:
+
+- **`types` defaults to `[]`.** Ambient globals like `process` vanish with `TS2591`. Set it explicitly: `"types": ["node"]`, or `["bun"]` for Bun projects.
+- **`rootDir` defaults to `./`.** With sources under `src/` and an `outDir`, emit fails `TS5011`. Set `"rootDir": "./src"`. This fires **only when the program emits** — `tsc --noEmit` stays silent, so a type-check-only CI job can stay green while the build breaks.
+
+`strict` defaults to `true`, and `stableTypeOrdering` is on and cannot be turned off. `experimentalDecorators` and `emitDecoratorMetadata` both survive.
+
+Project references, `--build` mode, incremental builds, declaration emit, and CommonJS emit all work.
+
+> Reference note: `typescriptlang.org/tsconfig` has not been updated for TS7 and still documents removed options, and there is no TS 7.0 handbook release-notes page. The [GA announcement](https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/) is the authoritative what's-new source.
+
 ## Key Patterns
 
 ### Strict Mode

package/docs/stacks/esnext-idioms.md

@@ -0,0 +1,25 @@
+# ESNext Idioms
+
+> Modern ECMAScript runtime idioms — Temporal, iterator helpers, `using`, structuredClone.
+
+**Type:** Stack Skill (requires `esnext` stack)
+**Source:** [`stacks/esnext/skills/ct-esnext-idioms/SKILL.md`](../../stacks/esnext/skills/ct-esnext-idioms/SKILL.md)
+**Detected by:** tsconfig `target`/`module`/`lib` = `ESNext`/`ES2022+`, package.json `"type":"module"`, `engines.node >= 20`, or a `.mjs` file
+**File Extensions:** `.mjs`, `.cjs`
+
+## Overview
+
+Guidance for preferring current ECMAScript **runtime features** over legacy patterns and hand-rolled polyfills. It is availability-aware: each newer feature notes the runtime/polyfill it needs, so the recommendation never generates code the target can't run. Types are covered by `ct-typescript-conventions`; general code structure by `ct-code-style`.
+
+## Topics
+
+- **Dates → `Temporal`** — immutable, timezone-correct calendar/clock math (polyfill until baseline).
+- **Resource management → `using` / `await using`** — deterministic cleanup via `Symbol.dispose`/`asyncDispose`.
+- **Iterator helpers** — lazy `map`/`filter`/`take`, `Iterator.concat`, `Array.fromAsync`.
+- **Clone & group** — `structuredClone`, `Object.groupBy` / `Map.groupBy`.
+- **Async ergonomics** — `Promise.withResolvers`, `AbortSignal.timeout`/`any`, top-level await.
+- **Immutable array ops** — `at`, `findLast`, `toSorted`/`toReversed`/`with`.
+- **Errors** — `Error({ cause })`, `AggregateError`.
+- **ESM hygiene** — `import.meta.dirname` over `__dirname`, dynamic `import()`.
+
+See the [skill source](../../stacks/esnext/skills/ct-esnext-idioms/SKILL.md) for the full patterns, availability notes, and anti-patterns table.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-toolkit",
-	"version": "0.11.0",
+	"version": "0.16.0",
 	"description": "Reusable Claude Code configuration toolkit with stack-specific connectors",
 	"type": "module",
 	"bin": {

package/src/detect.ts

@@ -12,6 +12,8 @@ interface PackageJson {
 	dependencies?: Record<string, string>;
 	devDependencies?: Record<string, string>;
 	workspaces?: string[] | { packages?: string[] };
+	type?: string;
+	engines?: { node?: string };
 }
 
 /** A directory to inspect for stack markers, with its project-relative label */
@@ -54,6 +56,9 @@ const IGNORE_DIRS = new Set([
 	"test-results",
 ]);
 
+/** Node major version at/above which modern ESNext runtime features are assumed available. */
+const MIN_MODERN_NODE_MAJOR = 20;
+
 function readPackageJson(dir: string): PackageJson | null {
 	const pkgPath = join(dir, "package.json");
 	if (!existsSync(pkgPath)) return null;
@@ -174,6 +179,57 @@ function findProtoFiles(ctx: DetectContext): string | null {
 	return null;
 }
 
+/** Read a file's text, or null if missing/unreadable (tolerates comments/trailing commas). */
+function readTextFile(path: string): string | null {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * First scan root whose tsconfig.json sets target/module/lib to ESNext or ES2022+.
+ * Uses a lenient text scan because tsconfig files routinely carry comments and
+ * trailing commas that would break JSON.parse.
+ */
+function tsconfigTargetsEsnext(ctx: DetectContext): string | null {
+	const modern = /es(?:next|20(?:2[2-9]|[3-9]\d))/i; // ESNext or ES2022..ES2099
+	const keyValue = /"(?:target|module|lib)"\s*:\s*(?:"([^"]*)"|\[([^\]]*)\])/gi;
+	for (const { rel, dir } of ctx.scanRoots) {
+		const text = readTextFile(join(dir, "tsconfig.json"));
+		if (!text) continue;
+		for (const m of text.matchAll(keyValue)) {
+			if (modern.test(m[1] ?? m[2] ?? "")) return relPath(rel, "tsconfig.json");
+		}
+	}
+	return null;
+}
+
+/** Whether a package.json's engines.node floor is >= `major` (first integer in the range). */
+function enginesNodeAtLeast(pkg: PackageJson, major: number): boolean {
+	const range = pkg.engines?.node;
+	if (!range) return false;
+	const m = range.match(/(\d+)/);
+	return m ? Number(m[1]) >= major : false;
+}
+
+/** First `.mjs` file in a bounded search: each scan root's top level + bin/, src/, scripts/. */
+function findMjs(ctx: DetectContext): string | null {
+	const subs = ["", "bin", "src", "scripts"];
+	for (const { rel, dir } of ctx.scanRoots) {
+		for (const sub of subs) {
+			const searchDir = sub ? join(dir, sub) : dir;
+			if (!existsSync(searchDir)) continue;
+			const glob = new Bun.Glob("*.mjs"); // non-recursive: never descends into node_modules
+			for (const match of glob.scanSync({ cwd: searchDir, onlyFiles: true })) {
+				return relPath(rel, sub ? `${sub}/${match}` : match);
+			}
+		}
+	}
+	return null;
+}
+
 const DETECTORS: StackDetector[] = [
 	{
 		name: "solidjs",
@@ -271,6 +327,24 @@ const DETECTORS: StackDetector[] = [
 			return config ? { name: "capacitor", reason: `found ${config}` } : null;
 		},
 	},
+	{
+		name: "esnext",
+		detect: (ctx) => {
+			const ts = tsconfigTargetsEsnext(ctx);
+			if (ts) return { name: "esnext", reason: `found ESNext target in ${ts}` };
+			const mod = ctx.packages.find(({ pkg }) => pkg.type === "module");
+			if (mod) return { name: "esnext", reason: `found "type":"module" in ${pkgLabel(mod.rel)}` };
+			const eng = ctx.packages.find(({ pkg }) => enginesNodeAtLeast(pkg, MIN_MODERN_NODE_MAJOR));
+			if (eng)
+				return {
+					name: "esnext",
+					reason: `found engines.node >=${MIN_MODERN_NODE_MAJOR} in ${pkgLabel(eng.rel)}`,
+				};
+			const mjs = findMjs(ctx);
+			if (mjs) return { name: "esnext", reason: `found ${mjs}` };
+			return null;
+		},
+	},
 ];
 
 /** Scan a project directory (root + subdirs + workspace packages) and detect which stacks are present */

package/src/generator.ts

@@ -42,7 +42,7 @@ async function resolveConfig(config: ClaudeToolkitConfig): Promise<ResolvedConfi
 		"ct-testing-patterns",
 		"ct-typescript-conventions",
 		"ct-verification-before-completion",
-		...(config.excludeSkills ? [] : []),
+		"ct-code-style",
 	].filter((s) => !config.excludeSkills?.includes(s));
 
 	return { config, skills, directoryMappings: allMappings, hooks, stacks };
@@ -373,8 +373,11 @@ async function generateSkillsReadme(claudeDir: string, resolved: ResolvedConfig)
 	content +=
 		"| ct-systematic-debugging | Four-phase debugging methodology, root cause analysis |\n";
 	content += "| ct-testing-patterns | Test-driven development workflow and patterns |\n";
-	content += "| ct-typescript-conventions | TypeScript strict mode and conventions |\n";
+	content +=
+		"| ct-typescript-conventions | TypeScript strict mode, conventions, and TS7 compiler selection |\n";
 	content += "| ct-verification-before-completion | Evidence-based completion claims protocol |\n";
+	content +=
+		"| ct-code-style | Code structure & style: guard clauses, lookup tables, no magic values |\n";
 	content += "\n## Stack Skills\n\n";
 	content += "| Skill | Stack | Description |\n";
 	content += "|-------|-------|-------------|\n";

package/src/types.ts

@@ -10,6 +10,7 @@ export type StackName =
 	| "playwright"
 	| "storybook"
 	| "capacitor"
+	| "esnext"
 	| (string & {});
 
 /** Hook configuration for post-tool-use automation */

package/stacks/esnext/skills/ct-esnext-idioms/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: ct-esnext-idioms
+description: Modern ECMAScript runtime idioms — Temporal, iterator helpers, using, structuredClone
+---
+
+# Modern ESNext Idioms
+
+Prefer current ECMAScript runtime features over legacy patterns and hand-rolled polyfills. Types live in `ct-typescript-conventions`; code structure lives in `ct-code-style`; this skill is about *runtime features*.
+
+> Some features below are newer than the Node/browser baseline. Each is tagged with what it needs. When a target can't guarantee it, use the noted polyfill/flag rather than dropping back to the legacy pattern.
+
+## Dates & time → `Temporal`
+
+`Date` is mutable, timezone-naive, and error-prone for math. Use `Temporal` for calendar/clock work.
+
+```ts
+const today = Temporal.Now.plainDateISO();               // no time, no tz confusion
+const due = today.add({ days: 30 });                     // immutable — returns a new value
+const start = Temporal.ZonedDateTime.from("2026-07-04T09:00[Europe/Paris]");
+const mins = start.until(Temporal.Now.zonedDateTimeISO()).total("minutes");
+```
+
+_Availability: Stage 3 — not yet baseline in Node. Add `temporal-polyfill` (or `@js-temporal/polyfill`) until it ships._ Avoid `Date` mutation, manual `getTime()` ms math, and moment.js.
+
+## Deterministic cleanup → `using` / `await using`
+
+`Symbol.dispose` / `Symbol.asyncDispose` free resources when scope exits — no `try/finally` ladder.
+
+```ts
+const openFile = (path: string) => {
+  const handle = fs.openSync(path, "r");
+  return { handle, [Symbol.dispose]: () => fs.closeSync(handle) };
+};
+
+const readHead = (path: string) => {
+  using file = openFile(path);       // closed automatically at end of block
+  return fs.readSync(file.handle, Buffer.alloc(16), 0, 16, 0);
+};                                    // ← dispose runs here, even on throw
+```
+
+`await using` awaits `Symbol.asyncDispose` (db connections, locks, spans). _Availability: TS 5.2+ (downlevels) or Node 24+._
+
+## Iterator helpers → lazy, no intermediate arrays
+
+```ts
+const firstThree = users.values()
+  .filter((u) => u.active)
+  .map((u) => u.name)
+  .take(3)
+  .toArray();                        // only 3 names ever materialised
+
+const merged = Iterator.concat(pageA.values(), pageB.values()); // Iterator Sequencing — Stage 4 (2025); polyfill on older runtimes
+const rows = await Array.fromAsync(streamRows());   // async iterable → array
+```
+
+_Availability: standard iterator helpers (`.filter`/`.map`/`.take`) and `Array.fromAsync` are Node 22+ / modern browsers; `Iterator.concat` is newer (Iterator Sequencing, 2025) — polyfill until it lands._ Replaces `[...a, ...b].filter().map().slice()`, which allocates at every step.
+
+## Clone & group
+
+```ts
+const copy = structuredClone(state);                 // deep clone — Map/Set/Date/typed arrays
+const byRole = Object.groupBy(users, (u) => u.role); // { admin: [...], guest: [...] }
+const byId = Map.groupBy(users, (u) => u.id);        // Map keys (any type)
+```
+
+Avoid `JSON.parse(JSON.stringify(x))` (drops `undefined`, turns `Date` into a string, throws on cycles) and manual `reduce` grouping.
+
+## Promise & async ergonomics
+
+```ts
+const { promise, resolve, reject } = Promise.withResolvers<Data>();   // no deferred-hack closure
+const res = await fetch(url, { signal: AbortSignal.timeout(5_000) }); // auto-abort
+const signal = AbortSignal.any([userAbort, AbortSignal.timeout(30_000)]);
+```
+
+Top-level `await` is available in ESM modules — no IIFE wrapper.
+
+## Immutable array ops
+
+```ts
+const last = items.at(-1);                           // negative index
+const newest = orders.findLast((o) => o.settled);
+const sorted = scores.toSorted((a, b) => b - a);     // non-mutating; also toReversed/toSpliced/with
+const patched = row.with(2, "x");                    // copy with index 2 replaced
+```
+
+## Errors with cause
+
+```ts
+try {
+  await save();
+} catch (err) {
+  throw new Error("Checkout failed", { cause: err }); // preserve the chain
+}
+throw new AggregateError(errors, "Some uploads failed"); // aggregate independent failures
+```
+
+## ESM hygiene
+
+```ts
+const here = import.meta.dirname;          // replaces __dirname (Node 20.11+/21.2+)
+const url = import.meta.url;
+const mod = await import("./plugin.js");    // dynamic import, not require()
+```
+
+## Performance
+
+> _Verified against ECMAScript 2024 / Node 22 (2026-07)._
+
+- **Iterator helpers are lazy** — `take(3)` stops the pipeline after 3 items; the array form processes everything first. Use them for early-exit and large/infinite sequences.
+- **`structuredClone` is a native deep copy** — faster and more correct than `JSON.parse(JSON.stringify())`, with no string round-trip.
+- **`AbortSignal.timeout`** removes `setTimeout` bookkeeping and leaks; the runtime clears the timer when the signal settles.
+
+## Anti-Patterns
+
+| Legacy | Modern |
+| --- | --- |
+| `new Date()` math / moment.js | `Temporal` (via polyfill) |
+| `try { } finally { close() }` | `using` / `await using` |
+| `[...a, ...b].filter().map().slice()` | iterator helpers + `Iterator.concat` |
+| `JSON.parse(JSON.stringify(x))` | `structuredClone(x)` |
+| manual `reduce` grouping | `Object.groupBy` / `Map.groupBy` |
+| deferred `let resolve; new Promise(...)` | `Promise.withResolvers()` |
+| `arr[arr.length - 1]` | `arr.at(-1)` |
+| `__dirname` / `require()` | `import.meta.dirname` / `import()` |
+
+## See Also
+
+- `ct-typescript-conventions` — typing these values (`satisfies`, discriminated unions for async state).
+- `ct-code-style` — structure around these features (guard clauses, no magic numbers, `??`).

package/stacks/esnext/stack.json

@@ -0,0 +1,37 @@
+{
+	"name": "ct-esnext-idioms",
+	"description": "Modern ECMAScript runtime idioms — Temporal, iterator helpers, using, structuredClone",
+	"defaultMappings": {},
+	"fileExtensions": ["mjs", "cjs"],
+	"skillRules": {
+		"ct-esnext-idioms": {
+			"description": "Modern ECMAScript runtime idioms and features",
+			"priority": 5,
+			"triggers": {
+				"keywords": [
+					"Temporal",
+					"structuredClone",
+					"iterator",
+					"using",
+					"dispose",
+					"groupBy",
+					"withResolvers",
+					"AbortSignal",
+					"fromAsync",
+					"esnext",
+					"moment",
+					"date"
+				],
+				"keywordPatterns": ["\\bTemporal\\b", "\\busing\\b", "\\bstructuredClone\\b"],
+				"contentPatterns": [
+					"new Date\\(",
+					"JSON\\.parse\\(JSON\\.stringify",
+					"__dirname",
+					"\\.groupBy\\("
+				],
+				"intentPatterns": ["(?:format|parse|manipulate).*date", "(?:clone|copy).*(?:object|deep)"]
+			},
+			"relatedSkills": ["ct-typescript-conventions", "ct-code-style"]
+		}
+	}
+}

package/stacks/solidjs/skills/ct-solidjs-patterns/SKILL.md

@@ -29,7 +29,7 @@ const [data] = createResource(userId, fetchUser); // async: data(), data.loading
 
 ## Props
 
-**CRITICAL: Never destructure props.** Destructuring breaks reactivity.
+**CRITICAL: Never destructure props.** Destructuring breaks reactivity. (This overrides the general "use destructuring" guidance in `ct-code-style` — destructure plain data, never reactive `props`.)
 
 ```tsx
 // WRONG -- reads once, never updates

package/templates/configs/biome.base.json

@@ -16,7 +16,14 @@
 	"linter": {
 		"enabled": true,
 		"rules": {
-			"recommended": true
+			"recommended": true,
+			"style": {
+				"noUselessElse": "error",
+				"noNestedTernary": "error"
+			},
+			"complexity": {
+				"useArrowFunction": "error"
+			}
 		}
 	},
 	"javascript": {

package/templates/skill-rules.base.json

@@ -43,14 +43,37 @@
 			}
 		},
 		"ct-typescript-conventions": {
-			"description": "TypeScript strict mode and conventions",
+			"description": "TypeScript strict mode, conventions, and TS7 compiler selection",
 			"priority": 5,
 			"triggers": {
-				"keywords": ["typescript", "type", "interface", "generic", "strict mode"],
-				"keywordPatterns": ["\\btype\\b", "\\binterface\\b", "\\bgeneric\\b"],
-				"pathPatterns": ["**/*.d.ts", "**/types/**", "**/types.ts"],
-				"intentPatterns": ["(?:define|create).*(?:type|interface)", "(?:type).*(?:error|issue)"],
-				"contentPatterns": ["interface ", "type ", ": unknown", "as const"]
+				"keywords": [
+					"typescript",
+					"type",
+					"interface",
+					"generic",
+					"strict mode",
+					"tsc",
+					"tsgo",
+					"tsconfig",
+					"typecheck",
+					"compiler"
+				],
+				"keywordPatterns": [
+					"\\btype\\b",
+					"\\binterface\\b",
+					"\\bgeneric\\b",
+					"\\btsc\\b",
+					"\\btsconfig\\b",
+					"\\bts\\s?7\\b"
+				],
+				"pathPatterns": ["**/*.d.ts", "**/types/**", "**/types.ts", "**/tsconfig*.json"],
+				"intentPatterns": [
+					"(?:define|create).*(?:type|interface)",
+					"(?:type).*(?:error|issue)",
+					"(?:run|fix).*type.?check",
+					"(?:upgrade|migrate|update).*typescript"
+				],
+				"contentPatterns": ["interface ", "type ", ": unknown", "as const", "compilerOptions"]
 			},
 			"excludePatterns": ["issue type", "type of bug"]
 		},
@@ -65,6 +88,29 @@
 				],
 				"contextPatterns": ["before claiming", "make sure", "double check"]
 			}
+		},
+		"ct-code-style": {
+			"description": "Code structure & style — guard clauses, lookup tables, destructuring, no magic values",
+			"priority": 6,
+			"triggers": {
+				"keywords": [
+					"refactor",
+					"clean up",
+					"guard clause",
+					"early return",
+					"destructure",
+					"ternary",
+					"magic number",
+					"magic string",
+					"lookup table",
+					"arrow function"
+				],
+				"contentPatterns": ["else if", "else\\s*\\{", "\\bclass\\b", "this\\.", "\\bfunction\\b"],
+				"intentPatterns": [
+					"(?:refactor|clean up|simplify|tidy).*(?:code|function|logic)",
+					"(?:extract|avoid).*(?:magic|constant|conditional)"
+				]
+			}
 		}
 	}
 }