@sigloch/contracts 9.1.0 → 10.0.0

package/dist/se/module-crossings.d.ts

@@ -0,0 +1,102 @@
+/**
+ * CR-SM-276 — EIN Begriff „kreuzender Fluss", EINE Berechnung.
+ *
+ * Zwei Katalogeintraege messen Modulrand-Kopplung: **CR-01** je Modul*paar* und **R-04** je
+ * Modul (Groesse GEGEN Kreuzungen). Bis CR-SM-274/276 hatte jeder seine eigene, jeweils
+ * falsche Vorstellung davon, was eine Kreuzung ist:
+ *
+ * - CR-01 suchte `FUNC -io-> FUNC` — ein Paar, das `TRACE_PATTERNS` nicht kennt (R-18 lehnt es
+ *   ab). Die Regel konnte strukturell nicht feuern (CR-SM-274).
+ * - R-04 zaehlte „jede io-Kante einer Modul-FUNC mit einem Endpunkt ausserhalb der FUNC-Menge".
+ *   FLOWs liegen NIE in der FUNC-Menge — also zaehlte jede io-Kante zu jedem FLOW, auch dem
+ *   modul*internen*. Das war der io-Grad des Moduls, nicht seine Randkopplung: fuer jedes Modul
+ *   mit irgendeinem Datenfluss trivial > 2, womit R-04 faktisch wieder „max module size" war —
+ *   genau der Name, den CR-SM-236 verworfen hat.
+ *
+ * Hier steht der Pfad, den beide Regelkoepfe meinen: **`FUNC -io-> FLOW -io-> FUNC` ueber eine
+ * Modulgrenze**. MOD-Zugehoerigkeit einer FUNC = **direkte** `allocate`-Kante (`FUNC -allocate->
+ * MOD` ist `0..1`) — dieselbe Aufloesung wie `moduleMetrics` und die RC-05-Adjazenz.
+ *
+ * ## CR-SM-282: `byModule` rollt auf, `pairs` nicht
+ *
+ * Bis hierher las AUCH `byModule` nur die direkte Zuordnung. Ein Eltern-MOD (`MOD -compose-> MOD`)
+ * hat keine direkt allozierten FUNCs — es kam in `byModule` also gar nicht vor, und R-04 sah an ihm
+ * **null Kreuzungen**. Genau die Whitebox, in die der Leser hineinklickt, war unsichtbar. Jetzt ist
+ * die Zugehoerigkeit die **Besitzkette**: das direkt allozierte MOD plus seine compose-Vorfahren.
+ * Ein Vertrag quert den Rand von `m`, wenn ein Endpunkt in `m`s Teilbaum liegt und einer nicht.
+ *
+ * `pairs` (CR-01) bleibt bewusst auf der direkten Zuordnung: „wie stark haengen DIESE zwei Module
+ * aneinander" ist eine Frage der Blattebene; ein Elternpaar meldete dieselbe Kopplung ein zweites
+ * Mal. Ohne `MOD -compose-> MOD` im Graphen ist das Ergebnis Zeichen fuer Zeichen das bisherige.
+ *
+ * ## Zaehlbasis: verschiedene SCHEMA, nicht Einzelquerungen
+ *
+ * Begruendung in CR-SM-274 (dort familienweit gemessen): Kopplung ist die Zahl der **Vertraege**,
+ * auf die sich zwei Module einigen muessen — ein FLOW mit 3 Produzenten und 3 Konsumenten ist
+ * EIN Vertrag, nicht 9. Roh ist hub-empfindlich und durch FLOW-Splitting manipulierbar;
+ * `FLOW -relation-> SCHEMA` ist seit CR-SM-271 Teil 2 `1..1` und per R-18 erzwungen, die
+ * Zaehlbasis also garantiert vorhanden. Ein FLOW ohne SCHEMA zaehlt als eigener, untypisierter
+ * Vertrag (`UNBOUND:<flow>`) — er darf nicht stillschweigend mit anderen verschmelzen.
+ *
+ * ## Warum `byModule` die VEREINIGUNG ist und nicht die Summe ueber die Paare
+ *
+ * R-04 meldet an EINEM MOD. Quert derselbe Vertrag zu drei Nachbarn, besitzt das Modul trotzdem
+ * einen Vertrag — die Summe ueber die Paare brächte die Hub-Empfindlichkeit zurueck, die die
+ * distinct-Zaehlung gerade beseitigt, und zaehlte doppelt, was CR-01 je Paar ohnehin meldet.
+ * `byModule` ist damit die **Vertragsflaeche** des Modulrandes.
+ */
+import type { OntologyGraph } from './ontology.js';
+export interface ModulePairCrossing {
+    readonly modA: string;
+    readonly modB: string;
+    /** SCHEMA-ids bzw. `UNBOUND:<flow>` — die verschiedenen Vertraege an dieser Grenze. */
+    readonly contracts: ReadonlySet<string>;
+}
+export interface ModuleCrossings {
+    /** Je sortiertem Modulpaar (Schluessel `modA::modB`) die querenden Vertraege. */
+    readonly pairs: ReadonlyMap<string, ModulePairCrossing>;
+    /** Je MOD die Vereinigung aller Vertraege, die seine Grenze queren. */
+    readonly byModule: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * CR-SM-283: je ZERLEGTER FUNC die Vertraege, die den Rand seiner Whitebox queren —
+     * dieselbe Definition und derselbe Durchlauf wie `byModule`, nur ist die Innen-Menge der
+     * `compose`-Teilbaum statt des Modul-Teilbaums. Ein Blatt-FUNC steht NICHT drin: es ist
+     * keine Whitebox, seine io-Kanten sind kein Rand.
+     *
+     * Der Rollup ist hier nicht Genauigkeit, sondern Existenz: ein zerlegter FUNC traegt selbst
+     * keine io-Kanten (die liegen an seinen Blaettern), ohne Teilbaum-Aufloesung waere die Zahl
+     * strukturell immer 0. Gemessen: `FUNC-block-grounding` 0 -> 19 (Spike CR-SM-282).
+     */
+    readonly byFunc: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * CR-SM-282: je MOD die FUNCs seines TEILBAUMS — direkt alloziert plus die seiner
+     * compose-Sub-MODs. Fuer ein Blatt-MOD identisch zur direkten Allokation; fuer ein
+     * Eltern-MOD ist es die Groesse, die R-04 gegen die Kreuzungen abwaegt. Ohne diese
+     * Zahl war ein Eltern-MOD fuer R-04 leer und die Regel schwieg per `funcCount <= coupled`.
+     */
+    readonly funcsByModule: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * CR-SM-293: dieselbe Grenze, jetzt mit RICHTUNG — Martins Ca/Ce, gerechnet im selben
+     * Durchlauf und auf derselben Zaehlbasis (verschiedene Vertraege) wie `pairs`/`byModule`.
+     *
+     * `afferentContracts` = Vertraege, die dieses Modul ueber seinen Rand LIEFERT: andere
+     * haengen von ihm ab. `efferentContracts` = Vertraege, die es von draussen BEZIEHT: es
+     * haengt von anderen ab. Ein Vertrag, dessen Produzent und Konsument beide im Teilbaum
+     * liegen, steht in keiner der beiden Mengen — er quert den Rand nicht.
+     *
+     * Die Richtung ist die Entscheidung, die bis hierher nirgends im Repo stand: der
+     * KONSUMENT haengt vom Vertrag des Produzenten ab, nicht umgekehrt. `moduleMetrics`
+     * las vorher „Kante zeigt weg = Abhaengigkeit" und drehte damit jedes reine
+     * Verbrauchermodul auf `I = 0` (maximal stabil), wo es `1` sein muss.
+     */
+    readonly afferentContracts: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly efferentContracts: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/** Die querenden Vertraege dieses Graphen — einmal je Graph-Objekt berechnet. */
+export declare function moduleCrossings(graph: OntologyGraph): ModuleCrossings;
+/** Zahl der verschiedenen Vertraege, die den Rand dieses Moduls queren. */
+export declare function crossingContractCount(graph: OntologyGraph, modId: string): number;
+/** Zahl der verschiedenen Vertraege, die den Rand dieser FUNC-Whitebox queren — CR-SM-283. */
+export declare function whiteboxContractCount(graph: OntologyGraph, funcId: string): number;
+/** Die FUNCs im Teilbaum dieses Moduls (direkt alloziert + die seiner Sub-MODs) — CR-SM-282. */
+export declare function subtreeFuncs(graph: OntologyGraph, modId: string): ReadonlySet<string>;

package/dist/se/module-crossings.js

@@ -0,0 +1,196 @@
+import { indexOf } from './graph-index.js';
+const CACHE = new WeakMap();
+function build(graph) {
+    const idx = indexOf(graph);
+    // FUNC → MOD (`FUNC -allocate-> MOD` ist `0..1`, also hoechstens ein Modul je FUNC).
+    const modOfFunc = new Map();
+    for (const mod of idx.elementsOfType('MOD')) {
+        for (const t of idx.in(mod.id, 'allocate')) {
+            if (idx.typeOf(t.source) === 'FUNC')
+                modOfFunc.set(t.source, mod.id);
+        }
+    }
+    // CR-SM-282: die Besitzkette eines MODs — es selbst plus seine `compose`-Vorfahren.
+    // `byModule` braucht sie, `pairs` nicht (s. Kopf).
+    const parentMod = new Map();
+    for (const mod of idx.elementsOfType('MOD')) {
+        for (const t of idx.in(mod.id, 'compose')) {
+            if (idx.typeOf(t.source) === 'MOD')
+                parentMod.set(mod.id, t.source);
+        }
+    }
+    const chainOf = (modId) => {
+        const out = [];
+        const seen = new Set();
+        let cur = modId;
+        while (cur !== undefined && !seen.has(cur)) {
+            seen.add(cur);
+            out.push(cur);
+            cur = parentMod.get(cur);
+        }
+        return out;
+    };
+    const ownersOfFunc = new Map();
+    for (const [func, mod] of modOfFunc)
+        ownersOfFunc.set(func, chainOf(mod));
+    // CR-SM-283: dieselbe Konstruktion auf dem FUNC-compose-Baum. `funcChainOf(f)` ist f selbst
+    // plus seine Vorfahren; nur ZERLEGTE FUNCs sind Whiteboxes und kommen als Kandidat in Frage.
+    const parentFunc = new Map();
+    const decomposed = new Set();
+    for (const t of graph.traces) {
+        if (t.type !== 'compose')
+            continue;
+        if (idx.typeOf(t.source) !== 'FUNC' || idx.typeOf(t.target) !== 'FUNC')
+            continue;
+        parentFunc.set(t.target, t.source);
+        decomposed.add(t.source);
+    }
+    const funcChain = new Map();
+    const funcChainOf = (funcId) => {
+        const cached = funcChain.get(funcId);
+        if (cached)
+            return cached;
+        const out = [];
+        const seen = new Set();
+        let cur = funcId;
+        while (cur !== undefined && !seen.has(cur)) {
+            seen.add(cur);
+            out.push(cur);
+            cur = parentFunc.get(cur);
+        }
+        funcChain.set(funcId, out);
+        return out;
+    };
+    const pairs = new Map();
+    const byModule = new Map();
+    const byFunc = new Map();
+    const afferentContracts = new Map();
+    const efferentContracts = new Map();
+    const addInto = (m, key, contracts) => {
+        let set = m.get(key);
+        if (!set) {
+            set = new Set();
+            m.set(key, set);
+        }
+        for (const c of contracts)
+            set.add(c);
+    };
+    const addTo = (mod, contracts) => addInto(byModule, mod, contracts);
+    for (const flow of idx.elementsOfType('FLOW')) {
+        const producerMods = new Set(idx.in(flow.id, 'io')
+            .filter(t => idx.typeOf(t.source) === 'FUNC')
+            .map(t => modOfFunc.get(t.source))
+            .filter((m) => !!m));
+        const consumerMods = new Set(idx.out(flow.id, 'io')
+            .filter(t => idx.typeOf(t.target) === 'FUNC')
+            .map(t => modOfFunc.get(t.target))
+            .filter((m) => !!m));
+        const schemas = idx.out(flow.id, 'relation')
+            .filter(t => idx.typeOf(t.target) === 'SCHEMA')
+            .map(t => t.target);
+        const contracts = schemas.length > 0 ? schemas : [`UNBOUND:${flow.id}`];
+        // CR-SM-283: derselbe Test auf dem compose-Baum. `allEndpoints` statt `endpoints` —
+        // die FUNC-Whitebox kennt keine Modul-Zugehoerigkeit, eine unallozierte FUNC liegt
+        // trotzdem drinnen oder draussen.
+        const allEndpoints = [
+            ...idx.in(flow.id, 'io').filter(t => idx.typeOf(t.source) === 'FUNC').map(t => t.source),
+            ...idx.out(flow.id, 'io').filter(t => idx.typeOf(t.target) === 'FUNC').map(t => t.target),
+        ];
+        const funcCandidates = new Set(allEndpoints.flatMap(f => funcChainOf(f)).filter(f => decomposed.has(f)));
+        for (const w of funcCandidates) {
+            const inside = allEndpoints.some(f => funcChainOf(f).includes(w));
+            const outside = allEndpoints.some(f => !funcChainOf(f).includes(w));
+            if (inside && outside) {
+                let set = byFunc.get(w);
+                if (!set) {
+                    set = new Set();
+                    byFunc.set(w, set);
+                }
+                for (const c of contracts)
+                    set.add(c);
+            }
+        }
+        // Der MOD-Teil ab hier: ohne Zuordnung auf BEIDEN Seiten gibt es keine Modulgrenze.
+        // Der FUNC-Teil oben haengt bewusst NICHT daran — eine Whitebox ist eine Whitebox,
+        // auch wenn ihre Blaetter noch keinem Modul zugewiesen sind (R-22 meldet das separat).
+        if (producerMods.size === 0 || consumerMods.size === 0)
+            continue;
+        for (const a of producerMods) {
+            for (const b of consumerMods) {
+                if (a === b)
+                    continue;
+                const [modA, modB] = a < b ? [a, b] : [b, a];
+                const key = `${modA}::${modB}`;
+                let entry = pairs.get(key);
+                if (!entry) {
+                    entry = { modA, modB, contracts: new Set() };
+                    pairs.set(key, entry);
+                }
+                for (const c of contracts)
+                    entry.contracts.add(c);
+            }
+        }
+        // byModule MIT Rollup (CR-SM-282): ein Vertrag quert den Rand von `m`, wenn ein Endpunkt
+        // in `m`s Besitzkette liegt und einer nicht. Ohne Eltern-MODs faellt das exakt auf die
+        // frueheren `addTo(a)/addTo(b)` zurueck — das ist die Regressions-Invariante.
+        const endpoints = [
+            ...idx.in(flow.id, 'io').filter(t => idx.typeOf(t.source) === 'FUNC').map(t => t.source),
+            ...idx.out(flow.id, 'io').filter(t => idx.typeOf(t.target) === 'FUNC').map(t => t.target),
+        ].filter(f => ownersOfFunc.has(f));
+        const candidates = new Set(endpoints.flatMap(f => ownersOfFunc.get(f)));
+        for (const m of candidates) {
+            const inside = endpoints.some(f => ownersOfFunc.get(f).includes(m));
+            const outside = endpoints.some(f => !ownersOfFunc.get(f).includes(m));
+            if (inside && outside)
+                addTo(m, contracts);
+        }
+        // CR-SM-293: dieselben Endpunkte, nach Seite getrennt. Ein Modul, das auf BEIDEN
+        // Seiten steht (es produziert und konsumiert diesen Vertrag im eigenen Teilbaum),
+        // faellt aus beiden Mengen — der Vertrag quert seinen Rand nicht.
+        const producerChain = new Set(idx.in(flow.id, 'io')
+            .filter(t => idx.typeOf(t.source) === 'FUNC' && ownersOfFunc.has(t.source))
+            .flatMap(t => ownersOfFunc.get(t.source)));
+        const consumerChain = new Set(idx.out(flow.id, 'io')
+            .filter(t => idx.typeOf(t.target) === 'FUNC' && ownersOfFunc.has(t.target))
+            .flatMap(t => ownersOfFunc.get(t.target)));
+        for (const m of producerChain)
+            if (!consumerChain.has(m))
+                addInto(afferentContracts, m, contracts);
+        for (const m of consumerChain)
+            if (!producerChain.has(m))
+                addInto(efferentContracts, m, contracts);
+    }
+    const funcsByModule = new Map();
+    for (const [func, owners] of ownersOfFunc) {
+        for (const m of owners) {
+            let set = funcsByModule.get(m);
+            if (!set) {
+                set = new Set();
+                funcsByModule.set(m, set);
+            }
+            set.add(func);
+        }
+    }
+    return { pairs, byModule, byFunc, funcsByModule, afferentContracts, efferentContracts };
+}
+/** Die querenden Vertraege dieses Graphen — einmal je Graph-Objekt berechnet. */
+export function moduleCrossings(graph) {
+    let result = CACHE.get(graph);
+    if (result === undefined) {
+        result = build(graph);
+        CACHE.set(graph, result);
+    }
+    return result;
+}
+/** Zahl der verschiedenen Vertraege, die den Rand dieses Moduls queren. */
+export function crossingContractCount(graph, modId) {
+    return moduleCrossings(graph).byModule.get(modId)?.size ?? 0;
+}
+/** Zahl der verschiedenen Vertraege, die den Rand dieser FUNC-Whitebox queren — CR-SM-283. */
+export function whiteboxContractCount(graph, funcId) {
+    return moduleCrossings(graph).byFunc.get(funcId)?.size ?? 0;
+}
+/** Die FUNCs im Teilbaum dieses Moduls (direkt alloziert + die seiner Sub-MODs) — CR-SM-282. */
+export function subtreeFuncs(graph, modId) {
+    return moduleCrossings(graph).funcsByModule.get(modId) ?? new Set();
+}

package/dist/se/near-duplicate-rules.d.ts

@@ -1,33 +1,25 @@
 /**
  * CR-121 P2: Near-Duplicate Detection for FUNC and SCHEMA elements.
- * Uses pre-injected similarity matrices (same pattern as BQ-04).
+ *
+ * CR-SM-286: **die Aehnlichkeit wird HIER gerechnet, nicht injiziert.**
+ *
+ * Bis hierher trugen beide Regeln `if (!_ndXXMatrix) return [];` und warteten auf
+ * `setND01SimilarityMatrix()` / `setND02SimilarityMatrix()`. Die Formel stand als Prosa in
+ * diesem Kopf, die Implementierung in `graphcode/src/kernel/measure/nd-similarity.ts`. Folgen,
+ * alle gemessen: bei severity `error` ununterscheidbares Fail-open (moneyflow trug 16
+ * ND-01-Befunde, die ausserhalb graphcodes niemand sah), prozessweiter Modulzustand (Graph A
+ * urteilte ueber Graph B, wogegen graphcode eine `finally`-Klammer brauchte), und AO-D01 —
+ * eine GATE-Regel — schwaechte sich stillschweigend ab ("no matrix → assume pass").
+ *
+ * Jetzt: `funcSimilarity(graph)` / `schemaSimilarity(graph)` aus `similarity.ts`, je Graph
+ * gecacht. Kein Setter, kein Modulzustand, kein Fail-open. Formeln und Schwelle 0,85 sind
+ * zeichengleich uebernommen — dasselbe Urteil an der richtigen Stelle.
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation } from './rules.js';
-/**
- * Inject pre-computed similarity matrix for FUNC elements.
- * Similarity = 0.35 × descr_jaccard + 0.25 × verb_match + 0.25 × io_topology + 0.15 × req_overlap
- */
-export declare function setND01SimilarityMatrix(data: {
-    funcIds: string[];
-    matrix: number[][];
-} | null): void;
-/** ND-01: FUNC pairs with similarity >= 0.85 → error. */
+/** ND-01: FUNC pairs with similarity >= 0.85 -> error. */
 export declare function nd01FuncNearDuplicate(graph: OntologyGraph): RuleViolation[];
-/**
- * Inject pre-computed similarity matrix for SCHEMA elements.
- * Similarity = 0.50 × field_jaccard + 0.30 × descr_jaccard + 0.20 × usage_overlap
- */
-export declare function setND02SimilarityMatrix(data: {
-    schemaIds: string[];
-    matrix: number[][];
-} | null): void;
-/** Read-only access to current ND-02 matrix (used by AO-D01 for schema overlap). */
-export declare function getND02SimilarityMatrix(): {
-    schemaIds: string[];
-    matrix: number[][];
-} | null;
-/** ND-02: SCHEMA pairs with similarity >= 0.85 → error. */
+/** ND-02: SCHEMA pairs with similarity >= 0.85 -> error. */
 export declare function nd02SchemaNearDuplicate(graph: OntologyGraph): RuleViolation[];
 export declare const ND_RULES: readonly [{
     readonly id: "ND-01";

package/dist/se/near-duplicate-rules.js

@@ -1,101 +1,30 @@
+import { funcSimilarity, schemaSimilarity, pairsAbove } from './similarity.js';
 const ND_SIMILARITY_THRESHOLD = 0.85;
-// ---------------------------------------------------------------------------
-// ND-01: FUNC near-duplicates
-// ---------------------------------------------------------------------------
-let _nd01Matrix = null;
-/**
- * Inject pre-computed similarity matrix for FUNC elements.
- * Similarity = 0.35 × descr_jaccard + 0.25 × verb_match + 0.25 × io_topology + 0.15 × req_overlap
- */
-export function setND01SimilarityMatrix(data) {
-    _nd01Matrix = data;
+/** Der gemeinsame Rumpf beider Regeln — eine Schleife, zwei Meldungstexte. */
+function nearDuplicates(graph, sim, ruleId, what, fixHint) {
+    const byId = new Map(graph.elements.map(e => [e.id, e]));
+    return pairsAbove(sim, ND_SIMILARITY_THRESHOLD).map(({ a, b, similarity }) => {
+        const elA = byId.get(a);
+        const elB = byId.get(b);
+        const pct = Math.round(similarity * 100);
+        return {
+            rule_id: ruleId,
+            severity: 'error',
+            element_id: b,
+            message: `${b}${elB?.name ? ' (' + elB.name + ')' : ''} is ${pct}% similar to ${a}${elA?.name ? ' (' + elA.name + ')' : ''} — potential duplicate ${what}`,
+            fix_hint: fixHint,
+            context: { element_type: elB?.type, element_name: elB?.name },
+        };
+    });
 }
-/** ND-01: FUNC pairs with similarity >= 0.85 → error. */
+/** ND-01: FUNC pairs with similarity >= 0.85 -> error. */
 export function nd01FuncNearDuplicate(graph) {
-    if (!_nd01Matrix)
-        return [];
-    const { funcIds, matrix } = _nd01Matrix;
-    const violations = [];
-    const seen = new Set();
-    for (let i = 0; i < funcIds.length; i++) {
-        for (let j = i + 1; j < funcIds.length; j++) {
-            const sim = matrix[i][j];
-            if (sim < ND_SIMILARITY_THRESHOLD)
-                continue;
-            const pairKey = `${funcIds[i]}:${funcIds[j]}`;
-            if (seen.has(pairKey))
-                continue;
-            seen.add(pairKey);
-            const pct = Math.round(sim * 100);
-            const elI = graph.elements.find(e => e.id === funcIds[i]);
-            const elJ = graph.elements.find(e => e.id === funcIds[j]);
-            violations.push({
-                rule_id: 'ND-01',
-                severity: 'error',
-                element_id: funcIds[j],
-                message: `${funcIds[j]}${elJ?.name ? ' (' + elJ.name + ')' : ''} is ${pct}% similar to ${funcIds[i]}${elI?.name ? ' (' + elI.name + ')' : ''} — potential duplicate function`,
-                fix_hint: 'Merge into single FUNC or differentiate responsibilities',
-                context: {
-                    element_type: elJ?.type,
-                    element_name: elJ?.name,
-                },
-            });
-        }
-    }
-    return violations;
+    return nearDuplicates(graph, funcSimilarity(graph), 'ND-01', 'function', 'Merge into single FUNC or differentiate responsibilities');
 }
-// ---------------------------------------------------------------------------
-// ND-02: SCHEMA near-duplicates
-// ---------------------------------------------------------------------------
-let _nd02Matrix = null;
-/**
- * Inject pre-computed similarity matrix for SCHEMA elements.
- * Similarity = 0.50 × field_jaccard + 0.30 × descr_jaccard + 0.20 × usage_overlap
- */
-export function setND02SimilarityMatrix(data) {
-    _nd02Matrix = data;
-}
-/** Read-only access to current ND-02 matrix (used by AO-D01 for schema overlap). */
-export function getND02SimilarityMatrix() {
-    return _nd02Matrix;
-}
-/** ND-02: SCHEMA pairs with similarity >= 0.85 → error. */
+/** ND-02: SCHEMA pairs with similarity >= 0.85 -> error. */
 export function nd02SchemaNearDuplicate(graph) {
-    if (!_nd02Matrix)
-        return [];
-    const { schemaIds, matrix } = _nd02Matrix;
-    const violations = [];
-    const seen = new Set();
-    for (let i = 0; i < schemaIds.length; i++) {
-        for (let j = i + 1; j < schemaIds.length; j++) {
-            const sim = matrix[i][j];
-            if (sim < ND_SIMILARITY_THRESHOLD)
-                continue;
-            const pairKey = `${schemaIds[i]}:${schemaIds[j]}`;
-            if (seen.has(pairKey))
-                continue;
-            seen.add(pairKey);
-            const pct = Math.round(sim * 100);
-            const elI = graph.elements.find(e => e.id === schemaIds[i]);
-            const elJ = graph.elements.find(e => e.id === schemaIds[j]);
-            violations.push({
-                rule_id: 'ND-02',
-                severity: 'error',
-                element_id: schemaIds[j],
-                message: `${schemaIds[j]}${elJ?.name ? ' (' + elJ.name + ')' : ''} is ${pct}% similar to ${schemaIds[i]}${elI?.name ? ' (' + elI.name + ')' : ''} — potential duplicate schema`,
-                fix_hint: 'Merge schemas or differentiate field sets',
-                context: {
-                    element_type: elJ?.type,
-                    element_name: elJ?.name,
-                },
-            });
-        }
-    }
-    return violations;
+    return nearDuplicates(graph, schemaSimilarity(graph), 'ND-02', 'schema', 'Merge schemas or differentiate field sets');
 }
-// ---------------------------------------------------------------------------
-// Aggregate
-// ---------------------------------------------------------------------------
 export const ND_RULES = [
     { id: 'ND-01', name: 'FuncNearDuplicate', severity: 'error', evaluate: nd01FuncNearDuplicate, domain: ['FUNC'] },
     { id: 'ND-02', name: 'SchemaNearDuplicate', severity: 'error', evaluate: nd02SchemaNearDuplicate, domain: ['SCHEMA'] },

package/dist/se/ontology.d.ts

@@ -79,14 +79,6 @@ export type ReqKind = z.infer<typeof ReqKind>;
  * und faellt danach am Enum-Vergleich durch. Die Drift wird sichtbar, nicht geheilt.
  */
 export declare function normalizeReqKinds(raw: unknown): readonly string[];
-export declare const AsilLevel: z.ZodEnum<{
-    QM: "QM";
-    A: "A";
-    B: "B";
-    C: "C";
-    D: "D";
-}>;
-export type AsilLevel = z.infer<typeof AsilLevel>;
 /** INCOSE TIAD verification method (only relevant for type=TEST). */
 export declare const VerificationMethod: z.ZodEnum<{
     test: "test";
@@ -254,13 +246,6 @@ export declare const OntologyElement: z.ZodObject<{
     }>;
     name: z.ZodString;
     description: z.ZodString;
-    asil: z.ZodOptional<z.ZodEnum<{
-        QM: "QM";
-        A: "A";
-        B: "B";
-        C: "C";
-        D: "D";
-    }>>;
     method: z.ZodOptional<z.ZodEnum<{
         test: "test";
         inspection: "inspection";
@@ -327,13 +312,6 @@ export declare const OntologyGraph: z.ZodObject<{
         }>;
         name: z.ZodString;
         description: z.ZodString;
-        asil: z.ZodOptional<z.ZodEnum<{
-            QM: "QM";
-            A: "A";
-            B: "B";
-            C: "C";
-            D: "D";
-        }>>;
         method: z.ZodOptional<z.ZodEnum<{
             test: "test";
             inspection: "inspection";

package/dist/se/ontology.js

@@ -65,7 +65,6 @@ export function normalizeReqKinds(raw) {
         return raw.map(k => String(k).trim()).filter(Boolean);
     return String(raw).split(',').map(k => k.trim()).filter(Boolean);
 }
-export const AsilLevel = z.enum(['QM', 'A', 'B', 'C', 'D']);
 /** INCOSE TIAD verification method (only relevant for type=TEST). */
 export const VerificationMethod = z.enum(['test', 'inspection', 'analysis', 'demonstration']);
 /** Test execution result (only relevant for type=TEST). */
@@ -197,7 +196,6 @@ export const OntologyElement = z.object({
     type: ElementType,
     name: z.string(),
     description: z.string(),
-    asil: AsilLevel.optional(),
     /** INCOSE TIAD verification method — only for TEST elements (CR-057). */
     method: VerificationMethod.optional(),
     /** REQ kinds: multi-valued classification (CR-180). Only for REQ elements. */

package/dist/se/policy.d.ts

@@ -24,6 +24,12 @@ export declare const MetricPolicySchema: z.ZodObject<{
     crossingFlows: z.ZodNullable<z.ZodObject<{
         warning: z.ZodNumber;
     }, z.core.$strip>>;
+    decompositionBreadth: z.ZodNullable<z.ZodObject<{
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
+    boundaryWidth: z.ZodNullable<z.ZodObject<{
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
     riskRpn: z.ZodNullable<z.ZodNumber>;
     apTable: z.ZodNullable<z.ZodObject<{
         severityBands: z.ZodArray<z.ZodObject<{

package/dist/se/policy.js

@@ -34,6 +34,27 @@ export const MetricPolicySchema = z.object({
      * in die `arch`-Dimension ein (CR-SM-236).
      */
     crossingFlows: z.object({ warning: z.number().int().min(1) }).nullable(),
+    /**
+     * CR-SM-282: Kinderzahl je Blackbox (RD-04). Stand bis hierher als
+     * `DECOMPOSITION_BREADTH_MAX = 11` inline in `rules.ts` — eine Urteilsschwelle, die sich
+     * weder per grep noch aus dem Regelnamen ablesen liess (dieselbe Klasse, die CR-SM-236 fuer
+     * R-04 aufgeloest hat). `null` -> messen, nicht urteilen: die Regel schweigt.
+     *
+     * Der Default bleibt 11 und ist damit verhaltensgleich zum Bisherigen. Die Doktrin
+     * (`se:top-level`: „max 5 per level") ist bewusst NICHT der Default: `info` bei 5 haette am
+     * graphcode-Selbstmodell 20 zusaetzliche Befunde erzeugt, und `readiness` zaehlt `info`
+     * ungefiltert in den Nenner (`score = 1 - Verstoesse / applicable`) — genau der Grund, aus dem
+     * MT-03 zur Messung statt zur Regel wurde. Wer doktrin-streng fahren will, setzt 5.
+     */
+    decompositionBreadth: z.object({ warning: z.number().int().min(2) }).nullable(),
+    /**
+     * CR-SM-283: Randbreite je Blackbox (BW-02) — verschiedene Vertraege, die den Rand queren.
+     * Bewusst OHNE `info`-Stufe: die Verteilung gibt sie nicht her. bok und graph-view-edit enden
+     * beide bei 3; eine info-Schwelle dort truege bok 4 Befunde auf 9 Blackboxes, und `readiness`
+     * zaehlt `info` ungefiltert in den Nenner (`score = 1 - Verstoesse / applicable`) — der Grund,
+     * aus dem MT-03 zur Messung statt zur Regel wurde. `null` -> messen, nicht urteilen.
+     */
+    boundaryWidth: z.object({ warning: z.number().int().min(1) }).nullable(),
     /**
      * FM-03: RPN (severity · occurrence · detection), ab dem ein Risiko-REQ eine bestandene
      * Verifikation braucht (exklusiv). null → FM-03 feuert nie.
@@ -84,15 +105,45 @@ export const MetricPolicySchema = z.object({
  * `> 5` → warning, also warning ab 6.
  */
 export const DEFAULT_METRIC_POLICY = {
-    instability: 0.7,
+    // CR-SM-293: `null` — MESSEN, NICHT URTEILEN. Die 0.7 stand hier als Startwert und war laut
+    // CR-SM-223 ausdruecklich "gesetzt, nicht gemessen". Nachdem MT-01 nur noch Kopplung zaehlt,
+    // ist die Verteilung ueber 149 messbare Module ZWEIGIPFLIG: 44 liegen exakt auf 0.00 (reine
+    // Produzenten), 45 exakt auf 1.00 (reine Konsumenten), und 45 der 51 Befunde bei 0.7 sind
+    // genau die 1.00. Aus einer solchen Verteilung laesst sich keine Schwelle ABLESEN (Praezedenz
+    // CR-SM-283/BW-02), und der Grund ist Struktur, nicht Zaehlweise: die meisten Module tragen
+    // zwei bis drei kreuzende Vertraege, da ist das Verhaeltnis 0 oder 1.
+    //
+    // Tiefer liegt der Einwand von Martin selbst: I ist eine KOORDINATE, kein Defekt. Sein Satz
+    // lautet "in Richtung Stabilitaet abhaengen", nicht "I klein halten" — ein Blattmodul mit
+    // I = 1.0 ist richtig, nicht kaputt. Damit fehlt MT-01 die Eigenschaft, die CR-SM-287 §2 von
+    // einer Steuerdimension verlangt: GERICHTET, "weniger ist besser, ohne Diskussion".
+    //
+    // Die Zahl bleibt vollstaendig erhalten — in jeder Modulzeile von `graph_metrics`, im Export
+    // und im gve-Dashboard, das den Zustand bereits rendert ("Instabilitaet wird hier nur
+    // gemessen"). Es entsteht nur kein Verstoss. graphcode faehrt das seit CR-GC-329 in seiner
+    // eigenen Config; dieser Default macht aus der Konfigurationszufaelligkeit eine Entscheidung.
+    instability: null,
     lcom4: { info: 4, warning: 6 },
     // CR-SM-236: die bisherigen Literale, jetzt an einer grep-baren Stelle.
     // `crossingFlows.warning = 3` ist die unveränderte Alt-Semantik: vorher `count > 2` → warning.
     crossingFlows: { warning: 3 },
+    // CR-SM-282: unveraenderte Alt-Semantik (`DECOMPOSITION_BREADTH_MAX = 11`, `> max` meldet).
+    // CR-SM-296: 7+-2 ist die Doktrin (`se:top-level`), 9 ist ihre Obergrenze. Bis hierher stand
+    // hier 11 -- gesetzt, nicht abgelesen. CR-SM-282 hatte gegen die Doktrin-Zahl 5 entschieden,
+    // weil `info` bei 5 den readiness-Nenner verwaessert haette; das Argument traegt fuer die
+    // OBERgrenze nicht, denn RD-04 meldet als `warning`. Die Zahl steht jetzt an EINER Stelle und
+    // gilt fuer beide Zerlegungsfragen -- Sub-FUNC und Sub-MOD.
+    decompositionBreadth: { warning: 9 },
+    // CR-SM-283: aus der Verteilung abgelesen — bok/gve max 3, graphcode 19, moneyflow 17.
+    boundaryWidth: { warning: 5 },
     riskRpn: 100,
     // `large`/`coupled`/`crossings` = die drei Literale aus `maxModuleSize`: vorher
     // `funcCount <= 8` → skip, `funcCount > 12` → groß, `crossings > 2` → gekoppelt.
-    moduleSize: { large: 12, coupled: 8, crossings: 2 },
+    // CR-SM-296: an dieselbe Doktrin gebunden statt danebengesetzt. R-04 ist seit diesem CR ALLEIN
+    // fuer die Modulgroesse zustaendig (RD-04 hat ihr Allokations-Bein abgegeben), also gilt hier
+    // dieselbe 7+-2: `large` = 9 (Obergrenze), `coupled` = 7 (Untergrenze, ab der die Regel
+    // hinsieht). Vorher 12/8 -- zwei Zahlen fuer dieselbe Frage, unverbunden mit den 11 darueber.
+    moduleSize: { large: 9, coupled: 7, crossings: 2 },
     // CR-SM-229: kein Startwert möglich und keiner gewollt — die Tabelle steht nur im Handbook.
     // `null` heißt hier nicht „aus", sondern „markierter Übergang": bestätigte AP-Invarianten,
     // sonst RPN-Bänder. `apMethod()` macht das für den Leser sichtbar.

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

@@ -20,6 +20,24 @@ export declare function setBQ04SimilarityMatrix(data: {
 /**
  * BQ-04 checks for duplicate / near-duplicate requirements using
  * pre-computed embedding similarity. Returns [] when no matrix is set.
+ *
+ * CR-SM-286: **bewusst NICHT angeschlossen — anders als ND-01/ND-02.**
+ *
+ * Die Naht ist dieselbe und sie ist genauso tot: `setBQ04SimilarityMatrix()` ruft im gesamten
+ * Familienbaum niemand (CR-SM-278, erneut geprueft). Der Unterschied liegt in der Eingabe. ND-01
+ * und ND-02 nennen deterministische Formeln ueber Graphinhalt (Jaccard ueber Beschreibung,
+ * Verb, io-Topologie, Felder) — die konnten nach `similarity.ts` wandern und tun dort dasselbe.
+ * BQ-04 verlangt laut eigener Zeile "pre-computed EMBEDDING similarity", und Embeddings kann ein
+ * reines Vertragspaket nicht berechnen: kein Modell, kein Netz, kein Zufall.
+ *
+ * Ein Ersatzmass haette ich erfinden muessen. Ein Versuch mit 0.7*Beschreibung + 0.3*Name lief:
+ * **0 Befunde an allen neun Familiengraphen** und 4950 an einer templatierten Fixture — also
+ * genau die zwei Gate-7-Ausreisser zugleich ("0 Befunde am Selbstmodell" und "quadratisch mit
+ * der Graphgroesse"). Erfundene Gewichte ohne Messung sind keine Reparatur.
+ *
+ * Damit ist BQ-04 der naechste AO-D03-Fall: entweder eine Eingabe, die der Host liefern MUSS
+ * (dann gehoert die Regel nicht in ein reines Paket), oder streichen. Das ist eine
+ * Grammatik-Entscheidung — `se-grammar-review`, eigener CR, nicht hier nebenbei.
  */
 export declare function bq04Necessary(graph: OntologyGraph): RuleViolation[];
 export declare function bq06Conforming(graph: OntologyGraph): RuleViolation[];