@sigloch/contracts 0.8.0 → 2.0.0

package/dist/se/element-uid.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ElementUid — the family's canonical element id form (CR-SM-217).
+ *
+ *     <TYPE>-<slug>        ACTOR-claude-code · REQ-safety · MOD-harness
+ *
+ * Decided on 2026-07-27 over the previous `Name.TypeAbbr.Counter` schema, in this order:
+ *
+ * 1. **Token-neutral.** Measured on the graphcode SSOT graph (1871 uid occurrences,
+ *    cl100k_base): `ACTOR-claude-code.ACTOR` 5.28 tok/uid vs `claudecode.ACTOR.001`
+ *    5.30 — 0.3 % apart. The spelling costs nothing, so it is decided on correctness.
+ * 2. **It is what the real graphs use.** 626 of 1145 family elements are already
+ *    `TYPE-slug`; the schema's declared canon had 89.
+ * 3. **It keeps a free type cross-check.** CR-SM-216 moved the type into the `### <TYPE>`
+ *    section, which removes the "type appears twice" redundancy that used to catch a
+ *    mis-sectioned node. A `TYPE-slug` uid carries the type in its prefix without paying
+ *    for it (`REQ-safety` = 3 tokens, `REQ-safety.REQ` = 5), so the check survives.
+ *
+ * `parseElementUid` exists **only** for that cross-check. It is never a type source —
+ * the type comes from the graph or from the Format-E section (CR-SM-216 contract).
+ *
+ * **Not every id is an ElementUid, and that is allowed.** Ids that mirror an external
+ * identifier live in their own namespace and are simply unchecked, never rejected:
+ * CR elements carry their change-request number (`CR-GC-100`, 88 in graphcode, 123 in
+ * graph-view-edit) and graphify's pre-gate candidates are `cand_<hex>`. The canon binds
+ * *new* ids minted through `toElementUid`; existing ids stay until their repo touches
+ * them.
+ */
+import { z } from 'zod/v4';
+import { ElementType } from './ontology.js';
+/** Longest slug we accept; keeps ids readable and index-friendly. */
+export declare const MAX_SLUG_LENGTH = 60;
+export declare const ElementUid: z.ZodString;
+export type ElementUid = z.infer<typeof ElementUid>;
+/**
+ * Build a canonical uid. Pure and deterministic — the same (type, name) always yields
+ * the same uid.
+ *
+ * Collisions are the **caller's** problem: only the caller knows the namespace, so
+ * disambiguation (`-2`, `-3`) belongs there. Documented rather than hidden behind a
+ * counter that would make this function stateful.
+ */
+export declare function toElementUid(type: ElementType, name: string): string;
+/**
+ * Split a uid into its parts. Throws when the prefix is not an ElementType.
+ *
+ * ⚠️ For the prefix↔section cross-check only — **never** as a type source. Deriving a
+ * type from an id's spelling is what made aimpro CR-230 drop an entire graph silently.
+ */
+export declare function parseElementUid(uid: string): {
+    type: ElementType;
+    slug: string;
+};
+/** Non-throwing variant: `undefined` for ids of any other convention (legacy, graphify candidates). */
+export declare function tryParseElementUid(uid: string): {
+    type: ElementType;
+    slug: string;
+} | undefined;
+/** True when `uid` is a canonical ElementUid. */
+export declare function isElementUid(uid: string): boolean;

package/dist/se/element-uid.js

