@hellraisercenobit/ai-engineering-gate 0.8.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@hellraisercenobit/ai-engineering-gate",
+  "version": "0.8.0",
+  "description": "Generic enforcement for the transpose/review engineering suite - registry, evidence, fingerprints, verdicts",
+  "keywords": [
+    "agent",
+    "skills",
+    "code-review",
+    "tdd",
+    "design-patterns"
+  ],
+  "author": {
+    "name": "Guillaume Mongin",
+    "url": "https://github.com/hellraisercenobit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hellraisercenobit/skills",
+    "directory": "packages/ai-engineering-gate"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "ai-engineering-gate": "bin/ai-engineering-gate.mjs"
+  },
+  "exports": {
+    ".": "./dist/ai-engineering-gate.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "contracts",
+    "skills",
+    "agents",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "node ../../scripts/stage-gate-package.mjs",
+    "postpack": "node ../../scripts/stage-gate-package.mjs --clean"
+  }
+}

package/skills/engineering/review-design-patterns/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2026 Guillaume Mongin (@hellraisercenobit)
+
+This skill (`review-design-patterns`) is an original work by Guillaume Mongin.
+See the repository root `LICENSE` and `NOTICE` for full terms.

package/skills/engineering/review-design-patterns/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: review-design-patterns
+description: Independently audit design-pattern decisions against the shared pattern catalog - re-derive each site blind and freeze the expected design, then compare it with the recorded decision and the actual code, and put every finding through a steelman gate - so each pattern is confirmed sound or flagged with evidence. USE WHEN reviewing existing code, a diff, or a PR for pattern soundness and anti-patterns (switch-on-type-tag, DTO leaking to UI, Command folded into a store, missing Strategy/Registry, a lazy none), when a transpose-design-patterns task hands its code to a fresh reviewer, or when challenging a not-yet-built design proposal. Companion to transpose-design-patterns. EXAMPLES - "review the design patterns in this lib", "is this Strategy correct?", "audit this PR's architecture", "did I apply Registry right?".
+license: MIT
+author: Guillaume Mongin (@hellraisercenobit)
+---
+
+# Review Design Patterns
+
+An **independent**, adversarial audit of the design-pattern decisions in any codebase. It is the mirror of
+`transpose-design-patterns`: that skill decides a pattern (or `none`) and records it; this one judges whether
+the code that exists realizes the right design - and is willing to say it does not.
+
+The review is worthless if it is not **independent**. Two failures kill it equally: rubber-stamping the
+author's choice, and manufacturing findings to look thorough. The protocol below defends against both - you
+re-derive every decision **blind** and **freeze** it, then make each finding survive a **steelman** before
+it ships.
+
+## What "independent" means here
+
+- **The catalog is the standard, not the author's intent.** A comment, commit message, PR description or
+  design decision record saying "this is the Strategy pattern" is never evidence the design is right. The
+  code carries the burden of proof.
+- **Re-derive blind, then freeze.** For each site, write down what the catalog says the design *should* be
+  **before** you read the author's rationale, the design decision record, comments or commit messages.
+  Once written, the expected design does not move: you compare against it, you do not revise it to fit
+  what you find.
+- **If you wrote it, you are not independent.** When auditing code you authored earlier in this session,
+  dispatch the audit to a fresh reviewer - the `design-pattern-reviewer` agent when the harness defines
+  one, else a fresh subagent (the `Agent` tool) - with the brief `transpose-design-patterns` prescribes. The
+  fresh reviewer never authored anything in scope, so it runs this skill itself and does not dispatch
+  again. This is the strongest realization of independence; the blind re-derivation below is the floor.
+
+## Shared standard - read, do not duplicate
+
+This skill owns no catalog. It judges against the bundled sources of its companion, `transpose-design-patterns`:
+
+- **Shared procedure:** resolve `/transpose-design-patterns` and read its `references/suite-contract.md` (contract 1.1.0). Apply its dependency, read-only, neutral-context, composition and state-expiry guarantees alongside this domain protocol. Missing required references mean incomplete execution, never `SOUND`.
+- **Catalog (the rules):** [`../transpose-design-patterns/references/pattern-catalog.md`](../transpose-design-patterns/references/pattern-catalog.md)
+  - the _Structural forces_ table (with the _Extension-cost test_) and each entry's _Invariants_ are the
+  **positive** checklist (what must be observable when the design is right); each entry's **Avoid** clause
+  is the **negative** one (your violation checklist); the _Core Principles_ and the table's _Decision_ column
+  settle which pattern a force points at, `None` included.
+- **Record shape:** [`../transpose-design-patterns/references/design-decision-record.schema.json`](../transpose-design-patterns/references/design-decision-record.schema.json)
+  - what a design decision record contains, so you know what to compare against in step 4.
+- **Transposition (per framework):** the `transpose-<framework>.md` guide for the project's framework - its
+  _Decision Matrix_ and _Anti-Patterns to Avoid_ tell you what *correct* wiring looks like. Resolve the
+  framework and pick the guide from the table in
+  [`../transpose-design-patterns/SKILL.md`](../transpose-design-patterns/SKILL.md). No guide for the stack:
+  judge on the catalog alone.
+- **Detection layer (this skill):** [`references/smell-signatures.md`](references/smell-signatures.md) - per
+  pattern, how a violation *looks in code*, the steelman that might excuse it, and what confirms it as real.
+
+## Audit procedure
+
+Run every step. The discipline is in steps 3 and 5 - do not skip from "I spotted something" to "here are my
+findings".
+
+1. **Frame the audit.** Open your window first: `ai-engineering-gate begin --dimension design-patterns` freezes
+   the state your verdict will bind to, captures who you are and refuses you outright if you are the builder of
+   this task. State that the standard is the catalog, not author intent. Fix the **scope** - a diff, a lib, the
+   whole codebase - and establish a diff with `git diff --stat <base>...HEAD` plus the working tree, **never
+   with `git log`**: commit subjects carry the author's intent. Resolve the **framework**. Note whether a
+   **design decision record** exists - its path comes from the brief; checking that the path exists is fine,
+   reading its content is not. If you authored the code in scope this session, dispatch to a fresh reviewer
+   now. _Done when:_ the window is open and scope, framework, record presence and independence stance are
+   explicit.
+
+2. **Inventory the pattern-shaped sites.** Find every site with a pattern-shaped decision - interchangeable
+   behavior, plugin/extensibility, object-creation logic, a DTO/domain boundary, shared state, a composable
+   action, a cross-cutting concern. Locate them by search, never by eyeballing: a small scope is read file by
+   file, in full; a large one starts from the repo's dependency graph when it has one (Nx graph, graphify,
+   Deptrac layers in PHP) and greps the signature shapes - a `switch`/`if` on a tag, `constructor.name`,
+   `instanceof`, `extends`/`abstract`, module-level `let`, `*Dto` or snake_case fields in UI code,
+   `as SomeDto` casts, `Map`/`Record`/`satisfies` tables - then reads each hit in context. For a not-yet-built
+   design proposal, sites come from the design doc instead of code, and "location" in the report below
+   becomes the doc section. _Done when:_ every site in scope is listed - exhaustive, not a sample.
+
+3. **Re-derive blind and freeze the matrix.** For each site write one row in your report, under _Frozen
+   matrix_: the site, the structural forces present (catalog _Structural forces_, extension-cost test
+   applied), the expected pattern or `none`, the expected transposition (the guide section; for `none`, the
+   catalog's `None` _Best practices_), and the expected invariants (the catalog entry's _Invariants_, made
+   concrete). Derive from the code, the catalog and the guide only - **before** reading the record, comments,
+   commit messages or rationale. Then freeze it: the matrix is the reference for every later step and is
+   never edited. _Done when:_ every site has its row and the record is still unopened.
+
+4. **Open the record and confront three ways.** Now read the design decision record when there is one. For
+   each site compare **expected** (your row) against **recorded** (the author's decision, or `not covered`
+   when the record does not address the site) against **actual** (the code), and label it `match` or
+   `candidate finding`. A candidate is: a wrong pattern; a missing pattern (a pattern-shaped need solved ad
+   hoc); a wrong `none` (a force present, or the extension-cost test failing); an **Avoid**-clause
+   anti-pattern; a mis-transposition (right pattern, wrong framework wiring); a misplaced artifact (a Command
+   folded into a store, a DTO leaking into a template); a recorded invariant not observable in the code; a
+   recorded `extensionCost` your own count contradicts. Two shapes matter equally: a bad decision
+   implemented faithfully, and a good decision implemented wrong. Without a record, expected against actual
+   suffices. _Done when:_ every site is labeled.
+
+5. **Steelman gate.** This is what makes the review challenging instead of noisy. For each candidate, build
+   the **strongest** defense of the current code - YAGNI over ceremony, deliberate simplicity, a sanctioned
+   framework idiom, a closed set that never grows. Then test it: does a catalog rule still get violated, and
+   does it still matter? _Done when:_ every candidate is either **dropped** (the steelman held → move it to
+   the "Challenged, survived" list) or **confirmed** with a written refutation of its steelman.
+
+6. **Verdict.** Emit the report (format below). _Done when:_ every confirmed finding carries location,
+   quoted rule, steelman + refutation, severity, and a fix; catalog gaps are listed apart; and the audit
+   ends on one overall verdict.
+
+## Severity
+
+The [contract](../transpose-design-patterns/references/suite-contract.md) owns Blocker, Major and Minor.
+Apply that clause. Tie the chosen tier to impact, not to how clever the finding is. A catalog gap has
+no severity: it is not a finding (see _Catalog gaps_).
+
+Each finding is also typed. A **judgment** finding says a recorded decision is wrong against the catalog and
+carries the `correction` to make. An **evidence** finding says an artifact the record planned is not on file
+and carries a `remedy` the builder can execute - `produce` the artifact, or `rerun` the check that proves it.
+A finding a builder believes wrong is disputed, never argued in prose: the builder files
+`dispute --dimension design-patterns` with counter-evidence, and only the user arbitrates it.
+
+## Verdict
+
+- **SOUND** - zero confirmed findings. The only verdict that completes a `transpose-design-patterns` task.
+- **SMELLS** - confirmed findings, none of them a blocker.
+- **VIOLATIONS** - at least one blocker.
+
+Open the window before the audit and file through it afterwards, so the verdict binds to the state you read:
+
+```bash
+ai-engineering-gate begin --dimension design-patterns          # prints the three fingerprints you bind to
+ai-engineering-gate attest --dimension design-patterns --stdin  # SOUND only
+ai-engineering-gate report --dimension design-patterns --stdin  # SMELLS and VIOLATIONS
+```
+
+Both read a [review envelope](../transpose-design-patterns/references/review-envelope.schema.json) on stdin:
+the verdict, the records examined, the checks you saw executed, your independence claim and every finding with
+its type, severity and remedy or correction. Never put a fingerprint in it - the gate computes all three and
+accepts none - and never file for a dimension you were not dispatched for. If the state moved while you were
+reading, `attest` refuses with `state-moved` and the review is void: say so and stop rather than filing on
+code you did not read. `SMELLS` and `VIOLATIONS` are reported, never attested: the builder corrects, then a
+fresh reviewer reassesses. An implementer never attests its own code, and the gate refuses it by identity.
+
+## Catalog gaps
+
+"No rule, no finding" stays. But a credible structural smell the catalog does not cover is not discarded
+silently: list it under **Catalog gaps** with the location, the smell, why the current catalog does not cover
+it, and the candidate rule or pattern family for a human to consider. A catalog gap never changes the
+verdict and never carries a severity - it feeds the catalog, it does not let the reviewer invent a rule.
+
+## Report format
+
+```
+## Design-pattern audit - <scope>
+
+**Verdict:** <SOUND | SMELLS | VIOLATIONS> - <n> findings (<x> blocker, <y> major, <z> minor)
+**Compared against record:** <path> | none
+
+### Frozen matrix
+| Site | Forces | Expected | Expected transposition | Expected invariants |
+| --- | --- | --- | --- | --- |
+| `path:line` <what it does> | ... | <pattern | none> | <guide section> | ... |
+
+### Findings
+#### [SEVERITY] <title> - `path/to/file.ts:line`
+- **Site:** what the code does (the evidence)
+- **Expected / recorded / actual:** <your frozen row> / <the author's decision | not covered> / <what the code does>
+- **Rule:** <catalog Avoid clause, Invariant, Core Principle, or guide anti-pattern, quoted verbatim>
+- **Steelman:** the strongest case for the current code
+- **Why it fails:** why that defense does not hold here
+- **Fix:** need → pattern → <framework guide section to follow>
+
+### Challenged, survived
+- `path:line` - considered <pattern>; current choice stands because <the steelman that held>
+
+### Catalog gaps
+- `path:line` - <smell>; not covered because <reason>; candidate: <rule or pattern family>
+```
+
+The "Frozen matrix" section is the proof of the blind pass: it is written before the record is opened and is
+not edited afterwards. The "Challenged, survived" section is not optional padding - it is the proof the audit
+was independent and balanced rather than a hit job. An audit that finds nothing is a valid outcome **only**
+when both sections show you re-derived and steelmanned each site.
+
+## Hard rules
+
+- **Independence is non-negotiable.** Never cite the author's stated intent as evidence the design is right.
+- **Freeze before you compare.** The expected design is written before the record is opened, and never
+  revised afterwards.
+- **No rule, no finding.** Every finding quotes a specific catalog **Avoid** clause, **Invariant** or
+  **Core Principle**, or a guide anti-pattern. A preference with no rule behind it is taste - drop it; a
+  credible smell with no rule goes to _Catalog gaps_, not to _Findings_.
+- **No steelman survived, no finding.** If the strongest defense of the code holds, it is not a finding.
+- **Never invent rules** absent from the catalog or the framework guide.
+- **Findings are framework-checked.** Judge the transposition against the project's `transpose-<framework>.md`,
+  not against another framework's idioms.
+- **Never modify code in scope.** The review's output is judgment; the fix belongs to the author, and a fresh
+  review follows it.

