@sigloch/contracts 3.3.0 → 4.0.0

package/dist/harness/index.d.ts

@@ -118,8 +118,8 @@ export declare const RuleViolationSchema: z.ZodObject<{
     ruleId: z.ZodString;
     severity: z.ZodEnum<{
         error: "error";
-        warning: "warning";
         info: "info";
+        warning: "warning";
     }>;
     message: z.ZodString;
     elementId: z.ZodOptional<z.ZodString>;
@@ -142,8 +142,8 @@ export declare const MutateResultSchema: z.ZodObject<{
         ruleId: z.ZodString;
         severity: z.ZodEnum<{
             error: "error";
-            warning: "warning";
             info: "info";
+            warning: "warning";
         }>;
         message: z.ZodString;
         elementId: z.ZodOptional<z.ZodString>;

package/dist/se/action-priority.d.ts

@@ -0,0 +1,101 @@
+/**
+ * CR-SM-229 — Action Priority (AP) ersetzt RPN, ohne die geschützte Tabelle auszuliefern.
+ *
+ * Das AIAG-VDA FMEA Handbook (1st Edition, 2019) hat RPN **ersetzt**, nicht ergänzt. Der Skill
+ * `se-fmea` sagt das in Step 5 wörtlich („Risk Analysis → Action Priority (AP), not RPN"); der
+ * Regelcode folgte ihm bis hierher nicht.
+ *
+ * **RPN irrt gerichtet.** S 10 / O 2 / D 2 ergibt RPN 40 → „niedriges Risiko", während AP dort
+ * immer `High` sagt: ein gutes Detection-Rating rechnet eine sicherheitskritische Schwere weg.
+ * Genau dafür wurde AP eingeführt.
+ *
+ * ## Warum die Tabelle hier nicht steht
+ *
+ * Die normative AP-Tabelle (5 Severity- × 5 Occurrence- × 4 Detection-Bänder = 100 Zellen) steht
+ * ausschließlich im Handbook. Urheberrecht schützt keine Verfahren — **die Methode anzuwenden ist
+ * frei**. Die 100 Zellwerte sind aber normative Wertung (jemand hat entschieden, dass S 7 / O 4 /
+ * D 6 „Medium" ist), keine Fakten; sie in ein publiziertes npm-Paket zu legen wäre die verbotene
+ * Reproduktion.
+ *
+ * Deshalb: **die Logik wird ausgeliefert, die Zellwerte nie.** Eine Funktion, zwei Konsumenten
+ * (FM-03 und der graphcode-Exporter) — kein zweiter Klassifikationspfad. Die Tabelle wandert auch
+ * nicht in den Graphen (SYS-Attribute o. ä.): der Graph wird exportiert und verteilt, das wäre
+ * dieselbe Reproduktion durch die Hintertür.
+ *
+ * > Keine Rechtsberatung. Vor einem kommerziellen Release anwaltlich bestätigen lassen; in DE/EU
+ * > kommt zusätzlich das Datenbankherstellerrecht (§ 87a UrhG) in Betracht.
+ *
+ * ## Offene Fachfrage, hier nicht entschieden
+ *
+ * DFMEA und FMEA-MSR haben verschiedene AP-Tabellen. `ApTableSchema` muss die Variante
+ * mitführen, sobald MSR relevant wird.
+ */
+import { z } from 'zod/v4';
+/** Die drei Stufen des AIAG-VDA-Verfahrens. */
+export declare const ActionPriority: z.ZodEnum<{
+    High: "High";
+    Medium: "Medium";
+    Low: "Low";
+}>;
+export type ActionPriority = z.infer<typeof ActionPriority>;
+/**
+ * Form einer AP-Tabelle, **nicht ihr Inhalt**.
+ *
+ * Ein Konsument lädt sie zur Laufzeit aus einer lokalen, nie eingecheckten Datei (z. B.
+ * `.graphcode/ap-table.json`, dort mit `.gitignore`-Eintrag). Das Schema erzwingt, dass sie
+ * vollständig ist: 5 × 5 × 4 Bänder und für jede der 100 Kombinationen eine Stufe. Eine
+ * unvollständige Tabelle wird abgelehnt, statt still auf die Interimslogik zurückzufallen —
+ * ein halb geladenes Urteil ist schlimmer als ein bekanntermaßen ersatzweises.
+ */
+export declare const ApTableSchema: z.ZodObject<{
+    severityBands: z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+    }, z.core.$strip>>;
+    occurrenceBands: z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+    }, z.core.$strip>>;
+    detectionBands: z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+    }, z.core.$strip>>;
+    cells: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodEnum<{
+        High: "High";
+        Medium: "Medium";
+        Low: "Low";
+    }>>>>;
+}, z.core.$strip>;
+export type ApTable = z.infer<typeof ApTableSchema>;
+/**
+ * Welches Verfahren die Einstufung gerade trägt.
+ *
+ * Treibt die Kennzeichnung beim Konsumenten (graphcode rendert die AP-Spalte als `AP*` mit
+ * generierter Fußnote, solange `'rpn-interim'` gilt). Hinweis und Berechnung können nicht
+ * auseinanderlaufen, weil beide aus derselben Quelle kommen.
+ */
+export declare function apMethod(table?: ApTable): 'aiag-vda' | 'rpn-interim';
+/**
+ * Action Priority für ein S/O/D-Tripel.
+ *
+ * **Mit `table`** gilt die echte Zuordnung des Handbooks.
+ *
+ * **Ohne `table`** gilt der *markierte Übergang* — nur die von allen geprüften Quellen
+ * bestätigten Invarianten, sonst RPN-Bänder:
+ *
+ * ```
+ * s >= 9            → 'High'      // bestätigt
+ * s === 1           → 'Low'       // bestätigt
+ * sonst  rpn > interimRpn → 'High'   // übernimmt die bisherige FM-03-Grenze
+ *        rpn >= 40        → 'Medium'
+ *        sonst            → 'Low'
+ * ```
+ *
+ * Das ist „bestätigtes AP, wo bekannt; RPN, wo nicht" — **nicht geratenes AP**. Die
+ * S-9-10-Klausel entfernt die gefährliche Irrtumsrichtung (hohe Schwere, gutes Detection) und
+ * kostet nichts.
+ *
+ * `interimRpn` ist die Schwelle aus `MetricPolicy.riskRpn` (CR-SM-236) — dieselbe Zahl, die
+ * FM-03 vorher direkt benutzt hat. Sie steht damit weiter an genau einer Stelle.
+ */
+export declare function actionPriority(s: number, o: number, d: number, interimRpn: number, table?: ApTable): ActionPriority;

