@sigloch/se-engine 1.4.1 → 1.5.0

package/dist/fix-templates.d.ts

@@ -118,8 +118,16 @@ export declare const MERGE_SIMILARITY_THRESHOLD = 0.85;
  */
 export declare function contractSimilarity(g: OntologyGraph, a: string, b: string): number;
 /**
- * Konsolidierungs-Kandidaten: FLOW-Paare, die DENSELBEN Datenvertrag tragen
- * (CR-GC-444, Zielbild „graphcode als Regelkreis", FLOWs 62 → 27).
+ * Konsolidierungs-Kandidaten: FLOW-Paare, die DENSELBEN Datenvertrag tragen UND dieselbe
+ * Verbindung sind — gleiche Produzenten, gleiche Konsumenten (CR-GC-444, CR-SM-309).
+ *
+ * CR-SM-309: vorher genuegte der gleiche Vertrag. Seit CR-GC-510 ist „ein FLOW je
+ * Verbindung, n FLOW -> 1 SCHEMA" das Modell, und IO-02 blockt am Gate. Ein Merge zweier
+ * FLOWs mit verschiedenen Produzenten legte zwei Quellen in einen Fluss (IO-02); einer mit
+ * gleichem Produzenten, aber verschiedenen Konsumenten behauptete Verbindungen, die es nicht
+ * gibt. Gemessen an graphcode v261: alle 11 Vorschlaege der alten Fassung verletzten IO-02
+ * und wurden am Gate abgewiesen. Echt verschmelzbar sind nur DUPLIKATE — derselbe Vertrag
+ * auf derselben Verbindung, zweimal modelliert.
  *
  * „Derselbe Vertrag" = `contractSimilarity` (identischer SCHEMA-Knoten oder
  * ND-02-Duplikat) — EINE Definition, keine neue Zahl. Ein FLOW ohne oder mit

package/dist/fix-templates.js

@@ -439,9 +439,35 @@ function coupledMerges(g, drop, keep) {
 function ioDegree(g, id) {
     return g.traces.filter((t) => t.type === 'io' && (t.source === id || t.target === id)).length;
 }
+/** Produzenten- und Konsumentenmenge eines FLOW als Signatur (FUNC/ACTOR-Enden, sortiert). */
+function endpointSignature(g, flowId) {
+    const isEnd = (id) => {
+        const t = byId(g, id)?.type;
+        return t === 'FUNC' || t === 'ACTOR';
+    };
+    const producers = new Set();
+    const consumers = new Set();
+    for (const t of g.traces) {
+        if (t.type !== 'io')
+            continue;
+        if (t.target === flowId && isEnd(t.source))
+            producers.add(t.source);
+        if (t.source === flowId && isEnd(t.target))
+            consumers.add(t.target);
+    }
+    return `${[...producers].sort().join(',')}|${[...consumers].sort().join(',')}`;
+}
 /**
- * Konsolidierungs-Kandidaten: FLOW-Paare, die DENSELBEN Datenvertrag tragen
- * (CR-GC-444, Zielbild „graphcode als Regelkreis", FLOWs 62 → 27).
+ * Konsolidierungs-Kandidaten: FLOW-Paare, die DENSELBEN Datenvertrag tragen UND dieselbe
+ * Verbindung sind — gleiche Produzenten, gleiche Konsumenten (CR-GC-444, CR-SM-309).
+ *
+ * CR-SM-309: vorher genuegte der gleiche Vertrag. Seit CR-GC-510 ist „ein FLOW je
+ * Verbindung, n FLOW -> 1 SCHEMA" das Modell, und IO-02 blockt am Gate. Ein Merge zweier
+ * FLOWs mit verschiedenen Produzenten legte zwei Quellen in einen Fluss (IO-02); einer mit
+ * gleichem Produzenten, aber verschiedenen Konsumenten behauptete Verbindungen, die es nicht
+ * gibt. Gemessen an graphcode v261: alle 11 Vorschlaege der alten Fassung verletzten IO-02
+ * und wurden am Gate abgewiesen. Echt verschmelzbar sind nur DUPLIKATE — derselbe Vertrag
+ * auf derselben Verbindung, zweimal modelliert.
  *
  * „Derselbe Vertrag" = `contractSimilarity` (identischer SCHEMA-Knoten oder
  * ND-02-Duplikat) — EINE Definition, keine neue Zahl. Ein FLOW ohne oder mit
@@ -492,11 +518,18 @@ export function mergeCandidates(g) {
     }
     const edits = [];
     for (const key of [...grouped.keys()].sort()) {
-        const members = grouped.get(key)
+        // CR-SM-309: innerhalb des Vertrags nur FLOWs derselben Verbindung (Endpunkt-Signatur).
+        const byEnds = new Map();
+        for (const f of grouped.get(key)) {
+            const sig = endpointSignature(g, f.id);
+            byEnds.set(sig, [...(byEnds.get(sig) ?? []), f]);
+        }
+        const duplicates = [...byEnds.keys()].sort().map((sig) => byEnds.get(sig)).find((m) => m.length >= 2);
+        if (!duplicates)
+            continue;
+        const members = duplicates
             .slice()
             .sort((a, b) => ioDegree(g, b.id) - ioDegree(g, a.id) || a.id.localeCompare(b.id));
-        if (members.length < 2)
-            continue;
         const [keep, drop] = members;
         const merges = coupledMerges(g, drop, keep);
         if (merges === null)

package/dist/readiness-compute.d.ts

@@ -19,12 +19,12 @@ import { type ReadinessDimensionType, type ReadinessReportType } from '@sigloch/
  * CR-SM-233: `policy` reicht bis zu den Regeln durch und hat keinen Default — sonst urteilte
  * die Readiness mit einer anderen Schwelle als die, die der Host anzeigt.
  *
- * CR-SM-235: `readyThreshold` ebenso. Vorher stand hier `0.7` und im graphcode-Treiber `0.8`
- * (`generate.ts`, Default-Parameter) — zwei Werte fuer dieselbe Frage „ist diese Dimension zu
- * schwach?", und der Konsument konnte nicht wissen, welcher gilt. Den Wert liefert die Config
- * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
+ * CR-SM-310: keine Schwelle mehr. CR-SM-235 hatte `readyThreshold` hereingereicht, damit es nur
+ * EINEN Wert fuer „ist diese Dimension zu schwach?" gibt — das Urteil stand danach trotzdem
+ * zweimal, hier als `ready` und beim Konsumenten (graphcode generate.ts). Messen und Urteilen
+ * sind getrennt: diese Funktion misst, der Konsument urteilt mit seiner Config.
  */
