@sigloch/contracts 9.1.0 → 10.0.0

package/dist/se/ao-rules.d.ts

@@ -6,20 +6,20 @@ import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
 import type { MetricPolicy } from './policy.js';
 /**
- * AO-D01: Relay Node Detection.
- * A FUNC is a relay if it (a) satisfies no REQ, (b) has >=2 outgoing io to FUNCs,
- * and (c) target FUNCs share SCHEMA overlap >= 0.5 (via ND-02 matrix, skipped if unavailable).
+ * CR-SM-283: **AO-D03 (`DuplicatePathDetection`) ist ersatzlos entfallen.**
+ *
+ * Die Regel suchte `FUNC -io-> FUNC` — ein Paar, das `TRACE_PATTERNS` nicht kennt und das R-18
+ * als `error` ablehnt. Sie konnte STRUKTURELL nicht feuern und hat es an keinem Familiengraphen
+ * je getan (Gate 7: 0 Befunde ueber fuenf Graphen). Eine Regel, die nie feuert, kostet trotzdem
+ * dauerhaft: einen Nenner-Anteil, eine Katalogzeile, eine readiness-Zuordnung, einen
+ * Golden-File-Eintrag und einen Leser, der sie von den anderen unterscheiden muss.
+ *
+ * **Nicht verwechseln:** die Aufgabe, die sie tragen sollte — zwei Wirkketten, die auf einer
+ * Ebene mitgliedsgleich werden — bleibt ungeloest (`se:top-level`: „Compare the member sets
+ * yourself — no rule does it for you"). BW-02 ersetzt sie nicht; das ist ein eigener CR.
  */
-export declare function aoD01RelayNode(graph: OntologyGraph): RuleViolation[];
-/**
- * AO-D03: Duplicate Path Detection.
- * FUNC A sends io to both B and C, where B and C connect to the same SCHEMA elements.
- */
-export declare function aoD03DuplicatePath(graph: OntologyGraph): RuleViolation[];
+export declare function bw02WhiteboxWidth(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];
 export declare function cr01CrossingFlowCount(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];
-export declare function rt01PhysicalBoundaryIntegrity(graph: OntologyGraph): RuleViolation[];
-export declare function ph01PhysicalModCompleteness(graph: OntologyGraph): RuleViolation[];
-export declare function ca01CapabilityAllocation(graph: OntologyGraph): RuleViolation[];
 export declare function io01CrossModuleCompleteness(graph: OntologyGraph): RuleViolation[];
 export declare const AO_RULES: RuleDefinition[];
 export declare function evaluateAORules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/ao-rules.js

@@ -1,42 +1,6 @@
-import { getND02SimilarityMatrix } from './near-duplicate-rules.js';
 import { indexOf } from './graph-index.js';
+import { moduleCrossings } from './module-crossings.js';
 const SCHEMA_OVERLAP_THRESHOLD = 0.5;
