@sigloch/se-engine 1.3.0 → 1.4.1

package/dist/fix-templates.d.ts

@@ -1,11 +1,63 @@
 import type { OntologyGraph, RuleViolation, TraceType, ElementType } from '@sigloch/contracts/se';
 export interface SuggestedEdit {
-    op: 'add-trace';
+    /**
+     * `'add-trace'` — die Kante `source -type-> target` wird angehängt (ggf. mit
+     * `retire`, s. u.).
+     *
+     * `'merge-nodes'` — CR-GC-444, der Konsolidierungs-Operator: `target`
+     * ABSORBIERT `source` (Semantik des gleichnamigen `MutateCommand`), `source`
+     * verschwindet. `type` benennt dann die Trace, über die die Kopplung läuft
+     * (heute `relation`, der Vertrag `FLOW -relation-> SCHEMA`); die gekoppelten
+     * Zusatz-Merges stehen in `merges`.
+     */
+    op: 'add-trace' | 'merge-nodes';
     source: string;
     target: string;
     type: TraceType;
     /** Warum genau dieses Ziel — Fundstelle im Elementtext bzw. Eindeutigkeit. */
     rationale: string;
+    /**
+     * CR-GC-435 — die EINE Kante, die weichen muss, damit der Edit die
+     * Kardinalitäts-Obergrenze des Meta-Modells (R-18, zweites Bein) einhält.
+     * Fehlt = reines Anhängen. Anwendung IMMER als EIN Batch
+     * [delete(retire), add(edit)] durchs Gate — nacheinander wäre der
+     * Zwischenzustand je nach Reihenfolge illegal oder unternormiert.
+     */
+    retire?: {
+        source: string;
+        target: string;
+        type: TraceType;
+        rationale: string;
+    };
+    /**
+     * CR-GC-435 — gesetzt NUR beim Umhängen (retire) einer realisierten Quelle
+     * (realRef/codeRef): die Allokation speist den Datei→Modul-Resolver
+     * (buildModResolver, RC-05/importCoverage) — der Graph-Edit zieht dann
+     * Code-Arbeit nach sich. Ohne Realisierung fehlt das Feld (kein Rauschen).
+     */
+    codeImpact?: {
+        file: string;
+        targetModule: string;
+    };
+    /**
+     * CR-GC-444 — die GEKOPPELTEN Knoten-Merges, die zusammen mit dem primären
+     * Merge (`source` → `target`) in EINEM Batch laufen MÜSSEN, damit der
+     * Endzustand die Kardinalitäts-Obergrenzen des Meta-Modells einhält.
+     *
+     * Die Kopplung ist keine Konvention, sondern Gate-Realität: `FLOW -relation->
+     * SCHEMA` ist `1..1` (contracts 10.0.0, drittes R-18-Bein). Werden zwei FLOWs
+     * zusammengelegt, trägt der überlebende FLOW zwei SCHEMAs — und wird
+     * abgewiesen, solange der SCHEMA-Merge nicht im selben Batch steht (in
+     * CR-GC-438 Kill 2 gemessen: 5 FLOWs mit > 1 SCHEMA, Zug tot).
+     *
+     * Reihenfolge: primärer Merge zuerst, dann diese Liste. Fehlt das Feld, ist
+     * keine Kopplung nötig (die Zusammengelegten teilen den Vertrag bereits).
+     */
+    merges?: {
+        source: string;
+        target: string;
+        rationale: string;
+    }[];
 }
 type Element = OntologyGraph['elements'][number];
 type FixTemplate = (v: RuleViolation, g: OntologyGraph) => SuggestedEdit | null;
@@ -21,4 +73,68 @@ export declare const FIX_TEMPLATES: Record<string, FixTemplate>;
  * Deterministisch; nie der generische applyRule-Trace.
  */
 export declare function fixFor(v: RuleViolation, g: OntologyGraph): SuggestedEdit | null;
+/**
+ * Die Kennung der Konsolidierungs-Vorschläge im `Suggestion.ruleId`-Feld.
+ *
+ * AUSDRÜCKLICH KEINE contracts-Regel-ID. Der Operator hängt an keiner Violation,
+ * weil ein Merge keine Regel repariert — er bewegt die Metrik (Vertrags-
+ * konzentration, in CR-GC-438 als dieselbe Größe wie `flowEfficiency` gemessen,
+ * r = 0,89). Ein Fund wäre erfunden; die Kennung sagt stattdessen, woher der
+ * Vorschlag kommt.
+ */
+export declare const MERGE_OPERATOR_ID = "OP-MERGE";
+/**
+ * Ab welcher ND-02-Ähnlichkeit zwei VERSCHIEDENE SCHEMAs als DERSELBE Vertrag
+ * gelten (CR-GC-444).
+ *
+ * Bewusst ND-02s eigene DUPLIKAT-Schwelle (0.85) und nicht die lockere
+ * Overlap-Schwelle 0.5 aus AO-D01 (AO-D03 ist mit CR-SM-283 entfallen):
+ * ein Merge ist destruktiv, „überlappt"
+ * ist nicht „ist derselbe Vertrag". Die Zahl steht hier, weil contracts sie
+ * modul-lokal hält (`near-duplicate-rules.ts`) — sie wird NICHT umdefiniert.
+ */
+export declare const MERGE_SIMILARITY_THRESHOLD = 0.85;
+/**
+ * Tragen zwei SCHEMA-Knoten denselben Datenvertrag?
+ *
+ * Genau die Definition, die contracts schon fährt: identischer Knoten = 100 %,
+ * sonst ND-02s eigene Rechnung (`similarity.ts`, seit CR-SM-286 dort statt in
+ * einer injizierten Matrix). Kein zweites Ähnlichkeitsmaß, keine eigene Formel,
+ * kein ND-02-Fork.
+ *
+ * **CR-SM-289 — der Ähnlichkeits-Zweig ist heute UNERREICHBAR, nicht nur still.**
+ * ND-02s `usage_overlap` läuft über die direkten Partner eines SCHEMA, und
+ * `FLOW -relation-> SCHEMA [1..1]` ist das einzige Pattern, das SCHEMA berührt:
+ * zwei VERSCHIEDENE SCHEMAs hängen an zwei verschiedenen FLOWs, ihre
+ * Partnermengen sind disjunkt, `usage_overlap` ist 0. Deckel damit
+ * `0,50 + 0,30 = 0,80` gegen die Schwelle `0,85` — gemessen, nicht gerechnet.
+ * Bis CR-SM-286 war das ein „ohne Matrix"-Vorbehalt; seit die Injektion weg ist,
+ * gilt es immer.
+ *
+ * Der Zweig BLEIBT: er ist die Sicherung gegen eine echte
+ * R-18-Kardinalitätsverletzung und wird scharf, sobald Formel, Schwelle oder
+ * SCHEMA-Pattern wandern. `suggest.test.ts` nagelt beide Zahlen fest und schlägt
+ * dann an. Das zu reparieren ist eine contracts-Entscheidung, kein Fork hier.
+ */
+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).
+ *
+ * „Derselbe Vertrag" = `contractSimilarity` (identischer SCHEMA-Knoten oder
+ * ND-02-Duplikat) — EINE Definition, keine neue Zahl. Ein FLOW ohne oder mit
+ * mehr als einem SCHEMA nimmt nicht teil: er ist schon grammatikalisch kaputt
+ * und gehört R-18, nicht dem Optimierer.
+ *
+ * Pro Kandidaten-GRUPPE genau EIN Vorschlag (ein Greedy-Schritt, wie der Rest
+ * des Optimierers): der io-stärkste FLOW absorbiert den nächststärksten.
+ * Deterministisch — io-Grad absteigend, Tiebreak id aufsteigend.
+ */
+export declare function mergeCandidates(g: OntologyGraph): SuggestedEdit[];
+/**
+ * Den Merge-Verbund eines `SuggestedEdit` IN MEMORY anwenden — die Δm-Sonde des
+ * Operators (`suggestEdits`). Kein Ersatz fürs Gate: hier wird gemessen, dort
+ * geurteilt. Reihenfolge wie beim Batch: primärer Merge zuerst, dann `merges`.
+ */
+export declare function applyMergeEdit(g: OntologyGraph, edit: SuggestedEdit): OntologyGraph;
 export {};