-export declare function computeReadiness(graph: OntologyGraph, policy: MetricPolicy, readyThreshold: number): ReadinessReportType;
+export declare function computeReadiness(graph: OntologyGraph, policy: MetricPolicy): ReadinessReportType;
 /**
  * CR-146 / CR-SM-235: Anzahl anwendbarer Pruefungen je Dimension.
  *

package/dist/readiness-compute.js

@@ -14,12 +14,12 @@ import { ReadinessDimension, RULE_TO_DIMENSION, } from '@sigloch/contracts/se';
  * CR-SM-233: `policy` reicht bis zu den Regeln durch und hat keinen Default — sonst urteilte
  * die Readiness mit einer anderen Schwelle als die, die der Host anzeigt.
  *
- * CR-SM-235: `readyThreshold` ebenso. Vorher stand hier `0.7` und im graphcode-Treiber `0.8`
- * (`generate.ts`, Default-Parameter) — zwei Werte fuer dieselbe Frage „ist diese Dimension zu
- * schwach?", und der Konsument konnte nicht wissen, welcher gilt. Den Wert liefert die Config
- * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
+ * CR-SM-310: keine Schwelle mehr. CR-SM-235 hatte `readyThreshold` hereingereicht, damit es nur
+ * EINEN Wert fuer „ist diese Dimension zu schwach?" gibt — das Urteil stand danach trotzdem
+ * zweimal, hier als `ready` und beim Konsumenten (graphcode generate.ts). Messen und Urteilen
+ * sind getrennt: diese Funktion misst, der Konsument urteilt mit seiner Config.
  */
