@hellraisercenobit/ai-engineering-gate 0.8.0

package/skills/engineering/transpose-design-patterns/references/transpose-vanilla.md

@@ -0,0 +1,204 @@
+# Vanilla TypeScript Transposition — Design Patterns (TypeScript 2026)
+
+Generic, portable wiring for the patterns in [`pattern-catalog.md`](pattern-catalog.md) in a
+**framework-less** TypeScript project (libraries, CLIs, workers, Web Components, plain DOM apps). No DI
+container, no component framework — just ES modules, functions, closures, and explicit wiring. Examples
+use throwaway domains (user, cart, payment, order); substitute your own types.
+
+## Vanilla building blocks
+
+The transpositions below lean on a few framework-less defaults:
+
+- **ES modules with named exports** — tree-shakeable; one concern per module. No default-export grab-bags.
+- **Functions and closures over classes.** Use a `class` only for genuine identity/lifecycle; never build
+  inheritance hierarchies — compose factory functions instead.
+- **Explicit dependency injection**: pass collaborators as function arguments, or close over them in a
+  factory. There is no magic container — a single **composition root** (your entry module) wires the
+  concrete implementations once.
+- **One reactive primitive, deliberately chosen**: a tiny closure-based observable store (below) for
+  app state, or **signals / atom-based stores** (e.g. `@preact/signals-core`, `nanostores`'
+  atoms/computed, or a TC39 Signals polyfill) when you want fine-grained derivation. Pick one and keep
+  state out of scattered module-level `let`s.
+- **Strong typing**: `as const satisfies` for lookup maps, discriminated unions, branded ids, `readonly`.
+- **Runtime validation** (zod/valibot) at every external boundary — network, storage, plugins, env.
+
+## Pattern → Vanilla wiring
+
+### Strategy → typed lookup map, resolved by key
+
+Stateless strategies in an `as const satisfies` record; pick by key — no `switch`.
+
+```ts
+export interface PaymentStrategy {
+  pay(amount: number): Promise<void>;
+}
+
+export const paymentStrategies = {
+  stripe: stripeStrategy,
+  paypal: paypalStrategy,
+} as const satisfies Record<string, PaymentStrategy>;
+
+export type PaymentMethod = keyof typeof paymentStrategies;
+
+const strategy = paymentStrategies[method]; // typed, exhaustive, no switch
+```
+
+### Registry → self-registering map (validated when dynamic)
+
+Plugins self-register into a module-level map; no central switch. Validate runtime/external plugins.
+
+```ts
+const registry = new Map<string, Plugin>();
+export const registerPlugin = (p: Plugin): void => void registry.set(p.key, p);
+export const getPlugin = (key: string): Plugin | undefined => registry.get(key);
+// dynamic plugins: validate the shape with zod/valibot before registering
+```
+
+### Factory → factory function closing over dependencies
+
+Isolate creation logic; return an interface, not a concrete class. Closures replace constructor DI.
+
+```ts
+export const createLogger = (env: Env): Logger => (env.production ? remoteLogger() : consoleLogger());
+
+export const createOrderApi = (http: HttpClient): OrderApi => ({
+  place: (cart: Cart): Promise<Order> => http.post('/orders', cart),
+});
+```
+
+### Command → framework-agnostic use-case function
+
+Encapsulate one action as a plain (async) function. Invoke it from an event handler, a CLI command, or
+a store action — keep it independent of any caller.
+
+```ts
+// application/use-case — depends only on a port, not on the DOM/transport
+export const checkoutCart = (orders: OrderApi, cart: Cart): Promise<Order> => orders.place(cart);
+```
+
+A store action is **not automatically** the Command — keep it a distinct use-case function the store action **delegates** to. Full rule + layering: catalog → _Command_.
+
+### Adapter / DTO Mapping → pure `from`/`to` at the data boundary
+
+Map DTO ↔ domain inside the api module; never let DTOs reach UI/render code.
+
+```ts
+// UserDto / User / userFromDto: see catalog -> Adapter / DTO Mapping
+export const getUser = async (http: HttpClient, id: string): Promise<User> =>
+  userFromDto(await http.get<UserDto>(`/api/users/${id}`));
+```
+
+### Composition → factory functions + closures + a composition root
+
+Compose behavior by combining small functions; wire concrete dependencies once at the entry module.
+No inheritance, no service locator.
+
+```ts
+// main.ts — composition root: build the graph explicitly, top-down
+const env = loadEnv();
+const http = createHttpClient(env.apiUrl);
+const orders = createOrderApi(http);
+const checkout = (cart: Cart) => checkoutCart(orders, cart);
+
+mountApp({ checkout, cartStore });
+```
+
+### Singleton / shared state → a closure-based observable store
+
+The common case for app-wide state without a framework: a single store instance exposing an immutable
+snapshot, a `subscribe`, and actions. Keep the shape minimal; update immutably inside actions.
+
+```ts
+type Listener<S> = (state: S) => void;
+
+export interface Store<S> {
+  get(): S;
+  subscribe(fn: Listener<S>): () => void;
+}
+
+const createStore = <S>(initial: S) => {
+  let state = initial;
+  const listeners = new Set<Listener<S>>();
+  const set = (next: (s: S) => S): void => {
+    state = next(state);
+    for (const fn of listeners) fn(state);
+  };
+  const store: Store<S> = {
+    get: () => state,
+    subscribe: (fn) => (listeners.add(fn), () => void listeners.delete(fn)),
+  };
+  return { store, set };
+};
+
+// a concrete store: expose the readonly Store + named actions, hide `set`
+export const createCartStore = () => {
+  const { store, set } = createStore<{ items: readonly CartItem[] }>({ items: [] });
+  const add = (item: CartItem): void => set((s) => ({ items: [...s.items, item] }));
+  const total = (): number => store.get().items.reduce((sum, i) => sum + i.price, 0);
+  return { ...store, add, total };
+};
+```
+
+Prefer **signals / atom-based stores** (`@preact/signals-core`, `nanostores`' atoms/computed, a TC39
+Signals polyfill) when you need fine-grained derived values and effects instead of re-deriving on each
+`subscribe` notification.
+
+## Cross-cutting vanilla practice
+
+### Wire dependencies in a composition root
+
+Construct the dependency graph once, at the entry module, and pass it down. Modules receive collaborators
+as arguments — they never import concrete singletons or reach into a global container.
+
+### Derive, don't duplicate
+
+Compute derived values with pure functions (or `computed` signals). Never store the same fact twice and
+keep it in sync by hand.
+
+### Render from state
+
+Drive the DOM from state: `subscribe` to the store (or run a signal effect) and re-render the affected
+region. Keep render functions pure-of-logic — they read state and produce DOM, nothing else.
+
+```ts
+const unsubscribe = cartStore.subscribe((s) => renderCart(root, s));
+```
+
+### Async at the boundary
+
+Use native `fetch` with an `AbortController` for cancellation; map DTO→domain in the api module. Surface
+errors as typed results (`{ ok: true; value } | { ok: false; error }`) rather than throwing across layers.
+
+### Keep modules cohesive
+
+UI/DOM code renders and dispatches; api modules do IO and mapping; use-cases hold logic; the store holds
+state. Don't mix transport, mapping, and business rules in one function.
+
+## Vanilla Decision Matrix
+
+| Problem                       | Recommended Solution                                          |
+| ----------------------------- | ------------------------------------------------------------ |
+| Shared app state              | closure observable store, or signals / atoms (@preact/signals-core, nanostores) |
+| Derived value                 | pure function, or `computed` signal                          |
+| Dependency injection          | function arguments / factory closures + a composition root   |
+| Interchangeable behaviors     | Strategy (`as const satisfies` lookup map)                   |
+| Plugin / extension system     | Registry (self-registering Map, zod for dynamic)             |
+| Object creation with logic    | Factory (function closing over dependencies)                 |
+| Reusable action               | Command (use-case function, store action delegates)          |
+| API ↔ domain shape mismatch  | Adapter — fromDto / toDto in the api module                  |
+| Cross-cutting behavior        | Composition (factories + closures + composition root)        |
+| Async read / mutation         | native `fetch` + `AbortController`, map at the boundary       |
+| DOM update                    | subscribe to store / signal effect → render the region       |
+| Runtime data validation       | zod / valibot at the boundary                                |
+
+## Anti-Patterns to Avoid
+
+- inheritance hierarchies / abstract base classes — compose factory functions instead
+- a service locator or hidden global container instead of an explicit composition root
+- module-level mutable `let` state scattered across files instead of one store / signal
+- mutating state in place instead of immutable updates inside actions
+- business logic in DOM event handlers instead of use-case functions; DTOs leaking into render/DOM code
+- string magic / `switch` on a type tag instead of an `as const satisfies` lookup map
+- a Command merged into a store action when it must be reusable — keep it a distinct use-case the action delegates to
+- god modules mixing transport + mapping + business rules; calling `fetch` from UI code — go through an api module
+- `any`; magic strings; skipping runtime validation at external boundaries

