@sigloch/se-engine 1.2.0 → 1.4.0

package/dist/readiness-compute.d.ts

@@ -4,7 +4,7 @@
  * Relocated from aimpro (learning-engine/graph/readiness.ts) into @sigloch/se-engine (CR-SM-248).
  */
 import type { OntologyGraph, MetricPolicy } from '@sigloch/contracts/se';
-import { type ReadinessReportType } from '@sigloch/contracts/se';
+import { type ReadinessDimensionType, type ReadinessReportType } from '@sigloch/contracts/se';
 /**
  * Compute readiness report from the current graph state.
  *
@@ -25,3 +25,37 @@ import { type ReadinessReportType } from '@sigloch/contracts/se';
  * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
  */
 export declare function computeReadiness(graph: OntologyGraph, policy: MetricPolicy, readyThreshold: number): ReadinessReportType;
+/**
+ * CR-146 / CR-SM-235: Anzahl anwendbarer Pruefungen je Dimension.
+ *
+ * `applicable = Σ (Elemente der Grundgesamtheit)` ueber die Regeln der Dimension. Die
+ * Grundgesamtheit steht seit CR-SM-235 an der Regel selbst (`ALL_RULE_DEFS[].domain`) —
+ * vorher lag hier eine Handtabelle `RULE_ELEMENT_TYPE`, in der **18 von 71 Regeln** fehlten.
+ * Deren Verstoesse erhoehten den Zaehler, nie den Nenner; auf graph-view-edit waren das 38
+ * von 415 Verstoessen. Jede neue Regel senkte den Score automatisch, bis jemand die zweite
+ * Tabelle nachzog, und kein Test erzwang das.
+ *
+ * Eine Regel mit mehreren Typen (RD-04: FUNC, MOD, SYS) traegt deren Summe bei — dieselben
+ * Elemente, die sie auch pruefen kann.
+ */
+/**
+ * CR-SM-270: die KERNMENGE je Dimension — die Elemente der Typen, um die es der Dimension
+ * wirklich geht.
+ *
+ * Der Anlass, gemessen: `moneyflow` ist ein reiner Code-Import (0 UC, 0 FCHAIN, 0 ACTOR,
+ * 306 FUNC) und meldete `uc: 0,997, ready: true`. Von den 15 uc-Regeln haben dreizehn eine
+ * leere Grundgesamtheit — sie schweigen mangels Gegenstand —, R-17 traegt 1 (SYS) und FC-03
+ * traegt 306 (FUNC). 99,7 % des Nenners kamen also aus EINER Fremdtyp-Regel, und das Schweigen
+ * der dreizehn las sich als Erfolg. Je mehr importierte FUNCs ein Repo ohne Wozu-Ebene hat,
+ * desto besser sah seine uc-Readiness aus — der Score zeigte in die falsche Richtung, und
+ * `dimension_readiness` ist Steuergroesse fuer `graph_next_step`.
+ *
+ * ABGELEITET, nicht deklariert: der Kern sind die Typen, die die MEHRHEIT der Dimensionsregeln
+ * prueft. Eine zweite Tabelle neben `RULE_TO_DIMENSION` waere ein zweiter Speicher derselben
+ * Wahrheit und liefe auseinander, sobald jemand nur eine von beiden pflegt — genau der Defekt,
+ * den CR-SM-235 hier schon einmal beseitigt hat (`RULE_ELEMENT_TYPE`, 18 von 71 Regeln
+ * fehlten). Ein Attribut waere zusaetzlich eine Selbstauskunft (abgelehnt in CR-SM-263).
+ *
+ * Graph-Regeln zaehlen auch hier nicht mit: sie haben keine Gruppe (CR-SM-239).
+ */
+export declare function coreTypesOf(dim: ReadinessDimensionType): string[];

package/dist/readiness-compute.js

