@sigloch/contracts 6.1.0 → 9.1.0

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>;
@@ -186,6 +179,18 @@ export interface RuleDefinition {
      */
     domain: readonly string[];
 }
+/** Find the MOD a FUNC/SCHEMA is allocated to. */
+/**
+ * CR-SM-256: die EINE Definition von "zerlegt". Ein FUNC mit FUNC-Kindern ist ein Rollup
+ * seiner Kinder — ein Blackbox-Block, durch den nichts fliesst und der keine Anforderung
+ * erfuellt, die nicht schon ein Blatt erfuellt. Die Pflichten liegen vollstaendig auf den
+ * Blaettern (so schon R-30 seit CR-SM-249, so R-20 seit CR-210).
+ *
+ * Bewusst EIN Helper statt drei Kopien: eine zweite Definition von "Blatt" waere ein
+ * zweiter Weg zu derselben Aussage, und der billigere gewinnt immer. CR-SM-263 haengt als
+ * vierter Nutzer daran (MT-02, `metric-rules.ts`) — deshalb exportiert.
+ */
+export declare function decomposedFuncs(graph: OntologyGraph): Set<string>;
 export declare const V3_RULES: RuleDefinition[];
 /** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
 export declare function evaluateRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];