@sigloch/contracts 6.3.0 → 10.0.0

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

@@ -1,16 +1,55 @@
 // ---------------------------------------------------------------------------
-// CR-R01: CR must have at least one outgoing relation trace
+// CR-R01: ein offener CR nennt, WAS er aendert (CR-SM-295)
+//
+// Bis hierher waren es zwei Regeln, und beide zielten daneben. CR-R01 verlangte
+// IRGENDEINE relation-Kante — und akzeptierte damit einen CR, der nur an einem
+// Meilenstein haengt: das ist ein Termin, kein Umfang. Ueber 514 CR-Knoten in 19
+// Familiengraphen feuerte sie 5-mal, waehrend 49 CRs ausschliesslich auf ein MS zeigten
+// und unbeanstandet blieben. CR-R04 verlangte umgekehrt einen FUNC — zu eng: 21 CRs
+// meldeten, und ein grosser Teil davon aendert Daten, Doku oder Konfiguration und
+// beruehrt zu Recht keine Funktion.
+//
+// Die tragende Frage ist keine von beiden, sondern: nennt dieser CR ein Element, das er
+// AENDERT? Umfang sind FUNC, MOD, SCHEMA, REQ und UC. MS ist Terminplanung und zaehlt
+// nicht — MS-03 stellt diese Frage getrennt und bleibt unberuehrt.
+//
+// Grundgesamtheit wie bei CR-R04 (CR-SM-255) — nur was noch steuerbar ist. An einem
+// geschlossenen CR ist die Frage Archaeologie: was er beruehrt hat, steht im Commit.
+//
+// Die Menge ist aber UMGEDREHT formuliert: nicht "open oder in-progress", sondern "nicht
+// abgeschlossen". Der Grund ist gemessen — im Bestand tragen CRs die Status `done` (463),
+// `open` (34), `planned` (12), `rejected` (2), `dropped` (1) und keinen (2). `planned`
+// steht in keinem Enum der Ontologie, wird aber real geschrieben; eine Positivliste haette
+// diese zwoelf CRs stillschweigend uebersprungen. Eine Regel, die durch einen ihr
+// unbekannten Statuswert stumm wird, ist von einer bestandenen Pruefung nicht zu
+// unterscheiden — dieselbe Fail-open-Klasse wie ND-01/ND-02 vor CR-SM-286.
+//
+// Ein CR ganz OHNE status ist erst recht nicht abgeschlossen.
+//
+// Gemessen vor der Umstellung: von 514 CRs tragen 54 keinen Umfangsbezug — davon sind
+// **0 offen**, 52 `done` und 2 ohne Status. Die neue Fassung feuert am Bestand also auf
+// hoechstens 2 und laesst die Historie unangetastet; ihre Wirkung beginnt beim naechsten
+// CR, der geschrieben wird.
 // ---------------------------------------------------------------------------
