@hellraisercenobit/ai-engineering-gate 0.8.0

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

@@ -0,0 +1,108 @@
+---
+name: review-testing-patterns
+description: "Independently audit test strategy, oracles, doubles, TypeScript guarantees and TDD evidence. Detect false green, implementation coupling and environment or execution gaps; freeze expectations before records, compare every site and steelman findings. Use for a diff, existing suite, proposal or fresh transpose-testing-patterns handoff. Read-only companion to transpose-testing-patterns."
+license: MIT
+metadata:
+  author: Guillaume Mongin (@hellraisercenobit)
+---
+
+# Review testing patterns
+
+Run this audit yourself. Modify no files, including fixtures, records and catalogs, and
+delegate no review. [Signatures](references/smell-signatures.md) locate candidates; they
+are not an independent rule catalog.
+
+## Prerequisites
+
+Resolve installed /transpose-testing-patterns through harness skill locations, without a
+maintainer checkout. Read its `references/suite-contract.md`, `catalog.md`,
+`decision-record.schema.json`, `journal-event.schema.json` and applicable guides. This
+reviewer requires contract 1.1.0, catalog 1.0.0, record schema 2.0.0 and the adapter for
+the detected family, compatible with 1.0.0. Apply `assessTestingProfile` from
+`references/compiler-profile.mjs`. Vitest loads
+`references/transpose-vitest.md`. Karma + jasmine-core + Angular TestBed loads
+`references/transpose-karma-jasmine-angular.md`. Codeception loads
+`references/transpose-codeception.md`. SOUND on Karma + Angular TestBed requires the
+adapter and a qualification pin under `tests/testing-patterns/karma-jasmine-angular/`;
+ChromeHeadless execution is optional. SOUND on Codeception requires that adapter and a
+qualification pin under `tests/testing-patterns/codeception/`; Docker execution of
+`codecept` is optional. Other runners still receive catalog recale, including compiler
+profile and wrong-runner APIs. SOUND for a qualified Vitest transposition still needs the
+Vitest adapter. Missing or conflicting references mean incomplete execution, without
+verdict; do not download substitutes or invent rules.
+
+A transposition requires a fresh context and neutral brief. Check record paths exist but
+do not open them before freezing. Contamination requires a new dispatch. Standalone audits
+need no historical decision record and must not manufacture a process claim.
+
+Open the window before step 1: `ai-engineering-gate begin --dimension testing-patterns` freezes
+the state the verdict binds to, captures who you are and refuses the builder of the task.
+
+## Blind audit and comparison
+
+1. **Facts.** Establish scope/base with git diff, reads and relevant untracked files, never
+   git log, PR descriptions or author analysis. Identify source/configuration/reference
+   state as well as HEAD. Derive runner, checker and compiler/runtime profile independently
+   from project files; do not copy the builder's record or trust constraints alone. When any
+   in-scope test is TypeScript or JavaScript emitted by tsc, the profile has four layers:
+   parser/compiler syntax (installed TypeScript version + target), lib/types, emit/runner
+   transform, and actual runtime. Constraints must contain the ES/compiler target; a
+   tsconfig path is not a substitute, and derived `compiler.target` is a second independent
+   layer. Apply `assessTestingProfile` to that derived profile and the actual syntax/APIs.
+2. **Derive.** Inventory behaviors and risks from the request and public contracts.
+   Builder-written names, assertions and helpers are not independent requirements. Defer
+   detailed assertion reading until freeze when possible; disclose significant exposure
+   to author rationale. Consider direct, state, interaction, contract, property and
+   characterization tests, including defensible existing choices.
+3. **Freeze.** Publish an immutable matrix in your response before the next tool call
+   opening records or builder evidence: site, behavior/risk, rule IDs, acceptable seams
+   and alternatives, runtime/type guarantees, the four compiler/runtime layers and
+   discriminating cases. Freeze acceptable outcomes, not exact syntax. An unknown required
+   layer is incomplete execution: leave it unresolved and do not issue SOUND. Changed
+   verified premises require a new framing/reviewer, preserving this matrix.
+4. **Compare.** Open records and evidence. Validate shape/membership separately from
+   semantic judgment. Compare expected / recorded / actual for every site, including
+   uncovered risks. Inspect actual assertions, production, helpers and configuration.
+   Verify scenario-to-executed-test mapping and skips/fails/retries, checker file coverage,
+   failure causes, oracle hashes, raw output and resolvable RED/GREEN states. Read the state
+   the journal derives rather than a process claim: `observed` when the builder's own events
+   carry the red, `replayed` when the gate ran the scenario itself, `incomplete` when a phase
+   or its failure class is missing, and `non-TDD` when the record never claimed the mode. A
+   missing red is an evidence finding whose remedy is a replay, not a judgment about intent.
+   Hashes alone are not inspectable evidence. A reassuring record or global green is not proof.
+   Recale syntax the installed compiler/`target` cannot parse, APIs not in `lib` and not proven
+   on the runtime, and runner APIs from a different adapter family (for example `vi.fn` on
+   karma-jasmine-angular). Incompatible modernization is a finding (MT-23), not taste. A
+   constraints versus derived target mismatch is a finding. Tests-only work with
+   `modern-typescript` non-applicable still recales too-modern spec TypeScript here.
+5. **Steelman.** Defend every candidate by contract, fidelity, compatibility, diagnostic
+   value, cost or simplicity. Drop it if that defense holds. Confirm only with an exact
+   applicable rule, observed evidence, impact and refutation. Report catalog gaps
+   separately without severity or verdict impact. Missing old TDD history is not a bug;
+   missing required evidence prevents completing a claimed TDD transposition.
+6. **Report.** Give scope/base/state, references/profile, coverage, unchanged matrix,
+   each site's comparison, findings, defended choices, gaps, checks and limits. Each
+   finding includes location, rule, severity, expected/recorded/actual, evidence, strongest
+   defense, refutation and scoped correction. Builder performs mutations/experiments and
+   fixes; a new fresh reviewer reassesses.
+
+## Completion
+
+Use exactly SOUND (complete audit, no findings), SMELLS (findings without Blocker), or
+VIOLATIONS (a Blocker). Apply the contract's severity clause for Blocker, Major and Minor;
+do not restate it. Missing prerequisites or an unknown required compiler/runtime layer are
+incomplete execution, not a fourth verdict. Findings from `assessTestingProfile` prevent
+SOUND. A proposal verdict does not qualify runtime behavior.
+
+File through the window you opened. Pipe a
+[review envelope](../transpose-testing-patterns/references/review-envelope.schema.json) to
+`ai-engineering-gate attest --dimension testing-patterns --stdin` for SOUND, and to
+`ai-engineering-gate report --dimension testing-patterns --stdin` otherwise. Filing the envelope is the sole
+permitted external mutation. Type each finding: `judgment` carries the correction, `evidence`
+carries a remedy - `produce` an artifact, `rerun` a check, or `replay` a scenario the gate
+runs itself. Put no fingerprint in the envelope; the gate computes all three. A refusal of
+`state-moved` means the suite or the production code moved while you read it, so the review is
+void: say so and stop. Portable reports have no automatic lock. Covered source, record or
+reference changes expire the report, which the gate reports as `stale-source`,
+`stale-reference` or `stale-decision`; `can-stop` is what answers whether every applicable
+dimension and check agrees on one final state.

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

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Review Testing Patterns"
+  short_description: "Independently audit tests and TDD evidence"
+  default_prompt: "Use $review-testing-patterns to audit this test strategy independently."

