@sigloch/contracts 10.5.0 → 10.6.0

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 } 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,33 +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;
-}
-/** 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,15 +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 { ELEMENT_ATTRIBUTES } from './ontology.js';
 // ---------------------------------------------------------------------------
 // Extraction
 // ---------------------------------------------------------------------------
@@ -20,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.
  *
@@ -68,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
@@ -94,239 +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);
-    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, 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, 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 the trace type (e.g. FLOW→SCHEMA io → relation).
-        // CR-SM-325: no legality verdict while parsing — the parser knows neither label nor the
-        // kinds of existing nodes. The write path judges with the one rule (gate R-18, GraphService).
-        const resolvedTraceType = normalizeTraceType(srcType, tgtType, traceType);
-        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) {

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

@@ -24,5 +24,5 @@ export declare const GRAMMAR_SNAPSHOT: {
     readonly conformanceRules: readonly ["RC-01 (error)", "RC-02 (error)", "RC-03 (error)", "RC-04 (warning)", "RC-05 (warning)", "RC-06 (warning)", "RC-07 (warning)"];
     readonly policy: readonly ["apTable = null", "boundaryWidth = {warning:5}", "criticality = {infrastructure:3}", "crossingFlows = {warning:3}", "decompositionBreadth = {min:3,warning:9}", "instability = null", "lcom4 = {info:4,warning:6}", "riskRpn = 100"];
     readonly ruleHelp: readonly ["AF-01", "AF-02", "AF-03", "AF-04", "AF-05", "BQ-01", "BQ-02", "BQ-04", "BQ-06", "BQ-07", "BW-02", "CL-01", "CR-01", "CR-R01", "CR-R02", "CR-R03", "FC-02", "FC-03", "FC-04", "FM-01", "FM-02", "FM-03", "IO-01", "IO-02", "MS-01", "MS-02", "MS-03", "MT-01", "MT-02", "MT-04", "ND-01", "ND-02", "NFR-01", "R-01", "R-02", "R-04", "R-05", "R-08", "R-10", "R-12", "R-15", "R-16", "R-17", "R-18", "R-19", "R-20", "R-21", "R-22", "R-23", "R-26", "R-29", "R-30", "R-31", "R-32", "RC-01", "RC-02", "RC-03", "RC-04", "RC-05", "RC-06", "RC-07", "RD-01", "RD-02", "RD-03", "RD-04", "RD-05", "SC-02", "UC-01", "UC-02", "UC-03", "UC-04", "UC-05", "UC-06", "VR-01"];
-    readonly exports: readonly ["AF_RULES", "ALL_RULE_DEFS", "AO_RULES", "ActionPriority", "AnalysisArtifactId", "AnalysisFreshnessStampSchema", "ApTableSchema", "BOUNDED_PATTERNS", "BQ_RULES", "CLOSED_STATUS", "CODE_CONFORMANCE_RULES", "CR_RULES", "CodeFactsSchema", "DEFAULT_METRIC_POLICY", "DIMENSION_READINESS_DELTA_NAME", "DIMENSION_READINESS_NAME", "ELEMENT_ATTRIBUTES", "ELEMENT_DESCRIPTIONS", "ElementType", "ElementUid", "FC_RULES", "FM_RULES", "FileFactsSchema", "ImportEdgeSchema", "MAX_SLUG_LENGTH", "META_MODEL_VERSION", "MODELING_ELEMENT_TYPES", "MT_RULES", "MetricPolicySchema", "ND_RULES", "ONTOLOGY_VERSION", "OntologyElement", "OntologyGraph", "PHASE_READINESS_NAME", "PhaseGate", "READINESS_SCORED_PROFILES", "REQUIRED_PATTERNS", "RULES_VERSION", "RULE_HELP", "RULE_TO_DIMENSION", "RULE_TO_PHASE", "ReadinessDimension", "ReadinessReport", "ReadinessScore", "RealRefSchema", "RepoRelativePathSchema", "ReqKind", "RuleSeverity", "RuleViolation", "SC_RULES", "TRACE_PATTERNS", "TestRefSchema", "TestRefsSchema", "TestResult", "Trace", "TraceType", "UC_RULES", "V3_RULES", "VIEW_RULES", "VerificationMethod", "ViolationCandidate", "ViolationContext", "actionPriority", "allocationCohesion", "apMethod", "attributeTypeOf", "boxContracts", "bq01Unambiguous", "bq02Verifiable", "bq04Necessary", "bq06Conforming", "bq07Complete", "bw02WhiteboxWidth", "cl01ConopsCompleteness", "cr01CrossingFlowCount", "crossingContractCount", "decomposedFuncs", "evaluateAFRules", "evaluateAORules", "evaluateAllRules", "evaluateBQRules", "evaluateCRRules", "evaluateConformanceRules", "evaluateFCRules", "evaluateFMRules", "evaluateMTRules", "evaluateNDRules", "evaluateRules", "evaluateSCRules", "evaluateUCRules", "evaluateViewRules", "extractFormatE", "fc02LeafUcHasFchain", "fc03FchainFlat", "fc04ActorBounded", "fm01MissingFmeaAttributes", "fm02MissingMitigation", "fm03HighRiskUnverified", "funcSimilarity", "funcSubtree", "functionCriticality", "getRuleDefsForProfile", "hydrateAttrValue", "importCoverage", "indexOf", "io01CrossModuleCompleteness", "isElementUid", "isValidTrace", "jaccard", "maxOccurs", "minOccurs", "moduleCrossings", "moduleMetrics", "mt01Instability", "mt02Lcom4", "mt04WhiteboxLcom4", "nd01FuncNearDuplicate", "nd02SchemaNearDuplicate", "nfr01BudgetOvershoot", "normalizeReqKinds", "pairsAbove", "parseElementUid", "parseFormatE", "sc02IsReferenced", "schemaSimilarity", "serializeToFormatE", "setBQ04SimilarityMatrix", "subtreeFuncs", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "uc05HasPostcondition", "uc06HasPrecondition", "vr01TestNoResult", "whiteboxContractCount"];
+    readonly exports: readonly ["AF_RULES", "ALL_RULE_DEFS", "AO_RULES", "ActionPriority", "AnalysisArtifactId", "AnalysisFreshnessStampSchema", "ApTableSchema", "BOUNDED_PATTERNS", "BQ_RULES", "CLOSED_STATUS", "CODE_CONFORMANCE_RULES", "CR_RULES", "CodeFactsSchema", "DEFAULT_METRIC_POLICY", "DIMENSION_READINESS_DELTA_NAME", "DIMENSION_READINESS_NAME", "ELEMENT_ATTRIBUTES", "ELEMENT_DESCRIPTIONS", "ElementType", "ElementUid", "FC_RULES", "FM_RULES", "FileFactsSchema", "ImportEdgeSchema", "MAX_SLUG_LENGTH", "META_MODEL_VERSION", "MODELING_ELEMENT_TYPES", "MT_RULES", "MetricPolicySchema", "ND_RULES", "ONTOLOGY_VERSION", "OntologyElement", "OntologyGraph", "PHASE_READINESS_NAME", "PhaseGate", "READINESS_SCORED_PROFILES", "REQUIRED_PATTERNS", "RULES_VERSION", "RULE_HELP", "RULE_TO_DIMENSION", "RULE_TO_PHASE", "ReadinessDimension", "ReadinessReport", "ReadinessScore", "RealRefSchema", "RepoRelativePathSchema", "ReqKind", "RuleSeverity", "RuleViolation", "SC_RULES", "SteerSpace", "SteerTerm", "TRACE_PATTERNS", "TestRefSchema", "TestRefsSchema", "TestResult", "Trace", "TraceType", "UC_RULES", "V3_RULES", "VIEW_RULES", "VerificationMethod", "ViolationCandidate", "ViolationContext", "actionPriority", "allocationCohesion", "apMethod", "attributeTypeOf", "boxContracts", "bq01Unambiguous", "bq02Verifiable", "bq04Necessary", "bq06Conforming", "bq07Complete", "bw02WhiteboxWidth", "chainsByFunc", "cl01ConopsCompleteness", "cr01CrossingFlowCount", "crossingContractCount", "decomposedFuncs", "evaluateAFRules", "evaluateAORules", "evaluateAllRules", "evaluateBQRules", "evaluateCRRules", "evaluateConformanceRules", "evaluateFCRules", "evaluateFMRules", "evaluateMTRules", "evaluateNDRules", "evaluateRules", "evaluateSCRules", "evaluateUCRules", "evaluateViewRules", "extractFormatE", "fc02LeafUcHasFchain", "fc03FchainFlat", "fc04ActorBounded", "fm01MissingFmeaAttributes", "fm02MissingMitigation", "fm03HighRiskUnverified", "funcSimilarity", "funcSubtree", "functionCriticality", "getRuleDefsForProfile", "hydrateAttrValue", "importCoverage", "indexOf", "io01CrossModuleCompleteness", "isElementUid", "isValidTrace", "jaccard", "maxOccurs", "minOccurs", "moduleCrossings", "moduleMetrics", "mt01Instability", "mt02Lcom4", "mt04WhiteboxLcom4", "nd01FuncNearDuplicate", "nd02SchemaNearDuplicate", "nfr01BudgetOvershoot", "normalizeReqKinds", "pairsAbove", "parseElementUid", "sc02IsReferenced", "schemaSimilarity", "setBQ04SimilarityMatrix", "subtreeFuncs", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "uc05HasPostcondition", "uc06HasPrecondition", "vr01TestNoResult", "whiteboxContractCount"];
 };

package/dist/se/grammar-snapshot.js

@@ -342,6 +342,8 @@ export const GRAMMAR_SNAPSHOT = {
         "RuleSeverity",
         "RuleViolation",
         "SC_RULES",
+        "SteerSpace",
+        "SteerTerm",
         "TRACE_PATTERNS",
         "TestRefSchema",
         "TestRefsSchema",
@@ -365,6 +367,7 @@ export const GRAMMAR_SNAPSHOT = {
         "bq06Conforming",
         "bq07Complete",
         "bw02WhiteboxWidth",
+        "chainsByFunc",
         "cl01ConopsCompleteness",
         "cr01CrossingFlowCount",
         "crossingContractCount",
@@ -414,10 +417,8 @@ export const GRAMMAR_SNAPSHOT = {
         "normalizeReqKinds",
         "pairsAbove",
         "parseElementUid",
-        "parseFormatE",
         "sc02IsReferenced",
         "schemaSimilarity",
-        "serializeToFormatE",
         "setBQ04SimilarityMatrix",
         "subtreeFuncs",
         "toElementUid",

package/dist/se/readiness.d.ts

@@ -45,6 +45,51 @@ export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
  * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
  * Konsumenten hat — nicht auf Vorrat.
  */