package/skills/engineering/transpose-design-patterns/references/transpose-vue.md

@@ -0,0 +1,234 @@
+# Vue Transposition — Design Patterns (TypeScript 2026)
+
+Generic, portable Vue wiring for the patterns in [`pattern-catalog.md`](pattern-catalog.md).
+Framework-specific only — keep business logic framework-agnostic in the catalog. Examples use
+throwaway domains (user, cart, payment, order); substitute your own types. This guide states **common**
+Vue practice, not any single project's house rules.
+
+## Vue building blocks
+
+The transpositions below lean on a few modern-Vue defaults (Vue 3.4+/3.5+):
+
+- **`<script setup lang="ts">` + Composition API** only — no Options API, no mixins in new code.
+- **`ref` / `computed`** for reactive state; prefer `ref` for primitives and `computed` for derived
+  values. Reach for `reactive` only for cohesive objects, and read it without destructuring.
+- **`defineModel()`** for two-way binding instead of a manual `modelValue` prop + `update:modelValue`
+  emit; **`useTemplateRef()`** for template refs; **reactive props destructure** (3.5, with defaults).
+- **Composables (`useXxx`)** for reusable, composable logic — the Vue unit of composition (VueUse for
+  common ones). Keep them small and focused.
+- **Typed DI** via `provide` / `inject` with an `InjectionKey<T>`, consumed through a custom composable.
+- **Strong typing**: `defineProps`/`defineEmits` generics, discriminated unions for variants,
+  `as const satisfies` for lookup maps, branded ids.
+
+```ts
+// di.ts
+export const ANALYTICS = Symbol() as InjectionKey<Analytics>;
+
+// useAnalytics.ts
+export function useAnalytics(): Analytics {
+  const a = inject(ANALYTICS);
+  if (!a) throw new Error('ANALYTICS not provided');
+  return a;
+}
+```
+
+## Pattern → Vue wiring
+
+### Strategy → typed lookup map, resolved by key
+
+Stateless strategies in an `as const satisfies` record; pick by key — no `switch`.
+
+```ts
+export interface PaymentStrategy {
+  pay(amount: number): Promise<void>;
+}
+
+export const paymentStrategies = {
+  stripe: stripeStrategy,
+  paypal: paypalStrategy,
+} as const satisfies Record<string, PaymentStrategy>;
+
+export type PaymentMethod = keyof typeof paymentStrategies;
+
+const strategy = paymentStrategies[method]; // typed, exhaustive, no switch
+```
+
+### Registry → self-registering map (validated when dynamic)
+
+Plugins self-register into a module-level map; no central switch. Validate runtime/external plugins with
+zod/valibot. When the registry is request/tenant-scoped, `provide` it and read it through a composable
+instead of importing the module singleton.
+
+```ts
+const registry = new Map<string, Plugin>();
+export const registerPlugin = (p: Plugin): void => void registry.set(p.key, p);
+export const getPlugin = (key: string): Plugin | undefined => registry.get(key);
+```
+
+### Factory → factory function returning an abstraction
+
+Isolate creation logic; return an interface, not a concrete class. A composable can be a factory of
+reactive-bound values.
+
+```ts
+export const createLogger = (env: Env): Logger => (env.production ? new RemoteLogger() : new ConsoleLogger());
+```
+
+### Command → framework-agnostic use-case, invoked from a handler or store action
+
+Encapsulate one action as a plain (async) function in a framework-agnostic module. Invoke it from an
+event handler or a Pinia action.
+
+```ts
+// application/use-case — no Vue imports
+export const checkoutCart = (cart: Cart): Promise<Order> => orderApi.place(cart);
+```
+
+A Pinia action is **not automatically** the Command — keep the action a distinct framework-agnostic use-case (function) the store action **delegates** to. Full rule + layering: catalog → _Command_.
+
+### Adapter / DTO Mapping → pure `from`/`to` at the data boundary
+
+Map DTO ↔ domain inside the api client / composable; never leak DTOs into components or templates.
+
+```ts
+// UserDto / User / userFromDto: see catalog -> Adapter / DTO Mapping
+export const getUser = async (id: string): Promise<User> =>
+  userFromDto(await api.get<UserDto>(`/api/users/${id}`));
+```
+
+### Composition → composables + slots + provide/inject
+
+Compose behavior through composables and component composition (slots, `provide`/`inject`) — not
+inheritance, not mixins.
+
+```vue
+<script setup lang="ts">
+const { visible } = useTooltip(); // behavior via composable
+</script>
+
+<template>
+  <section>
+    <slot name="media" />
+    <slot />
+  </section>
+</template>
+```
+
+### Singleton / shared state → a Pinia setup store
+
+The common case for app-wide state. Use a **setup store** (function form): `ref` for state, `computed`
+for getters, functions for actions; mutate only through actions. Consume with `storeToRefs` so the
+destructured state/getters stay reactive.
+
+```ts
+import { defineStore } from 'pinia';
+
+export const useCartStore = defineStore('cart', () => {
+  const items = ref<CartItem[]>([]);
+  const total = computed(() => items.value.reduce((sum, i) => sum + i.price, 0));
+  const add = (item: CartItem): void => void items.value.push(item);
+  return { items, total, add };
+});
+
+// consume
+const cart = useCartStore();
+const { items, total } = storeToRefs(cart); // reactive
+cart.add(item); // actions destructure directly
+```
+
+For app-wide _services_ (not reactive state), inject via `provide` / `inject` + a typed composable.
+
+## Cross-cutting Vue practice
+
+### computed for derived state, not watchers
+
+Derive with `computed`. Do **not** use a `watch` that writes into another `ref` to compute a value.
+
+```ts
+// Bad: watch([first, last], () => (full.value = `${first.value} ${last.value}`))
+const fullName = computed(() => `${first.value} ${last.value}`);
+```
+
+### Watchers only at external boundaries
+
+`watch` / `watchEffect` are for side effects that sync with systems outside Vue (persistence, analytics,
+non-Vue widgets). Register teardown with `onWatcherCleanup` (3.5). Event-response logic belongs in the
+handler, not a watcher.
+
+```ts
+import { onWatcherCleanup } from 'vue';
+
+watchEffect(() => {
+  const sub = socket.subscribe(onMessage);
+  onWatcherCleanup(() => sub.unsubscribe()); // 3.5 — also available as the callback's onCleanup arg
+});
+```
+
+### Async at the edge
+
+Default to a composable (TanStack Query Vue, or a framework helper like Nuxt `useAsyncData`); or —
+accepting that `<Suspense>` is still an **experimental** API (it may change before stabilizing) —
+`<Suspense>` + top-level `await` in `<script setup>`. Map DTO→domain in the fetcher; route API calls
+through a composable/store rather than calling the HTTP client from a component.
+
+### Two-way binding with defineModel
+
+For a value mirroring a parent binding, use `defineModel()` — not a manual `modelValue` prop plus an
+`update:modelValue` emit, and not a `watch` to sync.
+
+```ts
+const value = defineModel<string>();
+```
+
+### Keep components thin
+
+Components render UI, bind state, dispatch actions. Push logic and mapping into composables, the store,
+and pure framework-agnostic functions.
+
+### Template SRP
+
+No business logic in templates. Move ternaries, multi-condition branches, and data-transforming calls
+into `computed`.
+
+```ts
+// Bad (template): {{ user.isActive ? 'Active' : 'Inactive' }}
+const statusLabel = computed(() => (user.value.isActive ? 'Active' : 'Inactive'));
+// template: {{ statusLabel }}
+```
+
+### Forms
+
+Bind with `v-model` / `defineModel`. Keep validation rules in pure functions (zod/valibot) the form just
+calls; a library (VeeValidate) wires them to fields when forms get large.
+
+## Vue Decision Matrix
+
+| Problem                       | Recommended Solution                                          |
+| ----------------------------- | ------------------------------------------------------------ |
+| Local component state         | ref / reactive (objects)                                     |
+| Derived value                 | computed                                                      |
+| Shared app state              | Pinia setup store + storeToRefs                              |
+| Dependency injection          | provide / inject + InjectionKey + a typed composable         |
+| Interchangeable behaviors     | Strategy (`as const satisfies` lookup map)                   |
+| Plugin / extension system     | Registry (self-registering Map, zod for dynamic)             |
+| Object creation with logic    | Factory (factory function / composable)                      |
+| Reusable action               | Command (framework-agnostic use-case, store action delegates) |
+| API ↔ domain shape mismatch  | Adapter — fromDto / toDto in the fetcher / composable        |
+| Cross-cutting behavior        | Composition (composables + slots + provide/inject)           |
+| Async read / mutation         | composable (TanStack Query / useAsyncData) — or `<Suspense>` (experimental) + await |
+| Two-way binding               | defineModel()                                                |
+| Template ref                  | useTemplateRef()                                             |
+| External system sync          | watch / watchEffect with onWatcherCleanup                    |
+| Form                          | v-model / defineModel + pure validators (zod/valibot)        |
+
+## Anti-Patterns to Avoid
+
+- Options API or mixins in new code (use `<script setup>` + composables)
+- deriving state in a `watch` that writes a `ref` instead of using `computed`
+- destructuring a `reactive` object (loses reactivity) — use `ref` + `computed`, or `toRefs` / `storeToRefs`
+- mutating props; mutating store state outside actions
+- business logic in templates; DTOs leaking into templates; string magic / `switch` on a type tag instead of an `as const satisfies` lookup map
+- god composables/components; calling the HTTP client from a component — go through a composable/store
+- manual `modelValue` prop + `update:modelValue` emit instead of `defineModel`
+- a Command merged into a Pinia action when it must be reusable — keep it a distinct use-case the action delegates to
+- inheritance-heavy code; `any`; magic strings; global mutable singletons outside Pinia

