@sigloch/se-engine 1.4.1 → 1.6.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-apply.js

@@ -18,7 +18,7 @@
  * Edit; Vorschläge laufen durchs Gate (nie auto-apply).
  */
 import { evaluateAllRules, isValidTrace } from '@sigloch/contracts/se';
-import { classOf, MT_IRRELEVANT_POLICY } from './rule-classify.js';
+import { classOf, classOfViolation, MT_IRRELEVANT_POLICY } from './rule-classify.js';
 /** Deterministic timestamp for synthesized traces (no Date.now — keeps metrics stable). */
 const APPLY_TS = '2026-07-26T00:00:00.000Z';
 /**
@@ -52,19 +52,25 @@ function addTrace(graph, source, target, type) {
  * @returns graph' + whether an edit was applied. Deterministic.
  */
 export function applyRule(rule, graph, knownViolations) {
-    const cls = classOf(rule.id);
     const allViolations = knownViolations ?? evaluateAllRules(graph, MT_IRRELEVANT_POLICY);
-    const violations = allViolations.filter((v) => v.rule_id === rule.id);
-    if (violations.length === 0) {
+    const typeById = new Map(graph.elements.map((e) => [e.id, e.type]));
+    const forRule = allViolations.filter((v) => v.rule_id === rule.id);
+    if (forRule.length === 0) {
         return { graph, applied: false, reason: 'rule does not fire on this graph (empty Δm)' };
     }
-    if (cls.class !== 'Operator') {
+    // CR-SM-334: die Klasse haengt bei R-21 am Ankerknoten des BEFUNDS, nicht nur an der Regel —
+    // ein Befund am Sender-FUNC (Zweig 3, keine gemeinsame Kette) ist kein Operator, auch wenn
+    // die Regel als Ganzes einer ist. Sonst schlaegt der Optimizer einen Test vor, wo die
+    // Modellierung fehlt.
+    const violations = forRule.filter((v) => classOfViolation(rule.id, typeById.get(v.element_id)).class === 'Operator');
+    if (violations.length === 0) {
+        const cls = classOfViolation(rule.id, typeById.get(forRule[0].element_id));
         return { graph, applied: false, reason: `class=${cls.class}: not a transforming operator` };
     }
     // Find a single additive edge that (a) is meta-model valid for the two
     // 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]));
+    // (`typeById` steht seit CR-SM-334 weiter oben — die Klassifikation je Befund braucht es.)
     // 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.

package/dist/rule-classify.d.ts

@@ -21,6 +21,33 @@ export interface Classification {
 export declare const CLASS_MAP: Record<string, Classification>;
 /** Classify a single rule id (falls back to ambiguous-unknown). */
 export declare function classOf(ruleId: string): Classification;
+/**
+ * CR-SM-334 (ITEM-2026-095) — die Klasse einer Regel, die MEHRERE Fragen stellt, haengt am
+ * ANKERKNOTEN des Befunds, nicht nur an der Regel-ID.
+ *
+ * Bisher einziger Fall: R-21 seit seiner scharfen Fassung (CR-SM-313). Die Regel hat drei
+ * Zweige, und ihre `domain` waechst genau deshalb auf ['FCHAIN','FUNC']:
+ *   1. ein Ende in GAR KEINER Kette -> still, das ist R-30s Aussage
+ *   2. gemeinsame Kette, aber keine geprueft -> Befund an der KETTE (FCHAIN)
+ *   3. beide in Ketten, aber KEINE gemeinsame -> Befund am SENDER (FUNC)
+ *
+ * Zweig 2 ist ein Operator: es fehlt ein Integrationstest, der Fix fuegt TEST + verify hinzu.
+ * Zweig 3 ist etwas anderes, und der Unterschied ist teuer. Dort fehlt kein Test, sondern die
+ * gemeinsame KETTE — zwei Funktionen reichen einander etwas, ohne dass das Modell sagt, in
+ * welchem Ablauf das passiert. Ein Operator, der hier einen Test vorschlaegt, erzeugt
+ * Testarbeit an einer Stelle, an der Modellierungsarbeit fehlt: der Test wuerde eine
+ * Uebergabe belegen, die im Modell gar nicht vorgesehen ist.
+ *
+ * ENTSCHEIDUNG ZUR KLASSE (Kriterium 3 des CR): Zweig 3 ist **Constraint, ambiguous**. Der
+ * Fix waere zwar additiv (compose-Kanten), aber WELCHE Kette die beiden teilen sollen —
+ * die des Senders verlaengern, die des Empfaengers, oder eine neue aufmachen — steht in
+ * keinem Feld; das ist Modellierungsabsicht. Ein Operator daraus waere geraten, nicht
+ * abgeleitet, und wuerde falsche compose-Kanten erzeugen. Praezedenz: IO-02 ("welcher
+ * Produzent welche Konsumenten behaelt, steht in keinem Feld") und die sechs RC-Regeln
+ * (CR-SM-305). `applyRule`/`suggestEdits` verwerfen Nicht-Operatoren — Zweig 3 bleibt damit
+ * Befund und Steuersignal, was er ist.
+ */
+export declare function classOfViolation(ruleId: string, elementType?: string): Classification;
 export interface ClassifiedRule {
     id: string;
     name: string;

package/dist/rule-classify.js

@@ -53,13 +53,20 @@ 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' },
     'R-15': { class: 'Operator', rationale: 'add compose trace FCHAIN→FUNC' },
     'R-16': { class: 'Operator', rationale: 'add io trace ACTOR→UC/FLOW' },
     'R-17': { class: 'Operator', rationale: 'add compose trace SYS→child' },
-    'R-21': { class: 'Operator', rationale: 'add integration TEST + verify for FUNC↔FUNC link' },
+    // CR-SM-334 (ITEM-2026-095, zugesagt in CR-SM-313): dieser Eintrag gilt fuer ZWEIG 2 —
+    // Befund an der KETTE, beide Enden teilen eine Kette, nur geprueft ist sie nicht. Zweig 3
+    // (Befund am SENDER-FUNC) verlangt einen anderen Fix und wird in `classOfViolation`
+    // unterschieden; die Klasse allein kann das nicht tragen, denn sie haengt am Ankerknoten.
+    'R-21': { class: 'Operator', rationale: 'chain has no integration TEST — add TEST + verify for the shared chain' },
     'R-22': { class: 'Operator', rationale: 'add allocate trace FUNC→MOD' },
     'R-23': { class: 'Operator', rationale: 'add allocate trace MOD←FUNC' },
     'RD-01': { class: 'Operator', rationale: 'resolve REQ by adding satisfy/decompose trace' },
@@ -73,6 +80,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 +92,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 +106,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,12 +156,50 @@ 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). */
 export function classOf(ruleId) {
     return CLASS_MAP[ruleId] ?? UNKNOWN;
 }
+/**
+ * CR-SM-334 (ITEM-2026-095) — die Klasse einer Regel, die MEHRERE Fragen stellt, haengt am
+ * ANKERKNOTEN des Befunds, nicht nur an der Regel-ID.
+ *
+ * Bisher einziger Fall: R-21 seit seiner scharfen Fassung (CR-SM-313). Die Regel hat drei
+ * Zweige, und ihre `domain` waechst genau deshalb auf ['FCHAIN','FUNC']:
+ *   1. ein Ende in GAR KEINER Kette -> still, das ist R-30s Aussage
+ *   2. gemeinsame Kette, aber keine geprueft -> Befund an der KETTE (FCHAIN)
+ *   3. beide in Ketten, aber KEINE gemeinsame -> Befund am SENDER (FUNC)
+ *
+ * Zweig 2 ist ein Operator: es fehlt ein Integrationstest, der Fix fuegt TEST + verify hinzu.
+ * Zweig 3 ist etwas anderes, und der Unterschied ist teuer. Dort fehlt kein Test, sondern die
+ * gemeinsame KETTE — zwei Funktionen reichen einander etwas, ohne dass das Modell sagt, in
+ * welchem Ablauf das passiert. Ein Operator, der hier einen Test vorschlaegt, erzeugt
+ * Testarbeit an einer Stelle, an der Modellierungsarbeit fehlt: der Test wuerde eine
+ * Uebergabe belegen, die im Modell gar nicht vorgesehen ist.
+ *
+ * ENTSCHEIDUNG ZUR KLASSE (Kriterium 3 des CR): Zweig 3 ist **Constraint, ambiguous**. Der
+ * Fix waere zwar additiv (compose-Kanten), aber WELCHE Kette die beiden teilen sollen —
+ * die des Senders verlaengern, die des Empfaengers, oder eine neue aufmachen — steht in
+ * keinem Feld; das ist Modellierungsabsicht. Ein Operator daraus waere geraten, nicht
+ * abgeleitet, und wuerde falsche compose-Kanten erzeugen. Praezedenz: IO-02 ("welcher
+ * Produzent welche Konsumenten behaelt, steht in keinem Feld") und die sechs RC-Regeln
+ * (CR-SM-305). `applyRule`/`suggestEdits` verwerfen Nicht-Operatoren — Zweig 3 bleibt damit
+ * Befund und Steuersignal, was er ist.
+ */
+export function classOfViolation(ruleId, elementType) {
+    if (ruleId === 'R-21' && elementType === 'FUNC') {
+        return {
+            class: 'Constraint',
+            rationale: 'handover without a shared chain — model the common FCHAIN; which chain the two '
+                + 'functions should share is modelling intent, not derivable, so no operator',
+            ambiguous: true,
+        };
+    }
+    return classOf(ruleId);
+}
 /** Classify the entire live rule catalog (ALL_RULE_DEFS). */
 export function classifyAll() {
     return ALL_RULE_DEFS.map((r) => {

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 {
@@ -79,6 +80,34 @@ export interface SteerScore {
     /** Zahl der Blackboxes, die in die Rechnung eingegangen sind. */
     measured: number;
 }
+/**
+ * CR-SM-337 (ITEM-2026-059): ein TERM je gemessener Blackbox — die Zwischenrechnung, aus der
+ * `worst` und `mean` entstehen.
+ *
+ * Bis hierher gab `steerScore` nur das Ergebnis heraus. Wer die Terme brauchte — der Host, um
+ * den Steuerungsraum zu exportieren, das GVE-Dashboard, um ihn zu zeigen — musste sie selbst
+ * aus dem Regelstrom ableiten, also die Normierung ein zweites Mal schreiben. Eine zweite
+ * Rechnung ist eine zweite Wahrheit; hier ist sie vermeidbar, weil die Zwischenschritte schon
+ * existierten und nur nicht herausgereicht wurden.
+ *
+ * Die Form spiegelt `SteerTerm` in @sigloch/contracts (`se/readiness.ts`) — dort der Vertrag,
+ * hier die Rechnung.
+ */
+export interface SteerTerm {
+    ruleId: string;
+    elementId: string;
+    value: number;
+    threshold: number;
+    /** `max(0, (value − threshold) / threshold)`, dimensionslos. */
+    overshoot: number;
+}
+/**
+ * Die Terme des Steuerungsraums, in kanonischer Befund-Reihenfolge (CR-SM-240). Rein.
+ *
+ * DIE Quelle für alles Weitere: `steerScore` rechnet daraus, der Host exportiert sie
+ * unverändert. Es gibt genau eine Normierung und genau eine Regel-Liste.
+ */
+export declare function steerTerms(violations: readonly RuleViolation[]): SteerTerm[];
 /** Der Chebyshev-Score eines Zustands, aus seinem Regelstrom. Rein. */
 export declare function steerScore(violations: readonly RuleViolation[]): SteerScore;
 /** Ein Kandidat, so weit der Ranker ihn kennen muss. */

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 };
@@ -37,39 +37,56 @@ const NEUTRAL = { worst: 0, worstAt: null, mean: 0, score: 0, measured: 0 };
  * ist nicht „keine Überschreitung". Dieselbe Konvention wie `policy.X = null` und
  * `moduleMetrics.instability = null`.
  */
-function overshootOf(v) {
+function termOf(v) {
     const value = v.context?.value;
     const budget = v.context?.threshold;
     if (typeof value !== 'number' || typeof budget !== 'number' || budget <= 0)
         return null;
-    return Math.max(0, (value - budget) / budget);
+    return {
+        ruleId: v.rule_id,
+        elementId: v.element_id,
+        value,
+        threshold: budget,
+        overshoot: Math.max(0, (value - budget) / budget),
+    };
+}
+/**
+ * Die Terme des Steuerungsraums, in kanonischer Befund-Reihenfolge (CR-SM-240). Rein.
+ *
+ * DIE Quelle für alles Weitere: `steerScore` rechnet daraus, der Host exportiert sie
+ * unverändert. Es gibt genau eine Normierung und genau eine Regel-Liste.
+ */
+export function steerTerms(violations) {
+    const rules = STEER_RULES;
+    const terms = [];
+    for (const v of violations) {
+        if (!rules.includes(v.rule_id))
+            continue;
+        const t = termOf(v);
+        if (t !== null)
+            terms.push(t);
+    }
+    return terms;
 }
 /** Der Chebyshev-Score eines Zustands, aus seinem Regelstrom. Rein. */
 export function steerScore(violations) {
-    const rules = STEER_RULES;
+    const terms = steerTerms(violations);
+    if (terms.length === 0)
+        return NEUTRAL;
     let worst = 0;
     let worstAt = null;
     let sum = 0;
-    let measured = 0;
-    for (const v of violations) {
-        if (!rules.includes(v.rule_id))
-            continue;
-        const d = overshootOf(v);
-        if (d === null)
-            continue;
-        measured += 1;
-        sum += d;
+    for (const t of terms) {
+        sum += t.overshoot;
         // `>` statt `>=`: bei Gleichstand gewinnt der zuerst gesehene, und die Befund-Sequenz ist
         // seit CR-SM-240 kanonisch — damit ist `worstAt` deterministisch.
-        if (d > worst) {
-            worst = d;
-            worstAt = { ruleId: v.rule_id, elementId: v.element_id };
+        if (t.overshoot > worst) {
+            worst = t.overshoot;
+            worstAt = { ruleId: t.ruleId, elementId: t.elementId };
         }
     }
-    if (measured === 0)
-        return NEUTRAL;
-    const mean = sum / measured;
-    return { worst, worstAt, mean, score: worst + EPS_AUGMENT * mean, measured };
+    const mean = sum / terms.length;
+    return { worst, worstAt, mean, score: worst + EPS_AUGMENT * mean, measured: terms.length };
 }
 /**
  * Vergleicht zwei Kandidaten. `< 0` heisst **a ist besser**; direkt sortierbar.

package/dist/suggest.js

@@ -19,7 +19,7 @@ import { evaluateAllRules } from '@sigloch/contracts/se';
 import { metrics, toArray } from './metrics.js';
 import { steerScore, beatsBySteer } from './steer.js';
 import { applyRule } from './rule-apply.js';
-import { classOf, MT_IRRELEVANT_POLICY } from './rule-classify.js';
+import { classOfViolation, MT_IRRELEVANT_POLICY } from './rule-classify.js';
 import { fixFor, mergeCandidates, applyMergeEdit, MERGE_OPERATOR_ID } from './fix-templates.js';
 /**
  * Rankt die feuernden Operator-Regeln danach, wie weit ihr Sonden-Edit den **Chebyshev-Score**
@@ -43,9 +43,14 @@ export function suggestEdits(graph, opts = {}) {
     for (const v of violations)
         if (!firstByRule.has(v.rule_id))
             firstByRule.set(v.rule_id, v);
+    // CR-SM-334: die Klasse haengt bei R-21 am Ankerknoten des Befunds. Ohne den Typ schlaegt
+    // der Vorschlag fuer Zweig 3 (Uebergabe ohne gemeinsame Kette) einen Integrationstest vor,
+    // wo die gemeinsame Kette fehlt — Testarbeit statt Modellierungsarbeit.
+    const typeOfElement = new Map(graph.elements.map((e) => [e.id, e.type]));
+    const classOfFinding = (ruleId, elementId) => classOfViolation(ruleId, typeOfElement.get(elementId));
     const suggestions = [];
     for (const [ruleId, v] of firstByRule) {
-        if (classOf(ruleId).class !== 'Operator')
+        if (classOfFinding(ruleId, v.element_id).class !== 'Operator')
             continue;
         const probe = applyRule({ id: ruleId }, graph, violations);
         if (!probe.applied)
@@ -77,7 +82,7 @@ export function suggestEdits(graph, opts = {}) {
     // ohnehin nicht anwendbar — vor diesem Block fiel der Fund deshalb ganz heraus, mitsamt
     // dem vertragsbauenden Arm des Aktionsraums (CR-GC-430: COHESIVE 5 -> 2 Schritte).
     for (const [ruleId, v] of firstByRule) {
-        if (classOf(ruleId).class === 'Operator')
+        if (classOfFinding(ruleId, v.element_id).class === 'Operator')
             continue;
         const edit = fixFor(v, graph);
         if (!edit || edit.op !== 'add-trace')

package/package.json

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