-export function computeReadiness(graph, policy, readyThreshold) {
+export function computeReadiness(graph, policy) {
     const allViolations = evaluateAllRules(graph, policy);
     // Group violations by dimension
     const violationsByDim = new Map();
@@ -83,8 +83,6 @@ export function computeReadiness(graph, policy, readyThreshold) {
             violations,
             applicable,
             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
@@ -140,13 +138,25 @@ export function coreTypesOf(dim) {
         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();
+    // CR-SM-328: die RELATIVE Mehrheit mit eindeutigem Sieger, nicht die absolute.
+    //
+    // Die absolute Mehrheit (> n/2) haengt an einer Zahl, die mit dem KATALOG waechst und mit
+    // dem Gegenstand der Dimension nichts zu tun hat. Gemessen an `ver`: sieben Regeln mit TEST
+    // in vier ergaben 4 > 3,5 und den Kern [TEST]; nach CR-SM-319 (R-32, domain SCHEMA) waren es
+    // acht Regeln mit TEST in vier, also 4 > 4 = falsch — der Fallback machte ALLES zum Kern und
+    // legte den Waechter dieser Dimension still, ohne dass sich an `ver` selbst etwas geaendert
+    // haette. Eine einzige neue Regel mit fremder Grundgesamtheit genuegte.
+    //
+    // Die relative Mehrheit beantwortet dieselbe Frage stabil: welcher Typ wird von den MEISTEN
+    // Regeln dieser Dimension geprueft. Sie ist eine Abschwaechung, keine Umkehr — eine absolute
+    // Mehrheit IST immer das eindeutige Maximum, das Ergebnis kann sich also nur dort aendern,
+    // wo vorher der Fallback stand.
+    const top = Math.max(...Object.values(seenIn));
+    const core = Object.keys(seenIn).filter(type => seenIn[type] === top).sort();
+    // Gleichstand an der Spitze: kein Typ ist DER Gegenstand, also ist der Kern ALLES, was die
+    // Dimension prueft. Der Waechter greift dann nur noch, wenn auch `applicable` 0 waere —
+    // Verhalten wie vor CR-SM-270. Lieber nicht greifen als am falschen Ort greifen.
+    return core.length === 1 ? core : [...new Set(defs.flatMap(d => d.domain))].sort();
 }
 function computeCoreApplicable(countByType) {
     const result = {};

package/dist/rule-classify.js

@@ -53,6 +53,9 @@ export const MT_IRRELEVANT_POLICY = {
 export const CLASS_MAP = {
     // --- Operators: fix adds a trace/element (topology-changing) ---------------
     'R-01': { class: 'Operator', rationale: 'add verify trace REQ←TEST' },
+    // CR-SM-328 (nachgezogen aus CR-SM-319): derselbe Fix wie R-01, nur am SCHEMA —
+    // eine `verify`-Kante kommt hinzu, die Topologie bewegt sich.
+    'R-32': { class: 'Operator', rationale: 'add verify trace SCHEMA←TEST — the contract test is missing, not mis-shaped' },
     'R-02': { class: 'Operator', rationale: 'add satisfy trace FUNC→REQ' },
     'R-05': { class: 'Operator', rationale: 'add verify trace TEST→REQ' },
     'R-10': { class: 'Operator', rationale: 'add io traces to complete the FLOW' },
@@ -73,6 +76,10 @@ export const CLASS_MAP = {
     'FC-02': { class: 'Operator', rationale: 'add FCHAIN via compose trace to leaf UC' },
     'SC-02': { class: 'Operator', rationale: 'link FLOW→SCHEMA via relation trace' },
     'IO-01': { class: 'Operator', rationale: 'add FLOW element + io traces between the FUNC pair' },
+    // CR-SM-309: IO-02 (contracts 20) — die Reparatur ist ein Auftrennen je Verbindung. Welcher
+    // Produzent welche Konsumenten behaelt, steht in keinem Feld, sondern im Code; ein Operator
+    // daraus waere geraten (Praezedenz RC-*, CR-SM-305).
+    'IO-02': { class: 'Constraint', rationale: 'one producer per FLOW — the split per connection needs code evidence, no deterministic operator' },
     // CR-GC-366: beide Fixes fuegen eine Trace hinzu, also Operator wie R-15 (compose) und R-10 (io).
     'R-30': { class: 'Operator', rationale: 'add compose trace FCHAIN→FUNC to bind the function into a chain' },
     'R-31': { class: 'Operator', rationale: 'add io traces FLOW→FUNC / FUNC→FLOW to wire the function up' },
@@ -81,7 +88,7 @@ export const CLASS_MAP = {
     'FM-02': { class: 'Operator', rationale: 'create mitigation REQ + compose trace' },
     'FM-03': { class: 'Operator', rationale: 'add TEST(passed) + verify trace to risk REQ' },
     // --- Constraints: remove/repair/reduce, or attribute/text-only -------------
-    'R-04': { class: 'Constraint', rationale: 'module too large — split, non-additive' },
+    'R-04': { class: 'Constraint', rationale: 'module boundary too wide — merge contracts or move functions, non-additive' },
     'R-08': { class: 'Constraint', rationale: 'repair dangling trace endpoint' },
     'R-12': { class: 'Constraint', rationale: 'break dependency cycle — remove an edge' },
     'R-18': { class: 'Constraint', rationale: 'invalid trace pattern — change/remove trace' },
@@ -95,11 +102,15 @@ export const CLASS_MAP = {
     'RD-02': { class: 'Constraint', rationale: 'decomposition consistency — repair existing' },
     'RD-03': { class: 'Constraint', rationale: 'premature decomposition — remove children' },
     'RD-04': { class: 'Constraint', rationale: 'decomposition breadth 7±2 — split level, non-additive' },
+    'RD-05': { class: 'Constraint', rationale: 'degenerate level (< min children) — dissolve into parent, non-additive' },
     'MS-02': { class: 'Constraint', rationale: 'dangling dependency — fix relation target' },
     'UC-04': { class: 'Constraint', rationale: 'goal = description text — no topology change' },
     'FC-03': { class: 'Constraint', rationale: 'flatten chain — move nested funcs' },
     'MT-01': { class: 'Constraint', rationale: 'instability threshold — restructure' },
     'MT-02': { class: 'Constraint', rationale: 'cohesion (LCOM4) threshold — restructure' },
+    // CR-SM-327: wie MT-02 — der Fix zerlegt oder verdrahtet um, er fuegt keine einzelne
+    // Kante hinzu, die der Operator raten koennte.
+    'MT-04': { class: 'Constraint', rationale: 'split the whitebox or wire its groups — a restructuring, not one additive trace' },
     'BQ-01': { class: 'Constraint', rationale: 'unambiguous — text quality' },
     'BQ-02': { class: 'Constraint', rationale: 'verifiable — text quality' },
     'BQ-04': { class: 'Constraint', rationale: 'necessary — text/scope quality' },
@@ -141,6 +152,7 @@ export const CLASS_MAP = {
     'RC-04': { class: 'Constraint', rationale: 'SCHEMA wird an seiner Schnittstelle nicht geparst — Codeänderung' },
     'RC-05': { class: 'Constraint', rationale: 'Import quert eine undokumentierte Modulgrenze — Import entfernen oder Fluss modellieren', ambiguous: true },
     'RC-06': { class: 'Constraint', rationale: 'externe Bindung nennt ein nicht deklariertes Paket — dependency oder realRef' },
+    'RC-07': { class: 'Constraint', rationale: 'CR-Knoten widerspricht docs/cr — Status angleichen oder Knoten anlegen, das Verzeichnis entscheidet' },
 };
 const UNKNOWN = { class: 'Constraint', rationale: 'unclassified — not in CLASS_MAP', ambiguous: true };
 /** Classify a single rule id (falls back to ambiguous-unknown). */

package/dist/steer.d.ts

@@ -47,10 +47,11 @@
  *     weiter zählt, was fehlt. Die beiden sind komplementär: readiness misst ABDECKUNG (wie
  *     viele Stellen sind erledigt), dieser Score AUSPRÄGUNG (wie schlimm ist die schlimmste
  *     offene). Beide lesen denselben Regelstrom.
- *  3. Die MOD-Whitebox hat keine eigene Randbreiten-Regel — R-04 sieht den Rand nur zusammen mit
- *     der Grösse, also ist ein kleines Modul mit breitem Rand stumm (gemessen:
- *     `MOD-kernel-measure` 10 Verträge, `mod_api_server_ts` 17). Der Score erbt den blinden
- *     Fleck; ihn zu schliessen ist ein eigener Grammatik-Vorgang.
+ *  3. ~~Die MOD-Whitebox hat keine eigene Randbreiten-Regel.~~ GESCHLOSSEN mit CR-SM-312: R-04
+ *     misst jetzt allein den Modulrand, gegen dieselbe Schwelle wie BW-02, und steht unten in
+ *     `STEER_RULES`. Vorher sah R-04 den Rand nur zusammen mit der Grösse, also war ein kleines
+ *     Modul mit breitem Rand stumm (gemessen: `MOD-kernel-measure` 9 Verträge bei 7 Funktionen,
+ *     `mod_api_server_ts` 17). Die Grösse ist seit CR-SM-311 RD-04s Frage.
  */
 import type { RuleViolation } from '@sigloch/contracts/se';
 /**
@@ -61,7 +62,7 @@ import type { RuleViolation } from '@sigloch/contracts/se';
  * Bewusst eine geschlossene Liste und NICHT aus `context.value !== undefined` abgeleitet: eine
  * künftige Regel, die zufällig eine Zahl mitführt, würde sonst still zum Steuersignal.
  */
-export declare const STEER_RULES: readonly ["RD-04", "BW-02", "CR-01", "MT-02"];
+export declare const STEER_RULES: readonly ["RD-04", "BW-02", "R-04", "CR-01", "MT-02"];
 /** Der Ausgleichsterm. Klein genug, dass er ein echtes Maximum nie überstimmt. */
 export declare const EPS_AUGMENT = 0.001;
 export interface SteerScore {

package/dist/steer.js

@@ -26,7 +26,7 @@
  * 305 Abhaengigkeiten (11 %), 132 von 146 Modulen bei null, Schwanz bis 6. Lokal, gerichtet,
  * budgetierbar, nicht entartet: drei von drei.
  */
-export const STEER_RULES = ['RD-04', 'BW-02', 'CR-01', 'MT-02'];
+export const STEER_RULES = ['RD-04', 'BW-02', 'R-04', 'CR-01', 'MT-02'];
 /** Der Ausgleichsterm. Klein genug, dass er ein echtes Maximum nie überstimmt. */
 export const EPS_AUGMENT = 1e-3;
 const NEUTRAL = { worst: 0, worstAt: null, mean: 0, score: 0, measured: 0 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/se-engine",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",