@sigloch/contracts 6.1.0 → 6.3.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. */

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
@@ -359,6 +370,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 +432,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;

package/dist/se/flat-graph.js

@@ -0,0 +1,52 @@
+/**
+ * CR-SM-258 / CR-SM-260 — eine committete `*.graph.json` ist FLACH.
+ *
+ * graphcode schreibt seine SSOT seit CR-GC-219 flach, damit die Datei, die ein Mensch diffed,
+ * jeden Wert genau einmal traegt: `{id, type, name, description, ...attributes}`, gar kein
+ * `attributes`-Schluessel. Die Regeln lesen aber `e.attributes?.*` — der Zustand, den der
+ * Live-Gate aus Kuzu projiziert. Wer die flache Form ungehoben in den Evaluator reicht, macht
+ * JEDES Attribut unsichtbar:
+ *
+ *   graphcode-Selbstmodell, graphVersion 171 — flach gelesen | korrekt genestet
+ *   R-19  123 | 0      R-20  95 | 0      Summe  610 | 374
+ *
+ * 236 Phantom-Befunde, und CR-R02 (severity error) war umgekehrt komplett stumm. Jede
+ * Gate-7-Zahl zwischen CR-SM-246 und CR-SM-258 war davon betroffen.
+ *
+ * Warum die Hebung hier im QUELLTEXT steht und nicht mehr in der Messdatei (CR-SM-260): sie hat
+ * einen zweiten Nutzer bekommen — den Regel-Profillauf in `@sigloch/se-engine`, der dasselbe
+ * Selbstmodell liest. Zwei Kopien waeren zwei Projektionen derselben Wahrheit, und die
+ * fehlerhafte faellt genau dann nicht auf, wenn sie nur Zeiten misst statt Befunde.
+ *
+ * Warum nicht `fromOntologyGraph` aus `@sigloch/graph-api-core` (CR-SM-254): das Paket haengt an
+ * contracts, nicht umgekehrt — ein Import waere ein Zyklus. Statt die Projektion von Hand
+ * nachzubauen (genau der Fehler, der hier repariert wird), leitet die Hebung ihre kanonische
+ * Schluesselmenge aus den Zod-Schemata ab. Sie kann damit nicht von der Ontologie wegdriften:
+ * ein neues Top-Level-Feld ist sofort auch hier eines.
+ */
+import { OntologyElement, Trace } from './ontology.js';
+const TOP_LEVEL_ELEMENT_KEYS = new Set(Object.keys(OntologyElement.shape));
+const TOP_LEVEL_TRACE_KEYS = new Set(Object.keys(Trace.shape));
+function nestAttributes(entry, canonical) {
+    if (entry.attributes !== undefined)
+        return entry; // schon in der genesteten Form
+    const top = {};
+    const attributes = {};
+    for (const [key, value] of Object.entries(entry)) {
+        (canonical.has(key) ? top : attributes)[key] = value;
+    }
+    // `status` lebt in BEIDEN Welten: als Top-Level-Feld am Schema und unter `attributes`, wo
+    // CR-R02/CR-R03/CR-R04 es lesen. Die Kuzu-Projektion liefert beides, also spiegelt die
+    // Hebung es ebenfalls — sonst lesen genau die CR-Regeln wieder ins Leere.
+    if (entry.status !== undefined)
+        attributes.status = entry.status;
+    return { ...top, attributes };
+}
+/** Hebt eine flach committete SSOT in die Form, die der Live-Gate dem Evaluator gibt. */
+export function toEvaluableGraph(graph) {
+    return {
+        ...graph,
+        elements: graph.elements.map((e) => nestAttributes(e, TOP_LEVEL_ELEMENT_KEYS)),
+        traces: graph.traces.map((t) => nestAttributes(t, TOP_LEVEL_TRACE_KEYS)),
+    };
+}

package/dist/se/grammar-snapshot.d.ts

