@sigloch/se-engine 1.2.0 → 1.4.0

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.2.0",
+  "version": "1.4.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,9 +42,9 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@sigloch/contracts": ">=5 <7"
+    "@sigloch/contracts": ">=10 <11"
   },
   "devDependencies": {
-    "@sigloch/contracts": "^6.0.0"
+    "@sigloch/contracts": ">=10 <11"
   }
 }