@sigloch/contracts 10.4.0 → 10.6.0

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

@@ -50,6 +50,10 @@ export declare const CodeFactsSchema: z.ZodObject<{
         to: z.ZodString;
     }, z.core.$strip>>>;
     declaredDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    crFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        open: "open";
+        done: "done";
+    }>>>;
 }, 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

@@ -16,6 +16,7 @@
  */
 import { z } from 'zod/v4';
 import { RealRefSchema, TestRefsSchema } from './ontology.js';
+import { CLOSED_STATUS } from './cr-quality-rules.js';
 /** Parser facts about one source file (extracted by the executor). */
 export const FileFactsSchema = z.object({
     /** File exists on disk (repo-relative path). */
@@ -59,6 +60,13 @@ export const CodeFactsSchema = z.object({
      * every external binding in the graph at once, which is noise, not a finding.
      */
     declaredDependencies: z.array(z.string()).optional(),
+    /**
+     * CR id → the directory its file lives in (`docs/cr/open/` or `docs/cr/done/`), for RC-07
+     * (CR-SM-329). The directory is where a CR's state is decided; the node only mirrors it.
+     * Optional, ABSENT = silence, same reasoning as `declaredDependencies`: a repo without
+     * `docs/cr/` was never looked at, it does not "have no CRs".
+     */
+    crFiles: z.record(z.string(), z.enum(['open', 'done'])).optional(),
 });
 const missingFile = (facts, file) => facts.files[file]?.exists !== true;
 // RC-01: every valid FUNC realRef must resolve — file on disk, symbol declared in
@@ -451,6 +459,60 @@ function externalRefMustNameDependency(graph, facts) {
     }
     return violations;
 }
+// ---------------------------------------------------------------------------
+// RC-07: a CR node agrees with its file in docs/cr (CR-SM-329).
+//
+// The CR text lives in `docs/cr/{open,done}/`, the graph carries a lean CR node for scope and
+// planning. The DIRECTORY decides a CR's state — moving the file is the close; the node's
+// `status` mirrors it, because CR-R01/02/03 and the milestone readiness read it. Two findings:
+//   1. a node whose closed-ness (CLOSED_STATUS, the same set CR-R01 uses) contradicts the
+//      directory;
+//   2. an OPEN file with no node — an open CR the graph cannot see. The missing node has no
+//      element to carry the finding, so it anchors at the first SYS (sorted, Gate 5); without
+//      a SYS the branch is silent — R-17 already reports that graph.
+// A node WITHOUT a file is not reported: that is history (archived CRs, pre-docs/cr numbering).
+// ---------------------------------------------------------------------------
+function crNodeMatchesFile(graph, facts) {
+    const crFiles = facts.crFiles;
+    if (crFiles === undefined)
+        return []; // extractor never looked — silence, s. CodeFactsSchema
+    const crs = graph.elements.filter((e) => e.type === 'CR').sort((a, b) => a.id.localeCompare(b.id));
+    const violations = [];
+    for (const cr of crs) {
+        const dir = crFiles[cr.id];
+        if (dir === undefined)
+            continue;
+        const status = String(cr.attributes?.status ?? '');
+        if (CLOSED_STATUS.has(status) === (dir === 'done'))
+            continue;
+        violations.push({
+            rule_id: 'RC-07',
+            severity: 'warning',
+            element_id: cr.id,
+            message: `${cr.id} status '${status || 'none'}' contradicts docs/cr/${dir}/`,
+            fix_hint: dir === 'done'
+                ? 'The file is in done/ — set status done through graph_mutate'
+                : 'The file is in open/ — set status open through graph_mutate, or close the CR by moving its file to done/',
+            context: { element_type: cr.type, element_name: cr.name },
+        });
+    }
+    const sys = graph.elements.filter((e) => e.type === 'SYS').sort((a, b) => a.id.localeCompare(b.id))[0];
+    if (sys === undefined)
+        return violations;
+    const nodeIds = new Set(crs.map((c) => c.id));
+    const orphans = Object.keys(crFiles).filter((id) => crFiles[id] === 'open' && !nodeIds.has(id)).sort();
+    for (const id of orphans) {
+        violations.push({
+            rule_id: 'RC-07',
+            severity: 'warning',
+            element_id: sys.id,
+            message: `open CR ${id} (docs/cr/open/) has no CR node`,
+            fix_hint: `Add a lean CR node ${id} (id, title, no text) with relation edges to its scope through graph_mutate`,
+            context: { element_type: sys.type, element_name: sys.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', domain: ['FUNC'], evaluate: codeRefMustResolve },
@@ -459,6 +521,7 @@ export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-04', name: 'SCHEMA realRef is parsed at its interface', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaRefMustBeUsed },
     { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', domain: ['MOD'], evaluate: importDriftConformance },
     { id: 'RC-06', name: 'external realRef names a declared dependency', severity: 'warning', domain: ['FUNC', 'MOD', 'SCHEMA'], evaluate: externalRefMustNameDependency },
+    { id: 'RC-07', name: 'CR node agrees with docs/cr', severity: 'warning', domain: ['CR', 'SYS'], evaluate: crNodeMatchesFile },
 ];
 /** Run all RC rules against a graph + extracted code facts. */
 export function evaluateConformanceRules(graph, facts) {

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

@@ -5,5 +5,10 @@
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
 import type { MetricPolicy } from './policy.js';
+/**
+ * Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit.
+ * Exportiert fuer RC-07 (CR-SM-329), das dieselbe Frage gegen `docs/cr/done/` stellt.
+ */
+export declare const CLOSED_STATUS: ReadonlySet<string>;
 export declare const CR_RULES: RuleDefinition[];
 export declare function evaluateCRRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -33,8 +33,11 @@
 // ---------------------------------------------------------------------------
 /** Elementtypen, die einen Aenderungsumfang darstellen — MS gehoert bewusst nicht dazu. */
 const SCOPE_TYPES = new Set(['FUNC', 'MOD', 'SCHEMA', 'REQ', 'UC']);
-/** Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit. */
-const CLOSED_STATUS = new Set(['done', 'dropped', 'rejected']);
+/**
+ * Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit.
+ * Exportiert fuer RC-07 (CR-SM-329), das dieselbe Frage gegen `docs/cr/done/` stellt.
+ */
+export const CLOSED_STATUS = new Set(['done', 'dropped', 'rejected']);
 function crMustTrack(graph) {
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
     const crs = graph.elements.filter(e => {

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

@@ -1,43 +1,15 @@
+import type { AttributeSpec } from './ontology.js';
+/** Extract a ```format-e block from LLM output. Returns null if not found. */
+export declare function extractFormatE(llmOutput: string): string | null;
 /**
- * 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).
+ * CR-SM-251: der deklarierte Typ des Attributs entscheidet, nicht die Schreibweise des Wertes.
  *
- * @sigloch/contracts/se
+ * `ELEMENT_ATTRIBUTES` sagt fuer 14 Attribute (9 boolean, 5 number), welchen Typ sie tragen.
+ * Wer stattdessen raet (`raw === 'true'`, `/^\d+$/`), verschiebt den Defekt nur: ein
+ * Freitext-Attribut mit dem Wert "true" oder "8" kippt dann still den Typ. Unbekannte Keys —
+ * jeder Graph darf eigene tragen — fallen sauber auf String zurueck.
  */
-import { ElementType, TraceType } from './ontology.js';
-import type { OntologyGraph, AttributeSpec, ReqKind } 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.
-     * Values are strings, EXCEPT JSON object/array literals which are hydrated
-     * (BOK-CR-026) — object- and array-valued bindings like `realRef`/`testRefs` must reach
-     * `attributes` as objects or R-26/R-19 reject them as invalid.
-     */
-    attributes?: Record<string, unknown>;
-    sourceId?: string;
-    targetId?: string;
-    traceType?: TraceType;
-}
-export interface FormatEDiff {
-    operations: FormatEOperation[];
-    errors: string[];
-}
-/** Extract a ```format-e block from LLM output. Returns null if not found. */
-export declare function extractFormatE(llmOutput: string): string | null;
+export declare function attributeTypeOf(elementType: string | undefined, key: string): AttributeSpec['type'] | undefined;
 /**
  * BOK-CR-026: hydrate a JSON object/array attribute value. The ontology's bindings
  * (`realRef {file,symbol?,lang?}`, `testRefs [{file,tool,…}]`) are objects/arrays; kept as raw
@@ -50,45 +22,4 @@ export declare function extractFormatE(llmOutput: string): string | null;
  * package over. Two hydration rules would drift; there is one, and it lives here with the
  * schemas it feeds.
  */
-/**
- * CR-SM-251: der deklarierte Typ des Attributs entscheidet, nicht die Schreibweise des Wertes.
- *
- * `ELEMENT_ATTRIBUTES` sagt fuer 14 Attribute (9 boolean, 5 number), welchen Typ sie tragen.
- * Wer stattdessen raet (`raw === 'true'`, `/^\d+$/`), verschiebt den Defekt nur: ein
- * Freitext-Attribut mit dem Wert "true" oder "8" kippt dann still den Typ. Unbekannte Keys —
- * jeder Graph darf eigene tragen — fallen sauber auf String zurueck.
- */
-export declare function attributeTypeOf(elementType: string | undefined, key: string): AttributeSpec['type'] | undefined;
 export declare function hydrateAttrValue(raw: string, declaredType?: AttributeSpec['type']): unknown;
-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;
-    /**
-     * CR-SM-266 B: die Kinds eines uid, den dieser Text nicht deklariert. Seit die
-     * satisfy-Patterns ein `where` tragen, entscheidet nicht mehr das Typ-Paar allein — ein
-     * `MOD -satisfy-> REQ` ist nur gueltig, wenn das REQ strukturelle Kinds traegt.
-     *
-     * Ohne diesen Resolver sieht der Parser die Kinds eines BESTEHENDEN Knotens nicht und lehnt
-     * solche Kanten ab. Das ist Absicht: fehlschlagen und es sagen, nicht raten und durchlassen
-     * — dieselbe Entscheidung wie bei `resolveType` ("Without it such a diff is an error, never
-     * a silent skip"). Knoten, die DIESER Text anlegt, brauchen ihn nicht; ihre Kinds stehen als
-     * `@kinds` in denselben Zeilen.
-     */
-    resolveKinds?: (uid: string) => readonly ReqKind[] | undefined;
-}
-/** Parse a Format E text block into validated operations. */
-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,16 +1,29 @@
 /**
- * Format E Parser — Graph mutations from compact text format.
- * SE-relevant subset: nodes (+/-/~) and edges (+/-), no chat-canvas or views.
+ * Format E — der GETEILTE Teil: Attribut-Hydration und das Herausloesen des Blocks.
  *
- * 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).
+ * CR-SM-331: Parser UND Serializer standen bis hierher ebenfalls in dieser Datei — ein
+ * zweites Paar neben `FormatECodec` in @sigloch/graph-api-core. Zwei Implementierungen
+ * desselben Dialekts urteilten ueber denselben Text verschieden: eine Beschreibung mit
+ * Zeilenumbruch lehnte DIESER Parser ab ("Invalid node line", `NODE_RE` verlangte eine uid
+ * ohne Leerzeichen), waehrend der lebende Codec die uebergelaufene Zeile als KNOTENZEILE
+ * annahm und daraus einen Phantom-Knoten baute (ITEM-2026-183, am Gate reproduziert). Der
+ * strengere war der, den keine Produktionsstelle der Familie je aufrief.
+ *
+ * Ein Dialekt, eine Implementierung — und sie lebt in graph-api-core, nicht hier, weil sie
+ * DESKRIPTOR-PARAMETRISIERT sein muss: `loadFixture` (test-fixtures.ts) parst Format E mit
+ * einer FREMDEN Ontologie und ist publizierte API. Ein SE-fester Parser in contracts koennte
+ * das nicht mehr bedienen.
+ *
+ * Was hier bleibt, bleibt mit Grund: `attributeTypeOf` und `hydrateAttrValue` lesen
+ * `ELEMENT_ATTRIBUTES` und fuettern `RealRefSchema`/`TestRefSchema` — sie gehoeren zu den
+ * SCHEMATA, nicht zum Dialekt, und der Codec importiert sie von hier (CR-GC-334). Zwei
+ * Hydrationsregeln wuerden driften; es gibt genau eine.
+ *
+ * Der Dateiname bleibt absichtlich stehen — ein Rename traegt Kosten bei jedem Importeur.
  *
  * @sigloch/contracts/se
  */
-import { ElementType, ELEMENT_ATTRIBUTES, TraceType, normalizeReqKinds } from './ontology.js';
-import { isValidTrace } from './meta-model.js';
+import { ELEMENT_ATTRIBUTES } from './ontology.js';
 // ---------------------------------------------------------------------------
 // Extraction
 // ---------------------------------------------------------------------------
@@ -21,40 +34,8 @@ export function extractFormatE(llmOutput) {
     return m ? m[1].trim() : null;
 }
 // ---------------------------------------------------------------------------
-// Parser
+// Attribut-Hydration — geteilt mit FormatECodec (CR-GC-334)
 // ---------------------------------------------------------------------------
-// CR-SM-266 D5: ABGELEITET statt abgeschrieben. Die Liste stand hier als zweite Kopie des
-// TraceType-Enums und trug `produces` noch, als es dort schon entfernt war — genau die Drift,
-// die eine doppelte Wahrheit erzeugt. Eine Quelle, keine Pflege.
-const VALID_TRACE_TYPES = new Set(TraceType.options);
-const OP_PREFIX = {
-    '+': 'add',
-    '-': 'remove',
-    '~': 'update',
-    '!': 'strict_add',
-};
-/**
- * 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?}`, `testRefs [{file,tool,…}]`) are objects/arrays; 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.
- *
- * CR-GC-334: exported, because `FormatECodec` (graph-api-core) parses the SAME `@key value`
- * lines and did NOT hydrate — the identical defect this function was written for, one
- * package over. Two hydration rules would drift; there is one, and it lives here with the
- * schemas it feeds.
- */
 /**
  * CR-SM-251: der deklarierte Typ des Attributs entscheidet, nicht die Schreibweise des Wertes.
  *
@@ -69,6 +50,18 @@ export function attributeTypeOf(elementType, key) {
     const specs = ELEMENT_ATTRIBUTES[elementType];
     return specs?.find(s => s.key === key)?.type;
 }
+/**
+ * BOK-CR-026: hydrate a JSON object/array attribute value. The ontology's bindings
+ * (`realRef {file,symbol?,lang?}`, `testRefs [{file,tool,…}]`) are objects/arrays; 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.
+ *
+ * CR-GC-334: exported, because `FormatECodec` (graph-api-core) parses the SAME `@key value`
+ * lines and did NOT hydrate — the identical defect this function was written for, one
+ * package over. Two hydration rules would drift; there is one, and it lives here with the
+ * schemas it feeds.
+ */
 export function hydrateAttrValue(raw, declaredType) {
     // CR-SM-251: `concept:true` kam als String "true" an, und alle 11 Vergleiche in
     // rules.ts/conformance-rules.ts pruefen identitaetsscharf (`=== true`). Damit war jeder
@@ -95,261 +88,3 @@ export function hydrateAttrValue(raw, declaredType) {
         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, 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);
-    /**
-     * CR-SM-266 B: die Kinds eines uid — erst aus DIESEM Text, dann aus dem Store.
-     *
-     * `kinds` reist in Format E als `@kinds a,b` und wird erst vom Konsumenten aufs
-     * Top-Level-Feld gehoben (graph-api-core, CR-195d). Hier steht es also noch in
-     * `op.attributes.kinds`, und genau dort wird es gelesen — sonst saehe eine Mutation, die
-     * REQ und satisfy-Kante in EINEM Block anlegt, die eigenen Kinds nicht. Seit CR-SM-320
-     * liegt es dort bereits als Liste (s. Attribut-Zeile unten), also ohne eigene Normalisierung.
-     */
-    const kindsOf = (uid) => {
-        for (const op of operations) {
-            if ('elementType' in op && op.semanticId === uid && Array.isArray(op.attributes?.kinds)) {
-                return op.attributes.kinds;
-            }
-        }
-        return options.resolveKinds?.(uid);
-    };
-    for (const rawLine of input.split('\n')) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith('//') || line.startsWith('#!'))
-            continue;
-        // CR-147: @attribute lines attach to the last node operation
-        const attrMatch = ATTR_RE.exec(line);
-        if (attrMatch) {
-            const lastOp = operations.length > 0 ? operations[operations.length - 1] : null;
-            if (lastOp && (lastOp.type === 'add_node' || lastOp.type === 'update_node' || lastOp.type === 'strict_add_node')) {
-                if (!lastOp.attributes)
-                    lastOp.attributes = {};
-                const key = attrMatch[1];
-                const value = hydrateAttrValue(attrMatch[2].trim(), attributeTypeOf(lastOp.elementType, key));
-                // CR-SM-320 (ITEM-2026-007): `kinds` ist keine freie Eigenschaft, sondern die REQ-Spalte,
-                // die hier nur durchreist. Ein Einzelwert (`@kinds non-functional`) blieb als roher
-                // String liegen und wurde so persistiert — jede Sicht, die auf Listen-Mitgliedschaft
-                // filtert, verlor die REQ still. Die Form wird am PRODUZENTEN hergestellt, nicht bei
-                // jedem Leser einzeln: hier ist `kinds` immer eine Liste.
-                lastOp.attributes[key] = key === 'kinds' ? [...normalizeReqKinds(value)] : value;
-            }
-            else {
-                errors.push(`@attribute line without preceding node: "${line}"`);
-            }
-            continue;
-        }
-        // 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;
-        // 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, typeOf, kindsOf, operations, errors);
-            }
-            else {
-                errors.push(`Invalid edge line: "${line}"`);
-            }
-            continue;
-        }
-        // Node
-        if (section === 'nodes') {
-            const nodeMatch = NODE_RE.exec(line);
-            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 {
-                declared.set(nodeMatch[2], currentType);
-                parseNode(nodeMatch, currentType, operations, errors);
-            }
-            continue;
-        }
-        // Unknown line (edges are handled above, nodes need their section)
-        if (line.length > 0)
-            errors.push(`Unrecognized line: "${line}"`);
-    }
-    return { operations, errors };
-}
-/** CR-148: Normalize trace type using alias table. */
-function normalizeTraceType(srcType, tgtType, traceType) {
-    const aliases = TRACE_NORMALIZE[srcType];
-    if (aliases && aliases[tgtType] && traceType !== aliases[tgtType]) {
-        return aliases[tgtType];
-    }
-    return traceType;
-}
-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 (!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, elementType, description: descr });
-    }
-    else if (action === 'strict_add') {
-        ops.push({ type: 'strict_add_node', semanticId: id, elementType, description: descr });
-    }
-    else {
-        ops.push({ type: 'add_node', semanticId: id, elementType, description: descr });
-    }
-}
-function parseEdge(m, typeOf, kindsOf, ops, errors) {
-    const opChar = m[1] || '+';
-    const sourceId = m[2];
-    const traceType = m[3];
-    const action = OP_PREFIX[opChar] ?? 'add';
-    if (!VALID_TRACE_TYPES.has(traceType)) {
-        errors.push(`Invalid trace type: "${traceType}"`);
-        return;
-    }
-    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'
-        ? 'remove_edge'
-        : action === 'strict_add'
-            ? 'strict_add_edge'
-            : 'add_edge';
-    // 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,
-            sourceKinds: kindsOf(sourceId), targetKinds: kindsOf(targetId),
-        })) {
-            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.
- *
- * 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, grouped by type
-    // CR-SM-266 D5: kein SESSION-Skip mehr — der Elementtyp existiert nicht.
-    const modelingElements = graph.elements;
-    if (modelingElements.length > 0) {
-        lines.push('## Nodes');
-        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/testRefs
-                        // 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}`);
-                    }
-                }
-            }
-        }
-    }
-    // Edges
-    // CR-SM-266 D5: kein audit-Filter mehr — `Trace.category` existiert nicht.
-    const modelingTraces = graph.traces;
-    if (modelingTraces.length > 0) {
-        lines.push('');
-        lines.push('## Edges');
-        for (const t of modelingTraces) {
-            lines.push(`+ ${t.source} -${t.type}-> ${t.target}`);
-        }
-    }
-    return lines.join('\n');
-}