@@ -13,11 +13,12 @@ export declare const GRAMMAR_SNAPSHOT: {
     readonly versions: {
         readonly ontology: "7.0.0";
         readonly metaModel: "2.0.0";
-        readonly rules: "6.1.0";
+        readonly rules: "6.3.0";
     };
     readonly elementTypes: readonly ["ACTOR", "CR", "FCHAIN", "FLOW", "FUNC", "MOD", "MS", "REQ", "SCHEMA", "SESSION", "SYS", "TEST", "UC"];
     readonly traceTypes: readonly ["allocate", "compose", "io", "produces", "relation", "satisfy", "verify"];
     readonly patterns: readonly ["ACTOR -io-> FLOW", "ACTOR -io-> UC", "CR -relation-> FUNC", "CR -relation-> MOD", "CR -relation-> MS", "CR -relation-> REQ", "CR -relation-> UC", "FCHAIN -compose-> FUNC [1..*]", "FCHAIN -satisfy-> REQ", "FLOW -io-> ACTOR", "FLOW -io-> FUNC", "FLOW -io-> UC", "FLOW -relation-> SCHEMA", "FUNC -allocate-> MOD", "FUNC -compose-> FUNC [0..*]", "FUNC -io-> FLOW", "FUNC -satisfy-> REQ", "MOD -compose-> MOD [0..*]", "MOD -io-> MOD", "MOD -satisfy-> REQ", "MS -compose-> FUNC", "MS -compose-> MS", "MS -compose-> REQ", "MS -compose-> UC", "MS -relation-> MS", "REQ -compose-> REQ [0..*]", "SESSION -produces-> * (audit)", "SYS -compose-> MOD [0..*]", "SYS -compose-> REQ [0..*]", "SYS -compose-> SYS [0..*]", "SYS -compose-> UC [1..*]", "SYS -satisfy-> REQ", "TEST -verify-> REQ", "UC -compose-> FCHAIN [1..*]", "UC -compose-> REQ [1..*]"];
     readonly attributes: readonly ["CR.rationale: string", "CR.spike: boolean", "CR.status: enum", "FLOW.protocol: string", "FLOW.qos: string", "FUNC.concept: boolean", "FUNC.external: boolean", "FUNC.measuredMs: number", "FUNC.realRef: object", "FUNC.safety_relevant: boolean", "FUNC.sourceFile: string", "FUNC.timingBudgetMs: number", "MOD.concept: boolean", "MOD.external: boolean", "MOD.kind: string", "MOD.path: string", "MOD.realRef: object", "REQ.detection: number", "REQ.occurrence: number", "REQ.severity: number", "SCHEMA.concept: boolean", "SCHEMA.contract: string", "SCHEMA.external: boolean", "SCHEMA.realRef: object", "TEST.concept: boolean", "TEST.sourceFile: string", "TEST.testRefs: array", "UC.operatingMode: string"];
     readonly rules: readonly ["AF-01 (warning) domain=[graph]", "AF-02 (warning) domain=[graph]", "AF-03 (warning) domain=[graph]", "AF-04 (warning) domain=[graph]", "AF-05 (warning) domain=[graph]", "AO-D01 (info) domain=[FUNC]", "AO-D03 (info) domain=[FUNC]", "BQ-01 (warning) domain=[REQ]", "BQ-02 (warning) domain=[REQ]", "BQ-04 (warning) domain=[REQ]", "BQ-06 (warning) domain=[REQ]", "BQ-07 (warning) domain=[REQ]", "CA-01 (error) domain=[FUNC]", "CL-01 (warning) domain=[ACTOR]", "CR-01 (warning) domain=[MOD]", "CR-R01 (error) domain=[CR]", "CR-R02 (error) domain=[CR]", "CR-R03 (warning) domain=[all]", "CR-R04 (warning) domain=[CR]", "FC-01 (warning) domain=[FCHAIN]", "FC-02 (warning) domain=[UC]", "FC-03 (warning) domain=[FUNC]", "FC-04 (warning) domain=[FCHAIN]", "FM-01 (warning) domain=[REQ]", "FM-02 (warning) domain=[REQ]", "FM-03 (error) domain=[REQ]", "IO-01 (warning) domain=[FUNC]", "MS-01 (warning) domain=[MS]", "MS-02 (error) domain=[MS]", "MS-03 (info) domain=[CR]", "MT-01 (warning) domain=[MOD]", "MT-02 (info) domain=[MOD]", "ND-01 (error) domain=[FUNC]", "ND-02 (error) domain=[SCHEMA]", "NFR-01 (warning) domain=[FCHAIN,FUNC,MOD]", "PH-01 (info) domain=[MOD]", "R-01 (error) domain=[REQ]", "R-02 (warning) domain=[FUNC]", "R-03 (error) domain=[MOD]", "R-04 (warning) domain=[MOD]", "R-05 (warning) domain=[TEST]", "R-08 (error) domain=[all]", "R-10 (warning) domain=[FLOW]", "R-12 (warning) domain=[FUNC]", "R-14 (warning) domain=[UC]", "R-15 (warning) domain=[FCHAIN]", "R-16 (warning) domain=[ACTOR]", "R-17 (warning) domain=[SYS]", "R-18 (error) domain=[all]", "R-19 (warning) domain=[TEST]", "R-20 (warning) domain=[FUNC]", "R-21 (warning) domain=[FCHAIN]", "R-22 (warning) domain=[FUNC]", "R-23 (warning) domain=[MOD]", "R-26 (warning) domain=[SCHEMA]", "R-27 (warning) domain=[MOD]", "R-29 (error) domain=[TEST]", "R-30 (warning) domain=[FUNC]", "R-31 (warning) domain=[FUNC]", "RD-01 (warning) domain=[REQ]", "RD-02 (warning) domain=[REQ]", "RD-03 (info) domain=[REQ]", "RD-04 (warning) domain=[FUNC,MOD,SYS]", "RT-01 (error) domain=[FUNC]", "SC-02 (warning) domain=[SCHEMA]", "SC-04 (warning) domain=[FLOW]", "UC-01 (error) domain=[UC]", "UC-02 (error) domain=[UC]", "UC-03 (warning) domain=[UC]", "UC-04 (warning) domain=[UC]", "UC-05 (info) domain=[UC]", "UC-06 (info) domain=[UC]", "VR-01 (info) domain=[TEST]"];
+    readonly conformanceRules: readonly ["RC-01 (error)", "RC-02 (error)", "RC-03 (error)", "RC-04 (warning)", "RC-05 (warning)", "RC-06 (warning)"];
 };