package/skills/engineering/review-testing-patterns/references/compiler-profile.mjs

@@ -0,0 +1,103 @@
+const INCOMPATIBLE_MODERNIZATION = { id: 'incompatible-modernization', rule: 'TP-12' };
+const TARGET_MISMATCH = { id: 'target-mismatch', rule: 'TP-16' };
+const WRONG_RUNNER_API = { id: 'wrong-runner-api', rule: 'TP-14' };
+
+export function assessTestingProfile(input) {
+  if (needsCompilerProfile(input) && !hasResolvedProfile(input)) {
+    return { status: 'incomplete', findings: [] };
+  }
+  const findings = [];
+  if (declaredTargetMismatchesDerived(input)) {
+    findings.push(TARGET_MISMATCH);
+  }
+  if (syntaxExceedsCompiler(input)) {
+    findings.push(INCOMPATIBLE_MODERNIZATION);
+  }
+  if (usesWrongRunnerApi(input)) {
+    findings.push(WRONG_RUNNER_API);
+  }
+  return { status: 'complete', findings };
+}
+
+function needsCompilerProfile(input) {
+  return input.language === 'typescript' || input.emittedByTsc === true;
+}
+
+function hasResolvedProfile(input) {
+  return hasEsTarget(input)
+    && knownLayer(input.compiler?.version)
+    && hasLibLayer(input)
+    && knownLayer(input.emit)
+    && knownLayer(input.runtime);
+}
+
+function hasEsTarget(input) {
+  return Boolean(input.compiler?.target) && constraintHasTarget(input.constraints);
+}
+
+function hasLibLayer(input) {
+  return Array.isArray(input.compiler?.lib) && input.compiler.lib.length > 0;
+}
+
+function knownLayer(value) {
+  return Boolean(value) && String(value).toLowerCase() !== 'unknown';
+}
+
+function declaredTargetMismatchesDerived(input) {
+  const declared = constraintEsTarget(input.constraints);
+  const derived = normalizeEsTarget(input.compiler?.target);
+  return Boolean(declared && derived && declared !== derived);
+}
+
+function syntaxExceedsCompiler(input) {
+  const version = typescriptVersion(input.compiler?.version);
+  if (version === undefined) {
+    return false;
+  }
+  const syntax = input.actual?.syntax ?? [];
+  if (syntax.includes('satisfies') && version < 4.9) {
+    return true;
+  }
+  if (syntax.includes('using') && version < 5.2) {
+    return true;
+  }
+  return false;
+}
+
+function usesWrongRunnerApi(input) {
+  if (!input.adapterFamily) {
+    return false;
+  }
+  const usesVitestApi = input.actual?.apis?.includes('vi.fn');
+  return Boolean(usesVitestApi) && !input.adapterFamily.includes('vitest');
+}
+
+function constraintHasTarget(constraints = []) {
+  return Boolean(constraintEsTarget(constraints));
+}
+
+function constraintEsTarget(constraints = []) {
+  for (const item of constraints) {
+    const match = item.match(/\btarget\s+(ES\d+)/i);
+    if (match) {
+      return normalizeEsTarget(match[1]);
+    }
+  }
+  return undefined;
+}
+
+function normalizeEsTarget(value) {
+  if (!value) {
+    return undefined;
+  }
+  const match = String(value).match(/ES\d+/i);
+  return match ? match[0].toUpperCase() : undefined;
+}
+
+function typescriptVersion(value) {
+  const match = String(value ?? '').match(/(\d+)\.(\d+)/);
+  if (!match) {
+    return undefined;
+  }
+  return Number(match[1]) + Number(match[2]) / 10;
+}

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