+/** Elementtypen, die einen Aenderungsumfang darstellen — MS gehoert bewusst nicht dazu. */
+const SCOPE_TYPES = new Set(['FUNC', 'MOD', 'SCHEMA', 'REQ', 'UC']);
+/** Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit. */
+const CLOSED_STATUS = new Set(['done', 'dropped', 'rejected']);
 function crMustTrack(graph) {
-    const crs = graph.elements.filter(e => e.type === 'CR');
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const crs = graph.elements.filter(e => {
+        if (e.type !== 'CR')
+            return false;
+        return !CLOSED_STATUS.has(String(e.attributes?.status ?? ''));
+    });
     return crs
-        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation'))
+        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' && SCOPE_TYPES.has(typeOf.get(t.target) ?? '')))
         .map(cr => ({
         rule_id: 'CR-R01',
         severity: 'error',
         element_id: cr.id,
-        message: `${cr.id} has no relation traces (tracks nothing)`,
-        fix_hint: 'Add relation traces to affected UC, REQ, FUNC, or MOD elements',
+        message: `${cr.id} names no scope (no relation to FUNC/MOD/SCHEMA/REQ/UC)`,
+        fix_hint: 'Add a relation trace to the FUNC, MOD, SCHEMA, REQ or UC this CR changes — a milestone alone is a date, not a scope',
         context: {
             element_type: cr.type,
             element_name: cr.name,
@@ -63,71 +102,50 @@ function noConcurrentMutation(graph) {
             targetToCrs.set(tgt, list);
         }
     }
-    const violations = [];
-    const seen = new Set();
-    for (const [target, crIds] of targetToCrs) {
+    // CR-SM-304 — EIN Befund je Konflikt-MENGE, aber an einem BERECHENBAREN Element.
+    //
+    // Die Ein-Befund-Regel bleibt: dieselben zwei offenen CRs, die sich an drei Knoten begegnen,
+    // sind EIN Koordinationsproblem und nicht drei (Gate 4, Doppelzaehlung). Falsch war, woher der
+    // Anker kam: `targetToCrs` folgt der TRACE-Reihenfolge, also entschied die Array-Ordnung im
+    // Graphen, welches Ziel meldet — "kein erster Treffer" ist Gate 5 woertlich, und dieselbe
+    // Klasse wie der offene R-28-Fall (CR-SM-245). Gemessen am graphcode-Selbstmodell wechselte
+    // der Befund bei umgedrehter Reihenfolge von FUNC-graph-suggest auf MS-9-generation; ein
+    // Reseed aus dem Kuzu-Store reichte, damit eine Vorher/Nachher-Bilanz bei NULL Zuegen
+    // "einen geschlossen, einen neu" meldete.
+    //
+    // Zweiter Teil desselben Defekts: das unterdrueckte Ziel wurde nicht nur nicht angekert, es
+    // wurde gar nicht genannt. Wer koordinieren soll, braucht die vollstaendige Liste — sie steht
+    // jetzt in der Meldung und als `also_affects` im Kontext.
+    const bySet = new Map();
+    for (const target of [...targetToCrs.keys()].sort()) {
+        const crIds = [...targetToCrs.get(target)].sort();
         if (crIds.length < 2)
             continue;
-        const key = crIds.sort().join(',');
-        if (seen.has(key))
-            continue;
-        seen.add(key);
+        const key = crIds.join(',');
+        bySet.set(key, [...(bySet.get(key) ?? []), target]);
+    }
+    const violations = [];
+    for (const [key, targets] of bySet) {
+        const crIds = key.split(',');
+        const [anchor, ...also] = targets;
+        const el = graph.elements.find(e => e.id === anchor);
         violations.push({
             rule_id: 'CR-R03',
             severity: 'warning',
-            element_id: target,
-            message: `${target} is tracked by ${crIds.length} open CRs: ${crIds.join(', ')}`,
+            element_id: anchor,
+            message: `${anchor} is tracked by ${crIds.length} open CRs: ${crIds.join(', ')}` +
+                (also.length > 0 ? ` — the same CRs also track ${also.join(', ')}` : ''),
             fix_hint: 'Coordinate changes to avoid merge conflicts',
             context: {
-                element_type: graph.elements.find(e => e.id === target)?.type,
-                element_name: graph.elements.find(e => e.id === target)?.name,
+                element_type: el?.type,
+                element_name: el?.name,
+                also_affects: also,
             },
         });
     }
     return violations;
 }
 // ---------------------------------------------------------------------------
-// CR-R04: an OPEN CR must have at least one relation→FUNC trace (CR-207,
-// Grundgesamtheit verengt in CR-SM-255)
-//
-// "Welche Funktionen fasst dieser CR an" ist eine PLANUNGSfrage — sie steuert, bevor
-// gebaut wird. An einem geschlossenen CR ist sie Archaeologie: was er beruehrt hat,
-// steht im Commit und im Diff, nicht im Graphen. Wer die Kanten nachtraeglich zieht,
-// raet, und erfundene Praezision ist teurer als eine fehlende Kante.
-//
-// Gemessen am graphcode-Selbstmodell (graphVersion 171): 41 meldende CRs, davon 40
-// `done` und 1 `dropped` — kein einziger offener. Die Regel feuerte ausschliesslich
-// dort, wo sie nichts mehr steuern kann, und trug damit 41 unbearbeitbare Befunde.
-//
-// Die Statusmenge ist woertlich die von CR-R03 (s. o.): dieselbe Frage nach "noch in
-// Arbeit", dieselbe Antwort. CR-R01 ("ein CR trackt ueberhaupt etwas") bleibt fuer
-// ALLE CRs gueltig — nur die Verschaerfung "und zwar einen FUNC" ist Planung.
-// ---------------------------------------------------------------------------
-function crMustHaveFunc(graph) {
-    // Ein CR ganz OHNE status ist kein geschlossener CR — die Regel darf nicht durch ein
-    // fehlendes Attribut stumm werden.
-    const crs = graph.elements.filter(e => {
-        if (e.type !== 'CR')
-            return false;
-        const status = e.attributes?.status;
-        return status === undefined || status === 'open' || status === 'in-progress';
-    });
-    return crs
-        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'FUNC')))
-        .map(cr => ({
-        rule_id: 'CR-R04',
-        severity: 'warning',
-        element_id: cr.id,
-        message: `${cr.id} has no relation→FUNC trace (no implementation scope)`,
-        fix_hint: 'Add CR→FUNC [relation] traces to define which functions this CR changes',
-        context: {
-            element_type: cr.type,
-            element_name: cr.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // MS-03: CR should have a CR→MS [relation] trace (CR-207)
 // ---------------------------------------------------------------------------
 function crShouldHaveMilestone(graph) {
@@ -159,7 +177,6 @@ export const CR_RULES = [
     // (= 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: 'Open CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc, domain: ['CR'] },
     { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone, domain: ['CR'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —

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

@@ -13,14 +13,16 @@ import type { MetricPolicy } from './policy.js';
  * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
  * wenn es keine zweite gibt.
  */
+/** Profile groupings — see CATALOGS. */
+export type ProfileId = 'default' | 'se' | 'coding';
 export declare const ALL_RULE_DEFS: ReadonlyArray<{
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
     domain: readonly string[];
+    /** CR-SM-285: das Profil reist mit der Regel, statt aus ihrer ID geraten zu werden. */
+    profile: Exclude<ProfileId, 'default'>;
 }>;
-/** Profile groupings derived from rule prefixes. */
-export type ProfileId = 'default' | 'se' | 'coding';
 export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RULE_DEFS;
 /**
  * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.

package/dist/se/evaluate-all.js

@@ -3,6 +3,7 @@ import { SC_RULES, evaluateSCRules } from './schema-quality-rules.js';
 import { UC_RULES, evaluateUCRules } from './uc-quality-rules.js';
 import { FC_RULES, evaluateFCRules } from './fchain-quality-rules.js';
 import { MT_RULES, evaluateMTRules } from './metric-rules.js';
+import { toEvaluableGraph } from './flat-graph.js';
 import { FM_RULES, evaluateFMRules } from './fmea-rules.js';
 import { VIEW_RULES, evaluateViewRules } from './view-rules.js';
 import { CR_RULES, evaluateCRRules } from './cr-quality-rules.js';
@@ -11,33 +12,38 @@ import { AO_RULES, evaluateAORules } from './ao-rules.js';
 import { BQ_RULES, evaluateBQRules } from './quality-rules.js';
 import { AF_RULES, evaluateAFRules } from './analysis-freshness-rules.js';
 /**
- * All prescribed rule definitions (single source of truth for the catalog).
+ * CR-SM-285: das Profil haengt am KATALOG, nicht am ID-Praefix.
  *
- * CR-SM-235: `domain` reicht mit durch — die Grundgesamtheit, ueber die eine Regel feuert.
- * Konsumenten, die einen Anteil bilden (`se-steering`s `computeApplicable`), lesen den Nenner
- * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
- * wenn es keine zweite gibt.
+ * Bis hierher ordnete `SE_PREFIXES`/`CODING_PREFIXES` eine Regel ueber den Anfang ihrer ID zu.
+ * Drei dokumentierte Ausfaelle derselben Klasse: `RD-` (CR-SM-221 — `'RD-01'.startsWith('R-')`
+ * ist false, die Zerlegungsregeln liefen nie im se-Profil), `MS-` (CR-SM-245 — fehlte in BEIDEN
+ * Listen, die Dimension `ms` hatte im se-Profil keine einzige zaehlende Regel), `BW-`
+ * (CR-SM-283). Jede neue Regel-ID war ein potenzieller vierter.
+ *
+ * Ein Katalog weiss, wozu er gehoert; eine Zeichenkette weiss es nicht. Neue Regeln erben das
+ * Profil ihres Katalogs automatisch — und ein NEUER Katalog muss hier eingetragen werden, sonst
+ * bricht `ALL_RULE_DEFS` schon beim Typcheck (jeder Eintrag braucht sein Profil).
  */
-export const ALL_RULE_DEFS = [
-    ...V3_RULES, ...UC_RULES, ...FC_RULES, ...SC_RULES, ...MT_RULES, ...BQ_RULES,
-    ...ND_RULES, ...CR_RULES, ...AO_RULES, ...FM_RULES, ...VIEW_RULES, ...AF_RULES,
-].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.
-// 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-'];
+const CATALOGS = [
+    { profile: 'se', rules: V3_RULES },
+    { profile: 'se', rules: UC_RULES },
+    { profile: 'se', rules: FC_RULES },
+    { profile: 'se', rules: SC_RULES },
+    { profile: 'se', rules: MT_RULES },
+    { profile: 'se', rules: CR_RULES },
+    { profile: 'se', rules: AO_RULES },
+    { profile: 'se', rules: FM_RULES },
+    { profile: 'se', rules: VIEW_RULES },
+    { profile: 'se', rules: AF_RULES },
+    // Sprach-/Textqualitaet statt SE-Struktur — das ist die Trennlinie, die die Praefixliste meinte.
+    { profile: 'coding', rules: BQ_RULES },
+    { profile: 'coding', rules: ND_RULES },
+];
+export const ALL_RULE_DEFS = CATALOGS.flatMap(({ profile, rules }) => rules.map(r => ({ id: r.id, name: r.name, severity: r.severity, domain: r.domain, profile })));
 export function getRuleDefsForProfile(profile) {
-    if (profile === 'se')
-        return ALL_RULE_DEFS.filter(r => SE_PREFIXES.some(p => r.id.startsWith(p)));
-    if (profile === 'coding')
-        return ALL_RULE_DEFS.filter(r => CODING_PREFIXES.some(p => r.id.startsWith(p)));
-    return ALL_RULE_DEFS;
+    if (profile === 'default')
+        return ALL_RULE_DEFS;
+    return ALL_RULE_DEFS.filter(r => r.profile === profile);
 }
 /**
  * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.
@@ -47,6 +53,16 @@ export function getRuleDefsForProfile(profile) {
  * `DEFAULT_METRIC_POLICY` sichtbar an der Aufrufstelle.
  */
 export function evaluateAllRules(graph, policy) {
+    // CR-SM-284: die Hebung der flach committeten SSOT laeuft HIER, nicht beim Aufrufer.
+    //
+    // `toEvaluableGraph` gibt es seit CR-SM-258 — und sie wurde von keinem Produktionspfad und
+    // keinem Messskript gerufen, nur aus Tests. Eine Korrektur, die man rufen DARF statt MUSS, ist
+    // keine: an graphcode erzeugte die flache Lesart 158 Phantom-Befunde (R-19 124, R-20 115,
+    // R-26 36, CR-R04 42) und verdeckte zugleich 156 ECHTE Fehler (CR-R02, severity error).
+    //
+    // Idempotent und identitaetserhaltend (s. dort), also eine Normalisierung am einzigen Eingang
+    // und kein Fallback: ein bereits genesteter Graph geht unveraendert und uneingepackt durch.
+    graph = toEvaluableGraph(graph);
     return [
         ...evaluateRules(graph, policy),
         ...evaluateBQRules(graph, policy),

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

@@ -4,7 +4,6 @@
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
 import type { MetricPolicy } from './policy.js';
-export declare function fc01ActorBoundary(graph: OntologyGraph): RuleViolation[];
 export declare function fc02LeafUcHasFchain(graph: OntologyGraph): RuleViolation[];
 export declare function fc03FchainFlat(graph: OntologyGraph): RuleViolation[];
 export declare function fc04ActorBounded(graph: OntologyGraph): RuleViolation[];

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

@@ -1,48 +1,5 @@
 import { indexOf } from './graph-index.js';
 // ---------------------------------------------------------------------------
-// FC-01: FCHAIN must have Actor boundary (input or output via FLOW→ACTOR io)
-// ---------------------------------------------------------------------------
-export function fc01ActorBoundary(graph) {
-    // CR-SM-264: dieselbe Frage, einmal statt je Kette neu.
-    //
-    // Die alte Fassung war die verschachtelte Form, die UC-02 kubisch gemacht hat (CR-SM-261):
-    // je FCHAIN alle Traces, darin je io-Kante noch einmal alle Traces, darin je Treffer alle
-    // Elemente — `FCHAIN x FUNC x T x T x E`. Im Profil nach Teil a war FC-01 mit 6,3 % die
-    // teuerste FCHAIN-Regel.
-    //
-    // Beide Zweige fragen in Wahrheit DASSELBE: "beruehrt dieses Element eine io-Kante, deren
-    // anderes Ende ein ACTOR ist?" Einmal fuer den Zwischenknoten der Kettenglieder, einmal
-    // direkt fuer den Eltern-UC. Eine Menge beantwortet beide.
-    const idx = indexOf(graph);
-    const actorAdjacent = new Set();
-    for (const t of idx.tracesOfType('io')) {
-        if (idx.typeOf(t.target) === 'ACTOR')
-            actorAdjacent.add(t.source);
-        if (idx.typeOf(t.source) === 'ACTOR')
-            actorAdjacent.add(t.target);
-    }
-    return idx.elementsOfType('FCHAIN')
-        .filter(fc => {
-        // Mitglieder der Kette — bewusst OHNE Typfilter, wie in der alten Fassung: FC-01 fragt
-        // nach dem, was komponiert ist, nicht nach dem, was eine FUNC ist (FC-03 tut das).
-        const memberIds = idx.out(fc.id, 'compose').map(t => t.target);
-        const hasActorIO = memberIds.some(fid => idx.out(fid, 'io').some(t => actorAdjacent.has(t.target)) ||
-            idx.in(fid, 'io').some(t => actorAdjacent.has(t.source)));
-        // Der Umweg ueber den Eltern-UC: dessen eigene ACTOR-io zaehlt auch.
-        const parentUC = idx.in(fc.id, 'compose').find(t => idx.typeOf(t.source) === 'UC');
-        const hasDirectActorIO = parentUC !== undefined && actorAdjacent.has(parentUC.source);
-        return !hasActorIO && !hasDirectActorIO;
-    })
-        .map(fc => ({
-        rule_id: 'FC-01',
-        severity: 'warning',
-        element_id: fc.id,
-        message: `${fc.id} has no actor boundary (no ACTOR io connection)`,
-        fix_hint: 'Ensure at least one FUNC in the chain connects to an ACTOR via FLOW io',
-        context: { element_type: fc.type, element_name: fc.name },
-    }));
-}
-// ---------------------------------------------------------------------------
 // FC-02: Leaf UC (no UC→compose→UC) must have at least one FCHAIN
 // ---------------------------------------------------------------------------
 export function fc02LeafUcHasFchain(graph) {
@@ -142,7 +99,6 @@ export function fc04ActorBounded(graph) {
 // Aggregated
 // ---------------------------------------------------------------------------
 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'] },
     // 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:

package/dist/se/flat-graph.d.ts

@@ -1,3 +1,11 @@
 import type { OntologyGraph } from './ontology.js';
-/** Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt. */
+/**
+ * Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt.
+ *
+ * CR-SM-284: **identitaetserhaltend.** War nichts zu heben — der Normalfall, weil der Live-Gate
+ * bereits genestet liefert —, kommt DIESELBE Referenz zurueck. Das ist die Voraussetzung dafuer,
+ * dass `evaluateAllRules` die Funktion selbst rufen kann: die WeakMap-Caches der Familie
+ * (`indexOf`, `moduleCrossings`, `MEASURE_CACHE`) haengen an der Graph-Identitaet, und ein bei
+ * jedem Aufruf neu gebautes Objekt haette sie im Best-of-N-Loop bei jedem Kandidaten gesprengt.
+ */
 export declare function toEvaluableGraph(graph: OntologyGraph): OntologyGraph;

package/dist/se/flat-graph.js

@@ -42,11 +42,20 @@ function nestAttributes(entry, canonical) {
         attributes.status = entry.status;
     return { ...top, attributes };
 }
-/** Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt. */
+/**
+ * Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt.
+ *
+ * CR-SM-284: **identitaetserhaltend.** War nichts zu heben — der Normalfall, weil der Live-Gate
+ * bereits genestet liefert —, kommt DIESELBE Referenz zurueck. Das ist die Voraussetzung dafuer,
+ * dass `evaluateAllRules` die Funktion selbst rufen kann: die WeakMap-Caches der Familie
+ * (`indexOf`, `moduleCrossings`, `MEASURE_CACHE`) haengen an der Graph-Identitaet, und ein bei
+ * jedem Aufruf neu gebautes Objekt haette sie im Best-of-N-Loop bei jedem Kandidaten gesprengt.
+ */
 export function toEvaluableGraph(graph) {
-    return {
-        ...graph,
-        elements: graph.elements.map((e) => nestAttributes(e, TOP_LEVEL_ELEMENT_KEYS)),
-        traces: graph.traces.map((t) => nestAttributes(t, TOP_LEVEL_TRACE_KEYS)),
-    };
+    const elements = graph.elements.map((e) => nestAttributes(e, TOP_LEVEL_ELEMENT_KEYS));
+    const traces = graph.traces.map((t) => nestAttributes(t, TOP_LEVEL_TRACE_KEYS));
+    // `nestAttributes` gibt bei bereits genesteten Eintraegen das Original zurueck; sind ALLE
+    // unveraendert, war der Graph schon evaluierbar und wird nicht angefasst.
+    const untouched = elements.every((e, i) => e === graph.elements[i]) && traces.every((t, i) => t === graph.traces[i]);
+    return untouched ? graph : { ...graph, elements, traces };
 }

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

@@ -9,8 +9,8 @@
  *
  * @sigloch/contracts/se
  */
-import { ElementType } from './ontology.js';
-import type { TraceType, OntologyGraph, AttributeSpec } from './ontology.js';
+import { ElementType, TraceType } from './ontology.js';
+import type { OntologyGraph, AttributeSpec, ReqKind } 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;
@@ -68,6 +68,18 @@ export interface ParseFormatEOptions {
      * silent skip.
      */
     resolveType?: (uid: string) => ElementType | undefined;
+    /**
+     * CR-SM-266 B: die Kinds eines uid, den dieser Text nicht deklariert. Seit die
+     * satisfy-Patterns ein `where` tragen, entscheidet nicht mehr das Typ-Paar allein — ein
+     * `MOD -satisfy-> REQ` ist nur gueltig, wenn das REQ strukturelle Kinds traegt.
+     *
+     * Ohne diesen Resolver sieht der Parser die Kinds eines BESTEHENDEN Knotens nicht und lehnt
+     * solche Kanten ab. Das ist Absicht: fehlschlagen und es sagen, nicht raten und durchlassen
+     * — dieselbe Entscheidung wie bei `resolveType` ("Without it such a diff is an error, never
+     * a silent skip"). Knoten, die DIESER Text anlegt, brauchen ihn nicht; ihre Kinds stehen als
+     * `@kinds` in denselben Zeilen.
+     */
+    resolveKinds?: (uid: string) => readonly ReqKind[] | undefined;
 }
 /** Parse a Format E text block into validated operations. */
 export declare function parseFormatE(input: string, options?: ParseFormatEOptions): FormatEDiff;

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

@@ -9,7 +9,7 @@
  *
  * @sigloch/contracts/se
  */
-import { ElementType, ELEMENT_ATTRIBUTES } from './ontology.js';
+import { ElementType, ELEMENT_ATTRIBUTES, TraceType } from './ontology.js';
 import { isValidTrace } from './meta-model.js';
 // ---------------------------------------------------------------------------
 // Extraction
@@ -23,9 +23,10 @@ export function extractFormatE(llmOutput) {
 // ---------------------------------------------------------------------------
 // Parser
 // ---------------------------------------------------------------------------
-const VALID_TRACE_TYPES = new Set([
-    'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation', 'produces',
-]);
+// CR-SM-266 D5: ABGELEITET statt abgeschrieben. Die Liste stand hier als zweite Kopie des
+// TraceType-Enums und trug `produces` noch, als es dort schon entfernt war — genau die Drift,
+// die eine doppelte Wahrheit erzeugt. Eine Quelle, keine Pflege.
+const VALID_TRACE_TYPES = new Set(TraceType.options);
 const OP_PREFIX = {
     '+': 'add',
     '-': 'remove',
@@ -109,6 +110,24 @@ export function parseFormatE(input, options = {}) {
     /** uid → type, from this text's node sections. */
     const declared = new Map();
     const typeOf = (uid) => declared.get(uid) ?? options.resolveType?.(uid);
+    /**
+     * CR-SM-266 B: die Kinds eines uid — erst aus DIESEM Text, dann aus dem Store.
+     *
+     * `kinds` reist in Format E als `@kinds a,b` und wird erst vom Konsumenten aufs
+     * Top-Level-Feld gehoben (graph-api-core, CR-195d). Hier steht es also noch in
+     * `op.attributes.kinds`, und genau dort wird es gelesen — sonst saehe eine Mutation, die
+     * REQ und satisfy-Kante in EINEM Block anlegt, die eigenen Kinds nicht.
+     */
+    const kindsOf = (uid) => {
+        for (const op of operations) {
+            if ('elementType' in op && op.semanticId === uid && op.attributes?.kinds != null) {
+                const raw = op.attributes.kinds;
+                const list = Array.isArray(raw) ? raw.map(String) : String(raw).split(',');
+                return list.map(k => k.trim()).filter(Boolean);
+            }
+        }
+        return options.resolveKinds?.(uid);
+    };
     for (const rawLine of input.split('\n')) {
         const line = rawLine.trim();
         if (!line || line.startsWith('//') || line.startsWith('#!'))
@@ -163,7 +182,7 @@ export function parseFormatE(input, options = {}) {
         if (isEdgeLine || section === 'edges') {
             const edgeMatch = isEdgeLine ? EDGE_RE.exec(line) : null;
             if (edgeMatch) {
-                parseEdge(edgeMatch, typeOf, operations, errors);
+                parseEdge(edgeMatch, typeOf, kindsOf, operations, errors);
             }
             else {
                 errors.push(`Invalid edge line: "${line}"`);
@@ -223,7 +242,7 @@ function parseNode(m, elementType, ops, errors) {
         ops.push({ type: 'add_node', semanticId: id, elementType, description: descr });
     }
 }
-function parseEdge(m, typeOf, ops, errors) {
+function parseEdge(m, typeOf, kindsOf, ops, errors) {
     const opChar = m[1] || '+';
     const sourceId = m[2];
     const traceType = m[3];
@@ -254,7 +273,10 @@ function parseEdge(m, typeOf, ops, errors) {
         }
         // CR-148: Normalize before the meta-model check (e.g. FLOW→SCHEMA io → relation)
         const resolvedTraceType = normalizeTraceType(srcType, tgtType, traceType);
-        if (!isValidTrace({ source: srcType, target: tgtType, type: resolvedTraceType })) {
+        if (!isValidTrace({
+            source: srcType, target: tgtType, type: resolvedTraceType,
+            sourceKinds: kindsOf(sourceId), targetKinds: kindsOf(targetId),
+        })) {
             errors.push(`Meta-model violation: ${srcType} -${traceType}-> ${tgtType} is not valid`);
             continue;
         }
@@ -281,7 +303,8 @@ function parseEdge(m, typeOf, ops, errors) {
 export function serializeToFormatE(graph) {
     const lines = [];
     // Nodes, grouped by type
-    const modelingElements = graph.elements.filter(el => el.type !== 'SESSION'); // skip audit sessions
+    // CR-SM-266 D5: kein SESSION-Skip mehr — der Elementtyp existiert nicht.
+    const modelingElements = graph.elements;
     if (modelingElements.length > 0) {
         lines.push('## Nodes');
         const byType = new Map();
@@ -313,7 +336,8 @@ export function serializeToFormatE(graph) {
         }
     }
     // Edges
-    const modelingTraces = graph.traces.filter(t => t.category !== 'audit');
+    // CR-SM-266 D5: kein audit-Filter mehr — `Trace.category` existiert nicht.
+    const modelingTraces = graph.traces;
     if (modelingTraces.length > 0) {
         lines.push('');
         lines.push('## Edges');

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

@@ -11,14 +11,17 @@
  */
 export declare const GRAMMAR_SNAPSHOT: {
     readonly versions: {
-        readonly ontology: "7.0.0";
-        readonly metaModel: "2.0.0";
-        readonly rules: "6.3.0";
+        readonly ontology: "9.0.0";
+        readonly metaModel: "5.0.0";
+        readonly rules: "19.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 elementTypes: readonly ["ACTOR", "CR", "FCHAIN", "FLOW", "FUNC", "MOD", "MS", "REQ", "SCHEMA", "SYS", "TEST", "UC"];
+    readonly traceTypes: readonly ["allocate", "compose", "io", "relation", "satisfy", "verify"];
+    readonly patterns: readonly ["ACTOR -io-> FLOW", "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 -relation-> SCHEMA [1]", "FUNC -allocate-> MOD [0..1]", "FUNC -compose-> FUNC [0..*]", "FUNC -io-> FLOW", "FUNC -satisfy-> REQ where target.kinds in {functional,postcondition,precondition}", "MOD -compose-> MOD [0..*]", "MOD -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}", "MS -compose-> FUNC", "MS -compose-> REQ", "MS -compose-> UC", "MS -relation-> MS label=depends-on", "REQ -compose-> REQ [0..*]", "SYS -compose-> MOD [0..*]", "SYS -compose-> REQ [0..*]", "SYS -compose-> SYS [0..*]", "SYS -compose-> UC [1..*]", "SYS -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}", "TEST -verify-> REQ", "UC -compose-> FCHAIN [1..*]", "UC -compose-> REQ [1..*]"];
+    readonly elementColumns: readonly ["OntologyElement.attributes", "OntologyElement.created_at", "OntologyElement.description", "OntologyElement.id", "OntologyElement.kinds", "OntologyElement.method", "OntologyElement.name", "OntologyElement.status", "OntologyElement.type", "OntologyElement.updated_at", "Trace.attributes", "Trace.created_at", "Trace.label", "Trace.source", "Trace.target", "Trace.type", "Trace.verified_at", "Trace.weight"];
     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]"];
+    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]", "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]", "BW-02 (warning) 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]", "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]", "R-01 (error) domain=[REQ]", "R-02 (warning) domain=[FUNC]", "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-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-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]", "SC-02 (warning) domain=[SCHEMA]", "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]"];
     readonly conformanceRules: readonly ["RC-01 (error)", "RC-02 (error)", "RC-03 (error)", "RC-04 (warning)", "RC-05 (warning)", "RC-06 (warning)"];
+    readonly policy: readonly ["apTable = null", "boundaryWidth = {warning:5}", "crossingFlows = {warning:3}", "decompositionBreadth = {warning:9}", "instability = null", "lcom4 = {info:4,warning:6}", "moduleSize = {coupled:7,crossings:2,large:9}", "riskRpn = 100"];
+    readonly exports: readonly ["AF_RULES", "ALL_RULE_DEFS", "AO_RULES", "ActionPriority", "AnalysisArtifactId", "AnalysisFreshnessStampSchema", "ApTableSchema", "BOUNDED_PATTERNS", "BQ_RULES", "CODE_CONFORMANCE_RULES", "CR_RULES", "CodeFactsSchema", "DEFAULT_METRIC_POLICY", "DIMENSION_READINESS_DELTA_NAME", "DIMENSION_READINESS_NAME", "ELEMENT_ATTRIBUTES", "ELEMENT_DESCRIPTIONS", "ElementType", "ElementUid", "FC_RULES", "FM_RULES", "FileFactsSchema", "ImportEdgeSchema", "MAX_SLUG_LENGTH", "META_MODEL_VERSION", "MODELING_ELEMENT_TYPES", "MT_RULES", "MetricPolicySchema", "ND_RULES", "ONTOLOGY_VERSION", "OntologyElement", "OntologyGraph", "PHASE_READINESS_NAME", "PhaseGate", "REQUIRED_PATTERNS", "RULES_VERSION", "RULE_TO_DIMENSION", "RULE_TO_PHASE", "ReadinessDimension", "ReadinessReport", "ReadinessScore", "RealRefSchema", "RepoRelativePathSchema", "ReqKind", "RuleSeverity", "RuleViolation", "SC_RULES", "TRACE_PATTERNS", "TestRefSchema", "TestRefsSchema", "TestResult", "Trace", "TraceType", "UC_RULES", "V3_RULES", "VIEW_RULES", "VerificationMethod", "ViolationCandidate", "ViolationContext", "actionPriority", "allocationCohesion", "apMethod", "attributeTypeOf", "bq01Unambiguous", "bq02Verifiable", "bq04Necessary", "bq06Conforming", "bq07Complete", "bw02WhiteboxWidth", "cl01ConopsCompleteness", "cr01CrossingFlowCount", "decomposedFuncs", "evaluateAFRules", "evaluateAORules", "evaluateAllRules", "evaluateBQRules", "evaluateCRRules", "evaluateConformanceRules", "evaluateFCRules", "evaluateFMRules", "evaluateMTRules", "evaluateNDRules", "evaluateRules", "evaluateSCRules", "evaluateUCRules", "evaluateViewRules", "extractFormatE", "fc02LeafUcHasFchain", "fc03FchainFlat", "fc04ActorBounded", "fm01MissingFmeaAttributes", "fm02MissingMitigation", "fm03HighRiskUnverified", "funcSimilarity", "getRuleDefsForProfile", "hydrateAttrValue", "importCoverage", "indexOf", "io01CrossModuleCompleteness", "isElementUid", "isValidTrace", "jaccard", "maxOccurs", "minOccurs", "moduleMetrics", "mt01Instability", "mt02Lcom4", "nd01FuncNearDuplicate", "nd02SchemaNearDuplicate", "nfr01BudgetOvershoot", "normalizeReqKinds", "pairsAbove", "parseElementUid", "parseFormatE", "sc02IsReferenced", "schemaSimilarity", "serializeToFormatE", "setBQ04SimilarityMatrix", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "uc05HasPostcondition", "uc06HasPrecondition", "vr01TestNoResult"];
 };