@sigloch/contracts 0.7.0 → 1.0.0

package/dist/se/format-e-parser.js

@@ -1,5 +1,16 @@
+/**
+ * Format E Parser — Graph mutations from compact text format.
+ * SE-relevant subset: nodes (+/-/~) and edges (+/-), no chat-canvas or views.
+ *
+ * CR-SM-216 (Format-E v2): the element type comes from the `### <TYPE>` section a node
+ * is declared under, never from the spelling of its id. The old id-derived typing made
+ * every consumer with a different id convention fail *silently* — aimpro CR-230 lost a
+ * whole graph that way (`TYPE-slug` ids rejected, result empty, no error).
+ *
+ * @sigloch/contracts/se
+ */
+import { ElementType } from './ontology.js';
 import { isValidTrace } from './meta-model.js';
-import { isSemanticId, extractFromSemanticId } from './semantic-id.js';
 // ---------------------------------------------------------------------------
 // Extraction
 // ---------------------------------------------------------------------------
@@ -21,19 +32,48 @@ const OP_PREFIX = {
     '~': 'update',
     '!': 'strict_add',
 };
-const EDGE_RE = /^([+\-~!])?\s*(\S+)\s+-(\w+)->\s+(\S+)\s*$/;
+/**
+ * CR-SM-215: the target group is `(.+)` — Format-E allows fan-out
+ * `A -x-> B, C, D`, one edge per target. `graph-api-core`'s codec has always parsed
+ * it; this parser rejected it as `Invalid edge syntax`, so the same text produced
+ * different operations depending on which parser saw it.
+ */
+const EDGE_RE = /^([+\-~!])?\s*(\S+)\s+-(\w+)->\s+(.+?)\s*$/;
 const NODE_RE = /^([+\-~!])?\s*(\S+?)(?:\|(.*))?$/;
 /** CR-147: @key value attribute line (indented, below a node entry). */
 const ATTR_RE = /^\s*@(\w+)\s+(.+)$/;