@@ -0,0 +1,30 @@
+# Detection leads
+
+These are search leads, not normative rules. Read the transpose-owned rule and context,
+then steelman before confirming. Do not count words, mocks, classes or lines as defects.
+
+| Candidate | Rule | Strongest plausible defense to examine |
+| --- | --- | --- |
+| Expected result repeats production algorithm | TP-01/05/15 | Independent specification or simpler model |
+| Test reads private representation or seeds invalid state | TP-02/09/11 | Legitimate public read model or unknown boundary |
+| Only verifies a business object's method was called | TP-03/08/10 | Interaction itself is an external protocol |
+| Fake owns policy; only fake is exercised | TP-04/08 | Tooling test labelled honestly, product policy tested elsewhere |
+| Fake/real shared tests never execute real adapter | TP-04/14 | No substitutability claim, limited stub role |
+| Builder/mother hides the decisive input | TP-09/15 | Named reusable business case remains explicit |
+| Every collaborator mocked or every resource real | TP-08/10 | Specific diagnostic/fidelity requirement |
+| New getter/port exists only for assertion | TP-11 | Real unstable boundary or supported library consumer |
+| Cast makes malformed data appear valid | TP-12 | Validated boundary with an explicit narrowing proof |
+| Runtime green offered as type proof | TP-12/16 | Separate checker covers files and consumer contracts |
+| Message-only error check accepts wrong error | TP-15 | Message is the whole public error contract |
+| Promise assertion is unawaited; catch can skip assertions | TP-13/15 | Runner actually awaits returned operation |
+| Concurrency test never forces overlap | TP-13 | Claim is eventual result, not exclusion |
+| Generator cleanup/abort only tested on success | TP-13/16 | Contract has no ownership of that resource |
+| Browser/provider claim backed by DOM/network simulation | TP-14 | Guarantee is within simulation fidelity |
+| RED is import failure or changed oracle | TP-07 | Labelled setup or restarted cycle with preserved observations |
+| TDD inferred from final files or commit messages | TP-07 | Retrospective quality audit with no chronology claim |
+| Green run has missing required scenarios, skips or retries | TP-16 | Explicit non-required limitation, not claimed proof |
+| Spec uses syntax the frozen compiler cannot parse (`satisfies`, `using`) | TP-12 | Compiler version actually supports that syntax |
+| Spec uses a runner API from a different adapter (`vi.fn` on Karma/Jasmine) | TP-14 | Detected adapter family actually owns that API |
+
+An experiment must preserve the audited tree. Ask the builder to run a scoped isolated
+probe when evidence is unavailable. Do not inject a defect or rewrite a test yourself.

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

