@sigloch/se-engine 1.2.0 → 1.4.0

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