@@ -0,0 +1,74 @@
+/**
+ * ElementUid — the family's canonical element id form (CR-SM-217).
+ *
+ *     <TYPE>-<slug>        ACTOR-claude-code · REQ-safety · MOD-harness
+ *
+ * Decided on 2026-07-27 over the previous `Name.TypeAbbr.Counter` schema, in this order:
+ *
+ * 1. **Token-neutral.** Measured on the graphcode SSOT graph (1871 uid occurrences,
+ *    cl100k_base): `ACTOR-claude-code.ACTOR` 5.28 tok/uid vs `claudecode.ACTOR.001`
+ *    5.30 — 0.3 % apart. The spelling costs nothing, so it is decided on correctness.
+ * 2. **It is what the real graphs use.** 626 of 1145 family elements are already
+ *    `TYPE-slug`; the schema's declared canon had 89.
+ * 3. **It keeps a free type cross-check.** CR-SM-216 moved the type into the `### <TYPE>`
+ *    section, which removes the "type appears twice" redundancy that used to catch a
+ *    mis-sectioned node. A `TYPE-slug` uid carries the type in its prefix without paying
+ *    for it (`REQ-safety` = 3 tokens, `REQ-safety.REQ` = 5), so the check survives.
+ *
+ * `parseElementUid` exists **only** for that cross-check. It is never a type source —
+ * the type comes from the graph or from the Format-E section (CR-SM-216 contract).
+ *
+ * **Not every id is an ElementUid, and that is allowed.** Ids that mirror an external
+ * identifier live in their own namespace and are simply unchecked, never rejected:
+ * CR elements carry their change-request number (`CR-GC-100`, 88 in graphcode, 123 in
+ * graph-view-edit) and graphify's pre-gate candidates are `cand_<hex>`. The canon binds
+ * *new* ids minted through `toElementUid`; existing ids stay until their repo touches
+ * them.
+ */
+import { z } from 'zod/v4';
+import { ElementType } from './ontology.js';
+/** Longest slug we accept; keeps ids readable and index-friendly. */
+export const MAX_SLUG_LENGTH = 60;
+/** Built from the live ElementType enum — there is no second type catalogue. */
+const UID_RE = new RegExp(`^(${ElementType.options.join('|')})-([a-z0-9]+(?:-[a-z0-9]+)*)$`);
+export const ElementUid = z.string()
+    .regex(UID_RE, 'ElementUid must match <TYPE>-<kebab-slug>')
+    .refine(uid => (uid.split('-').slice(1).join('-')).length <= MAX_SLUG_LENGTH, `slug must be at most ${MAX_SLUG_LENGTH} characters`);
+/**
+ * Build a canonical uid. Pure and deterministic — the same (type, name) always yields
+ * the same uid.
+ *
+ * Collisions are the **caller's** problem: only the caller knows the namespace, so
+ * disambiguation (`-2`, `-3`) belongs there. Documented rather than hidden behind a
+ * counter that would make this function stateful.
+ */
+export function toElementUid(type, name) {
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, MAX_SLUG_LENGTH)
+        .replace(/-+$/, '');
+    return `${type}-${slug}`;
+}
+/**
+ * Split a uid into its parts. Throws when the prefix is not an ElementType.
+ *
+ * ⚠️ For the prefix↔section cross-check only — **never** as a type source. Deriving a
+ * type from an id's spelling is what made aimpro CR-230 drop an entire graph silently.
+ */
+export function parseElementUid(uid) {
+    const m = UID_RE.exec(uid);
+    if (!m)
+        throw new Error(`Not an ElementUid: "${uid}" — expected <TYPE>-<kebab-slug>`);
+    return { type: m[1], slug: m[2] };
+}
+/** Non-throwing variant: `undefined` for ids of any other convention (legacy, graphify candidates). */
+export function tryParseElementUid(uid) {
+    const m = UID_RE.exec(uid);
+    return m ? { type: m[1], slug: m[2] } : undefined;
+}
+/** True when `uid` is a canonical ElementUid. */
+export function isElementUid(uid) {
+    return ElementUid.safeParse(uid).success;
+}

package/dist/se/evaluate-all.js

@@ -23,7 +23,9 @@ export const ALL_RULE_DEFS = [
     ...FM_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
     ...VIEW_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
 ];