package/dist/fix-templates.js

@@ -7,7 +7,7 @@
  * Ausgeliefert wird ein Edit nur, wenn ein rule-spezifisches Template ihn aus
  * dem Elementtext DETERMINISTISCH herleiten kann (Fundstelle = Begründung):
  *
- *   - CR-R01: CR ohne relation → relation zu einem IM CR-TEXT genannten
+ *   - CR-R01: CR ohne Umfangsbezug → relation zu einem IM CR-TEXT genannten
  *     UC/REQ/FUNC/MOD (Spike: "Relation zu im CR-Text genannten Elementen")
  *   - CR-R04: CR ohne FUNC → relation zu einer im CR-Text genannten FUNC
  *   - MS-03 : CR ohne Milestone → relation zur im Text genannten MS,
@@ -23,15 +23,18 @@
  *     sonst zum einzigen MOD im Graphen (eindeutig ⇒ herleitbar)
  *   - R-23 : MOD ohne allozierte FUNC → allocate von der im MOD-TEXT
  *     genannten FUNC (kein Eindeutigkeits-Fallback, s. dort)
- *   - SC-02/SC-04: FLOW ohne Datenvertrag → relation zum im FLOW-TEXT
- *     genannten SCHEMA, sonst zum einzigen SCHEMA
+ *   - SC-02: fehlende SCHEMA-Nutzung → relation zum im TEXT genannten
+ *     SCHEMA, sonst zum einzigen SCHEMA
+ *   - R-18 : NUR das Untergrenzen-Bein (CR-SM-302) → die vom Meta-Modell
+ *     geforderte Kante zum im TEXT genannten Ziel, sonst zum einzigen
+ *     (heute `FLOW -relation-> SCHEMA [1..1]`, aus REQUIRED_PATTERNS gelesen)
  *
  * Regeln ohne Template (oder Template ohne Fund) liefern null → die Suggestion
  * bleibt Fund-Ebene (Violation + Richtung + Δm), ohne Edit. Regeln, deren Fix
  * Element-Erzeugung braucht (FCHAIN, REQ-Pre/Postcondition, TEST), sind mit
  * additiven Kanten prinzipiell nicht ausdrückbar — bewusst kein Template.
  */
-import { isValidTrace } from '@sigloch/contracts/se';
+import { isValidTrace, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs, schemaSimilarity } from '@sigloch/contracts/se';
 function byId(g, id) {
     return g.elements.find((e) => e.id === id);
 }
