@sigloch/contracts 6.3.0 → 9.1.0

package/dist/se/meta-model.js

@@ -1,3 +1,8 @@
+import { normalizeReqKinds } from './ontology.js';
+/** Die Kinds, die eine Wirkkette bzw. ein Verhalten traegt. */
+const BEHAVIOURAL_KINDS = ['functional', 'precondition', 'postcondition'];
+/** Die Kinds, die eine Struktur (Modul/System) traegt. */
+const STRUCTURAL_KINDS = ['non-functional', 'risk', 'mitigation'];
 export const TRACE_PATTERNS = [
     // ── compose (parent → child) ──
     { source: 'SYS', target: 'SYS', type: 'compose', cardinality: '0..*', description: 'System decomposes into subsystems' },
@@ -15,11 +20,25 @@ export const TRACE_PATTERNS = [
     { source: 'FLOW', target: 'ACTOR', type: 'io', description: 'Flow delivers to actor' },
     { source: 'FUNC', target: 'FLOW', type: 'io', description: 'Function outputs to flow' },
     { source: 'FLOW', target: 'FUNC', type: 'io', description: 'Flow feeds into function' },
-    { source: 'ACTOR', target: 'UC', type: 'io', description: 'Actor triggers use case' },
-    { source: 'FLOW', target: 'UC', type: 'io', description: 'Flow feeds use case' },
-    { source: 'MOD', target: 'MOD', type: 'io', description: 'Module communicates with module (ACL)' },
+    // CR-SM-266 D1: `ACTOR -io-> UC` ENTFAELLT (BREAKING). Der tragende Pfad existiert und ist
+    // typisiert: `ACTOR -io-> FLOW -io-> FUNC`, FUNC in der FCHAIN des UC. Die Direktkante war
+    // die TYPLOSE Abkuerzung daneben — ein Actor-Beitrag ohne FLOW traegt kein SCHEMA und
+    // entzieht sich damit derselben Typgarantie, die fuer jeden anderen Fluss gilt. Migration
+    // je Bestandskante: FLOW einfuehren oder Kante loeschen (70 Kanten ueber 6 Graphen).
+    // CR-SM-266 D2: `MOD -io-> MOD` ENTFAELLT (BREAKING). Modul-Kopplung ist vollstaendig
+    // ABLEITBAR: `FUNC -allocate-> MOD` x `FUNC -io-> FLOW -io-> FUNC` ergibt die
+    // Modul-Ebenen-Projektion. Eine BEHAUPTETE Kopplungskante kann von der tatsaechlichen
+    // driften, eine berechnete nicht — und die behauptete gewann, weil sie billiger war.
+    // Soll-Architektur wird als REQ (non-functional) modelliert, nicht als Kante.
+    // CR-SM-266 D4: `FLOW -io-> UC` ENTFAELLT (BREAKING). Zweitweg neben `FLOW -io-> FUNC` mit
+    // FUNC in der FCHAIN des UC. Die UC-Grenze ERGIBT SICH aus den FLOWs der Kettenglieder; eine
+    // direkte FLOW-UC-Kante umgeht die Kettenzuordnung und damit IO-01 und R-21.
     // ── satisfy (implementation) ──
-    { source: 'FUNC', target: 'REQ', type: 'satisfy', description: 'Function implements requirement' },
+    {
+        source: 'FUNC', target: 'REQ', type: 'satisfy',
+        where: { on: 'target', field: 'kinds', allowed: BEHAVIOURAL_KINDS },
+        description: 'Function implements requirement — behavioural kinds only',
+    },
     // CR-GC-366: `FUNC -satisfy-> UC` ENTFAELLT (BREAKING). Es war ein zweiter, redundanter Weg
     // vom Verhalten zum Use Case neben dem einzig tragenden `UC -compose-> FCHAIN -compose-> FUNC`.
     // Zwei Wege = zwei Wahrheiten: eine FUNC konnte einen UC bedienen, ohne in dessen Wirkkette zu
@@ -29,14 +48,38 @@ export const TRACE_PATTERNS = [
     // stand ohnehin in einer FCHAIN); die restlichen 13 sind der Migrationsanlass, nicht ein
     // Argument fuer das Pattern. Ersatz: die FUNC in die FCHAIN des UC aufnehmen (R-30).
     // CR-154: NFR satisfy — non-functional REQs can be satisfied by chains, modules, or the system
+    //
+    // CR-SM-266 B: die drei strukturellen satisfy-Patterns tragen jetzt ein `where`. Ohne es
+    // konnte ein MOD oder SYS ein FUNKTIONALES REQ erfuellen, ohne dass eine Wirkkette es traegt
+    // — der Zweitweg aus CR-GC-366, eine Ebene hoeher. Die FCHAIN behaelt bewusst ALLE Kinds:
+    // sie IST die Wirkkette, an ihr haengen IO-01 und R-21, sie ist also nie die Abkuerzung.
     { source: 'FCHAIN', target: 'REQ', type: 'satisfy', description: 'Function chain satisfies end-to-end NFR (e.g. latency)' },
-    { source: 'MOD', target: 'REQ', type: 'satisfy', description: 'Module satisfies budget NFR (e.g. uptime, memory)' },
-    { source: 'SYS', target: 'REQ', type: 'satisfy', description: 'System satisfies system-level NFR (e.g. availability)' },
+    {
+        source: 'MOD', target: 'REQ', type: 'satisfy',
+        where: { on: 'target', field: 'kinds', allowed: STRUCTURAL_KINDS },
+        description: 'Module satisfies budget NFR (e.g. uptime, memory) — structural kinds only',
+    },
+    {
+        source: 'SYS', target: 'REQ', type: 'satisfy',
+        where: { on: 'target', field: 'kinds', allowed: STRUCTURAL_KINDS },
+        description: 'System satisfies system-level NFR (e.g. availability) — structural kinds only',
+    },
     // ── verify (INCOSE: test verifies requirement) ──
     { source: 'TEST', target: 'REQ', type: 'verify', description: 'Test verifies requirement' },
     // ── allocate (deployment/assignment) ──
-    { source: 'FUNC', target: 'MOD', type: 'allocate', description: 'Function deployed in module' },
-    { source: 'FLOW', target: 'SCHEMA', type: 'relation', description: 'Flow data format defined by schema' },
+    // CR-SM-266b A/C: OBERGRENZEN als Grammatik. Beide Kanten sind Besitz-Aussagen, und Besitz
+    // ist nicht mehrfach vergebbar — eine FUNC wohnt in EINEM Modul, ein FLOW traegt EINEN
+    // Datenvertrag. Zwei Allokationen sind kein "staerkeres" Modell, sondern eine Frage ohne
+    // Antwort ("in welchem Modul liegt der Code?"), und zwei SCHEMA an einem FLOW heben genau
+    // die Typgarantie auf, fuer die der geteilte SCHEMA-Knoten existiert (CR-SM-266 C): zwei
+    // Vertraege koennen divergieren, einer kann es nicht.
+    //
+    // Nur die OBERE Grenze steht hier, bewusst als `0..1` und nicht `1..1`. Die untere haben
+    // R-22 (FUNC muss alloziert sein) und SC-04 (FLOW hat SCHEMA) laengst — sie hier zu
+    // wiederholen waere die Doppelzaehlung aus Gate 4: eine Ursache, zwei Befunde, ein Nenner
+    // doppelt belastet. Die beiden Haelften ergeben zusammen das `[1..1]` des CR.
+    { source: 'FUNC', target: 'MOD', type: 'allocate', cardinality: '0..1', description: 'Function deployed in exactly one module' },
+    { source: 'FLOW', target: 'SCHEMA', type: 'relation', cardinality: '0..1', description: 'Flow data format defined by exactly one schema' },
     // CR-228: REQ→MOD allocate removed — a MOD does not own a REQ. Physical NFRs use
     // MOD→satisfy→REQ, behavioral NFRs FCHAIN→satisfy→REQ; structural constraints are
     // rules, not REQs. R-18 now flags any REQ→MOD allocate edge as invalid.
@@ -44,24 +87,75 @@ export const TRACE_PATTERNS = [
     { source: 'MS', target: 'FUNC', type: 'compose', description: 'Milestone includes function' },
     { source: 'MS', target: 'REQ', type: 'compose', description: 'Milestone includes requirement' },
     { source: 'MS', target: 'UC', type: 'compose', description: 'Milestone includes use case' },
-    { source: 'MS', target: 'MS', type: 'compose', description: 'Sub-milestone' },
-    { source: 'MS', target: 'MS', type: 'relation', label: 'depends-on', description: 'Milestone dependency' },
+    // CR-SM-266 D3: `MS -compose-> MS` ENTFAELLT (BREAKING). Zwei Kantenarten zwischen denselben
+    // zwei Meilensteinen sagten dasselbe auf zwei Arten — Schachtelung und Abfolge sind an einem
+    // Meilenstein nicht unterscheidbar, MS-01 zaehlte den Scope einmal ueber `CR -relation-> MS`
+    // (seit CR-SM-245 der einzige Weg) und die compose-Kante trug nichts mehr bei. `relation`
+    // bleibt als EINZIGE MS-MS-Kante, Semantik: Ordnung/Abfolge (Vorgaenger → Nachfolger).
+    // Migration: keine — 0 solche Kanten in allen 9 aktiven Familie-Graphen (gemessen 2026-08-25).
+    { source: 'MS', target: 'MS', type: 'relation', label: 'depends-on', description: 'Milestone order: predecessor → successor' },
     { source: 'CR', target: 'MS', type: 'relation', description: 'CR assigned to milestone' },
     // ── CR traceability (CR-155: CR tracks mutated elements) ──
     { source: 'CR', target: 'UC', type: 'relation', description: 'CR affects use case' },
     { source: 'CR', target: 'REQ', type: 'relation', description: 'CR affects requirement' },
     { source: 'CR', target: 'FUNC', type: 'relation', description: 'CR affects function' },
     { source: 'CR', target: 'MOD', type: 'relation', description: 'CR affects module' },
-    // ── produces (audit lineage) ──
-    { source: 'SESSION', target: '*', type: 'produces', category: 'audit', description: 'Session produced/modified element' },
+    // CR-SM-266 D5: `SESSION -produces-> *` ENTFAELLT ersatzlos, mit ihm der TraceType `produces`
+    // und der ElementType `SESSION`. Der urspruengliche Entwurf hielt das Pattern fuer die
+    // Provenance-Kante und wollte es behalten; die MESSUNG hat das widerlegt: 0 produces-Kanten
+    // und 0 SESSION-Knoten in ALLEN 9 aktiven Familie-Graphen, auch im graphcode-Selbstmodell
+    // nach 195 gegateten Versionen. Die reale Provenance lebt seit CR-GC-347 in
+    // `.graphcode/audit.jsonl` — audit_trail/audit_stats lesen die DATEI, nie den Graphen.
+    // Einziger Schreiber war ein toter Pfad (CR-195d in graph-api-core), Leser mit Wirkung: keiner.
+    // Nicht auf `relation` umgebogen: eine Kante ohne Schreiber UND ohne Leser wird gestrichen,
+    // nicht umbenannt.
 ];
+/**
+ * Erfuellt das betroffene Kantenende das Praedikat?
+ *
+ * TEILMENGEN-Semantik, nicht Schnittmenge: JEDER deklarierte Kind muss in der erlaubten Liste
+ * liegen. Die schwaechere Lesart ("mindestens einer passt") waere das Loch, das der ganze
+ * Abschnitt schliessen will — ein funktionales REQ zusaetzlich als `non-functional` zu
+ * deklarieren haette gereicht, damit ein MOD es wieder erfuellen darf, und der billige
+ * Zweitweg waere ueber ein Attribut zurueck.
+ *
+ * Der leere Fall LEHNT AB (`kinds.length === 0`): ohne Deklaration ist nicht entscheidbar, ob
+ * die Kante zulaessig ist, und "unentscheidbar" darf nicht "erlaubt" heissen — sonst wird das
+ * WEGLASSEN des Attributs zum Umgehungsweg. Das ist die durchsetzende Haelfte von REQ-X06
+ * (`kinds` ist Pflicht am REQ); die meldende Haelfte haengt an BQ-07.
+ */
+function satisfiesPredicate(where, trace) {
+    // `normalizeReqKinds` statt direktem Zugriff: drei Familie-Graphen tragen `kinds` als String
+    // statt als Liste, und ein `.every()` darauf WIRFT — mitten im Regellauf, statt einen Befund
+    // zu melden. Die Normalisierung heilt die Drift nicht, sie macht sie nur urteilsfaehig.
+    const kinds = normalizeReqKinds(where.on === 'source' ? trace.sourceKinds : trace.targetKinds);
+    if (kinds.length === 0)
+        return false;
+    return kinds.every(k => where.allowed.includes(k));
+}
+/**
+ * Die Obergrenze eines Kardinalitaets-Ausdrucks — `Infinity`, wo keine gilt.
+ *
+ * Getrennt von `isValidTrace`, weil es eine andere ART von Bedingung ist: `isValidTrace`
+ * urteilt ueber EINE Kante und braucht nur deren Enden, eine Kardinalitaet urteilt ueber die
+ * MENGE der Kanten eines Knotens. Der urspruengliche CR-Entwurf wollte beides in
+ * `isValidTrace` erledigen; das geht nicht, und die Korrektur steht im Impact-Audit.
+ */
+export function maxOccurs(cardinality) {
+    if (cardinality === undefined)
+        return Infinity;
+    return cardinality === '1' || cardinality === '0..1' ? 1 : Infinity;
+}
+/** Die Patterns mit einer echten Obergrenze — die Arbeitsliste des Kardinalitaets-Beins. */
+export const BOUNDED_PATTERNS = TRACE_PATTERNS.filter(p => maxOccurs(p.cardinality) < Infinity);
 /**
  * Check if a trace matches a valid pattern in the meta-model.
- * Uses element types (not IDs) for validation.
+ * Uses element types (not IDs) plus — where a pattern declares one — an attribute predicate.
  */
 export function isValidTrace(trace, patterns = TRACE_PATTERNS) {
     return patterns.some(p => (p.source === '*' || p.source === trace.source) &&
         (p.target === '*' || p.target === trace.target) &&
         p.type === trace.type &&
-        (!p.label || p.label === trace.label));
+        (!p.label || p.label === trace.label) &&
+        (!p.where || satisfiesPredicate(p.where, trace)));
 }

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,20 +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>;
+/**
+ * `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[];
 export declare const AsilLevel: z.ZodEnum<{
     QM: "QM";
     A: "A";
@@ -222,7 +249,6 @@ export declare const OntologyElement: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>;
@@ -245,7 +271,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 +290,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 +300,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,7 +322,6 @@ export declare const OntologyGraph: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>;
@@ -331,7 +344,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 +368,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 +379,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,13 +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',
 ]);
+/**
+ * `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);
+}
 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']);
@@ -175,14 +211,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 +254,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/quality-rules.js

@@ -1,3 +1,4 @@
+import { normalizeReqKinds } from './ontology.js';
 // ---------------------------------------------------------------------------
 // Weasel words list (BQ-01)
 // ---------------------------------------------------------------------------
@@ -162,12 +163,22 @@ export function bq06Conforming(graph) {
 const placeholderPattern = /\b(TBD|TBR|TODO|placeholder|to be determined)\b|needs\s.*review/i;
 const BQ07_MIN_DESC_LENGTH = 20;
 export function bq07Complete(graph) {
+    // CR-SM-266 REQ-X06: `kinds` ist Pflicht am REQ — hier als DRITTER Grund derselben Regel,
+    // bewusst ohne neue Regel-ID (Gate 6 des Grammatik-Reviews: eine ID kostet dauerhaft einen
+    // Nenner-Anteil, eine Katalogzeile, eine readiness-Zuordnung und einen Golden-File-Eintrag).
+    // BQ-07 heisst "Complete" und sammelt bereits mehrere Unvollstaendigkeits-Gruende in EINEN
+    // Befund; ein REQ ohne Klassifikation ist genau das — unvollstaendig, nicht falsch.
+    //
+    // Die DURCHSETZENDE Haelfte liegt woanders: `satisfiesPredicate` (meta-model.ts) lehnt jede
+    // satisfy-Kante auf ein REQ ohne `kinds` ab, weil dort nicht entscheidbar ist, ob sie
+    // zulaessig ist. Das ist die Fehlmessung und deshalb R-18/error; das blosse Fehlen der
+    // Angabe ist ein Vollstaendigkeitssignal und deshalb hier/warning — dieselbe Trennung, die
+    // CR-SM-262 fuer RC-06 begruendet hat.
+    const isIncomplete = (req) => req.description.trim().length < BQ07_MIN_DESC_LENGTH ||
+        placeholderPattern.test(req.description) ||
+        normalizeReqKinds(req.kinds).length === 0;
     return reqElements(graph)
-        .filter(req => {
-        const tooShort = req.description.trim().length < BQ07_MIN_DESC_LENGTH;
-        const hasPlaceholder = placeholderPattern.test(req.description);
-        return tooShort || hasPlaceholder;
-    })
+        .filter(isIncomplete)
         .map(req => {
         const reasons = [];
         if (req.description.trim().length < BQ07_MIN_DESC_LENGTH) {
@@ -176,6 +187,9 @@ export function bq07Complete(graph) {
         if (placeholderPattern.test(req.description)) {
             reasons.push('contains placeholder');
         }
+        if (normalizeReqKinds(req.kinds).length === 0) {
+            reasons.push('no kinds declared');
+        }
         return {
             rule_id: 'BQ-07',
             severity: 'warning',

package/dist/se/readiness.d.ts

@@ -30,9 +30,10 @@ export declare const ReadinessScore: z.ZodObject<{
         cr: "cr";
         ms: "ms";
     }>;
-    score: z.ZodNumber;
+    score: z.ZodNullable<z.ZodNumber>;
     violations: z.ZodNumber;
     applicable: z.ZodNumber;
+    coreApplicable: z.ZodNumber;
     ready: z.ZodBoolean;
 }, z.core.$strip>;
 export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
@@ -57,9 +58,10 @@ export declare const ReadinessReport: z.ZodObject<{
             cr: "cr";
             ms: "ms";
         }>;
-        score: z.ZodNumber;
+        score: z.ZodNullable<z.ZodNumber>;
         violations: z.ZodNumber;
         applicable: z.ZodNumber;
+        coreApplicable: z.ZodNumber;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
     timestamp: z.ZodISODateTime;

package/dist/se/readiness.js

@@ -20,11 +20,33 @@ export const ReadinessDimension = z.enum([
 ]);
 export const ReadinessScore = z.object({
     dimension: ReadinessDimension,
-    score: z.number().min(0).max(1), // 1 - (violations / applicable)
+    /**
+     * `1 - (violations / applicable)` — oder **`null`**, wenn die Dimension nicht messbar ist
+     * (CR-SM-270).
+     *
+     * `null` heisst nie 0 %, so wie schon bei `graph_metrics` (CR-GC-326): "a value that is not
+     * measurable is not zero percent". Der Anlass war die Gegenrichtung — ein Modell ohne einen
+     * einzigen Use Case meldete `uc: 0,997, ready: true`, weil 306 FUNC ueber eine einzige
+     * Fremdtyp-Regel (FC-03) den Nenner fuellten, waehrend die dreizehn Regeln, die wirklich Use
+     * Cases pruefen, nichts zu pruefen hatten und ihr SCHWEIGEN sich als Erfolg las. Der Score
+     * zeigte damit in die falsche Richtung: je mehr importierte FUNCs ein Repo ohne Wozu-Ebene
+     * hat, desto reifer sah seine uc-Readiness aus.
+     */
+    score: z.number().min(0).max(1).nullable(),
     violations: z.number().int(),
     applicable: z.number().int(),
+    /**
+     * CR-SM-270: die Kernmenge der Dimension — die Elemente der Typen, die die MEHRHEIT ihrer
+     * Regeln prueft (uc → UC/FCHAIN/ACTOR, arch → FUNC/MOD). Ist sie 0, ist `score` `null`.
+     *
+     * Sie steht im Bericht, weil sonst niemand das `null` erklaeren kann: `applicable` allein
+     * unterscheidet "nichts zu pruefen" (0) nicht von "nur Fremdtypen" (307). Genau die
+     * Unterscheidung, an der der dokumentierte Ausweg aus CR-SM-237 gescheitert ist.
+     */
+    coreApplicable: z.number().int(),
     // CR-SM-235: `score >= readyThreshold`. Die Schwelle steht bewusst NICHT hier — sie ist
     // Eingabe von `computeReadiness`, und eine Zahl im Kommentar wäre die dritte Meinung dazu.
+    // CR-SM-270: bei `score === null` ist `ready` immer `false` — nicht messbar ist nicht bereit.
     ready: z.boolean(),
 });
 /**

package/dist/se/rules.d.ts

@@ -26,7 +26,6 @@ export declare const ViolationCandidate: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>;
@@ -46,7 +45,6 @@ export declare const ViolationContext: z.ZodObject<{
         TEST: "TEST";
         MOD: "MOD";
         SCHEMA: "SCHEMA";
-        SESSION: "SESSION";
         CR: "CR";
         MS: "MS";
     }>>;
@@ -64,7 +62,6 @@ export declare const ViolationContext: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>;
@@ -79,7 +76,6 @@ export declare const ViolationContext: z.ZodObject<{
             verify: "verify";
             allocate: "allocate";
             relation: "relation";
-            produces: "produces";
         }>;
     }, z.core.$strip>>>;
     parent_module: z.ZodOptional<z.ZodString>;
@@ -108,7 +104,6 @@ export declare const RuleViolation: z.ZodObject<{
             TEST: "TEST";
             MOD: "MOD";
             SCHEMA: "SCHEMA";
-            SESSION: "SESSION";
             CR: "CR";
             MS: "MS";
         }>>;
@@ -126,7 +121,6 @@ export declare const RuleViolation: z.ZodObject<{
                 TEST: "TEST";
                 MOD: "MOD";
                 SCHEMA: "SCHEMA";
-                SESSION: "SESSION";
                 CR: "CR";
                 MS: "MS";
             }>;
@@ -141,7 +135,6 @@ export declare const RuleViolation: z.ZodObject<{
                 verify: "verify";
                 allocate: "allocate";
                 relation: "relation";
-                produces: "produces";
             }>;
         }, z.core.$strip>>>;
         parent_module: z.ZodOptional<z.ZodString>;