@sigloch/contracts 3.2.0 → 4.0.0

package/dist/se/policy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CR-SM-233: Urteilsschwellen der Architektur-Metriken als Eingabe, nicht als Modulkonstante.
+ *
+ * Vorher stand die Schwelle als `const INSTABILITY_THRESHOLD = 0.7` in `metric-rules.ts`.
+ * Jede Konfigurierbarkeit von außen wäre damit automatisch ein zweiter Pfad gewesen
+ * (Config-Wert neben Code-Default) — und ein stillgelegter Wert hätte still weiterurteilt,
+ * weil der Default einspringt. Deshalb: Parameter ohne Fallback.
+ */
+import { z } from 'zod';
+/**
+ * Urteilsschwellen der Architektur-Metriken. `null` = messen, nicht urteilen.
+ *
+ * `null` ist ein erstklassiger Wert, kein „aus": die Kennzahl wird weiter gerechnet,
+ * exportiert und angezeigt; es entsteht nur kein Verstoß. Das ist die MT-03-Entscheidung
+ * (CR-SM-223) verallgemeinert — der Weg, einen unvalidierten Wert stillzulegen, ohne die
+ * Zahl zu verlieren.
+ */
+export declare const MetricPolicySchema: z.ZodObject<{
+    instability: z.ZodNullable<z.ZodNumber>;
+    lcom4: z.ZodNullable<z.ZodObject<{
+        info: z.ZodNumber;
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
+    crossingFlows: z.ZodNullable<z.ZodObject<{
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
+    riskRpn: z.ZodNullable<z.ZodNumber>;
+    apTable: z.ZodNullable<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>>;
+    moduleSize: z.ZodNullable<z.ZodObject<{
+        large: z.ZodNumber;
+        coupled: z.ZodNumber;
+        crossings: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MetricPolicy = z.infer<typeof MetricPolicySchema>;
+/**
+ * Der Startwert, sichtbar als solcher — **kein** Fallback in der Regel.
+ *
+ * Ein Aufrufer nimmt ihn bewusst oder ersetzt ihn; er steht an genau einer Stelle und ist
+ * grep-bar. Die Werte sind die bisherigen (0.7 / 4 / 6-statt-5-Grenze siehe unten) und
+ * ausdrücklich **unvalidiert** (CR-SM-223: „Validation … is deferred") — sie sind gesetzt,
+ * nicht gemessen.
+ *
+ * `lcom4.warning = 6` ist die unveränderte Alt-Semantik: vorher `>= 4 && <= 5` → info,
+ * `> 5` → warning, also warning ab 6.
+ */
+export declare const DEFAULT_METRIC_POLICY: MetricPolicy;

package/dist/se/policy.js

@@ -0,0 +1,100 @@
+/**
+ * CR-SM-233: Urteilsschwellen der Architektur-Metriken als Eingabe, nicht als Modulkonstante.
+ *
+ * Vorher stand die Schwelle als `const INSTABILITY_THRESHOLD = 0.7` in `metric-rules.ts`.
+ * Jede Konfigurierbarkeit von außen wäre damit automatisch ein zweiter Pfad gewesen
+ * (Config-Wert neben Code-Default) — und ein stillgelegter Wert hätte still weiterurteilt,
+ * weil der Default einspringt. Deshalb: Parameter ohne Fallback.
+ */
+import { z } from 'zod';
+import { ApTableSchema } from './action-priority.js';
+/**
+ * Urteilsschwellen der Architektur-Metriken. `null` = messen, nicht urteilen.
+ *
+ * `null` ist ein erstklassiger Wert, kein „aus": die Kennzahl wird weiter gerechnet,
+ * exportiert und angezeigt; es entsteht nur kein Verstoß. Das ist die MT-03-Entscheidung
+ * (CR-SM-223) verallgemeinert — der Weg, einen unvalidierten Wert stillzulegen, ohne die
+ * Zahl zu verlieren.
+ */
+export const MetricPolicySchema = z.object({
+    /** MT-01: Instabilität, ab der gewarnt wird (exklusiv). null → MT-01 feuert nie. */
+    instability: z.number().min(0).max(1).nullable(),
+    /** MT-02: LCOM4-Stufen (info ab, warning ab). null → MT-02 feuert nie. */
+    lcom4: z
+        .object({
+        info: z.number().int().min(2),
+        warning: z.number().int().min(2),
+    })
+        .nullable(),
+    /**
+     * CR-01: kreuzende io-Flows je Modulpaar, ab denen gewarnt wird (inklusiv).
+     *
+     * `null` → CR-01 meldet **nichts**, auch keine info. Das ist der Aus-Zustand, den die Regel
+     * vorher nicht hatte: sie meldete je Modulpaar mit ≥ 1 Kreuzung, und diese info-Fälle zählen
+     * in die `arch`-Dimension ein (CR-SM-236).
+     */
+    crossingFlows: 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.
+     *
+     * 100 ist Domänenstandard, aber skalenabhängig: bei anderer Belegung von S/O/D ist es die
+     * falsche Grenze.
+     */
+    riskRpn: z.number().int().positive().nullable(),
+    /**
+     * CR-SM-229: die lizenzierte AIAG-VDA-Tabelle, wenn der Host eine hat.
+     *
+     * Sie reist im Policy-Objekt mit, **nicht** in einem zweiten Kontext-Parameter: seit
+     * CR-SM-233 ist `policy` der eine Kanal, über den eine Regel ihre Urteilsgrundlage bekommt.
+     * Ein zweiter daneben wäre genau der parallele Pfad, den der Regelsatz verbietet.
+     *
+     * `null` → der markierte Übergang gilt (bestätigte AP-Invarianten, sonst RPN-Bänder). Der
+     * Konsument lädt die Tabelle aus einer lokalen, nie eingecheckten Datei; **im Repo und im
+     * exportierten Graphen steht sie nie** (Zellwerte sind normative Wertung, keine Fakten).
+     */
+    apTable: ApTableSchema.nullable(),
+    /**
+     * R-04: Modulgröße **gegen** Kreuzungen — die Regel wägt beides ab, ihr alter Name
+     * („Max module size") gab das nicht her. null → R-04 feuert nie.
+     *
+     * Drei Werte, weil die Regel drei Urteile fällt. Ein einzelner Schwellwert hätte zwei davon
+     * im Code gelassen — genau der Zustand, den dieser CR beseitigt.
+     */
+    moduleSize: z
+        .object({
+        /** > `large` FUNCs: mit Kreuzungen warning, ohne Kreuzungen info („kohäsiv, nur groß"). */
+        large: z.number().int().min(1),
+        /** > `coupled` FUNCs ist die Untergrenze, ab der die Regel überhaupt hinsieht. */
+        coupled: z.number().int().min(1),
+        /** Kreuzungen, ab denen ein nur `coupled`-großes Modul warnt (exklusiv). */
+        crossings: z.number().int().min(0),
+    })
+        .nullable(),
+});
+/**
+ * Der Startwert, sichtbar als solcher — **kein** Fallback in der Regel.
+ *
+ * Ein Aufrufer nimmt ihn bewusst oder ersetzt ihn; er steht an genau einer Stelle und ist
+ * grep-bar. Die Werte sind die bisherigen (0.7 / 4 / 6-statt-5-Grenze siehe unten) und
+ * ausdrücklich **unvalidiert** (CR-SM-223: „Validation … is deferred") — sie sind gesetzt,
+ * nicht gemessen.
+ *
+ * `lcom4.warning = 6` ist die unveränderte Alt-Semantik: vorher `>= 4 && <= 5` → info,
+ * `> 5` → warning, also warning ab 6.
+ */
+export const DEFAULT_METRIC_POLICY = {
+    instability: 0.7,
+    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 },
+    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-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.
+    apTable: null,
+};

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

@@ -5,6 +5,7 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function bq01Unambiguous(graph: OntologyGraph): RuleViolation[];
 export declare function bq02Verifiable(graph: OntologyGraph): RuleViolation[];
 /**
@@ -25,4 +26,4 @@ export declare function bq06Conforming(graph: OntologyGraph): RuleViolation[];
 export declare function bq07Complete(graph: OntologyGraph): RuleViolation[];
 export declare const BQ_RULES: RuleDefinition[];
 /** Run all BQ rules against a graph, returning combined violations. */
-export declare function evaluateBQRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateBQRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/quality-rules.js

@@ -194,13 +194,15 @@ export function bq07Complete(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const BQ_RULES = [
-    { id: 'BQ-01', name: 'Unambiguous', severity: 'warning', evaluate: bq01Unambiguous },
-    { id: 'BQ-02', name: 'Verifiable', severity: 'warning', evaluate: bq02Verifiable },
-    { id: 'BQ-04', name: 'Necessary', severity: 'warning', evaluate: bq04Necessary },
-    { id: 'BQ-06', name: 'Conforming', severity: 'warning', evaluate: bq06Conforming },
-    { id: 'BQ-07', name: 'Complete', severity: 'warning', evaluate: bq07Complete },
+    { id: 'BQ-01', name: 'Unambiguous', severity: 'warning', evaluate: bq01Unambiguous, domain: ['REQ'] },
+    { id: 'BQ-02', name: 'Verifiable', severity: 'warning', evaluate: bq02Verifiable, domain: ['REQ'] },
+    { id: 'BQ-04', name: 'Necessary', severity: 'warning', evaluate: bq04Necessary, domain: ['REQ'] },
+    { id: 'BQ-06', name: 'Conforming', severity: 'warning', evaluate: bq06Conforming, domain: ['REQ'] },
+    { id: 'BQ-07', name: 'Complete', severity: 'warning', evaluate: bq07Complete, domain: ['REQ'] },
 ];
 /** Run all BQ rules against a graph, returning combined violations. */
-export function evaluateBQRules(graph) {
-    return BQ_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 evaluateBQRules(graph, policy) {
+    return BQ_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

package/dist/se/readiness.d.ts

@@ -36,6 +36,15 @@ export declare const ReadinessScore: z.ZodObject<{
     ready: z.ZodBoolean;
 }, z.core.$strip>;
 export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
+/**
+ * CR-SM-237: `overallScore` ist weg. Es war das **ungewichtete** Mittel der acht
+ * Dimensions-Scores — `ms` (3 Regeln) zählte so viel wie `arch` (~20 Regeln über Hunderte
+ * Elemente), die Zahl bewegte sich also mit dem Größenverhältnis der Dimensionen und nicht mit
+ * dem Zustand des Modells. Gelesen hat sie ohnehin niemand: der einzige Zugriff in der Familie
+ * war eine Formprüfung (`'overallScore' in x`) im inzwischen gelöschten `weight-vector.ts`.
+ * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
+ * Konsumenten hat — nicht auf Vorrat.
+ */
 export declare const ReadinessReport: z.ZodObject<{
     scores: z.ZodArray<z.ZodObject<{
         dimension: z.ZodEnum<{
@@ -53,7 +62,6 @@ export declare const ReadinessReport: z.ZodObject<{
         applicable: z.ZodNumber;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
-    overallScore: z.ZodNumber;
     timestamp: z.ZodISODateTime;
 }, z.core.$strip>;
 export type ReadinessReportType = z.infer<typeof ReadinessReport>;

package/dist/se/readiness.js

@@ -23,11 +23,21 @@ export const ReadinessScore = z.object({
     score: z.number().min(0).max(1), // 1 - (violations / applicable)
     violations: z.number().int(),
     applicable: z.number().int(),
-    ready: z.boolean(), // score >= 0.7
+    // 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.
+    ready: z.boolean(),
 });
+/**
+ * CR-SM-237: `overallScore` ist weg. Es war das **ungewichtete** Mittel der acht
+ * Dimensions-Scores — `ms` (3 Regeln) zählte so viel wie `arch` (~20 Regeln über Hunderte
+ * Elemente), die Zahl bewegte sich also mit dem Größenverhältnis der Dimensionen und nicht mit
+ * dem Zustand des Modells. Gelesen hat sie ohnehin niemand: der einzige Zugriff in der Familie
+ * war eine Formprüfung (`'overallScore' in x`) im inzwischen gelöschten `weight-vector.ts`.
+ * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
+ * Konsumenten hat — nicht auf Vorrat.
+ */
 export const ReadinessReport = z.object({
     scores: z.array(ReadinessScore),
-    overallScore: z.number().min(0).max(1),
     timestamp: z.iso.datetime(),
 });
 /**
@@ -44,6 +54,9 @@ export const RULE_TO_DIMENSION = {
     'RD-04': 'arch',
     // trace/realization/allocation completeness rules (CR-228 D: previously unmapped → advisory fall-through)
     'R-18': 'arch', 'R-19': 'ver', 'R-20': 'arch', 'R-21': 'ver',
+    // 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-SM-226: R-28 Ebenen-Präsenz (>1 FUNC needs FLOW+SCHEMA) is an architecture rule.
     'R-28': 'arch',
@@ -148,6 +161,9 @@ export const RULE_TO_PHASE = {
     'NFR-01': 'CDR',
     // TRR — test readiness.
     'R-01': 'TRR', 'R-05': 'TRR', 'R-19': 'TRR', 'R-20': 'TRR', 'R-21': 'TRR',
+    // CR-SM-231: eine doppelt beanspruchte Testdatei laesst den TRR-Gate dieselbe Evidenz
+    // doppelt zaehlen — der Befund gehoert genau an dieses Gate.
+    'R-29': 'TRR',
     'VR-01': 'TRR',
     'FM-03': 'TRR',
     'CR-R02': 'TRR',

package/dist/se/rules.d.ts

@@ -5,10 +5,11 @@
  */
 import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
+import type { MetricPolicy } from './policy.js';
 export declare const RuleSeverity: z.ZodEnum<{
     error: "error";
-    warning: "warning";
     info: "info";
+    warning: "warning";
 }>;
 export type RuleSeverity = z.infer<typeof RuleSeverity>;
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
@@ -89,8 +90,8 @@ export declare const RuleViolation: z.ZodObject<{
     rule_id: z.ZodString;
     severity: z.ZodEnum<{
         error: "error";
-        warning: "warning";
         info: "info";
+        warning: "warning";
     }>;
     element_id: z.ZodString;
     message: z.ZodString;
@@ -152,8 +153,27 @@ export interface RuleDefinition {
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
-    evaluate: (graph: OntologyGraph) => RuleViolation[];
+    /**
+     * CR-SM-236: `policy` steht jeder Regel zur Verfuegung, damit eine Urteilsschwelle nirgends
+     * als Literal im Regelcode zurueckbleibt. Regeln ohne Schwelle deklarieren den Parameter
+     * schlicht nicht — eine einstellige Funktion bleibt zuweisbar.
+     */
+    evaluate: (graph: OntologyGraph, policy: MetricPolicy) => RuleViolation[];
+    /**
+     * CR-SM-235: die Grundgesamtheit, ueber die die Regel feuert — der Nenner ihres
+     * Readiness-Anteils. **Der Elementtyp, ueber den sie feuert, nicht das Thema, dem sie
+     * gehoert:** MS-03 („CR ohne Milestone") feuert je CR, nicht je MS.
+     *
+     * Pflichtfeld, damit ein neuer Regeleintrag ohne Grundgesamtheit den Build bricht. Vorher
+     * lag die Zuordnung als Handtabelle in einem anderen Paket (`se-steering`), 18 von 71 Regeln
+     * fehlten dort — sie erhoehten den Zaehler, nie den Nenner, und jede neue Regel senkte den
+     * Score automatisch, bis jemand die zweite Tabelle nachzog.
+     *
+     * Mehrere Typen, wo die Regel ueber mehrere feuert (RD-04: FUNC, MOD und SYS als Eltern
+     * einer Zerlegung). `['all']` = jedes Nicht-SESSION-Element (R-08/R-18 pruefen Traces).
+     */
+    domain: readonly string[];
 }
 export declare const V3_RULES: RuleDefinition[];
-/** Run all rules against a graph */
-export declare function evaluateRules(graph: OntologyGraph): RuleViolation[];
+/** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
+export declare function evaluateRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/rules.js

@@ -4,7 +4,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { ElementType, TraceType, TestRefSchema, RealRefSchema } from './ontology.js';
+import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
 import { isValidTrace } from './meta-model.js';
 export const RuleSeverity = z.enum(['error', 'warning', 'info']);
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
@@ -168,16 +168,26 @@ function asilIsolation(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
-// R-04: Max module size
+// R-04: Modulgroesse GEGEN Kreuzungen (nicht „max module size")
+//
+// CR-SM-236: die Regel waegt Groesse gegen kreuzende io-Flows ab — ein grosses Modul ohne
+// Kreuzungen ist info („kohaesiv, nur gross"), dasselbe Modul mit Kreuzungen ist warning.
+// Der alte Name gab das nicht her, und die drei Schwellen (8/12/2) standen inline: eine
+// Urteilsschwelle, die sich weder per grep noch aus dem Regelnamen ablesen laesst, ist nicht
+// ueberpruefbar. Jetzt sind es `policy.moduleSize.{coupled,large,crossings}`.
+// `null` → messen, nicht urteilen: die Regel schweigt.
 // ---------------------------------------------------------------------------
-function maxModuleSize(graph) {
-    const modules = graph.elements.filter(e => e.type === 'MOD');
+function maxModuleSize(graph, policy) {
     const violations = [];
+    const steps = policy.moduleSize;
+    if (steps === null)
+        return violations;
+    const modules = graph.elements.filter(e => e.type === 'MOD');
     for (const mod of modules) {
         const allocatedIds = graph.traces.filter(t => t.target === mod.id && t.type === 'allocate').map(t => t.source);
         const allocated = allocatedIds.map(id => graph.elements.find(e => e.id === id)).filter((e) => !!e);
         const funcCount = allocated.length;
-        if (funcCount <= 8)
+        if (funcCount <= steps.coupled)
             continue;
         // Count crossing flows: io paths from FUNCs in this module to FUNCs in other modules
         const funcIds = new Set(allocatedIds);
@@ -188,27 +198,27 @@ function maxModuleSize(graph) {
             const tgtIn = funcIds.has(t.target);
             return (srcIn && !tgtIn) || (!srcIn && tgtIn);
         }).length;
-        if (funcCount > 12 && crossings === 0) {
+        if (funcCount > steps.large && crossings === 0) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'info',
                 element_id: mod.id,
                 message: `${mod.id} has ${funcCount} functions but 0 crossings (cohesive, just large)`,
-                fix_hint: 'Consider splitting if complexity grows',
+                fix_hint: `Size alone is not the finding: > ${steps.large} functions without crossing flows is cohesive. Split only if crossings appear`,
                 context: { element_type: mod.type, element_name: mod.name, candidate_targets: toCandidates(allocated) },
             });
         }
-        else if (funcCount > 12 && crossings > 0) {
+        else if (funcCount > steps.large && crossings > 0) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'warning',
                 element_id: mod.id,
                 message: `${mod.id} has ${funcCount} functions and ${crossings} crossing flows (split recommended)`,
-                fix_hint: 'Split module into smaller units to reduce coupling',
+                fix_hint: `Split module into smaller units to reduce coupling (> ${steps.large} functions AND crossing flows)`,
                 context: { element_type: mod.type, element_name: mod.name, candidate_targets: toCandidates(allocated) },
             });
         }
-        else if (funcCount > 8 && crossings > 2) {
+        else if (funcCount > steps.coupled && crossings > steps.crossings) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'warning',
@@ -439,7 +449,7 @@ function decompositionBreadth(graph) {
     const byId = new Map(graph.elements.map(e => [e.id, e]));
     const counts = new Map();
     const bump = (parentId, kind) => {
-        const key = `${parentId}${kind}`;
+        const key = `${parentId}\u0000${kind}`;
         const entry = counts.get(key);
         if (entry)
             entry.n++;
@@ -621,11 +631,11 @@ function validTracePattern(graph) {
 }
 // ---------------------------------------------------------------------------
 // R-19: Runnable TEST binding (CR-GC-205 Item 4) — a TEST that is not explicitly
-// concept-only (attributes.concept === true) should carry a valid testRef runnable
+// concept-only (attributes.concept === true) should carry a valid testRefs runnable
 // binding so the deduced selective test set is trustworthy. WARNING (a completeness
 // signal like R-05, not a hard gate): a freshly-spec'd TEST is legitimately concept-
 // level until implemented, and the no-phantom-file guarantee is enforced separately
-// by the consumer's export materialization (every testRef.file is scaffolded). File
+// by the consumer's export materialization (every testRefs entry file is scaffolded). File
 // EXISTENCE is out of scope here (rules are pure, no I/O); this guards presence/shape
 // only and surfaces an unbound runnable TEST in rules_evaluate / readiness.
 // ---------------------------------------------------------------------------
@@ -633,17 +643,71 @@ function testMustHaveRunnableBinding(graph) {
     return graph.elements
         .filter(e => e.type === 'TEST')
         .filter(e => e.attributes?.concept !== true) // concept-only TESTs are exempt
-        .filter(e => !TestRefSchema.safeParse(e.attributes?.testRef).success)
+        // CR-SM-231: `testRefs` (Array, min 1) statt `testRef` (Objekt). Semantik unveraendert —
+        // Praesenz und Form, keine Datei-Existenz; die pruefst RC-02.
+        .filter(e => !TestRefsSchema.safeParse(e.attributes?.testRefs).success)
         .map(test => ({
         rule_id: 'R-19',
         severity: 'warning',
         element_id: test.id,
-        message: `${test.id} is a runnable TEST without a valid testRef binding`,
-        fix_hint: 'Add attributes.testRef {file, case?, tool, level?}, or set attributes.concept:true if it has no run artifact yet',
+        message: `${test.id} is a runnable TEST without a valid testRefs binding`,
+        fix_hint: 'Add attributes.testRefs [{file, case?, tool, level?}, …] with at least one entry, or set attributes.concept:true if it has no run artifact yet',
         context: { element_type: test.type, element_name: test.name },
     }));
 }
 // ---------------------------------------------------------------------------
+// R-29: Testdatei-Exklusivitaet (CR-SM-231)
+//
+// Jede Testdatei erscheint in hoechstens einem `testRefs`. Das ist die Haelfte, die 1:n
+// **erzwingt** statt es nur zu erlauben — ohne sie driftet das Attribut zurueck nach n:m,
+// und genau das war der belegte Ist-Zustand: dieselbe Spec-Datei stand im `testRef` zweier
+// TEST-Knoten. Folge: ein roter Lauf ist keiner Abnahme mehr eindeutig zuordenbar, und der
+// TRR-Gate zaehlt dieselbe Evidenz doppelt.
+//
+// `error`, nicht `warning` (Entscheid 2026-08-13): eine doppelt beanspruchte Datei macht
+// Gate-Zahlen nachweislich falsch. Das ist eine Fehlmessung, kein Vollstaendigkeits-Signal —
+// und damit eine andere Klasse als R-19/R-20, die beide `warning` sind.
+//
+// Rein graph-strukturell, kein I/O: die Datei muss nicht existieren, um doppelt beansprucht
+// zu sein.
+// ---------------------------------------------------------------------------
+function testFileExclusivity(graph) {
+    const claimedBy = new Map();
+    for (const el of graph.elements) {
+        if (el.type !== 'TEST')
+            continue;
+        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
+        if (!parsed.success)
+            continue; // keine/ungueltige Bindung → R-19-Gebiet
+        // Innerhalb EINES Knotens ist dieselbe Datei zweimal kein Konflikt, sondern eine
+        // Redundanz — sie wuerde sonst als Selbstkollision gemeldet.
+        for (const file of new Set(parsed.data.map(r => r.file))) {
+            const owners = claimedBy.get(file) ?? [];
+            owners.push(el.id);
+            claimedBy.set(file, owners);
+        }
+    }
+    const violations = [];
+    for (const [file, owners] of claimedBy) {
+        if (owners.length < 2)
+            continue;
+        const sorted = [...owners].sort();
+        // Einmal je beanspruchendem Knoten: jeder von ihnen muss handeln, und eine Meldung an
+        // nur einem waere fuer die anderen unsichtbar.
+        for (const owner of sorted) {
+            violations.push({
+                rule_id: 'R-29',
+                severity: 'error',
+                element_id: owner,
+                message: `${owner} claims test file '${file}', which is also claimed by ${sorted.filter(o => o !== owner).join(', ')}`,
+                fix_hint: 'A test file belongs to at most one TEST. Split the file, or drop the entry from all but the one acceptance it really evidences',
+                context: { element_type: 'TEST', element_name: graph.elements.find(e => e.id === owner)?.name },
+            });
+        }
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
 // R-20: FUNC realRef binding (CR-GC-205 Item 5, extended by CR-210, unified CR-228)
 // — a FUNC that is not explicitly concept-only (attributes.concept === true) or
 // externally realized (attributes.external === true) counts as BOUND when it EITHER
@@ -876,7 +940,7 @@ function modMustHaveAllocatedFunc(graph) {
 // so its Zod definition is machine-resolvable (RC-03 then checks it resolves, RC-04
 // that it is parsed at the interface). WARNING, not error: currently-unbound SCHEMAs
 // on the reference model must not turn readiness red before any binding exists — the
-// presence signal mirrors R-20 (FUNC realRef) / R-19 (testRef). Symbol RESOLUTION is
+// presence signal mirrors R-20 (FUNC realRef) / R-19 (testRefs). Symbol RESOLUTION is
 // out of scope here (pure, no I/O — that is RC-03's job).
 // ---------------------------------------------------------------------------
 function schemaMustHaveSchemaRef(graph) {
@@ -953,35 +1017,36 @@ function ebenenPraesenz(graph) {
         }];
 }
 export const V3_RULES = [
-    { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification },
-    { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq },
-    { id: 'R-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation },
-    { id: 'R-04', name: 'Max module size', severity: 'warning', evaluate: maxModuleSize },
-    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq },
-    { id: 'R-14', name: 'UC must have compose', severity: 'warning', evaluate: ucMustHaveCompose },
-    { id: 'R-15', name: 'FCHAIN must have compose', severity: 'warning', evaluate: fchainMustHaveCompose },
-    { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace },
-    { id: 'R-17', name: 'SYS must have compose', severity: 'warning', evaluate: sysMustHaveCompose },
-    { id: 'R-08', name: 'Trace consistency', severity: 'error', evaluate: traceConsistency },
-    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness },
-    { id: 'R-12', name: 'No circular dependencies', severity: 'warning', evaluate: noDirectCircular },
-    { id: 'R-18', name: 'Valid trace pattern', severity: 'error', evaluate: validTracePattern },
-    { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding },
-    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding },
-    { id: 'R-21', name: 'FUNC↔FUNC connection needs integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest },
-    { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated },
-    { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc },
-    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef },
-    { id: 'R-27', name: 'Physical MOD must have realRef', severity: 'warning', evaluate: physicalModMustHaveRealRef },
-    { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement },
-    { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency },
-    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition },
-    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth },
-    { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope },
-    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency },
-    { id: 'R-28', name: 'Ebenen-Präsenz (FLOW+SCHEMA when funcCount>1)', severity: 'warning', evaluate: ebenenPraesenz },
+    { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification, domain: ['REQ'] },
+    { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq, domain: ['FUNC'] },
+    { id: 'R-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation, domain: ['FUNC'] },
+    { id: 'R-04', name: 'Module size relative to crossing flows', severity: 'warning', evaluate: maxModuleSize, domain: ['MOD'] },
+    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq, domain: ['TEST'] },
+    { id: 'R-14', name: 'UC must have compose', severity: 'warning', evaluate: ucMustHaveCompose, domain: ['UC'] },
+    { id: 'R-15', name: 'FCHAIN must have compose', severity: 'warning', evaluate: fchainMustHaveCompose, domain: ['FCHAIN'] },
+    { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace, domain: ['ACTOR'] },
+    { id: 'R-17', name: 'SYS must have compose', severity: 'warning', evaluate: sysMustHaveCompose, domain: ['SYS'] },
+    { id: 'R-08', name: 'Trace consistency', severity: 'error', evaluate: traceConsistency, domain: ['all'] },
+    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness, domain: ['FUNC'] },
+    { id: 'R-12', name: 'No circular dependencies', severity: 'warning', evaluate: noDirectCircular, domain: ['FUNC'] },
+    { id: 'R-18', name: 'Valid trace pattern', severity: 'error', evaluate: validTracePattern, domain: ['all'] },
+    { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding, domain: ['TEST'] },
+    { id: 'R-29', name: 'Test file exclusivity', severity: 'error', evaluate: testFileExclusivity, domain: ['TEST'] },
+    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding, domain: ['FUNC'] },
+    { id: 'R-21', name: 'FUNC↔FUNC connection needs integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN'] },
+    { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated, domain: ['FUNC'] },
+    { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc, domain: ['MOD'] },
+    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef, domain: ['SCHEMA'] },
+    { id: 'R-27', name: 'Physical MOD must have realRef', severity: 'warning', evaluate: physicalModMustHaveRealRef, domain: ['MOD'] },
+    { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement, domain: ['REQ'] },
+    { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency, domain: ['REQ'] },
+    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition, domain: ['REQ'] },
+    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
+    { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope, domain: ['MS'] },
+    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency, domain: ['MS'] },
+    { id: 'R-28', name: 'Ebenen-Präsenz (FLOW+SCHEMA when funcCount>1)', severity: 'warning', evaluate: ebenenPraesenz, domain: ['SYS'] },
 ];
-/** Run all rules against a graph */
-export function evaluateRules(graph) {
-    return V3_RULES.flatMap(rule => rule.evaluate(graph));
+/** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
+export function evaluateRules(graph, policy) {
+    return V3_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

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

@@ -14,7 +14,8 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function sc02IsReferenced(graph: OntologyGraph): RuleViolation[];
 export declare function sc04FlowHasSchema(graph: OntologyGraph): RuleViolation[];
 export declare const SC_RULES: RuleDefinition[];
-export declare function evaluateSCRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateSCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -49,9 +49,11 @@ export function sc04FlowHasSchema(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
-    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced },
-    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema },
+    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced, domain: ['SCHEMA'] },
+    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema, domain: ['SCHEMA'] },
 ];
-export function evaluateSCRules(graph) {
-    return SC_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 evaluateSCRules(graph, policy) {
+    return SC_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

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

@@ -3,6 +3,7 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function uc01HasRequirements(graph: OntologyGraph): RuleViolation[];
 export declare function uc02HasActor(graph: OntologyGraph): RuleViolation[];
 export declare function uc03HasScenario(graph: OntologyGraph): RuleViolation[];
@@ -10,4 +11,4 @@ export declare function uc04GoalDefined(graph: OntologyGraph): RuleViolation[];
 export declare function uc05HasPostcondition(graph: OntologyGraph): RuleViolation[];
 export declare function uc06HasPrecondition(graph: OntologyGraph): RuleViolation[];
 export declare const UC_RULES: RuleDefinition[];
-export declare function evaluateUCRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateUCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];