claude-toolkit 0.11.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 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)
 
@@ -122,6 +123,7 @@ Stacks in your config that are no longer detected are reported but left unchange
 - `ct-testing-patterns` — TDD workflow and patterns
 - `ct-typescript-conventions` — TypeScript strict mode best practices
 - `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/docs/README.md

@@ -16,6 +16,7 @@ Skills that are always included regardless of stack configuration.
 | [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-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/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/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.15.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 };
@@ -375,6 +375,8 @@ async function generateSkillsReadme(claudeDir: string, resolved: ResolvedConfig)
 	content += "| ct-testing-patterns | Test-driven development workflow and patterns |\n";
 	content += "| ct-typescript-conventions | TypeScript strict mode and conventions |\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

@@ -65,6 +65,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)"
+				]
+			}
 		}
 	}
 }