+/**
+ * CR-SM-337 (ITEM-2026-059) — der STEUERUNGSRAUM im Bericht, Stufe 1: der Vertrag.
+ *
+ * Readiness misst ABDECKUNG ("wie viele Stellen sind erledigt"), der Steuer-Score AUSPRAEGUNG
+ * ("wie schlimm ist die schlimmste offene"). Beide lesen denselben Regelstrom, und beide
+ * gehoeren in denselben Bericht — sonst rechnet der naechste Leser die zweite Haelfte selbst
+ * nach. Genau das drohte: das GVE-Dashboard (ITEM-2026-018) haette `steerScore` nachbauen
+ * muessen, weil die Zahlen bisher nur als `verdict.steer.improvement` je Suggestion sichtbar
+ * waren. Eine zweite Rechnung ist eine zweite Wahrheit.
+ *
+ * Die Form ist die von `SteerScore` in @sigloch/se-engine (CR-SM-292), ZEICHENGLEICH
+ * uebernommen — contracts darf se-engine nicht importieren (es ist die Basis), also steht hier
+ * der Vertrag und dort die Rechnung. Wer die Form aendert, aendert sie an beiden Stellen; der
+ * Vertragstest daneben haelt die Felder fest.
+ *
+ * `worst` = der schlimmste normierte Ueberschuss `(wert - budget) / budget`. Normiert wird
+ * gegen die REGELSCHWELLE selbst, nicht gegen eine eigene Zahl — deshalb gibt es hier keine
+ * freien Parameter (CR-SM-292: daran ist der Vorgaenger CR-SM-281 gestorben).
+ */
+export declare const SteerTerm: z.ZodObject<{
+    ruleId: z.ZodString;
+    elementId: z.ZodString;
+    value: z.ZodNumber;
+    threshold: z.ZodNumber;
+    overshoot: z.ZodNumber;
+}, z.core.$strip>;
+export type SteerTermType = z.infer<typeof SteerTerm>;
+export declare const SteerSpace: z.ZodObject<{
+    worst: z.ZodNumber;
+    worstAt: z.ZodNullable<z.ZodObject<{
+        ruleId: z.ZodString;
+        elementId: z.ZodString;
+    }, z.core.$strip>>;
+    mean: z.ZodNumber;
+    score: z.ZodNumber;
+    measured: z.ZodNumber;
+    terms: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        elementId: z.ZodString;
+        value: z.ZodNumber;
+        threshold: z.ZodNumber;
+        overshoot: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SteerSpaceType = z.infer<typeof SteerSpace>;
 export declare const ReadinessReport: z.ZodObject<{
     scores: z.ZodArray<z.ZodObject<{
         dimension: z.ZodEnum<{
@@ -63,6 +108,23 @@ export declare const ReadinessReport: z.ZodObject<{
         coreApplicable: z.ZodNumber;
     }, z.core.$strip>>;
     timestamp: z.ZodISODateTime;
+    steer: z.ZodOptional<z.ZodObject<{
+        worst: z.ZodNumber;
+        worstAt: z.ZodNullable<z.ZodObject<{
+            ruleId: z.ZodString;
+            elementId: z.ZodString;
+        }, z.core.$strip>>;
+        mean: z.ZodNumber;
+        score: z.ZodNumber;
+        measured: z.ZodNumber;
+        terms: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            elementId: z.ZodString;
+            value: z.ZodNumber;
+            threshold: z.ZodNumber;
+            overshoot: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ReadinessReportType = z.infer<typeof ReadinessReport>;
 /**

package/dist/se/readiness.js

@@ -57,9 +57,68 @@ export const ReadinessScore = z.object({
  * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
  * Konsumenten hat — nicht auf Vorrat.
  */
+/**
+ * CR-SM-337 (ITEM-2026-059) — der STEUERUNGSRAUM im Bericht, Stufe 1: der Vertrag.
+ *
+ * Readiness misst ABDECKUNG ("wie viele Stellen sind erledigt"), der Steuer-Score AUSPRAEGUNG
+ * ("wie schlimm ist die schlimmste offene"). Beide lesen denselben Regelstrom, und beide
+ * gehoeren in denselben Bericht — sonst rechnet der naechste Leser die zweite Haelfte selbst
+ * nach. Genau das drohte: das GVE-Dashboard (ITEM-2026-018) haette `steerScore` nachbauen
+ * muessen, weil die Zahlen bisher nur als `verdict.steer.improvement` je Suggestion sichtbar
+ * waren. Eine zweite Rechnung ist eine zweite Wahrheit.
+ *
+ * Die Form ist die von `SteerScore` in @sigloch/se-engine (CR-SM-292), ZEICHENGLEICH
+ * uebernommen — contracts darf se-engine nicht importieren (es ist die Basis), also steht hier
+ * der Vertrag und dort die Rechnung. Wer die Form aendert, aendert sie an beiden Stellen; der
+ * Vertragstest daneben haelt die Felder fest.
+ *
+ * `worst` = der schlimmste normierte Ueberschuss `(wert - budget) / budget`. Normiert wird
+ * gegen die REGELSCHWELLE selbst, nicht gegen eine eigene Zahl — deshalb gibt es hier keine
+ * freien Parameter (CR-SM-292: daran ist der Vorgaenger CR-SM-281 gestorben).
+ */
+export const SteerTerm = z.object({
+    /** Eine der STEER_RULES — die messenden Regeln (se-engine `STEER_RULES`). */
+    ruleId: z.string(),
+    /** Die Blackbox, an der der Term haengt. */
+    elementId: z.string(),
+    /** Der gemessene Wert (`violation.context.value`). */
+    value: z.number(),
+    /** Das Budget, gegen das normiert wird (`violation.context.threshold`). */
+    threshold: z.number(),
+    /** `max(0, (value - threshold) / threshold)` — dimensionslos, damit vergleichbar. */
+    overshoot: z.number().min(0),
+});
+export const SteerSpace = z.object({
+    worst: z.number().min(0),
+    /**
+     * Wo der schlimmste Ueberschuss sitzt — die Begruendung, nicht nur die Zahl.
+     * `null`, wenn nichts ueberschreitet.
+     */
+    worstAt: z.object({ ruleId: z.string(), elementId: z.string() }).nullable(),
+    mean: z.number().min(0),
+    /** `worst + EPS_AUGMENT * mean`. **Kleiner ist besser**, 0 = alles im Budget. */
+    score: z.number().min(0),
+    /**
+     * Zahl der Blackboxes, die in die Rechnung eingegangen sind.
+     *
+     * DIE WICHTIGSTE ZAHL DES OBJEKTS, und zwar wegen `score: 0`: der steht sowohl fuer "alles
+     * innerhalb seiner Budgets" als auch fuer "es wurde nichts gemessen". `measured: 0`
+     * unterscheidet die beiden. Ohne sie waere eine stille Null nicht von einem guten Zustand zu
+     * trennen — dieselbe Konvention wie `policy.X = null` und `moduleMetrics.instability = null`.
+     */
+    measured: z.number().int().min(0),
+    /** Die Terme je Element, aus denen `worst` und `mean` entstehen. */
+    terms: z.array(SteerTerm),
+});
 export const ReadinessReport = z.object({
     scores: z.array(ReadinessScore),
     timestamp: z.iso.datetime(),
+    /**
+     * CR-SM-337: OPTIONAL, damit ein aelterer Produzent gueltig bleibt — der Vertrag wandert vor
+     * dem Fueller (Stufe 2, graphcode CR-GC-537). Fehlt das Feld, heisst das "dieser Produzent
+     * kennt den Steuerungsraum noch nicht", und das ist etwas anderes als `measured: 0`.
+     */
+    steer: SteerSpace.optional(),
 });
 /**
  * CR-SM-305 — welche Profile in die readiness-Zahlen eingehen, und warum `conformance` nicht.

package/dist/se/rules.js

@@ -8,7 +8,7 @@ import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontolog
 import { traceRejection, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
 import { moduleCrossings, subtreeFuncs } from './module-crossings.js';
-import { functionCriticality } from './function-criticality.js';
+import { functionCriticality, chainsByFunc } from './function-criticality.js';
 export const RuleSeverity = z.enum(['error', 'warning', 'info']);
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
 export const ViolationCandidate = z.object({
@@ -1260,14 +1260,11 @@ function fchainMustHaveIntegrationTest(graph, policy) {
     }
     if (connections.length === 0)
         return [];
-    // FUNC → set of FCHAINs composing it. LOKALER Index fuer eine andere Frage als die Kennzahl:
-    // "teilen diese beiden EINE Kette" braucht die Mengen, nicht die Zahl (CR-SM-313).
-    const chainsOfFunc = new Map();
-    for (const t of graph.traces) {
-        if (t.type === 'compose' && typeOf.get(t.source) === 'FCHAIN' && isFunc(t.target)) {
-            (chainsOfFunc.get(t.target) ?? chainsOfFunc.set(t.target, new Set()).get(t.target)).add(t.source);
-        }
-    }
+    // FUNC → set of FCHAINs composing it. CR-SM-335: DIESELBE Rechnung, die auch die Kennzahl
+    // speist — vorher stand hier ein zweiter, lokaler Index ueber dieselbe Kantenmenge. "Teilen
+    // diese beiden EINE Kette" braucht die Mengen, die Infrastruktur-Ausnahme die Zahl; beides
+    // kommt jetzt aus `chainsByFunc` (CR-SM-313 hatte den Helfer zugesagt, CR-SM-314 die Zahl).
+    const chainsOf = chainsByFunc(graph);
     // FCHAINs whose satisfy-REQ is verified by a TEST = chains with an integration test.
     const verifiedReqs = new Set(idx.tracesOfType('verify').map(t => t.target));
     const testedChains = new Set();
@@ -1285,8 +1282,8 @@ function fchainMustHaveIntegrationTest(graph, policy) {
     const violations = [];
     const seen = new Set();
     for (const [p, c] of connections) {
-        const pChains = chainsOfFunc.get(p) ?? new Set();
-        const cChains = chainsOfFunc.get(c) ?? new Set();
+        const pChains = chainsOf.get(p) ?? new Set();
+        const cChains = chainsOf.get(c) ?? new Set();
         // ZWEIG 1 — ein Ende in GAR KEINER Kette: still. Das ist R-30s Aussage, nicht R-21s.
         // Ohne diese Klausel feuert die Regel an einem code-importierten Graphen wie moneyflow
         // 219 von 219 Mal und meldet in Wahrheit "dieses Repo hat keine Wirkketten", einmal je Kante.

package/package.json

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