@sigloch/contracts 6.3.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/conformance-rules.d.ts

@@ -59,6 +59,34 @@ export interface ConformanceRuleDefinition {
     severity: RuleSeverity;
     evaluate: (graph: OntologyGraph, facts: CodeFacts) => RuleViolation[];
 }
+/**
+ * Wie viel des Import-Graphen konnte RC-05 überhaupt ansehen? (CR-SM-268 Teil 2)
+ *
+ * Eine MESSUNG über den Lauf, kein Befund über das Modell — deshalb eine eigene Funktion neben
+ * den Regeln und keine `RuleViolation`. „12 von 178 Endpunkten nicht zugeordnet" sagt nichts
+ * über den Graphen aus; es sagt, wie belastbar die Zahl daneben ist.
+ *
+ * Vorher hing die Liste als Textanhang an der Meldung eines ANDEREN Befundes und verschwand mit
+ * ihm: CR-GC-423 hat die drei RC-05-Drift-Befunde von graphcode geschlossen, und mit ihnen war
+ * die Liste der nicht zugeordneten Dateien weg — sie musste in CR-GC-424/425 von Hand
+ * rekonstruiert werden. „RC-05: 0 Befunde" hieß damit wahlweise „alle 178 Endpunkte geprüft,
+ * keiner driftet" oder „166 geprüft, 12 gar nicht angesehen", und niemand konnte die beiden
+ * unterscheiden.
+ *
+ * Geschwister von `skipped` (CR-GC-398), nicht dasselbe: `skipped` heißt „diese Quelle wurde GAR
+ * NICHT ausgewertet" (kein lesbarer repoRoot). Hier ist sie ausgewertet worden, und trotzdem
+ * fällt ein Teil durch. Zwei Zustände, zwei Felder — zusammengelegt wären „nicht gelaufen" und
+ * „gelaufen, aber blind" wieder ununterscheidbar.
+ */
+export interface ImportCoverage {
+    /** Verschiedene Dateien, die überhaupt als Import-Endpunkt vorkommen. */
+    endpoints: number;
+    /** Davon einer MOD zugeordnet — nur diese konnte RC-05 beurteilen. */
+    assigned: number;
+    /** Der Rest, benannt statt gezählt: ohne die Namen ist die Lücke nicht schließbar. */
+    unassigned: string[];
+}
+export declare function importCoverage(graph: OntologyGraph, facts: CodeFacts): ImportCoverage;
 /** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
 export declare const CODE_CONFORMANCE_RULES: ConformanceRuleDefinition[];
 /** Run all RC rules against a graph + extracted code facts. */

package/dist/se/conformance-rules.js

