@sigloch/contracts 4.1.0 → 5.0.0

package/dist/se/ao-rules.js

@@ -343,7 +343,10 @@ export const AO_RULES = [
     { id: 'RT-01', name: 'PhysicalBoundaryIntegrity', severity: 'error', evaluate: rt01PhysicalBoundaryIntegrity, domain: ['FUNC'] },
     { id: 'PH-01', name: 'PhysicalModCompleteness', severity: 'info', evaluate: ph01PhysicalModCompleteness, domain: ['MOD'] },
     { id: 'CA-01', name: 'CapabilityAllocation', severity: 'error', evaluate: ca01CapabilityAllocation, domain: ['FUNC'] },
-    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness, domain: ['MOD'] },
+    // CR-SM-242: domain ist FUNC, nicht MOD — die Regel laeuft ueber FUNC-Paare in FCHAINs und
+    // meldet am FUNC. Mit ['MOD'] uebertraf ihr Zaehler (21) ihren eigenen Nenner-Beitrag (10);
+    // nur der Clamp verhinderte einen negativen Score.
+    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness, domain: ['FUNC'] },
 ];
 export function evaluateAORules(graph, policy) {
     return AO_RULES.flatMap(r => r.evaluate(graph, policy));

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

@@ -132,7 +132,12 @@ function crShouldHaveMilestone(graph) {
 export const CR_RULES = [
     { id: 'CR-R01', name: 'CR must track', severity: 'error', evaluate: crMustTrack, domain: ['CR'] },
     { id: 'CR-R02', name: 'Done requires commit', severity: 'error', evaluate: crDoneRequiresCommit, domain: ['CR'] },
-    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation, domain: ['CR'] },
+    // CR-SM-243: domain ist 'all', nicht CR — die Regel meldet am getrackten ZIELKNOTEN
+    // ("dieser Knoten wird von 2 offenen CRs angefasst"), und der kann jeden Typ haben. Eine
+    // Aufzaehlung waere eine Momentaufnahme der heute getrackten Typen, kein Modell; 'all'
+    // (= alle Elemente) ist die einzige Menge, aus der der Zielknoten garantiert stammt.
+    // Damit ist sie nach R-08/R-18 die dritte 'all'-Regel — bewusst, nicht vergessen.
+    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation, domain: ['all'] },
     { id: 'CR-R04', name: 'CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc, domain: ['CR'] },
     { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone, domain: ['CR'] },
 ];

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

@@ -140,7 +140,10 @@ export function fc04ActorBounded(graph) {
 export const FC_RULES = [
     { id: 'FC-01', name: 'FCHAIN has actor boundary', severity: 'warning', evaluate: fc01ActorBoundary, domain: ['FCHAIN'] },
     { id: 'FC-02', name: 'Leaf UC has FCHAIN', severity: 'warning', evaluate: fc02LeafUcHasFchain, domain: ['UC'] },
-    { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat, domain: ['FCHAIN'] },
+    // CR-SM-243: domain ist FUNC, nicht FCHAIN — die Regel meldet am FUNC mit der
+    // verschachtelten Zerlegung. Die FCHAIN ist der Suchraum, nicht die Grundgesamtheit:
+    // eine Kette mit n verschachtelten FUNCs erzeugt n Verstoesse gegen einen Beitrag von 1.
+    { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat, domain: ['FUNC'] },
     { id: 'FC-04', name: 'FCHAIN actor-bounded (trigger+consumer)', severity: 'warning', evaluate: fc04ActorBounded, domain: ['FCHAIN'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —

package/dist/se/fmea-rules.js

@@ -167,7 +167,11 @@ export const FM_RULES = [
     { id: 'FM-01', name: 'RiskReqFmeaAttributes', severity: 'warning', evaluate: fm01MissingFmeaAttributes, domain: ['REQ'] },
     { id: 'FM-02', name: 'RiskReqMitigation', severity: 'warning', evaluate: fm02MissingMitigation, domain: ['REQ'] },
     { id: 'FM-03', name: 'HighRiskVerification', severity: 'error', evaluate: fm03HighRiskUnverified, domain: ['REQ'] },
-    { id: 'NFR-01', name: 'BudgetOvershoot', severity: 'warning', evaluate: nfr01BudgetOvershoot, domain: ['FUNC'] },
+    // CR-SM-243: die Regel prueft drei Typen, nicht einen — physische Budgets am MOD
+    // (PHYSICAL_BUDGET_TYPES), Verhaltensbudgets an FUNC und FCHAIN (BEHAVIORAL_BUDGET_TYPES).
+    // Die domain nennt dieselben Mengen wie die beiden Konstanten oben; wer eine davon
+    // erweitert, zieht diese Zeile mit.
+    { id: 'NFR-01', name: 'BudgetOvershoot', severity: 'warning', evaluate: nfr01BudgetOvershoot, domain: ['MOD', 'FUNC', 'FCHAIN'] },
 ];
 export function evaluateFMRules(graph, policy) {
     return FM_RULES.flatMap(rule => rule.evaluate(graph, policy));

package/dist/se/index.d.ts

@@ -3,9 +3,9 @@
  * Single source of truth for SE ontology schemas across all projects.
  */
 /** Ontology schema version (element types + trace types). */
-export declare const ONTOLOGY_VERSION = "6.0.0";
+export declare const ONTOLOGY_VERSION = "7.0.0";
 /** Rules engine version (validation rules incl. RC conformance). */
-export declare const RULES_VERSION = "2.27.0";
+export declare const RULES_VERSION = "3.0.0";
 /** Meta-model version (trace pattern constraints + format-e parser). */
 export declare const META_MODEL_VERSION = "1.4.0";
 export * from './ontology.js';

package/dist/se/index.js

@@ -3,9 +3,9 @@
  * Single source of truth for SE ontology schemas across all projects.
  */
 /** Ontology schema version (element types + trace types). */
-export const ONTOLOGY_VERSION = '6.0.0'; // 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)
+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 = '2.27.0'; // 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 = '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).
 /** 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 * from './ontology.js';

package/dist/se/meta-model.js

@@ -20,7 +20,14 @@ export const TRACE_PATTERNS = [
     { source: 'MOD', target: 'MOD', type: 'io', description: 'Module communicates with module (ACL)' },
     // ── satisfy (implementation) ──
     { source: 'FUNC', target: 'REQ', type: 'satisfy', description: 'Function implements requirement' },
-    { source: 'FUNC', target: 'UC', type: 'satisfy', description: 'Function implements use case' },
+    // CR-GC-366: `FUNC -satisfy-> UC` ENTFAELLT (BREAKING). Es war ein zweiter, redundanter Weg
+    // vom Verhalten zum Use Case neben dem einzig tragenden `UC -compose-> FCHAIN -compose-> FUNC`.
+    // Zwei Wege = zwei Wahrheiten: eine FUNC konnte einen UC bedienen, ohne in dessen Wirkkette zu
+    // stehen, womit IO-01 (FLOW-Pfade je FCHAIN-Paar) und R-21 (Integrationstest je Kette) sie nie
+    // sahen — die Abkuerzung umging genau die Pruefungen, die die Anbindung belastbar machen.
+    // Gemessen am graphcode-Selbstmodell waren 10 von 26 solcher Kanten reine Dopplung (die FUNC
+    // stand ohnehin in einer FCHAIN); die restlichen 13 sind der Migrationsanlass, nicht ein
+    // Argument fuer das Pattern. Ersatz: die FUNC in die FCHAIN des UC aufnehmen (R-30).
     // CR-154: NFR satisfy — non-functional REQs can be satisfied by chains, modules, or the system
     { source: 'FCHAIN', target: 'REQ', type: 'satisfy', description: 'Function chain satisfies end-to-end NFR (e.g. latency)' },
     { source: 'MOD', target: 'REQ', type: 'satisfy', description: 'Module satisfies budget NFR (e.g. uptime, memory)' },

package/dist/se/readiness.js

@@ -60,6 +60,11 @@ export const RULE_TO_DIMENSION = {
     '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;
+    // diese beiden fragen von der FUNC aus, ob sie angeschlossen ist.
+    'R-30': 'arch', 'R-31': 'arch',
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
     'UC-05': 'uc', 'UC-06': 'uc',
@@ -149,6 +154,9 @@ export const RULE_TO_PHASE = {
     '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',
     'MT-01': 'PDR', 'MT-02': 'PDR',
     'ND-01': 'PDR',
     'AO-D01': 'PDR', 'AO-D03': 'PDR', 'CR-01': 'PDR', 'RT-01': 'PDR', 'PH-01': 'PDR', 'CA-01': 'PDR',

package/dist/se/rules.js

@@ -103,8 +103,15 @@ function reqMustHaveVerification(graph) {
 function funcMustSatisfyReq(graph) {
     const funcs = graph.elements.filter(e => e.type === 'FUNC');
     const allReqs = graph.elements.filter(e => e.type === 'REQ');
+    // CR-GC-366: der Filter prueft den ZIELTYP. Vorher war er zieltyp-blind (`type === 'satisfy'`),
+    // womit ein `FUNC -satisfy-> UC` die Regel stumm schaltete, obwohl kein Requirement erfuellt war —
+    // der Regelname versprach mehr als der Code pruefte. Am graphcode-Selbstmodell verdeckte das 6 von
+    // 33 Faellen (gemeldet: 27). Mit dem Wegfall des UC-Patterns waere der alte Ausdruck de facto
+    // aequivalent geworden; explizit bleibt er trotzdem, damit die Regel nicht davon abhaengt, welche
+    // Ziele das Meta-Modell gerade zulaesst.
+    const reqIds = new Set(allReqs.map(r => r.id));
     return funcs
-        .filter(fn => !graph.traces.some(t => t.source === fn.id && t.type === 'satisfy'))
+        .filter(fn => !graph.traces.some(t => t.source === fn.id && t.type === 'satisfy' && reqIds.has(t.target)))
         .map(fn => {
         const modId = findParentModule(graph, fn.id);
         // Candidate REQs: same module's other FUNCs satisfy these, or constraints referencing this func
@@ -1016,10 +1023,111 @@ function ebenenPraesenz(graph) {
             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.
+// ---------------------------------------------------------------------------
+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 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))
+        .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)`,
+        fix_hint: 'Add the FUNC to the FCHAIN of the use case it serves (FCHAIN -compose-> FUNC)',
+        context: {
+            element_type: fn.type,
+            element_name: fn.name,
+            candidate_targets: toCandidates(fchains, fn),
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
+// R-31: FUNC ist verdrahtet — Ein- UND Ausgang per io (CR-GC-366)
+// Nur ACTOR darf eine Kette terminieren; eine FUNC ohne Eingang oder ohne Ausgang
+// ist ein toter Block. R-10 prueft dieselbe Verdrahtung vom FLOW aus ("hat dieser
+// Flow Producer und Consumer?") und sieht eine FUNC ohne jede io-Kante deshalb nie:
+// sie kommt in der FLOW-Schleife gar nicht vor. IO-01 setzt Ketten-Mitgliedschaft
+// voraus und sieht sie ebenfalls nicht. Diese Regel schliesst die FUNC-Seite.
+// EIN Befund je FUNC (nicht je fehlender Seite): sonst uebersteigt der Zaehler den
+// eigenen Nenner-Beitrag, was CR-SM-242 fuer IO-01 als Fehlmessung nachgewiesen hat.
+// ---------------------------------------------------------------------------
+function funcMustBeWired(graph) {
+    const funcs = graph.elements.filter(e => e.type === 'FUNC');
+    const flows = graph.elements.filter(e => e.type === 'FLOW');
+    const io = graph.traces.filter(t => t.type === 'io');
+    const hasInput = new Set(io.map(t => t.target)); // FLOW -io-> FUNC
+    const hasOutput = new Set(io.map(t => t.source)); // FUNC -io-> FLOW
+    return funcs
+        .map(fn => {
+        const missing = [];
+        if (!hasInput.has(fn.id))
+            missing.push('input');
+        if (!hasOutput.has(fn.id))
+            missing.push('output');
+        return { fn, missing };
+    })
+        .filter(({ missing }) => missing.length > 0)
+        .map(({ fn, missing }) => ({
+        rule_id: 'R-31',
+        severity: 'warning',
+        element_id: fn.id,
+        message: `${fn.id} is not wired into any flow (missing: ${missing.join(' + ')})`,
+        fix_hint: 'Connect the FUNC to a FLOW on the missing side (FLOW -io-> FUNC for input, FUNC -io-> FLOW for output) — only an ACTOR may terminate a chain',
+        context: {
+            element_type: fn.type,
+            element_name: fn.name,
+            candidate_targets: toCandidates(flows, fn),
+        },
+    }));
+}
 export const V3_RULES = [
     { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification, domain: ['REQ'] },
     { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq, domain: ['FUNC'] },
-    { id: 'R-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation, domain: ['FUNC'] },
+    // 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-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation, domain: ['MOD'] },
     { 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'] },
@@ -1027,7 +1135,10 @@ export const V3_RULES = [
     { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace, domain: ['ACTOR'] },
     { id: 'R-17', name: 'SYS must have compose', severity: 'warning', evaluate: sysMustHaveCompose, domain: ['SYS'] },
     { id: 'R-08', name: 'Trace consistency', severity: 'error', evaluate: traceConsistency, domain: ['all'] },
-    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness, domain: ['FUNC'] },
+    // CR-SM-242: domain ist FLOW, nicht FUNC — die Regel iteriert ueber FLOWs und meldet am FLOW.
+    // 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'] },
     { 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'] },
@@ -1045,6 +1156,8 @@ export const V3_RULES = [
     { 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-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`. */
 export function evaluateRules(graph, policy) {

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

@@ -49,8 +49,11 @@ export function sc04FlowHasSchema(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
+    // Die Asymmetrie ist gewollt (CR-SM-242): SC-02 iteriert ueber SCHEMA („wird dieses SCHEMA
+    // benutzt"), SC-04 ueber FLOW („hat dieser FLOW einen Datenvertrag"). Gleiches Thema,
+    // verschiedene Grundgesamtheit. SC-04 als ['SCHEMA'] zog 46 FLOW-Verstoesse gegen 20 SCHEMA.
     { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced, domain: ['SCHEMA'] },
-    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema, domain: ['SCHEMA'] },
+    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema, domain: ['FLOW'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
 // ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.

package/package.json

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