package/skills/engineering/transpose-design-patterns/transpose-design-patterns.yaml

@@ -0,0 +1,24 @@
+name: transpose-design-patterns
+type: skill
+tools:
+  - claude-code
+  - cursor
+  - github-copilot
+description: "Decide a design pattern - or an explicit none - from a framework-agnostic catalog, transpose it to the target framework (Angular, React, Vue, Vanilla TS, Quarkus, PHP/Symfony), and record the decision before writing implementation code; then hand the code to a fresh blind reviewer. Use when implementing or refactoring a pattern-shaped decision - interchangeable behaviors, plugin extensibility, object creation, DTO mapping, shared state, or cross-cutting concerns."
+label: "Transpose Design Patterns"
+author: "Guillaume Mongin (@hellraisercenobit)"
+license: "MIT"
+copyright: "Copyright (c) 2026 Guillaume Mongin (@hellraisercenobit)"
+homepage: "https://github.com/hellraisercenobit/skills/tree/main/skills/engineering/transpose-design-patterns"
+version: "1.2.0"
+icon: "https://img.icons8.com/color/48/blueprint.png"
+tags:
+  - software-engineering
+  - architecture
+  - implementation
+  - conventions
+content: SKILL.md
+installPaths:
+  claude-code: .claude/skills/transpose-design-patterns/SKILL.md
+  cursor: .cursor/skills/transpose-design-patterns/SKILL.md
+  github-copilot: .github/instructions/transpose-design-patterns.instructions.md

