@sigloch/contracts 6.3.0 → 10.0.0

package/dist/se/policy.js

@@ -34,6 +34,27 @@ export const MetricPolicySchema = z.object({
      * in die `arch`-Dimension ein (CR-SM-236).
      */
     crossingFlows: z.object({ warning: z.number().int().min(1) }).nullable(),
+    /**
+     * CR-SM-282: Kinderzahl je Blackbox (RD-04). Stand bis hierher als
+     * `DECOMPOSITION_BREADTH_MAX = 11` inline in `rules.ts` — eine Urteilsschwelle, die sich
+     * weder per grep noch aus dem Regelnamen ablesen liess (dieselbe Klasse, die CR-SM-236 fuer
+     * R-04 aufgeloest hat). `null` -> messen, nicht urteilen: die Regel schweigt.
+     *
+     * Der Default bleibt 11 und ist damit verhaltensgleich zum Bisherigen. Die Doktrin
+     * (`se:top-level`: „max 5 per level") ist bewusst NICHT der Default: `info` bei 5 haette am
+     * graphcode-Selbstmodell 20 zusaetzliche Befunde erzeugt, und `readiness` zaehlt `info`
+     * ungefiltert in den Nenner (`score = 1 - Verstoesse / applicable`) — genau der Grund, aus dem
+     * MT-03 zur Messung statt zur Regel wurde. Wer doktrin-streng fahren will, setzt 5.
+     */
+    decompositionBreadth: z.object({ warning: z.number().int().min(2) }).nullable(),
+    /**
+     * CR-SM-283: Randbreite je Blackbox (BW-02) — verschiedene Vertraege, die den Rand queren.
+     * Bewusst OHNE `info`-Stufe: die Verteilung gibt sie nicht her. bok und graph-view-edit enden
+     * beide bei 3; eine info-Schwelle dort truege bok 4 Befunde auf 9 Blackboxes, und `readiness`
+     * zaehlt `info` ungefiltert in den Nenner (`score = 1 - Verstoesse / applicable`) — der Grund,
+     * aus dem MT-03 zur Messung statt zur Regel wurde. `null` -> messen, nicht urteilen.
+     */
+    boundaryWidth: z.object({ warning: z.number().int().min(1) }).nullable(),
     /**
      * FM-03: RPN (severity · occurrence · detection), ab dem ein Risiko-REQ eine bestandene
      * Verifikation braucht (exklusiv). null → FM-03 feuert nie.
@@ -84,15 +105,45 @@ export const MetricPolicySchema = z.object({
  * `> 5` → warning, also warning ab 6.
  */
 export const DEFAULT_METRIC_POLICY = {
-    instability: 0.7,
+    // CR-SM-293: `null` — MESSEN, NICHT URTEILEN. Die 0.7 stand hier als Startwert und war laut
+    // CR-SM-223 ausdruecklich "gesetzt, nicht gemessen". Nachdem MT-01 nur noch Kopplung zaehlt,
+    // ist die Verteilung ueber 149 messbare Module ZWEIGIPFLIG: 44 liegen exakt auf 0.00 (reine
+    // Produzenten), 45 exakt auf 1.00 (reine Konsumenten), und 45 der 51 Befunde bei 0.7 sind
+    // genau die 1.00. Aus einer solchen Verteilung laesst sich keine Schwelle ABLESEN (Praezedenz
+    // CR-SM-283/BW-02), und der Grund ist Struktur, nicht Zaehlweise: die meisten Module tragen
+    // zwei bis drei kreuzende Vertraege, da ist das Verhaeltnis 0 oder 1.
+    //
+    // Tiefer liegt der Einwand von Martin selbst: I ist eine KOORDINATE, kein Defekt. Sein Satz
+    // lautet "in Richtung Stabilitaet abhaengen", nicht "I klein halten" — ein Blattmodul mit
+    // I = 1.0 ist richtig, nicht kaputt. Damit fehlt MT-01 die Eigenschaft, die CR-SM-287 §2 von
+    // einer Steuerdimension verlangt: GERICHTET, "weniger ist besser, ohne Diskussion".
+    //
+    // Die Zahl bleibt vollstaendig erhalten — in jeder Modulzeile von `graph_metrics`, im Export
+    // und im gve-Dashboard, das den Zustand bereits rendert ("Instabilitaet wird hier nur
+    // gemessen"). Es entsteht nur kein Verstoss. graphcode faehrt das seit CR-GC-329 in seiner
+    // eigenen Config; dieser Default macht aus der Konfigurationszufaelligkeit eine Entscheidung.
+    instability: null,
     lcom4: { info: 4, warning: 6 },
     // CR-SM-236: die bisherigen Literale, jetzt an einer grep-baren Stelle.
     // `crossingFlows.warning = 3` ist die unveränderte Alt-Semantik: vorher `count > 2` → warning.
     crossingFlows: { warning: 3 },
+    // CR-SM-282: unveraenderte Alt-Semantik (`DECOMPOSITION_BREADTH_MAX = 11`, `> max` meldet).
+    // CR-SM-296: 7+-2 ist die Doktrin (`se:top-level`), 9 ist ihre Obergrenze. Bis hierher stand
+    // hier 11 -- gesetzt, nicht abgelesen. CR-SM-282 hatte gegen die Doktrin-Zahl 5 entschieden,
+    // weil `info` bei 5 den readiness-Nenner verwaessert haette; das Argument traegt fuer die
+    // OBERgrenze nicht, denn RD-04 meldet als `warning`. Die Zahl steht jetzt an EINER Stelle und
+    // gilt fuer beide Zerlegungsfragen -- Sub-FUNC und Sub-MOD.
+    decompositionBreadth: { warning: 9 },
+    // CR-SM-283: aus der Verteilung abgelesen — bok/gve max 3, graphcode 19, moneyflow 17.
+    boundaryWidth: { warning: 5 },
     riskRpn: 100,
     // `large`/`coupled`/`crossings` = die drei Literale aus `maxModuleSize`: vorher
     // `funcCount <= 8` → skip, `funcCount > 12` → groß, `crossings > 2` → gekoppelt.
-    moduleSize: { large: 12, coupled: 8, crossings: 2 },
+    // CR-SM-296: an dieselbe Doktrin gebunden statt danebengesetzt. R-04 ist seit diesem CR ALLEIN
+    // fuer die Modulgroesse zustaendig (RD-04 hat ihr Allokations-Bein abgegeben), also gilt hier
+    // dieselbe 7+-2: `large` = 9 (Obergrenze), `coupled` = 7 (Untergrenze, ab der die Regel
+    // hinsieht). Vorher 12/8 -- zwei Zahlen fuer dieselbe Frage, unverbunden mit den 11 darueber.
+    moduleSize: { large: 9, coupled: 7, crossings: 2 },
     // CR-SM-229: kein Startwert möglich und keiner gewollt — die Tabelle steht nur im Handbook.
     // `null` heißt hier nicht „aus", sondern „markierter Übergang": bestätigte AP-Invarianten,
     // sonst RPN-Bänder. `apMethod()` macht das für den Leser sichtbar.

package/dist/se/quality-rules.d.ts

@@ -20,6 +20,24 @@ export declare function setBQ04SimilarityMatrix(data: {
 /**
  * BQ-04 checks for duplicate / near-duplicate requirements using
  * pre-computed embedding similarity. Returns [] when no matrix is set.
+ *
+ * CR-SM-286: **bewusst NICHT angeschlossen — anders als ND-01/ND-02.**
+ *
+ * Die Naht ist dieselbe und sie ist genauso tot: `setBQ04SimilarityMatrix()` ruft im gesamten
+ * Familienbaum niemand (CR-SM-278, erneut geprueft). Der Unterschied liegt in der Eingabe. ND-01
+ * und ND-02 nennen deterministische Formeln ueber Graphinhalt (Jaccard ueber Beschreibung,
+ * Verb, io-Topologie, Felder) — die konnten nach `similarity.ts` wandern und tun dort dasselbe.
+ * BQ-04 verlangt laut eigener Zeile "pre-computed EMBEDDING similarity", und Embeddings kann ein
+ * reines Vertragspaket nicht berechnen: kein Modell, kein Netz, kein Zufall.
+ *
+ * Ein Ersatzmass haette ich erfinden muessen. Ein Versuch mit 0.7*Beschreibung + 0.3*Name lief:
+ * **0 Befunde an allen neun Familiengraphen** und 4950 an einer templatierten Fixture — also
+ * genau die zwei Gate-7-Ausreisser zugleich ("0 Befunde am Selbstmodell" und "quadratisch mit
+ * der Graphgroesse"). Erfundene Gewichte ohne Messung sind keine Reparatur.
+ *
+ * Damit ist BQ-04 der naechste AO-D03-Fall: entweder eine Eingabe, die der Host liefern MUSS
+ * (dann gehoert die Regel nicht in ein reines Paket), oder streichen. Das ist eine
+ * Grammatik-Entscheidung — `se-grammar-review`, eigener CR, nicht hier nebenbei.
  */
 export declare function bq04Necessary(graph: OntologyGraph): RuleViolation[];
 export declare function bq06Conforming(graph: OntologyGraph): RuleViolation[];

package/dist/se/quality-rules.js

@@ -1,3 +1,4 @@
+import { normalizeReqKinds } from './ontology.js';
 // ---------------------------------------------------------------------------
 // Weasel words list (BQ-01)
 // ---------------------------------------------------------------------------
@@ -22,14 +23,37 @@ const measurablePattern = /(\d+[\s]*(ms|s|sec|min|%|percent|byte|MB|GB|times|x|s
 function reqElements(graph) {
     return graph.elements.filter(e => e.type === 'REQ');
 }
+/**
+ * CR-SM-275: `description` ist im Zod-Schema Pflicht, aber die Regeln bekommen Graphen aus
+ * Store/Import ohne Re-Parse — dort fehlt das Feld. `req.description.trim()` warf dann
+ * `TypeError` und riss `evaluateAllRules` ab (gemessen am kadjar-Graphen, Spike CR-GC-438 §7).
+ * EIN Normalisierungspunkt statt eines Guards je Fundstelle: eine fehlende Beschreibung ist
+ * die leere Beschreibung — ein BEFUND (BQ-06/BQ-07 melden sie), kein Absturz.
+ */
+/**
+ * CR-SM-285: `?? ''` faengt nur `null`/`undefined`. Ein Graph aus einer fremden Quelle (Import,
+ * fremdes Tool, handgeschriebene Fixture) kann `description` als Zahl, Objekt oder Array tragen —
+ * dann warf `.trim()` und `evaluateAllRules` STARB, statt zu urteilen. Am Gate heisst das:
+ * Stacktrace statt `block`-Verdict, der Aufrufer sieht kein Urteil.
+ *
+ * Gemessen vor dem Fix: `null` ok, `42`/`{}`/`[]`/`true` -> "descriptionOf(...).trim is not a
+ * function". Vier von fuenf Typen.
+ *
+ * Nicht-Strings werden zu `''` — also behandelt wie "keine Beschreibung". Das ist die richtige
+ * Deutung: ein Objekt IST keine Beschreibung, und die Regel soll das melden statt zu raten oder
+ * zu sterben.
+ */
+function descriptionOf(el) {
+    return typeof el.description === 'string' ? el.description : '';
+}
 // ---------------------------------------------------------------------------
 // BQ-01 Unambiguous — detect weasel words in REQ descriptions
 // ---------------------------------------------------------------------------
 export function bq01Unambiguous(graph) {
     return reqElements(graph)
-        .filter(req => weaselPattern.test(req.description))
+        .filter(req => weaselPattern.test(descriptionOf(req)))
         .map(req => {
-        const match = req.description.match(weaselPattern);
+        const match = descriptionOf(req).match(weaselPattern);
         return {
             rule_id: 'BQ-01',
             severity: 'warning',
@@ -49,7 +73,7 @@ export function bq01Unambiguous(graph) {
 // ---------------------------------------------------------------------------
 export function bq02Verifiable(graph) {
     return reqElements(graph)
-        .filter(req => !measurablePattern.test(req.description))
+        .filter(req => !measurablePattern.test(descriptionOf(req)))
         .map(req => ({
         rule_id: 'BQ-02',
         severity: 'warning',
@@ -84,6 +108,24 @@ export function setBQ04SimilarityMatrix(data) {
 /**
  * BQ-04 checks for duplicate / near-duplicate requirements using
  * pre-computed embedding similarity. Returns [] when no matrix is set.
+ *
+ * CR-SM-286: **bewusst NICHT angeschlossen — anders als ND-01/ND-02.**
+ *
+ * Die Naht ist dieselbe und sie ist genauso tot: `setBQ04SimilarityMatrix()` ruft im gesamten
+ * Familienbaum niemand (CR-SM-278, erneut geprueft). Der Unterschied liegt in der Eingabe. ND-01
+ * und ND-02 nennen deterministische Formeln ueber Graphinhalt (Jaccard ueber Beschreibung,
+ * Verb, io-Topologie, Felder) — die konnten nach `similarity.ts` wandern und tun dort dasselbe.
+ * BQ-04 verlangt laut eigener Zeile "pre-computed EMBEDDING similarity", und Embeddings kann ein
+ * reines Vertragspaket nicht berechnen: kein Modell, kein Netz, kein Zufall.
+ *
+ * Ein Ersatzmass haette ich erfinden muessen. Ein Versuch mit 0.7*Beschreibung + 0.3*Name lief:
+ * **0 Befunde an allen neun Familiengraphen** und 4950 an einer templatierten Fixture — also
+ * genau die zwei Gate-7-Ausreisser zugleich ("0 Befunde am Selbstmodell" und "quadratisch mit
+ * der Graphgroesse"). Erfundene Gewichte ohne Messung sind keine Reparatur.
+ *
+ * Damit ist BQ-04 der naechste AO-D03-Fall: entweder eine Eingabe, die der Host liefern MUSS
+ * (dann gehoert die Regel nicht in ein reines Paket), oder streichen. Das ist eine
+ * Grammatik-Entscheidung — `se-grammar-review`, eigener CR, nicht hier nebenbei.
  */
 export function bq04Necessary(graph) {
     if (!_bq04Matrix)
@@ -140,7 +182,7 @@ const conformingPatternDE = /\b(soll|muss|darf nicht)\s+\w+/i;
 export function bq06Conforming(graph) {
     return reqElements(graph)
         .filter(req => {
-        const desc = req.description.trim();
+        const desc = descriptionOf(req).trim();
         return !conformingPattern.test(desc) && !conformingPatternDE.test(desc);
     })
         .map(req => ({
@@ -162,20 +204,34 @@ export function bq06Conforming(graph) {
 const placeholderPattern = /\b(TBD|TBR|TODO|placeholder|to be determined)\b|needs\s.*review/i;
 const BQ07_MIN_DESC_LENGTH = 20;
 export function bq07Complete(graph) {
+    // CR-SM-266 REQ-X06: `kinds` ist Pflicht am REQ — hier als DRITTER Grund derselben Regel,
+    // bewusst ohne neue Regel-ID (Gate 6 des Grammatik-Reviews: eine ID kostet dauerhaft einen
+    // Nenner-Anteil, eine Katalogzeile, eine readiness-Zuordnung und einen Golden-File-Eintrag).
+    // BQ-07 heisst "Complete" und sammelt bereits mehrere Unvollstaendigkeits-Gruende in EINEN
+    // Befund; ein REQ ohne Klassifikation ist genau das — unvollstaendig, nicht falsch.
+    //
+    // Die DURCHSETZENDE Haelfte liegt woanders: `satisfiesPredicate` (meta-model.ts) lehnt jede
+    // satisfy-Kante auf ein REQ ohne `kinds` ab, weil dort nicht entscheidbar ist, ob sie
+    // zulaessig ist. Das ist die Fehlmessung und deshalb R-18/error; das blosse Fehlen der
+    // Angabe ist ein Vollstaendigkeitssignal und deshalb hier/warning — dieselbe Trennung, die
+    // CR-SM-262 fuer RC-06 begruendet hat.
+    const isIncomplete = (req) => descriptionOf(req).trim().length < BQ07_MIN_DESC_LENGTH ||
+        placeholderPattern.test(descriptionOf(req)) ||
+        normalizeReqKinds(req.kinds).length === 0;
     return reqElements(graph)
-        .filter(req => {
-        const tooShort = req.description.trim().length < BQ07_MIN_DESC_LENGTH;
-        const hasPlaceholder = placeholderPattern.test(req.description);
-        return tooShort || hasPlaceholder;
-    })
+        .filter(isIncomplete)
         .map(req => {
+        const desc = descriptionOf(req);
         const reasons = [];
-        if (req.description.trim().length < BQ07_MIN_DESC_LENGTH) {
-            reasons.push(`description too short (${req.description.trim().length}/${BQ07_MIN_DESC_LENGTH} chars)`);
+        if (desc.trim().length < BQ07_MIN_DESC_LENGTH) {
+            reasons.push(`description too short (${desc.trim().length}/${BQ07_MIN_DESC_LENGTH} chars)`);
         }
-        if (placeholderPattern.test(req.description)) {
+        if (placeholderPattern.test(desc)) {
             reasons.push('contains placeholder');
         }
+        if (normalizeReqKinds(req.kinds).length === 0) {
+            reasons.push('no kinds declared');
+        }
         return {
             rule_id: 'BQ-07',
             severity: 'warning',

package/dist/se/readiness.d.ts

@@ -9,30 +9,31 @@
  */
 import { z } from 'zod/v4';
 export declare const ReadinessDimension: z.ZodEnum<{
+    schema: "schema";
     req: "req";
     uc: "uc";
     arch: "arch";
     alloc: "alloc";
     ver: "ver";
-    schema: "schema";
     cr: "cr";
     ms: "ms";
 }>;
 export type ReadinessDimensionType = z.infer<typeof ReadinessDimension>;
 export declare const ReadinessScore: z.ZodObject<{
     dimension: z.ZodEnum<{
+        schema: "schema";
         req: "req";
         uc: "uc";
         arch: "arch";
         alloc: "alloc";
         ver: "ver";
-        schema: "schema";
         cr: "cr";
         ms: "ms";
     }>;
-    score: z.ZodNumber;
+    score: z.ZodNullable<z.ZodNumber>;
     violations: z.ZodNumber;
     applicable: z.ZodNumber;
+    coreApplicable: z.ZodNumber;
     ready: z.ZodBoolean;
 }, z.core.$strip>;
 export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
@@ -48,18 +49,19 @@ export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
 export declare const ReadinessReport: z.ZodObject<{
     scores: z.ZodArray<z.ZodObject<{
         dimension: z.ZodEnum<{
+            schema: "schema";
             req: "req";
             uc: "uc";
             arch: "arch";
             alloc: "alloc";
             ver: "ver";
-            schema: "schema";
             cr: "cr";
             ms: "ms";
         }>;
-        score: z.ZodNumber;
+        score: z.ZodNullable<z.ZodNumber>;
         violations: z.ZodNumber;
         applicable: z.ZodNumber;
+        coreApplicable: z.ZodNumber;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
     timestamp: z.ZodISODateTime;

package/dist/se/readiness.js

@@ -14,17 +14,39 @@ export const ReadinessDimension = z.enum([
     'arch', // Functional architecture (R-02, R-03, R-10, R-12)
     'alloc', // Module allocation (R-04)
     'ver', // Test coverage (R-01, R-05)
-    'schema', // Interface completeness (R-26 binding, SC-02/SC-04 usage)
+    'schema', // Interface completeness (R-26 binding, SC-02 usage)
     'cr', // CR traceability (CR-R01..R03)
     'ms', // Milestone planning (MS-01..02)
 ]);
 export const ReadinessScore = z.object({
     dimension: ReadinessDimension,
-    score: z.number().min(0).max(1), // 1 - (violations / applicable)
+    /**
+     * `1 - (violations / applicable)` — oder **`null`**, wenn die Dimension nicht messbar ist
+     * (CR-SM-270).
+     *
+     * `null` heisst nie 0 %, so wie schon bei `graph_metrics` (CR-GC-326): "a value that is not
+     * measurable is not zero percent". Der Anlass war die Gegenrichtung — ein Modell ohne einen
+     * einzigen Use Case meldete `uc: 0,997, ready: true`, weil 306 FUNC ueber eine einzige
+     * Fremdtyp-Regel (FC-03) den Nenner fuellten, waehrend die dreizehn Regeln, die wirklich Use
+     * Cases pruefen, nichts zu pruefen hatten und ihr SCHWEIGEN sich als Erfolg las. Der Score
+     * zeigte damit in die falsche Richtung: je mehr importierte FUNCs ein Repo ohne Wozu-Ebene
+     * hat, desto reifer sah seine uc-Readiness aus.
+     */
+    score: z.number().min(0).max(1).nullable(),
     violations: z.number().int(),
     applicable: z.number().int(),
+    /**
+     * CR-SM-270: die Kernmenge der Dimension — die Elemente der Typen, die die MEHRHEIT ihrer
+     * Regeln prueft (uc → UC/FCHAIN/ACTOR, arch → FUNC/MOD). Ist sie 0, ist `score` `null`.
+     *
+     * Sie steht im Bericht, weil sonst niemand das `null` erklaeren kann: `applicable` allein
+     * unterscheidet "nichts zu pruefen" (0) nicht von "nur Fremdtypen" (307). Genau die
+     * Unterscheidung, an der der dokumentierte Ausweg aus CR-SM-237 gescheitert ist.
+     */
+    coreApplicable: z.number().int(),
     // CR-SM-235: `score >= readyThreshold`. Die Schwelle steht bewusst NICHT hier — sie ist
     // Eingabe von `computeReadiness`, und eine Zahl im Kommentar wäre die dritte Meinung dazu.
+    // CR-SM-270: bei `score === null` ist `ready` immer `false` — nicht messbar ist nicht bereit.
     ready: z.boolean(),
 });
 /**
@@ -57,8 +79,7 @@ export const RULE_TO_DIMENSION = {
     // CR-SM-231: R-29 (Testdatei-Exklusivitaet) gehoert zu 'ver' wie R-19 — beide bewerten die
     // Evidenz-Bindung einer Abnahme, R-19 ihre Praesenz, R-29 ihre Eindeutigkeit.
     'R-29': 'ver',
-    'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', 'R-27': 'arch',
-    // CR-GC-366: R-30 (Wirkketten-Bindung) und R-31 (io-Verdrahtung) bewerten beide, ob ein
+    'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', // CR-GC-366: R-30 (Wirkketten-Bindung) und R-31 (io-Verdrahtung) bewerten beide, ob ein
     // Funktionsblock ueberhaupt im Bauplan haengt — dieselbe Dimension wie R-20 (realRef).
     // NICHT 'uc': R-14..R-17 fragen, ob ein Behaelter gefuellt ist;
     // diese beiden fragen von der FUNC aus, ob sie angeschlossen ist.
@@ -66,19 +87,19 @@ export const RULE_TO_DIMENSION = {
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
     'UC-05': 'uc', 'UC-06': 'uc',
-    'R-14': 'uc', 'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
+    'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
     // FC-04 (CR-SM-226): FCHAIN actor-bounded (trigger+consumer) — same dimension as FC-01..03.
-    'FC-01': 'uc', 'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
+    'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
     // arch
-    'R-02': 'arch', 'R-03': 'arch', 'R-10': 'arch', 'R-12': 'arch',
+    'R-02': 'arch', 'R-10': 'arch', 'R-12': 'arch',
     // alloc
     'R-04': 'alloc',
     // ver
     'R-01': 'ver', 'R-05': 'ver',
     // schema
     'SC-02': 'schema', // SC-01/SC-03 deleted (BOK-CR-026) — R-26 is the binding rule
-    // CR-SM-226: SC-04 sharp per-FLOW SCHEMA-binding check — same dimension as SC-02.
-    'SC-04': 'schema',
+    // SC-04 entfiel mit CR-SM-271: FLOW ohne SCHEMA ist jetzt Grammatik (R-18-Bein, error)
+    // und zaehlt damit unter R-18/'arch' statt als eigene 'schema'-Zeile.
     // structural rules without primary dimension → assigned by closest concern
     'R-08': 'arch',
     // near-duplicate detection
@@ -88,12 +109,12 @@ export const RULE_TO_DIMENSION = {
     // rule (CR-SM-223) — a per-module advisory would depress this score permanently.
     'MT-01': 'alloc', 'MT-02': 'alloc',
     // CR traceability
-    'CR-R01': 'cr', 'CR-R02': 'cr', 'CR-R03': 'cr', 'CR-R04': 'cr',
-    // architecture optimization
-    'AO-D01': 'arch', 'AO-D03': 'arch',
+    'CR-R01': 'cr', 'CR-R02': 'cr', 'CR-R03': 'cr', // architecture optimization
+    // CR-SM-283: BW-02 (Whitebox-Randbreite) ersetzt AO-D03 an dieser Stelle — dieselbe
+    // Dimension, denn beide fragen nach der Struktur des Funktionsschnitts, nicht nach Evidenz.
+    'BW-02': 'arch',
     // allocation rules (CR-191)
-    'CR-01': 'arch', 'RT-01': 'arch', 'PH-01': 'arch', 'CA-01': 'arch',
-    // milestone planning
+    'CR-01': 'arch', // milestone planning
     'MS-01': 'ms', 'MS-02': 'ms', 'MS-03': 'ms',
     // FMEA / risk
     'FM-01': 'req', 'FM-02': 'req', 'FM-03': 'ver',
@@ -139,7 +160,7 @@ export const RULE_TO_PHASE = {
     'BQ-01': 'SRR', 'BQ-02': 'SRR', 'BQ-04': 'SRR', 'BQ-06': 'SRR', 'BQ-07': 'SRR',
     'RD-01': 'SRR', 'RD-02': 'SRR', 'RD-03': 'SRR',
     'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR', 'UC-05': 'SRR', 'UC-06': 'SRR',
-    'R-14': 'SRR', 'R-16': 'SRR', 'R-17': 'SRR',
+    'R-16': 'SRR', 'R-17': 'SRR',
     'FC-02': 'SRR',
     'CL-01': 'SRR',
     'FM-01': 'SRR', 'FM-02': 'SRR',
@@ -147,21 +168,18 @@ export const RULE_TO_PHASE = {
     'MS-01': 'SRR', 'MS-02': 'SRR', 'MS-03': 'SRR',
     // PDR — architecture/functional completeness.
     'RD-04': 'PDR',
-    'R-02': 'PDR', 'R-03': 'PDR', 'R-08': 'PDR', 'R-10': 'PDR', 'R-12': 'PDR', 'R-18': 'PDR',
+    'R-02': 'PDR', 'R-08': 'PDR', 'R-10': 'PDR', 'R-12': 'PDR', 'R-18': 'PDR',
     'R-04': 'PDR', 'R-22': 'PDR', 'R-23': 'PDR',
     'R-15': 'PDR',
-    'FC-01': 'PDR', 'FC-03': 'PDR', 'FC-04': 'PDR',
+    'FC-03': 'PDR', 'FC-04': 'PDR',
     // CR-GC-366: Anschluss des Funktionsbaus — gehoert an dasselbe Gate wie R-15/IO-01,
     // die auf derselben Kette aufsetzen.
     'R-30': 'PDR', 'R-31': 'PDR',
     'MT-01': 'PDR', 'MT-02': 'PDR',
     'ND-01': 'PDR',
-    'AO-D01': 'PDR', 'AO-D03': 'PDR', 'CR-01': 'PDR', 'RT-01': 'PDR', 'PH-01': 'PDR', 'CA-01': 'PDR',
-    'IO-01': 'PDR', // CR-SM-226: extended to all FCHAIN FUNC-pairs, added to the phase axis.
-    'CR-R04': 'PDR',
+    'BW-02': 'PDR', 'CR-01': 'PDR', 'IO-01': 'PDR', // CR-SM-226: extended to all FCHAIN FUNC-pairs, added to the phase axis.
     // CDR — critical design/schema completeness.
-    'R-26': 'CDR', 'R-27': 'CDR',
-    'SC-02': 'CDR', 'SC-04': 'CDR', // SC-04: FLOW→SCHEMA sharp rule (CR-SM-226)
+    'R-26': 'CDR', 'SC-02': 'CDR', // SC-04 entfiel mit CR-SM-271 — der FLOW-ohne-SCHEMA-Fall haengt an R-18/PDR
     'ND-02': 'CDR',
     'NFR-01': 'CDR',
     // TRR — test readiness.

package/dist/se/rules.d.ts

@@ -26,7 +26,6 @@ export declare const ViolationCandidate: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>;
@@ -46,7 +45,6 @@ export declare const ViolationContext: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>>;
@@ -64,7 +62,6 @@ export declare const ViolationContext: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>;
@@ -79,11 +76,13 @@ export declare const ViolationContext: z.ZodObject<{
             verify: "verify";
             allocate: "allocate";
             relation: "relation";
-            produces: "produces";
         }>;
     }, z.core.$strip>>>;
     parent_module: z.ZodOptional<z.ZodString>;
     current_description: z.ZodOptional<z.ZodString>;
+    also_affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    value: z.ZodOptional<z.ZodNumber>;
+    threshold: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type ViolationContext = z.infer<typeof ViolationContext>;
 export declare const RuleViolation: z.ZodObject<{
@@ -108,7 +107,6 @@ export declare const RuleViolation: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>>;
@@ -126,7 +124,6 @@ export declare const RuleViolation: z.ZodObject<{
                 TEST: "TEST";
                 MOD: "MOD";
                 SCHEMA: "SCHEMA";
-                SESSION: "SESSION";
                 CR: "CR";
                 MS: "MS";
             }>;
@@ -141,11 +138,13 @@ export declare const RuleViolation: z.ZodObject<{
                 verify: "verify";
                 allocate: "allocate";
                 relation: "relation";
-                produces: "produces";
             }>;
         }, z.core.$strip>>>;
         parent_module: z.ZodOptional<z.ZodString>;
         current_description: z.ZodOptional<z.ZodString>;
+        also_affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        value: z.ZodOptional<z.ZodNumber>;
+        threshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RuleViolation = z.infer<typeof RuleViolation>;