package/dist/se/grammar-snapshot.js

@@ -13,7 +13,7 @@ export const GRAMMAR_SNAPSHOT = {
     versions: {
         ontology: "7.0.0",
         metaModel: "2.0.0",
-        rules: "6.1.0",
+        rules: "6.3.0",
     },
     elementTypes: [
         "ACTOR",
@@ -181,4 +181,12 @@ export const GRAMMAR_SNAPSHOT = {
         "UC-06 (info) domain=[UC]",
         "VR-01 (info) domain=[TEST]",
     ],
+    conformanceRules: [
+        "RC-01 (error)",
+        "RC-02 (error)",
+        "RC-03 (error)",
+        "RC-04 (warning)",
+        "RC-05 (warning)",
+        "RC-06 (warning)",
+    ],
 };

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

@@ -0,0 +1,56 @@
+/**
+ * CR-SM-264 — ein Index je Graph statt Vollscans je Regel.
+ *
+ * ## Der Befund, der ihn rechtfertigt
+ *
+ * Nach CR-SM-261 ist das Profil flach: keine Regel ueber 7,2 %, praktisch jede bei n^2,0
+ * (`npm run profile:rules -w @sigloch/se-engine`). Das ist keine einzelne teure Regel mehr,
+ * sondern EINE Form, die im ganzen Katalog steht — 58 Stellen der Bauart
+ *
+ *     graph.elements.some(e => e.id === t.target && e.type === 'FLOW')   // O(E), in einer T-Schleife
+ *     graph.traces.filter(t => t.source === x && t.type === 'compose')   // O(T), je Element
+ *
+ * Jede einzelne ist `O(E)` bzw. `O(T)` und steht in einer Schleife ueber die jeweils andere
+ * Menge. Der Index ersetzt beide durch konstante Lookups.
+ *
+ * ## Warum eine WeakMap und kein dritter Parameter an `evaluate`
+ *
+ * Die Alternative waere ein dritter Parameter an `RuleDefinition.evaluate` gewesen — 73
+ * Signaturen, und jede Regelfamilie muesste in einem Zug umgestellt werden. Diese Fassung
+ * kostet keine Signatur: eine Regel ruft `indexOf(graph)` und bekommt den Index, den die erste
+ * Regel desselben Laufs gebaut hat. Damit ist die Umstellung Regel fuer Regel moeglich
+ * (CR-SM-264 ist entlang der Familien geschnitten), und eine noch nicht umgestellte Regel
+ * funktioniert unveraendert weiter.
+ *
+ * Der Schluessel ist das Graph-OBJEKT. `applyRule` (se-engine) arbeitet auf einem
+ * `structuredClone` — ein anderes Objekt, also ein anderer Index, korrekt per Konstruktion.
+ * Eine `WeakMap` gibt den Eintrag frei, sobald der Graph es tut; es entsteht kein Cache, den
+ * jemand invalidieren muesste.
+ *
+ * ## Die Invariante, auf der das ruht
+ *
+ * **Regeln lesen, sie mutieren nicht.** Wuerde eine Regel `graph.elements` oder `graph.traces`
+ * in place aendern, waere der Index danach falsch — still, und nur bei den Regeln, die nach ihr
+ * laufen. `se-graph-index.test.ts` haelt das fest.
+ */
+import type { OntologyElement, OntologyGraph, Trace } from './ontology.js';
+export interface GraphIndex {
+    /** Element je id — ersetzt `elements.find(e => e.id === x)`. */
+    byId: ReadonlyMap<string, OntologyElement>;
+    /** Typ je id — ersetzt `elements.some(e => e.id === x && e.type === 'Y')`. */
+    typeOf(id: string): OntologyElement['type'] | undefined;
+    /** Elemente eines Typs, in GRAPH-Reihenfolge — ersetzt `elements.filter(e => e.type === 'X')`. */
+    elementsOfType(type: OntologyElement['type']): readonly OntologyElement[];
+    /** ids eines Typs, als Menge. */
+    idsOfType(type: OntologyElement['type']): ReadonlySet<string>;
+    /** Ausgehende Traces je (source, type), in Graph-Reihenfolge. */
+    out(source: string, type: Trace['type']): readonly Trace[];
+    /** Eingehende Traces je (target, type), in Graph-Reihenfolge. */
+    in(target: string, type: Trace['type']): readonly Trace[];
+    /** Alle Traces eines Typs, in Graph-Reihenfolge. */
+    tracesOfType(type: Trace['type']): readonly Trace[];
+    /** Alle ausgehenden Traces eines Elements, TYPUNABHAENGIG, in Graph-Reihenfolge. */
+    outAll(source: string): readonly Trace[];
+}
+/** Der Index dieses Graphen — einmal gebaut, danach konstante Lookups. */
+export declare function indexOf(graph: OntologyGraph): GraphIndex;