+/**
+ * BOK-CR-026: hydrate a JSON object/array attribute value. The ontology's bindings
+ * (`realRef {file,symbol?,lang?}`, `testRef {file,tool,…}`) are objects; kept as raw
+ * strings they fail RealRefSchema/TestRefSchema and the element reads as unbound.
+ * Only `{…}`/`[…]` are attempted — every other value stays the string it is, and a
+ * malformed literal falls back to the string rather than failing the whole parse.
+ */
+function hydrateAttrValue(raw) {
+    if (!/^[{[]/.test(raw))
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
 /** CR-148: Trace-type normalization aliases (source→target→from→to). */
 const TRACE_NORMALIZE = {
     FLOW: { SCHEMA: 'relation' }, // FLOW→SCHEMA io → relation
 };
+/** `### <TYPE>` — the node type section (CR-SM-216). */
+const TYPE_SECTION_RE = /^###\s+([A-Za-z_]+)\s*$/;
 /** Parse a Format E text block into validated operations. */
-export function parseFormatE(input) {
+export function parseFormatE(input, options = {}) {
     const operations = [];
     const errors = [];
     let section = null;
+    let currentType = null;
+    /** uid → type, from this text's node sections. */
+    const declared = new Map();
+    const typeOf = (uid) => declared.get(uid) ?? options.resolveType?.(uid);
     for (const rawLine of input.split('\n')) {
         const line = rawLine.trim();
         if (!line || line.startsWith('//') || line.startsWith('#!'))
@@ -45,7 +85,7 @@ export function parseFormatE(input) {
             if (lastOp && (lastOp.type === 'add_node' || lastOp.type === 'update_node' || lastOp.type === 'strict_add_node')) {
                 if (!lastOp.attributes)
                     lastOp.attributes = {};
-                lastOp.attributes[attrMatch[1]] = attrMatch[2].trim();
+                lastOp.attributes[attrMatch[1]] = hydrateAttrValue(attrMatch[2].trim());
             }
             else {
                 errors.push(`@attribute line without preceding node: "${line}"`);
@@ -55,49 +95,64 @@ export function parseFormatE(input) {
         // Section headers
         if (/^##\s*nodes?\s*$/i.test(line)) {
             section = 'nodes';
+            currentType = null;
             continue;
         }
         if (/^##\s*edges?\s*$/i.test(line)) {
             section = 'edges';
+            currentType = null;
+            continue;
+        }
+        // CR-SM-216: `### <TYPE>` carries the element type for the nodes below it.
+        const typeSection = TYPE_SECTION_RE.exec(line);
+        if (typeSection && section === 'nodes') {
+            const parsed = ElementType.safeParse(typeSection[1]);
+            if (parsed.success) {
+                currentType = parsed.data;
+            }
+            else {
+                currentType = null;
+                errors.push(`Unknown element type section: "### ${typeSection[1]}"`);
+            }
             continue;
         }
         // Skip other markdown headers
         if (line.startsWith('#'))
             continue;
-        // Try edge first (more specific pattern)
-        const edgeMatch = EDGE_RE.exec(line);
-        if (edgeMatch || section === 'edges') {
+        // Edge: detect by arrow in the structural part only — before the description
+        // pipe. Node descriptions may legitimately contain '->' ("FUNC->FUNC compose");
+        // edges carry no pipe, so splitting on '|' disambiguates (CR-GC-247). Since
+        // CR-SM-215 widened the target group to `(.+?)`, this guard is what keeps a
+        // multi-word node description from being read as an edge.
+        const isEdgeLine = line.split('|', 1)[0].includes('->');
+        if (isEdgeLine || section === 'edges') {
+            const edgeMatch = isEdgeLine ? EDGE_RE.exec(line) : null;
             if (edgeMatch) {
-                parseEdge(edgeMatch, operations, errors);
+                parseEdge(edgeMatch, typeOf, operations, errors);
             }
             else {
                 errors.push(`Invalid edge line: "${line}"`);
             }
             continue;
         }
-        // Try node
+        // Node
         if (section === 'nodes') {
             const nodeMatch = NODE_RE.exec(line);
-            if (nodeMatch) {
-                parseNode(nodeMatch, operations, errors);
+            if (!nodeMatch) {
+                errors.push(`Invalid node line: "${line}"`);
+            }
+            else if (!currentType) {
+                // CR-SM-216: no type section, no type. Guessing one from the id is what
+                // CR-230 punished; an error is the point.
+                errors.push(`Node "${nodeMatch[2]}" is not under a "### <TYPE>" section`);
             }
             else {
-                errors.push(`Invalid node line: "${line}"`);
+                declared.set(nodeMatch[2], currentType);
+                parseNode(nodeMatch, currentType, operations, errors);
             }
             continue;
         }
-        // Outside a section — try to auto-detect
-        const autoEdge = EDGE_RE.exec(line);
-        if (autoEdge) {
-            parseEdge(autoEdge, operations, errors);
-            continue;
-        }
-        const autoNode = NODE_RE.exec(line);
-        if (autoNode && isSemanticId(autoNode[2])) {
-            parseNode(autoNode, operations, errors);
-            continue;
-        }
-        // Unknown line
+        // Unknown line (edges are handled above, nodes need their section)
         if (line.length > 0)
             errors.push(`Unrecognized line: "${line}"`);
     }
@@ -111,60 +166,40 @@ function normalizeTraceType(srcType, tgtType, traceType) {
     }
     return traceType;
 }
-function parseNode(m, ops, errors) {
+function parseNode(m, elementType, ops, errors) {
     const opChar = m[1] || '+';
     const id = m[2];
     const descr = m[3]?.trim();
     const action = OP_PREFIX[opChar] ?? 'add';
-    if (!isSemanticId(id)) {
-        errors.push(`Invalid SemanticId: "${id}"`);
+    if (!id) {
+        errors.push(`Node line without an id: "${m[0]}"`);
         return;
     }
     if (action === 'remove') {
         ops.push({ type: 'remove_node', semanticId: id });
     }
     else if (action === 'update') {
-        ops.push({ type: 'update_node', semanticId: id, description: descr });
+        ops.push({ type: 'update_node', semanticId: id, elementType, description: descr });
     }
     else if (action === 'strict_add') {
-        ops.push({ type: 'strict_add_node', semanticId: id, description: descr });
+        ops.push({ type: 'strict_add_node', semanticId: id, elementType, description: descr });
     }
     else {
-        ops.push({ type: 'add_node', semanticId: id, description: descr });
+        ops.push({ type: 'add_node', semanticId: id, elementType, description: descr });
     }
 }
-function parseEdge(m, ops, errors) {
+function parseEdge(m, typeOf, ops, errors) {
     const opChar = m[1] || '+';
     const sourceId = m[2];
     const traceType = m[3];
-    const targetId = m[4];
     const action = OP_PREFIX[opChar] ?? 'add';
-    if (!isSemanticId(sourceId)) {
-        errors.push(`Invalid source SemanticId: "${sourceId}"`);
-        return;
-    }
-    if (!isSemanticId(targetId)) {
-        errors.push(`Invalid target SemanticId: "${targetId}"`);
-        return;
-    }
     if (!VALID_TRACE_TYPES.has(traceType)) {
         errors.push(`Invalid trace type: "${traceType}"`);
         return;
     }
-    // Meta-model validation (with CR-148 normalization)
-    let resolvedTraceType = traceType;
-    try {
-        const src = extractFromSemanticId(sourceId);
-        const tgt = extractFromSemanticId(targetId);
-        // CR-148: Normalize before meta-model check (e.g. FLOW→SCHEMA io → relation)
-        resolvedTraceType = normalizeTraceType(src.type, tgt.type, traceType);
-        if (!isValidTrace({ source: src.type, target: tgt.type, type: resolvedTraceType })) {
-            errors.push(`Meta-model violation: ${src.type} -${traceType}-> ${tgt.type} is not valid`);
-            return;
-        }
-    }
-    catch {
-        errors.push(`Cannot extract types from edge: ${sourceId} -${traceType}-> ${targetId}`);
+    const srcType = typeOf(sourceId);
+    if (!srcType) {
+        errors.push(`Cannot resolve type of "${sourceId}" — not declared under a "### <TYPE>" section and no resolveType provided`);
         return;
     }
     const edgeType = action === 'remove'
@@ -172,33 +207,71 @@ function parseEdge(m, ops, errors) {
         : action === 'strict_add'
             ? 'strict_add_edge'
             : 'add_edge';
-    ops.push({
-        type: edgeType,
-        semanticId: `${sourceId}->${targetId}`,
-        sourceId,
-        targetId,
-        traceType: resolvedTraceType,
-    });
+    // CR-SM-215: 1:n fan-out — `A -x-> B, C` is n independent edges. Validation runs
+    // per target (like `graph-api-core`'s codec), so one bad target does not discard
+    // its siblings.
+    const targets = m[4].split(',').map(t => t.trim()).filter(Boolean);
+    for (const targetId of targets) {
+        const tgtType = typeOf(targetId);
+        if (!tgtType) {
+            errors.push(`Cannot resolve type of "${targetId}" — not declared under a "### <TYPE>" section and no resolveType provided`);
+            continue;
+        }
+        // CR-148: Normalize before the meta-model check (e.g. FLOW→SCHEMA io → relation)
+        const resolvedTraceType = normalizeTraceType(srcType, tgtType, traceType);
+        if (!isValidTrace({ source: srcType, target: tgtType, type: resolvedTraceType })) {
+            errors.push(`Meta-model violation: ${srcType} -${traceType}-> ${tgtType} is not valid`);
+            continue;
+        }
+        ops.push({
+            type: edgeType,
+            semanticId: `${sourceId}->${targetId}`,
+            sourceId,
+            targetId,
+            traceType: resolvedTraceType,
+        });
+    }
 }
 // ---------------------------------------------------------------------------
 // Serializer
 // ---------------------------------------------------------------------------
-/** Serialize an OntologyGraph to compact Format E text. */
+/**
+ * Serialize an OntologyGraph to compact Format E text.
+ *
+ * CR-SM-216: nodes are written under `### <TYPE>` sections — the type is declared once
+ * per section instead of once per id. Measured on the graphcode SSOT graph (369
+ * elements), 12 section headers cost ~48 tokens where a per-node type attribute would
+ * have cost ~1476.
+ */
 export function serializeToFormatE(graph) {
     const lines = [];
-    // Nodes
-    if (graph.elements.length > 0) {
+    // Nodes, grouped by type
+    const modelingElements = graph.elements.filter(el => el.type !== 'SESSION'); // skip audit sessions
+    if (modelingElements.length > 0) {
         lines.push('## Nodes');
-        for (const el of graph.elements) {
-            if (el.type === 'SESSION')
-                continue; // skip audit sessions
-            const descr = el.description ? `|${el.description}` : '';
-            lines.push(`+ ${el.id}${descr}`);
-            // CR-147: Serialize known attributes
-            if (el.attributes) {
-                for (const [k, v] of Object.entries(el.attributes)) {
-                    if (v != null && String(v).length > 0) {
-                        lines.push(`  @${k} ${String(v)}`);
+        const byType = new Map();
+        for (const el of modelingElements) {
+            const group = byType.get(el.type);
+            if (group)
+                group.push(el);
+            else
+                byType.set(el.type, [el]);
+        }
+        for (const type of [...byType.keys()].sort()) {
+            lines.push(`### ${type}`);
+            for (const el of byType.get(type) ?? []) {
+                const descr = el.description ? `|${el.description}` : '';
+                lines.push(`+ ${el.id}${descr}`);
+                // CR-147: Serialize known attributes
+                if (el.attributes) {
+                    for (const [k, v] of Object.entries(el.attributes)) {
+                        if (v == null)
+                            continue;
+                        // BOK-CR-026: objects/arrays as JSON — String({}) collapses a realRef/testRef
+                        // binding to "[object Object]" and loses it on the next parse.
+                        const text = typeof v === 'object' ? JSON.stringify(v) : String(v);
+                        if (text.length > 0)
+                            lines.push(`  @${k} ${text}`);
                     }
                 }
             }

package/dist/se/index.d.ts

@@ -3,9 +3,9 @@
  * Single source of truth for SE ontology schemas across all projects.
  */
 /** Ontology schema version (element types + trace types). */
-export declare const ONTOLOGY_VERSION = "3.8.0";
+export declare const ONTOLOGY_VERSION = "4.0.0";
 /** Rules engine version (validation rules incl. RC conformance). */
-export declare const RULES_VERSION = "2.17.0";
+export declare const RULES_VERSION = "2.20.0";
 /** Meta-model version (trace pattern constraints + format-e parser). */
 export declare const META_MODEL_VERSION = "1.4.0";
 export * from './ontology.js';
@@ -24,5 +24,5 @@ export * from './quality-rules.js';
 export * from './evaluate-all.js';
 export * from './readiness.js';
 export * from './meta-model.js';
-export * from './semantic-id.js';
+export * from './element-uid.js';
 export * from './format-e-parser.js';

package/dist/se/index.js

@@ -3,9 +3,9 @@
  * Single source of truth for SE ontology schemas across all projects.
  */
 /** Ontology schema version (element types + trace types). */
-export const ONTOLOGY_VERSION = '3.8.0'; // +RepoRelativePathSchema on testRef/codeRef/schemaRef .file — no absolute/`..` paths (CR-GC-255)
+export const ONTOLOGY_VERSION = '4.0.0'; // BREAKING: `SemanticId` (`Name.TypeAbbr.Counter`) deleted, `ElementUid` (`<TYPE>-<slug>`) is the family canon — the old canon was used by no production graph of the family while 626 of 1145 elements already carried TYPE-slug (CR-SM-217); realRef unifies codeRef+schemaRef (+physical-MOD CAD ref), symbol optional; testRef stays separate (CR-228 C); +RepoRelativePathSchema on testRef/realRef .file — no absolute/`..` paths (CR-GC-255)
 /** Rules engine version (validation rules incl. RC conformance). */
-export const RULES_VERSION = '2.17.0'; // -R-24/R-25 REQ→MOD allocation rules deleted (CR-228 A: REQ→MOD allocate no longer a valid pattern, R-18 flags residual edges); NFR-01 budget target split physical→MOD / behavioral→FCHAIN; RULE_TO_DIMENSION completeness (R-18..R-23/R-26/MS-03/CR-R04 mapped, no advisory fall-through) (CR-228 B/D); +BQ-01/02/04/06/07 base-quality rules promoted from aimpro (K2-b, completes rule consolidation); +ND-01/02 near-duplicate + AO-D01/D03/CR-01/RT-01/PH-01/CA-01/IO-01 architecture rules promoted from aimpro (K2-b); +CR-R01..04/MS-03 change-request rules promoted from aimpro (K2-b); +FM-01..03/NFR-01 FMEA + VR-01/CL-01 view rules promoted from aimpro (K2-b); +MT-01..03 architecture metrics promoted from aimpro (K2-b); +SC-01..03/UC-01..06/FC-01..03 quality rules promoted from aimpro (K2-a); +RC-05 cross-module import drift (CR-212); +R-26/RC-03/RC-04 schemaRef (CR-211); +R-22..R-25/R-10/R-20 (CR-201/202/208/209/210)
+export const RULES_VERSION = '2.20.0'; // +RD-04 decomposition breadth (>11 children per level → warning) and MT-03 recalibrated to FLOW-transitive connection pairs — counting raw io traces reported internal=0 on every real SE graph (15/15 false positives), because the meta-model routes FUNC↔FUNC through FLOW; 'RD-' added to the se profile prefixes, where RD-01..04 were silently missing (CR-SM-221); -SC-01/-SC-03 deleted (BOK-CR-026): `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution); the legacy `zodDefinition`/`sourceFile`/`sourceExport` attributes are gone from every producer, SC_RULES = [SC-02]; R-20/R-26/RC-01/RC-03/RC-04 read realRef (unified codeRef+schemaRef); +R-27 physical-MOD realRef presence (CR-228 C); -R-24/R-25 REQ→MOD allocation rules deleted (CR-228 A: REQ→MOD allocate no longer a valid pattern, R-18 flags residual edges); NFR-01 budget target split physical→MOD / behavioral→FCHAIN; RULE_TO_DIMENSION completeness (R-18..R-23/R-26/MS-03/CR-R04 mapped, no advisory fall-through) (CR-228 B/D); +BQ-01/02/04/06/07 base-quality rules promoted from aimpro (K2-b, completes rule consolidation); +ND-01/02 near-duplicate + AO-D01/D03/CR-01/RT-01/PH-01/CA-01/IO-01 architecture rules promoted from aimpro (K2-b); +CR-R01..04/MS-03 change-request rules promoted from aimpro (K2-b); +FM-01..03/NFR-01 FMEA + VR-01/CL-01 view rules promoted from aimpro (K2-b); +MT-01..03 architecture metrics promoted from aimpro (K2-b); +SC-01..03/UC-01..06/FC-01..03 quality rules promoted from aimpro (K2-a); +RC-05 cross-module import drift (CR-212); +R-26/RC-03/RC-04 schemaRef (CR-211); +R-22..R-25/R-10/R-20 (CR-201/202/208/209/210)
 /** Meta-model version (trace pattern constraints + format-e parser). */
 export const META_MODEL_VERSION = '1.4.0'; // -REQ→MOD allocate pattern removed (CR-228 A); +FUNC→FUNC compose (blackbox function decomposition)
 export * from './ontology.js';
@@ -24,5 +24,5 @@ export * from './quality-rules.js';
 export * from './evaluate-all.js';
 export * from './readiness.js';
 export * from './meta-model.js';
-export * from './semantic-id.js';
+export * from './element-uid.js';
 export * from './format-e-parser.js';

package/dist/se/meta-model.js

@@ -8,7 +8,7 @@ export const TRACE_PATTERNS = [
     { source: 'UC', target: 'FCHAIN', type: 'compose', cardinality: '1..*', description: 'UC behavioral scenarios' },
     { source: 'UC', target: 'REQ', type: 'compose', cardinality: '1..*', description: 'UC functional/non-functional requirements' },
     { source: 'FCHAIN', target: 'FUNC', type: 'compose', cardinality: '1..*', description: 'Functions participating in chain' },
-    { source: 'FUNC', target: 'FUNC', type: 'compose', cardinality: '0..*', description: 'Function (blackbox architecture block) decomposes into sub-functions one level deeper; leaf FUNCs carry codeRef, the parent is realized by its children' },
+    { source: 'FUNC', target: 'FUNC', type: 'compose', cardinality: '0..*', description: 'Function (blackbox architecture block) decomposes into sub-functions one level deeper; leaf FUNCs carry realRef, the parent is realized by its children' },
     { source: 'REQ', target: 'REQ', type: 'compose', cardinality: '0..*', description: 'Requirement decomposes into sub-requirements (incl. mitigation)' },
     // ── io (data exchange, always through FLOW) ──
     { source: 'ACTOR', target: 'FLOW', type: 'io', description: 'Actor triggers/receives via flow' },

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

@@ -19,11 +19,11 @@ export declare function mt01Instability(graph: OntologyGraph): RuleViolation[];
  */
 export declare function mt02Lcom4(graph: OntologyGraph): RuleViolation[];
 /**
- * MT-03: Allocation Cohesion (CR-191: reformulated).
- * cohesion = internal_flows / (internal_flows + external_flows).
- * internal_flows = io traces between FUNCs within the same module.
- * external_flows = io traces crossing module boundary (one end inside, one outside).
- * If external_flows === 0 → cohesion = 100% → OK.
+ * MT-03: Allocation Cohesion (CR-191 reformulated, CR-SM-221 recalibrated).
+ * cohesion = internal / (internal + external), over FLOW-transitive connection pairs.
+ * internal = both endpoints allocated to this module.
+ * external = exactly one endpoint allocated to this module.
+ * If external === 0 → cohesion = 100% → OK.
  */
 export declare function mt03AllocationCohesion(graph: OntologyGraph): RuleViolation[];
 export declare const MT_RULES: readonly [{

package/dist/se/metric-rules.js

@@ -151,48 +151,95 @@ export function mt02Lcom4(graph) {
     return violations;
 }
 /**
- * MT-03: Allocation Cohesion (CR-191: reformulated).
- * cohesion = internal_flows / (internal_flows + external_flows).
- * internal_flows = io traces between FUNCs within the same module.
- * external_flows = io traces crossing module boundary (one end inside, one outside).
- * If external_flows === 0 → cohesion = 100% → OK.
+ * CR-SM-221: connection pairs between non-FLOW elements, FLOW-transitive.
+ *
+ * The SE meta-model routes FUNC↔FUNC communication through FLOW nodes
+ * (`FUNC —io→ FLOW —io→ FUNC`); a direct FUNC→FUNC io trace is the exception, not
+ * the rule. Counting raw io traces therefore found *zero* internal edges on every
+ * real graph — measured on graphcode (369 elements), graph-view-edit (257) and the
+ * family graph (638): 15 of 15 MODs reported internal=0, i.e. 15 false positives and
+ * no discriminating power at all.
+ *
+ * A pair counts once, no matter how many flows connect it: the metric asks "do these
+ * two talk to each other", not "how often".
+ */
+function connectionPairs(graph) {
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const pairs = new Set();
+    const add = (a, b) => {
+        if (a !== b)
+            pairs.add(a < b ? `${a}|${b}` : `${b}|${a}`);
+    };
+    const intoFlow = new Map(); // flow → producers
+    const outOfFlow = new Map(); // flow → consumers
+    const push = (m, k, v) => {
+        const list = m.get(k);
+        if (list)
+            list.push(v);
+        else
+            m.set(k, [v]);
+    };
+    for (const t of graph.traces) {
+        if (t.type !== 'io')
+            continue;
+        const srcIsFlow = typeOf.get(t.source) === 'FLOW';
+        const tgtIsFlow = typeOf.get(t.target) === 'FLOW';
+        if (srcIsFlow && tgtIsFlow)
+            continue; // FLOW→FLOW carries no endpoint
+        if (!srcIsFlow && !tgtIsFlow) {
+            add(t.source, t.target);
+            continue;
+        }
+        if (tgtIsFlow)
+            push(intoFlow, t.target, t.source);
+        else
+            push(outOfFlow, t.source, t.target);
+    }
+    for (const [flow, producers] of intoFlow) {
+        for (const consumer of outOfFlow.get(flow) ?? []) {
+            for (const producer of producers)
+                add(producer, consumer);
+        }
+    }
+    return pairs;
+}
+/**
+ * MT-03: Allocation Cohesion (CR-191 reformulated, CR-SM-221 recalibrated).
+ * cohesion = internal / (internal + external), over FLOW-transitive connection pairs.
+ * internal = both endpoints allocated to this module.
+ * external = exactly one endpoint allocated to this module.
+ * If external === 0 → cohesion = 100% → OK.
  */
 export function mt03AllocationCohesion(graph) {
     const violations = [];
     const mods = graph.elements.filter(e => e.type === 'MOD');
     const COHESION_THRESHOLD = 0.8;
+    const pairs = [...connectionPairs(graph)].map(p => p.split('|'));
     for (const mod of mods) {
         const allocTraces = graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id);
         const funcIds = new Set(allocTraces.map(t => t.source));
         if (funcIds.size < 2)
             continue;
-        let internalFlows = 0;
-        let externalFlows = 0;
-        for (const t of graph.traces) {
-            if (t.type !== 'io')
-                continue;
-            const srcIn = funcIds.has(t.source);
-            const tgtIn = funcIds.has(t.target);
-            if (srcIn && tgtIn) {
-                internalFlows++;
-            }
-            else if (srcIn || tgtIn) {
-                externalFlows++;
-            }
+        let internal = 0;
+        let external = 0;
+        for (const [a, b] of pairs) {
+            const aIn = funcIds.has(a);
+            const bIn = funcIds.has(b);
+            if (aIn && bIn)
+                internal++;
+            else if (aIn || bIn)
+                external++;
         }
-        // No external flows → cohesion = 100% → OK
-        if (externalFlows === 0)
-            continue;
-        const total = internalFlows + externalFlows;
-        if (total === 0)
+        // No external connections → cohesion = 100% → OK
+        if (external === 0)
             continue;
-        const cohesion = internalFlows / total;
+        const cohesion = internal / (internal + external);
         if (cohesion < COHESION_THRESHOLD) {
             violations.push({
                 rule_id: 'MT-03',
                 severity: 'info',
                 element_id: mod.id,
-                message: `${mod.name} allocation cohesion ${Math.round(cohesion * 100)}% (<${COHESION_THRESHOLD * 100}%). internal=${internalFlows}, external=${externalFlows}`,
+                message: `${mod.name} allocation cohesion ${Math.round(cohesion * 100)}% (<${COHESION_THRESHOLD * 100}%). internal=${internal}, external=${external}`,
             });
         }
     }

package/dist/se/ontology.d.ts

@@ -110,40 +110,27 @@ export declare const TestRefSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TestRef = z.infer<typeof TestRefSchema>;
 /**
- * Code binding for a FUNC element (CR-GC-205 Item 5, ontology bump 3.6.0).
- * Resolves a FUNC node to the concrete code symbol that realizes it, enabling
- * graph<->code conformance: every non-concept/non-external FUNC must resolve to a
- * real symbol in its allocated MOD's file, and (via the consumer's LSP-backed
- * check) every cross-module-called symbol must itself be a FUNC node.
- *   - `file`   : implementation file path, e.g. `src/harness.ts` (the symbol's home).
- *   - `symbol` : the exported symbol (function/method/class) name realizing the FUNC.
- *   - `lang`   : optional language id (default `ts`) — selects the LSP/engine the
- *               conformance check drives, so the binding is language-agnostic.
- * Stored under `OntologyElement.attributes.codeRef` (additive, opt-in validation).
+ * Realization binding for an element (CR-228, ontology bump 3.9.0) — unifies the
+ * byte-identical former `codeRef` (FUNC → code symbol) and `schemaRef` (SCHEMA →
+ * Zod export), and extends to MOD (physical part → CAD/geometry artefact). The
+ * *type* of the pointing element disambiguates what kind of realization it is:
+ * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRef`
+ * (a TEST is not just located but *executed* — the runner is the extra value).
+ *   - `file`   : realization file path, e.g. `src/harness.ts`, `part.step`.
+ *   - `symbol` : the realizing symbol (function/class/Zod export). Optional — a
+ *               geometry artefact (CAD) has no symbol; file-exists is the binding.
+ *   - `lang`   : optional language/format id (default `ts`) — selects the
+ *               conformance engine, so the binding is language-agnostic.
+ * Stored under `OntologyElement.attributes.realRef` (additive, opt-in validation).
+ * The free-text SCHEMA `contract` attribute stays a human description, not the
+ * conformance basis: RC-01/RC-03 resolve this binding, RC-04 checks it is parsed.
  */
-export declare const CodeRefSchema: z.ZodObject<{
+export declare const RealRefSchema: z.ZodObject<{
     file: z.ZodString;
-    symbol: z.ZodString;
+    symbol: z.ZodOptional<z.ZodString>;
     lang: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type CodeRef = z.infer<typeof CodeRefSchema>;
-/**
- * Binding of a SCHEMA node to the Zod schema that defines it (CR-211), analogous
- * to CodeRefSchema for FUNC:
- *   - `file`   : the source file declaring the Zod schema, e.g. `src/se/ontology.ts`.
- *   - `symbol` : the exported schema symbol, e.g. `CodeRefSchema`.
- *   - `lang`   : optional language id (default `ts`).
- * Stored under `OntologyElement.attributes.schemaRef`. The free-text `contract`
- * attribute stays as a human description but is no longer the conformance basis:
- * RC-03 resolves this binding to a declared export, RC-04 checks it is parsed at
- * the modelled interface.
- */
-export declare const SchemaRefSchema: z.ZodObject<{
-    file: z.ZodString;
-    symbol: z.ZodString;
-    lang: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type SchemaRef = z.infer<typeof SchemaRefSchema>;
+export type RealRef = z.infer<typeof RealRefSchema>;
 /**
  * An element (node) in the SE ontology graph.
  * `attributes` holds type-specific properties (e.g. FUNC.safety_relevant).