@sigloch/contracts 6.3.0 → 10.0.0

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

@@ -21,7 +21,6 @@ export declare const ElementType: z.ZodEnum<{
     TEST: "TEST";
     MOD: "MOD";
     SCHEMA: "SCHEMA";
-    SESSION: "SESSION";
     CR: "CR";
     MS: "MS";
 }>;
@@ -38,28 +37,48 @@ export declare const TraceType: z.ZodEnum<{
     verify: "verify";
     allocate: "allocate";
     relation: "relation";
-    produces: "produces";
 }>;
 export type TraceType = z.infer<typeof TraceType>;
-/** REQ kind — 7 values aligned with SysML 2.0 + FMEA (CR-180). */
+/**
+ * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ *
+ * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
+ * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
+ * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
+ * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
+ * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
+ * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
+ * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
+ * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ */
 export declare const ReqKind: z.ZodEnum<{
     functional: "functional";
     "non-functional": "non-functional";
     risk: "risk";
-    negative: "negative";
     mitigation: "mitigation";
     precondition: "precondition";
     postcondition: "postcondition";
 }>;
 export type ReqKind = z.infer<typeof ReqKind>;
-export declare const AsilLevel: z.ZodEnum<{
-    QM: "QM";
-    A: "A";
-    B: "B";
-    C: "C";
-    D: "D";
-}>;
-export type AsilLevel = z.infer<typeof AsilLevel>;
+/**
+ * `kinds` in der Form, die WIRKLICH auf Platte liegt — als Liste.
+ *
+ * Gefunden beim Migrations-Audit zu CR-SM-266 (2026-08-25), nicht von Hand: drei Graphen der
+ * Familie tragen `kinds` als blossen STRING statt als Liste (`graph-view-edit`
+ * `REQ-edit-genesis: 'functional'`, dazu gc_test-graphview und graphify), einer davon mit dem
+ * Wert `'security'`, den das Enum gar nicht kennt. Ursache ist der Format-E-Weg: dort reist
+ * das Feld als `@kinds a,b` und wird erst vom Konsumenten gehoben (graph-api-core, CR-195d).
+ *
+ * Seit die where-Praedikate `kinds` LESEN (CR-SM-266 B), ist diese Drift tragend: ein
+ * `kinds.every(...)` auf einem String wirft, und eine geworfene Exception in `isValidTrace`
+ * reisst den ganzen Regellauf statt einen Befund zu melden. Die SSOT muss auch bei kaputten
+ * Daten ein URTEIL liefern, keinen Absturz.
+ *
+ * Normalisieren heisst hier ausdruecklich NICHT raten: `'a,b'` wird zu `['a','b']`, weil genau
+ * das die Schreibform ist — ein unbekannter Wert wie `'security'` ueberlebt die Normalisierung
+ * und faellt danach am Enum-Vergleich durch. Die Drift wird sichtbar, nicht geheilt.
+ */
+export declare function normalizeReqKinds(raw: unknown): readonly string[];
 /** INCOSE TIAD verification method (only relevant for type=TEST). */
 export declare const VerificationMethod: z.ZodEnum<{
     test: "test";
@@ -222,19 +241,11 @@ export declare const OntologyElement: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>;
     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";
@@ -245,7 +256,6 @@ export declare const OntologyElement: z.ZodObject<{
         functional: "functional";
         "non-functional": "non-functional";
         risk: "risk";
-        negative: "negative";
         mitigation: "mitigation";
         precondition: "precondition";
         postcondition: "postcondition";
@@ -265,12 +275,6 @@ export type OntologyElement = z.infer<typeof OntologyElement>;
  * A trace (edge) in the SE ontology graph.
  * `label` provides semantic context for 'relation' edges (e.g. 'derives', 'depends-on').
  */
-/** Trace category: modeling traces are user-visible, audit traces are internal. */
-export declare const TraceCategory: z.ZodEnum<{
-    modeling: "modeling";
-    audit: "audit";
-}>;
-export type TraceCategory = z.infer<typeof TraceCategory>;
 export declare const Trace: z.ZodObject<{
     source: z.ZodString;
     target: z.ZodString;
@@ -281,12 +285,7 @@ export declare const Trace: z.ZodObject<{
         verify: "verify";
         allocate: "allocate";
         relation: "relation";
-        produces: "produces";
     }>;
-    category: z.ZodOptional<z.ZodEnum<{
-        modeling: "modeling";
-        audit: "audit";
-    }>>;
     label: z.ZodOptional<z.ZodString>;
     weight: z.ZodDefault<z.ZodNumber>;
     attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -308,19 +307,11 @@ export declare const OntologyGraph: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>;
         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";
@@ -331,7 +322,6 @@ export declare const OntologyGraph: z.ZodObject<{
             functional: "functional";
             "non-functional": "non-functional";
             risk: "risk";
-            negative: "negative";
             mitigation: "mitigation";
             precondition: "precondition";
             postcondition: "postcondition";
@@ -356,12 +346,7 @@ export declare const OntologyGraph: z.ZodObject<{
             verify: "verify";
             allocate: "allocate";
             relation: "relation";
-            produces: "produces";
         }>;
-        category: z.ZodOptional<z.ZodEnum<{
-            modeling: "modeling";
-            audit: "audit";
-        }>>;
         label: z.ZodOptional<z.ZodString>;
         weight: z.ZodDefault<z.ZodNumber>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -372,7 +357,7 @@ export declare const OntologyGraph: z.ZodObject<{
 export type OntologyGraph = z.infer<typeof OntologyGraph>;
 /** Human-readable descriptions for each ElementType. */
 export declare const ELEMENT_DESCRIPTIONS: Record<ElementType, string>;
-/** Element types used in modeling (user-visible). Excludes audit types (SESSION, CR). */
+/** Element types used in modeling (user-visible). Excludes the planning type CR. */
 export declare const MODELING_ELEMENT_TYPES: ElementType[];
 export interface AttributeSpec {
     key: string;

package/dist/se/ontology.js

@@ -13,7 +13,7 @@ import { z } from 'zod/v4';
 export const ElementType = z.enum([
     'SYS', 'UC', 'ACTOR', 'FCHAIN',
     'FUNC', 'FLOW', 'REQ', 'TEST',
-    'MOD', 'SCHEMA', 'SESSION', 'CR',
+    'MOD', 'SCHEMA', 'CR',
     'MS',
 ]);
 /**
@@ -22,14 +22,49 @@ export const ElementType = z.enum([
  * verify=test coverage, allocate=function-to-module, relation=generic link.
  */
 export const TraceType = z.enum([
-    'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation', 'produces',
+    'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation',
 ]);
-/** REQ kind — 7 values aligned with SysML 2.0 + FMEA (CR-180). */
+/**
+ * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ *
+ * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
+ * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
+ * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
+ * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
+ * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
+ * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
+ * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
+ * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ */
 export const ReqKind = z.enum([
-    'functional', 'non-functional', 'risk', 'negative',
+    'functional', 'non-functional', 'risk',
     'mitigation', 'precondition', 'postcondition',
 ]);
-export const AsilLevel = z.enum(['QM', 'A', 'B', 'C', 'D']);
+/**
+ * `kinds` in der Form, die WIRKLICH auf Platte liegt — als Liste.
+ *
+ * Gefunden beim Migrations-Audit zu CR-SM-266 (2026-08-25), nicht von Hand: drei Graphen der
+ * Familie tragen `kinds` als blossen STRING statt als Liste (`graph-view-edit`
+ * `REQ-edit-genesis: 'functional'`, dazu gc_test-graphview und graphify), einer davon mit dem
+ * Wert `'security'`, den das Enum gar nicht kennt. Ursache ist der Format-E-Weg: dort reist
+ * das Feld als `@kinds a,b` und wird erst vom Konsumenten gehoben (graph-api-core, CR-195d).
+ *
+ * Seit die where-Praedikate `kinds` LESEN (CR-SM-266 B), ist diese Drift tragend: ein
+ * `kinds.every(...)` auf einem String wirft, und eine geworfene Exception in `isValidTrace`
+ * reisst den ganzen Regellauf statt einen Befund zu melden. Die SSOT muss auch bei kaputten
+ * Daten ein URTEIL liefern, keinen Absturz.
+ *
+ * Normalisieren heisst hier ausdruecklich NICHT raten: `'a,b'` wird zu `['a','b']`, weil genau
+ * das die Schreibform ist — ein unbekannter Wert wie `'security'` ueberlebt die Normalisierung
+ * und faellt danach am Enum-Vergleich durch. Die Drift wird sichtbar, nicht geheilt.
+ */
+export function normalizeReqKinds(raw) {
+    if (raw == null)
+        return [];
+    if (Array.isArray(raw))
+        return raw.map(k => String(k).trim()).filter(Boolean);
+    return String(raw).split(',').map(k => k.trim()).filter(Boolean);
+}
 /** 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). */
@@ -161,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. */
@@ -175,14 +209,24 @@ export const OntologyElement = z.object({
  * A trace (edge) in the SE ontology graph.
  * `label` provides semantic context for 'relation' edges (e.g. 'derives', 'depends-on').
  */
-/** Trace category: modeling traces are user-visible, audit traces are internal. */
-export const TraceCategory = z.enum(['modeling', 'audit']);
+/*
+ * CR-SM-266 D5: `TraceCategory` und `Trace.category` ENTFALLEN ersatzlos.
+ *
+ * Die Unterscheidung modeling/audit trug genau EIN Pattern (`SESSION -produces-> *`), und das
+ * ist mit D5 weg. Was blieb, waere ein SCHLUPFLOCH gewesen, kein Vertrag: R-08 und R-18 haben
+ * `category === 'audit'` uebersprungen (`filter(t => t.category !== 'audit')`), also haette
+ * JEDE Kante mit diesem Attribut die komplette Pattern-Matrix umgangen — die
+ * Referenzintegritaet gleich mit. Ein selbstgesetztes Attribut, das eine Strukturpruefung
+ * abschaltet, ist genau die Klasse, die CR-SM-263 und CR-SM-257 abgelehnt haben, und hier
+ * zusaetzlich der billige Zweitweg aus CR-GC-366: die Kante gaebe es weiterhin, nur ungeprueft.
+ * Gemessen: 0 Kanten in allen 9 aktiven Familie-Graphen tragen `category` ueberhaupt — die
+ * Entfernung nimmt niemandem etwas weg. Provenance lebt seit CR-GC-347 in
+ * `.graphcode/audit.jsonl`, ausserhalb des Graphen.
+ */
 export const Trace = z.object({
     source: z.string(),
     target: z.string(),
     type: TraceType,
-    /** 'modeling' (default, user-visible) or 'audit' (internal, e.g. produces traces). Absent = modeling. */
-    category: TraceCategory.optional(),
     label: z.string().optional(),
     weight: z.number().default(1),
     attributes: z.record(z.string(), z.unknown()).optional(),
@@ -208,12 +252,11 @@ export const ELEMENT_DESCRIPTIONS = {
     TEST: 'Testfall',
     MOD: 'Modul (SW-Paket oder HW-Baugruppe)',
     SCHEMA: 'Datenschema (Zod)',
-    SESSION: 'Audit-Session',
     CR: 'Change Request',
     MS: 'Meilenstein',
 };
-/** Element types used in modeling (user-visible). Excludes audit types (SESSION, CR). */
-export const MODELING_ELEMENT_TYPES = ElementType.options.filter(t => t !== 'SESSION' && t !== 'CR');
+/** Element types used in modeling (user-visible). Excludes the planning type CR. */
+export const MODELING_ELEMENT_TYPES = ElementType.options.filter(t => t !== 'CR');
 /**
  * Documented attributes per ElementType.
  * `attributes` is Record<string,unknown> on the schema level, but these are

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<{