@@ -43,7 +43,8 @@ export function computeReadiness(graph, policy, readyThreshold) {
     // Die Verstoesse sind nicht verloren: sie stehen im Regelstrom und auf der Gate-Achse.
     const graphLevelRules = new Set(ALL_RULE_DEFS.filter(d => d.domain.includes('graph')).map(d => d.id));
     // Count elements by type — used for applicable counts AND phase gate checks
-    const els = graph.elements.filter(e => e.type !== 'SESSION');
+    // CR-SM-266 D5: kein SESSION-Ausschluss mehr — den Elementtyp gibt es nicht.
+    const els = graph.elements;
     const countByType = {};
     for (const e of els) {
         countByType[e.type] = (countByType[e.type] ?? 0) + 1;
@@ -59,16 +60,31 @@ export function computeReadiness(graph, policy, readyThreshold) {
             continue;
         violationsByDim.get(dim).push(v);
     }
+    const coreCounts = computeCoreApplicable(countByType);
     const scores = ReadinessDimension.options.map(dim => {
         const violations = violationsByDim.get(dim).length;
         const applicable = applicableCounts[dim];
-        const score = applicable === 0 ? 0.0 : Math.max(0, 1 - violations / applicable);
+        const coreApplicable = coreCounts[dim];
+        // CR-SM-270: der Interpretierbarkeits-Waechter VOR der Rechnung. Ist die Kernmenge leer,
+        // wird nicht gerechnet — `null`, nicht 0,997 und nicht 0,0. Der Nenner selbst bleibt
+        // unangetastet: wo die Kernmenge da ist, zaehlen die Fremdtyp-Beitraege weiter mit.
+        //
+        // Die Reihenfolge ist Absicht: `applicable === 0` behaelt seine 0,0. Der Fall ist mit
+        // demselben Argument angreifbar ("nichts zu pruefen ist nicht 0 %"), aber CR-SM-270
+        // verlangt ihn ausdruecklich UNVERAENDERT, und ein stiller Mitnahmeeffekt waere hier die
+        // schlechtere Wahl als eine eigene Entscheidung dazu. Der Waechter greift also nur im
+        // wirklich neuen Fall: Kernmenge leer, Fremdtyp-Menge gross.
+        const score = applicable === 0 ? 0.0
+            : coreApplicable === 0 ? null
+                : Math.max(0, 1 - violations / applicable);
         return {
             dimension: dim,
-            score: Math.round(score * 1000) / 1000, // 3 decimal precision
+            score: score === null ? null : Math.round(score * 1000) / 1000, // 3 decimal precision
             violations,
             applicable,
-            ready: score >= readyThreshold,
+            coreApplicable,
+            // Nicht messbar ist nicht bereit — nie `true` bei `null`.
+            ready: score !== null && score >= readyThreshold,
         };
     });
     // CR-SM-237: `overallScore` faellt — das ungewichtete Mittel dieser Scores, von keinem
@@ -94,6 +110,51 @@ export function computeReadiness(graph, policy, readyThreshold) {
  * Eine Regel mit mehreren Typen (RD-04: FUNC, MOD, SYS) traegt deren Summe bei — dieselben
  * Elemente, die sie auch pruefen kann.
  */
+/**
+ * CR-SM-270: die KERNMENGE je Dimension — die Elemente der Typen, um die es der Dimension
+ * wirklich geht.
+ *
+ * Der Anlass, gemessen: `moneyflow` ist ein reiner Code-Import (0 UC, 0 FCHAIN, 0 ACTOR,
+ * 306 FUNC) und meldete `uc: 0,997, ready: true`. Von den 15 uc-Regeln haben dreizehn eine
+ * leere Grundgesamtheit — sie schweigen mangels Gegenstand —, R-17 traegt 1 (SYS) und FC-03
+ * traegt 306 (FUNC). 99,7 % des Nenners kamen also aus EINER Fremdtyp-Regel, und das Schweigen
+ * der dreizehn las sich als Erfolg. Je mehr importierte FUNCs ein Repo ohne Wozu-Ebene hat,
+ * desto besser sah seine uc-Readiness aus — der Score zeigte in die falsche Richtung, und
+ * `dimension_readiness` ist Steuergroesse fuer `graph_next_step`.
+ *
+ * ABGELEITET, nicht deklariert: der Kern sind die Typen, die die MEHRHEIT der Dimensionsregeln
+ * prueft. Eine zweite Tabelle neben `RULE_TO_DIMENSION` waere ein zweiter Speicher derselben
+ * Wahrheit und liefe auseinander, sobald jemand nur eine von beiden pflegt — genau der Defekt,
+ * den CR-SM-235 hier schon einmal beseitigt hat (`RULE_ELEMENT_TYPE`, 18 von 71 Regeln
+ * fehlten). Ein Attribut waere zusaetzlich eine Selbstauskunft (abgelehnt in CR-SM-263).
+ *
+ * Graph-Regeln zaehlen auch hier nicht mit: sie haben keine Gruppe (CR-SM-239).
+ */
+export function coreTypesOf(dim) {
+    const defs = ALL_RULE_DEFS.filter(d => RULE_TO_DIMENSION[d.id] === dim && !d.domain.includes('graph'));
+    if (defs.length === 0)
+        return [];
+    const seenIn = {};
+    for (const d of defs) {
+        // Ein Typ zaehlt EINMAL je Regel, auch wenn die Regel mehrere Typen prueft (RD-04).
+        for (const type of new Set(d.domain))
+            seenIn[type] = (seenIn[type] ?? 0) + 1;
+    }
+    const majority = defs.length / 2;
+    const core = Object.keys(seenIn).filter(type => seenIn[type] > majority).sort();
+    // Keine Mehrheit ableitbar (die Regeln verteilen sich gleichmaessig ueber mehrere Typen):
+    // dann ist der Kern ALLES, was die Dimension prueft. Der Waechter greift damit nur noch,
+    // wenn auch `applicable` 0 waere — das Verhalten bleibt exakt wie vor CR-SM-270. Lieber
+    // nicht greifen als am falschen Ort greifen.
+    return core.length > 0 ? core : [...new Set(defs.flatMap(d => d.domain))].sort();
+}
+function computeCoreApplicable(countByType) {
+    const result = {};
+    for (const dim of ReadinessDimension.options) {
+        result[dim] = coreTypesOf(dim).reduce((sum, type) => sum + (countByType[type] ?? 0), 0);
+    }
+    return result;
+}
 function computeApplicable(countByType) {
     const result = {};
     for (const dim of ReadinessDimension.options) {

package/dist/rule-apply.js

@@ -65,6 +65,10 @@ export function applyRule(rule, graph, knownViolations) {
     // elements' stored types (isValidTrace) and (b) links two currently-
     // unconnected nodes, so it genuinely moves the topology.
     const typeById = new Map(graph.elements.map((e) => [e.id, e.type]));
+    // CR-SM-266 B: die where-Patterns lesen die Kinds des Zielknotens mit. Ohne sie wuerde
+    // `isValidTrace` jede satisfy-Kante ablehnen und der Operator griffe stumm auf einen anderen
+    // Kantentyp aus — ein falscher Vorschlag statt keinem.
+    const kindsById = new Map(graph.elements.map((e) => [e.id, e.kinds]));
     const v = violations[0];
     const source = v.element_id;
     const srcType = typeById.get(source);
@@ -94,7 +98,10 @@ export function applyRule(rule, graph, knownViolations) {
                 [source, srcType, partner, tgtType],
                 [partner, tgtType, source, srcType],
             ]) {
-                if (isValidTrace({ source: sType, target: tType, type: tt })) {
+                if (isValidTrace({
+                    source: sType, target: tType, type: tt,
+                    sourceKinds: kindsById.get(s), targetKinds: kindsById.get(t),
+                })) {
                     return { graph: addTrace(graph, s, t, tt), applied: true, op: `+ ${s} -${tt}-> ${t}` };
                 }
             }
@@ -120,7 +127,8 @@ export function markEmptyDelta(graph, measure) {
     });
 }
 /** Trace types the meta-model accepts (ontology TraceType enum). */
-const TRACE_KEYWORDS = ['verify', 'satisfy', 'allocate', 'compose', 'produces', 'io', 'relation'];
+// CR-SM-266 D5: `produces` entfaellt — der TraceType existiert nicht mehr.
+const TRACE_KEYWORDS = ['verify', 'satisfy', 'allocate', 'compose', 'io', 'relation'];
 /**
  * Best-effort trace type from the violation's fix_hint (topology-only — the
  * exact type does not affect `metrics`, but a plausible one keeps the edit

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,7 +122,6 @@ 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 },
 };

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[];