package/dist/se/function-criticality.d.ts

@@ -72,4 +72,20 @@ export interface FunctionCriticality {
  * Cases, dann stabil nach `funcId`. Eine Zeile je FUNC — auch fuer die mit 0, sonst waere die
  * Abwesenheit eines Wertes von der Abwesenheit der Funktion nicht zu unterscheiden.
  */
+/**
+ * CR-SM-335 (ITEM-2026-096, zugesagt in CR-SM-313) — EINE Definition von "welche Ketten
+ * enthalten diese FUNC", als MENGEN.
+ *
+ * R-21 hielt fuer "teilen diese beiden EINE Kette" einen eigenen, lokalen Index in `rules.ts`,
+ * waehrend die ZAHL fuer seine Infrastruktur-Ausnahme aus `functionCriticality` kam. Zwei
+ * Stellen lasen dieselbe Kantenmenge nach derselben Definition (R-30: direkte
+ * `FCHAIN -compose-> FUNC`, keine Vererbung). Es gab keinen Widerspruch — beide taten
+ * dasselbe. Die Gefahr ist die kuenftige Aenderung an nur einer der beiden, und das ist
+ * genau die Drift-Klasse, gegen die `module-crossings.ts` gebaut wurde (CR-SM-276).
+ *
+ * Eine Rechnung liefert jetzt beides: `chainsByFunc` die Mengen, `functionCriticality` die
+ * Zahlen daraus. Eine FUNC ohne Kette taucht NICHT auf — `get` liefert `undefined`, und der
+ * Aufrufer entscheidet, ob das 0 oder "nicht gefragt" heisst.
+ */
+export declare function chainsByFunc(graph: OntologyGraph): Map<string, Set<string>>;
 export declare function functionCriticality(graph: OntologyGraph): FunctionCriticality[];

package/dist/se/function-criticality.js

@@ -6,15 +6,27 @@ import { indexOf } from './graph-index.js';
  * Cases, dann stabil nach `funcId`. Eine Zeile je FUNC — auch fuer die mit 0, sonst waere die
  * Abwesenheit eines Wertes von der Abwesenheit der Funktion nicht zu unterscheiden.
  */
-export function functionCriticality(graph) {
+/**
+ * CR-SM-335 (ITEM-2026-096, zugesagt in CR-SM-313) — EINE Definition von "welche Ketten
+ * enthalten diese FUNC", als MENGEN.
+ *
+ * R-21 hielt fuer "teilen diese beiden EINE Kette" einen eigenen, lokalen Index in `rules.ts`,
+ * waehrend die ZAHL fuer seine Infrastruktur-Ausnahme aus `functionCriticality` kam. Zwei
+ * Stellen lasen dieselbe Kantenmenge nach derselben Definition (R-30: direkte
+ * `FCHAIN -compose-> FUNC`, keine Vererbung). Es gab keinen Widerspruch — beide taten
+ * dasselbe. Die Gefahr ist die kuenftige Aenderung an nur einer der beiden, und das ist
+ * genau die Drift-Klasse, gegen die `module-crossings.ts` gebaut wurde (CR-SM-276).
+ *
+ * Eine Rechnung liefert jetzt beides: `chainsByFunc` die Mengen, `functionCriticality` die
+ * Zahlen daraus. Eine FUNC ohne Kette taucht NICHT auf — `get` liefert `undefined`, und der
+ * Aufrufer entscheidet, ob das 0 oder "nicht gefragt" heisst.
+ */
+export function chainsByFunc(graph) {
     const idx = indexOf(graph);
-    const funcs = idx.elementsOfType('FUNC');
     const typeOf = new Map(graph.elements.map((e) => [e.id, e.type]));
-    const funcIds = new Set(funcs.map((f) => f.id));
-    const compose = idx.tracesOfType('compose');
-    // FUNC -> seine Ketten. R-30s Fassung, woertlich.
+    const funcIds = new Set(idx.elementsOfType('FUNC').map((f) => f.id));
     const chainsOf = new Map();
-    for (const t of compose) {
+    for (const t of idx.tracesOfType('compose')) {
         if (typeOf.get(t.source) !== 'FCHAIN' || !funcIds.has(t.target))
             continue;
         let s = chainsOf.get(t.target);
@@ -24,6 +36,15 @@ export function functionCriticality(graph) {
         }
         s.add(t.source);
     }
+    return chainsOf;
+}
+export function functionCriticality(graph) {
+    const idx = indexOf(graph);
+    const funcs = idx.elementsOfType('FUNC');
+    const typeOf = new Map(graph.elements.map((e) => [e.id, e.type]));
+    const compose = idx.tracesOfType('compose');
+    // FUNC -> seine Ketten. R-30s Fassung, woertlich — und dieselbe Rechnung, die R-21 liest.
+    const chainsOf = chainsByFunc(graph);
     // FCHAIN -> seine Use Cases.
     const ucsOf = new Map();
     for (const t of compose) {