package/skills/engineering/review-design-patterns/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Review Design Patterns"
+  short_description: "Independent audit of design-pattern decisions"

package/skills/engineering/review-design-patterns/references/smell-signatures.md

@@ -0,0 +1,117 @@
+# Smell Signatures - design-pattern violations, with their steelman
+
+The detection layer for `review-design-patterns`. For each catalog pattern: **how a violation looks in code**,
+the **steelman** that might legitimately excuse it, and what **confirms** it as a real finding once the
+steelman fails. The *rules* live in the shared catalog and the per-framework guide - this file does not restate
+them, it tells you how to spot and pressure-test a breach.
+
+- Rule source: [`../../transpose-design-patterns/references/pattern-catalog.md`](../../transpose-design-patterns/references/pattern-catalog.md) (_Avoid_ clauses, _Core Principles_).
+- Correct wiring: the project's `transpose-<framework>.md` (_Decision Matrix_, _Anti-Patterns to Avoid_).
+
+A finding is only real when the **signature** is present **and** the **steelman** does not hold. Default to
+*not a finding* when in doubt - an over-eager audit is as useless as a blind one.
+
+This file is the **negative** checklist. The **positive** one is the catalog's _Invariants_ line per pattern:
+an invariant the recorded pattern promises and the code does not show is a candidate finding even when no
+signature below matches.
+
+---
+
+## Strategy
+
+- **Catalog → Strategy → Avoid:** `switch`/`case` on a type tag; `constructor.name` lookups; string magic; giant strategy classes.
+- **Signature:** a `switch (type)` or `if (kind === '…')` chain that selects *behavior*; one class with a method per variant; a behavior chosen by reading `constructor.name` or a magic string.
+- **Steelman:** exactly two variants that demonstrably never grow, no external/plugin variants → a small inline branch can beat Strategy ceremony (YAGNI). A `{ … } as const satisfies Record<K, Strategy>` lookup table is the *correct* idiom - not a smell.
+- **Confirm when:** adding a variant means editing the switch; the switch is duplicated at more than one call site; variants come from plugins/config/runtime; the branch decides domain behavior, not a trivial display string.
+- **Framework:** Vanilla TS expects an `as const satisfies Record<K, Strategy>` lookup map (transpose-vanilla → Strategy); a `switch` on a tag as the extension mechanism is a **blocker**. Angular expects `InjectionToken` + `multi` providers resolved by key (transpose-angular → Strategy). A behavior-selecting `switch` inside a component is a **blocker**. For React, Vue and Quarkus, the guide's _Anti-Patterns to Avoid_ names the tag-dispatch smell: cite it. PHP expects `#[AutoconfigureTag]` on the interface + `#[AutowireIterator]` + `supports()`, or a backed enum + exhaustive `match` for a closed set (transpose-php → Strategy): a `switch` on a string tag in a service or controller is a **blocker**; a `match` over an enum with no `default` is the correct idiom, not a smell.
+
+## Registry
+
+- **Catalog → Registry → Avoid:** hand-maintained enums for external plugins; the service-locator anti-pattern.
+- **Signature:** a central `switch`/object literal edited by hand every time a plugin is added; an enum of plugin keys kept in sync manually; a global "get me anything by string" locator.
+- **Steelman:** the set of entries is compile-time-known and closed (e.g. two app-owned exporters) → a typed `satisfies Record<K, T>` table is fine and is *not* the service-locator smell; when that table is the whole realization, the catalog names it Strategy, not Registry (catalog _Strategy or Registry_). Registration centralized in one composition-root module is acceptable.
+- **Confirm when:** entries are external/dynamic yet enumerated by hand; adding a plugin forces edits in unrelated modules; lookups are untyped string fetches scattered across the code (service locator).
+- **Framework:** Angular = DI lookup over `multi` providers *is* the registry (transpose-angular → Registry). PHP = `#[AutowireLocator]` / indexed `#[AutowireIterator]` over one tag (transpose-php → Registry); a locator scoped to one tag is *not* the service-locator smell. Broad application-container or static-facade access is a candidate finding; steelman a confined legacy bridge using the guide's interface binding, visibility and caller-level substitution test.
+
+## Factory
+
+- **Catalog → Factory → Avoid:** factories with no creation logic; giant conditional factories.
+- **Signature:** a `createX()` that only calls `new X()` with no decisions (ceremony); a factory with a sprawling conditional building many unrelated types.
+- **Steelman:** the factory isolates *real* creation complexity (env-dependent wiring, async setup, returning an abstraction) → keep it. A `useFactory` that picks an implementation by environment is correct, not a giant-conditional smell.
+- **Confirm when:** the factory adds an indirection layer over a plain constructor with zero logic (delete it), or it has become a god-factory branching over many product types (split it).
+
+## Command
+
+- **Catalog → Command → Avoid:** burying a reusable command inside a store/facade method; mixing the action with UI-state, persistence, or presentation. **"A store action is _not automatically_ the Command."**
+- **Signature:** a store/facade method (`withMethods`, Zustand/Pinia action, closure-store method) that performs a side-effecting action which is - or should be - reused, composed, or unit-tested in isolation, yet lives only inside the store and drags state flags + IO + mapping together.
+- **Steelman:** a genuine one-off with no reuse or isolated-test pressure → inlining it in the store is correct (YAGNI); extracting a use-case would be premature. The store legitimately owns the *surrounding* state (status flags, journal, reset) and may **delegate** to a use-case - delegation is the right shape, not a smell.
+- **Confirm when:** the action is called from (or clearly needs) more than one place; it can't be unit-tested without standing up the whole store; domain logic is fused with persistence/presentation inside the method. Fix: extract a distinct injectable use-case / exported function the store delegates to (catalog → Command for the layering).
+- **Framework:** PHP: the action lives in a controller action, a repository method or an ORM model method (transpose-php → Command); the fix is a `readonly` command + invokable handler the caller delegates to.
+
+## Adapter / DTO Mapping
+
+- **Catalog → Adapter → Avoid:** DTOs leaking into the UI; framework-dependent mappers.
+- **Signature:** snake_case / raw API fields, `created_at`, untyped JSON, or `*Dto` types referenced inside components/templates; mapping logic that depends on the framework; mapping done in the component instead of at the data-access boundary.
+- **Steelman:** DTO and domain shapes are genuinely identical for this resource → a pass-through with no mapper is acceptable (don't manufacture a `fromDto` that copies fields 1:1). A typed response used only inside the service is fine.
+- **Confirm when:** raw DTO shapes reach a template or view-model; mapping lives in a component; the mapper imports framework symbols. Fix: pure `from`/`to` functions at the service boundary (catalog → Adapter; framework guide → Adapter).
+- **Framework:** PHP: an entity or ORM model serialized directly (`$this->json($entity)`, `$model->toArray()`) or reaching a Twig template (transpose-php → Adapter); the fix is a `final readonly` DTO with a static `from*` constructor.
+
+## Composition
+
+- **Catalog → Composition → Avoid:** inheritance chains; tightly coupled modules.
+- **Signature:** an `abstract` base class extended for behavior reuse; deep `extends` hierarchies; modules reaching into each other's internals instead of depending on an injected abstraction.
+- **Steelman:** a shallow framework-mandated base class (e.g. a required lifecycle superclass) is not the inheritance smell. A short, stable, single-purpose base may be simpler than composition - judge by change pressure.
+- **Confirm when:** behavior is shared via inheritance that composition (DI, functions, host directives) would model with less coupling; the hierarchy is more than one level deep; subclasses override to specialize behavior that should be injected.
+
+## Singleton / shared state
+
+- **Catalog → Singleton → Avoid:** global mutable state; hidden shared state.
+- **Signature:** module-level `let` mutated across the app; a service exposing a writable signal / the whole store object; shared state mutated through paths the type system doesn't guard. PHP: `static` properties, `$GLOBALS`, a stateful service without `ResetInterface` (invisible under PHP-FPM, a cross-request leak under a worker runtime).
+- **Steelman:** a root-provided service with private state and a **readonly/computed** public surface is the *correct* shape, not a smell. Minimal, explicitly-shared app state is fine. In PHP, stateless services are fine; a memo requires evidence that its lifetime matches the unit of work. `ResetInterface` alone does not prove reset between iterations of a multi-tenant loop. A cache owned per iteration or an explicit reset on every boundary can satisfy the guide.
+- **Confirm when:** state is module-global and mutable; writable signals or the raw store are exposed; consumers mutate shared state directly. Fix: keep state private, expose readonly/computed (framework guide → Singleton / shared state).
+
+## None - no named pattern
+
+- **Catalog → None → Avoid:** `none` chosen while a force is present; an "exhaustive" branch duplicated at several call sites; a closed set fed from config, plugins or runtime.
+- **Signature:** a recorded `none` (or an inline branch with no record) over a variant set that has grown since, is duplicated at more than one call site, or receives variants from outside the code. An inline branch whose record names a pattern is the other shape - a pattern decided and not realized - and is judged under that pattern's _Avoid_ and _Invariants_, not here.
+- **Steelman:** the set is closed by declaration (sealed type, discriminated union, backed enum), the compiler or analyzer enforces exhaustiveness, one call site, no external variants → `none` is correct and the branch is the idiom, not a smell.
+- **Confirm when:** the extension-cost test fails (one more variant edits orchestration code, or edits it in more than one place), or variants come from plugins/config/runtime. Fix: the pattern the forces point at - usually Strategy or Registry.
+
+---
+
+## Cross-cutting (catalog Core Principles + guide anti-patterns)
+
+These are not single patterns but principles the catalog enforces everywhere. Same gate: signature present **and** steelman fails.
+
+- **Domain purity** - presentation (view-models, design tokens, display labels, locale formatting) or
+  infrastructure (URLs, HTTP, runtime config) living in the domain layer. *Steelman:* a type that merely
+  *looks* domain-ish but is correctly placed in its own layer is fine. *Confirm when:* the domain layer
+  imports framework/HTTP/CSS or holds display strings.
+- **ISP - split ports by concern** - one interface bundling a domain rule + an IO/output port + UI-copy
+  strings. *Steelman:* a cohesive interface whose members are one concern is fine. *Confirm when:* a single
+  port forces implementers to satisfy unrelated concerns.
+- **Immutability** - object mutation / hidden side effects where `readonly` + immutable updates belong.
+  *Steelman:* a local mutable accumulator inside a pure function is fine. *Confirm when:* shared/returned
+  state is mutated in place.
+- **Explicitness over magic** - magic strings, implicit effects, dynamic behavior without a contract.
+  *Confirm when:* behavior keys are untyped strings, or effects fire from hidden global state.
+- **Derived-value ownership** - a read-only derived field persists through an alternate write path,
+  or a memo key omits a fallback dependency. *Steelman:* materialized values have an explicit refresh
+  contract; intentional negative caches define scope and invalidation. *Confirm when:* changing the
+  omitted input returns stale data, or a raw stored record contains a field the read model alone owns.
+- **Replacement-set ownership** - callers duplicate builders for the same replace-all context and
+  supply different keys. *Steelman:* the callers represent distinct contexts with different contracts.
+  *Confirm when:* an alternate caller silently drops a required attribute or header.
+- **PHP scoped reads** - a fallback hides a row filtered out by the active tenant, or an opt-out lacks
+  target authorization or scope restoration. *Steelman:* the read is intentionally scoped, or an
+  authorized cross-scope operation restores the prior filter state. *Confirm when:* an out-of-scope
+  fixture or a subsequent scoped read demonstrates the wrong result. Use the PHP guide's boundary tests.
+- **PHP test and docblock integrity** - a declaration separates a method from its docblock, or a test
+  repeats the production derivation. *Steelman:* input-field assertions can test a real mapping;
+  container/persistence integration tests need their runtime. *Confirm when:* the docblock attaches to
+  the wrong element or a targeted behavioral mutation survives the test.
+- **Framework-specific anti-patterns** - business logic in components/templates/effects, `BehaviorSubject`
+  stores for UI state, `@HostListener`/`@HostBinding` in new Angular code, calling `HttpClient` from a
+  component; in PHP, business logic in controllers / ORM models / Twig, `new \DateTime()` inside a service, a
+  file without `declare(strict_types=1)`. These are owned by the project's `transpose-<framework>.md` _Anti-Patterns to Avoid_ - cite that
+  list verbatim; do not re-derive it here.

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

@@ -0,0 +1,25 @@
+name: review-design-patterns
+type: skill
+tools:
+  - claude-code
+  - cursor
+  - github-copilot
+description: "Independently audit design-pattern decisions against a shared catalog - re-derive each site blind and freeze the expected design, compare it with the recorded decision and the code, then put every finding through a steelman gate - so it ships confirmed or flagged with evidence, with catalog gaps reported apart. Use when reviewing code, a diff, or a PR for pattern soundness and anti-patterns, or when challenging a not-yet-built design. Companion to transpose-design-patterns."
+label: "Review 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/review-design-patterns"
+version: "1.2.0"
+icon: "https://img.icons8.com/color/48/code-review.png"
+tags:
+  - software-engineering
+  - code-review
+  - audit
+  - architecture
+  - quality-gate
+content: SKILL.md
+installPaths:
+  claude-code: .claude/skills/review-design-patterns/SKILL.md
+  cursor: .cursor/skills/review-design-patterns/SKILL.md
+  github-copilot: .github/instructions/review-design-patterns.instructions.md

package/skills/engineering/review-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/review-modern-typescript/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: review-modern-typescript
+description: "Independently audit TS/JS idioms, types, collections, generators, lifetime and native platform choices. Detect verbose legacy idioms, redundant helpers, missed native capabilities, unsafe type claims and incompatible modernization; freeze expectations blind, compare decisions and code, then steelman findings. Use for a diff, existing module, proposal or fresh transpose-modern-typescript handoff. Read-only companion to transpose-modern-typescript. Excludes prose-only and formatting-only edits."
+license: MIT
+metadata:
+  author: Guillaume Mongin (@hellraisercenobit)
+---
+
+# Review modern TypeScript
+
+Run the audit yourself. Edit no files and delegate no review. The transpose companion owns
+all normative rules. These [smell signatures](references/smell-signatures.md) are detection
+leads, never standalone rules or findings.
+
+## Prerequisites
+
+Resolve the installed /transpose-modern-typescript through the harness skill locations.
+Read its `references/suite-contract.md`, `catalog.md`, `compatibility.md` and
+`decision-record.schema.json`, then applicable families only. This reviewer requires
+contract 1.1.0, catalog 1.1.0 and record schema 2.0.0. Missing or conflicting references
+mean incomplete execution, without verdict. Do not download substitutes, reconstruct rules
+from memory or depend on the maintainer's checkout.
+
+For transposition, require a fresh context, neutral brief and accessible records. Check
+paths exist without opening contents. A contaminated brief requires a new neutral dispatch
+before completion. A standalone audit needs no historical record.
+
+Open the window before step 1: `ai-engineering-gate begin --dimension modern-typescript` freezes
+the state the verdict binds to, captures who you are and refuses the builder of the task.
+
+## Blind audit, then comparison
+
+1. **Facts.** Establish scope with git diff against the stated base, staged/unstaged changes
+   and relevant untracked files. Never git log, PR rationale or author analysis. State
+   standalone/proposal mode when applicable. Derive compiler/types/build/runtime/browser
+   profile independently. A missing required compiler profile is incomplete execution, not
+   SOUND. Identify dirty and untracked contents as well as HEAD. Report significant author
+   justification encountered in source; do not use it to choose outcomes.
+2. **Inventory.** Walk catalog axes at every site, including retained choices. Use signatures
+   to locate repeated guards, helpers, lookups, retention, eager work and manual platform
+   mechanisms. Read context; a search hit is not evidence.
+3. **Freeze.** Emit the immutable expected matrix in your response **before opening any
+   record**: site, constraints, rule IDs, acceptable alternatives, support prerequisites
+   and invariants. Support prerequisites name the four MT-23 layers: parser/compiler
+   syntax (installed TypeScript version + target), lib/types, emit/bundler, actual runtime.
+   A missing required layer is incomplete execution. Include sites needing no specialized
+   choice. Freeze acceptable outcomes, not exact syntax. Changed verified premises require
+   reframing and a fresh reviewer, retaining the old matrix.
+4. **Compare.** Now open records and check evidence. Check schema, catalog membership,
+   profiles, alternatives, revisions and invariants. Compare expected / recorded / actual
+   at every site. Independently verify support claims. A recorded or actual idiom that fails
+   any MT-23 layer is a finding even if the builder omitted MT-23 from the record. Steelman
+   still allows retaining compatible code. A reassuring record is not proof. A proposal
+   review judges intended artifacts, not a runtime implementation.
+5. **Steelman.** Defend each candidate using concrete compatibility, public contract, domain
+   behavior, framework effects, workload or simplicity. Drop it if the defense holds.
+   Otherwise cite exact rule and evidence, refute the defense and propose a scoped fix.
+   Demonstrated simplification can be Minor; age, missing fashionable syntax or taste
+   cannot. No applicable rule means a catalog gap without severity or verdict impact.
+   Apply the contract's severity clause for Blocker, Major and Minor; do not restate it.
+6. **Report.** File through the window you opened, never beside it. Pipe a
+   [review envelope](../transpose-modern-typescript/references/review-envelope.schema.json) to
+   `ai-engineering-gate attest --dimension modern-typescript --stdin` for SOUND, and to
+   `ai-engineering-gate report --dimension modern-typescript --stdin` otherwise. Type each finding:
+   `judgment` carries the correction, `evidence` carries a remedy the builder can execute.
+   Put no fingerprint in the envelope - the gate computes all three and accepts none. A refusal
+   of `state-moved` means the code moved while you read it: the review is void, say so and stop.
+   Edit neither code, records, fixtures nor catalogs; filing the envelope is the only exception.
+   The builder corrects or disputes; a fresh reviewer reassesses.
+
+## Report
+
+- Scope/base/examined state, profile and reference versions/hashes.
+- Coverage and the previously emitted frozen matrix, unchanged.
+- Every site's expected / recorded (or absent in standalone mode) / actual comparison.
+- Confirmed findings: severity, location, rule, evidence, comparison, impact, strongest
+  defense, refutation and correction.
+- Defended choices, rejected candidates, separate catalog gaps, check evidence and limits.
+- One verdict: SOUND (complete, zero findings), SMELLS (findings, no Blocker), or VIOLATIONS
+  (a Blocker). Missing prerequisites or a missing compiler profile are incomplete execution,
+  not a fourth quality verdict. Skipped MT-23 still yields a finding when actual exceeds the
+  profile.
+
+SOUND expires on audited file or pinned reference changes: the gate recomputes the source,
+reference and decision fingerprints and reports `stale-source`, `stale-reference` or
+`stale-decision` rather than keeping a verdict alive. Portable evidence is not an automatic
+gate lock. Completion needs every applicable dimension on the same final state, passing checks
+and resolved disputes; `ai-engineering-gate can-stop` is what answers that question.

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

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Review Modern TypeScript"
+  short_description: "Independently audit TS/JS idioms and native APIs"

package/skills/engineering/review-modern-typescript/references/smell-signatures.md

@@ -0,0 +1,36 @@
+# Detection leads
+
+Resolve each rule in the transpose companion and steelman the choice. This table is not a
+second catalog. Search results require contextual inspection.
+
+| Lead | Rules | Defense to try |
+| --- | --- | --- |
+| Repeated extractions, verbose object reconstruction | MT-01 | Getters, read timing, reactive tracking, receiver binding, provenance |
+| Null-only ternary, falsy default, repeated initialization | MT-02, MT-03 | Intentional falsy semantics, mutation forbidden, setter effects |
+| Nested optional arrays, indices, items and calls | MT-04 | Required values must fail; callable/type checks still needed |
+| Manual grouping/search, transparent helper | MT-05, MT-19 | Domain meaning, public contract, prototype/order/hole differences |
+| Repeated scans, string-coerced dictionary keys | MT-06 | Small one-shot data, index cost, duplicate policy, serialization |
+| Object metadata retained globally, unbounded cache | MT-07 | Enumeration, deterministic cleanup, other strong references |
+| Eager sequence only partly consumed | MT-08 | Replay/random access, small data, error timing |
+| Manual resolvers, races without cancellation | MT-09 | Structured async, bounded concurrency, cancellation propagation |
+| Full fetch buffering, polling streams | MT-10 | Atomic payload, replay/retry contract, support |
+| Manual URL/locale parsing or formatting | MT-11 | Domain grammar, security allowlist, locale differences |
+| JSON clone, binary copies, repeated message data | MT-12 | Custom serialization, noncloneable types, transfer ownership |
+| DOM polling, global listeners, repeated layout work | MT-13 | Framework ownership, notifications, timing, accessibility |
+| Sync yield claimed to give UI time | MT-14 | Worker startup/transfer exceeds work; supported task slicing |
+| Ad hoc persistence/coordination/random IDs | MT-15, MT-16 | Consistency, quotas, threat model, secure context |
+| Identity helper or annotation erasing inference | MT-17 | Stable API, intentional widening, understandable diagnostics |
+| Flags creating impossible states | MT-18 | Independent facts, public representation, exhaustive branches |
+| External cast or dishonest predicate | MT-20 | Independently validated boundary with localized proof |
+| readonly claimed to freeze, type puzzles | MT-21 | Runtime freeze, useful derived contract, editor/compiler cost |
+| API or import justified only by TS lib | MT-22, MT-23 | Actual transpiler, loader, runtime and consumers |
+| Widened signature, dropped `readonly`, collapsed union or tuple, new caller-side casts | MT-24 | Simpler public type, boundary accepting unvalidated input, looser native declarations |
+| Single forwarding call, project alias for a global, wrapper added with the transposition it hides | MT-25 | Domain semantics, one-place compatibility policy, instrumentation, lifecycle the caller must not manage, migration boundary |
+
+Read data flow and lifetime too, not only old syntax. Useful loops, helpers, classes, enums
+and explicit branches can be SOUND.
+
+Two leads are not searchable and are read from the diff instead. MT-24 is found by comparing what
+the compiler knew at each touched signature before and after the change, so hover the symbol or
+compile a consumer rather than grepping. MT-25 is found by reading a helper's body: one forwarding
+call with the arguments unchanged is the shape, and the record must name the reason it survives.

package/skills/engineering/review-modern-typescript/review-modern-typescript.yaml

@@ -0,0 +1,22 @@
+name: review-modern-typescript
+type: skill
+tools:
+  - claude-code
+  - cursor
+  - github-copilot
+description: "Audit modern TS/JS decisions with a blind matrix and steelman gate."
+label: "Review Modern TypeScript"
+author: "Guillaume Mongin (@hellraisercenobit)"
+license: "MIT"
+copyright: "Copyright (c) 2026 Guillaume Mongin (@hellraisercenobit)"
+homepage: "https://github.com/hellraisercenobit/skills/tree/main/skills/engineering/review-modern-typescript"
+version: "1.0.0"
+tags:
+  - software-engineering
+  - typescript
+  - javascript
+content: SKILL.md
+installPaths:
+  claude-code: .claude/skills/review-modern-typescript/SKILL.md
+  cursor: .cursor/skills/review-modern-typescript/SKILL.md
+  github-copilot: .github/instructions/review-modern-typescript.instructions.md