@@ -39,6 +42,46 @@ function hasTrace(g, source, target, type) {
     return g.traces.some((t) => t.source === source && t.target === target && t.type === type);
 }
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Datei-Bindung einer Quelle — dieselbe Zugriffsfolge wie weightNodes (layer.ts). */
+function realFileOf(e) {
+    const el = e;
+    return el.realRef?.file ?? el.codeRef?.file ?? el.attributes?.realRef?.file ?? el.attributes?.codeRef?.file;
+}
+/**
+ * CR-GC-435 — das Kardinalitäts-Bewusstsein der Templates. `isValidTrace` prüft
+ * die PAAR-Legalität; die MENGEN-Bedingung (BOUNDED_PATTERNS, z.B.
+ * `FUNC -allocate-> MOD [0..1]`) sah bis dahin kein Template — es schlug Edits
+ * vor, die das Gate über R-18s zweites Bein sicher abweist (der verifizierte
+ * Repo-Befund: KEIN Architektur-Vorschlag anwendbar, sobald alloziert ist).
+ *
+ * Rückgabe: `undefined` = kein retire nötig (Anhängen bleibt Anhängen);
+ * eine Kante = GENAU DIE muss weichen, damit der Edit legal wird (Umhängen);
+ * `'blocked'` = kein EINZELNES retire macht den Edit legal (die Quelle verletzt
+ * die Obergrenze schon jetzt) — dann Option C: kein Edit statt eines sicher
+ * scheiternden (der Aufrufer probiert den nächsten Kandidaten bzw. liefert null).
+ */
+function retireFor(g, source, target, type) {
+    const pattern = BOUNDED_PATTERNS.find((p) => p.source === source.type && p.target === target.type && p.type === type);
+    if (!pattern)
+        return undefined;
+    const max = maxOccurs(pattern.cardinality);
+    const existing = g.traces.filter((t) => t.type === type &&
+        t.source === source.id &&
+        t.target !== target.id &&
+        byId(g, t.target)?.type === pattern.target);
+    if (existing.length + 1 <= max)
+        return undefined;
+    if (existing.length + 1 - max > 1)
+        return 'blocked';
+    const old = existing[0];
+    return {
+        source: old.source,
+        target: old.target,
+        type,
+        rationale: `${source.id} trägt bereits ${type} → ${old.target}; das Meta-Modell erlaubt höchstens ` +
+            `${max} (${pattern.cardinality}) — diese Kante muss weichen, damit ${target.id} legal wird`,
+    };
+}
 /**
  * Elemente der gegebenen Typen, deren id ODER name (Wortgrenze, ≥3 Zeichen,
  * case-insensitive) im Text vorkommt. Deterministische Rangfolge:
@@ -117,6 +160,14 @@ function edgeToMentioned(opts) {
                 sourceKinds: source.kinds, targetKinds: target.kinds,
             }))
                 continue;
+            // CR-GC-435: Paar legal ≠ Menge legal — die Kardinalitäts-Obergrenze
+            // entscheidet, ob der Edit ein Anhängen (kein retire), ein Umhängen
+            // (genau ein retire) oder nicht ausdrückbar ist ('blocked' → nächster
+            // Kandidat; Option C statt eines Edits, den das Gate sicher abweist).
+            const retire = retireFor(g, source, target, opts.traceType);
+            if (retire === 'blocked')
+                continue;
+            const file = retire ? realFileOf(source) : undefined;
             return {
                 op: 'add-trace',
                 source: source.id,
@@ -125,14 +176,17 @@ function edgeToMentioned(opts) {
                 rationale: mentioned.length > 0
                     ? `${other.id} ist im Text von ${el.id} genannt`
                     : `${other.id} ist das einzige ${other.type} im Graphen`,
+                ...(retire ? { retire } : {}),
+                ...(retire && file ? { codeImpact: { file, targetModule: target.id } } : {}),
             };
         }
         return null;
     };
 }
 export const FIX_TEMPLATES = {
-    'CR-R01': relationToMentioned(['UC', 'REQ', 'FUNC', 'MOD']),
-    'CR-R04': relationToMentioned(['FUNC']),
+    // CR-SM-295: SCHEMA gehoert zum Umfang — ein CR, der nur einen Datenvertrag aendert,
+    // ist ein vollstaendiger CR. Die Liste ist woertlich SCOPE_TYPES aus cr-quality-rules.
+    'CR-R01': relationToMentioned(['UC', 'REQ', 'FUNC', 'MOD', 'SCHEMA']),
     // --- Architektur-Operatoren (CR-SM-241) ------------------------------------
     // Ohne sie hat auf `layer: 'arch'` — graphcodes DEFAULT-Messebene — jeder
     // Template-Edit Δm = 0, weil CR/MS/UC gar nicht im Teilgraphen liegen.
@@ -144,9 +198,46 @@ export const FIX_TEMPLATES = {
     // irgendwohin), „das einzige FUNC" ist keine — ein FUNC darf legitim einem
     // anderen Modul gehören, und dieses hier hätte dann einfach noch keins.
     'R-23': edgeToMentioned({ types: ['FUNC'], traceType: 'allocate', direction: 'in' }),
-    // FLOW ohne Datenvertrag → das im FLOW-Text genannte SCHEMA, sonst das einzige.
+    // SCHEMA-Nutzung → das im Text genannte SCHEMA, sonst das einzige.
     'SC-02': edgeToMentioned({ types: ['SCHEMA'], traceType: 'relation', direction: 'out', uniqueFallback: true }),
-    'SC-04': edgeToMentioned({ types: ['SCHEMA'], traceType: 'relation', direction: 'out', uniqueFallback: true }),
+    /**
+     * CR-SM-302 — das UNTERGRENZEN-Bein von R-18, und ausschliesslich dieses.
+     *
+     * CR-SM-271 hat SC-04 gestrichen und den Fall zur Grammatik gemacht; mit der Regel fiel
+     * ihr Template, mit der Begruendung "R-18 meldet zu viele verschiedene Faelle". Der Satz
+     * stimmt fuer drei der vier Beine — und genau die drei sind hier ausgeschlossen:
+     *
+     *   illegales Paar · Kardinalitaets-OBERgrenze · compose-Baum
+     *
+     * Ihr Fix ist ein LOESCHEN, und ein additives Template drueckt das nicht aus. Das vierte
+     * Bein ist das Gegenteil: es fehlt genau EINE Kante, deren Typ und Ziel-Elementtyp das
+     * Meta-Modell vorgibt. Erkennungsmerkmal ist `candidate_targets` im Kontext — das setzt
+     * nur `cardinalityViolations`' Untergrenzen-Schleife (contracts `rules.ts`).
+     *
+     * Gemessen (CR-SM-302): an einem Graphen IM BAU (graphcodes DIVERGENCE_FIXTURE, 5 FLOWs)
+     * sind 3 von 4 Befunden herleitbar — der FLOW-Text nennt sein SCHEMA. An den migrierten
+     * Selbstmodellen sind es 0 von 6, aber diese Zahl misst Ueberlebende: ein R-18-Befund ist
+     * ein `error`, ein Graph, der sein Gate besteht, hat per Konstruktion keinen.
+     *
+     * Das Muster kommt aus REQUIRED_PATTERNS, nicht aus einer Konstanten: kommt eine zweite
+     * durchgesetzte Untergrenze dazu, traegt dieses Template sie ohne Aenderung.
+     */
+    'R-18': (v, g) => {
+        if (!Array.isArray(v.context?.candidate_targets))
+            return null;
+        const el = byId(g, v.element_id);
+        if (!el)
+            return null;
+        const pattern = REQUIRED_PATTERNS.find((p) => p.source === el.type);
+        if (!pattern)
+            return null;
+        return edgeToMentioned({
+            types: [pattern.target],
+            traceType: pattern.type,
+            direction: 'out',
+            uniqueFallback: true,
+        })(v, g);
+    },
     'MS-03': (v, g) => {
         const cr = byId(g, v.element_id);
         if (!cr)
@@ -226,3 +317,234 @@ export const FIX_TEMPLATES = {
 export function fixFor(v, g) {
     return FIX_TEMPLATES[v.rule_id]?.(v, g) ?? null;
 }
+// ---------------------------------------------------------------------------
+// CR-GC-444 — der Konsolidierungs-Operator (Merge)
+// ---------------------------------------------------------------------------
+/**
+ * Die Kennung der Konsolidierungs-Vorschläge im `Suggestion.ruleId`-Feld.
+ *
+ * AUSDRÜCKLICH KEINE contracts-Regel-ID. Der Operator hängt an keiner Violation,
+ * weil ein Merge keine Regel repariert — er bewegt die Metrik (Vertrags-
+ * konzentration, in CR-GC-438 als dieselbe Größe wie `flowEfficiency` gemessen,
+ * r = 0,89). Ein Fund wäre erfunden; die Kennung sagt stattdessen, woher der
+ * Vorschlag kommt.
+ */
+export const MERGE_OPERATOR_ID = 'OP-MERGE';
+/**
+ * Ab welcher ND-02-Ähnlichkeit zwei VERSCHIEDENE SCHEMAs als DERSELBE Vertrag
+ * gelten (CR-GC-444).
+ *
+ * Bewusst ND-02s eigene DUPLIKAT-Schwelle (0.85) und nicht die lockere
+ * Overlap-Schwelle 0.5 aus AO-D01 (AO-D03 ist mit CR-SM-283 entfallen):
+ * ein Merge ist destruktiv, „überlappt"
+ * ist nicht „ist derselbe Vertrag". Die Zahl steht hier, weil contracts sie
+ * modul-lokal hält (`near-duplicate-rules.ts`) — sie wird NICHT umdefiniert.
+ */
+export const MERGE_SIMILARITY_THRESHOLD = 0.85;
+/**
+ * Tragen zwei SCHEMA-Knoten denselben Datenvertrag?
+ *
+ * Genau die Definition, die contracts schon fährt: identischer Knoten = 100 %,
+ * sonst ND-02s eigene Rechnung (`similarity.ts`, seit CR-SM-286 dort statt in
+ * einer injizierten Matrix). Kein zweites Ähnlichkeitsmaß, keine eigene Formel,
+ * kein ND-02-Fork.
+ *
+ * **CR-SM-289 — der Ähnlichkeits-Zweig ist heute UNERREICHBAR, nicht nur still.**
+ * ND-02s `usage_overlap` läuft über die direkten Partner eines SCHEMA, und
+ * `FLOW -relation-> SCHEMA [1..1]` ist das einzige Pattern, das SCHEMA berührt:
+ * zwei VERSCHIEDENE SCHEMAs hängen an zwei verschiedenen FLOWs, ihre
+ * Partnermengen sind disjunkt, `usage_overlap` ist 0. Deckel damit
+ * `0,50 + 0,30 = 0,80` gegen die Schwelle `0,85` — gemessen, nicht gerechnet.
+ * Bis CR-SM-286 war das ein „ohne Matrix"-Vorbehalt; seit die Injektion weg ist,
+ * gilt es immer.
+ *
+ * Der Zweig BLEIBT: er ist die Sicherung gegen eine echte
+ * R-18-Kardinalitätsverletzung und wird scharf, sobald Formel, Schwelle oder
+ * SCHEMA-Pattern wandern. `suggest.test.ts` nagelt beide Zahlen fest und schlägt
+ * dann an. Das zu reparieren ist eine contracts-Entscheidung, kein Fork hier.
+ */
+export function contractSimilarity(g, a, b) {
+    if (a === b)
+        return 1;
+    // CR-SM-286: der Graph ist jetzt Parameter. Vorher las die Funktion den contracts-Modulzustand
+    // und gab ohne Injektion 0 — also "nicht aehnlich" statt "nicht beurteilbar", und das an einer
+    // Stelle, die ueber einen destruktiven Merge entscheidet.
+    const sim = schemaSimilarity(g);
+    const i = sim.ids.indexOf(a);
+    const j = sim.ids.indexOf(b);
+    if (i < 0 || j < 0)
+        return 0;
+    return sim.matrix[i]?.[j] ?? 0;
+}
+/** Eindeutige Ziele einer Kante `id -type-> <targetType>`, in Graph-Reihenfolge. */
+function outTargets(g, id, type, targetType) {
+    const out = [];
+    for (const t of g.traces) {
+        if (t.type !== type || t.source !== id)
+            continue;
+        if (byId(g, t.target)?.type !== targetType)
+            continue;
+        if (!out.includes(t.target))
+            out.push(t.target);
+    }
+    return out;
+}
+/**
+ * Die Merges, die MITLAUFEN müssen, wenn `drop` in `keep` aufgeht — hergeleitet
+ * aus der GRAMMATIK, nicht konventioniert.
+ *
+ * Für jedes `BOUNDED_PATTERNS`-Muster, dessen QUELLE der gemergte Typ ist
+ * (Kardinalität zählt ausgehend, wie R-18s zweites Bein), wird geprüft, ob die
+ * Vereinigung der Ziele von `keep` und `drop` die Obergrenze reißt. Genau dann
+ * fällt ein gekoppelter Merge an. Heute trifft das exakt einen Fall:
+ * `FLOW -relation-> SCHEMA [1..1]`.
+ *
+ * `null` = nicht eindeutig auflösbar ⇒ KEIN Vorschlag (Option C aus CR-GC-435:
+ * lieber kein Edit als einer, den das Gate sicher abweist). Das gilt, wenn die
+ * Obergrenze > 1 ist, wenn `keep` selbst schon überzählt, oder wenn die weichenden
+ * Ziele nicht nachweislich derselbe Vertrag sind.
+ */
+function coupledMerges(g, drop, keep) {
+    const out = [];
+    for (const p of BOUNDED_PATTERNS) {
+        if (p.source !== drop.type || p.target === '*')
+            continue;
+        const targetType = p.target;
+        const keepTargets = outTargets(g, keep.id, p.type, targetType);
+        const dropTargets = outTargets(g, drop.id, p.type, targetType);
+        const union = [...keepTargets, ...dropTargets.filter((t) => !keepTargets.includes(t))];
+        if (union.length <= maxOccurs(p.cardinality))
+            continue;
+        if (maxOccurs(p.cardinality) !== 1 || keepTargets.length !== 1)
+            return null;
+        const survivor = keepTargets[0];
+        for (const extra of union) {
+            if (extra === survivor)
+                continue;
+            // Nur SCHEMA lässt sich hier belegen — für alles andere fehlt der Nachweis,
+            // dass die beiden Ziele dasselbe sind, also gibt es keinen Vorschlag.
+            if (targetType !== 'SCHEMA' || contractSimilarity(g, extra, survivor) < MERGE_SIMILARITY_THRESHOLD)
+                return null;
+            out.push({
+                source: extra,
+                target: survivor,
+                rationale: `${keep.id} trüge nach dem Merge ${union.length} ${targetType} über ${p.type}, ` +
+                    `die Grammatik erlaubt ${p.cardinality} — ${extra} muss im SELBEN Batch in ${survivor} aufgehen`,
+            });
+        }
+    }
+    return out;
+}
+/** io-Grad eines Knotens — der besser verdrahtete Vertrag überlebt den Merge. */
+function ioDegree(g, id) {
+    return g.traces.filter((t) => t.type === 'io' && (t.source === id || t.target === id)).length;
+}
+/**
+ * Konsolidierungs-Kandidaten: FLOW-Paare, die DENSELBEN Datenvertrag tragen
+ * (CR-GC-444, Zielbild „graphcode als Regelkreis", FLOWs 62 → 27).
+ *
+ * „Derselbe Vertrag" = `contractSimilarity` (identischer SCHEMA-Knoten oder
+ * ND-02-Duplikat) — EINE Definition, keine neue Zahl. Ein FLOW ohne oder mit
+ * mehr als einem SCHEMA nimmt nicht teil: er ist schon grammatikalisch kaputt
+ * und gehört R-18, nicht dem Optimierer.
+ *
+ * Pro Kandidaten-GRUPPE genau EIN Vorschlag (ein Greedy-Schritt, wie der Rest
+ * des Optimierers): der io-stärkste FLOW absorbiert den nächststärksten.
+ * Deterministisch — io-Grad absteigend, Tiebreak id aufsteigend.
+ */
+export function mergeCandidates(g) {
+    const flows = g.elements.filter((e) => e.type === 'FLOW');
+    // Gruppen zunächst nach identischem SCHEMA-Knoten …
+    const bySchema = new Map();
+    for (const f of flows) {
+        const schemas = outTargets(g, f.id, 'relation', 'SCHEMA');
+        if (schemas.length !== 1)
+            continue;
+        const group = bySchema.get(schemas[0]);
+        if (group)
+            group.push(f);
+        else
+            bySchema.set(schemas[0], [f]);
+    }
+    // … dann die Gruppen verschmelzen, deren SCHEMAs ND-02-Duplikate sind.
+    const schemaIds = [...bySchema.keys()].sort();
+    const groupOf = new Map(schemaIds.map((s) => [s, s]));
+    const root = (s) => {
+        let x = s;
+        for (let n = 0; n < 50 && groupOf.get(x) !== x; n += 1)
+            x = groupOf.get(x);
+        return x;
+    };
+    for (let i = 0; i < schemaIds.length; i += 1) {
+        for (let j = i + 1; j < schemaIds.length; j += 1) {
+            if (contractSimilarity(g, schemaIds[i], schemaIds[j]) < MERGE_SIMILARITY_THRESHOLD)
+                continue;
+            const a = root(schemaIds[i]);
+            const b = root(schemaIds[j]);
+            if (a !== b)
+                groupOf.set(b, a);
+        }
+    }
+    const grouped = new Map();
+    for (const s of schemaIds) {
+        const key = root(s);
+        grouped.set(key, [...(grouped.get(key) ?? []), ...bySchema.get(s)]);
+    }
+    const edits = [];
+    for (const key of [...grouped.keys()].sort()) {
+        const members = grouped.get(key)
+            .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)
+            continue;
+        const keepSchema = outTargets(g, keep.id, 'relation', 'SCHEMA')[0];
+        const dropSchema = outTargets(g, drop.id, 'relation', 'SCHEMA')[0];
+        edits.push({
+            op: 'merge-nodes',
+            source: drop.id,
+            target: keep.id,
+            type: 'relation',
+            rationale: keepSchema === dropSchema
+                ? `${drop.id} und ${keep.id} tragen denselben Vertrag ${keepSchema} — ${keep.id} absorbiert ${drop.id}`
+                : `${drop.id} und ${keep.id} tragen mit ${dropSchema} / ${keepSchema} ein ND-02-Duplikat ` +
+                    `(${Math.round(contractSimilarity(g, dropSchema, keepSchema) * 100)} %) — ${keep.id} absorbiert ${drop.id}`,
+            ...(merges.length ? { merges } : {}),
+        });
+    }
+    return edits;
+}
+/**
+ * Den Merge-Verbund eines `SuggestedEdit` IN MEMORY anwenden — die Δm-Sonde des
+ * Operators (`suggestEdits`). Kein Ersatz fürs Gate: hier wird gemessen, dort
+ * geurteilt. Reihenfolge wie beim Batch: primärer Merge zuerst, dann `merges`.
+ */
+export function applyMergeEdit(g, edit) {
+    const absorbedBy = new Map([
+        [edit.source, edit.target],
+        ...(edit.merges ?? []).map((m) => [m.source, m.target]),
+    ]);
+    const resolve = (id) => {
+        let x = id;
+        for (let n = 0; n < 50 && absorbedBy.has(x); n += 1)
+            x = absorbedBy.get(x);
+        return x;
+    };
+    const seen = new Set();
+    const traces = [];
+    for (const t of g.traces) {
+        const source = resolve(t.source);
+        const target = resolve(t.target);
+        if (source === target)
+            continue;
+        const key = `${source}>${t.type}>${target}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        traces.push({ ...t, source, target });
+    }
+    return { ...g, elements: g.elements.filter((e) => !absorbedBy.has(e.id)), traces };
+}

package/dist/metrics.d.ts

@@ -48,6 +48,7 @@ export declare function metrics(graph: OntologyGraph, opts?: MetricsOptions): Me
 export { projectLayer, weightNodes, ARCH_TYPES, type MetricLayer } from './layer.js';
 export { CLASS_MAP, classOf, classifyAll, classificationStats, type RuleClass, type Classification, type ClassifiedRule, type ClassificationStats, } from './rule-classify.js';
 export { applyRule, markEmptyDelta, type ApplyResult, type DeltaMark } from './rule-apply.js';
-export { targetFor, suggestEdits, type Suggestion, type SuggestOptions } from './suggest.js';
-export { fixFor, mentionedElements, FIX_TEMPLATES, type SuggestedEdit } from './fix-templates.js';
+export { suggestEdits, type Suggestion, type SuggestOptions } from './suggest.js';
+export { steerScore, beatsBySteer, STEER_RULES, EPS_AUGMENT, type SteerScore, type SteerCandidate } from './steer.js';
+export { fixFor, mentionedElements, FIX_TEMPLATES, mergeCandidates, applyMergeEdit, contractSimilarity, MERGE_OPERATOR_ID, MERGE_SIMILARITY_THRESHOLD, type SuggestedEdit, } from './fix-templates.js';
 export { buildAdjacency, betweenness, maxBetweenness, detectCommunities, modularityOf, modularityQ, redundancyDensity, intraEdgeFraction, components, componentSizes, sourceSinkPaths, type Adjacency, } from './topology.js';

package/dist/metrics.js

@@ -92,6 +92,8 @@ export function metrics(graph, opts = {}) {
 export { projectLayer, weightNodes, ARCH_TYPES } from './layer.js';
 export { CLASS_MAP, classOf, classifyAll, classificationStats, } from './rule-classify.js';
 export { applyRule, markEmptyDelta } from './rule-apply.js';
-export { targetFor, suggestEdits } from './suggest.js';
-export { fixFor, mentionedElements, FIX_TEMPLATES } from './fix-templates.js';
+export { suggestEdits } from './suggest.js';
+// CR-SM-292: der Ranking-Score. `targetFor` ist mit dem ℝ⁶-Ranking ersatzlos entfallen.
+export { steerScore, beatsBySteer, STEER_RULES, EPS_AUGMENT } from './steer.js';
+export { fixFor, mentionedElements, FIX_TEMPLATES, mergeCandidates, applyMergeEdit, contractSimilarity, MERGE_OPERATOR_ID, MERGE_SIMILARITY_THRESHOLD, } from './fix-templates.js';
 export { buildAdjacency, betweenness, maxBetweenness, detectCommunities, modularityOf, modularityQ, redundancyDensity, intraEdgeFraction, components, componentSizes, sourceSinkPaths, } from './topology.js';

package/dist/rule-classify.js

@@ -19,7 +19,8 @@
  *
  * Delta zum Spike-Original: RD-04 (Dekompositionsbreite, CR-SM-221) ergänzt;
  * SC-01/SC-03 (BOK-CR-026) und MT-03 (CR-SM-223) sind aus dem Katalog gelöscht
- * und daher hier entfernt. CR-SM-226: +R-28/FC-04/SC-04 (neue Regeln; R-28 mit CR-SM-247 wieder entfallen); IO-01
+ * und daher hier entfernt. CR-SM-226: +R-28/FC-04/SC-04 (neue Regeln; R-28 mit CR-SM-247,
+ * SC-04 mit CR-SM-271 wieder entfallen — Untergrenze ist Grammatik/R-18-Bein); IO-01
  * ist nicht mehr cross-module-only (Rationale-Text angepasst, Klasse unverändert).
  * CR-GC-366: +R-30 (Wirkketten-Bindung) und +R-31 (io-Verdrahtung), beide Operator —
  * ihr Fix fügt eine Trace hinzu und bewegt damit die Topologie.
@@ -55,7 +56,6 @@ export const CLASS_MAP = {
     '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-14': { class: 'Operator', rationale: 'add compose trace UC→FCHAIN/REQ' },
     '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' },
@@ -70,22 +70,17 @@ export const CLASS_MAP = {
     'UC-03': { class: 'Operator', rationale: 'add compose trace UC→FCHAIN (scenario)' },
     'UC-05': { class: 'Operator', rationale: 'add REQ(postcondition) via compose trace' },
     'UC-06': { class: 'Operator', rationale: 'add REQ(precondition) via compose trace' },
-    'FC-01': { class: 'Operator', rationale: 'connect chain to ACTOR via FLOW io trace' },
     'FC-02': { class: 'Operator', rationale: 'add FCHAIN via compose trace to leaf UC' },
     'SC-02': { class: 'Operator', rationale: 'link FLOW→SCHEMA via relation trace' },
-    'PH-01': { class: 'Operator', rationale: 'add logical MOD via compose trace' },
     'IO-01': { class: 'Operator', rationale: 'add FLOW element + io traces between the FUNC pair' },
     // 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' },
     'FC-04': { class: 'Operator', rationale: 'add ACTOR→FLOW entry + FUNC→FLOW exit io traces' },
-    'SC-04': { class: 'Operator', rationale: 'link FLOW→SCHEMA via relation trace' },
     'CR-R01': { class: 'Operator', rationale: 'add relation traces CR→affected elements' },
-    'CR-R04': { class: 'Operator', rationale: 'add relation trace CR→FUNC' },
     '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-03': { class: 'Constraint', rationale: 'ASIL isolation — separate mixed levels, non-additive' },
     'R-04': { class: 'Constraint', rationale: 'module too large — split, non-additive' },
     'R-08': { class: 'Constraint', rationale: 'repair dangling trace endpoint' },
     'R-12': { class: 'Constraint', rationale: 'break dependency cycle — remove an edge' },
@@ -97,10 +92,9 @@ export const CLASS_MAP = {
     'R-29': { class: 'Constraint', rationale: 'test file claimed twice — which acceptance owns it is a judgement call' },
     'R-20': { class: 'Constraint', rationale: 'add realRef attribute — no topology change' },
     'R-26': { class: 'Constraint', rationale: 'add realRef attribute — no topology change' },
-    'R-27': { class: 'Constraint', rationale: 'physical MOD add realRef attribute — no topology change' },
     '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–11 — split level, non-additive' },
+    'RD-04': { class: 'Constraint', rationale: 'decomposition breadth 7±2 — split level, 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' },
@@ -115,10 +109,8 @@ export const CLASS_MAP = {
     'ND-02': { class: 'Constraint', rationale: 'near-duplicate SCHEMA — merge/differentiate' },
     'CR-R02': { class: 'Constraint', rationale: 'done requires commitRef — attribute' },
     'CR-R03': { class: 'Constraint', rationale: 'concurrent mutation — coordinate, non-additive' },
-    'AO-D01': { class: 'Constraint', rationale: 'relay node — eliminate/rewire, advisory' },
-    'AO-D03': { class: 'Constraint', rationale: 'duplicate path — unify, advisory' },
+    'BW-02': { class: 'Constraint', rationale: 'whitebox boundary width — consolidate contracts or add a level' },
     'CR-01': { class: 'Constraint', rationale: 'crossing-flow coupling — reduce, advisory' },
-    'RT-01': { class: 'Constraint', rationale: 'physical boundary integrity — repair' },
     'NFR-01': { class: 'Constraint', rationale: 'budget overshoot — reduce measured/raise budget' },
     'VR-01': { class: 'Constraint', rationale: 'missing testResult attribute — no topology change' },
     // CR-SM-227 hat AF-01..05 in den Katalog gelegt, ohne sie hier zu klassifizieren;
@@ -130,9 +122,25 @@ export const CLASS_MAP = {
     'AF-04': { class: 'Constraint', rationale: 'FMEA freshness stamp — attribute, no topology change' },
     'AF-05': { class: 'Constraint', rationale: 'Implementation Plan freshness stamp — attribute, no topology change' },
     // --- Ambiguous (mixed-intent fix) ------------------------------------------
-    'CA-01': { class: 'Constraint', rationale: 'add capabilities OR move FUNC — mixed', ambiguous: true },
     'CL-01': { class: 'Constraint', rationale: 'ConOps completeness — attribute vs added element unclear', ambiguous: true },
     'FM-01': { class: 'Constraint', rationale: 'FMEA S/O/D attributes vs added mitigation — mixed', ambiguous: true },
+    // --- Kongruenz (CR-SM-305): der Code hat recht, nicht der Graph ------------
+    //
+    // Alle sechs sind **Constraints**, und der Grund ist derselbe für alle: der Befund sagt, dass
+    // die Bindung an den Code nicht mehr stimmt — und die Antwort darauf ist entweder eine
+    // Änderung AM CODE (den der Optimizer nicht anfasst) oder ein Umbinden der Referenz auf den
+    // Stand, den der Code inzwischen hat. Beides ist keine Topologie-Änderung am Graphen, und
+    // beides kann der Optimizer nicht aus dem Elementtext ableiten: wohin eine verwaiste `realRef`
+    // ZEIGEN SOLL, steht in keinem Feld. Ein Operator daraus wäre geraten, nicht abgeleitet.
+    //
+    // `applyRule`/`suggestEdits` verwerfen alles, was nicht `Operator` ist — RC bleibt damit
+    // Bericht und Gate-Signal, so wie es gemeint ist.
+    'RC-01': { class: 'Constraint', rationale: 'realRef zeigt ins Leere — umbinden oder Code nachziehen, keine Kante' },
+    'RC-02': { class: 'Constraint', rationale: 'testRefs zeigt ins Leere — Testdatei/Fall umbinden, keine Kante' },
+    'RC-03': { class: 'Constraint', rationale: 'SCHEMA-realRef zeigt ins Leere — umbinden, keine Kante' },
+    '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' },
 };
 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

@@ -0,0 +1,104 @@
+/**
+ * steer.ts — der Ranking-Score der Familie (CR-SM-292).
+ *
+ * Er ersetzt `Δm · t̂` aus `metrics()`, das dreimal an gemessenen Gegenbeispielen gefallen ist
+ * (CR-SM-281, CR-SM-287 §10/§11): eine gewichtete Summe über sechs Zahlen aus dem UNTYPISIERTEN
+ * Graphen kann Enthaltensein nicht von Fluss und nicht von Besitz unterscheiden — und rankte
+ * deshalb einen Code-Import mit 306 flachen Wurzeln über jedes strukturierte Modell der Familie.
+ *
+ * ## Die Rechnung
+ *
+ *     score = max_i( (wert_i − budget_i)/budget_i ) + ε · mittel_i( (wert_i − budget_i)/budget_i )
+ *
+ * über die fünf messenden Regeln. **Kleiner ist besser**; 0 heisst „jede Blackbox innerhalb
+ * ihres Budgets".
+ *
+ * ## Warum das Maximum und nicht die Summe
+ *
+ * Summe und Lexikographie sind derselbe Fehler an entgegengesetzten Enden. Die Summe ist
+ * KOMPENSATORISCH — eine gute Dimension kauft eine schlechte frei (CR-SM-281: `faultTolerance`
+ * +2,11 kaufte drei Regressionen frei). Die Lexikographie ist DIKTATORISCH — die erste Stufe,
+ * die sich unterscheidet, entscheidet allein (CR-SM-287 §11: RD-04 entschied, BW-02 kam nie zu
+ * Wort, und ein bedeutungsloser Zufallsschnitt gewann gegen den bestätigten).
+ *
+ * Chebyshev (Wierzbickis achievement scalarizing function) sitzt dazwischen: **man ist so gut wie
+ * die eigene schlechteste Stelle.** Kein Freikauf, kein Diktat. Und es ist dieselbe Logik, nach
+ * der das Gate schon immer urteilt — „ein neuer `error` blockiert" ist ein Maximum über
+ * Severities, nie ein Mittelwert.
+ *
+ * ## Warum es keine neuen freien Zahlen gibt
+ *
+ * Normiert wird gegen `context.threshold`, also gegen die **Regelschwelle selbst**
+ * (`policy.decompositionBreadth`, `boundaryWidth`, `crossingFlows`, `instability`, `lcom4`) —
+ * aus der Verteilung realer Modelle abgelesen, unter `RULES_VERSION` versioniert, an einer Stelle
+ * grep-bar. Genau daran ist CR-SM-281 gestorben: sechs Gewichte, die nie bestimmbar waren
+ * (R² = 0,91 bei R²_LOO = −40, N = 9 auf 6 Prädiktoren). Hier erbt die Steuerung die Schwellen
+ * der Regeln, statt eigene zu führen.
+ *
+ * `EPS_AUGMENT` ist die einzige eigene Zahl und kein Urteil: ohne sie sind zwei Kandidaten mit
+ * gleichem Maximum ununterscheidbar (schwach pareto-optimal) und die Rangfolge hinge an der
+ * Sortier-Stabilität.
+ *
+ * ## Was der Score NICHT kann — gemessen, nicht vermutet (CR-SM-291 §7.2)
+ *
+ *  1. **Er misst Form, nie Substanz.** Ein Kandidat, der Elemente LÖSCHT, senkt ihn zuverlässig.
+ *     Dagegen hilft kein besserer Skalar, sondern `beatsBySteer` — die Nebenbedingung unten.
+ *  2. **Innerhalb aller Budgets ist er blind** (Score 0 für alles). Dort führt `readiness`, die
+ *     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.
+ */
+import type { RuleViolation } from '@sigloch/contracts/se';
+/**
+ * Die fünf messenden Regeln — der theoriegestützte Satz, der im Katalog schon stand: Simon
+ * (Breite je Container), Parnas (Randbreite je Whitebox), Baldwin/Clark (Kopplung je Modulpaar),
+ * Martin (Instabilität), LCOM4 (Kohäsion).
+ *
+ * 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"];
+/** Der Ausgleichsterm. Klein genug, dass er ein echtes Maximum nie überstimmt. */
+export declare const EPS_AUGMENT = 0.001;
+export interface SteerScore {
+    /** Der schlimmste normierte Überschuss. 0 = jede Blackbox innerhalb ihres Budgets. */
+    worst: number;
+    /** Wo er sitzt — die Begründung, nicht nur die Zahl. `null`, wenn nichts überschreitet. */
+    worstAt: {
+        ruleId: string;
+        elementId: string;
+    } | null;
+    /** Mittel über alle gemessenen Blackboxes; Grundlage des Ausgleichsterms. */
+    mean: number;
+    /** `worst + EPS_AUGMENT * mean` — der Vergleichswert. **Kleiner ist besser.** */
+    score: number;
+    /** Zahl der Blackboxes, die in die Rechnung eingegangen sind. */
+    measured: number;
+}
+/** 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. */
+export interface SteerCandidate {
+    /** Der Score des Zustands NACH dem Zug. */
+    score: SteerScore;
+    /**
+     * Entfernt der Zug Elemente? Gemessen, nicht deklariert: Elementzahl vorher gegen nachher.
+     */
+    removesElements: boolean;
+}
+/**
+ * Vergleicht zwei Kandidaten. `< 0` heisst **a ist besser**; direkt sortierbar.
+ *
+ * Die Zerstörungs-Sperre steht VOR dem Score und ist keine Gewichtung: gemessen (CR-SM-291
+ * Satz F) rankt „18 Kinder löschen" unter jeder Massen-Ablesung vor jeder echten Reparatur, weil
+ * der ℝ⁵ Form misst und nie Substanz. Ein Score, der Zerstörung „einpreist", bräuchte genau das
+ * Gewicht, das niemand bestimmen kann — deshalb eine Nebenbedingung statt einer Zahl.
+ *
+ * Zwei löschende Kandidaten werden untereinander wieder nach Score verglichen: die Sperre soll
+ * Löschen nicht belohnen, aber auch nicht unvergleichbar machen.
+ */
+export declare function beatsBySteer(a: SteerCandidate, b: SteerCandidate): number;

package/dist/steer.js

@@ -0,0 +1,89 @@
+/**
+ * Die fünf messenden Regeln — der theoriegestützte Satz, der im Katalog schon stand: Simon
+ * (Breite je Container), Parnas (Randbreite je Whitebox), Baldwin/Clark (Kopplung je Modulpaar),
+ * Martin (Instabilität), LCOM4 (Kohäsion).
+ *
+ * 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.
+ */
+/*
+ * CR-SM-293: **MT-01 ist raus.** Der Satz oben nennt vier Theorien und beschreibt damit den
+ * Stand; Martin fehlt vorerst, und das ist eine Luecke mit Namen, kein stiller Verzicht.
+ *
+ * Der Grund ist das Kriterium aus CR-SM-287 §2 selbst — lokal, GERICHTET ("weniger ist besser,
+ * ohne Diskussion"), BUDGETIERT ("Schwelle aus der Verteilung abgelesen"). MT-01 erfuellt nur
+ * das erste. Martins Aussage ist "in Richtung Stabilitaet abhaengen", nicht "I klein halten":
+ * ein Blattmodul mit I = 1.0 ist richtig. Und die Verteilung gibt keine Schwelle her (44 Module
+ * exakt auf 0.00, 45 exakt auf 1.00 von 149). MT-01 kam ueber die Theorie-TABELLE in §3 herein
+ * und wurde nie gegen die drei Kriterien gehalten, die derselbe CR eine Seite vorher aufstellt.
+ *
+ * Praktisch war die Dimension ohnehin still: `steerScore` liest VERSTOESSE, und graphcodes
+ * Config setzt `instability: null` seit CR-GC-329 — auf dem einzigen Repo, das taeglich steuert,
+ * lief der R5 laengst als R4. Diese Zeile sagt es jetzt, statt es zu verbergen.
+ *
+ * Der Nachfolger ist gemessen und angelegt (CR-SM-298): Martins Stable Dependencies Principle
+ * als GERICHTETE Groesse — Abhaengigkeiten "bergauf" je Modul. Ueber 19 Familiengraphen 34 von
+ * 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'];
+/** 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 };
+/**
+ * Normierter Überschuss je Befund: `(wert − budget) / budget`, dimensionslos.
+ *
+ * Ein Befund ohne `value`/`threshold` wird ÜBERSPRUNGEN, nicht als 0 gezählt — „keine Messung"
+ * ist nicht „keine Überschreitung". Dieselbe Konvention wie `policy.X = null` und
+ * `moduleMetrics.instability = null`.
+ */
+function overshootOf(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);
+}
+/** Der Chebyshev-Score eines Zustands, aus seinem Regelstrom. Rein. */
+export function steerScore(violations) {
+    const rules = STEER_RULES;
+    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;
+        // `>` 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 (measured === 0)
+        return NEUTRAL;
+    const mean = sum / measured;
+    return { worst, worstAt, mean, score: worst + EPS_AUGMENT * mean, measured };
+}
+/**
+ * Vergleicht zwei Kandidaten. `< 0` heisst **a ist besser**; direkt sortierbar.
+ *
+ * Die Zerstörungs-Sperre steht VOR dem Score und ist keine Gewichtung: gemessen (CR-SM-291
+ * Satz F) rankt „18 Kinder löschen" unter jeder Massen-Ablesung vor jeder echten Reparatur, weil
+ * der ℝ⁵ Form misst und nie Substanz. Ein Score, der Zerstörung „einpreist", bräuchte genau das
+ * Gewicht, das niemand bestimmen kann — deshalb eine Nebenbedingung statt einer Zahl.
+ *
+ * Zwei löschende Kandidaten werden untereinander wieder nach Score verglichen: die Sperre soll
+ * Löschen nicht belohnen, aber auch nicht unvergleichbar machen.
+ */
+export function beatsBySteer(a, b) {
+    if (a.removesElements !== b.removesElements)
+        return a.removesElements ? 1 : -1;
+    return a.score.score - b.score.score;
+}

package/dist/suggest.d.ts

@@ -1,9 +1,7 @@
 import type { OntologyGraph } from '@sigloch/contracts/se';
-import { type MetricVector } from './metrics.js';
+import { type SteerScore } from './steer.js';
 import type { MetricLayer } from './layer.js';
 import { type SuggestedEdit } from './fix-templates.js';
-/** Build a target vector (ℝ⁶, canonical dimension order) from named metric weights. */
-export declare function targetFor(weights: Partial<Record<keyof MetricVector, number>>): number[];
 export interface Suggestion {
     ruleId: string;
     /** Fund: das verletzte Element. */
@@ -11,10 +9,21 @@ export interface Suggestion {
     /** Fund: die Regel-Botschaft (erste Violation der Regel). */
     message: string;
     fixHint?: string;
-    /** Δm der generischen Richtungssonde (ℝ⁶, kanonische Ordnung). */
+    /**
+     * Δm der generischen Richtungssonde (ℝ⁶, kanonische Ordnung) — **Ablesung, kein Ranking**.
+     * Seit CR-SM-292 rankt niemand mehr danach; die Zahl bleibt im Bericht, weil `graph_metrics`
+     * und das Fit-Advisory sie zeigen.
+     */
     delta: number[];
-    /** Projektion von Δm auf das Einheitsziel: >0 hin, <0 weg. */
+    /**
+     * **Senkung des Chebyshev-Scores** durch diesen Zug: `steer(basis) − steer(nachher)`.
+     * Positiv = besser, absteigend sortiert. Ersetzt `Δm · t̂` (CR-SM-292).
+     */
     score: number;
+    /** Der Zustands-Score NACH dem Zug — trägt `worstAt`, also das WO, nicht nur das WIEVIEL. */
+    steer: SteerScore;
+    /** Entfernt der Zug Elemente? Trägt die Zerstörungs-Sperre (`beatsBySteer`). */
+    removesElements: boolean;
     /** Rule-spezifischer Template-Edit; fehlt = Fund-Ebene ohne Edit. */
     edit?: SuggestedEdit;
 }
@@ -25,7 +34,11 @@ export interface SuggestOptions {
     layer?: MetricLayer;
 }
 /**
- * Rank the firing Operator rules by how much their probe edit moves `graph`
- * toward `target`. Deterministic, score-descending, tiebreak ruleId.
+ * Rankt die feuernden Operator-Regeln danach, wie weit ihr Sonden-Edit den **Chebyshev-Score**
+ * senkt (CR-SM-292). Deterministisch, score-absteigend, Tiebreak ruleId/elementId.
+ *
+ * Vorher stand hier `Δm · t̂` gegen einen Zielvektor aus `target-profile.json`. Der Parameter ist
+ * mit diesem CR ersatzlos entfallen — dreimal widerlegt, und ein zweiter Pfad daneben wäre genau
+ * das, was der Regelsatz verbietet.
  */
-export declare function suggestEdits(graph: OntologyGraph, target: number[], opts?: SuggestOptions): Suggestion[];
+export declare function suggestEdits(graph: OntologyGraph, opts?: SuggestOptions): Suggestion[];

package/dist/suggest.js

@@ -2,39 +2,43 @@
  * Greedy one-step optimization suggestions (promotet aus aimpro
  * src/spike/suggest.ts, CR-234 → CR-SM-225) — MIT dem Spike-2-Redesign:
  *
- * AUSGELIEFERT wird die Fund-Ebene: Violation (Element + Message) + Richtung
- * (score = Δm·t̂) + Δm. Der generische applyRule-Trace bleibt eine interne
- * Richtungssonde — als Edit ausgeliefert wird NUR, was ein rule-spezifisches
- * Fix-Template (fix-templates.ts) deterministisch aus dem Elementtext herleitet.
- * Δm rankt, es gibt nie frei: Anwendung läuft immer durchs Gate (3-Tier-Verdict,
- * graphcode graph_suggest → dryRun-Preview), nie auto-apply.
+ * AUSGELIEFERT wird die Fund-Ebene: Violation (Element + Message) + Richtung. Der generische
+ * applyRule-Trace bleibt eine interne Richtungssonde — als Edit ausgeliefert wird NUR, was ein
+ * rule-spezifisches Fix-Template (fix-templates.ts) deterministisch aus dem Elementtext
+ * herleitet. Der Score rankt, er gibt nie frei: Anwendung läuft immer durchs Gate
+ * (3-Tier-Verdict, graphcode graph_suggest → dryRun-Preview), nie auto-apply.
+ *
+ * CR-SM-292: gerankt wird nach der Senkung des CHEBYSHEV-Scores (`steer.ts`), nicht mehr nach
+ * `Δm · t̂`. Δm bleibt als Ablesung im Ergebnis, rankt aber nichts mehr — die Begründung steht
+ * vollständig im Kopf von `steer.ts`.
  *
  * Bewusst EIN Schritt von der Baseline — kein Sequencing, keine Interaktion,
  * keine Pareto-Front, keine Suche (Fahrplan-Schritt 5).
  */
 import { evaluateAllRules } from '@sigloch/contracts/se';
-import { metrics, toArray, METRIC_DIMENSIONS } from './metrics.js';
+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 { fixFor } from './fix-templates.js';
-/** Build a target vector (ℝ⁶, canonical dimension order) from named metric weights. */
-export function targetFor(weights) {
-    return METRIC_DIMENSIONS.map((d) => weights[d] ?? 0);
-}
-function l2(v) {
-    return Math.sqrt(v.reduce((s, x) => s + x * x, 0));
-}
+import { fixFor, mergeCandidates, applyMergeEdit, MERGE_OPERATOR_ID } from './fix-templates.js';
 /**
- * Rank the firing Operator rules by how much their probe edit moves `graph`
- * toward `target`. Deterministic, score-descending, tiebreak ruleId.
+ * Rankt die feuernden Operator-Regeln danach, wie weit ihr Sonden-Edit den **Chebyshev-Score**
+ * senkt (CR-SM-292). Deterministisch, score-absteigend, Tiebreak ruleId/elementId.
+ *
+ * Vorher stand hier `Δm · t̂` gegen einen Zielvektor aus `target-profile.json`. Der Parameter ist
+ * mit diesem CR ersatzlos entfallen — dreimal widerlegt, und ein zweiter Pfad daneben wäre genau
+ * das, was der Regelsatz verbietet.
  */
-export function suggestEdits(graph, target, opts = {}) {
+export function suggestEdits(graph, opts = {}) {
     const { k = Infinity, layer = 'all' } = opts;
-    const tn = l2(target);
-    const t = tn < 1e-12 ? target : target.map((x) => x / tn);
     const measure = (g) => toArray(metrics(g, { layer }));
     const base = measure(graph);
     const violations = evaluateAllRules(graph, MT_IRRELEVANT_POLICY);
+    // Der Score braucht die Befunde MIT ihren Schwellen; `MT_IRRELEVANT_POLICY` legt MT-01/MT-02
+    // still (`null`), sie tragen dort also keine `context.threshold` und fallen im Score
+    // automatisch weg — dieselbe Konvention wie in `steerScore`, kein Sonderfall hier.
+    const baseSteer = steerScore(violations);
+    const steerOf = (g) => steerScore(evaluateAllRules(g, MT_IRRELEVANT_POLICY));
     const firstByRule = new Map();
     for (const v of violations)
         if (!firstByRule.has(v.rule_id))
@@ -47,17 +51,90 @@ export function suggestEdits(graph, target, opts = {}) {
         if (!probe.applied)
             continue;
         const delta = measure(probe.graph).map((x, i) => x - base[i]);
-        const score = delta.reduce((s, x, i) => s + x * t[i], 0);
+        const steer = steerOf(probe.graph);
         suggestions.push({
             ruleId,
             elementId: v.element_id,
             message: v.message,
             fixHint: v.fix_hint,
             delta,
-            score,
+            score: baseSteer.score - steer.score,
+            steer,
+            removesElements: probe.graph.elements.length < graph.elements.length,
             edit: fixFor(v, graph) ?? undefined,
         });
     }
-    suggestions.sort((a, b) => b.score - a.score || a.ruleId.localeCompare(b.ruleId));
+    // CR-SM-302 — die Regel, deren KLASSE nicht reicht. `CLASS_MAP` ist je `rule_id`; R-18
+    // meldet vier Beine, und drei davon (illegales Paar, Kardinalitaets-Obergrenze,
+    // compose-Baum) heilt nur ein Loeschen — deshalb steht die Regel dort zu Recht als
+    // `Constraint`. Das vierte Bein ist das Gegenteil: es fehlt genau EINE Kante, deren Typ und
+    // Zieltyp das Meta-Modell vorgibt. Trennen kann das nicht die Klasse, sondern nur das
+    // TEMPLATE — es liefert genau dort einen Edit und sonst `null`.
+    //
+    // Deshalb ist hier der gelieferte Edit das Kriterium, und Δm kommt aus IHM statt aus der
+    // generischen Sonde: dieselbe Linie wie der Merge-Operator unten und wie CR-GC-431
+    // ("gerankt wird, was ausgeliefert wird"). Die Sonde ist fuer eine Constraint-Regel
+    // 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')
+            continue;
+        const edit = fixFor(v, graph);
+        if (!edit || edit.op !== 'add-trace')
+            continue;
+        const kept = edit.retire
+            ? graph.traces.filter((t) => !(t.source === edit.retire.source && t.target === edit.retire.target && t.type === edit.retire.type))
+            : graph.traces;
+        const after = {
+            ...graph,
+            traces: [...kept, { source: edit.source, target: edit.target, type: edit.type }],
+        };
+        const steer = steerOf(after);
+        suggestions.push({
+            ruleId,
+            elementId: v.element_id,
+            message: v.message,
+            fixHint: v.fix_hint,
+            delta: measure(after).map((x, i) => x - base[i]),
+            score: baseSteer.score - steer.score,
+            steer,
+            removesElements: false,
+            edit,
+        });
+    }
+    // CR-GC-444 — der KONSOLIDIERUNGS-Operator, die eine Quelle ohne Violation.
+    // Ein Merge repariert keine Regel (deshalb kein Fund, deshalb `MERGE_OPERATOR_ID`
+    // statt einer erfundenen Regel-ID) — er legt zwei Knoten zusammen, die denselben
+    // Vertrag tragen, und bewegt damit die Metrik. Δm kommt hier NICHT aus der
+    // generischen `applyRule`-Sonde, sondern aus dem echten In-Memory-Merge: das
+    // Δm des Zuges, der auch ausgeliefert wird.
+    for (const edit of mergeCandidates(graph)) {
+        const merged = applyMergeEdit(graph, edit);
+        const delta = measure(merged).map((x, i) => x - base[i]);
+        const steer = steerOf(merged);
+        suggestions.push({
+            ruleId: MERGE_OPERATOR_ID,
+            elementId: edit.source,
+            message: edit.rationale,
+            fixHint: 'Als EIN graph_mutate-Batch anwenden: merge-nodes(source→target) plus die gekoppelten ' +
+                '`merges` — getrennt weist das Gate den FLOW-Merge über R-18 ab (FLOW -relation-> SCHEMA ist 1..1).',
+            delta,
+            score: baseSteer.score - steer.score,
+            steer,
+            // Ein Merge entfernt per Definition einen Knoten. Die Sperre (CR-SM-291 §7.2 Grenze 1)
+            // trifft ihn damit bewusst: er bleibt Kandidat, rankt aber nie über einem Zug, der
+            // nichts wegnimmt.
+            removesElements: true,
+            edit,
+        });
+    }
+    // Tiebreak bis auf elementId: seit dem Konsolidierungs-Operator kann DIESELBE
+    // Kennung mehrfach vorkommen, und eine stabile Ordnung ist Teil des Vertrags.
+    // `beatsBySteer` trägt die Zerstörungs-Sperre und den Score; die Kennungen sind der
+    // Determinismus-Anker.
+    const asCandidate = (x) => ({ score: x.steer, removesElements: x.removesElements });
+    suggestions.sort((a, b) => beatsBySteer(asCandidate(a), asCandidate(b)) ||
+        a.ruleId.localeCompare(b.ruleId) ||
+        a.elementId.localeCompare(b.elementId));
     return Number.isFinite(k) ? suggestions.slice(0, k) : suggestions;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/se-engine",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,9 +42,9 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@sigloch/contracts": ">=5 <10"
+    "@sigloch/contracts": ">=10 <11"
   },
   "devDependencies": {
-    "@sigloch/contracts": ">=6 <10"
+    "@sigloch/contracts": ">=10 <11"
   }
 }