package/skills/engineering/transpose-modern-typescript/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guillaume Mongin (@hellraisercenobit)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/engineering/transpose-modern-typescript/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: transpose-modern-typescript
+description: "Translate implementation intent into modern idiomatic TS/JS: everyday syntax, types, collections, generators, resource lifetime and native browser APIs. Compare native, library, custom and existing choices; record before editing, then obtain a fresh blind review. Use when writing or refactoring TS/JS with verbose extraction, nullish guards, redundant helpers, repeated lookups, eager production, unsafe casts or manual platform mechanisms. Companion to review-modern-typescript. Excludes prose-only and formatting-only edits."
+license: MIT
+metadata:
+  author: Guillaume Mongin (@hellraisercenobit)
+---
+
+# Transpose modern TypeScript
+
+Choose the simplest supported implementation that expresses intent and protects invariants.
+Actively seek useful language and platform capabilities: working code can still contain
+avoidable complexity. Justify readability, maintenance, safety, work avoided or lifetime.
+Keep an existing choice when it wins.
+
+## Read first, then disclose by need
+
+- [Shared contract 1.1.0](references/suite-contract.md): C01-C12, the declaration, the three
+  fingerprints, neutral brief, independence, composition, verdicts and gate/portable execution.
+  Read once per execution.
+- [Catalog 1.1.0](references/catalog.md): inventory axes and rule routing; load applicable families only.
+- [Compatibility](references/compatibility.md): compiler, declarations, build and runtime are separate.
+- [Record schema 2.0.0](references/decision-record.schema.json) and
+  [record guidance](references/record.md): validate before the first affected write.
+- Shared shapes beside the contract: [declaration](references/declaration.schema.json),
+  [decision envelope](references/decision-envelope.schema.json),
+  [evidence append](references/evidence-append.schema.json) and [dispute](references/dispute.schema.json).
+
+Resolve /review-modern-typescript before claiming completion. Both companions require contract
+1.1.0, catalog 1.1.0 and record schema 2.0.0. Missing or conflicting references make execution
+incomplete. No framework guide is required by this catalog.
+
+## Procedure
+
+0. **Declare.** Pipe a [declaration](references/declaration.schema.json) to
+   `ai-engineering-gate declare --dimension modern-typescript --stdin` before any record: whether the
+   dimension applies, the reason, the requester's own wording, the factual constraints, the comparison
+   base and the protected paths. `non-applicable` with its reason is a complete answer. The reviewer's
+   brief is rendered from this document, so it carries no chosen idiom and no rationale.
+1. **Frame.** Identify raw need, exact scope/base and actual compiler/lockfile, tsconfig,
+   build, runtimes and browsers. Put the ES/compiler target in declaration `constraints`
+   when this dimension applies; a tsconfig path is not a substitute. Do not pin projects to
+   the test compiler. In JS, use runtime rules and existing JSDoc/checkJs without requiring
+   a TS migration. Respect
+   framework reactivity, DOM ownership and cleanup. Invoke /transpose-design-patterns only
+   for architectural decisions; a local idiom does not automatically need a pattern.
+2. **Inventory.** Walk every catalog axis across relevant sites, including retained code.
+   Record applicable axes and reasoned exclusions at scope level. Searches suggest
+   candidates; read context. Examine access, amount consumed, lifetime, asynchrony,
+   platform services, transformations and type guarantees.
+3. **Compare.** Read applicable rules. Compare current code, native, library and custom
+   constructions wherever plausible. Prefer a supported native capability satisfying the
+   whole contract. Explain semantics, complexity, maintenance and compatibility. Preserve
+   business meaning in helpers. No blanket bans on loops, reduce, classes, enums,
+   libraries or assertions. Distinguish algorithmic benefits from measured timings;
+   benchmark only when the decision depends on timing.
+4. **Record before editing.** File it: `ai-engineering-gate record --dimension modern-typescript --stdin`,
+   which stores it outside the repository, validates it against the envelope and this catalog's schema, and
+   refuses a `cites` path that does not exist. Name in `plans` what the record commits to produce. State
+   each site's `semanticDelta` - what the change is expected to alter, what it must preserve - and, where a
+   type guarantee moves, its `consumption`, so MT-24 is answered rather than assumed. Group coherent choices
+   only if all sites remain identifiable. `none` means no specialized transposition helps; simple code can
+   still be written. `retain` is a separate action and can retain a named native idiom. A revision names the
+   cited paths it `changed`, and the gate refuses one whose citations are byte-identical. Without the gate,
+   validate with a JSON Schema 2020-12 validator plus catalog membership checks yourself.
+5. **Implement and check.** The first write inside the declared scope is allowed once the record is on file;
+   `ai-engineering-gate can-write --path <path>` answers it. Follow recorded invariants. Run proportional
+   existing checks and small behavioral/type checks where needed. Types do not prove runtime support. Verify
+   touched browser behavior in a real browser with the project's required tooling. Report commands, outcomes
+   and remaining limits separately, and file each planned artifact and check output through
+   `ai-engineering-gate evidence append --dimension modern-typescript --stdin`.
+6. **Dispatch fresh review.** Run `ai-engineering-gate status --full`: once the records and the planned
+   evidence are on file it prints the dispatch plan and the neutral brief for each reviewer. Use
+   `modern-typescript-reviewer`, otherwise a fresh general subagent without inherited conversation. Send the
+   brief as printed - scope and base, raw request, factual constraints, record paths, check evidence - and no
+   chosen idiom, rationale, expected verdict or test oracle. The reviewer runs /review-modern-typescript
+   itself. Without an independent context, report incomplete execution.
+7. **Close the loop.** Corrections are batched: address every pending finding of every dimension, then
+   dispatch all applicable reviews together on one state. An evidence finding is closed by its remedy, a
+   judgment finding by a revision that `addresses` it. A finding you contest goes to
+   `ai-engineering-gate dispute --dimension modern-typescript --stdin` with counter-evidence, and only the
+   user arbitrates it. Edits invalidate overlapping verdicts. Finish when `ai-engineering-gate can-stop`
+   exits 0.
+
+## Deliverable
+
+Summarize scope/profile, decisions, artifacts, benefits/trade-offs, records/revisions,
+checks, independent report and examined state. State portable mode honestly. Do not
+implicitly install polyfills, upgrade TS or extend a gate. Catalog gaps are separate
+from findings. Missing evidence is not successful completion.