@@ -0,0 +1,23 @@
+name: review-testing-patterns
+type: skill
+tools:
+  - claude-code
+  - cursor
+  - github-copilot
+description: "Audit testing decisions and TDD evidence with a blind matrix and steelman gate."
+label: "Review Testing 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-testing-patterns"
+version: "1.0.0"
+tags:
+  - software-engineering
+  - typescript
+  - testing
+  - vitest
+content: SKILL.md
+installPaths:
+  claude-code: .claude/skills/review-testing-patterns/SKILL.md
+  cursor: .cursor/skills/review-testing-patterns/SKILL.md
+  github-copilot: .github/instructions/review-testing-patterns.instructions.md

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

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

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

@@ -0,0 +1,231 @@
+---
+name: transpose-design-patterns
+description: Decide the design pattern - or an explicit none - for a code change from a built-in framework-agnostic catalog, transpose it to the target framework via a bundled per-framework guide, and record the decision BEFORE writing implementation code; after implementation, hand the code to a fresh blind reviewer. USE WHEN implementing or refactoring code with a pattern-shaped decision - interchangeable behaviors, plugin/extensibility, object-creation logic, DTO/API-shape mapping, shared state, composable actions, cross-cutting concerns - or when choosing where code goes or whether a design is sound. EXAMPLES - "add a new exporter type", "wire two payment providers via DI", "where should this DTO mapping live", "make this service pluggable", "Strategy or Registry here?".
+license: MIT
+author: Guillaume Mongin (@hellraisercenobit)
+---
+
+# Transpose Design Patterns
+
+Autonomous, portable, **mandatory** workflow: detect the structural forces in the change, decide on a
+catalog pattern **or on an explicit `none`**, transpose it to the target framework with a bundled guide,
+and record the decision - all **before** writing implementation code. After implementation, a fresh
+reviewer re-derives the design blind (`review-design-patterns`). Everything this skill needs ships inside
+it; it references **no project files**, so it works in any repository.
+
+## Bundled sources (this skill owns them - read, do not paraphrase from memory)
+
+- **Shared procedure:** [suite contract 1.1.0](references/suite-contract.md) - read once per execution for C01-C12, the declaration, the three fingerprints, neutral context, composition, state expiry and portable/gate limits. The shared schemas it refers to sit beside it: [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).
+- **Catalog (framework-agnostic):** [`references/pattern-catalog.md`](references/pattern-catalog.md) -
+  the _Structural forces_ table (force → decision) with the _Extension-cost test_, one entry per pattern
+  (_Use when / Best practices / Avoid / Invariants_), the `None` entry.
+- **Record shape:** [`references/design-decision-record.schema.json`](references/design-decision-record.schema.json) -
+  the JSON Schema of the design decision record; a gate validates against it, never against semantics.
+- **Transposition (per framework):** the guide from the table below.
+
+| Target framework          | Transposition guide                                                  | Store / shared state         |
+| ------------------------- | ------------------------------------------------------------------- | ---------------------------- |
+| Angular                   | [`references/transpose-angular.md`](references/transpose-angular.md) | `providedIn: 'root'` service / `@ngrx/signals` |
+| React                     | [`references/transpose-react.md`](references/transpose-react.md)     | Zustand                      |
+| Vue                       | [`references/transpose-vue.md`](references/transpose-vue.md)         | Pinia (setup store)          |
+| Vanilla TS (no framework) | [`references/transpose-vanilla.md`](references/transpose-vanilla.md) | closure observable store / signals |
+| Quarkus (Java)            | [`references/transpose-quarkus.md`](references/transpose-quarkus.md) | `@ApplicationScoped` CDI bean |
+| PHP (Symfony)             | [`references/transpose-php.md`](references/transpose-php.md)         | stateless shared service; Cache / Lock for cross-request state |
+
+> Determine the target framework from the project you are editing - `package.json` deps for the JS/TS
+> frameworks (no UI framework → Vanilla TS), or a `pom.xml` / `build.gradle` declaring `io.quarkus`
+> deps → Quarkus, or a `composer.json` → PHP (`symfony/framework-bundle` in its `require` confirms the Symfony
+> wiring; without it the same class shapes apply at a composition root). To support another, see
+> _Extending to a new framework_. **No guide for the detected stack is a valid state:** decide on the
+> catalog alone and record `transposition: null`.
+
+## Mandatory procedure
+
+Run **every** step before writing or changing implementation code. Do not jump straight to coding.
+
+0. **Declare the dimension.** Before any record, say whether design patterns apply to this change and on
+   which paths: pipe a [declaration](references/declaration.schema.json) to
+   `ai-engineering-gate declare --dimension design-patterns --stdin`. It carries the requester's own wording,
+   the factual constraints, the comparison base and the protected scope - never your rationale, because the
+   reviewer's brief is rendered from it. Declaring `non-applicable` with the reason is a complete answer:
+   skipping the dimension is a recorded decision, not silence. _Done when:_ the declaration is accepted.
+1. **Detect the structural forces.** Walk the eight forces of the catalog's _Structural forces_ table
+   against the change. Answer each one with a **value from its set** plus the site that carries it: a file,
+   the planned symbol, or the requirement that states it (a planned third variant lives in the ticket, not
+   in the code). _Done when:_ all eight forces have a value and a site - a value, never prose, because that
+   is what the reviewer compares.
+2. **Run the extension-cost test.** For each variation axis (the discriminator that selects a variant:
+   a type tag, a key, a config value), the catalog's two questions in order: _is the set closed by
+   declaration, and does it stay closed?_ - a closed set is a legitimate `none` even though the branch is
+   edited; otherwise _count the edit sites the next legitimate variant costs_ in orchestration code.
+   More than one orchestration edit points at a pattern. Count the next plausible variant, never the
+   current one, and never pick the inline branch because it is shorter.
+3. **Decide: pattern or `none`.** Take the decision the _Structural forces_ table gives for the forces
+   present, after step 2: a variability force whose set passes question 1 records as `none`, and the
+   extension force splits on the catalog's Strategy-or-Registry tie-breaker. Read the chosen entry's
+   _Use when / Best practices / Avoid / Invariants_. Name every alternative you considered and why it lost; the **current shape of the code is
+   always one of them**. `none` is a first-class result and carries the same burden: the forces, the
+   alternatives, the structural reason the simpler shape wins, and the trigger that reopens the decision.
+   Never force a pattern to satisfy a gate; never pick `none` to save ceremony.
+4. **Resolve the framework and transpose.** Look up the guide in the table above; read the section
+   matching your pattern (plus its _Decision Matrix_) and apply the wiring it shows - DI, signals, stores,
+   layering. When the section's example does not fit (injected dependencies, no entry module to wire at),
+   keep its layering and say in `framework.transposition` what you adapted and why. No guide:
+   `transposition: null`, and the catalog's _Best practices_ are the wiring. For `none` there is no guide
+   section either: the catalog's `None` _Best practices_ are the wiring, and `transposition` is `null`.
+5. **Record the decision.** Write one design decision record per pattern-shaped site in the change
+   (shape below, schema in `references/`), **before the first implementation write**, and file it:
+   `ai-engineering-gate record --dimension design-patterns --stdin`. The gate stores it outside the
+   repository, hashes every path it `cites` and refuses a citation that does not exist, so a claim about
+   the current code cannot outlive the code. A force absorbed by the chosen pattern keeps its own value and
+   says so in its `site`. What the record commits to produce goes in `plans`; the reviewer is never
+   dispatched to notice a file that was never written. The gate checks shape, catalog membership and
+   referential integrity, never semantics; a refused record is fixed, not bypassed. Without the gate, check
+   the record against the schema yourself (ajv, or a hand check of every constraint) and keep its path: the
+   reviewer compares against it as written.
+6. **Implement per the transposition.** The first write inside the declared scope is allowed only once the
+   record is on file - `ai-engineering-gate can-write --path <path>` answers it, and a PreToolUse hook asks
+   for you. In your summary state the chain _forces → pattern (or `none`) → framework section followed_,
+   **and for each pattern name the concrete artifact** (file + symbol) that realizes it. Verify the artifact
+   is **distinct from unrelated layers** - e.g. a Command/use-case is its own injectable or exported
+   function, **not** a method merged into a store/facade - and that every invariant in the record is
+   observable in the code. File each planned artifact through
+   `ai-engineering-gate evidence append --dimension design-patterns --stdin` as you produce it.
+
+## Framework transposition - step 4
+
+Every guide uses the **same section names** (Strategy, Registry, Factory, Command, Adapter / DTO Mapping,
+Composition, Singleton / shared state), so open the section matching your pattern. For
+everything around the pattern (front end: reactivity, async, forms; back end: transactions, validation,
+runtime model), read that guide's _Cross-cutting <framework> practice_ section; for anything else, its
+_Decision Matrix_ (bottom). Store choice per framework is in the _Bundled sources_ table above.
+
+## Design decision record - step 5
+
+The values below are illustrative. Every fact in your record comes from the code or from the requirement
+as stated, never from this example.
+
+```json
+{
+  "dimension": "design-patterns",
+  "schemaVersion": "1.0.0",
+  "catalogVersion": "1.0.0",
+  "contractVersions": ["1.0.0", "1.1.0"],
+  "need": "quote shipping rates from a second carrier; the sales team wants to add carriers by market",
+  "scope": ["src/shipping/"],
+  "base": "origin/main",
+  "revision": { "number": 1, "previous": null, "reason": "first decision for this change" },
+  "cites": [
+    {
+      "path": "src/shipping/rate.service.ts",
+      "checkedAt": "2026-09-18",
+      "claim": "RateService.quote holds one body per carrier and both callers repeat the carrier branch",
+      "covers": ["variability", "extension"]
+    }
+  ],
+  "plans": [
+    { "path": "src/shipping/rate.strategy.ts", "role": "implementation" },
+    { "path": "src/shipping/rate.strategies.ts", "role": "implementation" }
+  ],
+  "forces": [
+    { "force": "variability", "value": "interchangeable-open", "site": "RateService.quote holds one body per carrier" },
+    { "force": "extension", "value": "many-sites", "site": "the ticket names a second carrier now and carriers per market later" },
+    { "force": "creation-policy", "value": "absent", "site": "each carrier client is a plain constructor call with no runtime decision" },
+    { "force": "boundary-mismatch", "value": "shape-and-semantics-differ", "site": "absorbed by strategy: each carrier's weight unit stays inside its own strategy" },
+    { "force": "reusable-action", "value": "absent", "site": "quote has no caller outside RateService" },
+    { "force": "composition", "value": "absent", "site": "one behavior per carrier, nothing is combined" },
+    { "force": "shared-lifecycle", "value": "per-consumer", "site": "the service and the clients hold configuration only" },
+    { "force": "cross-cutting-behavior", "value": "absent", "site": "no logging, retry or metrics requested" }
+  ],
+  "alternatives": [
+    "none, the current if/else on the carrier code - the set is not closed by declaration and a second market reopens it",
+    "registry - carriers are compile-time known with typed credentials; a Map lookup loses the completeness check",
+    "factory - createUpsStrategy(client) holds no creation decision, it is injection by closure"
+  ],
+  "decision": {
+    "pattern": "strategy",
+    "reason": "variability and extension on one axis, the carrier; RateService must depend on a contract, not on a client class",
+    "extensionCost": "today: 4 edit sites in RateService per carrier (CarrierCode, import, constructor, quote branch); with the map: 1 strategy module, 1 CarrierCode literal, 1 map entry, RateService untouched",
+    "reconsiderWhen": "a carrier arrives from configuration or a plugin at runtime - then Registry"
+  },
+  "framework": {
+    "name": "vanilla",
+    "transposition": "Strategy → typed lookup map resolved by key; adapted: strategies are factory closures over their injected client, the map is built by createRateStrategies because the tree has no entry module"
+  },
+  "artifacts": [
+    { "file": "src/shipping/rate.strategy.ts", "symbol": "RateStrategy" },
+    { "file": "src/shipping/rate.strategies.ts", "symbol": "createRateStrategies" }
+  ],
+  "invariants": [
+    "RateService depends on RateStrategy and on Record<CarrierCode, RateStrategy> only; it imports no client",
+    "a third carrier is added without editing rate.service.ts, and the build fails until its map entry exists",
+    "no switch, if or ternary on the carrier code remains under src/shipping"
+  ]
+}
+```
+
+- Each `forces` entry answers with a value from that force's set in the catalog's _Structural forces_ table,
+  plus the site that carries it. All eight are present; every force at its `absent` value is a legitimate
+  `none`.
+- `cites` are the artifacts and sources the claims rest on, each with the date you checked it and what it
+  `covers` - a force name, a symbol, a finding. `plans` are the artifacts this record commits to produce.
+- `decision.pattern` is one of `strategy`, `registry`, `factory`, `command`, `adapter`, `composition`,
+  `singleton`, `none`. A facade over a store records as `singleton`; UI state (signals) is framework
+  wiring, not a record.
+- `framework.name` is `angular`, `react`, `vue`, `vanilla`, `quarkus`, `php`, or the detected stack when no
+  guide covers it (then `transposition` is `null`).
+- `decision.extensionCost` is the step 2 count, today and with the decision - the reviewer re-counts it.
+- `decision.reconsiderWhen` is allowed for any pattern and required for `none`. For `none`,
+  `framework.transposition` is `null` and `artifacts` may be empty.
+- `invariants` are the catalog entry's _Invariants_, made concrete for this change - the reviewer checks
+  each one against the code.
+
+## Completion protocol
+
+After implementation and the project's deterministic checks (tests, lint, typecheck):
+
+1. **Ask what is left.** `ai-engineering-gate status --full` names the next action and, once every applicable
+   dimension has its records and its planned evidence, prints the dispatch plan: which reviewer to launch and
+   the neutral brief to send it, rendered from the declaration alone.
+2. **Dispatch every reviewer in the plan in one turn.** Use the `design-pattern-reviewer` agent when the
+   harness defines one; otherwise a fresh general subagent. Send the brief the plan printed and nothing else:
+   **not** the pattern name, not your rationale, not your force analysis, not the record's content. The brief
+   carries the record's path; the reviewer opens it only after its blind matrix is frozen. The gate refuses a
+   review to your own identity, so this is enforced, not only asked.
+3. **The reviewer runs `review-design-patterns`:** expected design frozen first, then the record, then the
+   code, compared three ways. It opens its own window and files its own envelope.
+4. **Findings: correct or dispute, then dispatch a fresh review.** Corrections are batched - address every
+   pending finding of every dimension, then reopen all applicable reviews together on one state. An evidence
+   finding is closed by its remedy; a judgment finding by a record revision that `addresses` it. A new
+   dispatch, never a continued conversation with the same reviewer.
+5. **A finding you contest is neither fixed nor dismissed.** File
+   `ai-engineering-gate dispute --dimension design-patterns --stdin` with a pointer to counter-evidence, then
+   hand it to the user: only a command the user types can write the arbitration.
+6. **Complete only when `ai-engineering-gate can-stop` exits 0.** Any later change to code in scope moves the
+   source fingerprint and voids the verdict, which the status reports as `stale-source`.
+
+Without the gate, dispatch the reviewer yourself with a brief carrying exactly what the plan would have
+carried: the skill to run, the read-only rule, the scope and base, the requester's wording, the factual
+constraints, the record paths and the undeclared changes. Nothing of your rationale.
+
+## Enforcement rules
+
+- Steps 0-5 are **non-negotiable** before implementation code in pattern-shaped work. A declaration is the
+  proof the dimension was considered, and a record - pattern or `none` - the proof the evaluation happened.
+- Never invent a pattern absent from the catalog. Never use `switch` / `constructor.name` / magic strings
+  **as the extension mechanism** where the catalog marks them _Avoid_; the exhaustive branch over a closed
+  set that the catalog's `None` entry prescribes is not that.
+- Treat each pattern's _Avoid_ clause as a hard rule - e.g. do **not** fold a reusable Command into a
+  store/facade method; resolve plugins by key via a Registry, never `switch` on a type tag.
+- Keep business logic framework-agnostic - only the transposition step (4) is framework-specific.
+- The bundled references are the source of truth. If a project also has its own pattern docs, follow the
+  project doc for project-specific wiring, but the procedure above still applies.
+- The completion protocol is part of the work: an implementation without a `SOUND` fresh review is not done.
+
+## Extending to a new framework
+
+1. Author `references/transpose-<framework>.md`, mirroring `references/transpose-angular.md` (front end) or
+   `references/transpose-quarkus.md` (back end): a _Decision Matrix_ plus one section per catalog pattern
+   with idiomatic wiring for that framework.
+2. Add one row to the _Target framework_ table above, pointing at the new guide.
+3. Leave `references/pattern-catalog.md` framework-agnostic and unchanged - it is shared across all targets.

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

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Transpose Design Patterns"
+  short_description: "Pick a pattern and transpose it to the framework"

package/skills/engineering/transpose-design-patterns/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
+    }
+  }
+}