-const SE_PREFIXES = ['R-', 'UC-', 'FC-', 'SC-', 'MT-', 'CR-', 'AO-', 'FM-', 'NFR-', 'RT-', 'PH-', 'CA-', 'IO-', 'VR-', 'CL-'];
+// CR-SM-221: 'RD-' was missing — 'RD-01'.startsWith('R-') is false, so the
+// decomposition rules ran in `default` only and never in the `se` profile.
+const SE_PREFIXES = ['R-', 'RD-', 'UC-', 'FC-', 'SC-', 'MT-', 'CR-', 'AO-', 'FM-', 'NFR-', 'RT-', 'PH-', 'CA-', 'IO-', 'VR-', 'CL-'];
 const CODING_PREFIXES = ['BQ-', 'ND-'];
 export function getRuleDefsForProfile(profile) {
     if (profile === 'se')

package/dist/se/format-e-parser.d.ts

@@ -1,17 +1,33 @@
 /**
  * Format E Parser — Graph mutations from compact text format.
  * SE-relevant subset: nodes (+/-/~) and edges (+/-), no chat-canvas or views.
- * ~150 LOC, no external dependencies beyond @sigloch/contracts/se.
+ *
+ * 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 type { TraceType, OntologyGraph } from './ontology.js';
 export interface FormatEOperation {
     type: 'add_node' | 'remove_node' | 'update_node' | 'add_edge' | 'remove_edge' | 'strict_add_node' | 'strict_add_edge';
     semanticId: string;
+    /**
+     * CR-SM-216: the element type, taken from the node's `### <TYPE>` section. Set on
+     * every node-creating operation — consumers must read it instead of re-deriving a
+     * type from the id.
+     */
+    elementType?: ElementType;
     description?: string;
-    /** CR-147: Parsed @key value attributes from lines below the node entry. */
-    attributes?: Record<string, string>;
+    /**
+     * CR-147: Parsed @key value attributes from lines below the node entry.
+     * Values are strings, EXCEPT JSON object/array literals which are hydrated
+     * (BOK-CR-026) — object-valued bindings like `realRef`/`testRef` must reach
+     * `attributes` as objects or R-26/R-19 reject them as invalid.
+     */
+    attributes?: Record<string, unknown>;
     sourceId?: string;
     targetId?: string;
     traceType?: TraceType;
@@ -22,7 +38,23 @@ export interface FormatEDiff {
 }
 /** Extract a ```format-e block from LLM output. Returns null if not found. */
 export declare function extractFormatE(llmOutput: string): string | null;
+export interface ParseFormatEOptions {
+    /**
+     * CR-SM-216: resolve the type of a uid that this text does not declare. A mutation
+     * diff adding edges between existing nodes carries no `## Nodes` block, so the
+     * caller binds this to its store. Without it such a diff is an error, never a
+     * silent skip.
+     */
+    resolveType?: (uid: string) => ElementType | undefined;
+}
 /** Parse a Format E text block into validated operations. */
-export declare function parseFormatE(input: string): FormatEDiff;
-/** Serialize an OntologyGraph to compact Format E text. */
+export declare function parseFormatE(input: string, options?: ParseFormatEOptions): FormatEDiff;
+/**
+ * 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 declare function serializeToFormatE(graph: OntologyGraph): string;

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.9.0";
+export declare const ONTOLOGY_VERSION = "4.0.0";
 /** Rules engine version (validation rules incl. RC conformance). */
-export declare const RULES_VERSION = "2.18.0";
+export declare const RULES_VERSION = "2.21.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.9.0'; // 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)
+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.18.0'; // 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)
+export const RULES_VERSION = '2.21.0'; // -MT-03 retired as a rule and reborn as the `allocationCohesion` measurement (CR-SM-223): the 80 % threshold fired on 6/7 graphcode, 4/4 gve and 10/11 family modules — in a flow-routed architecture cross-boundary interaction is the design, not a defect; the metric now reports internal/external per MOD, worst-first, and stays out of the violation stream so it cannot depress the readiness score; +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/metric-rules.d.ts

@@ -18,14 +18,41 @@ export declare function mt01Instability(graph: OntologyGraph): RuleViolation[];
  * Components > 1 → info.
  */
 export declare function mt02Lcom4(graph: OntologyGraph): RuleViolation[];
+/** One module's allocation-cohesion measurement (CR-SM-223). */
+export interface AllocationCohesion {
+    moduleId: string;
+    moduleName: string;
+    /** Connection pairs with both endpoints allocated to this module. */
+    internal: number;
+    /** Connection pairs with exactly one endpoint allocated to this module. */
+    external: number;
+    /** internal / (internal + external), in [0, 1]. */
+    cohesion: number;
+}
 /**
- * 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.
+ * Allocation cohesion — a **measurement, not a rule** (CR-SM-223, decision 2026-07-29).
+ *
+ * It used to be MT-03 with an 80 % threshold, and it fired on nearly every module of
+ * every real graph: 6 of 7 on graphcode, 4 of 4 on graph-view-edit, 10 of 11 on the
+ * family graph. `CR-SM-221` first suspected the edge definition and made it
+ * FLOW-transitive — the hit rate did not move. The threshold was the miscalibration:
+ * in a flow-routed layered architecture, module interaction crosses boundaries by
+ * design, so "80 % of interaction is internal" describes a monolith, not a healthy
+ * module.
+ *
+ * Rather than fit a cut-off to 11 data points, this reports the number and lets the
+ * architect judge. Returned worst-first, so the head of the list is where to look.
+ * Modules with fewer than two allocated FUNCs, or with no external connection at all,
+ * carry no signal and are omitted.
+ *
+ * Deliberately NOT a `RuleDefinition`: `computeReadiness` counts every violation into
+ * its dimension score regardless of severity, so a per-module advisory would depress
+ * the `alloc` score permanently. A measurement must not masquerade as a defect.
+ *
+ * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
+ * is deferred (CR-SM-223).
  */
-export declare function mt03AllocationCohesion(graph: OntologyGraph): RuleViolation[];
+export declare function allocationCohesion(graph: OntologyGraph): AllocationCohesion[];
 export declare const MT_RULES: readonly [{
     readonly id: "MT-01";
     readonly name: "Module instability";
@@ -36,10 +63,5 @@ export declare const MT_RULES: readonly [{
     readonly name: "Module cohesion (LCOM4)";
     readonly severity: "info";
     readonly evaluate: typeof mt02Lcom4;
-}, {
-    readonly id: "MT-03";
-    readonly name: "Allocation cohesion";
-    readonly severity: "info";
-    readonly evaluate: typeof mt03AllocationCohesion;
 }];
 export declare function evaluateMTRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/metric-rules.js

@@ -151,57 +151,117 @@ 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".
  */
-export function mt03AllocationCohesion(graph) {
-    const violations = [];
+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;
+}
+/**
+ * Allocation cohesion — a **measurement, not a rule** (CR-SM-223, decision 2026-07-29).
+ *
+ * It used to be MT-03 with an 80 % threshold, and it fired on nearly every module of
+ * every real graph: 6 of 7 on graphcode, 4 of 4 on graph-view-edit, 10 of 11 on the
+ * family graph. `CR-SM-221` first suspected the edge definition and made it
+ * FLOW-transitive — the hit rate did not move. The threshold was the miscalibration:
+ * in a flow-routed layered architecture, module interaction crosses boundaries by
+ * design, so "80 % of interaction is internal" describes a monolith, not a healthy
+ * module.
+ *
+ * Rather than fit a cut-off to 11 data points, this reports the number and lets the
+ * architect judge. Returned worst-first, so the head of the list is where to look.
+ * Modules with fewer than two allocated FUNCs, or with no external connection at all,
+ * carry no signal and are omitted.
+ *
+ * Deliberately NOT a `RuleDefinition`: `computeReadiness` counts every violation into
+ * its dimension score regardless of severity, so a per-module advisory would depress
+ * the `alloc` score permanently. A measurement must not masquerade as a defect.
+ *
+ * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
+ * is deferred (CR-SM-223).
+ */
+export function allocationCohesion(graph) {
+    const measurements = [];
     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));
+        const funcIds = new Set(graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id).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 → nothing to compare against, no signal.
+        if (external === 0)
             continue;
-        const cohesion = internalFlows / total;
-        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}`,
-            });
-        }
+        measurements.push({
+            moduleId: mod.id,
+            moduleName: mod.name,
+            internal,
+            external,
+            cohesion: internal / (internal + external),
+        });
     }
-    return violations;
+    // Worst first; stable by id so the ranking is deterministic.
+    return measurements.sort((a, b) => a.cohesion - b.cohesion || (a.moduleId < b.moduleId ? -1 : a.moduleId > b.moduleId ? 1 : 0));
 }
 export const MT_RULES = [
     { id: 'MT-01', name: 'Module instability', severity: 'warning', evaluate: mt01Instability },
     { id: 'MT-02', name: 'Module cohesion (LCOM4)', severity: 'info', evaluate: mt02Lcom4 },
-    { id: 'MT-03', name: 'Allocation cohesion', severity: 'info', evaluate: mt03AllocationCohesion },
+    // MT-03 retired as a rule (CR-SM-223) — see `allocationCohesion` above.
 ];
 export function evaluateMTRules(graph) {
     return MT_RULES.flatMap(r => r.evaluate(graph));

package/dist/se/readiness.js

@@ -9,7 +9,7 @@ export const ReadinessDimension = z.enum([
     'arch', // Functional architecture (R-02, R-03, R-10, R-12)
     'alloc', // Module allocation (R-04)
     'ver', // Test coverage (R-01, R-05)
-    'schema', // Interface completeness (SC-01..03)
+    'schema', // Interface completeness (R-26 binding, SC-02 usage)
     'cr', // CR traceability (CR-R01..R03)
     'ms', // Milestone planning (MS-01..02)
 ]);
@@ -37,6 +37,8 @@ export const RULE_TO_DIMENSION = {
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': 'req',
     'RD-01': 'req', 'RD-02': 'req', 'RD-03': 'req',
+    // RD-04 is decomposition *breadth* — an architecture concern, not a requirement one
+    'RD-04': 'arch',
     // trace/realization/allocation completeness rules (CR-228 D: previously unmapped → advisory fall-through)
     'R-18': 'arch', 'R-19': 'ver', 'R-20': 'arch', 'R-21': 'ver',
     'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', 'R-27': 'arch',
@@ -52,13 +54,15 @@ export const RULE_TO_DIMENSION = {
     // ver
     'R-01': 'ver', 'R-05': 'ver',
     // schema
-    'SC-01': 'schema', 'SC-02': 'schema', 'SC-03': 'schema',
+    'SC-02': 'schema', // SC-01/SC-03 deleted (BOK-CR-026) — R-26 is the binding rule
     // structural rules without primary dimension → assigned by closest concern
     'R-08': 'arch',
     // near-duplicate detection
     'ND-01': 'arch', 'ND-02': 'schema',
     // architecture metrics
-    'MT-01': 'alloc', 'MT-02': 'alloc', 'MT-03': 'alloc',
+    // MT-03 is no longer here: it became a measurement (`allocationCohesion`), not a
+    // rule (CR-SM-223) — a per-module advisory would depress this score permanently.
+    'MT-01': 'alloc', 'MT-02': 'alloc',
     // CR traceability
     'CR-R01': 'cr', 'CR-R02': 'cr', 'CR-R03': 'cr', 'CR-R04': 'cr',
     // architecture optimization

package/dist/se/rules.js

@@ -411,6 +411,58 @@ function noPrematureDecomposition(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// RD-04: Decomposition breadth (CR-SM-221)
+// ---------------------------------------------------------------------------
+/**
+ * Max children on one decomposition level. The 7–11 convention existed only as
+ * prose ("darüber func-of-func"); below 7 is a guideline, not a violation, so only
+ * the upper bound is a rule.
+ *
+ * Counted per (parent, kind) — a MOD that both holds 12 FUNCs and composes 12
+ * sub-MODs has two breadth problems, not one. (The spike reference merged both into
+ * a single counter on the MOD id and would have reported 24 under one kind.)
+ */
+const DECOMPOSITION_BREADTH_MAX = 11;
+function decompositionBreadth(graph) {
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const byId = new Map(graph.elements.map(e => [e.id, e]));
+    const counts = new Map();
+    const bump = (parentId, kind) => {
+        const key = `${parentId}${kind}`;
+        const entry = counts.get(key);
+        if (entry)
+            entry.n++;
+        else
+            counts.set(key, { parentId, kind, n: 1 });
+    };
+    for (const t of graph.traces) {
+        const src = typeOf.get(t.source);
+        const tgt = typeOf.get(t.target);
+        if (t.type === 'compose' && src === 'FUNC' && tgt === 'FUNC') {
+            bump(t.source, 'sub-FUNC');
+        }
+        else if (t.type === 'allocate' && tgt === 'MOD' && src === 'FUNC') {
+            bump(t.target, 'allocated FUNC');
+        }
+        else if (t.type === 'compose' && (src === 'SYS' || src === 'MOD') && tgt === 'MOD') {
+            bump(t.source, 'sub-MOD');
+        }
+    }
+    return [...counts.values()]
+        .filter(c => c.n > DECOMPOSITION_BREADTH_MAX)
+        .map(c => {
+        const parent = byId.get(c.parentId);
+        return {
+            rule_id: 'RD-04',
+            severity: 'warning',
+            element_id: c.parentId,
+            message: `${c.parentId} has ${c.n} ${c.kind} children on one level (>${DECOMPOSITION_BREADTH_MAX})`,
+            fix_hint: 'Introduce an intermediate level (func-of-func / sub-MOD)',
+            context: { element_type: parent?.type, element_name: parent?.name },
+        };
+    });
+}
+// ---------------------------------------------------------------------------
 // R-14: UC must have at least 1 compose trace (→ FCHAIN or REQ) (CR-117)
 // ---------------------------------------------------------------------------
 function ucMustHaveCompose(graph) {
@@ -870,6 +922,7 @@ export const V3_RULES = [
     { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement },
     { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency },
     { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition },
+    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth },
     { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope },
     { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency },
 ];

package/dist/se/schema-quality-rules.d.ts

@@ -1,11 +1,19 @@
 /**
- * SC-01..SC-03 — Schema Quality rules (CR-122).
- * Complement V3 structural rules with content checks on SCHEMA elements.
+ * SC-02 — Schema Quality rule (CR-122, reduced by BOK-CR-026).
+ *
+ * SC-01 (`zodDefinition` present) and SC-03 (`sourceFile`/`sourceExport` present) were
+ * DELETED: both re-asked R-26's question ("is this SCHEMA bound to code?") on legacy
+ * attributes and fired on exactly the same elements (Jaccard 1.0 vs R-26). SC-03 had
+ * additionally become wrong — a SCHEMA correctly bound via `realRef` still fired it.
+ * `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution);
+ * a spec-only SCHEMA is `concept:true`, it does NOT carry a Zod body copy in the graph
+ * (same rule as TEST: bindings point at code, they never mirror it).
+ *
+ * What remains here is the one SCHEMA check that is NOT about binding: is the interface
+ * used by any FLOW.
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
-export declare function sc01HasDefinition(graph: OntologyGraph): RuleViolation[];
 export declare function sc02IsReferenced(graph: OntologyGraph): RuleViolation[];