-/**
- * AO-D01: Relay Node Detection.
- * A FUNC is a relay if it (a) satisfies no REQ, (b) has >=2 outgoing io to FUNCs,
- * and (c) target FUNCs share SCHEMA overlap >= 0.5 (via ND-02 matrix, skipped if unavailable).
- */
-export function aoD01RelayNode(graph) {
-    const idx = indexOf(graph);
-    const violations = [];
-    const funcs = idx.elementsOfType('FUNC');
-    const funcIdSet = new Set(funcs.map(f => f.id));
-    for (const func of funcs) {
-        // (a) No satisfy traces (FUNC as source) connecting to any REQ
-        const hasSatisfy = graph.traces.some(t => t.type === 'satisfy' &&
-            t.source === func.id && idx.typeOf(t.target) === 'REQ');
-        if (hasSatisfy)
-            continue;
-        // (b) >=2 outgoing io traces to other FUNCs
-        const ioTargets = graph.traces
-            .filter(t => t.type === 'io' && t.source === func.id && funcIdSet.has(t.target))
-            .map(t => t.target);
-        if (ioTargets.length < 2)
-            continue;
-        // (c) Target FUNCs share SCHEMA overlap >= 0.5 (skip check if no matrix)
-        if (!passesSchemaOverlap(graph, ioTargets))
-            continue;
-        const el = idx.byId.get(func.id);
-        violations.push({
-            rule_id: 'AO-D01',
-            severity: 'info',
-            element_id: func.id,
-            message: `${func.id}${el?.name ? ' (' + el.name + ')' : ''} is a relay node: no REQ satisfied, ${ioTargets.length} io targets`,
-            fix_hint: 'Consider eliminating relay by connecting consumers directly to producer',
-        });
-    }
-    return violations;
-}
 /** CR-165: Resolve FUNC→SCHEMA via FUNC→FLOW(io) + FLOW→SCHEMA(relation). */
 function funcToSchemas(graph, funcId) {
     const idx = indexOf(graph);
@@ -44,7 +8,7 @@ function funcToSchemas(graph, funcId) {
     // Find FLOWs connected to this FUNC via io (FUNC→FLOW or FLOW→FUNC)
     //
     // CR-SM-264: die io-Kanten dieser FUNC statt zweier Vollscans ueber ALLE Traces je FUNC
-    // (`F x T`) — AO-D03 ruft diese Funktion einmal je FUNC. Die Reihenfolge von `flowIds` ist
+    // (`F x T`) — AO-D01 ruft diese Funktion einmal je FUNC. Die Reihenfolge von `flowIds` ist
     // dabei egal, die Menge wird nur auf Mitgliedschaft geprueft.
     const flowIds = new Set();
     for (const t of idx.out(funcId, 'io'))
@@ -56,7 +20,7 @@ function funcToSchemas(graph, funcId) {
     // Find SCHEMAs connected to those FLOWs via relation.
     //
     // Hier NICHT ueber `flowIds` iterieren, obwohl das billiger waere: die Einfuegereihenfolge
-    // dieser Menge landet ueber `shared.join(', ')` woertlich in der AO-D03-Meldung. Der Lauf
+    // dieser Menge landet ueber `shared.join(', ')` woertlich in der AO-D01-Meldung. Der Lauf
     // ueber die relation-Kanten in Graph-Reihenfolge haelt sie identisch — und ist trotzdem
     // deutlich kuerzer als der Vollscan, weil er nur einen Kantentyp sieht.
     for (const t of idx.tracesOfType('relation')) {
@@ -65,124 +29,101 @@ function funcToSchemas(graph, funcId) {
     }
     return schemas;
 }
-/** Check if any pair of target FUNCs shares SCHEMA overlap via FLOW→SCHEMA(relation) + ND-02 matrix. */
-function passesSchemaOverlap(graph, targetFuncIds) {
-    const idx = indexOf(graph);
-    const nd02 = getND02SimilarityMatrix();
-    if (!nd02)
-        return true; // no matrix → skip check, assume pass
-    // For each target FUNC, collect connected SCHEMA ids via FLOW→SCHEMA(relation)
-    const funcSchemasMap = new Map();
-    for (const fid of targetFuncIds) {
-        funcSchemasMap.set(fid, funcToSchemas(graph, fid));
-    }
-    // Check pairwise: any pair of target FUNCs with overlapping SCHEMAs (similarity >= threshold)
-    const { schemaIds, matrix } = nd02;
-    const idxOf = new Map(schemaIds.map((id, i) => [id, i]));
-    for (let i = 0; i < targetFuncIds.length; i++) {
-        for (let j = i + 1; j < targetFuncIds.length; j++) {
-            const si = funcSchemasMap.get(targetFuncIds[i]);
-            const sj = funcSchemasMap.get(targetFuncIds[j]);
-            for (const a of si) {
-                for (const b of sj) {
-                    const ai = idxOf.get(a), bi = idxOf.get(b);
-                    if (ai !== undefined && bi !== undefined && matrix[ai][bi] >= SCHEMA_OVERLAP_THRESHOLD)
-                        return true;
-                    if (a === b)
-                        return true; // same SCHEMA = 100% overlap
-                }
-            }
-        }
-    }
-    return false;
-}
 /**
- * AO-D03: Duplicate Path Detection.
- * FUNC A sends io to both B and C, where B and C connect to the same SCHEMA elements.
+ * CR-SM-283: **AO-D03 (`DuplicatePathDetection`) ist ersatzlos entfallen.**
+ *
+ * Die Regel suchte `FUNC -io-> FUNC` — ein Paar, das `TRACE_PATTERNS` nicht kennt und das R-18
+ * als `error` ablehnt. Sie konnte STRUKTURELL nicht feuern und hat es an keinem Familiengraphen
+ * je getan (Gate 7: 0 Befunde ueber fuenf Graphen). Eine Regel, die nie feuert, kostet trotzdem
+ * dauerhaft: einen Nenner-Anteil, eine Katalogzeile, eine readiness-Zuordnung, einen
+ * Golden-File-Eintrag und einen Leser, der sie von den anderen unterscheiden muss.
+ *
+ * **Nicht verwechseln:** die Aufgabe, die sie tragen sollte — zwei Wirkketten, die auf einer
+ * Ebene mitgliedsgleich werden — bleibt ungeloest (`se:top-level`: „Compare the member sets
+ * yourself — no rule does it for you"). BW-02 ersetzt sie nicht; das ist ein eigener CR.
  */
-export function aoD03DuplicatePath(graph) {
+// ---------------------------------------------------------------------------
+// BW-02: Randbreite der FUNC-Whitebox (CR-SM-283)
+//
+// Die Zahl der VERSCHIEDENEN Vertraege, die den Rand einer zerlegten FUNC queren — dieselbe
+// Zaehlbasis wie CR-01/R-04 (SCHEMA, nicht rohe io-Kanten, CR-SM-274/276), nur ist die
+// Innen-Menge der `compose`-Teilbaum statt des Modul-Teilbaums. Gerechnet im selben Durchlauf
+// wie `byModule` (`module-crossings.ts`), damit es EINE Definition von „Rand" gibt.
+//
+// Warum es die Regel ueberhaupt braucht: eine zerlegte FUNC ist die Whitebox, in die der Leser
+// hineinklickt. Ihre Randbreite entscheidet, ob er den Ueberblick behaelt — und bis hierher
+// misst sie NIEMAND. AO-D01 misst Relay-Knoten, IO-01 die Kettenkohaerenz, R-31 die blosse
+// Verdrahtung. Gemessen: 12 Befunde an graphcode, davon 0 in Ueberlappung mit irgendeiner
+// FUNC-Regel (Gate 6).
+//
+// Schwelle aus der Verteilung, nicht gewaehlt: bok und graph-view-edit enden beide bei 3,
+// graphcode geht bis 19, moneyflow bis 17. Kein `info`-Level — bei Schwelle 3 truege bok 4 von
+// 9 Blackboxes, und `readiness` zaehlt `info` ungefiltert in den Nenner (MT-03-Praezedenz).
+// ---------------------------------------------------------------------------
+export function bw02WhiteboxWidth(graph, policy) {
+    const steps = policy.boundaryWidth;
+    if (steps === null)
+        return [];
     const idx = indexOf(graph);
     const violations = [];
-    const funcs = idx.elementsOfType('FUNC');
-    const funcIdSet = new Set(funcs.map(f => f.id));
-    const seen = new Set();
-    // Pre-compute: FUNC → set of SCHEMA targets via FLOW→SCHEMA(relation) (CR-165)
-    const funcToSchemasMap = new Map();
-    for (const f of funcs) {
-        funcToSchemasMap.set(f.id, funcToSchemas(graph, f.id));
-    }
-    for (const a of funcs) {
-        const ioTargets = graph.traces
-            .filter(t => t.type === 'io' && t.source === a.id && funcIdSet.has(t.target))
-            .map(t => t.target);
-        if (ioTargets.length < 2)
+    for (const [funcId, contracts] of moduleCrossings(graph).byFunc) {
+        if (contracts.size < steps.warning)
             continue;
-        for (let i = 0; i < ioTargets.length; i++) {
-            for (let j = i + 1; j < ioTargets.length; j++) {
-                const b = ioTargets[i], c = ioTargets[j];
-                const key = [a.id, b, c].sort().join(':');
-                if (seen.has(key))
-                    continue;
-                const sb = funcToSchemasMap.get(b) ?? new Set();
-                const sc = funcToSchemasMap.get(c) ?? new Set();
-                const shared = [...sb].filter(s => sc.has(s));
-                if (shared.length === 0)
-                    continue;
-                seen.add(key);
-                violations.push({
-                    rule_id: 'AO-D03',
-                    severity: 'info',
-                    element_id: a.id,
-                    message: `${a.id} sends io to ${b} and ${c} which share ${shared.length} SCHEMA target(s): ${shared.join(', ')}`,
-                    fix_hint: 'Consider introducing a mediator or unifying the data paths',
-                });
-            }
-        }
+        const el = idx.byId.get(funcId);
+        violations.push({
+            rule_id: 'BW-02',
+            severity: 'warning',
+            element_id: funcId,
+            message: `${funcId} exposes ${contracts.size} distinct contract(s) at its whitebox boundary (>= ${steps.warning})`,
+            fix_hint: 'Consolidate the contracts crossing this boundary, or introduce a level so fewer of them are visible at once',
+            // CR-SM-288: `>= steps.warning` ist inklusiv, also ist `steps.warning - 1` der groesste
+            // Wert, der noch im Budget liegt — die Masse `value - threshold` ist damit > 0 fuer jeden
+            // Befund dieser Regel.
+            context: { element_type: el?.type, element_name: el?.name, value: contracts.size, threshold: steps.warning - 1 },
+        });
     }
-    return violations;
+    // Die Einfuegereihenfolge von `byFunc` folgt der FLOW-Reihenfolge des Graphen — hier wird sie
+    // kanonisch gemacht, sonst haengt die Befund-Sequenz an der Trace-Reihenfolge (Gate 5).
+    return violations.sort((a, b) => (a.element_id < b.element_id ? -1 : a.element_id > b.element_id ? 1 : 0));
 }
 // ---------------------------------------------------------------------------
 // CR-01: Crossing Flow Count (CR-191)
-// For each module pair (A, B): count io paths FUNC_A → FUNC_B
+// Je Modulpaar (A, B): die VERSCHIEDENEN Vertraege, die den Rand queren — der io-Pfad
+// `FUNC_A -io-> FLOW -io-> FUNC_B` mit FUNC_A in A und FUNC_B in B, gezaehlt ueber das
+// SCHEMA des FLOW.
 //
 // CR-SM-236: die Schwelle ist Eingabe. `policy.crossingFlows === null` heisst messen statt
 // urteilen — die Regel schweigt dann vollstaendig, auch unterhalb der Schwelle. Vorher gab es
 // diesen Aus-Zustand nicht: jedes Modulpaar mit >= 1 Kreuzung erzeugte eine info-Meldung.
+//
+// CR-SM-274 (Befund aus Spike CR-GC-438 §6): die Regel suchte direkte `FUNC -io-> FUNC`-Kanten.
+// `TRACE_PATTERNS` kennt fuer `io` nur `ACTOR<->FLOW` und `FUNC<->FLOW` — R-18 lehnt eine
+// FUNC->FUNC-io-Kante ab, die Regel konnte STRUKTURELL nicht feuern und tat es in keinem der
+// 10 gemessenen Familie-Graphen (0 Befunde), waehrend ihre Schwelle in der MetricPolicy
+// gepflegt wurde. Jetzt laeuft sie den Pfad, den ihr Kopf meint.
+//
+// Zaehlbasis = SCHEMA, nicht Einzelquerung. Begruendung (CR-SM-274):
+//  1. Modul-Kopplung ist die Zahl der Vertraege, auf die sich zwei Module einigen muessen.
+//     Ein FLOW mit 3 Produzenten und 3 Konsumenten ist EIN Vertrag, nicht 9 Kopplungen —
+//     der Fix-Hint ("Mediator einziehen") greift je Vertrag, nicht je Konsument.
+//  2. Die rohe Produzent-x-Konsument-Zaehlung ist hub-empfindlich und durch FLOW-Splitting
+//     manipulierbar (CR-436 Befund 3: X 172 -> 1539 durch einen Merge ohne Code-Kopplung).
+//     SCHEMA ist die Zaehlbasis, die der Spike als gaming-fest gemessen hat (Kill 2).
+//  3. `FLOW -relation-> SCHEMA` ist seit CR-SM-271 Teil 2 `1..1` und per R-18 erzwungen —
+//     die Zaehlbasis ist damit garantiert vorhanden, kein optionales Feld.
+// Ein FLOW ohne SCHEMA zaehlt als eigener, untypisierter Vertrag (R-18 meldet ihn separat);
+// er darf nicht stillschweigend mit anderen verschmelzen.
+//
+// CR-SM-276: die Traversierung steht in `module-crossings.ts` — dieselbe Definition von
+// „Kreuzung" fuer CR-01 (je Modulpaar) und R-04 (je Modul). Zwei Kopien waeren zwei Begriffe.
 // ---------------------------------------------------------------------------
 export function cr01CrossingFlowCount(graph, policy) {
-    const idx = indexOf(graph);
     const violations = [];
     const steps = policy.crossingFlows;
     if (steps === null)
         return violations;
-    const mods = idx.elementsOfType('MOD');
-    // Build MOD → Set<FUNC-id> mapping
-    const modFuncs = new Map();
-    for (const mod of mods) {
-        const funcIds = new Set(idx.in(mod.id, 'allocate').map(t => t.source));
-        modFuncs.set(mod.id, funcIds);
-    }
-    // Count crossings per module pair
-    const pairCounts = new Map();
-    for (const t of graph.traces) {
-        if (t.type !== 'io')
-            continue;
-        let srcMod;
-        let tgtMod;
-        for (const [mid, fids] of modFuncs) {
-            if (fids.has(t.source))
-                srcMod = mid;
-            if (fids.has(t.target))
-                tgtMod = mid;
-        }
-        if (!srcMod || !tgtMod || srcMod === tgtMod)
-            continue;
-        const key = [srcMod, tgtMod].sort().join('::');
-        if (!pairCounts.has(key))
-            pairCounts.set(key, { modA: srcMod, modB: tgtMod, count: 0 });
-        pairCounts.get(key).count++;
-    }
-    for (const { modA, modB, count } of pairCounts.values()) {
+    for (const { modA, modB, contracts } of moduleCrossings(graph).pairs.values()) {
+        const count = contracts.size;
         if (count <= 0)
             continue;
         const over = count >= steps.warning;
@@ -190,93 +131,19 @@ export function cr01CrossingFlowCount(graph, policy) {
             rule_id: 'CR-01',
             severity: over ? 'warning' : 'info',
             element_id: modA,
-            message: `${modA} ↔ ${modB}: ${count} crossing io flow(s)`,
-            fix_hint: over ? 'Reduce coupling between modules or introduce a mediator' : 'Consider if coupling is intentional',
+            message: `${modA} ↔ ${modB}: ${count} distinct contract(s) crossing the module boundary (io path FUNC→FLOW→FUNC)`,
+            fix_hint: over
+                ? `Reduce coupling between modules or introduce a mediator (>= ${steps.warning} distinct contracts at one boundary)`
+                : 'Consider if coupling is intentional',
+            // CR-SM-288: dasselbe Budget fuer beide Severities. Ein `info`-Paar liegt per Konstruktion
+            // INNERHALB des Budgets und traegt damit die Masse 0 — es ist kein kleiner Verstoss,
+            // sondern keiner.
+            context: { value: count, threshold: steps.warning - 1 },
         });
     }
     return violations;
 }
 // ---------------------------------------------------------------------------
-// RT-01: Physical boundary integrity (CR-191)
-// FUNCs must not be allocated directly to physical MODs — use logical sub-modules.
-// ---------------------------------------------------------------------------
-export function rt01PhysicalBoundaryIntegrity(graph) {
-    const idx = indexOf(graph);
-    const physicalMods = graph.elements.filter(e => e.type === 'MOD' && e.attributes?.kind === 'physical');
-    return graph.traces
-        .filter(t => t.type === 'allocate' && physicalMods.some(m => m.id === t.target))
-        .filter(t => idx.typeOf(t.source) === 'FUNC')
-        .map(t => ({
-        rule_id: 'RT-01',
-        severity: 'error',
-        element_id: t.source,
-        message: `${t.source} allocated directly to physical module ${t.target} — must use logical sub-module`,
-        fix_hint: 'Create a logical MOD inside the physical MOD and allocate the FUNC there',
-    }));
-}
-// ---------------------------------------------------------------------------
-// PH-01: Physical MOD completeness (CR-191)
-// Physical MODs should have at least one logical sub-module via compose trace.
-// ---------------------------------------------------------------------------
-export function ph01PhysicalModCompleteness(graph) {
-    const idx = indexOf(graph);
-    const physicalMods = graph.elements.filter(e => e.type === 'MOD' && e.attributes?.kind === 'physical');
-    return physicalMods
-        .filter(pm => !graph.traces.some(t => t.source === pm.id && t.type === 'compose' &&
-        idx.typeOf(t.target) === 'MOD'))
-        .map(pm => ({
-        rule_id: 'PH-01',
-        severity: 'info',
-        element_id: pm.id,
-        message: `${pm.id} (physical) has no logical sub-modules`,
-        fix_hint: 'Add at least one logical MOD via compose trace',
-        context: { element_type: pm.type, element_name: pm.name },
-    }));
-}
-// ---------------------------------------------------------------------------
-// CA-01: Capability allocation check (CR-191)
-// FUNC @requires must be satisfied by the physical MOD's @capability.
-// ---------------------------------------------------------------------------
-export function ca01CapabilityAllocation(graph) {
-    const idx = indexOf(graph);
-    const violations = [];
-    const funcsWithRequires = graph.elements.filter(e => e.type === 'FUNC' && e.attributes?.requires);
-    for (const func of funcsWithRequires) {
-        const requires = (Array.isArray(func.attributes.requires)
-            ? func.attributes.requires
-            : [func.attributes.requires]);
-        // Find logical MOD via allocate
-        const allocTrace = graph.traces.find(t => t.source === func.id && t.type === 'allocate');
-        if (!allocTrace)
-            continue;
-        const logicalModCandidate = idx.byId.get(allocTrace.target);
-        const logicalMod = logicalModCandidate?.type === 'MOD' ? logicalModCandidate : undefined;
-        if (!logicalMod)
-            continue;
-        // Find physical parent MOD (compose source → logical MOD target)
-        const physParentTrace = graph.traces.find(t => t.type === 'compose' && t.target === logicalMod.id &&
-            (idx.byId.get(t.source)?.type === 'MOD' && idx.byId.get(t.source)?.attributes?.kind === 'physical'));
-        if (!physParentTrace)
-            continue;
-        const physMod = idx.byId.get(physParentTrace.source);
-        const capabilities = (Array.isArray(physMod.attributes?.capability)
-            ? physMod.attributes.capability
-            : physMod.attributes?.capability ? [physMod.attributes.capability] : []);
-        const missing = requires.filter(r => !capabilities.includes(r));
-        if (missing.length > 0) {
-            violations.push({
-                rule_id: 'CA-01',
-                severity: 'error',
-                element_id: func.id,
-                message: `${func.id} requires [${missing.join(', ')}] but ${physMod.id} only provides [${capabilities.join(', ')}]`,
-                fix_hint: `Add missing capabilities to ${physMod.id} or move ${func.id} to a capable module`,
-                context: { element_type: func.type, element_name: func.name, parent_module: physMod.id },
-            });
-        }
-    }
-    return violations;
-}
-// ---------------------------------------------------------------------------
 // IO-01: die Wirkkette haengt zusammen (CR-192, CR-SM-226, CR-SM-250)
 //
 // Geprueft wird ERREICHBARKEIT im io-Teilgraphen der Kette, nicht Adjazenz. Bis CR-SM-250
@@ -393,12 +260,8 @@ export function io01CrossModuleCompleteness(graph) {
     return violations;
 }
 export const AO_RULES = [
-    { id: 'AO-D01', name: 'RelayNodeDetection', severity: 'info', evaluate: aoD01RelayNode, domain: ['FUNC'] },
-    { id: 'AO-D03', name: 'DuplicatePathDetection', severity: 'info', evaluate: aoD03DuplicatePath, domain: ['FUNC'] },
+    { id: 'BW-02', name: 'Whitebox boundary width', severity: 'warning', evaluate: bw02WhiteboxWidth, domain: ['FUNC'] },
     { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
-    { id: 'RT-01', name: 'PhysicalBoundaryIntegrity', severity: 'error', evaluate: rt01PhysicalBoundaryIntegrity, domain: ['FUNC'] },
-    { id: 'PH-01', name: 'PhysicalModCompleteness', severity: 'info', evaluate: ph01PhysicalModCompleteness, domain: ['MOD'] },
-    { id: 'CA-01', name: 'CapabilityAllocation', severity: 'error', evaluate: ca01CapabilityAllocation, domain: ['FUNC'] },
     // CR-SM-242: domain ist FUNC, nicht MOD — die Regel laeuft ueber FUNC-Paare in FCHAINs und
     // meldet am FUNC. Mit ['MOD'] uebertraf ihr Zaehler (21) ihren eigenen Nenner-Beitrag (10);
     // nur der Clamp verhinderte einen negativen Score.

package/dist/se/cr-quality-rules.js

@@ -1,16 +1,55 @@
 // ---------------------------------------------------------------------------
-// CR-R01: CR must have at least one outgoing relation trace
+// CR-R01: ein offener CR nennt, WAS er aendert (CR-SM-295)
+//
+// Bis hierher waren es zwei Regeln, und beide zielten daneben. CR-R01 verlangte
+// IRGENDEINE relation-Kante — und akzeptierte damit einen CR, der nur an einem
+// Meilenstein haengt: das ist ein Termin, kein Umfang. Ueber 514 CR-Knoten in 19
+// Familiengraphen feuerte sie 5-mal, waehrend 49 CRs ausschliesslich auf ein MS zeigten
+// und unbeanstandet blieben. CR-R04 verlangte umgekehrt einen FUNC — zu eng: 21 CRs
+// meldeten, und ein grosser Teil davon aendert Daten, Doku oder Konfiguration und
+// beruehrt zu Recht keine Funktion.
+//
+// Die tragende Frage ist keine von beiden, sondern: nennt dieser CR ein Element, das er
+// AENDERT? Umfang sind FUNC, MOD, SCHEMA, REQ und UC. MS ist Terminplanung und zaehlt
+// nicht — MS-03 stellt diese Frage getrennt und bleibt unberuehrt.
+//
+// Grundgesamtheit wie bei CR-R04 (CR-SM-255) — nur was noch steuerbar ist. An einem
+// geschlossenen CR ist die Frage Archaeologie: was er beruehrt hat, steht im Commit.
+//
+// Die Menge ist aber UMGEDREHT formuliert: nicht "open oder in-progress", sondern "nicht
+// abgeschlossen". Der Grund ist gemessen — im Bestand tragen CRs die Status `done` (463),
+// `open` (34), `planned` (12), `rejected` (2), `dropped` (1) und keinen (2). `planned`
+// steht in keinem Enum der Ontologie, wird aber real geschrieben; eine Positivliste haette
+// diese zwoelf CRs stillschweigend uebersprungen. Eine Regel, die durch einen ihr
+// unbekannten Statuswert stumm wird, ist von einer bestandenen Pruefung nicht zu
+// unterscheiden — dieselbe Fail-open-Klasse wie ND-01/ND-02 vor CR-SM-286.
+//
+// Ein CR ganz OHNE status ist erst recht nicht abgeschlossen.
+//
+// Gemessen vor der Umstellung: von 514 CRs tragen 54 keinen Umfangsbezug — davon sind
+// **0 offen**, 52 `done` und 2 ohne Status. Die neue Fassung feuert am Bestand also auf
+// hoechstens 2 und laesst die Historie unangetastet; ihre Wirkung beginnt beim naechsten
+// CR, der geschrieben wird.
 // ---------------------------------------------------------------------------
+/** Elementtypen, die einen Aenderungsumfang darstellen — MS gehoert bewusst nicht dazu. */
+const SCOPE_TYPES = new Set(['FUNC', 'MOD', 'SCHEMA', 'REQ', 'UC']);
+/** Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit. */
+const CLOSED_STATUS = new Set(['done', 'dropped', 'rejected']);
 function crMustTrack(graph) {
-    const crs = graph.elements.filter(e => e.type === 'CR');
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const crs = graph.elements.filter(e => {
+        if (e.type !== 'CR')
+            return false;
+        return !CLOSED_STATUS.has(String(e.attributes?.status ?? ''));
+    });
     return crs
-        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation'))
+        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' && SCOPE_TYPES.has(typeOf.get(t.target) ?? '')))
         .map(cr => ({
         rule_id: 'CR-R01',
         severity: 'error',
         element_id: cr.id,
-        message: `${cr.id} has no relation traces (tracks nothing)`,
-        fix_hint: 'Add relation traces to affected UC, REQ, FUNC, or MOD elements',
+        message: `${cr.id} names no scope (no relation to FUNC/MOD/SCHEMA/REQ/UC)`,
+        fix_hint: 'Add a relation trace to the FUNC, MOD, SCHEMA, REQ or UC this CR changes — a milestone alone is a date, not a scope',
         context: {
             element_type: cr.type,
             element_name: cr.name,
@@ -63,71 +102,50 @@ function noConcurrentMutation(graph) {
             targetToCrs.set(tgt, list);
         }
     }
-    const violations = [];
-    const seen = new Set();
-    for (const [target, crIds] of targetToCrs) {
+    // CR-SM-304 — EIN Befund je Konflikt-MENGE, aber an einem BERECHENBAREN Element.
+    //
+    // Die Ein-Befund-Regel bleibt: dieselben zwei offenen CRs, die sich an drei Knoten begegnen,
+    // sind EIN Koordinationsproblem und nicht drei (Gate 4, Doppelzaehlung). Falsch war, woher der
+    // Anker kam: `targetToCrs` folgt der TRACE-Reihenfolge, also entschied die Array-Ordnung im
+    // Graphen, welches Ziel meldet — "kein erster Treffer" ist Gate 5 woertlich, und dieselbe
+    // Klasse wie der offene R-28-Fall (CR-SM-245). Gemessen am graphcode-Selbstmodell wechselte
+    // der Befund bei umgedrehter Reihenfolge von FUNC-graph-suggest auf MS-9-generation; ein
+    // Reseed aus dem Kuzu-Store reichte, damit eine Vorher/Nachher-Bilanz bei NULL Zuegen
+    // "einen geschlossen, einen neu" meldete.
+    //
+    // Zweiter Teil desselben Defekts: das unterdrueckte Ziel wurde nicht nur nicht angekert, es
+    // wurde gar nicht genannt. Wer koordinieren soll, braucht die vollstaendige Liste — sie steht
+    // jetzt in der Meldung und als `also_affects` im Kontext.
+    const bySet = new Map();
+    for (const target of [...targetToCrs.keys()].sort()) {
+        const crIds = [...targetToCrs.get(target)].sort();
         if (crIds.length < 2)
             continue;
-        const key = crIds.sort().join(',');
-        if (seen.has(key))
-            continue;
-        seen.add(key);
+        const key = crIds.join(',');
+        bySet.set(key, [...(bySet.get(key) ?? []), target]);
+    }
+    const violations = [];
+    for (const [key, targets] of bySet) {
+        const crIds = key.split(',');
+        const [anchor, ...also] = targets;
+        const el = graph.elements.find(e => e.id === anchor);
         violations.push({
             rule_id: 'CR-R03',
             severity: 'warning',
-            element_id: target,
-            message: `${target} is tracked by ${crIds.length} open CRs: ${crIds.join(', ')}`,
+            element_id: anchor,
+            message: `${anchor} is tracked by ${crIds.length} open CRs: ${crIds.join(', ')}` +
+                (also.length > 0 ? ` — the same CRs also track ${also.join(', ')}` : ''),
             fix_hint: 'Coordinate changes to avoid merge conflicts',
             context: {
-                element_type: graph.elements.find(e => e.id === target)?.type,
-                element_name: graph.elements.find(e => e.id === target)?.name,
+                element_type: el?.type,
+                element_name: el?.name,
+                also_affects: also,
             },
         });
     }
     return violations;
 }
 // ---------------------------------------------------------------------------
-// CR-R04: an OPEN CR must have at least one relation→FUNC trace (CR-207,
-// Grundgesamtheit verengt in CR-SM-255)
-//
-// "Welche Funktionen fasst dieser CR an" ist eine PLANUNGSfrage — sie steuert, bevor
-// gebaut wird. An einem geschlossenen CR ist sie Archaeologie: was er beruehrt hat,
-// steht im Commit und im Diff, nicht im Graphen. Wer die Kanten nachtraeglich zieht,
-// raet, und erfundene Praezision ist teurer als eine fehlende Kante.
-//
-// Gemessen am graphcode-Selbstmodell (graphVersion 171): 41 meldende CRs, davon 40
-// `done` und 1 `dropped` — kein einziger offener. Die Regel feuerte ausschliesslich
-// dort, wo sie nichts mehr steuern kann, und trug damit 41 unbearbeitbare Befunde.
-//
-// Die Statusmenge ist woertlich die von CR-R03 (s. o.): dieselbe Frage nach "noch in
-// Arbeit", dieselbe Antwort. CR-R01 ("ein CR trackt ueberhaupt etwas") bleibt fuer
-// ALLE CRs gueltig — nur die Verschaerfung "und zwar einen FUNC" ist Planung.
-// ---------------------------------------------------------------------------
-function crMustHaveFunc(graph) {
-    // Ein CR ganz OHNE status ist kein geschlossener CR — die Regel darf nicht durch ein
-    // fehlendes Attribut stumm werden.
-    const crs = graph.elements.filter(e => {
-        if (e.type !== 'CR')
-            return false;
-        const status = e.attributes?.status;
-        return status === undefined || status === 'open' || status === 'in-progress';
-    });
-    return crs
-        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'FUNC')))
-        .map(cr => ({
-        rule_id: 'CR-R04',
-        severity: 'warning',
-        element_id: cr.id,
-        message: `${cr.id} has no relation→FUNC trace (no implementation scope)`,
-        fix_hint: 'Add CR→FUNC [relation] traces to define which functions this CR changes',
-        context: {
-            element_type: cr.type,
-            element_name: cr.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // MS-03: CR should have a CR→MS [relation] trace (CR-207)
 // ---------------------------------------------------------------------------
 function crShouldHaveMilestone(graph) {
@@ -159,7 +177,6 @@ export const CR_RULES = [
     // (= alle Elemente) ist die einzige Menge, aus der der Zielknoten garantiert stammt.
     // Damit ist sie nach R-08/R-18 die dritte 'all'-Regel — bewusst, nicht vergessen.
     { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation, domain: ['all'] },
-    { id: 'CR-R04', name: 'Open CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc, domain: ['CR'] },
     { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone, domain: ['CR'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —

package/dist/se/evaluate-all.d.ts

@@ -13,14 +13,16 @@ import type { MetricPolicy } from './policy.js';
  * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
  * wenn es keine zweite gibt.
  */
+/** Profile groupings — see CATALOGS. */
+export type ProfileId = 'default' | 'se' | 'coding';
 export declare const ALL_RULE_DEFS: ReadonlyArray<{
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
     domain: readonly string[];
+    /** CR-SM-285: das Profil reist mit der Regel, statt aus ihrer ID geraten zu werden. */
+    profile: Exclude<ProfileId, 'default'>;
 }>;
-/** Profile groupings derived from rule prefixes. */
-export type ProfileId = 'default' | 'se' | 'coding';
 export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RULE_DEFS;
 /**
  * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.