@sigloch/contracts 3.2.0 → 4.0.0

package/dist/se/metric-rules.js

@@ -1,46 +1,30 @@
-const INSTABILITY_THRESHOLD = 0.7;
 /**
  * MT-01: Module Instability (CR-165: indirect via allocate-path).
- * I = fan_out / (fan_in + fan_out) > 0.7 → warning.
+ * I = fan_out / (fan_in + fan_out) > `policy.instability` → warning.
  * fan_out = traces from FUNCs-in-module pointing to elements OUTSIDE the module.
  * fan_in = traces from OUTSIDE pointing to FUNCs-in-module.
  * Direct MOD→MOD io/compose traces also count.
+ *
+ * CR-SM-233: die Schwelle ist Eingabe, nicht Konstante — `policy.instability === null`
+ * heißt messen, nicht urteilen (`moduleMetrics` liefert den Wert unverändert weiter).
  */
-export function mt01Instability(graph) {
+export function mt01Instability(graph, policy) {
     const violations = [];
-    const mods = graph.elements.filter(e => e.type === 'MOD');
-    for (const mod of mods) {
-        // FUNCs allocated to this module
-        const modFuncIds = new Set(graph.traces
-            .filter(t => t.type === 'allocate' && t.target === mod.id)
-            .map(t => t.source));
-        // Direct MOD-level traces (MOD→MOD io/compose)
-        const directOut = graph.traces.filter(t => t.source === mod.id && (t.type === 'io' || t.type === 'compose') && t.target !== mod.id).length;
-        const directIn = graph.traces.filter(t => t.target === mod.id && (t.type === 'io' || t.type === 'compose' || t.type === 'allocate')).length;
-        // Indirect: traces from module FUNCs to outside elements (and vice versa)
-        let indirectOut = 0;
-        let indirectIn = 0;
-        for (const t of graph.traces) {
-            if (t.type === 'allocate')
-                continue; // allocate itself doesn't count as coupling
-            if (modFuncIds.has(t.source) && !modFuncIds.has(t.target) && t.target !== mod.id) {
-                indirectOut++;
-            }
-            if (modFuncIds.has(t.target) && !modFuncIds.has(t.source) && t.source !== mod.id) {
-                indirectIn++;
-            }
-        }
-        const fanOut = directOut + indirectOut;
-        const fanIn = directIn + indirectIn;
-        if (fanIn + fanOut === 0)
+    const threshold = policy.instability;
+    if (threshold === null)
+        return violations;
+    // CR-SM-232: EINE Rechnung, zwei Ausgaben. Die fan_in/fan_out-Formel steht in
+    // `measureModules` — hier wird nur noch geschwellt. Sonst stünde die Formel
+    // doppelt im selben File und der Export wäre eine zweite Implementierung.
+    for (const m of measureModules(graph)) {
+        if (m.instability === null)
             continue;
-        const instability = fanOut / (fanIn + fanOut);
-        if (instability > INSTABILITY_THRESHOLD) {
+        if (m.instability > threshold) {
             violations.push({
                 rule_id: 'MT-01',
                 severity: 'warning',
-                element_id: mod.id,
-                message: `${mod.name} has instability ${Math.round(instability * 100)}% (>${INSTABILITY_THRESHOLD * 100}%). fan_in=${fanIn}, fan_out=${fanOut}`,
+                element_id: m.moduleId,
+                message: `${m.moduleName} has instability ${Math.round(m.instability * 100)}% (>${threshold * 100}%). fan_in=${m.fanIn}, fan_out=${m.fanOut}`,
             });
         }
     }
@@ -49,103 +33,25 @@ export function mt01Instability(graph) {
 /**
  * MT-02: LCOM4 (Lack of Cohesion — component count).
  * MOD with allocated FUNCs that share no common io/satisfy targets → cohesion problem.
- * Components > 1 → info.
+ * `policy.lcom4.info` ≤ LCOM4 < `policy.lcom4.warning` → info, darüber warning.
+ *
+ * CR-SM-233: die Stufen sind Eingabe, `null` heißt messen statt urteilen.
  */
-export function mt02Lcom4(graph) {
+export function mt02Lcom4(graph, policy) {
     const violations = [];
-    const mods = graph.elements.filter(e => e.type === 'MOD');
-    for (const mod of mods) {
-        // Find all FUNCs allocated to this MOD
-        const allocTraces = graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id);
-        const funcIds = allocTraces.map(t => t.source);
-        if (funcIds.length < 2)
+    const steps = policy.lcom4;
+    if (steps === null)
+        return violations;
+    // CR-SM-232: die Union-Find-Rechnung steht in `measureModules`; hier nur die Stufen.
+    for (const m of measureModules(graph)) {
+        if (m.lcom4 === null)
             continue;
-        // Build adjacency: two FUNCs are connected if they share a common io/satisfy target
-        const funcTargets = new Map();
-        for (const fid of funcIds) {
-            const targets = new Set();
-            for (const t of graph.traces) {
-                if (t.source === fid && (t.type === 'io' || t.type === 'satisfy')) {
-                    targets.add(t.target);
-                }
-            }
-            funcTargets.set(fid, targets);
-        }
-        // Count connected components via union-find
-        const parent = new Map();
-        for (const fid of funcIds)
-            parent.set(fid, fid);
-        function find(x) {
-            while (parent.get(x) !== x) {
-                x = parent.get(x);
-            }
-            return x;
-        }
-        function union(a, b) {
-            const ra = find(a), rb = find(b);
-            if (ra !== rb)
-                parent.set(ra, rb);
-        }
-        for (let i = 0; i < funcIds.length; i++) {
-            for (let j = i + 1; j < funcIds.length; j++) {
-                const ti = funcTargets.get(funcIds[i]);
-                const tj = funcTargets.get(funcIds[j]);
-                // Check if they share any target
-                for (const t of ti) {
-                    if (tj.has(t)) {
-                        union(funcIds[i], funcIds[j]);
-                        break;
-                    }
-                }
-            }
-        }
-        // CR-165/CR-171: FUNCs sharing the same FLOW (via io in either direction) are connected
-        const funcIdSet = new Set(funcIds);
-        const flowToFuncs = new Map();
-        for (const t of graph.traces) {
-            if (t.type !== 'io')
-                continue;
-            // FLOW→FUNC direction
-            if (funcIdSet.has(t.target)) {
-                const srcEl = graph.elements.find(e => e.id === t.source);
-                if (srcEl?.type === 'FLOW') {
-                    if (!flowToFuncs.has(t.source))
-                        flowToFuncs.set(t.source, new Set());
-                    flowToFuncs.get(t.source).add(t.target);
-                }
-            }
-            // FUNC→FLOW direction (CR-171)
-            if (funcIdSet.has(t.source)) {
-                const tgtEl = graph.elements.find(e => e.id === t.target);
-                if (tgtEl?.type === 'FLOW') {
-                    if (!flowToFuncs.has(t.target))
-                        flowToFuncs.set(t.target, new Set());
-                    flowToFuncs.get(t.target).add(t.source);
-                }
-            }
-        }
-        for (const funcsInFlow of flowToFuncs.values()) {
-            const arr = [...funcsInFlow];
-            for (let i = 1; i < arr.length; i++)
-                union(arr[0], arr[i]);
+        const message = `${m.moduleName} has LCOM4=${m.lcom4} (${m.allocatedFuncs} FUNCs in ${m.lcom4} disconnected groups)`;
+        if (m.lcom4 >= steps.info && m.lcom4 < steps.warning) {
+            violations.push({ rule_id: 'MT-02', severity: 'info', element_id: m.moduleId, message });
         }
-        const roots = new Set(funcIds.map(find));
-        const lcom4 = roots.size;
-        if (lcom4 >= 4 && lcom4 <= 5) {
-            violations.push({
-                rule_id: 'MT-02',
-                severity: 'info',
-                element_id: mod.id,
-                message: `${mod.name} has LCOM4=${lcom4} (${funcIds.length} FUNCs in ${lcom4} disconnected groups)`,
-            });
-        }
-        else if (lcom4 > 5) {
-            violations.push({
-                rule_id: 'MT-02',
-                severity: 'warning',
-                element_id: mod.id,
-                message: `${mod.name} has LCOM4=${lcom4} (${funcIds.length} FUNCs in ${lcom4} disconnected groups)`,
-            });
+        else if (m.lcom4 >= steps.warning) {
+            violations.push({ rule_id: 'MT-02', severity: 'warning', element_id: m.moduleId, message });
         }
     }
     return violations;
@@ -204,65 +110,187 @@ function connectionPairs(graph) {
     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.
+ * The one per-module computation (CR-SM-232) — in GRAPH ORDER, unsorted.
  *
- * 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.
+ * `mt01Instability` and `mt02Lcom4` consume this and only threshold; `moduleMetrics()`
+ * exports a sorted copy. Keeping the internal list in `graph.elements` order is what
+ * makes the violation ORDER of both rules byte-identical to the pre-CR implementation
+ * — the export's worst-first ranking must not leak into the rule output.
  *
- * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
- * is deferred (CR-SM-223).
+ * Every value that is not measurable is `null`, never 0: a module with one allocated
+ * FUNC has no LCOM4, and a 1 there would be an invented statement about cohesion.
  */
-export function allocationCohesion(graph) {
-    const measurements = [];
+function measureModules(graph) {
     const mods = graph.elements.filter(e => e.type === 'MOD');
     const pairs = [...connectionPairs(graph)].map(p => p.split('|'));
+    const rows = [];
     for (const mod of mods) {
-        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 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++;
+        const allocated = graph.traces
+            .filter(t => t.type === 'allocate' && t.target === mod.id)
+            .map(t => t.source);
+        const modFuncIds = new Set(allocated);
+        // --- MT-01: fan-in / fan-out (CR-165, indirect via the allocate path) ---
+        const directOut = graph.traces.filter(t => t.source === mod.id && (t.type === 'io' || t.type === 'compose') && t.target !== mod.id).length;
+        const directIn = graph.traces.filter(t => t.target === mod.id && (t.type === 'io' || t.type === 'compose' || t.type === 'allocate')).length;
+        let indirectOut = 0;
+        let indirectIn = 0;
+        for (const t of graph.traces) {
+            if (t.type === 'allocate')
+                continue; // allocate itself doesn't count as coupling
+            if (modFuncIds.has(t.source) && !modFuncIds.has(t.target) && t.target !== mod.id)
+                indirectOut++;
+            if (modFuncIds.has(t.target) && !modFuncIds.has(t.source) && t.source !== mod.id)
+                indirectIn++;
         }
-        // No external connections → nothing to compare against, no signal.
-        if (external === 0)
-            continue;
-        measurements.push({
+        const fanOut = directOut + indirectOut;
+        const fanIn = directIn + indirectIn;
+        const instability = fanIn + fanOut === 0 ? null : fanOut / (fanIn + fanOut);
+        rows.push({
             moduleId: mod.id,
             moduleName: mod.name,
-            internal,
-            external,
-            cohesion: internal / (internal + external),
+            allocatedFuncs: allocated.length,
+            fanIn,
+            fanOut,
+            instability,
+            lcom4: lcom4Of(graph, allocated),
+            cohesion: cohesionOf(pairs, modFuncIds),
         });
     }
-    // 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));
+    return rows;
+}
+/** MT-02 core: connected components over the allocated FUNCs. null below 2 FUNCs. */
+function lcom4Of(graph, funcIds) {
+    if (funcIds.length < 2)
+        return null;
+    // Two FUNCs are connected if they share a common io/satisfy target.
+    const funcTargets = new Map();
+    for (const fid of funcIds) {
+        const targets = new Set();
+        for (const t of graph.traces) {
+            if (t.source === fid && (t.type === 'io' || t.type === 'satisfy'))
+                targets.add(t.target);
+        }
+        funcTargets.set(fid, targets);
+    }
+    const parent = new Map();
+    for (const fid of funcIds)
+        parent.set(fid, fid);
+    function find(x) {
+        while (parent.get(x) !== x) {
+            x = parent.get(x);
+        }
+        return x;
+    }
+    function union(a, b) {
+        const ra = find(a), rb = find(b);
+        if (ra !== rb)
+            parent.set(ra, rb);
+    }
+    for (let i = 0; i < funcIds.length; i++) {
+        for (let j = i + 1; j < funcIds.length; j++) {
+            const ti = funcTargets.get(funcIds[i]);
+            const tj = funcTargets.get(funcIds[j]);
+            for (const t of ti) {
+                if (tj.has(t)) {
+                    union(funcIds[i], funcIds[j]);
+                    break;
+                }
+            }
+        }
+    }
+    // CR-165/CR-171: FUNCs sharing the same FLOW (via io in either direction) are connected.
+    const funcIdSet = new Set(funcIds);
+    const flowToFuncs = new Map();
+    for (const t of graph.traces) {
+        if (t.type !== 'io')
+            continue;
+        if (funcIdSet.has(t.target)) {
+            const srcEl = graph.elements.find(e => e.id === t.source);
+            if (srcEl?.type === 'FLOW') {
+                if (!flowToFuncs.has(t.source))
+                    flowToFuncs.set(t.source, new Set());
+                flowToFuncs.get(t.source).add(t.target);
+            }
+        }
+        if (funcIdSet.has(t.source)) {
+            const tgtEl = graph.elements.find(e => e.id === t.target);
+            if (tgtEl?.type === 'FLOW') {
+                if (!flowToFuncs.has(t.target))
+                    flowToFuncs.set(t.target, new Set());
+                flowToFuncs.get(t.target).add(t.source);
+            }
+        }
+    }
+    for (const funcsInFlow of flowToFuncs.values()) {
+        const arr = [...funcsInFlow];
+        for (let i = 1; i < arr.length; i++)
+            union(arr[0], arr[i]);
+    }
+    return new Set(funcIds.map(find)).size;
+}
+/** CR-SM-223 core: internal vs. external connection pairs. null where there is no signal. */
+function cohesionOf(pairs, funcIds) {
+    if (funcIds.size < 2)
+        return null;
+    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 connections → nothing to compare against, no signal.
+    if (external === 0)
+        return null;
+    return { internal, external, ratio: internal / (internal + external) };
+}
+/**
+ * Per-module architecture metrics as NUMBERS — one row per MOD, threshold or not
+ * (CR-SM-232).
+ *
+ * MT-01 only ever reported the modules above 70 %, MT-02 only those with ≥ 4
+ * components, and both only inside a prose `message`. For every module below the
+ * threshold there was no value, there was nothing — so a trend ("was 62 %, is 68 %"),
+ * the actual steering signal, was unobtainable. This exports what the rules already
+ * compute; it invents no metric and calibrates no threshold.
+ *
+ * Sorted worst cohesion first (as `allocationCohesion` does — the ranking IS the
+ * signal); modules without a cohesion measurement follow, stable by `moduleId`.
+ */
+export function moduleMetrics(graph) {
+    const byId = (a, b) => a.moduleId < b.moduleId ? -1 : a.moduleId > b.moduleId ? 1 : 0;
+    return measureModules(graph).sort((a, b) => {
+        if (a.cohesion && b.cohesion)
+            return a.cohesion.ratio - b.cohesion.ratio || byId(a, b);
+        if (a.cohesion)
+            return -1;
+        if (b.cohesion)
+            return 1;
+        return byId(a, b);
+    });
+}
+export function allocationCohesion(graph) {
+    // CR-SM-232: dieselbe Rechnung wie `moduleMetrics` — hier nur die Projektion auf
+    // die Module MIT Messwert. Zwei Implementierungen derselben Kohäsion wären genau
+    // die Drift, gegen die dieser CR angetreten ist.
+    return moduleMetrics(graph)
+        .filter((m) => m.cohesion !== null)
+        .map((m) => ({
+        moduleId: m.moduleId,
+        moduleName: m.moduleName,
+        internal: m.cohesion.internal,
+        external: m.cohesion.external,
+        cohesion: m.cohesion.ratio,
+    }));
 }
 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-01', name: 'Module instability', severity: 'warning', evaluate: mt01Instability, domain: ['MOD'] },
+    { id: 'MT-02', name: 'Module cohesion (LCOM4)', severity: 'info', evaluate: mt02Lcom4, domain: ['MOD'] },
     // MT-03 retired as a rule (CR-SM-223) — see `allocationCohesion` above.
 ];
-export function evaluateMTRules(graph) {
-    return MT_RULES.flatMap(r => r.evaluate(graph));
+export function evaluateMTRules(graph, policy) {
+    return MT_RULES.flatMap(r => r.evaluate(graph, policy));
 }

package/dist/se/near-duplicate-rules.d.ts

@@ -34,11 +34,13 @@ export declare const ND_RULES: readonly [{
     readonly name: "FuncNearDuplicate";
     readonly severity: "error";
     readonly evaluate: typeof nd01FuncNearDuplicate;
+    readonly domain: readonly ["FUNC"];
 }, {
     readonly id: "ND-02";
     readonly name: "SchemaNearDuplicate";
     readonly severity: "error";
     readonly evaluate: typeof nd02SchemaNearDuplicate;
+    readonly domain: readonly ["SCHEMA"];
 }];
 /** Evaluate all near-duplicate rules. */
 export declare function evaluateNDRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/near-duplicate-rules.js

@@ -97,8 +97,8 @@ export function nd02SchemaNearDuplicate(graph) {
 // Aggregate
 // ---------------------------------------------------------------------------
 export const ND_RULES = [
-    { id: 'ND-01', name: 'FuncNearDuplicate', severity: 'error', evaluate: nd01FuncNearDuplicate },
-    { id: 'ND-02', name: 'SchemaNearDuplicate', severity: 'error', evaluate: nd02SchemaNearDuplicate },
+    { id: 'ND-01', name: 'FuncNearDuplicate', severity: 'error', evaluate: nd01FuncNearDuplicate, domain: ['FUNC'] },
+    { id: 'ND-02', name: 'SchemaNearDuplicate', severity: 'error', evaluate: nd02SchemaNearDuplicate, domain: ['SCHEMA'] },
 ];
 /** Evaluate all near-duplicate rules. */
 export function evaluateNDRules(graph) {

package/dist/se/ontology.d.ts

@@ -95,26 +95,72 @@ export type RepoRelativePath = z.infer<typeof RepoRelativePathSchema>;
  * Runnable binding for a TEST element (CR-GC-134, ontology bump 3.4.0).
  * Resolves a TEST node to the concrete artefact a runner can execute, enabling
  * bottom-up selective test deduction (`graph_tests`): change → impacted TESTs →
- * `testRef` → minimal selective run command.
+ * `testRefs` → minimal selective run command.
  *   - `file`  : test file path, e.g. `tests/foo.test.ts` (the runner target).
  *   - `case`  : optional named case/`describe`/`it` block within the file.
  *   - `tool`  : the runner, e.g. `vitest`, `playwright`, `pytest`.
  *   - `level` : optional level, e.g. `unit`, `integration`, `validation`.
- * Stored under `OntologyElement.attributes.testRef` (additive, opt-in validation).
+ *
+ * `tool` steht bewusst **pro Eintrag**, nicht hochgezogen: eine Abnahme mischt real die
+ * Runner — ein TEST kann aus `tests/dashboard.test.mjs` (vitest) *und*
+ * `tests/visual/dashboard-render.spec.mjs` (playwright) bestehen. Ein Runner je TEST-Knoten
+ * wäre eine Lüge, die das alte 1:1-Schema nur deshalb nicht produzierte, weil es die zweite
+ * Datei gar nicht erst zuliess.
  */
 export declare const TestRefSchema: z.ZodObject<{
     file: z.ZodString;
     case: z.ZodOptional<z.ZodString>;
     tool: z.ZodString;
     level: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+        pending: "pending";
+    }>>;
+    ranAt: z.ZodOptional<z.ZodISODateTime>;
+    evidence: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type TestRef = z.infer<typeof TestRefSchema>;
+/**
+ * CR-SM-231: eine Abnahme, **n** Testdateien — 1:n, nie n:m.
+ *
+ * Vorher war `testRef` ein einzelnes Objekt: ein TEST-Knoten war an genau eine Datei bindbar.
+ * Eine Abnahme aus Unit- *und* Visual-Lauf konnte ihre Evidenz damit nicht vollstaendig
+ * deklarieren, und der Ausweichweg war belegt — dieselbe Spec-Datei stand im `testRef` zweier
+ * TEST-Knoten. Damit war die Relation faktisch n:m: ein roter Lauf war keiner Abnahme mehr
+ * eindeutig zuordenbar, waehrend der TRR-Gate dieselbe Evidenz doppelt zaehlte.
+ *
+ * **Warum n:m hier falsch ist.** n:m zwischen Abnahme und Anforderung ist bereits korrekt
+ * modelliert und in Gebrauch (`TEST -[verify]-> REQ`) — dafuer ist eine Kante da. Die Bindung
+ * an die Laufdatei ist etwas anderes: sie ist **Evidenz-Adresse**, kein Traceability-Link. Sie
+ * gehoert ins Attribut und bleibt 1:n — ein TEST kennt n Dateien, eine Datei gehoert zu
+ * hoechstens einem TEST. Die zweite Haelfte erzwingt R-29.
+ *
+ * Gespeichert unter `OntologyElement.attributes.testRefs`. Das alte `testRef` entfaellt
+ * ersatzlos — kein Union, kein Alias, keine parallelen Pfade.
+ */
+export declare const TestRefsSchema: z.ZodArray<z.ZodObject<{
+    file: z.ZodString;
+    case: z.ZodOptional<z.ZodString>;
+    tool: z.ZodString;
+    level: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+        pending: "pending";
+    }>>;
+    ranAt: z.ZodOptional<z.ZodISODateTime>;
+    evidence: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type TestRefs = z.infer<typeof TestRefsSchema>;
 /**
  * Realization binding for an element (CR-228, ontology bump 3.9.0) — unifies the
  * byte-identical former `codeRef` (FUNC → code symbol) and `schemaRef` (SCHEMA →
  * Zod export), and extends to MOD (physical part → CAD/geometry artefact). The
  * *type* of the pointing element disambiguates what kind of realization it is:
- * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRef`
+ * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRefs`
  * (a TEST is not just located but *executed* — the runner is the extra value).
  *   - `file`   : realization file path, e.g. `src/harness.ts`, `part.step`.
  *   - `symbol` : the realizing symbol (function/class/Zod export). Optional — a
@@ -330,7 +376,12 @@ export declare const ELEMENT_DESCRIPTIONS: Record<ElementType, string>;
 export declare const MODELING_ELEMENT_TYPES: ElementType[];
 export interface AttributeSpec {
     key: string;
-    type: 'string' | 'number' | 'boolean' | 'enum' | 'object';
+    /**
+     * CR-SM-231: `array` kommt dazu — `testRefs` ist das erste Attribut, das eine Liste ist.
+     * Als `object` deklariert waere es fuer jeden Konsumenten, der diese Spezifikation liest
+     * (Format-E-Editor, Doku-Generator), formal falsch.
+     */
+    type: 'string' | 'number' | 'boolean' | 'enum' | 'object' | 'array';
     enumValues?: readonly string[];
     description: string;
 }

package/dist/se/ontology.js

@@ -58,25 +58,65 @@ export const RepoRelativePathSchema = z
  * Runnable binding for a TEST element (CR-GC-134, ontology bump 3.4.0).
  * Resolves a TEST node to the concrete artefact a runner can execute, enabling
  * bottom-up selective test deduction (`graph_tests`): change → impacted TESTs →
- * `testRef` → minimal selective run command.
+ * `testRefs` → minimal selective run command.
  *   - `file`  : test file path, e.g. `tests/foo.test.ts` (the runner target).
  *   - `case`  : optional named case/`describe`/`it` block within the file.
  *   - `tool`  : the runner, e.g. `vitest`, `playwright`, `pytest`.
  *   - `level` : optional level, e.g. `unit`, `integration`, `validation`.
- * Stored under `OntologyElement.attributes.testRef` (additive, opt-in validation).
+ *
+ * `tool` steht bewusst **pro Eintrag**, nicht hochgezogen: eine Abnahme mischt real die
+ * Runner — ein TEST kann aus `tests/dashboard.test.mjs` (vitest) *und*
+ * `tests/visual/dashboard-render.spec.mjs` (playwright) bestehen. Ein Runner je TEST-Knoten
+ * wäre eine Lüge, die das alte 1:1-Schema nur deshalb nicht produzierte, weil es die zweite
+ * Datei gar nicht erst zuliess.
  */
 export const TestRefSchema = z.object({
     file: RepoRelativePathSchema,
     case: z.string().optional(),
     tool: z.string(),
     level: z.string().optional(),
+    /**
+     * CR-SM-231b: das Ergebnis haengt **pro Eintrag**, aus demselben Grund wie `tool`.
+     *
+     * Vorher lag `testResult` am TEST-**Knoten**. Mit n Eintraegen ist das mehrdeutig: laeuft eine
+     * Abnahme als vitest *und* playwright, kann ein einzelnes Ergebnis nicht sagen, welcher Lauf
+     * gemeint ist — und „einer rot, einer gruen" ist gar nicht darstellbar. Genau der Zustand,
+     * den ein Gate wissen muss.
+     *
+     * Optional: ein Eintrag ohne Ergebnis ist noch nicht gelaufen, nicht „bestanden". VR-01
+     * meldet das.
+     */
+    result: TestResult.optional(),
+    /** ISO-Zeitstempel des Laufs, der `result` erzeugt hat. Ohne ihn ist ein Ergebnis undatiert. */
+    ranAt: z.iso.datetime().optional(),
+    /** Repo-relativer Pfad zum Lauf-Artefakt (Report, Screenshot, Trace) — die Evidenz zur Aussage. */
+    evidence: RepoRelativePathSchema.optional(),
 });
+/**
+ * CR-SM-231: eine Abnahme, **n** Testdateien — 1:n, nie n:m.
+ *
+ * Vorher war `testRef` ein einzelnes Objekt: ein TEST-Knoten war an genau eine Datei bindbar.
+ * Eine Abnahme aus Unit- *und* Visual-Lauf konnte ihre Evidenz damit nicht vollstaendig
+ * deklarieren, und der Ausweichweg war belegt — dieselbe Spec-Datei stand im `testRef` zweier
+ * TEST-Knoten. Damit war die Relation faktisch n:m: ein roter Lauf war keiner Abnahme mehr
+ * eindeutig zuordenbar, waehrend der TRR-Gate dieselbe Evidenz doppelt zaehlte.
+ *
+ * **Warum n:m hier falsch ist.** n:m zwischen Abnahme und Anforderung ist bereits korrekt
+ * modelliert und in Gebrauch (`TEST -[verify]-> REQ`) — dafuer ist eine Kante da. Die Bindung
+ * an die Laufdatei ist etwas anderes: sie ist **Evidenz-Adresse**, kein Traceability-Link. Sie
+ * gehoert ins Attribut und bleibt 1:n — ein TEST kennt n Dateien, eine Datei gehoert zu
+ * hoechstens einem TEST. Die zweite Haelfte erzwingt R-29.
+ *
+ * Gespeichert unter `OntologyElement.attributes.testRefs`. Das alte `testRef` entfaellt
+ * ersatzlos — kein Union, kein Alias, keine parallelen Pfade.
+ */
+export const TestRefsSchema = z.array(TestRefSchema).min(1);
 /**
  * Realization binding for an element (CR-228, ontology bump 3.9.0) — unifies the
  * byte-identical former `codeRef` (FUNC → code symbol) and `schemaRef` (SCHEMA →
  * Zod export), and extends to MOD (physical part → CAD/geometry artefact). The
  * *type* of the pointing element disambiguates what kind of realization it is:
- * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRef`
+ * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRefs`
  * (a TEST is not just located but *executed* — the runner is the extra value).
  *   - `file`   : realization file path, e.g. `src/harness.ts`, `part.step`.
  *   - `symbol` : the realizing symbol (function/class/Zod export). Optional — a
@@ -181,10 +221,10 @@ export const MODELING_ELEMENT_TYPES = ElementType.options.filter(t => t !== 'SES
  */
 export const ELEMENT_ATTRIBUTES = {
     TEST: [
-        { key: 'testResult', type: 'enum', enumValues: TestResult.options, description: 'Test execution outcome' },
+        // CR-SM-231b: das knotenweite `testResult` ist weg — das Ergebnis haengt pro testRefs-Eintrag.
         { key: 'sourceFile', type: 'string', description: 'Test file path (e.g. tests/foo.test.ts)' },
-        { key: 'testRef', type: 'object', description: 'Runnable binding {file, case?, tool, level?} — see TestRefSchema (CR-GC-134)' },
-        { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRef-binding requirement (CR-GC-205)' },
+        { key: 'testRefs', type: 'array', description: 'Runnable bindings [{file, case?, tool, level?, result?, ranAt?, evidence?}, …] — one acceptance, n test files (1:n), each with its own outcome. See TestRefsSchema (CR-SM-231)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRefs-binding requirement (CR-GC-205)' },
     ],
     REQ: [
         { key: 'severity', type: 'number', description: 'FMEA severity (1-10)' },