@sigloch/contracts 10.1.0 → 10.3.0

package/dist/se/rules.js

@@ -7,7 +7,8 @@ import { z } from 'zod/v4';
 import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
 import { traceRejection, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
-import { crossingContractCount, subtreeFuncs } from './module-crossings.js';
+import { moduleCrossings } from './module-crossings.js';
+import { functionCriticality } from './function-criticality.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). */
 export const ViolationCandidate = z.object({
@@ -233,94 +234,65 @@ function funcMustSatisfyReq(graph) {
 // R-03: ASIL isolation
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
-// R-04: Modulgroesse GEGEN Kreuzungen (nicht „max module size")
+// R-04: Randbreite des Moduls (CR-SM-312)
 //
-// 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.
+// Die Groessenfrage ist mit CR-SM-311 an RD-04 gegangen: eine Modul-Ebene zeigt Untermodule UND
+// eigene Funktionen, das IST ihre Breite. Was bleibt, ist die Kopplung — und die misst diese Regel
+// jetzt allein: die VERSCHIEDENEN Vertraege, die den Modulrand queren (`moduleCrossings.byModule`,
+// dieselbe Zaehlung wie CR-01 und BW-02, CR-SM-276).
 //
-// CR-SM-276: „Kreuzung" heisst hier dasselbe wie bei CR-01 — ein Vertrag auf dem io-Pfad
-// `FUNC -io-> FLOW -io-> FUNC` UEBER die Modulgrenze (`module-crossings.ts`). Vorher zaehlte
-// die Regel jede io-Kante einer Modul-FUNC „mit einem Endpunkt ausserhalb der FUNC-Menge" —
-// FLOWs liegen nie in dieser Menge, also zaehlte auch jeder modulINTERNE Fluss mit. Das war der
-// io-Grad des Moduls und fuer jedes Modul mit Datenfluss trivial > `crossings`; damit war R-04
-// faktisch wieder „max module size", der Name, den CR-SM-236 gerade verworfen hatte.
-// ---------------------------------------------------------------------------
-function maxModuleSize(graph, policy) {
+// Dieselbe Frage wie BW-02 auf dem zweiten Baum, also dieselbe Schwelle: `policy.boundaryWidth`.
+// Damit faellt `policy.moduleSize` ersatzlos — drei Zahlen fuer eine Frage, die es nicht mehr gibt.
+//
+// Das schliesst die Blindstelle, die `se-engine/steer.ts` seit CR-SM-292 benennt: ein KLEINES
+// Modul mit breitem Rand war stumm, weil R-04 den Rand nur zusammen mit der Groesse ansah
+// (gemessen: MOD-kernel-measure 9 Vertraege bei 7 Funktionen). Seit diesem CR steuert R-04 mit
+// (`STEER_RULES`), denn der Befund ist lokal, gerichtet und budgetiert.
+// ---------------------------------------------------------------------------
+function moduleBoundaryWidth(graph, policy) {
+    const steps = policy.boundaryWidth;
+    if (steps === null)
+        return [];
     const idx = indexOf(graph);
     const violations = [];
-    const steps = policy.moduleSize;
-    if (steps === null)
-        return violations;
-    const modules = idx.elementsOfType('MOD');
-    for (const mod of modules) {
-        // CR-SM-282: die Groesse ist die des TEILBAUMS, nicht der direkten Allokation. Ein
-        // Eltern-MOD (`MOD -compose-> MOD`) hat keine direkt allozierten FUNCs; `funcCount`
-        // war dort 0 und die Regel schwieg an genau der Whitebox, in die man hineinklickt.
-        // Fuer ein Blatt-MOD ist die Menge zeichengleich mit der bisherigen (nur `FUNC
-        // -allocate-> MOD` existiert als Pattern) — Regressions-Invariante.
-        const allocatedIds = [...subtreeFuncs(graph, mod.id)];
-        const allocated = allocatedIds.map(id => idx.byId.get(id)).filter((e) => !!e);
-        const funcCount = allocated.length;
-        if (funcCount <= steps.coupled)
+    for (const [modId, contracts] of moduleCrossings(graph).byModule) {
+        if (contracts.size < steps.warning)
             continue;
-        // Verschiedene Vertraege (SCHEMA) auf io-Pfaden ueber DIESEN Modulrand — CR-SM-276.
-        const crossings = crossingContractCount(graph, mod.id);
-        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 contracts crossing its module boundary (cohesive, just large)`,
-                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 > steps.large && crossings > 0) {
-            violations.push({
-                rule_id: 'R-04',
-                severity: 'warning',
-                element_id: mod.id,
-                message: `${mod.id} has ${funcCount} functions and ${crossings} distinct contract(s) crossing its module boundary (split recommended)`,
-                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 > steps.coupled && crossings > steps.crossings) {
-            violations.push({
-                rule_id: 'R-04',
-                severity: 'warning',
-                element_id: mod.id,
-                message: `${mod.id} has ${funcCount} functions and ${crossings} distinct contract(s) crossing its module boundary (high coupling)`,
-                fix_hint: 'Reduce crossing flows or split module',
-                context: { element_type: mod.type, element_name: mod.name, candidate_targets: toCandidates(allocated) },
-            });
-        }
+        const mod = idx.byId.get(modId);
+        violations.push({
+            rule_id: 'R-04',
+            severity: 'warning',
+            element_id: modId,
+            message: `${modId} exposes ${contracts.size} distinct contract(s) at its module boundary (>= ${steps.warning})`,
+            fix_hint: 'Reduce the contracts crossing this module boundary — merge contracts, or move the functions that carry them',
+            // CR-SM-288: `>= steps.warning` ist inklusiv, also ist `steps.warning - 1` der groesste Wert
+            // im Budget; die Masse `value - threshold` ist damit fuer jeden Befund > 0. Gleiche Konvention
+            // wie BW-02, dieselbe Schwelle.
+            context: { element_type: mod?.type, element_name: mod?.name, value: contracts.size, threshold: steps.warning - 1 },
+        });
     }
-    return violations;
+    // Kanonische Reihenfolge wie bei BW-02 — sonst haengt die Befund-Sequenz an der Trace-Reihenfolge.
+    return violations.sort((a, b) => (a.element_id < b.element_id ? -1 : a.element_id > b.element_id ? 1 : 0));
 }
 // ---------------------------------------------------------------------------
-// R-05: Every TEST must verify at least one REQ
+// R-05: Every TEST must verify at least one REQ — or, as a contract test, a SCHEMA (CR-SM-317)
 // ---------------------------------------------------------------------------
 function testMustVerifyReq(graph) {
     const idx = indexOf(graph);
     const tests = idx.elementsOfType('TEST');
-    const allReqs = idx.elementsOfType('REQ');
+    const candidates = [...idx.elementsOfType('REQ'), ...idx.elementsOfType('SCHEMA')];
     return tests
         .filter(test => idx.out(test.id, 'verify').length === 0)
         .map(test => ({
         rule_id: 'R-05',
         severity: 'warning',
         element_id: test.id,
-        message: `${test.id} does not verify any requirement`,
-        fix_hint: 'Link to a REQ via verify trace',
+        message: `${test.id} does not verify any requirement or schema`,
+        fix_hint: 'Link to a REQ via verify trace — or, for a contract test, to the SCHEMA it exercises',
         context: {
             element_type: test.type,
             element_name: test.name,
-            candidate_targets: toCandidates(allReqs),
+            candidate_targets: toCandidates(candidates),
         },
     }));
 }
@@ -396,6 +368,95 @@ function flowCompleteness(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
+// IO-02: ein FLOW hat genau EINEN Produzenten (CR-SM-307).
+//
+// R-10 prueft die UNTERgrenze (mindestens ein Ende), IO-02 die OBERgrenze der
+// Produzentenseite. Die beiden koennen am selben FLOW nie zugleich feuern — |P| = 0
+// gegen |P| > 1 ist disjunkt — also keine Doppelzaehlung im Sinne von Gate 4. Getrennte
+// IDs, weil es getrennte Fragen sind (CR-SM-296, "je Frage eine Regel"): R-10 fragt
+// "hat dieser Fluss ueberhaupt Enden?", IO-02 fragt "kommt sein Inhalt von einer Stelle?".
+//
+// WARUM NUR DIE PRODUZENTENSEITE. Der Inhalt eines FLOW kommt von einer Stelle; haengen
+// zwei Quellen dran, sind es zwei Fluesse unter einem Namen, und kein Leser kann wissen,
+// welche Fassung er bekommt. Mehrere KONSUMENTEN sind dagegen normal — wer abholt, aendert
+// am Fluss nichts. Das ist genau die zentrale Konfiguration: eine Quelle, viele Verbraucher.
+// Eine beidseitige Fassung wurde gemessen und VERWORFEN: sie haette allein in graphcode
+// 8 saubere 1:N-Muster bestraft (FLOW-dimension-readiness 1x7, FLOW-steering-snapshot 1x3,
+// sechs weitere), ohne einen einzigen zusaetzlichen echten Fehler zu finden.
+//
+// BESTAND vor der Einfuehrung, fuenf Systeme (graphcode/rig/flow-cardinality):
+//   graphcode 20/42 · graph-view-edit 5/8 · bok 3/15 · moneyflow 0/220 · test_karp 0/21
+// Die beiden Referenzen sind auch BEIDSEITIG sauber — sie erfuellen die strengere Fassung
+// ohnehin, die Lockerung rettet sie nicht. graphcode wurde vor diesem CR auf 9 repariert
+// (CR-GC-499/500); die 9 sind Busse mit 3 bis 19 Produzenten, un-modellierte Entwurfsarbeit.
+//
+// WARUM ES BIS HIERHER KEIN GATE PRUEFTE: die vier io-Zeilen in TRACE_PATTERNS tragen kein
+// `cardinality`-Feld und fallen deshalb durch REQUIRED_PATTERNS
+// (= TRACE_PATTERNS.filter(p => p.cardinality === '1')). Die SCHEMA-Haelfte IST Grammatik
+// (`FLOW -relation-> SCHEMA [1..1]`, R-18 seit CR-SM-271 Teil 2) — die io-Haelfte war nie
+// deklariert. Es ist kein Regel-Loch, das jemand geschlossen und wieder geoeffnet haette:
+// die Frage wurde nie gestellt.
+//
+// EIN BEFUND JE FLOW, nicht je ueberzaehliger Kante (Klasse CR-SM-242): sonst uebertraefe
+// der Zaehler seinen eigenen Nenner-Beitrag (`domain: ['FLOW']`). `value`/`threshold` nach
+// CR-SM-288, damit der Befund budgetierbar ist.
+//
+// SEVERITY error, aber NICHT in STEER_RULES: das ist Hygiene, keine Steuerdimension
+// (Entscheidung Auftraggeber 2026-09-10).
+//
+// KORREKTUR (CR-SM-308): Hier stand als Beleg, das Auftrennen eines Flusses hebe BW-02 ("ein
+// aufgetrennter Fluss kreuzt zwei Grenzen statt einer"), eine rankende Regel zoege also gegen
+// diese urteilende. Das stimmt nicht. moduleCrossings zaehlt je Rand VERSCHIEDENE SCHEMA; ein
+// aufgetrennter FLOW behaelt sein SCHEMA und hat eine Teilmenge der Enden, er erzeugt keinen
+// neuen Randdurchgang. Gemessen an graphcode v257: alle sechs Mehrfach-Produzenten-FLOW je
+// Produzent getrennt, BW-02 15 -> 15, byFunc und byModule unveraendert, IO-02 6 -> 0. Der
+// Anstieg bei CR-GC-499/500 (BW-02 13 -> 14, Chebyshev -0,25) kam von drei NEUEN SCHEMA und
+// umgelegten Ketten, nicht vom Auftrennen. Die Entscheidung oben steht; ein gemessener
+// Zielkonflikt mit BW-02 traegt sie nicht.
+// ---------------------------------------------------------------------------
+function flowSingleProducer(graph) {
+    const idx = indexOf(graph);
+    const flowIds = new Set(idx.idsOfType('FLOW'));
+    const isEndpoint = (id) => { const t = idx.typeOf(id); return t === 'FUNC' || t === 'ACTOR'; };
+    // Produzenten je FLOW als MENGE: zwei io-Kanten derselben Quelle auf denselben FLOW sind
+    // eine Quelle, kein Verstoss. Konsumenten werden bewusst nicht gezaehlt (s. Kopf).
+    const producers = new Map();
+    for (const t of idx.tracesOfType('io')) {
+        if (!flowIds.has(t.target) || !isEndpoint(t.source))
+            continue;
+        if (!producers.has(t.target))
+            producers.set(t.target, new Set());
+        producers.get(t.target).add(t.source);
+    }
+    const violations = [];
+    // Ueber die Elementliste laufen, nicht ueber die Map: die Reihenfolge eines Befundes darf
+    // nicht an der Trace-Reihenfolge haengen (CR-SM-244, Ordnung).
+    for (const f of idx.elementsOfType('FLOW')) {
+        const ps = producers.get(f.id);
+        if (!ps || ps.size <= 1)
+            continue;
+        const sorted = [...ps].sort();
+        violations.push({
+            rule_id: 'IO-02',
+            severity: 'error',
+            element_id: f.id,
+            message: `${f.id} has ${ps.size} producers (${sorted.join(', ')}) — the content of a FLOW comes from exactly one place`,
+            fix_hint: 'Give each source its own FLOW; the shared contract stays on the SCHEMA (n FLOW -> 1 SCHEMA is legal)',
+            context: {
+                element_type: f.type,
+                element_name: f.name,
+                value: ps.size,
+                threshold: 1,
+                candidate_targets: sorted.slice(0, 3).map(id => {
+                    const e = idx.byId.get(id);
+                    return { id, type: e?.type ?? 'FUNC', name: e?.name ?? id };
+                }),
+            },
+        });
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
 // R-11: REMOVED — superseded by SC-02 (identical check, better severity).
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
@@ -564,54 +625,10 @@ function noPrematureDecomposition(graph) {
         context: { element_type: req.type, element_name: req.name },
     }));
 }
-// ---------------------------------------------------------------------------
-// RD-04: Decomposition breadth (CR-SM-221)
-// ---------------------------------------------------------------------------
-/**
- * Max children on one decomposition level. The 7±2 convention existed only as
- * prose ("darüber func-of-func"); below 7 is a guideline, not a violation, so only
- * the upper bound is a rule.
- *
- * Counted per (parent, kind) — a MOD that both holds 12 FUNCs and composes 12
- * sub-MODs has two breadth problems, not one. (The spike reference merged both into
- * a single counter on the MOD id and would have reported 24 under one kind.)
- *
- * CR-SM-282, zwei Aenderungen:
- *
- * 1. **Die Schwelle steht in `policy.decompositionBreadth`**, nicht mehr inline. `null`
- *    schaltet die Regel ab (messen statt urteilen). Der Default war hier 11 (verhaltensgleich
- *    zum vorherigen Literal) und ist seit CR-SM-296 **9** — die Obergrenze von 7±2.
- * 2. **Der FUNC-Wurzelwald zaehlt mit.** Die Regel zaehlt Kinder je *Parent*; die Wurzeln des
- *    `FUNC -compose-> FUNC`-Waldes haben keinen — die oberste Funktionsebene war damit fuer
- *    RD-04 unsichtbar. Gemessen: moneyflow hat 306 Wurzel-FUNCs und RD-04 meldete **0**.
- *    Die MOD-Seite hatte das Problem nie, weil `SYS -compose-> MOD` eine echte Kante ist und
- *    unten schon als `sub-MOD` gezaehlt wird; die FUNC-Seite hat keine solche Kante
- *    (`se:top-level`: „the top FUNC set is a PROJECTION, not an edge").
- *
- *    Anker ist der SYS-Knoten — determiniert, weil genau einer existiert; gibt es nicht genau
- *    einen, schweigt dieser Zweig statt zu raten (R-17 deckt den Fall ab). Kein zweiter Weg zur
- *    Wurzelmenge: es ist dieselbe Definition wie in `se:top-level` (FUNC ohne compose-Elternteil).
- */
-// CR-SM-296: das Bein `FUNC -allocate-> MOD` ist ENTFALLEN und an R-04 abgegeben.
-//
-// Es zaehlte die allozierten FUNCs je Modul — also die MODULGROESSE, und die misst R-04 auch.
-// Beide feuerten am selben Modul im selben Batch, mit zwei Schwellen aus zwei Policy-Feldern:
-//   RD-04  > 11 allozierte FUNC-Kinder        policy.decompositionBreadth
-//   R-04   > 12 FUNCs (bzw. 8-12 mit Kreuzungen)  policy.moduleSize
-// Ein Sachverhalt, zwei Regeln, zwei Zahlen — und welche recht hat, stand nirgends. Schlimmer:
-// dieselbe Ursache ging doppelt in den readiness-Nenner. R-04 ist die reichere Aussage (Groesse
-// GEGEN Kreuzungen, drei Urteile) und liest ueber `moduleCrossings` ohnehin dieselben Daten.
-//
-// RD-04 bleibt fuer ZERLEGUNGSBREITE zustaendig: `FUNC compose FUNC`, `SYS/MOD compose MOD` und
-// der FUNC-Wurzelwald am SYS (CR-SM-282). Je Frage eine Regel, je Frage eine Schwelle.
-function decompositionBreadth(graph, policy) {
-    const max = policy.decompositionBreadth;
-    if (max === null)
-        return [];
+function breadthCounts(graph) {
     const idx = indexOf(graph);
     // CR-SM-264: `typeOf` und `byId` baute diese Regel je Aufruf selbst — der Index hat beide.
     const typeOf = idx;
-    const byId = idx.byId;
     const counts = new Map();
     const bump = (parentId, kind) => {
         const key = `${parentId}\u0000${kind}`;
@@ -627,9 +644,24 @@ function decompositionBreadth(graph, policy) {
         if (t.type === 'compose' && src === 'FUNC' && tgt === 'FUNC') {
             bump(t.source, 'sub-FUNC');
         }
-        else if (t.type === 'compose' && (src === 'SYS' || src === 'MOD') && tgt === 'MOD') {
+        else if (t.type === 'compose' && src === 'SYS' && tgt === 'MOD') {
             bump(t.source, 'sub-MOD');
         }
+        else if (t.type === 'compose' && src === 'MOD' && tgt === 'MOD') {
+            bump(t.source, 'module element');
+        }
+    }
+    // CR-SM-311: eine MOD-Ebene liest sich aus Untermodulen UND eigenen Funktionen. Gezaehlt werden
+    // die BLAETTER — ein zerlegter FUNC ist ein Wertbaum-Knoten; seine Blaetter tragen den Code und
+    // stehen selbst im Modul, ihn mitzuzaehlen hiesse dieselbe Funktion zweimal.
+    const decomposedFuncs = new Set(graph.traces
+        .filter(t => t.type === 'compose' && typeOf.typeOf(t.source) === 'FUNC' && typeOf.typeOf(t.target) === 'FUNC')
+        .map(t => t.source));
+    for (const t of graph.traces) {
+        if (t.type !== 'allocate' || typeOf.typeOf(t.source) !== 'FUNC' || typeOf.typeOf(t.target) !== 'MOD')
+            continue;
+        if (!decomposedFuncs.has(t.source))
+            bump(t.target, 'module element');
     }
     // CR-SM-282: der FUNC-Wurzelwald als eigene Blackbox, verankert am SYS-Knoten.
     const composedFuncs = new Set(graph.traces
@@ -641,18 +673,56 @@ function decompositionBreadth(graph, policy) {
         if (rootFuncs > 0)
             counts.set(`${systems[0].id}\u0000root FUNC`, { parentId: systems[0].id, kind: 'root FUNC', n: rootFuncs });
     }
-    return [...counts.values()]
-        .filter(c => c.n > max.warning)
+    return [...counts.values()];
+}
+function decompositionBreadth(graph, policy) {
+    const band = policy.decompositionBreadth;
+    if (band === null)
+        return [];
+    const byId = indexOf(graph).byId;
+    return breadthCounts(graph)
+        .filter(c => c.n > band.warning)
         .map(c => {
         const parent = byId.get(c.parentId);
         return {
             rule_id: 'RD-04',
             severity: 'warning',
             element_id: c.parentId,
-            message: `${c.parentId} has ${c.n} ${c.kind} children on one level (>${max.warning})`,
+            message: `${c.parentId} has ${c.n} ${c.kind} children on one level (>${band.warning})`,
             fix_hint: 'Introduce an intermediate level (func-of-func / sub-MOD)',
-            // CR-SM-288: `> max.warning` ist exklusiv, also ist `max.warning` selbst noch im Budget.
-            context: { element_type: parent?.type, element_name: parent?.name, value: c.n, threshold: max.warning },
+            // CR-SM-288: `> band.warning` ist exklusiv, also ist `band.warning` selbst noch im Budget.
+            context: { element_type: parent?.type, element_name: parent?.name, value: c.n, threshold: band.warning },
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// RD-05: Zerlegung zu SCHMAL — eine Ebene mit weniger als `decompositionBreadth.min` Elementen
+// abstrahiert nichts (CR-SM-311, Z3 aus ITEM-2026-053). Dieselbe Zaehlung wie RD-04.
+//
+// Eine eigene Regel und nicht die untere Haelfte von RD-04: RD-04 ist eine der messenden Regeln
+// (CR-SM-288) — jeder ihrer Befunde traegt `value` und `threshold`, und `value > threshold`
+// heisst warning. Eine Unterschreitung hat keinen Ueberschuss; als RD-04 haette sie diese Zusage
+// fuer alle Konsumenten gebrochen und waere in `steerScore` als Masse 0 mitgelaufen. RD-05 fuehrt
+// deshalb keine Zahl im Kontext und steuert nicht — sie ist Lesbarkeit, nicht Randbreite.
+// Eine Ebene ohne jedes Kind ist nicht ihr Fall: ein leeres MOD meldet R-23, eine FUNC ohne Kinder
+// ist ein Blatt.
+// ---------------------------------------------------------------------------
+function decompositionNarrow(graph, policy) {
+    const band = policy.decompositionBreadth;
+    if (band === null)
+        return [];
+    const byId = indexOf(graph).byId;
+    return breadthCounts(graph)
+        .filter(c => c.n < band.min)
+        .map(c => {
+        const parent = byId.get(c.parentId);
+        return {
+            rule_id: 'RD-05',
+            severity: 'warning',
+            element_id: c.parentId,
+            message: `${c.parentId} has only ${c.n} ${c.kind} children on one level (<${band.min})`,
+            fix_hint: 'Dissolve the level into its parent, or gather related elements under it',
+            context: { element_type: parent?.type, element_name: parent?.name },
         };
     });
 }
@@ -1171,12 +1241,12 @@ function funcMustHaveCodeBinding(graph) {
 //       as one produced P·C findings per hub FLOW and made reuse the expensive
 //       choice. The FCHAIN is the modelled claim; the test is owed on the claim.
 // ---------------------------------------------------------------------------
-function fchainMustHaveIntegrationTest(graph) {
+function fchainMustHaveIntegrationTest(graph, policy) {
     const idx = indexOf(graph);
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
     const isFunc = (id) => typeOf.get(id) === 'FUNC';
     const io = idx.tracesOfType('io');
-    // FUNC↔FUNC connections via the FLOW hop: (producer FUNC) → FLOW → (consumer FUNC).
+    // FUNC↔FUNC handovers via the FLOW hop: (producer FUNC) → FLOW → (consumer FUNC).
     const connections = [];
     for (const e of graph.elements) {
         if (e.type !== 'FLOW')
@@ -1190,7 +1260,8 @@ function fchainMustHaveIntegrationTest(graph) {
     }
     if (connections.length === 0)
         return [];
-    // FUNC → set of FCHAINs composing it.
+    // FUNC → set of FCHAINs composing it. LOKALER Index fuer eine andere Frage als die Kennzahl:
+    // "teilen diese beiden EINE Kette" braucht die Mengen, nicht die Zahl (CR-SM-313).
     const chainsOfFunc = new Map();
     for (const t of graph.traces) {
         if (t.type === 'compose' && typeOf.get(t.source) === 'FCHAIN' && isFunc(t.target)) {
@@ -1205,16 +1276,46 @@ function fchainMustHaveIntegrationTest(graph) {
             testedChains.add(t.source);
         }
     }
+    // CR-SM-313: die Infrastruktur-Ausnahme. Die ZAHL kommt aus der Kennzahl (CR-SM-314), nicht
+    // aus einer zweiten Rechnung — eine Uebergabe an eine Funktion, die quer durch alle Ketten
+    // laeuft, ist kein fehlender Integrationstest, sondern ein Bus. `null` = keine Ausnahme.
+    const infra = policy.criticality?.infrastructure ?? null;
+    const chainCount = infra === null ? null : new Map(functionCriticality(graph).map(r => [r.funcId, r.chains]));
+    const isInfrastructure = (id) => infra !== null && chainCount !== null && (chainCount.get(id) ?? 0) >= infra;
     const violations = [];
     const seen = new Set();
     for (const [p, c] of connections) {
-        const shared = [...(chainsOfFunc.get(p) ?? [])].filter(ch => chainsOfFunc.get(c)?.has(ch));
-        // No shared FCHAIN = no asserted integration (CR-GC-315). Sharing one FLOW
-        // between P producers and C consumers does not mean P·C interfaces exist —
-        // deriving connections from FLOW adjacency alone taxed reuse quadratically.
-        // The FCHAIN is the declared integration scope; only that is held to a test.
-        if (shared.length === 0)
+        const pChains = chainsOfFunc.get(p) ?? new Set();
+        const cChains = chainsOfFunc.get(c) ?? new Set();
+        // ZWEIG 1 — ein Ende in GAR KEINER Kette: still. Das ist R-30s Aussage, nicht R-21s.
+        // Ohne diese Klausel feuert die Regel an einem code-importierten Graphen wie moneyflow
+        // 219 von 219 Mal und meldet in Wahrheit "dieses Repo hat keine Wirkketten", einmal je Kante.
+        if (pChains.size === 0 || cChains.size === 0)
+            continue;
+        const shared = [...pChains].filter(ch => cChains.has(ch));
+        // ZWEIG 3 — beide in Ketten, aber KEINE gemeinsame (CR-SM-313). CR-GC-315 hatte diesen Fall
+        // stillgelegt, weil ein FLOW damals viele Produzenten haben durfte und die P·C-Ableitung
+        // Wiederverwendung quadratisch besteuerte; seit IO-02 (CR-SM-307) hat er genau EINEN.
+        // Befund am SENDER: ohne gemeinsame Kette gibt es keinen Kettenanker.
+        if (shared.length === 0) {
+            if (isInfrastructure(p) || isInfrastructure(c))
+                continue;
+            const key = `pair|${p}>${c}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const sender = idx.byId.get(p);
+            violations.push({
+                rule_id: 'R-21',
+                severity: 'warning',
+                element_id: p,
+                message: `${p} hands over to ${c}, but the two share no FCHAIN — no integration scope is declared`,
+                fix_hint: 'Put both functions into one FCHAIN, or route the handover through a function of an existing chain',
+                context: { element_type: sender?.type, element_name: sender?.name },
+            });
             continue;
+        }
+        // ZWEIG 2 — gemeinsame Kette, aber keine davon geprueft: Befund an der Kette. Unveraendert.
         if (shared.some(ch => testedChains.has(ch)))
             continue;
         const anchor = shared[0];
@@ -1320,6 +1421,32 @@ function schemaMustHaveSchemaRef(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// R-32: Every realized SCHEMA must have a contract TEST (CR-SM-319, ITEM-2026-064).
+// A SCHEMA with a symbol-bearing realRef is a Zod contract in code. RC-04 checks that it is
+// PARSED at its boundary; this rule checks that it is TESTED as a contract — every variant
+// incl. rejection, independent of any scenario — via `TEST -verify-> SCHEMA` (CR-SM-317).
+// Chain tests (R-21) cover meaning end-to-end; they do not cover the contract's variants.
+// Owner's decision 2026-09-11: no exception, no KPI — a rule. concept-only SCHEMAs and
+// SCHEMAs without a symbol realRef are out of scope (presence is R-26's concern).
+// ---------------------------------------------------------------------------
+function schemaMustHaveContractTest(graph) {
+    const idx = indexOf(graph);
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const tests = idx.elementsOfType('TEST');
+    return idx.elementsOfType('SCHEMA')
+        .filter(sc => sc.attributes?.concept !== true)
+        .filter(sc => { const r = RealRefSchema.safeParse(sc.attributes?.realRef); return r.success && r.data.symbol !== undefined; })
+        .filter(sc => !graph.traces.some(t => t.type === 'verify' && t.target === sc.id && typeOf.get(t.source) === 'TEST'))
+        .map(sc => ({
+        rule_id: 'R-32',
+        severity: 'warning',
+        element_id: sc.id,
+        message: `${sc.id} is a realized SCHEMA without a contract TEST (no TEST -verify-> SCHEMA)`,
+        fix_hint: 'Add a TEST that exercises every variant of the contract incl. rejection, and link it via verify trace to this SCHEMA',
+        context: { element_type: sc.type, element_name: sc.name, candidate_targets: toCandidates(tests) },
+    }));
+}
+// ---------------------------------------------------------------------------
 // R-27: physical MOD realRef presence (CR-228) — the MOD arm of the unified
 // "element must have a realRef" rule (FUNC=R-20, SCHEMA=R-26, physical MOD=R-27).
 // A physical MOD (kind='physical') is a Bauteil realized by a CAD/geometry
@@ -1444,7 +1571,7 @@ export const V3_RULES = [
     { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq, domain: ['FUNC'] },
     // CR-SM-243: domain ist MOD, nicht FUNC — die Regel iteriert Module und meldet am Modul,
     // das ASIL-D und QM mischt. Die FUNCs sind der Anlass des Urteils, nicht seine Traeger.
-    { id: 'R-04', name: 'Module size relative to crossing flows', severity: 'warning', evaluate: maxModuleSize, domain: ['MOD'] },
+    { id: 'R-04', name: 'Module boundary width', severity: 'warning', evaluate: moduleBoundaryWidth, domain: ['MOD'] },
     { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq, domain: ['TEST'] },
     { id: 'R-15', name: 'FCHAIN completeness', severity: 'warning', evaluate: fchainCompleteness, domain: ['FCHAIN'] },
     { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace, domain: ['ACTOR'] },
@@ -1454,19 +1581,23 @@ export const V3_RULES = [
     // Als ['FUNC'] deklariert erhoehte sie den Zaehler einer Grundgesamtheit, zu der ihre
     // Verstoesse nicht gehoerten (bis zu 2 Legs je FLOW gegen einen FUNC-Nenner).
     { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness, domain: ['FLOW'] },
+    // Obergrenze zu R-10s Untergrenze — disjunkt, deshalb zwei IDs (CR-SM-307).
+    { id: 'IO-02', name: 'FLOW single producer', severity: 'error', evaluate: flowSingleProducer, domain: ['FLOW'] },
     { 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-21', name: 'FUNC↔FUNC handover needs a shared chain and an integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN', 'FUNC'] },
     { 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-32', name: 'SCHEMA must have contract TEST', severity: 'warning', evaluate: schemaMustHaveContractTest, domain: ['SCHEMA'] },
     { 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: 'RD-05', name: 'Decomposition too narrow', severity: 'warning', evaluate: decompositionNarrow, 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-30', name: 'FUNC leaf must belong to a function chain', severity: 'warning', evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "10.1.0",
+  "version": "10.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",