package/dist/se/action-priority.js

@@ -0,0 +1,124 @@
+/**
+ * CR-SM-229 — Action Priority (AP) ersetzt RPN, ohne die geschützte Tabelle auszuliefern.
+ *
+ * Das AIAG-VDA FMEA Handbook (1st Edition, 2019) hat RPN **ersetzt**, nicht ergänzt. Der Skill
+ * `se-fmea` sagt das in Step 5 wörtlich („Risk Analysis → Action Priority (AP), not RPN"); der
+ * Regelcode folgte ihm bis hierher nicht.
+ *
+ * **RPN irrt gerichtet.** S 10 / O 2 / D 2 ergibt RPN 40 → „niedriges Risiko", während AP dort
+ * immer `High` sagt: ein gutes Detection-Rating rechnet eine sicherheitskritische Schwere weg.
+ * Genau dafür wurde AP eingeführt.
+ *
+ * ## Warum die Tabelle hier nicht steht
+ *
+ * Die normative AP-Tabelle (5 Severity- × 5 Occurrence- × 4 Detection-Bänder = 100 Zellen) steht
+ * ausschließlich im Handbook. Urheberrecht schützt keine Verfahren — **die Methode anzuwenden ist
+ * frei**. Die 100 Zellwerte sind aber normative Wertung (jemand hat entschieden, dass S 7 / O 4 /
+ * D 6 „Medium" ist), keine Fakten; sie in ein publiziertes npm-Paket zu legen wäre die verbotene
+ * Reproduktion.
+ *
+ * Deshalb: **die Logik wird ausgeliefert, die Zellwerte nie.** Eine Funktion, zwei Konsumenten
+ * (FM-03 und der graphcode-Exporter) — kein zweiter Klassifikationspfad. Die Tabelle wandert auch
+ * nicht in den Graphen (SYS-Attribute o. ä.): der Graph wird exportiert und verteilt, das wäre
+ * dieselbe Reproduktion durch die Hintertür.
+ *
+ * > Keine Rechtsberatung. Vor einem kommerziellen Release anwaltlich bestätigen lassen; in DE/EU
+ * > kommt zusätzlich das Datenbankherstellerrecht (§ 87a UrhG) in Betracht.
+ *
+ * ## Offene Fachfrage, hier nicht entschieden
+ *
+ * DFMEA und FMEA-MSR haben verschiedene AP-Tabellen. `ApTableSchema` muss die Variante
+ * mitführen, sobald MSR relevant wird.
+ */
+import { z } from 'zod/v4';
+/** Die drei Stufen des AIAG-VDA-Verfahrens. */
+export const ActionPriority = z.enum(['High', 'Medium', 'Low']);
+/** Ein Rating von 1 bis 10 — die Skala, auf der S, O und D erhoben werden. */
+const RatingSchema = z.number().int().min(1).max(10);
+/**
+ * Ein Band der Tabelle: ein Rating-Bereich und die Zuordnung darunter.
+ *
+ * Die Bandgrenzen selbst sind KEINE geschützte Wertung, sondern die Achsenbeschriftung des
+ * Verfahrens (S 9–10 / 7–8 / 4–6 / 2–3 / 1 usw.). Geschützt ist, welche Stufe in einer Zelle
+ * steht — und genau das steht hier nicht.
+ */
+const BandSchema = z.object({
+    from: RatingSchema,
+    to: RatingSchema,
+}).refine((b) => b.from <= b.to, { message: 'from must be <= to' });
+/**
+ * Form einer AP-Tabelle, **nicht ihr Inhalt**.
+ *
+ * Ein Konsument lädt sie zur Laufzeit aus einer lokalen, nie eingecheckten Datei (z. B.
+ * `.graphcode/ap-table.json`, dort mit `.gitignore`-Eintrag). Das Schema erzwingt, dass sie
+ * vollständig ist: 5 × 5 × 4 Bänder und für jede der 100 Kombinationen eine Stufe. Eine
+ * unvollständige Tabelle wird abgelehnt, statt still auf die Interimslogik zurückzufallen —
+ * ein halb geladenes Urteil ist schlimmer als ein bekanntermaßen ersatzweises.
+ */
+export const ApTableSchema = z.object({
+    severityBands: z.array(BandSchema).length(5),
+    occurrenceBands: z.array(BandSchema).length(5),
+    detectionBands: z.array(BandSchema).length(4),
+    /**
+     * `cells[si][oi][di]` — Index in die drei Bandlisten, Wert ist die Stufe.
+     * 5 × 5 × 4 = 100 Zellen, alle Pflicht.
+     */
+    cells: z.array(z.array(z.array(ActionPriority).length(4)).length(5)).length(5),
+});
+/**
+ * Welches Verfahren die Einstufung gerade trägt.
+ *
+ * Treibt die Kennzeichnung beim Konsumenten (graphcode rendert die AP-Spalte als `AP*` mit
+ * generierter Fußnote, solange `'rpn-interim'` gilt). Hinweis und Berechnung können nicht
+ * auseinanderlaufen, weil beide aus derselben Quelle kommen.
+ */
+export function apMethod(table) {
+    return table ? 'aiag-vda' : 'rpn-interim';
+}
+function bandIndex(bands, rating) {
+    return bands.findIndex((b) => rating >= b.from && rating <= b.to);
+}
+/**
+ * Action Priority für ein S/O/D-Tripel.
+ *
+ * **Mit `table`** gilt die echte Zuordnung des Handbooks.
+ *
+ * **Ohne `table`** gilt der *markierte Übergang* — nur die von allen geprüften Quellen
+ * bestätigten Invarianten, sonst RPN-Bänder:
+ *
+ * ```
+ * s >= 9            → 'High'      // bestätigt
+ * s === 1           → 'Low'       // bestätigt
+ * sonst  rpn > interimRpn → 'High'   // übernimmt die bisherige FM-03-Grenze
+ *        rpn >= 40        → 'Medium'
+ *        sonst            → 'Low'
+ * ```
+ *
+ * Das ist „bestätigtes AP, wo bekannt; RPN, wo nicht" — **nicht geratenes AP**. Die
+ * S-9-10-Klausel entfernt die gefährliche Irrtumsrichtung (hohe Schwere, gutes Detection) und
+ * kostet nichts.
+ *
+ * `interimRpn` ist die Schwelle aus `MetricPolicy.riskRpn` (CR-SM-236) — dieselbe Zahl, die
+ * FM-03 vorher direkt benutzt hat. Sie steht damit weiter an genau einer Stelle.
+ */
+export function actionPriority(s, o, d, interimRpn, table) {
+    if (table) {
+        const si = bandIndex(table.severityBands, s);
+        const oi = bandIndex(table.occurrenceBands, o);
+        const di = bandIndex(table.detectionBands, d);
+        // Ein Rating ausserhalb aller Baender ist ein Datenfehler, kein 'Low'. Der markierte
+        // Uebergang ist die ehrlichere Antwort als eine erfundene Zelle.
+        if (si >= 0 && oi >= 0 && di >= 0)
+            return table.cells[si][oi][di];
+    }
+    if (s >= 9)
+        return 'High';
+    if (s === 1)
+        return 'Low';
+    const rpn = s * o * d;
+    if (rpn > interimRpn)
+        return 'High';
+    if (rpn >= 40)
+        return 'Medium';
+    return 'Low';
+}

