@sigloch/se-engine 1.1.0 → 1.3.0

package/dist/fix-templates.js

@@ -69,7 +69,10 @@ function relationToMentioned(types) {
                 continue;
             if (hasTrace(g, el.id, target.id, 'relation'))
                 continue;
-            if (!isValidTrace({ source: el.type, target: target.type, type: 'relation' }))
+            if (!isValidTrace({
+                source: el.type, target: target.type, type: 'relation',
+                sourceKinds: el.kinds, targetKinds: target.kinds,
+            }))
                 continue;
             return {
                 op: 'add-trace',
@@ -109,7 +112,10 @@ function edgeToMentioned(opts) {
             const target = opts.direction === 'out' ? other : el;
             if (hasTrace(g, source.id, target.id, opts.traceType))
                 continue;
-            if (!isValidTrace({ source: source.type, target: target.type, type: opts.traceType }))
+            if (!isValidTrace({
+                source: source.type, target: target.type, type: opts.traceType,
+                sourceKinds: source.kinds, targetKinds: target.kinds,
+            }))
                 continue;
             return {
                 op: 'add-trace',
@@ -150,7 +156,10 @@ export const FIX_TEMPLATES = {
         const ms = mentioned[0] ?? (milestones.length === 1 ? milestones[0] : undefined);
         if (!ms || hasTrace(g, cr.id, ms.id, 'relation'))
             return null;
-        if (!isValidTrace({ source: cr.type, target: ms.type, type: 'relation' }))
+        if (!isValidTrace({
+            source: cr.type, target: ms.type, type: 'relation',
+            sourceKinds: cr.kinds, targetKinds: ms.kinds,
+        }))
             return null;
         return {
             op: 'add-trace',
@@ -162,23 +171,50 @@ export const FIX_TEMPLATES = {
                 : `${ms.id} ist der einzige Milestone im Graphen`,
         };
     },
+    /**
+     * CR-SM-266 D1: der Vorschlag geht an den FLOW, nicht mehr an den UC.
+     *
+     * Die alte Fassung schlug `ACTOR -io-> UC` vor. Mit dem Wegfall des Patterns waere sie
+     * still gestorben — `isValidTrace` haette jeden Kandidaten verworfen, die Schleife immer
+     * `null` geliefert, und UC-02 haette einen Fix-Template-Eintrag OHNE Wirkung behalten: ein
+     * Vorschlagspfad, der nichts mehr vorschlaegt, ist schlimmer als keiner, weil niemand ihn
+     * vermisst.
+     *
+     * Der tragende Pfad ist jetzt `ACTOR -io-> FLOW`, wobei der FLOW ein Kettenglied des UC
+     * speisen muss — sonst ist die Kante zwar gueltig, macht UC-02 aber nicht gruen und der
+     * Vorschlag waere eine Kante ins Leere. Deshalb wird der FLOW nicht geraten, sondern aus
+     * dem Graphen HERGELEITET: die FLOWs, die in eine FUNC einer FCHAIN dieses UC laufen.
+     * Ist keiner da, gibt das Template `null` — der fehlende FLOW ist dann die eigentliche
+     * Luecke und gehoert R-31, nicht einer erfundenen Actor-Kante.
+     */
     'UC-02': (v, g) => {
         const uc = byId(g, v.element_id);
         if (!uc)
             return null;
+        const chainMembers = new Set(g.traces
+            .filter((t) => t.type === 'compose' && t.source === uc.id)
+            .flatMap((chain) => g.traces.filter((t) => t.type === 'compose' && t.source === chain.target).map((t) => t.target)));
+        const feedingFlows = g.traces
+            .filter((t) => t.type === 'io' && chainMembers.has(t.target))
+            .map((t) => byId(g, t.source))
+            .filter((e) => e?.type === 'FLOW');
+        if (feedingFlows.length === 0)
+            return null;
         const actors = mentionedElements(`${uc.name} ${uc.description ?? ''}`, g, ['ACTOR']);
         for (const actor of actors) {
-            if (hasTrace(g, actor.id, uc.id, 'io'))
-                continue;
-            if (!isValidTrace({ source: actor.type, target: uc.type, type: 'io' }))
-                continue;
-            return {
-                op: 'add-trace',
-                source: actor.id,
-                target: uc.id,
-                type: 'io',
-                rationale: `${actor.id} ist im Text von ${uc.id} genannt`,
-            };
+            for (const flow of feedingFlows) {
+                if (hasTrace(g, actor.id, flow.id, 'io'))
+                    continue;
+                if (!isValidTrace({ source: actor.type, target: flow.type, type: 'io' }))
+                    continue;
+                return {
+                    op: 'add-trace',
+                    source: actor.id,
+                    target: flow.id,
+                    type: 'io',
+                    rationale: `${actor.id} ist im Text von ${uc.id} genannt, und ${flow.id} speist dessen Wirkkette`,
+                };
+            }
         }
         return null;
     },

package/dist/readiness-compute.d.ts

@@ -4,7 +4,7 @@
  * Relocated from aimpro (learning-engine/graph/readiness.ts) into @sigloch/se-engine (CR-SM-248).
  */
 import type { OntologyGraph, MetricPolicy } from '@sigloch/contracts/se';
-import { type ReadinessReportType } from '@sigloch/contracts/se';
+import { type ReadinessDimensionType, type ReadinessReportType } from '@sigloch/contracts/se';
 /**
  * Compute readiness report from the current graph state.
  *
@@ -25,3 +25,37 @@ import { type ReadinessReportType } from '@sigloch/contracts/se';
  * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
  */
 export declare function computeReadiness(graph: OntologyGraph, policy: MetricPolicy, readyThreshold: number): ReadinessReportType;
+/**
+ * CR-146 / CR-SM-235: Anzahl anwendbarer Pruefungen je Dimension.
+ *
+ * `applicable = Σ (Elemente der Grundgesamtheit)` ueber die Regeln der Dimension. Die
+ * Grundgesamtheit steht seit CR-SM-235 an der Regel selbst (`ALL_RULE_DEFS[].domain`) —
+ * vorher lag hier eine Handtabelle `RULE_ELEMENT_TYPE`, in der **18 von 71 Regeln** fehlten.
+ * Deren Verstoesse erhoehten den Zaehler, nie den Nenner; auf graph-view-edit waren das 38
+ * von 415 Verstoessen. Jede neue Regel senkte den Score automatisch, bis jemand die zweite
+ * Tabelle nachzog, und kein Test erzwang das.
+ *
+ * Eine Regel mit mehreren Typen (RD-04: FUNC, MOD, SYS) traegt deren Summe bei — dieselben
+ * Elemente, die sie auch pruefen kann.
+ */
+/**
+ * CR-SM-270: die KERNMENGE je Dimension — die Elemente der Typen, um die es der Dimension
+ * wirklich geht.
+ *
+ * Der Anlass, gemessen: `moneyflow` ist ein reiner Code-Import (0 UC, 0 FCHAIN, 0 ACTOR,
+ * 306 FUNC) und meldete `uc: 0,997, ready: true`. Von den 15 uc-Regeln haben dreizehn eine
+ * leere Grundgesamtheit — sie schweigen mangels Gegenstand —, R-17 traegt 1 (SYS) und FC-03
+ * traegt 306 (FUNC). 99,7 % des Nenners kamen also aus EINER Fremdtyp-Regel, und das Schweigen
+ * der dreizehn las sich als Erfolg. Je mehr importierte FUNCs ein Repo ohne Wozu-Ebene hat,
+ * desto besser sah seine uc-Readiness aus — der Score zeigte in die falsche Richtung, und
+ * `dimension_readiness` ist Steuergroesse fuer `graph_next_step`.
+ *
+ * ABGELEITET, nicht deklariert: der Kern sind die Typen, die die MEHRHEIT der Dimensionsregeln
+ * prueft. Eine zweite Tabelle neben `RULE_TO_DIMENSION` waere ein zweiter Speicher derselben
+ * Wahrheit und liefe auseinander, sobald jemand nur eine von beiden pflegt — genau der Defekt,
+ * den CR-SM-235 hier schon einmal beseitigt hat (`RULE_ELEMENT_TYPE`, 18 von 71 Regeln
+ * fehlten). Ein Attribut waere zusaetzlich eine Selbstauskunft (abgelehnt in CR-SM-263).
+ *
+ * Graph-Regeln zaehlen auch hier nicht mit: sie haben keine Gruppe (CR-SM-239).
+ */
+export declare function coreTypesOf(dim: ReadinessDimensionType): string[];

package/dist/readiness-compute.js

@@ -43,7 +43,8 @@ export function computeReadiness(graph, policy, readyThreshold) {
     // Die Verstoesse sind nicht verloren: sie stehen im Regelstrom und auf der Gate-Achse.
     const graphLevelRules = new Set(ALL_RULE_DEFS.filter(d => d.domain.includes('graph')).map(d => d.id));
     // Count elements by type — used for applicable counts AND phase gate checks
-    const els = graph.elements.filter(e => e.type !== 'SESSION');
+    // CR-SM-266 D5: kein SESSION-Ausschluss mehr — den Elementtyp gibt es nicht.
+    const els = graph.elements;
     const countByType = {};
     for (const e of els) {
         countByType[e.type] = (countByType[e.type] ?? 0) + 1;
@@ -59,16 +60,31 @@ export function computeReadiness(graph, policy, readyThreshold) {
             continue;
         violationsByDim.get(dim).push(v);
     }
+    const coreCounts = computeCoreApplicable(countByType);
     const scores = ReadinessDimension.options.map(dim => {
         const violations = violationsByDim.get(dim).length;
         const applicable = applicableCounts[dim];
-        const score = applicable === 0 ? 0.0 : Math.max(0, 1 - violations / applicable);
+        const coreApplicable = coreCounts[dim];
+        // CR-SM-270: der Interpretierbarkeits-Waechter VOR der Rechnung. Ist die Kernmenge leer,
+        // wird nicht gerechnet — `null`, nicht 0,997 und nicht 0,0. Der Nenner selbst bleibt
+        // unangetastet: wo die Kernmenge da ist, zaehlen die Fremdtyp-Beitraege weiter mit.
+        //
+        // Die Reihenfolge ist Absicht: `applicable === 0` behaelt seine 0,0. Der Fall ist mit
+        // demselben Argument angreifbar ("nichts zu pruefen ist nicht 0 %"), aber CR-SM-270
+        // verlangt ihn ausdruecklich UNVERAENDERT, und ein stiller Mitnahmeeffekt waere hier die
+        // schlechtere Wahl als eine eigene Entscheidung dazu. Der Waechter greift also nur im
+        // wirklich neuen Fall: Kernmenge leer, Fremdtyp-Menge gross.
+        const score = applicable === 0 ? 0.0
+            : coreApplicable === 0 ? null
+                : Math.max(0, 1 - violations / applicable);
         return {
             dimension: dim,
-            score: Math.round(score * 1000) / 1000, // 3 decimal precision
+            score: score === null ? null : Math.round(score * 1000) / 1000, // 3 decimal precision
             violations,
             applicable,
-            ready: score >= readyThreshold,
+            coreApplicable,
+            // Nicht messbar ist nicht bereit — nie `true` bei `null`.
+            ready: score !== null && score >= readyThreshold,
         };
     });
     // CR-SM-237: `overallScore` faellt — das ungewichtete Mittel dieser Scores, von keinem
@@ -94,6 +110,51 @@ export function computeReadiness(graph, policy, readyThreshold) {
  * Eine Regel mit mehreren Typen (RD-04: FUNC, MOD, SYS) traegt deren Summe bei — dieselben
  * Elemente, die sie auch pruefen kann.
  */
+/**
+ * CR-SM-270: die KERNMENGE je Dimension — die Elemente der Typen, um die es der Dimension
+ * wirklich geht.
+ *
+ * Der Anlass, gemessen: `moneyflow` ist ein reiner Code-Import (0 UC, 0 FCHAIN, 0 ACTOR,
+ * 306 FUNC) und meldete `uc: 0,997, ready: true`. Von den 15 uc-Regeln haben dreizehn eine
+ * leere Grundgesamtheit — sie schweigen mangels Gegenstand —, R-17 traegt 1 (SYS) und FC-03
+ * traegt 306 (FUNC). 99,7 % des Nenners kamen also aus EINER Fremdtyp-Regel, und das Schweigen
+ * der dreizehn las sich als Erfolg. Je mehr importierte FUNCs ein Repo ohne Wozu-Ebene hat,
+ * desto besser sah seine uc-Readiness aus — der Score zeigte in die falsche Richtung, und
+ * `dimension_readiness` ist Steuergroesse fuer `graph_next_step`.
+ *
+ * ABGELEITET, nicht deklariert: der Kern sind die Typen, die die MEHRHEIT der Dimensionsregeln
+ * prueft. Eine zweite Tabelle neben `RULE_TO_DIMENSION` waere ein zweiter Speicher derselben
+ * Wahrheit und liefe auseinander, sobald jemand nur eine von beiden pflegt — genau der Defekt,
+ * den CR-SM-235 hier schon einmal beseitigt hat (`RULE_ELEMENT_TYPE`, 18 von 71 Regeln
+ * fehlten). Ein Attribut waere zusaetzlich eine Selbstauskunft (abgelehnt in CR-SM-263).
+ *
+ * Graph-Regeln zaehlen auch hier nicht mit: sie haben keine Gruppe (CR-SM-239).
+ */
+export function coreTypesOf(dim) {
+    const defs = ALL_RULE_DEFS.filter(d => RULE_TO_DIMENSION[d.id] === dim && !d.domain.includes('graph'));
+    if (defs.length === 0)
+        return [];
+    const seenIn = {};
+    for (const d of defs) {
+        // Ein Typ zaehlt EINMAL je Regel, auch wenn die Regel mehrere Typen prueft (RD-04).
+        for (const type of new Set(d.domain))
+            seenIn[type] = (seenIn[type] ?? 0) + 1;
+    }
+    const majority = defs.length / 2;
+    const core = Object.keys(seenIn).filter(type => seenIn[type] > majority).sort();
+    // Keine Mehrheit ableitbar (die Regeln verteilen sich gleichmaessig ueber mehrere Typen):
+    // dann ist der Kern ALLES, was die Dimension prueft. Der Waechter greift damit nur noch,
+    // wenn auch `applicable` 0 waere — das Verhalten bleibt exakt wie vor CR-SM-270. Lieber
+    // nicht greifen als am falschen Ort greifen.
+    return core.length > 0 ? core : [...new Set(defs.flatMap(d => d.domain))].sort();
+}
+function computeCoreApplicable(countByType) {
+    const result = {};
+    for (const dim of ReadinessDimension.options) {
+        result[dim] = coreTypesOf(dim).reduce((sum, type) => sum + (countByType[type] ?? 0), 0);
+    }
+    return result;
+}
 function computeApplicable(countByType) {
     const result = {};
     for (const dim of ReadinessDimension.options) {

package/dist/rule-apply.js

@@ -65,6 +65,10 @@ export function applyRule(rule, graph, knownViolations) {
     // elements' stored types (isValidTrace) and (b) links two currently-
     // unconnected nodes, so it genuinely moves the topology.
     const typeById = new Map(graph.elements.map((e) => [e.id, e.type]));
+    // CR-SM-266 B: die where-Patterns lesen die Kinds des Zielknotens mit. Ohne sie wuerde
+    // `isValidTrace` jede satisfy-Kante ablehnen und der Operator griffe stumm auf einen anderen
+    // Kantentyp aus — ein falscher Vorschlag statt keinem.
+    const kindsById = new Map(graph.elements.map((e) => [e.id, e.kinds]));
     const v = violations[0];
     const source = v.element_id;
     const srcType = typeById.get(source);
@@ -94,7 +98,10 @@ export function applyRule(rule, graph, knownViolations) {
                 [source, srcType, partner, tgtType],
                 [partner, tgtType, source, srcType],
             ]) {
-                if (isValidTrace({ source: sType, target: tType, type: tt })) {
+                if (isValidTrace({
+                    source: sType, target: tType, type: tt,
+                    sourceKinds: kindsById.get(s), targetKinds: kindsById.get(t),
+                })) {
                     return { graph: addTrace(graph, s, t, tt), applied: true, op: `+ ${s} -${tt}-> ${t}` };
                 }
             }
@@ -120,7 +127,8 @@ export function markEmptyDelta(graph, measure) {
     });
 }
 /** Trace types the meta-model accepts (ontology TraceType enum). */
-const TRACE_KEYWORDS = ['verify', 'satisfy', 'allocate', 'compose', 'produces', 'io', 'relation'];
+// CR-SM-266 D5: `produces` entfaellt — der TraceType existiert nicht mehr.
+const TRACE_KEYWORDS = ['verify', 'satisfy', 'allocate', 'compose', 'io', 'relation'];
 /**
  * Best-effort trace type from the violation's fix_hint (topology-only — the
  * exact type does not affect `metrics`, but a plausible one keeps the edit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/se-engine",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc",
     "test": "vitest run",
+    "profile:rules": "SE_PROFILE=1 vitest run tests/perf/rule-profile.test.ts",
     "prepublishOnly": "npm run build && npm run test"
   },
   "dependencies": {
@@ -41,9 +42,9 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@sigloch/contracts": ">=5 <7"
+    "@sigloch/contracts": ">=5 <10"
   },
   "devDependencies": {
-    "@sigloch/contracts": "^6.0.0"
+    "@sigloch/contracts": ">=6 <10"
   }
 }