@sigloch/contracts 5.0.0 → 6.0.0

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

@@ -1,6 +1,6 @@
 /**
  * CR-SM-227: Analysis-Freshness-Legs — the third leg-kind a review gate checks
- * (rule legs, layer-presence legs [R-28], now analysis-freshness legs).
+ * (rule legs, layer-presence legs [R-28, entfallen mit CR-SM-247], now analysis-freshness legs).
  * Presence/Resolution-Split (wie R-19/R-20/R-26/R-27 vs. RC-01..05): these five
  * rules are the PRÜFBARE FORM only — does a `graphVersion` stamp exist for the
  * artifact, as a graph attribute. They never compare the stamp against the

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

@@ -6,12 +6,12 @@ const ARTIFACT_LABEL = {
     fmea: 'FMEA',
     implplan: 'Implementation Plan',
 };
-/** Presence-check for one analysis artifact's freshness stamp, anchored on SYS (like R-28). */
+/** Presence-check for one analysis artifact's freshness stamp, anchored on SYS. */
 function analysisFreshnessPresence(ruleId, artifactId) {
     return (graph) => {
         const sys = graph.elements.find(e => e.type === 'SYS');
         if (!sys)
-            return []; // nothing to anchor on yet (same vacuous-complete exemption as R-28)
+            return []; // nothing to anchor on yet (vacuous-complete exemption)
         const stamp = sys.attributes?.analysisFreshness?.[artifactId];
         if (AnalysisFreshnessStampSchema.safeParse(stamp).success)
             return [];

package/dist/se/ao-rules.js

@@ -263,75 +263,116 @@ export function ca01CapabilityAllocation(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
-// IO-01: FUNC-pair IO completeness (CR-192, extended CR-SM-226)
-// For each FCHAIN with ≥2 FUNCs, every pair of FUNCs in the chain must have a
-// FLOW path between them — not just pairs allocated to different MODs.
-// CR-SM-226 removed the cross-module-only restriction: same-module FUNC
-// pairs need an explicit FLOW just as much (module allocation is an
-// orthogonal concern to whether the interaction itself is wired up).
+// IO-01: die Wirkkette haengt zusammen (CR-192, CR-SM-226, CR-SM-250)
+//
+// Geprueft wird ERREICHBARKEIT im io-Teilgraphen der Kette, nicht Adjazenz. Bis CR-SM-250
+// musste es fuer JEDES Paar einen gemeinsamen FLOW geben — die Regel forderte damit einen
+// vollstaendigen Graphen (n·(n−1)/2 Paarungen), obwohl eine Wirkkette eine Sequenz ist. Der
+// Zaehler wuchs quadratisch mit der Kettenlaenge, der Nenner-Beitrag linear: eine lange, gut
+// modellierte Kette las sich schlechter als eine kurze. Dieselbe Korrektur ist fuer R-21
+// bereits vollzogen (CR-GC-315, "reuse was penalised quadratically").
+//
+// Zwei Praezisierungen gegenueber dem Vorschlag (Review 2026-08-20):
+//
+// 1. EIN BEFUND JE GLIED, nicht je Paar. Auch nach dem Umbau waeren zwei Komponenten der
+//    Groesse n/2 wieder n²/4 Befunde. Gemeldet wird je Glied ausserhalb der groessten
+//    Komponente — hoechstens ein Befund je FUNC und Kette, damit der Zaehler den
+//    Nenner-Beitrag (`domain: ['FUNC']`) nicht uebersteigt (die Fehlmessung aus CR-SM-242).
+//    Groesste Komponente bei Gleichstand: die mit der lexikografisch kleinsten FUNC-ID —
+//    ein Befund darf nicht an der Array-Reihenfolge haengen (CR-SM-244, Ordnung).
+//
+// 2. GAR NICHT VERDRAHTETE GLIEDER GEHOEREN R-31. Eine FUNC ohne jede io-Kante ist trivial
+//    ihre eigene Komponente; sie zu melden waere eine zweite Meldung derselben Ursache. Am
+//    sigloch-modules-Selbstmodell waren 6 der 7 IO-01-Elemente zugleich R-31-Elemente —
+//    genau die Doppelzaehlung, die Gate 4 verbietet. IO-01 meldet ab jetzt nur, was
+//    verdrahtet, aber von seiner Kette abgehaengt ist. Das ist die Aussage, die keine
+//    andere Regel trifft.
 // ---------------------------------------------------------------------------
 export function io01CrossModuleCompleteness(graph) {
     const violations = [];
-    const fchains = graph.elements.filter(e => e.type === 'FCHAIN');
-    for (const fc of fchains) {
-        // Get FUNCs in this FCHAIN via compose
-        const funcIds = graph.traces
+    const flowIds = new Set(graph.elements.filter(e => e.type === 'FLOW').map(e => e.id));
+    const funcIdSet = new Set(graph.elements.filter(e => e.type === 'FUNC').map(e => e.id));
+    /** io-Nachbarschaft FUNC <-> FLOW, richtungslos: die Frage ist "haengt das zusammen?". */
+    const flowsOfFunc = new Map();
+    for (const t of graph.traces) {
+        if (t.type !== 'io')
+            continue;
+        const [f, fl] = funcIdSet.has(t.source) && flowIds.has(t.target) ? [t.source, t.target]
+            : funcIdSet.has(t.target) && flowIds.has(t.source) ? [t.target, t.source]
+                : [undefined, undefined];
+        if (!f || !fl)
+            continue;
+        if (!flowsOfFunc.has(f))
+            flowsOfFunc.set(f, new Set());
+        flowsOfFunc.get(f).add(fl);
+    }
+    for (const fc of graph.elements.filter(e => e.type === 'FCHAIN')) {
+        const members = graph.traces
             .filter(t => t.source === fc.id && t.type === 'compose')
             .map(t => t.target)
-            .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC'));
-        if (funcIds.length < 2)
+            .filter(id => funcIdSet.has(id));
+        // Nur verdrahtete Glieder — der Rest ist R-31s Befund (s. Kopf, Praezisierung 2).
+        const wired = members.filter(id => (flowsOfFunc.get(id)?.size ?? 0) > 0).sort();
+        if (wired.length < 2)
             continue;
-        // Map FUNC→MOD via allocate (kept for the message context; no longer a filter).
-        const funcToMod = new Map();
-        for (const fid of funcIds) {
-            const allocTrace = graph.traces.find(t => t.source === fid && t.type === 'allocate');
-            if (allocTrace)
-                funcToMod.set(fid, allocTrace.target);
-        }
-        // For each pair of FUNCs in the chain, check for a FLOW path.
-        const checked = new Set();
-        for (const fA of funcIds) {
-            for (const fB of funcIds) {
-                if (fA >= fB)
-                    continue;
-                const modA = funcToMod.get(fA) ?? 'unallocated';
-                const modB = funcToMod.get(fB) ?? 'unallocated';
-                const pairKey = `${fA}:${fB}`;
-                if (checked.has(pairKey))
-                    continue;
-                checked.add(pairKey);
-                // Check if there's a FLOW path: fA→io→FLOW→io→fB or fB→io→FLOW→io→fA
-                const hasFlow = graph.traces.some(t1 => {
-                    if (t1.type !== 'io')
-                        return false;
-                    if (t1.source !== fA && t1.source !== fB)
-                        return false;
-                    const flowId = t1.target;
-                    const flowEl = graph.elements.find(e => e.id === flowId && e.type === 'FLOW');
-                    if (!flowEl)
-                        return false;
-                    const otherFunc = t1.source === fA ? fB : fA;
-                    return graph.traces.some(t2 => t2.type === 'io' &&
-                        ((t2.source === flowId && t2.target === otherFunc) ||
-                            (t2.target === flowId && t2.source === otherFunc)));
-                });
-                if (!hasFlow) {
-                    const elA = graph.elements.find(e => e.id === fA);
-                    const elB = graph.elements.find(e => e.id === fB);
-                    violations.push({
-                        rule_id: 'IO-01',
-                        severity: 'warning',
-                        element_id: fA,
-                        message: `${fA} (${modA}) and ${fB} (${modB}) in FCHAIN ${fc.id} have no IO path — missing FLOW?`,
-                        fix_hint: 'Add a FLOW element with io traces between these functions',
-                        context: {
-                            element_type: 'FUNC',
-                            element_name: elA?.name ?? fA,
-                            candidate_targets: elB ? [{ id: elB.id, type: elB.type, name: elB.name }] : undefined,
-                        },
-                    });
-                }
+        // Union-Find ueber die Glieder: zwei Glieder am selben FLOW sind verbunden, Ketten von
+        // FLOW-Glied-FLOW verschmelzen dadurch transitiv zu einer Komponente.
+        const parent = new Map(wired.map(id => [id, id]));
+        const find = (x) => {
+            let r = x;
+            while (parent.get(r) !== r)
+                r = parent.get(r);
+            while (parent.get(x) !== r) {
+                const nxt = parent.get(x);
+                parent.set(x, r);
+                x = nxt;
+            }
+            return r;
+        };
+        const union = (a, b) => { const ra = find(a), rb = find(b); if (ra !== rb)
+            parent.set(ra < rb ? rb : ra, ra < rb ? ra : rb); };
+        const byFlow = new Map();
+        for (const id of wired)
+            for (const fl of flowsOfFunc.get(id)) {
+                if (!byFlow.has(fl))
+                    byFlow.set(fl, []);
+                byFlow.get(fl).push(id);
             }
+        for (const sharing of byFlow.values())
+            for (let i = 1; i < sharing.length; i++)
+                union(sharing[0], sharing[i]);
+        const components = new Map();
+        for (const id of wired) {
+            const root = find(id);
+            if (!components.has(root))
+                components.set(root, []);
+            components.get(root).push(id);
+        }
+        if (components.size < 2)
+            continue;
+        // Groesste Komponente; bei Gleichstand die mit der kleinsten ID — deterministisch.
+        const largest = [...components.values()].sort((a, b) => b.length - a.length || a[0].localeCompare(b[0]))[0];
+        const largestSet = new Set(largest);
+        for (const id of wired) {
+            if (largestSet.has(id))
+                continue;
+            const el = graph.elements.find(e => e.id === id);
+            const mod = graph.traces.find(t => t.source === id && t.type === 'allocate')?.target ?? 'unallocated';
+            violations.push({
+                rule_id: 'IO-01',
+                severity: 'warning',
+                element_id: id,
+                message: `${id} (${mod}) is io-wired but not connected to the rest of FCHAIN ${fc.id} — no FLOW path to ${largest[0]}`,
+                fix_hint: `Add a FLOW (or io traces on an existing one) linking ${id} to a function of the same chain`,
+                context: {
+                    element_type: 'FUNC',
+                    element_name: el?.name ?? id,
+                    candidate_targets: largest.slice(0, 3).map(t => {
+                        const te = graph.elements.find(e => e.id === t);
+                        return { id: t, type: te?.type ?? 'FUNC', name: te?.name ?? t };
+                    }),
+                },
+            });
         }
     }
     return violations;

package/dist/se/evaluate-all.js

@@ -24,7 +24,13 @@ export const ALL_RULE_DEFS = [
 ].map(r => ({ id: r.id, name: r.name, severity: r.severity, domain: r.domain }));
 // CR-SM-221: 'RD-' was missing — 'RD-01'.startsWith('R-') is false, so the
 // decomposition rules ran in `default` only and never in the `se` profile.
-const SE_PREFIXES = ['R-', 'RD-', 'UC-', 'FC-', 'SC-', 'MT-', 'CR-', 'AO-', 'FM-', 'NFR-', 'RT-', 'PH-', 'CA-', 'IO-', 'VR-', 'CL-', 'AF-'];
+// CR-SM-245: 'MS-' fehlte hier UND in CODING_PREFIXES — MS-01/02/03 fielen aus beiden Profilen
+// und liefen nur im 'default'-Lauf. Die Dimension `ms` wird von genau vier Regeln getragen
+// (MS-01/02/03 + AF-05); AF-05 ist eine `domain: ['graph']`-Regel und traegt per CR-SM-239
+// keinen Nenner bei. Im se-Profil hatte `ms` damit keine einzige zaehlende Regel — ein leerer
+// Topic-Score und drei fehlende SRR-Legs. Zweiter Fall derselben Klasse nach 'RD-' (CR-SM-221),
+// jetzt vom Profil-Test in se-grammar-invariant.test.ts abgedeckt.
+const SE_PREFIXES = ['R-', 'RD-', 'UC-', 'FC-', 'SC-', 'MT-', 'CR-', 'AO-', 'FM-', 'NFR-', 'RT-', 'PH-', 'CA-', 'IO-', 'VR-', 'CL-', 'AF-', 'MS-'];
 const CODING_PREFIXES = ['BQ-', 'ND-'];
 export function getRuleDefsForProfile(profile) {
     if (profile === 'se')

package/dist/se/format-e-parser.d.ts

@@ -10,7 +10,7 @@
  * @sigloch/contracts/se
  */
 import { ElementType } from './ontology.js';
-import type { TraceType, OntologyGraph } from './ontology.js';
+import type { TraceType, OntologyGraph, AttributeSpec } from './ontology.js';
 export interface FormatEOperation {
     type: 'add_node' | 'remove_node' | 'update_node' | 'add_edge' | 'remove_edge' | 'strict_add_node' | 'strict_add_edge';
     semanticId: string;
@@ -50,7 +50,16 @@ export declare function extractFormatE(llmOutput: string): string | null;
  * package over. Two hydration rules would drift; there is one, and it lives here with the
  * schemas it feeds.
  */
-export declare function hydrateAttrValue(raw: string): unknown;
+/**
+ * CR-SM-251: der deklarierte Typ des Attributs entscheidet, nicht die Schreibweise des Wertes.
+ *
+ * `ELEMENT_ATTRIBUTES` sagt fuer 14 Attribute (9 boolean, 5 number), welchen Typ sie tragen.
+ * Wer stattdessen raet (`raw === 'true'`, `/^\d+$/`), verschiebt den Defekt nur: ein
+ * Freitext-Attribut mit dem Wert "true" oder "8" kippt dann still den Typ. Unbekannte Keys —
+ * jeder Graph darf eigene tragen — fallen sauber auf String zurueck.
+ */
+export declare function attributeTypeOf(elementType: string | undefined, key: string): AttributeSpec['type'] | undefined;
+export declare function hydrateAttrValue(raw: string, declaredType?: AttributeSpec['type']): unknown;
 export interface ParseFormatEOptions {
     /**
      * CR-SM-216: resolve the type of a uid that this text does not declare. A mutation

package/dist/se/format-e-parser.js

@@ -9,7 +9,7 @@
  *
  * @sigloch/contracts/se
  */
-import { ElementType } from './ontology.js';
+import { ElementType, ELEMENT_ATTRIBUTES } from './ontology.js';
 import { isValidTrace } from './meta-model.js';
 // ---------------------------------------------------------------------------
 // Extraction
@@ -54,7 +54,37 @@ const ATTR_RE = /^\s*@(\w+)\s+(.+)$/;
  * package over. Two hydration rules would drift; there is one, and it lives here with the
  * schemas it feeds.
  */
-export function hydrateAttrValue(raw) {
+/**
+ * CR-SM-251: der deklarierte Typ des Attributs entscheidet, nicht die Schreibweise des Wertes.
+ *
+ * `ELEMENT_ATTRIBUTES` sagt fuer 14 Attribute (9 boolean, 5 number), welchen Typ sie tragen.
+ * Wer stattdessen raet (`raw === 'true'`, `/^\d+$/`), verschiebt den Defekt nur: ein
+ * Freitext-Attribut mit dem Wert "true" oder "8" kippt dann still den Typ. Unbekannte Keys —
+ * jeder Graph darf eigene tragen — fallen sauber auf String zurueck.
+ */
+export function attributeTypeOf(elementType, key) {
+    if (!elementType)
+        return undefined;
+    const specs = ELEMENT_ATTRIBUTES[elementType];
+    return specs?.find(s => s.key === key)?.type;
+}
+export function hydrateAttrValue(raw, declaredType) {
+    // CR-SM-251: `concept:true` kam als String "true" an, und alle 11 Vergleiche in
+    // rules.ts/conformance-rules.ts pruefen identitaetsscharf (`=== true`). Damit war jeder
+    // Ausnahme-Schalter (concept/external/safety_relevant/spike) ueber Format-E unerreichbar:
+    // der Autor befolgt den fix_hint woertlich, und die Warnung bleibt stehen. Ein Export-Reimport
+    // entwertete zusaetzlich jede bestehende Ausnahme still.
+    if (declaredType === 'boolean') {
+        if (raw === 'true')
+            return true;
+        if (raw === 'false')
+            return false;
+        return raw; // kein stiller Fallback auf false — ein unlesbarer Wert bleibt sichtbar falsch
+    }
+    if (declaredType === 'number') {
+        const n = Number(raw);
+        return raw.trim() !== '' && Number.isFinite(n) ? n : raw;
+    }
     if (!/^[{[]/.test(raw))
         return raw;
     try {
@@ -90,7 +120,7 @@ export function parseFormatE(input, options = {}) {
             if (lastOp && (lastOp.type === 'add_node' || lastOp.type === 'update_node' || lastOp.type === 'strict_add_node')) {
                 if (!lastOp.attributes)
                     lastOp.attributes = {};
-                lastOp.attributes[attrMatch[1]] = hydrateAttrValue(attrMatch[2].trim());
+                lastOp.attributes[attrMatch[1]] = hydrateAttrValue(attrMatch[2].trim(), attributeTypeOf(lastOp.elementType, attrMatch[1]));
             }
             else {
                 errors.push(`@attribute line without preceding node: "${line}"`);

package/dist/se/grammar-snapshot.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GENERIERT — nicht von Hand pflegen.
+ *
+ * Das Golden-File der SE-Grammatik (CR-SM-244). Sein Diff IST der Changelog der Oberflaeche:
+ * jede Zeile hier ist ein Vertrag, an dem ein Konsument der Familie haengt. Erzeugt von
+ * `npm run grammar:snapshot -w @sigloch/contracts`, geprueft von
+ * `tests/unit/se-grammar-invariant.test.ts`.
+ *
+ * Wer diese Datei aendert, ohne die zugehoerige Version in ./index.ts zu bumpen, hat den Zweck
+ * verfehlt — `npm run check:grammar` faellt darueber.
+ */
+export declare const GRAMMAR_SNAPSHOT: {
+    readonly versions: {
+        readonly ontology: "7.0.0";
+        readonly metaModel: "2.0.0";
+        readonly rules: "6.0.0";
+    };
+    readonly elementTypes: readonly ["ACTOR", "CR", "FCHAIN", "FLOW", "FUNC", "MOD", "MS", "REQ", "SCHEMA", "SESSION", "SYS", "TEST", "UC"];
+    readonly traceTypes: readonly ["allocate", "compose", "io", "produces", "relation", "satisfy", "verify"];
+    readonly patterns: readonly ["ACTOR -io-> FLOW", "ACTOR -io-> UC", "CR -relation-> FUNC", "CR -relation-> MOD", "CR -relation-> MS", "CR -relation-> REQ", "CR -relation-> UC", "FCHAIN -compose-> FUNC [1..*]", "FCHAIN -satisfy-> REQ", "FLOW -io-> ACTOR", "FLOW -io-> FUNC", "FLOW -io-> UC", "FLOW -relation-> SCHEMA", "FUNC -allocate-> MOD", "FUNC -compose-> FUNC [0..*]", "FUNC -io-> FLOW", "FUNC -satisfy-> REQ", "MOD -compose-> MOD [0..*]", "MOD -io-> MOD", "MOD -satisfy-> REQ", "MS -compose-> FUNC", "MS -compose-> MS", "MS -compose-> REQ", "MS -compose-> UC", "MS -relation-> MS", "REQ -compose-> REQ [0..*]", "SESSION -produces-> * (audit)", "SYS -compose-> MOD [0..*]", "SYS -compose-> REQ [0..*]", "SYS -compose-> SYS [0..*]", "SYS -compose-> UC [1..*]", "SYS -satisfy-> REQ", "TEST -verify-> REQ", "UC -compose-> FCHAIN [1..*]", "UC -compose-> REQ [1..*]"];
+    readonly attributes: readonly ["CR.rationale: string", "CR.spike: boolean", "CR.status: enum", "FLOW.protocol: string", "FLOW.qos: string", "FUNC.concept: boolean", "FUNC.external: boolean", "FUNC.measuredMs: number", "FUNC.realRef: object", "FUNC.safety_relevant: boolean", "FUNC.sourceFile: string", "FUNC.timingBudgetMs: number", "MOD.concept: boolean", "MOD.external: boolean", "MOD.kind: string", "MOD.path: string", "MOD.realRef: object", "REQ.detection: number", "REQ.occurrence: number", "REQ.severity: number", "SCHEMA.concept: boolean", "SCHEMA.contract: string", "SCHEMA.external: boolean", "SCHEMA.realRef: object", "TEST.concept: boolean", "TEST.sourceFile: string", "TEST.testRefs: array", "UC.operatingMode: string"];
+    readonly rules: readonly ["AF-01 (warning) domain=[graph]", "AF-02 (warning) domain=[graph]", "AF-03 (warning) domain=[graph]", "AF-04 (warning) domain=[graph]", "AF-05 (warning) domain=[graph]", "AO-D01 (info) domain=[FUNC]", "AO-D03 (info) domain=[FUNC]", "BQ-01 (warning) domain=[REQ]", "BQ-02 (warning) domain=[REQ]", "BQ-04 (warning) domain=[REQ]", "BQ-06 (warning) domain=[REQ]", "BQ-07 (warning) domain=[REQ]", "CA-01 (error) domain=[FUNC]", "CL-01 (warning) domain=[ACTOR]", "CR-01 (warning) domain=[MOD]", "CR-R01 (error) domain=[CR]", "CR-R02 (error) domain=[CR]", "CR-R03 (warning) domain=[all]", "CR-R04 (warning) domain=[CR]", "FC-01 (warning) domain=[FCHAIN]", "FC-02 (warning) domain=[UC]", "FC-03 (warning) domain=[FUNC]", "FC-04 (warning) domain=[FCHAIN]", "FM-01 (warning) domain=[REQ]", "FM-02 (warning) domain=[REQ]", "FM-03 (error) domain=[REQ]", "IO-01 (warning) domain=[FUNC]", "MS-01 (warning) domain=[MS]", "MS-02 (error) domain=[MS]", "MS-03 (info) domain=[CR]", "MT-01 (warning) domain=[MOD]", "MT-02 (info) domain=[MOD]", "ND-01 (error) domain=[FUNC]", "ND-02 (error) domain=[SCHEMA]", "NFR-01 (warning) domain=[FCHAIN,FUNC,MOD]", "PH-01 (info) domain=[MOD]", "R-01 (error) domain=[REQ]", "R-02 (warning) domain=[FUNC]", "R-03 (error) domain=[MOD]", "R-04 (warning) domain=[MOD]", "R-05 (warning) domain=[TEST]", "R-08 (error) domain=[all]", "R-10 (warning) domain=[FLOW]", "R-12 (warning) domain=[FUNC]", "R-14 (warning) domain=[UC]", "R-15 (warning) domain=[FCHAIN]", "R-16 (warning) domain=[ACTOR]", "R-17 (warning) domain=[SYS]", "R-18 (error) domain=[all]", "R-19 (warning) domain=[TEST]", "R-20 (warning) domain=[FUNC]", "R-21 (warning) domain=[FCHAIN]", "R-22 (warning) domain=[FUNC]", "R-23 (warning) domain=[MOD]", "R-26 (warning) domain=[SCHEMA]", "R-27 (warning) domain=[MOD]", "R-29 (error) domain=[TEST]", "R-30 (warning) domain=[FUNC]", "R-31 (warning) domain=[FUNC]", "RD-01 (warning) domain=[REQ]", "RD-02 (warning) domain=[REQ]", "RD-03 (info) domain=[REQ]", "RD-04 (warning) domain=[FUNC,MOD,SYS]", "RT-01 (error) domain=[FUNC]", "SC-02 (warning) domain=[SCHEMA]", "SC-04 (warning) domain=[FLOW]", "UC-01 (error) domain=[UC]", "UC-02 (error) domain=[UC]", "UC-03 (warning) domain=[UC]", "UC-04 (warning) domain=[UC]", "UC-05 (info) domain=[UC]", "UC-06 (info) domain=[UC]", "VR-01 (info) domain=[TEST]"];
+};

package/dist/se/grammar-snapshot.js

@@ -0,0 +1,184 @@
+/**
+ * GENERIERT — nicht von Hand pflegen.
+ *
+ * Das Golden-File der SE-Grammatik (CR-SM-244). Sein Diff IST der Changelog der Oberflaeche:
+ * jede Zeile hier ist ein Vertrag, an dem ein Konsument der Familie haengt. Erzeugt von
+ * `npm run grammar:snapshot -w @sigloch/contracts`, geprueft von
+ * `tests/unit/se-grammar-invariant.test.ts`.
+ *
+ * Wer diese Datei aendert, ohne die zugehoerige Version in ./index.ts zu bumpen, hat den Zweck
+ * verfehlt — `npm run check:grammar` faellt darueber.
+ */
+export const GRAMMAR_SNAPSHOT = {
+    versions: {
+        ontology: "7.0.0",
+        metaModel: "2.0.0",
+        rules: "6.0.0",
+    },
+    elementTypes: [
+        "ACTOR",
+        "CR",
+        "FCHAIN",
+        "FLOW",
+        "FUNC",
+        "MOD",
+        "MS",
+        "REQ",
+        "SCHEMA",
+        "SESSION",
+        "SYS",
+        "TEST",
+        "UC",
+    ],
+    traceTypes: [
+        "allocate",
+        "compose",
+        "io",
+        "produces",
+        "relation",
+        "satisfy",
+        "verify",
+    ],
+    patterns: [
+        "ACTOR -io-> FLOW",
+        "ACTOR -io-> UC",
+        "CR -relation-> FUNC",
+        "CR -relation-> MOD",
+        "CR -relation-> MS",
+        "CR -relation-> REQ",
+        "CR -relation-> UC",
+        "FCHAIN -compose-> FUNC [1..*]",
+        "FCHAIN -satisfy-> REQ",
+        "FLOW -io-> ACTOR",
+        "FLOW -io-> FUNC",
+        "FLOW -io-> UC",
+        "FLOW -relation-> SCHEMA",
+        "FUNC -allocate-> MOD",
+        "FUNC -compose-> FUNC [0..*]",
+        "FUNC -io-> FLOW",
+        "FUNC -satisfy-> REQ",
+        "MOD -compose-> MOD [0..*]",
+        "MOD -io-> MOD",
+        "MOD -satisfy-> REQ",
+        "MS -compose-> FUNC",
+        "MS -compose-> MS",
+        "MS -compose-> REQ",
+        "MS -compose-> UC",
+        "MS -relation-> MS",
+        "REQ -compose-> REQ [0..*]",
+        "SESSION -produces-> * (audit)",
+        "SYS -compose-> MOD [0..*]",
+        "SYS -compose-> REQ [0..*]",
+        "SYS -compose-> SYS [0..*]",
+        "SYS -compose-> UC [1..*]",
+        "SYS -satisfy-> REQ",
+        "TEST -verify-> REQ",
+        "UC -compose-> FCHAIN [1..*]",
+        "UC -compose-> REQ [1..*]",
+    ],
+    attributes: [
+        "CR.rationale: string",
+        "CR.spike: boolean",
+        "CR.status: enum",
+        "FLOW.protocol: string",
+        "FLOW.qos: string",
+        "FUNC.concept: boolean",
+        "FUNC.external: boolean",
+        "FUNC.measuredMs: number",
+        "FUNC.realRef: object",
+        "FUNC.safety_relevant: boolean",
+        "FUNC.sourceFile: string",
+        "FUNC.timingBudgetMs: number",
+        "MOD.concept: boolean",
+        "MOD.external: boolean",
+        "MOD.kind: string",
+        "MOD.path: string",
+        "MOD.realRef: object",
+        "REQ.detection: number",
+        "REQ.occurrence: number",
+        "REQ.severity: number",
+        "SCHEMA.concept: boolean",
+        "SCHEMA.contract: string",
+        "SCHEMA.external: boolean",
+        "SCHEMA.realRef: object",
+        "TEST.concept: boolean",
+        "TEST.sourceFile: string",
+        "TEST.testRefs: array",
+        "UC.operatingMode: string",
+    ],
+    rules: [
+        "AF-01 (warning) domain=[graph]",
+        "AF-02 (warning) domain=[graph]",
+        "AF-03 (warning) domain=[graph]",
+        "AF-04 (warning) domain=[graph]",
+        "AF-05 (warning) domain=[graph]",
+        "AO-D01 (info) domain=[FUNC]",
+        "AO-D03 (info) domain=[FUNC]",
+        "BQ-01 (warning) domain=[REQ]",
+        "BQ-02 (warning) domain=[REQ]",
+        "BQ-04 (warning) domain=[REQ]",
+        "BQ-06 (warning) domain=[REQ]",
+        "BQ-07 (warning) domain=[REQ]",
+        "CA-01 (error) domain=[FUNC]",
+        "CL-01 (warning) domain=[ACTOR]",
+        "CR-01 (warning) domain=[MOD]",
+        "CR-R01 (error) domain=[CR]",
+        "CR-R02 (error) domain=[CR]",
+        "CR-R03 (warning) domain=[all]",
+        "CR-R04 (warning) domain=[CR]",
+        "FC-01 (warning) domain=[FCHAIN]",
+        "FC-02 (warning) domain=[UC]",
+        "FC-03 (warning) domain=[FUNC]",
+        "FC-04 (warning) domain=[FCHAIN]",
+        "FM-01 (warning) domain=[REQ]",
+        "FM-02 (warning) domain=[REQ]",
+        "FM-03 (error) domain=[REQ]",
+        "IO-01 (warning) domain=[FUNC]",
+        "MS-01 (warning) domain=[MS]",
+        "MS-02 (error) domain=[MS]",
+        "MS-03 (info) domain=[CR]",
+        "MT-01 (warning) domain=[MOD]",
+        "MT-02 (info) domain=[MOD]",
+        "ND-01 (error) domain=[FUNC]",
+        "ND-02 (error) domain=[SCHEMA]",
+        "NFR-01 (warning) domain=[FCHAIN,FUNC,MOD]",
+        "PH-01 (info) domain=[MOD]",
+        "R-01 (error) domain=[REQ]",
+        "R-02 (warning) domain=[FUNC]",
+        "R-03 (error) domain=[MOD]",
+        "R-04 (warning) domain=[MOD]",
+        "R-05 (warning) domain=[TEST]",
+        "R-08 (error) domain=[all]",
+        "R-10 (warning) domain=[FLOW]",
+        "R-12 (warning) domain=[FUNC]",
+        "R-14 (warning) domain=[UC]",
+        "R-15 (warning) domain=[FCHAIN]",
+        "R-16 (warning) domain=[ACTOR]",
+        "R-17 (warning) domain=[SYS]",
+        "R-18 (error) domain=[all]",
+        "R-19 (warning) domain=[TEST]",
+        "R-20 (warning) domain=[FUNC]",
+        "R-21 (warning) domain=[FCHAIN]",
+        "R-22 (warning) domain=[FUNC]",
+        "R-23 (warning) domain=[MOD]",
+        "R-26 (warning) domain=[SCHEMA]",
+        "R-27 (warning) domain=[MOD]",
+        "R-29 (error) domain=[TEST]",
+        "R-30 (warning) domain=[FUNC]",
+        "R-31 (warning) domain=[FUNC]",
+        "RD-01 (warning) domain=[REQ]",
+        "RD-02 (warning) domain=[REQ]",
+        "RD-03 (info) domain=[REQ]",
+        "RD-04 (warning) domain=[FUNC,MOD,SYS]",
+        "RT-01 (error) domain=[FUNC]",
+        "SC-02 (warning) domain=[SCHEMA]",
+        "SC-04 (warning) domain=[FLOW]",
+        "UC-01 (error) domain=[UC]",
+        "UC-02 (error) domain=[UC]",
+        "UC-03 (warning) domain=[UC]",
+        "UC-04 (warning) domain=[UC]",
+        "UC-05 (info) domain=[UC]",
+        "UC-06 (info) domain=[UC]",
+        "VR-01 (info) domain=[TEST]",
+    ],
+};

package/dist/se/index.d.ts

@@ -5,9 +5,9 @@
 /** Ontology schema version (element types + trace types). */
 export declare const ONTOLOGY_VERSION = "7.0.0";
 /** Rules engine version (validation rules incl. RC conformance). */
-export declare const RULES_VERSION = "3.0.0";
+export declare const RULES_VERSION = "6.0.0";
 /** Meta-model version (trace pattern constraints + format-e parser). */
-export declare const META_MODEL_VERSION = "1.4.0";
+export declare const META_MODEL_VERSION = "2.0.0";
 export * from './ontology.js';
 export * from './rules.js';
 export * from './conformance-rules.js';

package/dist/se/index.js

@@ -5,9 +5,9 @@
 /** Ontology schema version (element types + trace types). */
 export const ONTOLOGY_VERSION = '7.0.0'; // BREAKING (CR-GC-366): das Trace-Pattern `FUNC -satisfy-> UC` entfaellt ersatzlos. Es war ein zweiter Weg vom Verhalten zum Use Case neben dem einzig tragenden `UC -compose-> FCHAIN -compose-> FUNC` — und der billigere: eine FUNC konnte einen UC bedienen, ohne in dessen Wirkkette zu stehen, womit IO-01 (FLOW-Pfade je Kettenpaar) und R-21 (Integrationstest je Kette) sie nie sahen. Die Abkuerzung umging genau die Pruefungen, die die Anbindung belastbar machen. Am graphcode-Selbstmodell waren 10 der 26 solchen Kanten reine Dopplung (die FUNC stand ohnehin in der FCHAIN), die restlichen 13 sind der Migrationsanlass. Jeder Graph mit solchen Kanten faellt jetzt R-18 (error) zur Last und muss migriert werden: FUNC in die FCHAIN des UC aufnehmen, satisfy-Kante loeschen. Prior: BREAKING (CR-SM-231b): das knotenweite `testResult` entfaellt — das Ergebnis haengt PRO `testRefs`-Eintrag (`result`, `ranAt`, `evidence`), aus demselben Grund wie `tool`. Ein einzelnes Ergebnis am Knoten konnte bei n Laeufen nicht sagen, welcher gemeint ist, und "einer rot, einer gruen" war gar nicht darstellbar — genau der Zustand, den ein Gate wissen muss. FM-03 liest jetzt "jeder Eintrag passed": "irgendeiner gruen" haette einen gruenen Unit-Lauf einen roten Visual-Lauf verdecken lassen. Ein Eintrag ohne Ergebnis ist nicht bestanden. VR-01 meldet die Dateien ohne Ergebnis statt nur den Knoten. Prior: BREAKING (CR-SM-231): `testRef` (Objekt) entfaellt ersatzlos zugunsten von `testRefs` (Array, min 1) — eine Abnahme, n Testdateien. Kein Union, kein Alias: ein Graph mit dem alten Attribut faellt R-19 zur Last und muss migriert werden. Anlass war ein Zaehl-Audit (537 laufende Tests in 67 Dateien, 14 TEST-Knoten mit je genau einer Datei, 53 Dateien an keine Abnahme gebunden) plus ein belegter Ausweichweg: dieselbe Spec-Datei stand im testRef ZWEIER TEST-Knoten, womit die Relation faktisch n:m war — ein roter Lauf keiner Abnahme mehr eindeutig zuordenbar, der TRR-Gate zaehlte dieselbe Evidenz doppelt. `tool` bleibt PRO EINTRAG: eine Abnahme mischt real die Runner (vitest + playwright). +AttributeSpec.type 'array' (testRefs ist das erste Listen-Attribut). Prior: BREAKING: `SemanticId` (`Name.TypeAbbr.Counter`) deleted, `ElementUid` (`<TYPE>-<slug>`) is the family canon — the old canon was used by no production graph of the family while 626 of 1145 elements already carried TYPE-slug (CR-SM-217); realRef unifies codeRef+schemaRef (+physical-MOD CAD ref), symbol optional; testRef stays separate (CR-228 C); +RepoRelativePathSchema on testRef/realRef .file — no absolute/`..` paths (CR-GC-255)
 /** Rules engine version (validation rules incl. RC conformance). */
-export const RULES_VERSION = '3.0.0'; // BREAKING (CR-GC-366): +R-30 Wirkketten-Bindung, +R-31 io-Verdrahtung, R-02 zieltyp-scharf. Die vier Pflichten einer FUNC (ein REQ erfuellen, verdrahtet sein, in einer Wirkkette haengen, in einem MOD wohnen) waren nur zu zweit geprueft: R-02 und R-22. R-30 schliesst die Kette — R-15 verlangte, dass eine FCHAIN Funktionen hat, niemand verlangte, dass eine Funktion zu einer FCHAIN gehoert; daran haengen aber IO-01 und R-21, die beide nur INNERHALB einer Kette pruefen. R-31 schliesst die Verdrahtung: R-10 stellt dieselbe Frage vom FLOW aus und sieht eine FUNC ohne jede io-Kante deshalb nie (sie kommt in der FLOW-Schleife nicht vor); nur ACTOR darf terminieren. Ein Befund je FUNC statt je fehlender Seite, sonst uebersteigt der Zaehler den Nenner-Beitrag (die Fehlmessung aus CR-SM-242). BREAKING ist R-02: der Filter war zieltyp-blind, ein `FUNC -satisfy-> UC` schaltete ihn stumm, obwohl kein Requirement erfuellt war — am Selbstmodell 6 von 33 Faellen verdeckt (gemeldet: 27). Messung am graphcode-Selbstmodell (82 FUNC): R-30 60, R-31 54 (52 ohne Eingang, 50 ohne Ausgang, 48 ohne beides), R-02 27->33, R-22 3, R-18 26 (die Migrationsschuld aus dem gestrichenen Pattern). Prior: CR-SM-242: R-10 (`['FUNC']`→`['FLOW']`), SC-04 (`['SCHEMA']`→`['FLOW']`) und IO-01 (`['MOD']`→`['FUNC']`) deklarieren jetzt den Typ, an dem sie WIRKLICH melden. Alle drei iterierten ueber einen anderen Typ als den deklarierten: ihre Verstoesse erhoehten den Zaehler einer Grundgesamtheit, zu der sie nicht gehoerten. Gemessen am graphcode-Graphen (46 FLOW / 55 FUNC / 20 SCHEMA / 10 MOD) hob das `schema` von 0.713 auf 0.783 — SC-04 zog 46 FLOW-Verstoesse gegen 20 SCHEMA; bei IO-01 uebertraf der Zaehler (21) den eigenen Nenner-Beitrag (10) schon, nur der Clamp verhinderte einen negativen Score. Kein Evaluator, keine Regel-Semantik und kein Gate-Urteil geaendert — nur die deklarierte Grundgesamtheit, wie bei CR-SM-239. Neu erzwungen durch `se-rule-domain-invariant.test.ts`: der Typ jedes gemeldeten Elements liegt in der `domain` der Regel (stumm fuer 29 der 72 Regeln, die auf den Fixtures nicht feuern). CR-SM-243 (dieselbe Auslieferung): genau dieser Test hat vier weitere Faelle gefunden, die von Hand nie auffielen — R-03 (`['FUNC']`→`['MOD']`, meldet am Modul, das ASIL-D und QM mischt), FC-03 (`['FCHAIN']`→`['FUNC']`, meldet am FUNC mit der verschachtelten Zerlegung), NFR-01 (`['FUNC']`→`['MOD','FUNC','FCHAIN']`, Budgets liegen physisch am MOD und verhaltensseitig an FUNC/FCHAIN) und CR-R03 (`['CR']`→`['all']`, meldet am getrackten Zielknoten beliebigen Typs — nach R-08/R-18 die dritte und bewusst begruendete `all`-Regel). Prior: CR-SM-239: AF-01..05 und R-28 deklarieren `domain: ['graph']` statt `['SYS']` — sie pruefen EINMAL den Graphen, nicht die SYS-Elemente. Als Ein-Element-Gruppe waren sie ein Nenner-Beitrag mit fast sicherem Verstoss und zogen jede sonst leere Dimension auf 0 %: ein Graph ohne eine einzige REQ las `req` = 0 % (1 - 2/2 aus AF-01/AF-03) statt „nichts zu messen", und die Fokuswahl schickte den Executor dorthin. Kein Regelverhalten geaendert — nur die deklarierte Grundgesamtheit. Prior: CR-SM-231: +R-29 Testdatei-Exklusivitaet (severity **error**) — 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. Bewusst schaerfer als R-19/R-20 (beide warning): eine doppelt beanspruchte Datei macht Gate-Zahlen nachweislich falsch, das ist eine Fehlmessung und kein Vollstaendigkeits-Signal. Rein graph-strukturell, kein I/O. R-19 und RC-02 lesen `testRefs`; RC-02 iteriert die Eintraege und nennt den konkreten Pfad statt nur der Knoten-ID. Prior: CR-SM-236: die letzten drei Urteilsschwellen sind Policy-Parameter statt Literal — CR-01 (`crossingFlows`, erstmals mit Aus-Zustand: `null` unterdrueckt auch die info je Modulpaar, die bisher die arch-Dimension verduennte), FM-03 (`riskRpn`, vorher inline 100) und R-04 (`moduleSize.{large,coupled,crossings}`, vorher inline 12/8/2 — drei Urteile, nicht eins). R-04 heisst jetzt 'Module size relative to crossing flows': die Regel waegt Groesse GEGEN Kreuzungen ab, der alte Name 'Max module size' verschwieg die zweite Haelfte der Bedingung. `RuleDefinition.evaluate` nimmt die Policy als zweiten Parameter, damit keine Familie einen Sonderweg braucht; einstellige Regelfunktionen bleiben zuweisbar. Bewertung unter DEFAULT_METRIC_POLICY unveraendert. Prior: CR-GC-315: R-12 + R-21 no longer tax FLOW reuse. R-12 restricted to dependency-carrying traces (compose/allocate/relation) — on `io` the only reachable shape was FUNC ─io→ FLOW ─io→ the SAME FUNC, i.e. read-modify-write on a shared FLOW, so the check was pure false-positive there (real io-cycles span ≥2 FUNCs and a 2-cycle test cannot see them); satisfy/verify/produces 2-cycles are pattern-illegal and belong to R-18. Its dedup key is now direction-independent (`type|sorted pair`) — keying on the message never collapsed anything, so every cycle was reported twice. R-21 no longer derives FUNC↔FUNC connections from FLOW co-adjacency alone: a producer/consumer pair with NO shared FCHAIN is silent. One hub FLOW with P producers and C consumers manufactured P·C findings, each demanding its own FCHAIN+integration test including pairs that never interact — reuse was penalised quadratically. The FCHAIN is the declared integration scope; the test is owed on that declared claim only. Rule intent (CR-GC-240 gap: unit/UC tests do not cover FUNC↔FUNC wiring) unchanged. Prior: CR-SM-227: +AF-01..05 Analysis-Freshness-Legs (analysis-freshness-rules.ts) — the third leg-kind a review gate checks (rule legs, layer-presence legs [R-28], now analysis-freshness legs, docs/articles/07-the-scoring-landscape.md); presence-only rules (Presence/Resolution-Split like R-19/R-20/R-26/R-27 vs. RC-01..05) checking a `graphVersion` freshness stamp exists under SYS.attributes.analysisFreshness.<AnalysisArtifactId> for each of the 5 CR-GC-221 judgment artifacts (conops/trade/assumption-review/fmea/implplan) — staleness (stamp vs live graphVersion) stays a consumer/I-O concern (`CreationCurrencyProvider`, @sigloch/graphcode-client), NOT evaluated here; Familie-Review 2026-08-05 gate assignment → RULE_TO_PHASE: ConOps/Trade/Assumption-Review → PDR, FMEA → CDR, Implementation Plan → TRR (SRR gets none); +AnalysisArtifactId enum + AnalysisFreshnessStampSchema (ontology.ts) as the SSOT graphcode-client's ARTIFACT_CATALOG analysis ids must match; grober Graph-Versions-Stempel only, no scope-hash in this first cut (conscious CR-SM-227 limitation).
+export const RULES_VERSION = '6.0.0'; // BREAKING (CR-SM-247): R-28 (Ebenen-Praesenz) entfaellt ersatzlos. Sie schloss das Vacuous-Complete-Loch — mit 0/1 FUNC feuert keine Pro-Element-Regel und jede Vollstaendigkeitsfrage liest 'fertig' —, ist seit CR-GC-366 aber doppelt: die FLOW-Haelfte traegt R-31 (je FUNC statt einmal je Graph) plus IO-01, die SCHEMA-Haelfte SC-04 (je FLOW). Probe (SYS+UC+FCHAIN+3 FUNC, ohne FLOW/SCHEMA): 28 Befunde aus 18 Regeln, ohne R-28 bleiben 17 — das Loch bleibt zu. Gemessen feuerte sie 1x/0x an den Selbstmodellen, dort neben 14x IO-01 und 10x R-31. Dimension und Gate bleiben besetzt (R-30/R-31 sind ebenfalls arch/PDR). Bewusst in Kauf genommen: die SCHEMA-Absenz rutscht von PDR nach CDR, weil SC-04 erst feuert, wenn FLOWs existieren. Als domain:['graph']-Regel trug sie keinen Nenner bei — kein Dimensions-Score verschiebt sich. Prior: MINOR (CR-SM-250): IO-01 prueft ERREICHBARKEIT im io-Teilgraphen der Kette statt Adjazenz jedes Paares. Die Regel forderte einen vollstaendigen Graphen (n·(n−1)/2 Paarungen), obwohl eine Wirkkette eine Sequenz ist — der Zaehler wuchs quadratisch mit der Kettenlaenge, der Nenner-Beitrag linear, und wer sie befriedigen wollte, erfand einen fachlich falschen FLOW oder baute einen Ketten-Bus. Dieselbe Korrektur wie CR-GC-315 fuer R-21, eine Ebene hoeher. Zwei Praezisierungen aus dem Grammar-Review: ein Befund je abgehaengtem Glied statt je Paar (sonst waeren zwei Komponenten der Groesse n/2 wieder n²/4 Befunde, Zaehler > Nenner-Beitrag), und gar nicht verdrahtete Glieder gehoeren R-31 — am sigloch-modules-Selbstmodell waren 6 der 7 IO-01-Elemente zugleich R-31-Elemente, also Doppelzaehlung derselben Ursache. Lockerung, kein heute gruener Graph wird rot. Prior: BREAKING (CR-SM-249): R-15 wird VERSCHAERFT und heisst jetzt 'FCHAIN completeness' — eine Kette braucht Funktionen UNTER sich UND einen UC UEBER sich. Zweites Bein unter derselben rule_id nach dem R-10-Muster (bis zu zwei Meldungen je FCHAIN), bewusst keine neue Regel-ID: eine ID kostet dauerhaft einen Nenner-Anteil, eine Katalogzeile, eine readiness-Zuordnung und einen Golden-File-Eintrag — fuer einen einzigen Befund ueber beide Selbstmodelle (Gate 6 des Grammatik-Reviews). Major, weil ein heute gruener Graph rot werden kann: seit Ontologie 7.0.0 ist `UC -compose-> FCHAIN -compose-> FUNC` der EINZIGE Pfad vom Verhalten zum Zweck, und geprueft war nur sein unteres Bein. Migration: eine Kette ohne UC unterstellen oder loeschen (graphcode: `FCHAIN-doc-export`, 1 Befund). Zweitens R-30: die Grundgesamtheit sind ab jetzt AUSSCHLIESSLICH Blaetter (FUNC ohne FUNC-Kinder), und die Aufwaerts-Vererbung aus CR-GC-366 entfaellt ersatzlos. Ein zerlegter FUNC ist ein Rollup seiner Kinder und DARF gar kein Kettenglied sein — FC-03 ('FCHAIN is flat') verbietet es; die erste Fassung forderte einen Zustand, den eine andere Regel untersagt (am graphcode-Gate quittiert: graphVersion 111, zurueckgenommen in 112). Die Vererbung konnte nur greifen, wenn ein Block Kettenglied ist, und haette sonst ein unverbundenes Blatt stumm geschaltet. R-30 allein waere ein Minor (es meldet weniger: 56 -> 43 am graphcode-Selbstmodell, die 13 Differenz sind exakt die Bloecke). ACHTUNG, Gate-Luecke: `check-grammar-version.mjs` sieht diese Aenderung NICHT — der Snapshot erfasst id/severity/domain, und alle drei bleiben gleich. Eine semantische Verschaerfung ist mit einem Oberflaechen-Abzug nicht greifbar; der Bump hier ist von Hand. Prior: BREAKING (CR-SM-245): MS-01 verliert den Legacy-Fallback `MS -compose-> *` ersatzlos — Scope ist ausschliesslich `CR -relation-> MS`. Der Fallback war ein zweiter Weg zu derselben Aussage: ein Meilenstein galt als befuellt, ohne dass ein CR auf ihn zeigte, womit MS-03 und jede Scope-Auswertung ihn nie sahen. Verschaerfung, deshalb major — gemessen faellt an den Selbstmodellen aber kein einziger Meilenstein (alle 7 in graphcode haben CR-Relationen, vier zusaetzlich compose; MS-01 bleibt 0 Befunde). Zweitens: '+MS-' in SE_PREFIXES — MS-01/02/03 lagen in KEINEM Profil (weder se noch coding) und liefen nur im default-Lauf. Die Dimension `ms` haengt an genau vier Regeln (MS-01/02/03 + AF-05), und AF-05 traegt als `domain: ['graph']`-Regel keinen Nenner bei — im se-Profil war `ms` damit ein strukturell leerer Topic-Score und das SRR-Gate um drei Legs aermer. Zweiter Fall der 'RD-'-Klasse (CR-SM-221), gefunden vom Profil-Test aus CR-SM-244. Prior: BREAKING (CR-GC-366): +R-30 Wirkketten-Bindung, +R-31 io-Verdrahtung, R-02 zieltyp-scharf. Die vier Pflichten einer FUNC (ein REQ erfuellen, verdrahtet sein, in einer Wirkkette haengen, in einem MOD wohnen) waren nur zu zweit geprueft: R-02 und R-22. R-30 schliesst die Kette — R-15 verlangte, dass eine FCHAIN Funktionen hat, niemand verlangte, dass eine Funktion zu einer FCHAIN gehoert; daran haengen aber IO-01 und R-21, die beide nur INNERHALB einer Kette pruefen. R-31 schliesst die Verdrahtung: R-10 stellt dieselbe Frage vom FLOW aus und sieht eine FUNC ohne jede io-Kante deshalb nie (sie kommt in der FLOW-Schleife nicht vor); nur ACTOR darf terminieren. Ein Befund je FUNC statt je fehlender Seite, sonst uebersteigt der Zaehler den Nenner-Beitrag (die Fehlmessung aus CR-SM-242). BREAKING ist R-02: der Filter war zieltyp-blind, ein `FUNC -satisfy-> UC` schaltete ihn stumm, obwohl kein Requirement erfuellt war — am Selbstmodell 6 von 33 Faellen verdeckt (gemeldet: 27). Messung am graphcode-Selbstmodell (82 FUNC): R-30 60, R-31 54 (52 ohne Eingang, 50 ohne Ausgang, 48 ohne beides), R-02 27->33, R-22 3, R-18 26 (die Migrationsschuld aus dem gestrichenen Pattern). Prior: CR-SM-242: R-10 (`['FUNC']`→`['FLOW']`), SC-04 (`['SCHEMA']`→`['FLOW']`) und IO-01 (`['MOD']`→`['FUNC']`) deklarieren jetzt den Typ, an dem sie WIRKLICH melden. Alle drei iterierten ueber einen anderen Typ als den deklarierten: ihre Verstoesse erhoehten den Zaehler einer Grundgesamtheit, zu der sie nicht gehoerten. Gemessen am graphcode-Graphen (46 FLOW / 55 FUNC / 20 SCHEMA / 10 MOD) hob das `schema` von 0.713 auf 0.783 — SC-04 zog 46 FLOW-Verstoesse gegen 20 SCHEMA; bei IO-01 uebertraf der Zaehler (21) den eigenen Nenner-Beitrag (10) schon, nur der Clamp verhinderte einen negativen Score. Kein Evaluator, keine Regel-Semantik und kein Gate-Urteil geaendert — nur die deklarierte Grundgesamtheit, wie bei CR-SM-239. Neu erzwungen durch `se-rule-domain-invariant.test.ts`: der Typ jedes gemeldeten Elements liegt in der `domain` der Regel (stumm fuer 29 der 72 Regeln, die auf den Fixtures nicht feuern). CR-SM-243 (dieselbe Auslieferung): genau dieser Test hat vier weitere Faelle gefunden, die von Hand nie auffielen — R-03 (`['FUNC']`→`['MOD']`, meldet am Modul, das ASIL-D und QM mischt), FC-03 (`['FCHAIN']`→`['FUNC']`, meldet am FUNC mit der verschachtelten Zerlegung), NFR-01 (`['FUNC']`→`['MOD','FUNC','FCHAIN']`, Budgets liegen physisch am MOD und verhaltensseitig an FUNC/FCHAIN) und CR-R03 (`['CR']`→`['all']`, meldet am getrackten Zielknoten beliebigen Typs — nach R-08/R-18 die dritte und bewusst begruendete `all`-Regel). Prior: CR-SM-239: AF-01..05 und R-28 deklarieren `domain: ['graph']` statt `['SYS']` — sie pruefen EINMAL den Graphen, nicht die SYS-Elemente. Als Ein-Element-Gruppe waren sie ein Nenner-Beitrag mit fast sicherem Verstoss und zogen jede sonst leere Dimension auf 0 %: ein Graph ohne eine einzige REQ las `req` = 0 % (1 - 2/2 aus AF-01/AF-03) statt „nichts zu messen", und die Fokuswahl schickte den Executor dorthin. Kein Regelverhalten geaendert — nur die deklarierte Grundgesamtheit. Prior: CR-SM-231: +R-29 Testdatei-Exklusivitaet (severity **error**) — 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. Bewusst schaerfer als R-19/R-20 (beide warning): eine doppelt beanspruchte Datei macht Gate-Zahlen nachweislich falsch, das ist eine Fehlmessung und kein Vollstaendigkeits-Signal. Rein graph-strukturell, kein I/O. R-19 und RC-02 lesen `testRefs`; RC-02 iteriert die Eintraege und nennt den konkreten Pfad statt nur der Knoten-ID. Prior: CR-SM-236: die letzten drei Urteilsschwellen sind Policy-Parameter statt Literal — CR-01 (`crossingFlows`, erstmals mit Aus-Zustand: `null` unterdrueckt auch die info je Modulpaar, die bisher die arch-Dimension verduennte), FM-03 (`riskRpn`, vorher inline 100) und R-04 (`moduleSize.{large,coupled,crossings}`, vorher inline 12/8/2 — drei Urteile, nicht eins). R-04 heisst jetzt 'Module size relative to crossing flows': die Regel waegt Groesse GEGEN Kreuzungen ab, der alte Name 'Max module size' verschwieg die zweite Haelfte der Bedingung. `RuleDefinition.evaluate` nimmt die Policy als zweiten Parameter, damit keine Familie einen Sonderweg braucht; einstellige Regelfunktionen bleiben zuweisbar. Bewertung unter DEFAULT_METRIC_POLICY unveraendert. Prior: CR-GC-315: R-12 + R-21 no longer tax FLOW reuse. R-12 restricted to dependency-carrying traces (compose/allocate/relation) — on `io` the only reachable shape was FUNC ─io→ FLOW ─io→ the SAME FUNC, i.e. read-modify-write on a shared FLOW, so the check was pure false-positive there (real io-cycles span ≥2 FUNCs and a 2-cycle test cannot see them); satisfy/verify/produces 2-cycles are pattern-illegal and belong to R-18. Its dedup key is now direction-independent (`type|sorted pair`) — keying on the message never collapsed anything, so every cycle was reported twice. R-21 no longer derives FUNC↔FUNC connections from FLOW co-adjacency alone: a producer/consumer pair with NO shared FCHAIN is silent. One hub FLOW with P producers and C consumers manufactured P·C findings, each demanding its own FCHAIN+integration test including pairs that never interact — reuse was penalised quadratically. The FCHAIN is the declared integration scope; the test is owed on that declared claim only. Rule intent (CR-GC-240 gap: unit/UC tests do not cover FUNC↔FUNC wiring) unchanged. Prior: CR-SM-227: +AF-01..05 Analysis-Freshness-Legs (analysis-freshness-rules.ts) — the third leg-kind a review gate checks (rule legs, layer-presence legs [R-28], now analysis-freshness legs, docs/articles/07-the-scoring-landscape.md); presence-only rules (Presence/Resolution-Split like R-19/R-20/R-26/R-27 vs. RC-01..05) checking a `graphVersion` freshness stamp exists under SYS.attributes.analysisFreshness.<AnalysisArtifactId> for each of the 5 CR-GC-221 judgment artifacts (conops/trade/assumption-review/fmea/implplan) — staleness (stamp vs live graphVersion) stays a consumer/I-O concern (`CreationCurrencyProvider`, @sigloch/graphcode-client), NOT evaluated here; Familie-Review 2026-08-05 gate assignment → RULE_TO_PHASE: ConOps/Trade/Assumption-Review → PDR, FMEA → CDR, Implementation Plan → TRR (SRR gets none); +AnalysisArtifactId enum + AnalysisFreshnessStampSchema (ontology.ts) as the SSOT graphcode-client's ARTIFACT_CATALOG analysis ids must match; grober Graph-Versions-Stempel only, no scope-hash in this first cut (conscious CR-SM-227 limitation).
 /** Meta-model version (trace pattern constraints + format-e parser). */
-export const META_MODEL_VERSION = '1.4.0'; // -REQ→MOD allocate pattern removed (CR-228 A); +FUNC→FUNC compose (blackbox function decomposition)
+export const META_MODEL_VERSION = '2.0.0'; // BREAKING, zwei Anlaesse in einer Zahl. (1) Nachtrag zu CR-GC-366: dort entfiel das Trace-Pattern `FUNC -satisfy-> UC`, gebumpt wurde aber nur ONTOLOGY_VERSION — nach der in CR-SM-244 festgeschriebenen Zustaendigkeit (meta-model.ts + format-e-Parser -> META_MODEL_VERSION) fehlte der Bump hier. Eine Entfernung ist major; dass kein Konsument semver-maessig auf diese Konstante verzweigt (schema-guard.ts keyt bewusst auf einen DDL-Fingerprint), macht sie nicht kleiner, nur folgenlos fuer die Bump-Kette. (2) CR-SM-251: `hydrateAttrValue` hydriert typ-geleitet ueber ELEMENT_ATTRIBUTES — boolean/number-Attribute kamen ueber BEIDE Format-E-Pfade als String an, womit die elf `=== true`-Vergleiche in den Regeln jede Ausnahme (concept/external/safety_relevant/spike) ins Leere laufen liessen und ein Export-Reimport bestehende Ausnahmen still entwertete. Verhaltensaenderung am Parser, also hier verbucht. Prior: -REQ→MOD allocate pattern removed (CR-228 A); +FUNC→FUNC compose (blackbox function decomposition)
 export * from './ontology.js';
 export * from './rules.js';
 export * from './conformance-rules.js';

package/dist/se/ontology.d.ts

@@ -199,7 +199,7 @@ export type AnalysisArtifactId = z.infer<typeof AnalysisArtifactId>;
  * artifact was written — I/O, so writing it stays a consumer (graphcode)
  * concern; contracts only defines the shape.
  * Stored under `OntologyElement.attributes.analysisFreshness.<AnalysisArtifactId>`
- * on the SYS root element (same anchor convention as R-28).
+ * on the SYS root element (the anchor convention of the graph-wide AF-01..05 rules).
  */
 export declare const AnalysisFreshnessStampSchema: z.ZodObject<{
     graphVersion: z.ZodNumber;

package/dist/se/ontology.js

@@ -147,7 +147,7 @@ export const AnalysisArtifactId = z.enum(['conops', 'fmea', 'trade', 'implplan',
  * artifact was written — I/O, so writing it stays a consumer (graphcode)
  * concern; contracts only defines the shape.
  * Stored under `OntologyElement.attributes.analysisFreshness.<AnalysisArtifactId>`
- * on the SYS root element (same anchor convention as R-28).
+ * on the SYS root element (the anchor convention of the graph-wide AF-01..05 rules).
  */
 export const AnalysisFreshnessStampSchema = z.object({
     graphVersion: z.number().int().nonnegative(),

package/dist/se/readiness.js

@@ -58,11 +58,9 @@ export const RULE_TO_DIMENSION = {
     // 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',
     // CR-GC-366: R-30 (Wirkketten-Bindung) und R-31 (io-Verdrahtung) bewerten beide, ob ein
-    // Funktionsblock ueberhaupt im Bauplan haengt — dieselbe Dimension wie R-20 (realRef) und
-    // R-28 (Ebenen-Praesenz). NICHT 'uc': R-14..R-17 fragen, ob ein Behaelter gefuellt ist;
+    // Funktionsblock ueberhaupt im Bauplan haengt — dieselbe Dimension wie R-20 (realRef).
+    // NICHT 'uc': R-14..R-17 fragen, ob ein Behaelter gefuellt ist;
     // diese beiden fragen von der FUNC aus, ob sie angeschlossen ist.
     'R-30': 'arch', 'R-31': 'arch',
     // uc
@@ -153,7 +151,6 @@ export const RULE_TO_PHASE = {
     'R-04': 'PDR', 'R-22': 'PDR', 'R-23': 'PDR',
     'R-15': 'PDR',
     'FC-01': 'PDR', 'FC-03': 'PDR', 'FC-04': 'PDR',
-    'R-28': 'PDR', // Ebenen-Präsenz (CR-SM-226)
     // CR-GC-366: Anschluss des Funktionsbaus — gehoert an dasselbe Gate wie R-15/IO-01,
     // die auf derselben Kette aufsetzen.
     'R-30': 'PDR', 'R-31': 'PDR',

package/dist/se/rules.d.ts

@@ -174,7 +174,7 @@ export interface RuleDefinition {
      *
      * **CR-SM-239 — „ganzer Graph" ist etwas anderes als „diese Gruppe".** `['graph']` markiert
      * eine Regel, die **einmal je Graph** prueft statt ueber eine Elementmenge: die
-     * Analyse-Freshness-Stempel (AF-01..05) und die Ebenen-Praesenz (R-28). Sie tragen KEINE
+     * Analyse-Freshness-Stempel (AF-01..05). Sie tragen KEINE
      * Grundgesamtheit bei, denn sie haben keine — der Stempel haengt zwar unter SYS, geprueft
      * wird aber der Graph, nicht das Element.
      *

package/dist/se/rules.js

@@ -510,25 +510,53 @@ function ucMustHaveCompose(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// R-15: FCHAIN must have at least 1 compose trace (→ FUNC) (CR-117)
+// R-15: FCHAIN completeness — a chain needs functions BELOW it and a use case
+// ABOVE it (CR-117, second leg CR-SM-249).
+//
+// Der tragende Pfad vom Verhalten zum Zweck ist `UC -compose-> FCHAIN
+// -compose-> FUNC` (seit Ontologie 7.0.0 der einzige). Geprueft war nur das
+// untere Bein: R-15 verlangte Funktionen unter der Kette, niemand verlangte
+// einen UC ueber ihr. Eine Kette ohne UC beantwortet die Leitfrage "welche
+// Wirkkette ist betroffen, wenn ich diese Funktion aendere?" auf halbem Weg.
+// Belegt: `FCHAIN-doc-export` (graphcode) traegt zwei Funktionen und dient
+// keinem UC.
+//
+// Dieselbe rule_id fuer beide Beine, nach dem Muster von R-10 (FLOW braucht
+// Produzent UND Konsument): ein Belang, eine ID, bis zu zwei Meldungen je
+// Element. Eine eigene ID kostete dauerhaft einen Nenner-Anteil, eine
+// Katalogzeile, eine readiness-Zuordnung und einen Golden-File-Eintrag — fuer
+// einen einzigen Befund ueber beide Selbstmodelle.
 // ---------------------------------------------------------------------------
-function fchainMustHaveCompose(graph) {
+function fchainCompleteness(graph) {
     const fchains = graph.elements.filter(e => e.type === 'FCHAIN');
     const funcs = graph.elements.filter(e => e.type === 'FUNC');
-    return fchains
-        .filter(fc => !graph.traces.some(t => t.source === fc.id && t.type === 'compose'))
-        .map(fc => ({
-        rule_id: 'R-15',
-        severity: 'warning',
-        element_id: fc.id,
-        message: `${fc.id} has no compose traces (no functions in chain)`,
-        fix_hint: 'Add FUNC elements via compose trace',
-        context: {
-            element_type: fc.type,
-            element_name: fc.name,
-            candidate_targets: toCandidates(funcs),
-        },
-    }));
+    const ucs = graph.elements.filter(e => e.type === 'UC');
+    const ucIds = new Set(ucs.map(u => u.id));
+    const violations = [];
+    for (const fc of fchains) {
+        const ctx = { element_type: fc.type, element_name: fc.name };
+        if (!graph.traces.some(t => t.source === fc.id && t.type === 'compose')) {
+            violations.push({
+                rule_id: 'R-15',
+                severity: 'warning',
+                element_id: fc.id,
+                message: `${fc.id} has no compose traces (no functions in chain)`,
+                fix_hint: 'Add FUNC elements via compose trace',
+                context: { ...ctx, candidate_targets: toCandidates(funcs) },
+            });
+        }
+        if (!graph.traces.some(t => t.target === fc.id && t.type === 'compose' && ucIds.has(t.source))) {
+            violations.push({
+                rule_id: 'R-15',
+                severity: 'warning',
+                element_id: fc.id,
+                message: `${fc.id} serves no use case (no UC -compose-> FCHAIN)`,
+                fix_hint: 'Attach the chain to the use case it realises (UC -compose-> FCHAIN)',
+                context: { ...ctx, candidate_targets: toCandidates(ucs, fc) },
+            });
+        }
+    }
+    return violations;
 }
 // ---------------------------------------------------------------------------
 // R-16: ACTOR must have at least 1 io trace (CR-117)
@@ -571,18 +599,19 @@ function sysMustHaveCompose(graph) {
 // ---------------------------------------------------------------------------
 // MS-01: Milestone without scope — no CRs assigned via CR→MS [relation]
 // (CR-207: scope = CRs pointing to this MS, not compose children)
+//
+// CR-SM-245: der Legacy-Fallback (`MS -compose-> *` zaehlt auch als Scope) ist ersatzlos weg.
+// Er war ein zweiter Weg zu derselben Aussage neben der einzig tragenden `CR -relation-> MS` —
+// und der billigere: ein Meilenstein galt als befuellt, ohne dass ein einziger CR auf ihn zeigte,
+// womit MS-03 (CR ohne Milestone) und jede Scope-Auswertung ihn nie sahen. Gemessen am
+// graphcode-Selbstmodell aendert die Entfernung nichts (alle 7 MS haben CR-Relationen, vier
+// zusaetzlich compose) — genau deshalb ist jetzt der Zeitpunkt.
 // ---------------------------------------------------------------------------
 function msEmptyScope(graph) {
-    const milestones = graph.elements.filter(e => e.type === 'MS');
-    return milestones
-        .filter(ms => {
-        // Check: any CR → MS [relation] trace?
-        const hasCr = graph.traces.some(t => t.type === 'relation' && t.target === ms.id &&
-            graph.elements.some(e => e.id === t.source && e.type === 'CR'));
-        // Fallback: legacy compose traces still count
-        const hasCompose = graph.traces.some(t => t.source === ms.id && t.type === 'compose');
-        return !hasCr && !hasCompose;
-    })
+    const crIds = new Set(graph.elements.filter(e => e.type === 'CR').map(e => e.id));
+    return graph.elements
+        .filter(e => e.type === 'MS')
+        .filter(ms => !graph.traces.some(t => t.type === 'relation' && t.target === ms.id && crIds.has(t.source)))
         .map(ms => ({
         rule_id: 'MS-01',
         severity: 'warning',
@@ -989,92 +1018,61 @@ function physicalModMustHaveRealRef(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// R-28: Ebenen-Präsenz — architecture-level presence (CR-SM-226).
-// Closes the vacuous-complete hole: with 0 or 1 FUNC, per-element rules like
-// R-15/FC-04/SC-04 fire 0 times and every completeness leg reads "complete" —
-// not because the architecture is done, but because there is nothing to check
-// yet. Once >1 FUNC exists, the graph must ALSO carry at least one FLOW (data
-// moves between functions) AND at least one SCHEMA (that data has a
-// contract) — ONE combined rule, not staged PDR/CDR checks (the CR draft's
-// two-stage proposal was simplified in Familie-Review 2026-08-04).
+// R-28 (Ebenen-Präsenz) ist mit CR-SM-247 ersatzlos entfallen — nicht weil sie falsch war,
+// sondern weil sie seit CR-GC-366 doppelt ist. Sie schloss das Vacuous-Complete-Loch (mit 0/1
+// FUNC feuert keine Pro-Element-Regel, alles liest "fertig"); beide Hälften trägt heute je eine
+// präzisere Regel: kein FLOW → R-31 (io-Verdrahtung, je FUNC statt einmal je Graph) + IO-01,
+// kein SCHEMA → SC-04 (je FLOW). Probe (SYS+UC+FCHAIN+3 FUNC, ohne FLOW/SCHEMA): 28 Befunde aus
+// 18 Regeln, ohne R-28 bleiben 17 — das Loch bleibt zu. Gemessen feuerte sie 1× / 0× an den
+// Selbstmodellen, dort neben 14× IO-01 und 10× R-31. Bewusst in Kauf genommen: die
+// SCHEMA-Absenz rutscht von PDR nach CDR, weil SC-04 erst feuert, wenn FLOWs existieren.
 // ---------------------------------------------------------------------------
-function ebenenPraesenz(graph) {
-    const funcs = graph.elements.filter(e => e.type === 'FUNC');
-    if (funcs.length <= 1)
-        return [];
-    const flows = graph.elements.filter(e => e.type === 'FLOW');
-    const schemas = graph.elements.filter(e => e.type === 'SCHEMA');
-    const missingLevels = [];
-    if (flows.length === 0)
-        missingLevels.push('FLOW');
-    if (schemas.length === 0)
-        missingLevels.push('SCHEMA');
-    if (missingLevels.length === 0)
-        return [];
-    // Anchor the graph-wide violation on SYS (the root) if present, else the
-    // first FUNC — there is no single "population" element this rule checks.
-    const anchor = graph.elements.find(e => e.type === 'SYS') ?? funcs[0];
-    return [{
-            rule_id: 'R-28',
-            severity: 'warning',
-            element_id: anchor.id,
-            message: `Graph has ${funcs.length} FUNCs but no ${missingLevels.join(' and no ')} element — architecture level(s) absent`,
-            fix_hint: `Add at least one ${missingLevels.join(' and one ')} element to bind the functional and data-level architecture`,
-            context: { element_type: anchor.type, element_name: anchor.name },
-        }];
-}
 // ---------------------------------------------------------------------------
-// R-30: FUNC gehoert in eine Wirkkette (CR-GC-366)
-// Die Ontologie deckte nur die Gegenrichtung ab: R-15 verlangt, dass eine FCHAIN
-// Funktionen hat — niemand verlangte, dass eine Funktion zu einer FCHAIN gehoert.
-// Genau daran haengt aber die uebrige Absicherung: IO-01 bildet FLOW-Pfade nur
-// zwischen FUNCs DERSELBEN Kette, R-21 fordert den Integrationstest je Kette.
-// Eine FUNC ausserhalb jeder Kette faellt durch beide Netze, ohne dass etwas meldet.
-// Severity warning, nicht error: am Selbstmodell trifft es 60 von 82 FUNC — ein
-// error wuerde ueber das Delta-Gate jede weitere Mutation blockieren und waere
-// Neubau-Zwang statt Steuerung.
+// R-30: jedes BLATT gehoert in eine Wirkkette (CR-GC-366, Grundgesamtheit
+// korrigiert in CR-SM-249).
+//
+// Die Ontologie deckte nur die Gegenrichtung ab: R-15 verlangt, dass eine
+// FCHAIN Funktionen hat — niemand verlangte, dass eine Funktion zu einer
+// FCHAIN gehoert. Genau daran haengt aber die uebrige Absicherung: IO-01
+// bildet FLOW-Pfade nur zwischen FUNCs DERSELBEN Kette, R-21 fordert den
+// Integrationstest je Kette. Eine FUNC ausserhalb jeder Kette faellt durch
+// beide Netze, ohne dass etwas meldet.
+//
+// Grundgesamtheit sind AUSSCHLIESSLICH Blaetter (FUNC ohne FUNC-Kinder). Ein
+// zerlegter FUNC ist ein Rollup seiner Kinder und hat keinen eigenen
+// Bindungszustand — er *darf* auch keinen haben: FC-03 ("FCHAIN is flat")
+// verbietet ein Kettenglied mit verschachtelter Zerlegung. Die erste Fassung
+// forderte damit einen Zustand, den eine andere Regel untersagt; am
+// graphcode-Gate quittiert (graphVersion 111, zurueckgenommen in 112).
+//
+// Die Aufwaerts-Vererbung aus CR-GC-366 ("ein Vorfahre steht in einer Kette →
+// Kind frei") entfaellt ersatzlos: sie konnte nur greifen, wenn ein Block
+// Kettenglied ist, und haette sonst ein unverbundenes Blatt stumm geschaltet.
+// Die Anforderung liegt jetzt vollstaendig auf den Blaettern — der Block wird
+// gruen, ohne je eine eigene Kante zu tragen.
+//
+// Severity warning, nicht error: am Selbstmodell trifft es 43 von 69 Blaettern
+// — ein error wuerde ueber das Delta-Gate jede weitere Mutation blockieren und
+// waere Neubau-Zwang statt Steuerung.
 // ---------------------------------------------------------------------------
 function funcMustBeInEffectChain(graph) {
     const funcs = graph.elements.filter(e => e.type === 'FUNC');
     const fchains = graph.elements.filter(e => e.type === 'FCHAIN');
     const funcIds = new Set(funcs.map(f => f.id));
     const fchainIds = new Set(fchains.map(fc => fc.id));
+    const decomposed = new Set(graph.traces
+        .filter(t => t.type === 'compose' && funcIds.has(t.source) && funcIds.has(t.target))
+        .map(t => t.source));
     const inChain = new Set(graph.traces
         .filter(t => t.type === 'compose' && fchainIds.has(t.source) && funcIds.has(t.target))
         .map(t => t.target));
-    // Zerlegung erbt Mitgliedschaft nach unten: steht der Elternteil in einer Kette,
-    // sind seine Kinder dessen Realisierung eine Ebene tiefer (TRACE_PATTERNS
-    // `FUNC -compose-> FUNC`) und damit mitgebunden. Ohne diesen Schritt meldete die
-    // Regel jede Sub-Funktion eines Kettenmitglieds als Waise — ein Fehlbefund aus
-    // der Ontologie selbst. Am Selbstmodell aendert der Schritt heute nichts
-    // (Zerlegungsbaum und Ketten sind dort disjunkt), er verhindert den Fehlbefund
-    // fuer jedes Modell, das beides kombiniert.
-    const parentOf = new Map();
-    for (const t of graph.traces) {
-        if (t.type === 'compose' && funcIds.has(t.source) && funcIds.has(t.target)) {
-            parentOf.set(t.target, t.source);
-        }
-    }
-    const reachesChain = (start) => {
-        const seen = new Set([start]);
-        let cur = start;
-        while (cur) {
-            if (inChain.has(cur))
-                return true;
-            cur = parentOf.get(cur);
-            if (!cur || seen.has(cur))
-                return false;
-            seen.add(cur);
-        }
-        return false;
-    };
     return funcs
-        .filter(fn => !reachesChain(fn.id))
+        .filter(fn => !decomposed.has(fn.id) && !inChain.has(fn.id))
         .map(fn => ({
         rule_id: 'R-30',
         severity: 'warning',
         element_id: fn.id,
-        message: `${fn.id} belongs to no function chain (no FCHAIN compose, directly or via a parent FUNC)`,
+        message: `${fn.id} belongs to no function chain (no FCHAIN -compose-> FUNC)`,
         fix_hint: 'Add the FUNC to the FCHAIN of the use case it serves (FCHAIN -compose-> FUNC)',
         context: {
             element_type: fn.type,
@@ -1131,7 +1129,7 @@ export const V3_RULES = [
     { 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-15', name: 'FCHAIN completeness', severity: 'warning', evaluate: fchainCompleteness, 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'] },
@@ -1155,8 +1153,7 @@ export const V3_RULES = [
     { 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: ['graph'] },
-    { id: 'R-30', name: 'FUNC must belong to a function chain', severity: 'warning', evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },
+    { id: 'R-30', name: 'FUNC leaf must belong to a function chain', severity: 'warning', evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },
     { id: 'R-31', name: 'FUNC must be wired (io input + output)', severity: 'warning', evaluate: funcMustBeWired, domain: ['FUNC'] },
 ];
 /** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,11 +24,14 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
+    "pretest": "node scripts/check-grammar-version.mjs",
     "test": "vitest run",
-    "prepublishOnly": "npm run build && npm run test"
+    "check:grammar": "node scripts/check-grammar-version.mjs",
+    "grammar:snapshot": "SE_WRITE_GRAMMAR_SNAPSHOT=1 vitest run tests/unit/se-grammar-invariant.test.ts",
+    "prepublishOnly": "npm run build && npm run test",
+    "grammar:measure": "SE_MEASURE=1 vitest run tests/unit/se-grammar-measure.test.ts"
   },
   "dependencies": {
-    "@sigloch/contracts": "^4.1.0",
     "zod": "^4.3.6"
   },
   "license": "MIT",