@@ -267,15 +267,19 @@ function schemaRefMustBeUsed(graph, facts) {
 //      such adjacency ⇒ one RC-05 per (fromMod → toMod) pair, evidence = the
 //      crossing file imports.
 // ---------------------------------------------------------------------------
-function importDriftConformance(graph, facts) {
-    const importEdges = facts.importEdges ?? [];
-    if (importEdges.length === 0)
-        return [];
+/**
+ * Datei → MOD, die EINE Auflösung für RC-05 und `importCoverage` (CR-SM-268 Teil 2).
+ *
+ * Bewusst herausgezogen und nicht zweimal geschrieben: die Abdeckungszahl muss dieselbe Frage
+ * stellen wie die Regel, sonst misst sie etwas anderes als das, was geprüft wird — und eine
+ * Abdeckungszahl, die nicht zur Prüfung passt, ist schlimmer als keine.
+ *
+ * Zwei Wege, in dieser Reihenfolge: die `realRef` einer allozierten FUNC (eine gebundene Datei
+ * gehört zur MOD ihrer FUNC), danach das `path`-Präfix einer MOD, longest-prefix. Wer keinen
+ * von beiden trifft, ist `unassigned` — und wird nie still verworfen.
+ */
+function buildModResolver(graph) {
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
-    const modIds = graph.elements.filter(e => e.type === 'MOD').map(e => e.id);
-    if (modIds.length === 0)
-        return [];
-    // 1. file → MOD. Direct realRef bindings first.
     const fileToMod = new Map();
     for (const el of graph.elements) {
         if (el.type !== 'FUNC')
@@ -292,7 +296,7 @@ function importDriftConformance(graph, facts) {
         .filter(e => e.type === 'MOD' && typeof e.attributes?.path === 'string')
         .map(e => ({ id: e.id, path: e.attributes.path.replace(/[*].*$/, '').replace(/\/+$/, '') }))
         .filter(m => m.path.length > 0);
-    const resolveMod = (file) => {
+    return (file) => {
         if (fileToMod.has(file))
             return fileToMod.get(file);
         let best;
@@ -303,6 +307,27 @@ function importDriftConformance(graph, facts) {
         }
         return best?.id;
     };
+}
+export function importCoverage(graph, facts) {
+    const importEdges = facts.importEdges ?? [];
+    const resolveMod = buildModResolver(graph);
+    const endpoints = new Set();
+    for (const edge of importEdges) {
+        endpoints.add(edge.from);
+        endpoints.add(edge.to);
+    }
+    const unassigned = [...endpoints].filter(f => resolveMod(f) === undefined).sort();
+    return { endpoints: endpoints.size, assigned: endpoints.size - unassigned.length, unassigned };
+}
+function importDriftConformance(graph, facts) {
+    const importEdges = facts.importEdges ?? [];
+    if (importEdges.length === 0)
+        return [];
+    const modIds = graph.elements.filter(e => e.type === 'MOD').map(e => e.id);
+    if (modIds.length === 0)
+        return [];
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const resolveMod = buildModResolver(graph);
     // 2. graph MOD-adjacency (undirected) from io crossings FUNC_A ─io→ FLOW ─io→ FUNC_B.
     const funcMod = (funcId) => {
         const t = graph.traces.find(tr => tr.source === funcId && tr.type === 'allocate' && typeOf.get(tr.target) === 'MOD');
@@ -332,16 +357,15 @@ function importDriftConformance(graph, facts) {
         const [x, y] = [a, b].sort();
         return adjacent.has(`${x}|${y}`);
     };
-    // 3. drift per (fromMod → toMod), aggregating evidence; collect unassigned files.
+    // 3. drift per (fromMod → toMod), aggregating evidence.
+    // CR-SM-268 Teil 2: die nicht zugeordneten Dateien werden hier NICHT mehr gesammelt. Sie
+    // hingen als Textanhang an der Meldung eines anderen Befundes und verschwanden mit ihm
+    // (CR-GC-423). Ihr Ort ist jetzt `importCoverage` — eine Messung, die auch dann etwas sagt,
+    // wenn diese Regel schweigt.
     const drift = new Map();
-    const unassigned = new Set();
     for (const edge of importEdges) {
         const fromMod = resolveMod(edge.from);
         const toMod = resolveMod(edge.to);
-        if (!fromMod)
-            unassigned.add(edge.from);
-        if (!toMod)
-            unassigned.add(edge.to);
         if (!fromMod || !toMod || fromMod === toMod)
             continue;
         if (isAdjacent(fromMod, toMod))
@@ -352,7 +376,6 @@ function importDriftConformance(graph, facts) {
         drift.set(key, entry);
     }
     const nameOf = new Map(graph.elements.map(e => [e.id, e.name]));
-    const unassignedNote = unassigned.size > 0 ? ` (unassigned files not mapped to a MOD: ${[...unassigned].sort().join(', ')})` : '';
     return [...drift.values()].map(d => {
         const shown = d.evidence.slice(0, 5);
         const more = d.evidence.length > shown.length ? ` +${d.evidence.length - shown.length} more` : '';
@@ -360,7 +383,7 @@ function importDriftConformance(graph, facts) {
             rule_id: 'RC-05',
             severity: 'warning',
             element_id: d.fromMod,
-            message: `${d.fromMod} imports ${d.toMod} across a module boundary the graph does not document — evidence: ${shown.join('; ')}${more}${unassignedNote}`,
+            message: `${d.fromMod} imports ${d.toMod} across a module boundary the graph does not document — evidence: ${shown.join('; ')}${more}`,
             fix_hint: `Document the ${d.fromMod}→${d.toMod} dependency in the graph (an io/FLOW connection between their FUNCs), or remove the import`,
             context: {
                 element_type: 'MOD',