@sigloch/contracts 6.1.0 → 9.1.0

package/dist/se/ao-rules.js

@@ -1,4 +1,5 @@
 import { getND02SimilarityMatrix } from './near-duplicate-rules.js';
+import { indexOf } from './graph-index.js';
 const SCHEMA_OVERLAP_THRESHOLD = 0.5;
 /**
  * AO-D01: Relay Node Detection.
@@ -6,13 +7,14 @@ const SCHEMA_OVERLAP_THRESHOLD = 0.5;
  * 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 = graph.elements.filter(e => e.type === 'FUNC');
+    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 && graph.elements.some(e => e.id === t.target && e.type === 'REQ'));
+            t.source === func.id && idx.typeOf(t.target) === 'REQ');
         if (hasSatisfy)
             continue;
         // (b) >=2 outgoing io traces to other FUNCs
@@ -24,7 +26,7 @@ export function aoD01RelayNode(graph) {
         // (c) Target FUNCs share SCHEMA overlap >= 0.5 (skip check if no matrix)
         if (!passesSchemaOverlap(graph, ioTargets))
             continue;
-        const el = graph.elements.find(e => e.id === func.id);
+        const el = idx.byId.get(func.id);
         violations.push({
             rule_id: 'AO-D01',
             severity: 'info',
@@ -37,29 +39,35 @@ export function aoD01RelayNode(graph) {
 }
 /** CR-165: Resolve FUNC→SCHEMA via FUNC→FLOW(io) + FLOW→SCHEMA(relation). */
 function funcToSchemas(graph, funcId) {
+    const idx = indexOf(graph);
     const schemas = new Set();
     // 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
+    // dabei egal, die Menge wird nur auf Mitgliedschaft geprueft.
     const flowIds = new Set();
-    for (const t of graph.traces) {
-        if (t.type === 'io') {
-            if (t.source === funcId && graph.elements.some(e => e.id === t.target && e.type === 'FLOW')) {
-                flowIds.add(t.target);
-            }
-            if (t.target === funcId && graph.elements.some(e => e.id === t.source && e.type === 'FLOW')) {
-                flowIds.add(t.source);
-            }
-        }
-    }
-    // Find SCHEMAs connected to those FLOWs via relation
-    for (const t of graph.traces) {
-        if (t.type === 'relation' && flowIds.has(t.source) && graph.elements.some(e => e.id === t.target && e.type === 'SCHEMA')) {
+    for (const t of idx.out(funcId, 'io'))
+        if (idx.typeOf(t.target) === 'FLOW')
+            flowIds.add(t.target);
+    for (const t of idx.in(funcId, 'io'))
+        if (idx.typeOf(t.source) === 'FLOW')
+            flowIds.add(t.source);
+    // 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
+    // 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')) {
+        if (flowIds.has(t.source) && idx.typeOf(t.target) === 'SCHEMA')
             schemas.add(t.target);
-        }
     }
     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
@@ -93,8 +101,9 @@ function passesSchemaOverlap(graph, targetFuncIds) {
  * FUNC A sends io to both B and C, where B and C connect to the same SCHEMA elements.
  */
 export function aoD03DuplicatePath(graph) {
+    const idx = indexOf(graph);
     const violations = [];
-    const funcs = graph.elements.filter(e => e.type === 'FUNC');
+    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)
@@ -141,15 +150,16 @@ export function aoD03DuplicatePath(graph) {
 // diesen Aus-Zustand nicht: jedes Modulpaar mit >= 1 Kreuzung erzeugte eine info-Meldung.
 // ---------------------------------------------------------------------------
 export function cr01CrossingFlowCount(graph, policy) {
+    const idx = indexOf(graph);
     const violations = [];
     const steps = policy.crossingFlows;
     if (steps === null)
         return violations;
-    const mods = graph.elements.filter(e => e.type === 'MOD');
+    const mods = idx.elementsOfType('MOD');
     // Build MOD → Set<FUNC-id> mapping
     const modFuncs = new Map();
     for (const mod of mods) {
-        const funcIds = new Set(graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id).map(t => t.source));
+        const funcIds = new Set(idx.in(mod.id, 'allocate').map(t => t.source));
         modFuncs.set(mod.id, funcIds);
     }
     // Count crossings per module pair
@@ -191,10 +201,11 @@ export function cr01CrossingFlowCount(graph, policy) {
 // 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 => graph.elements.some(e => e.id === t.source && e.type === 'FUNC'))
+        .filter(t => idx.typeOf(t.source) === 'FUNC')
         .map(t => ({
         rule_id: 'RT-01',
         severity: 'error',
@@ -208,10 +219,11 @@ export function rt01PhysicalBoundaryIntegrity(graph) {
 // 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' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'MOD')))
+        idx.typeOf(t.target) === 'MOD'))
         .map(pm => ({
         rule_id: 'PH-01',
         severity: 'info',
@@ -226,6 +238,7 @@ export function ph01PhysicalModCompleteness(graph) {
 // 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) {
@@ -236,15 +249,16 @@ export function ca01CapabilityAllocation(graph) {
         const allocTrace = graph.traces.find(t => t.source === func.id && t.type === 'allocate');
         if (!allocTrace)
             continue;
-        const logicalMod = graph.elements.find(e => e.id === allocTrace.target && e.type === 'MOD');
+        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 &&
-            graph.elements.some(e => e.id === t.source && e.type === 'MOD' && e.attributes?.kind === 'physical'));
+            (idx.byId.get(t.source)?.type === 'MOD' && idx.byId.get(t.source)?.attributes?.kind === 'physical'));
         if (!physParentTrace)
             continue;
-        const physMod = graph.elements.find(e => e.id === physParentTrace.source);
+        const physMod = idx.byId.get(physParentTrace.source);
         const capabilities = (Array.isArray(physMod.attributes?.capability)
             ? physMod.attributes.capability
             : physMod.attributes?.capability ? [physMod.attributes.capability] : []);
@@ -289,9 +303,10 @@ export function ca01CapabilityAllocation(graph) {
 //    andere Regel trifft.
 // ---------------------------------------------------------------------------
 export function io01CrossModuleCompleteness(graph) {
+    const idx = indexOf(graph);
     const violations = [];
     const flowIds = new Set(graph.elements.filter(e => e.type === 'FLOW').map(e => e.id));
-    const funcIdSet = new Set(graph.elements.filter(e => e.type === 'FUNC').map(e => e.id));
+    const funcIdSet = idx.idsOfType('FUNC');
     /** io-Nachbarschaft FUNC <-> FLOW, richtungslos: die Frage ist "haengt das zusammen?". */
     const flowsOfFunc = new Map();
     for (const t of graph.traces) {
@@ -306,7 +321,7 @@ export function io01CrossModuleCompleteness(graph) {
             flowsOfFunc.set(f, new Set());
         flowsOfFunc.get(f).add(fl);
     }
-    for (const fc of graph.elements.filter(e => e.type === 'FCHAIN')) {
+    for (const fc of idx.elementsOfType('FCHAIN')) {
         const members = graph.traces
             .filter(t => t.source === fc.id && t.type === 'compose')
             .map(t => t.target)
@@ -356,7 +371,7 @@ export function io01CrossModuleCompleteness(graph) {
         for (const id of wired) {
             if (largestSet.has(id))
                 continue;
-            const el = graph.elements.find(e => e.id === id);
+            const el = idx.byId.get(id);
             const mod = graph.traces.find(t => t.source === id && t.type === 'allocate')?.target ?? 'unallocated';
             violations.push({
                 rule_id: 'IO-01',
@@ -368,7 +383,7 @@ export function io01CrossModuleCompleteness(graph) {
                     element_type: 'FUNC',
                     element_name: el?.name ?? id,
                     candidate_targets: largest.slice(0, 3).map(t => {
-                        const te = graph.elements.find(e => e.id === t);
+                        const te = idx.byId.get(t);
                         return { id: t, type: te?.type ?? 'FUNC', name: te?.name ?? t };
                     }),
                 },

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

@@ -49,6 +49,7 @@ export declare const CodeFactsSchema: z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
     }, z.core.$strip>>>;
+    declaredDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type CodeFacts = z.infer<typeof CodeFactsSchema>;
 /** A conformance rule: pure over (graph, facts) — never touches I/O itself. */
@@ -58,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

@@ -48,6 +48,17 @@ export const CodeFactsSchema = z.object({
      * given), so pre-CR-212 CodeFacts stay valid.
      */
     importEdges: z.array(ImportEdgeSchema).optional(),
+    /**
+     * Package names the consumer declares in `dependencies` + `devDependencies`, for
+     * RC-06 (CR-SM-262). The extractor reads them from the repo's package.json.
+     *
+     * Optional, and the ABSENT case is silence, not a violation — the opposite of `files`,
+     * where a missing key must surface loudly. The asymmetry is deliberate: a missing file
+     * entry means the extractor looked and found nothing, while an absent dependency list
+     * means it never looked. Treating "never looked" as "declares nothing" would report
+     * every external binding in the graph at once, which is noise, not a finding.
+     */
+    declaredDependencies: z.array(z.string()).optional(),
 });
 const missingFile = (facts, file) => facts.files[file]?.exists !== true;
 // RC-01: every valid FUNC realRef must resolve — file on disk, symbol declared in
@@ -256,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')
@@ -281,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;
@@ -292,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');
@@ -321,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))
@@ -341,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` : '';
@@ -349,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',
@@ -359,6 +393,61 @@ function importDriftConformance(graph, facts) {
         };
     });
 }
+// ---------------------------------------------------------------------------
+// RC-06: an `external` realRef names a package the consumer actually depends on
+// (CR-SM-262).
+//
+// RC-01..03 skip `external === true` — and rightly so: the path of a foreign package is
+// not in this repo and cannot be resolved here. The consequence was that external bindings
+// were never checked at all and rotted in silence. Found by hand at the graphcode
+// self-model on 2026-08-22, not by a rule: `SCHEMA-metric-vector` carried
+// `realRef.file = "packages/se-optimizer/src/metrics.ts"`, and `@sigloch/se-optimizer` had
+// ceased to exist with CR-SM-248 — `MetricVector` moved to `se-engine`. The node pointed at
+// a package that is not there, and RC-01 said nothing because `external: true` was set.
+//
+// The PATH is unverifiable here; the PACKAGE NAME is not. A path of the shape
+// `packages/<name>/…` claims a workspace package, so `@sigloch/<name>` must appear in the
+// consumer's dependencies. Any other path shape stays unchecked rather than guessed.
+//
+// Severity `warning`, not `error`: the path may deviate from the convention for honest
+// reasons (monorepo restructuring, a linked working copy), and an `error` would block every
+// further mutation through the delta gate. A rotted binding is a completeness signal, not a
+// mismeasurement — unlike R-29, where the number itself becomes wrong.
+// ---------------------------------------------------------------------------
+/** `packages/<name>/…` — the workspace-package path shape RC-06 can decide. */
+const WORKSPACE_PATH = /^packages\/([^/]+)\//;
+/** Package scope of this family. A path claims `<SCOPE>/<name>`. */
+const WORKSPACE_SCOPE = '@sigloch';
+function externalRefMustNameDependency(graph, facts) {
+    const declared = facts.declaredDependencies;
+    if (declared === undefined)
+        return []; // extractor supplied none — silence, s. CodeFactsSchema
+    const known = new Set(declared);
+    const violations = [];
+    for (const el of graph.elements) {
+        // `concept: true` has no binding that could rot — a concept node claims nothing about code.
+        if (el.attributes?.external !== true || el.attributes?.concept === true)
+            continue;
+        const parsed = RealRefSchema.safeParse(el.attributes?.realRef);
+        if (!parsed.success)
+            continue;
+        const match = WORKSPACE_PATH.exec(parsed.data.file);
+        if (!match)
+            continue; // not the shape this rule can decide
+        const pkg = `${WORKSPACE_SCOPE}/${match[1]}`;
+        if (known.has(pkg))
+            continue;
+        violations.push({
+            rule_id: 'RC-06',
+            severity: 'warning',
+            element_id: el.id,
+            message: `${el.id} binds to '${parsed.data.file}', but '${pkg}' is not a declared dependency`,
+            fix_hint: `Add '${pkg}' to dependencies, or re-point the realRef at the package that now owns the symbol`,
+            context: { element_type: el.type, element_name: el.name },
+        });
+    }
+    return violations;
+}
 /** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
 export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-01', name: 'FUNC realRef resolves to a declared symbol', severity: 'error', evaluate: codeRefMustResolve },
@@ -366,6 +455,7 @@ export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-03', name: 'SCHEMA realRef resolves to a declared export', severity: 'error', evaluate: schemaRefMustResolve },
     { id: 'RC-04', name: 'SCHEMA realRef is parsed at its interface', severity: 'warning', evaluate: schemaRefMustBeUsed },
     { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', evaluate: importDriftConformance },
+    { id: 'RC-06', name: 'external realRef names a declared dependency', severity: 'warning', evaluate: externalRefMustNameDependency },
 ];
 /** Run all RC rules against a graph + extracted code facts. */
 export function evaluateConformanceRules(graph, facts) {

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

@@ -1,33 +1,36 @@
+import { indexOf } from './graph-index.js';
 // ---------------------------------------------------------------------------
 // FC-01: FCHAIN must have Actor boundary (input or output via FLOW→ACTOR io)
 // ---------------------------------------------------------------------------
 export function fc01ActorBoundary(graph) {
-    return graph.elements
-        .filter(e => e.type === 'FCHAIN')
+    // CR-SM-264: dieselbe Frage, einmal statt je Kette neu.
+    //
+    // Die alte Fassung war die verschachtelte Form, die UC-02 kubisch gemacht hat (CR-SM-261):
+    // je FCHAIN alle Traces, darin je io-Kante noch einmal alle Traces, darin je Treffer alle
+    // Elemente — `FCHAIN x FUNC x T x T x E`. Im Profil nach Teil a war FC-01 mit 6,3 % die
+    // teuerste FCHAIN-Regel.
+    //
+    // Beide Zweige fragen in Wahrheit DASSELBE: "beruehrt dieses Element eine io-Kante, deren
+    // anderes Ende ein ACTOR ist?" Einmal fuer den Zwischenknoten der Kettenglieder, einmal
+    // direkt fuer den Eltern-UC. Eine Menge beantwortet beide.
+    const idx = indexOf(graph);
+    const actorAdjacent = new Set();
+    for (const t of idx.tracesOfType('io')) {
+        if (idx.typeOf(t.target) === 'ACTOR')
+            actorAdjacent.add(t.source);
+        if (idx.typeOf(t.source) === 'ACTOR')
+            actorAdjacent.add(t.target);
+    }
+    return idx.elementsOfType('FCHAIN')
         .filter(fc => {
-        // Get FUNCs in this FCHAIN via compose
-        const funcIds = graph.traces
-            .filter(t => t.source === fc.id && t.type === 'compose')
-            .map(t => t.target);
-        // Check if any FUNC has io trace involving an ACTOR (via FLOW)
-        const hasActorIO = funcIds.some(fid => graph.traces.some(t => {
-            if (t.type !== 'io')
-                return false;
-            // FUNC→FLOW or FLOW→FUNC
-            const flowId = t.source === fid ? t.target : (t.target === fid ? t.source : null);
-            if (!flowId)
-                return false;
-            // FLOW→ACTOR or ACTOR→FLOW
-            return graph.traces.some(ft => ft.type === 'io' &&
-                ((ft.source === flowId && graph.elements.some(e => e.id === ft.target && e.type === 'ACTOR')) ||
-                    (ft.target === flowId && graph.elements.some(e => e.id === ft.source && e.type === 'ACTOR'))));
-        }));
-        // Also check direct ACTOR→UC io on the parent UC
-        const parentUC = graph.traces.find(t => t.type === 'compose' && t.target === fc.id &&
-            graph.elements.some(e => e.id === t.source && e.type === 'UC'));
-        const hasDirectActorIO = parentUC && graph.traces.some(t => t.type === 'io' &&
-            ((t.target === parentUC.source && graph.elements.some(e => e.id === t.source && e.type === 'ACTOR')) ||
-                (t.source === parentUC.source && graph.elements.some(e => e.id === t.target && e.type === 'ACTOR'))));
+        // Mitglieder der Kette — bewusst OHNE Typfilter, wie in der alten Fassung: FC-01 fragt
+        // nach dem, was komponiert ist, nicht nach dem, was eine FUNC ist (FC-03 tut das).
+        const memberIds = idx.out(fc.id, 'compose').map(t => t.target);
+        const hasActorIO = memberIds.some(fid => idx.out(fid, 'io').some(t => actorAdjacent.has(t.target)) ||
+            idx.in(fid, 'io').some(t => actorAdjacent.has(t.source)));
+        // Der Umweg ueber den Eltern-UC: dessen eigene ACTOR-io zaehlt auch.
+        const parentUC = idx.in(fc.id, 'compose').find(t => idx.typeOf(t.source) === 'UC');
+        const hasDirectActorIO = parentUC !== undefined && actorAdjacent.has(parentUC.source);
         return !hasActorIO && !hasDirectActorIO;
     })
         .map(fc => ({
@@ -43,17 +46,15 @@ export function fc01ActorBoundary(graph) {
 // FC-02: Leaf UC (no UC→compose→UC) must have at least one FCHAIN
 // ---------------------------------------------------------------------------
 export function fc02LeafUcHasFchain(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
         .filter(uc => {
+        const composed = idx.out(uc.id, 'compose');
         // Leaf = no compose→UC children
-        const hasUCChild = graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-            graph.elements.some(e => e.id === t.target && e.type === 'UC'));
-        if (hasUCChild)
+        if (composed.some(t => idx.typeOf(t.target) === 'UC'))
             return false;
         // Must have compose→FCHAIN
-        return !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-            graph.elements.some(e => e.id === t.target && e.type === 'FCHAIN'));
+        return !composed.some(t => idx.typeOf(t.target) === 'FCHAIN');
     })
         .map(uc => ({
         rule_id: 'FC-02',
@@ -69,15 +70,13 @@ export function fc02LeafUcHasFchain(graph) {
 // ---------------------------------------------------------------------------
 export function fc03FchainFlat(graph) {
     const violations = [];
-    const fchains = graph.elements.filter(e => e.type === 'FCHAIN');
-    for (const fc of fchains) {
-        const funcIds = graph.traces
-            .filter(t => t.source === fc.id && t.type === 'compose')
+    const idx = indexOf(graph);
+    for (const fc of idx.elementsOfType('FCHAIN')) {
+        const funcIds = idx.out(fc.id, 'compose')
             .map(t => t.target)
-            .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC'));
+            .filter(id => idx.typeOf(id) === 'FUNC');
         for (const fid of funcIds) {
-            const nestedCompose = graph.traces.filter(t => t.source === fid && t.type === 'compose' &&
-                graph.elements.some(e => e.id === t.target && e.type === 'FUNC'));
+            const nestedCompose = idx.out(fid, 'compose').filter(t => idx.typeOf(t.target) === 'FUNC');
             if (nestedCompose.length > 0) {
                 violations.push({
                     rule_id: 'FC-03',
@@ -85,7 +84,7 @@ export function fc03FchainFlat(graph) {
                     element_id: fid,
                     message: `${fid} in ${fc.id} has nested FUNC compose (should be flat)`,
                     fix_hint: 'Move nested functions to FCHAIN level (flat composition)',
-                    context: { element_type: 'FUNC', element_name: graph.elements.find(e => e.id === fid)?.name ?? fid },
+                    context: { element_type: 'FUNC', element_name: idx.byId.get(fid)?.name ?? fid },
                 });
             }
         }
@@ -105,24 +104,29 @@ export function fc03FchainFlat(graph) {
 // to have unrelated ACTOR io.
 // ---------------------------------------------------------------------------
 export function fc04ActorBounded(graph) {
-    return graph.elements
-        .filter(e => e.type === 'FCHAIN')
+    // CR-SM-264: die beiden Zwischenmengen einmal je Graph statt |io|^2 je Kette.
+    // `actorFed` sind die Knoten, in die ein ACTOR hineinschickt, `actorConsumed` die, aus denen
+    // ein ACTOR liest. Beide Richtungen bleiben getrennt — anders als bei FC-01, das nur fragt,
+    // OB ein ACTOR anliegt; FC-04 verlangt Eingang UND Ausgang.
+    const idx = indexOf(graph);
+    const io = idx.tracesOfType('io');
+    const actorFed = new Set();
+    const actorConsumed = new Set();
+    for (const a of io) {
+        if (idx.typeOf(a.source) === 'ACTOR')
+            actorFed.add(a.target);
+        if (idx.typeOf(a.target) === 'ACTOR')
+            actorConsumed.add(a.source);
+    }
+    return idx.elementsOfType('FCHAIN')
         .filter(fc => {
-        const funcIds = new Set(graph.traces
-            .filter(t => t.source === fc.id && t.type === 'compose')
-            .map(t => t.target)
-            .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC')));
+        const funcIds = new Set(idx.out(fc.id, 'compose').map(t => t.target).filter(id => idx.typeOf(id) === 'FUNC'));
         if (funcIds.size === 0)
             return false; // R-15 already flags the empty-chain case
-        const io = graph.traces.filter(t => t.type === 'io');
-        const isActor = (id) => graph.elements.some(e => e.id === id && e.type === 'ACTOR');
-        const isFlow = (id) => graph.elements.some(e => e.id === id && e.type === 'FLOW');
         // Entry: ACTOR→FLOW→FUNC∈chain (something triggers the chain).
-        const entry = io.some(e => funcIds.has(e.target) && isFlow(e.source) &&
-            io.some(a => a.target === e.source && isActor(a.source)));
+        const entry = io.some(e => funcIds.has(e.target) && idx.typeOf(e.source) === 'FLOW' && actorFed.has(e.source));
         // Exit: FUNC∈chain→FLOW→ACTOR (the chain produces something back to an actor).
-        const exit = io.some(e => funcIds.has(e.source) && isFlow(e.target) &&
-            io.some(a => a.source === e.target && isActor(a.target)));
+        const exit = io.some(e => funcIds.has(e.source) && idx.typeOf(e.target) === 'FLOW' && actorConsumed.has(e.target));
         return !(entry && exit);
     })
         .map(fc => ({

package/dist/se/flat-graph.d.ts

@@ -0,0 +1,3 @@
+import type { OntologyGraph } from './ontology.js';
+/** Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt. */
+export declare function toEvaluableGraph(graph: OntologyGraph): OntologyGraph;