package/skills/engineering/transpose-modern-typescript/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Transpose Modern TypeScript"
+  short_description: "Choose supported TS/JS idioms and verify the result"

package/skills/engineering/transpose-modern-typescript/references/arbitration.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/hellraisercenobit/skills/blob/main/contracts/schemas/arbitration.schema.json",
+  "title": "Arbitration 1.0.0",
+  "description": "A dispute's only exit, and only a human hand writes it. `arbitrate` is refused whenever an identity handoff exists for the call, which is the case for every agent tool call a hook saw.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "document",
+    "documentVersion",
+    "dimension",
+    "dispute",
+    "decision",
+    "words"
+  ],
+  "properties": {
+    "document": {
+      "const": "arbitration"
+    },
+    "documentVersion": {
+      "const": "1.0.0"
+    },
+    "dimension": {
+      "type": "string",
+      "minLength": 1
+    },
+    "dispute": {
+      "description": "The identifier of the dispute being arbitrated.",
+      "type": "string",
+      "minLength": 1
+    },
+    "decision": {
+      "description": "`uphold` closes the finding by arbitration and allows one fresh review on the same state; `reject` puts its remedy or correction back to pending.",
+      "enum": [
+        "uphold",
+        "reject"
+      ]
+    },
+    "words": {
+      "description": "The user's own words.",
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}

package/skills/engineering/transpose-modern-typescript/references/catalog.md

@@ -0,0 +1,38 @@
+# Modern TypeScript catalog 1.1.0
+
+One normative source per rule; the files below are owned by transpose-modern-typescript.
+The record schema enumerates these stable IDs. Review signatures only point here.
+Rules apply to JS as well as TS unless explicitly about static types.
+
+## Inventory axes
+
+For every scope, mark each axis applicable with sites, or excluded with a reason:
+`idioms`, `data-access`, `consumption`, `lifetime`, `async`, `platform`,
+`types`, `modules`. Examine all relevant sites, not only easy replacements.
+Prefer supported language/platform capabilities when they remove avoidable work or
+mechanism while preserving the complete contract. Current code is always an alternative.
+
+| Need or signal | Read |
+| --- | --- |
+| Repeated extraction, guards, array access, accumulation | [Everyday idioms](idioms.md), MT-01..05 |
+| Repeated lookup, membership, object metadata, partial consumption | [Collections and lifetime](collections.md), MT-06..08 |
+| Async coordination, network flow, parsing, copying | [Platform](platform.md), MT-09..12 |
+| DOM observation, rendering, workers, storage, security | [Platform](platform.md), MT-13..16 |
+| Inference, states, helpers, boundaries, mutability | [Types and abstractions](types.md), MT-17..21 |
+| Imports, runtime targets or any uncertain feature | [Compatibility](compatibility.md), MT-22..23 |
+| A replacement that may widen or erase a static guarantee | [Types and abstractions](types.md), MT-24 |
+| A helper that forwards to a platform or language capability | [Platform](platform.md), MT-25 |
+
+## Decision discipline
+
+Every rule specifies intent, use conditions, alternatives/trade-offs, avoid cases,
+observable invariants and compatibility sources. Read those clauses together. No rule
+requires syntax for its own sake or guarantees native code is faster. A Minor finding can
+identify concrete avoidable code, even without a bug, after its strongest defense fails.
+Claim measured speed only with a relevant measurement. Account for index construction,
+allocation, retained memory, serialization, cleanup, editor cost and public compatibility.
+
+`none` is a valid decision when no specialized transposition improves the scoped contract.
+Explain why plausible candidates do not help and what would reopen the choice. It can mean
+writing simple code, retaining a domain helper or using an ordinary loop. It is not the
+same as `retain` (an action), or an entirely non-applicable dimension.