package/dist/se/analysis-freshness-rules.d.ts

@@ -14,26 +14,31 @@ export declare const AF_RULES: readonly [{
     readonly name: "ConOps freshness stamp present";
     readonly severity: "warning";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly domain: readonly ["SYS"];
 }, {
     readonly id: "AF-02";
     readonly name: "Trade Study freshness stamp present";
     readonly severity: "warning";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly domain: readonly ["SYS"];
 }, {
     readonly id: "AF-03";
     readonly name: "Assumption Review freshness stamp present";
     readonly severity: "warning";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly domain: readonly ["SYS"];
 }, {
     readonly id: "AF-04";
     readonly name: "FMEA freshness stamp present";
     readonly severity: "warning";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly domain: readonly ["SYS"];
 }, {
     readonly id: "AF-05";
     readonly name: "Implementation Plan freshness stamp present";
     readonly severity: "warning";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly domain: readonly ["SYS"];
 }];
 /** Evaluate all analysis-freshness-presence rules. */
 export declare function evaluateAFRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/analysis-freshness-rules.js

@@ -32,11 +32,11 @@ const assumptionReviewFreshnessPresent = analysisFreshnessPresence('AF-03', 'ass
 const fmeaFreshnessPresent = analysisFreshnessPresence('AF-04', 'fmea');
 const implplanFreshnessPresent = analysisFreshnessPresence('AF-05', 'implplan');
 export const AF_RULES = [
-    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', evaluate: conopsFreshnessPresent },
-    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', evaluate: tradeFreshnessPresent },
-    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', evaluate: assumptionReviewFreshnessPresent },
-    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', evaluate: fmeaFreshnessPresent },
-    { id: 'AF-05', name: 'Implementation Plan freshness stamp present', severity: 'warning', evaluate: implplanFreshnessPresent },
+    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', evaluate: conopsFreshnessPresent, domain: ['SYS'] },
+    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', evaluate: tradeFreshnessPresent, domain: ['SYS'] },
+    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', evaluate: assumptionReviewFreshnessPresent, domain: ['SYS'] },
+    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', evaluate: fmeaFreshnessPresent, domain: ['SYS'] },
+    { id: 'AF-05', name: 'Implementation Plan freshness stamp present', severity: 'warning', evaluate: implplanFreshnessPresent, domain: ['SYS'] },
 ];
 /** Evaluate all analysis-freshness-presence rules. */
 export function evaluateAFRules(graph) {

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

@@ -3,7 +3,8 @@
  * Severity: info (optimization hints [OH], not blocking violations).
  */
 import type { OntologyGraph } from './ontology.js';
-import type { RuleViolation } from './rules.js';
+import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 /**
  * AO-D01: Relay Node Detection.
  * A FUNC is a relay if it (a) satisfies no REQ, (b) has >=2 outgoing io to FUNCs,
@@ -15,45 +16,10 @@ export declare function aoD01RelayNode(graph: OntologyGraph): RuleViolation[];
  * FUNC A sends io to both B and C, where B and C connect to the same SCHEMA elements.
  */
 export declare function aoD03DuplicatePath(graph: OntologyGraph): RuleViolation[];
-export declare function cr01CrossingFlowCount(graph: OntologyGraph): RuleViolation[];
+export declare function cr01CrossingFlowCount(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];
 export declare function rt01PhysicalBoundaryIntegrity(graph: OntologyGraph): RuleViolation[];
 export declare function ph01PhysicalModCompleteness(graph: OntologyGraph): RuleViolation[];
 export declare function ca01CapabilityAllocation(graph: OntologyGraph): RuleViolation[];
 export declare function io01CrossModuleCompleteness(graph: OntologyGraph): RuleViolation[];
-export declare const AO_RULES: readonly [{
-    readonly id: "AO-D01";
-    readonly name: "RelayNodeDetection";
-    readonly severity: "info";
-    readonly evaluate: typeof aoD01RelayNode;
-}, {
-    readonly id: "AO-D03";
-    readonly name: "DuplicatePathDetection";
-    readonly severity: "info";
-    readonly evaluate: typeof aoD03DuplicatePath;
-}, {
-    readonly id: "CR-01";
-    readonly name: "CrossingFlowCount";
-    readonly severity: "warning";
-    readonly evaluate: typeof cr01CrossingFlowCount;
-}, {
-    readonly id: "RT-01";
-    readonly name: "PhysicalBoundaryIntegrity";
-    readonly severity: "error";
-    readonly evaluate: typeof rt01PhysicalBoundaryIntegrity;
-}, {
-    readonly id: "PH-01";
-    readonly name: "PhysicalModCompleteness";
-    readonly severity: "info";
-    readonly evaluate: typeof ph01PhysicalModCompleteness;
-}, {
-    readonly id: "CA-01";
-    readonly name: "CapabilityAllocation";
-    readonly severity: "error";
-    readonly evaluate: typeof ca01CapabilityAllocation;
-}, {
-    readonly id: "IO-01";
-    readonly name: "FuncPairIOCompleteness";
-    readonly severity: "warning";
-    readonly evaluate: typeof io01CrossModuleCompleteness;
-}];
-export declare function evaluateAORules(graph: OntologyGraph): RuleViolation[];
+export declare const AO_RULES: RuleDefinition[];
+export declare function evaluateAORules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/ao-rules.js

@@ -135,9 +135,16 @@ export function aoD03DuplicatePath(graph) {
 // ---------------------------------------------------------------------------
 // CR-01: Crossing Flow Count (CR-191)
 // For each module pair (A, B): count io paths FUNC_A → FUNC_B
+//
+// CR-SM-236: die Schwelle ist Eingabe. `policy.crossingFlows === null` heisst messen statt
+// urteilen — die Regel schweigt dann vollstaendig, auch unterhalb der Schwelle. Vorher gab es
+// diesen Aus-Zustand nicht: jedes Modulpaar mit >= 1 Kreuzung erzeugte eine info-Meldung.
 // ---------------------------------------------------------------------------
-export function cr01CrossingFlowCount(graph) {
+export function cr01CrossingFlowCount(graph, policy) {
     const violations = [];
+    const steps = policy.crossingFlows;
+    if (steps === null)
+        return violations;
     const mods = graph.elements.filter(e => e.type === 'MOD');
     // Build MOD → Set<FUNC-id> mapping
     const modFuncs = new Map();
@@ -168,13 +175,13 @@ export function cr01CrossingFlowCount(graph) {
     for (const { modA, modB, count } of pairCounts.values()) {
         if (count <= 0)
             continue;
-        const severity = count > 2 ? 'warning' : 'info';
+        const over = count >= steps.warning;
         violations.push({
             rule_id: 'CR-01',
-            severity,
+            severity: over ? 'warning' : 'info',
             element_id: modA,
             message: `${modA} ↔ ${modB}: ${count} crossing io flow(s)`,
-            fix_hint: count > 2 ? 'Reduce coupling between modules or introduce a mediator' : 'Consider if coupling is intentional',
+            fix_hint: over ? 'Reduce coupling between modules or introduce a mediator' : 'Consider if coupling is intentional',
         });
     }
     return violations;
@@ -330,14 +337,14 @@ export function io01CrossModuleCompleteness(graph) {
     return violations;
 }
 export const AO_RULES = [
-    { id: 'AO-D01', name: 'RelayNodeDetection', severity: 'info', evaluate: aoD01RelayNode },
-    { id: 'AO-D03', name: 'DuplicatePathDetection', severity: 'info', evaluate: aoD03DuplicatePath },
-    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', evaluate: cr01CrossingFlowCount },
-    { id: 'RT-01', name: 'PhysicalBoundaryIntegrity', severity: 'error', evaluate: rt01PhysicalBoundaryIntegrity },
-    { id: 'PH-01', name: 'PhysicalModCompleteness', severity: 'info', evaluate: ph01PhysicalModCompleteness },
-    { id: 'CA-01', name: 'CapabilityAllocation', severity: 'error', evaluate: ca01CapabilityAllocation },
-    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness },
+    { id: 'AO-D01', name: 'RelayNodeDetection', severity: 'info', evaluate: aoD01RelayNode, domain: ['FUNC'] },
+    { id: 'AO-D03', name: 'DuplicatePathDetection', severity: 'info', evaluate: aoD03DuplicatePath, domain: ['FUNC'] },
+    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
+    { id: 'RT-01', name: 'PhysicalBoundaryIntegrity', severity: 'error', evaluate: rt01PhysicalBoundaryIntegrity, domain: ['FUNC'] },
+    { id: 'PH-01', name: 'PhysicalModCompleteness', severity: 'info', evaluate: ph01PhysicalModCompleteness, domain: ['MOD'] },
+    { id: 'CA-01', name: 'CapabilityAllocation', severity: 'error', evaluate: ca01CapabilityAllocation, domain: ['FUNC'] },
+    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness, domain: ['MOD'] },
 ];
-export function evaluateAORules(graph) {
-    return AO_RULES.flatMap(r => r.evaluate(graph));
+export function evaluateAORules(graph, policy) {
+    return AO_RULES.flatMap(r => r.evaluate(graph, policy));
 }

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

@@ -1,6 +1,6 @@
 /**
  * RC conformance rules (CR-GC-253) — graph↔code resolution, the RESOLUTION
- * twins of the presence rules R-20 (FUNC realRef) / R-19 (testRef).
+ * twins of the presence rules R-20 (FUNC realRef) / R-19 (testRefs).
  *
  * Rules stay in THIS library (one rule base per onto set — no rule definitions
  * in executor codebases). They are pure functions over (graph, facts): all
@@ -8,7 +8,7 @@
  * from the repo), so this module stays I/O-free and browser-bundlable.
  *
  * CodeFacts semantics: `files` is keyed by repo-relative path and MUST contain
- * an entry for every file referenced by a realRef/testRef the extractor saw.
+ * an entry for every file referenced by a realRef/testRefs entry the extractor saw.
  * A MISSING key is treated like `exists:false` — an extractor gap must surface
  * loudly as a violation, never as a silent pass.
  *

package/dist/se/conformance-rules.js

@@ -1,6 +1,6 @@
 /**
  * RC conformance rules (CR-GC-253) — graph↔code resolution, the RESOLUTION
- * twins of the presence rules R-20 (FUNC realRef) / R-19 (testRef).
+ * twins of the presence rules R-20 (FUNC realRef) / R-19 (testRefs).
  *
  * Rules stay in THIS library (one rule base per onto set — no rule definitions
  * in executor codebases). They are pure functions over (graph, facts): all
@@ -8,14 +8,14 @@
  * from the repo), so this module stays I/O-free and browser-bundlable.
  *
  * CodeFacts semantics: `files` is keyed by repo-relative path and MUST contain
- * an entry for every file referenced by a realRef/testRef the extractor saw.
+ * an entry for every file referenced by a realRef/testRefs entry the extractor saw.
  * A MISSING key is treated like `exists:false` — an extractor gap must surface
  * loudly as a violation, never as a silent pass.
  *
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { RealRefSchema, TestRefSchema } from './ontology.js';
+import { RealRefSchema, TestRefsSchema } from './ontology.js';
 /** Parser facts about one source file (extracted by the executor). */
 export const FileFactsSchema = z.object({
     /** File exists on disk (repo-relative path). */
@@ -92,8 +92,13 @@ function codeRefMustResolve(graph, facts) {
     }
     return violations;
 }
-// RC-02: every valid testRef must resolve — file on disk and, when `case` is
+// RC-02: every valid testRefs entry must resolve — file on disk and, when `case` is
 // set, the case name declared as an it/test/describe in that file.
+//
+// CR-SM-231: iteriert die Eintraege. Ein TEST mit zwei Dateien, von denen eine fehlt, ist
+// **ein** Befund an **einer** Adresse — die Meldung nennt deshalb den konkreten Pfad und
+// nicht nur die Knoten-ID. Ohne das waere „TEST-x hat eine kaputte Bindung" bei n Dateien
+// nicht handhabbar.
 function testRefMustResolve(graph, facts) {
     const violations = [];
     for (const el of graph.elements) {
@@ -101,33 +106,34 @@ function testRefMustResolve(graph, facts) {
             continue;
         if (el.attributes?.concept === true)
             continue;
-        const parsed = TestRefSchema.safeParse(el.attributes?.testRef);
+        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
         if (!parsed.success)
             continue; // no/invalid binding → R-19 territory
-        const ref = parsed.data;
-        if (missingFile(facts, ref.file)) {
-            violations.push({
-                rule_id: 'RC-02',
-                severity: 'error',
-                element_id: el.id,
-                message: `${el.id} testRef.file '${ref.file}' does not exist on disk`,
-                fix_hint: 'The test file was moved or deleted — rebind the TEST (graph_realize) to the current file',
-                context: { element_type: el.type, element_name: el.name },
-            });
-            continue;
-        }
-        // `case` is a name FILTER (vitest -t semantics): it matches by substring,
-        // so it must occur within some declared it/test/describe name — not equal it.
-        const caseName = ref.case;
-        if (caseName !== undefined && !facts.files[ref.file].testCases.some((name) => name.includes(caseName))) {
-            violations.push({
-                rule_id: 'RC-02',
-                severity: 'error',
-                element_id: el.id,
-                message: `${el.id} testRef.case '${ref.case}' is not declared in '${ref.file}'`,
-                fix_hint: 'The test case was renamed or removed — rebind the TEST case name',
-                context: { element_type: el.type, element_name: el.name },
-            });
+        for (const ref of parsed.data) {
+            if (missingFile(facts, ref.file)) {
+                violations.push({
+                    rule_id: 'RC-02',
+                    severity: 'error',
+                    element_id: el.id,
+                    message: `${el.id} testRefs entry file '${ref.file}' does not exist on disk`,
+                    fix_hint: 'The test file was moved or deleted — rebind the TEST (graph_realize) to the current file, or drop the entry',
+                    context: { element_type: el.type, element_name: el.name },
+                });
+                continue;
+            }
+            // `case` is a name FILTER (vitest -t semantics): it matches by substring,
+            // so it must occur within some declared it/test/describe name — not equal it.
+            const caseName = ref.case;
+            if (caseName !== undefined && !facts.files[ref.file].testCases.some((name) => name.includes(caseName))) {
+                violations.push({
+                    rule_id: 'RC-02',
+                    severity: 'error',
+                    element_id: el.id,
+                    message: `${el.id} testRefs entry case '${ref.case}' is not declared in '${ref.file}'`,
+                    fix_hint: 'The test case was renamed or removed — rebind the TEST case name',
+                    context: { element_type: el.type, element_name: el.name },
+                });
+            }
         }
     }
     return violations;
@@ -356,7 +362,7 @@ function importDriftConformance(graph, facts) {
 /** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
 export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-01', name: 'FUNC realRef resolves to a declared symbol', severity: 'error', evaluate: codeRefMustResolve },
-    { id: 'RC-02', name: 'testRef resolves to a runnable test', severity: 'error', evaluate: testRefMustResolve },
+    { id: 'RC-02', name: 'testRefs entries resolve to runnable tests', severity: 'error', evaluate: testRefMustResolve },
     { id: 'RC-03', name: 'SCHEMA realRef resolves to a declared export', severity: 'error', evaluate: schemaRefMustResolve },
     { id: 'RC-04', name: 'SCHEMA realRef is parsed at its interface', severity: 'warning', evaluate: schemaRefMustBeUsed },
     { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', evaluate: importDriftConformance },

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

@@ -4,5 +4,6 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare const CR_RULES: RuleDefinition[];
-export declare function evaluateCRRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateCRRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/cr-quality-rules.js

@@ -130,12 +130,14 @@ function crShouldHaveMilestone(graph) {
 // Exports
 // ---------------------------------------------------------------------------
 export const CR_RULES = [
-    { id: 'CR-R01', name: 'CR must track', severity: 'error', evaluate: crMustTrack },
-    { id: 'CR-R02', name: 'Done requires commit', severity: 'error', evaluate: crDoneRequiresCommit },
-    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation },
-    { id: 'CR-R04', name: 'CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc },
-    { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone },
+    { id: 'CR-R01', name: 'CR must track', severity: 'error', evaluate: crMustTrack, domain: ['CR'] },
+    { id: 'CR-R02', name: 'Done requires commit', severity: 'error', evaluate: crDoneRequiresCommit, domain: ['CR'] },
+    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation, domain: ['CR'] },
+    { id: 'CR-R04', name: 'CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc, domain: ['CR'] },
+    { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone, domain: ['CR'] },
 ];
-export function evaluateCRRules(graph) {
-    return CR_RULES.flatMap(rule => rule.evaluate(graph));
+// CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
+// ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.
+export function evaluateCRRules(graph, policy) {
+    return CR_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

package/dist/se/evaluate-all.d.ts

@@ -4,14 +4,29 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation } from './rules.js';
-/** All prescribed rule definitions (single source of truth for the catalog). */
+import type { MetricPolicy } from './policy.js';
+/**
+ * All prescribed rule definitions (single source of truth for the catalog).
+ *
+ * CR-SM-235: `domain` reicht mit durch — die Grundgesamtheit, ueber die eine Regel feuert.
+ * Konsumenten, die einen Anteil bilden (`se-steering`s `computeApplicable`), lesen den Nenner
+ * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
+ * wenn es keine zweite gibt.
+ */
 export declare const ALL_RULE_DEFS: ReadonlyArray<{
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
+    domain: readonly string[];
 }>;
 /** Profile groupings derived from rule prefixes. */
 export type ProfileId = 'default' | 'se' | 'coding';
 export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RULE_DEFS;
-/** Evaluate all rules against a graph. Single call replaces the individual evaluator calls. */
-export declare function evaluateAllRules(graph: OntologyGraph): RuleViolation[];
+/**
+ * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.
+ *
+ * CR-SM-233: `policy` ist **Pflicht und ohne Fallback** — ein Aufruf ohne Policy ist ein
+ * Typfehler, keine stille 0.7. Wer keine eigene Quelle hat (Konfiguration, Host), nimmt
+ * `DEFAULT_METRIC_POLICY` sichtbar an der Aufrufstelle.
+ */
+export declare function evaluateAllRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];