-export declare function sc03IsImplemented(graph: OntologyGraph): RuleViolation[];
 export declare const SC_RULES: RuleDefinition[];
 export declare function evaluateSCRules(graph: OntologyGraph): RuleViolation[];

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

@@ -1,26 +1,4 @@
 // ---------------------------------------------------------------------------
-// SC-01: SCHEMA must have zodDefinition attribute
-// ---------------------------------------------------------------------------
-export function sc01HasDefinition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'SCHEMA')
-        .filter(s => {
-        const def = s.attributes?.zodDefinition;
-        return !def || (typeof def === 'string' && def.trim().length === 0);
-    })
-        .map(s => ({
-        rule_id: 'SC-01',
-        severity: 'warning',
-        element_id: s.id,
-        message: `${s.id} has no zodDefinition attribute`,
-        fix_hint: 'Add zodDefinition attribute with Zod schema string',
-        context: {
-            element_type: s.type,
-            element_name: s.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // SC-02: SCHEMA must be referenced by at least one FLOW via relation trace
 // ---------------------------------------------------------------------------
 export function sc02IsReferenced(graph) {
@@ -42,31 +20,10 @@ export function sc02IsReferenced(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// SC-03: SCHEMA should have sourceFile (implementation marker)
-// ---------------------------------------------------------------------------
-export function sc03IsImplemented(graph) {
-    return graph.elements
-        .filter(e => e.type === 'SCHEMA')
-        .filter(s => !s.attributes?.sourceFile && !s.attributes?.sourceExport)
-        .map(s => ({
-        rule_id: 'SC-03',
-        severity: 'info',
-        element_id: s.id,
-        message: `${s.id} has no sourceFile/sourceExport (not implemented yet)`,
-        fix_hint: 'Implement the Zod schema in code and set sourceFile/sourceExport',
-        context: {
-            element_type: s.type,
-            element_name: s.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
-    { id: 'SC-01', name: 'Schema has definition', severity: 'warning', evaluate: sc01HasDefinition },
     { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced },
-    { id: 'SC-03', name: 'Schema is implemented', severity: 'info', evaluate: sc03IsImplemented },
 ];
 export function evaluateSCRules(graph) {
     return SC_RULES.flatMap(rule => rule.evaluate(graph));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "0.8.0",
+  "version": "2.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/se/semantic-id.d.ts

@@ -1,30 +0,0 @@
-/**
- * SemanticId — Format-E canonical element ID schema.
- * Aligned with graphengine CR-052/CR-053.
- *
- * Format: {Name}.{TypeAbbr}.{Counter}
- * Example: ObserveSessions.UC.001
- *
- * @sigloch/contracts/se
- */
-import { z } from 'zod/v4';
-import type { ElementType } from './ontology.js';
-/** 2-char abbreviation → full ElementType. */
-export declare const ABBREV_TO_TYPE: Record<string, ElementType>;
-/** Full ElementType → 2-char abbreviation. */
-export declare const TYPE_TO_ABBREV: Record<string, string>;
-/** SemanticId: `Name.TypeAbbr.Counter` where Counter is 3-digit or 6-char alphanumeric. */
-export declare const SemanticId: z.ZodString;
-export type SemanticId = z.infer<typeof SemanticId>;
-/** Check if a string is a valid SemanticId. */
-export declare function isSemanticId(s: string): boolean;
-/** Extract name, type, and counter from a SemanticId. */
-export declare function extractFromSemanticId(semanticId: string): {
-    name: string;
-    type: ElementType;
-    counter: string;
-};
-/** Build a SemanticId from parts. */
-export declare function toSemanticId(name: string, type: ElementType, counter: string): string;
-/** Get the 2-char abbreviation for an ElementType. */
-export declare function getTypeAbbreviation(type: ElementType): string;

package/dist/se/semantic-id.js

@@ -1,90 +0,0 @@
-/**
- * SemanticId — Format-E canonical element ID schema.
- * Aligned with graphengine CR-052/CR-053.
- *
- * Format: {Name}.{TypeAbbr}.{Counter}
- * Example: ObserveSessions.UC.001
- *
- * @sigloch/contracts/se
- */
-import { z } from 'zod/v4';
-// ---------------------------------------------------------------------------
-// Type abbreviation maps (aligned with graphengine semantic-id.ts)
-// ---------------------------------------------------------------------------
-/** 2-char abbreviation → full ElementType. */
-export const ABBREV_TO_TYPE = {
-    SY: 'SYS',
-    UC: 'UC',
-    RQ: 'REQ',
-    FN: 'FUNC',
-    FC: 'FCHAIN',
-    FL: 'FLOW',
-    AC: 'ACTOR',
-    MD: 'MOD',
-    TC: 'TEST',
-    TS: 'TEST', // legacy alias
-    SC: 'SCHEMA',
-    CR: 'CR',
-    MS: 'MS',
-};
-/** Full ElementType → 2-char abbreviation. */
-export const TYPE_TO_ABBREV = {
-    SYS: 'SY',
-    UC: 'UC',
-    REQ: 'RQ',
-    FUNC: 'FN',
-    FCHAIN: 'FC',
-    FLOW: 'FL',
-    ACTOR: 'AC',
-    MOD: 'MD',
-    TEST: 'TC',
-    SCHEMA: 'SC',
-    SESSION: 'SE',
-    CR: 'CR',
-    MS: 'MS',
-};
-// ---------------------------------------------------------------------------
-// Zod schema
-// ---------------------------------------------------------------------------
-/** SemanticId: `Name.TypeAbbr.Counter` where Counter is 3-digit or 6-char alphanumeric. */
-export const SemanticId = z.string().regex(/^[A-Za-z][A-Za-z0-9_+]{0,49}\.[A-Z]{2}\.[a-z0-9]{3,6}$/, 'SemanticId must match {Name}.{TypeAbbr}.{Counter}');
-// ---------------------------------------------------------------------------
-// Pure functions
-// ---------------------------------------------------------------------------
-/** Check if a string is a valid SemanticId. */
-export function isSemanticId(s) {
-    return SemanticId.safeParse(s).success;
-}
-/** Extract name, type, and counter from a SemanticId. */
-export function extractFromSemanticId(semanticId) {
-    const parts = semanticId.split('.');
-    if (parts.length < 3) {
-        throw new Error(`Invalid semanticId: "${semanticId}" — expected Name.TypeAbbr.Counter`);
-    }
-    const name = parts[0];
-    const typeAbbr = parts[1];
-    const type = ABBREV_TO_TYPE[typeAbbr];
-    if (!type) {
-        throw new Error(`Unknown type abbreviation "${typeAbbr}" in: "${semanticId}"`);
-    }
-    return { name, type, counter: parts[2] };
-}
-/** Build a SemanticId from parts. */
-export function toSemanticId(name, type, counter) {
-    const abbr = TYPE_TO_ABBREV[type];
-    if (!abbr)
-        throw new Error(`No abbreviation for type: ${type}`);
-    const sanitized = sanitizeName(name);
-    return `${sanitized}.${abbr}.${counter}`;
-}
-/** Get the 2-char abbreviation for an ElementType. */
-export function getTypeAbbreviation(type) {
-    return TYPE_TO_ABBREV[type] ?? type.slice(0, 2).toUpperCase();
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Sanitize a name for SemanticId: PascalCase, only alnum + underscore + plus, max 50 chars. */
-function sanitizeName(name) {
-    return name.replace(/[^a-zA-Z0-9_+]/g, '').slice(0, 50);
-}