@sigloch/contracts 3.3.0 → 4.1.0

package/dist/se/rules.js

@@ -4,7 +4,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { ElementType, TraceType, TestRefSchema, RealRefSchema } from './ontology.js';
+import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
 import { isValidTrace } from './meta-model.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). */
@@ -168,16 +168,26 @@ function asilIsolation(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
-// R-04: Max module size
+// R-04: Modulgroesse GEGEN Kreuzungen (nicht „max module size")
+//
+// CR-SM-236: die Regel waegt Groesse gegen kreuzende io-Flows ab — ein grosses Modul ohne
+// Kreuzungen ist info („kohaesiv, nur gross"), dasselbe Modul mit Kreuzungen ist warning.
+// Der alte Name gab das nicht her, und die drei Schwellen (8/12/2) standen inline: eine
+// Urteilsschwelle, die sich weder per grep noch aus dem Regelnamen ablesen laesst, ist nicht
+// ueberpruefbar. Jetzt sind es `policy.moduleSize.{coupled,large,crossings}`.
+// `null` → messen, nicht urteilen: die Regel schweigt.
 // ---------------------------------------------------------------------------
-function maxModuleSize(graph) {
-    const modules = graph.elements.filter(e => e.type === 'MOD');
+function maxModuleSize(graph, policy) {
     const violations = [];
+    const steps = policy.moduleSize;
+    if (steps === null)
+        return violations;
+    const modules = graph.elements.filter(e => e.type === 'MOD');
     for (const mod of modules) {
         const allocatedIds = graph.traces.filter(t => t.target === mod.id && t.type === 'allocate').map(t => t.source);
         const allocated = allocatedIds.map(id => graph.elements.find(e => e.id === id)).filter((e) => !!e);
         const funcCount = allocated.length;
-        if (funcCount <= 8)
+        if (funcCount <= steps.coupled)
             continue;
         // Count crossing flows: io paths from FUNCs in this module to FUNCs in other modules
         const funcIds = new Set(allocatedIds);
@@ -188,27 +198,27 @@ function maxModuleSize(graph) {
             const tgtIn = funcIds.has(t.target);
             return (srcIn && !tgtIn) || (!srcIn && tgtIn);
         }).length;
-        if (funcCount > 12 && crossings === 0) {
+        if (funcCount > steps.large && crossings === 0) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'info',
                 element_id: mod.id,
                 message: `${mod.id} has ${funcCount} functions but 0 crossings (cohesive, just large)`,
-                fix_hint: 'Consider splitting if complexity grows',
+                fix_hint: `Size alone is not the finding: > ${steps.large} functions without crossing flows is cohesive. Split only if crossings appear`,
                 context: { element_type: mod.type, element_name: mod.name, candidate_targets: toCandidates(allocated) },
             });
         }
-        else if (funcCount > 12 && crossings > 0) {
+        else if (funcCount > steps.large && crossings > 0) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'warning',
                 element_id: mod.id,
                 message: `${mod.id} has ${funcCount} functions and ${crossings} crossing flows (split recommended)`,
-                fix_hint: 'Split module into smaller units to reduce coupling',
+                fix_hint: `Split module into smaller units to reduce coupling (> ${steps.large} functions AND crossing flows)`,
                 context: { element_type: mod.type, element_name: mod.name, candidate_targets: toCandidates(allocated) },
             });
         }
-        else if (funcCount > 8 && crossings > 2) {
+        else if (funcCount > steps.coupled && crossings > steps.crossings) {
             violations.push({
                 rule_id: 'R-04',
                 severity: 'warning',
@@ -439,7 +449,7 @@ function decompositionBreadth(graph) {
     const byId = new Map(graph.elements.map(e => [e.id, e]));
     const counts = new Map();
     const bump = (parentId, kind) => {
-        const key = `${parentId}${kind}`;
+        const key = `${parentId}\u0000${kind}`;
         const entry = counts.get(key);
         if (entry)
             entry.n++;
@@ -621,11 +631,11 @@ function validTracePattern(graph) {
 }
 // ---------------------------------------------------------------------------
 // R-19: Runnable TEST binding (CR-GC-205 Item 4) — a TEST that is not explicitly
-// concept-only (attributes.concept === true) should carry a valid testRef runnable
+// concept-only (attributes.concept === true) should carry a valid testRefs runnable
 // binding so the deduced selective test set is trustworthy. WARNING (a completeness
 // signal like R-05, not a hard gate): a freshly-spec'd TEST is legitimately concept-
 // level until implemented, and the no-phantom-file guarantee is enforced separately
-// by the consumer's export materialization (every testRef.file is scaffolded). File
+// by the consumer's export materialization (every testRefs entry file is scaffolded). File
 // EXISTENCE is out of scope here (rules are pure, no I/O); this guards presence/shape
 // only and surfaces an unbound runnable TEST in rules_evaluate / readiness.
 // ---------------------------------------------------------------------------
@@ -633,17 +643,71 @@ function testMustHaveRunnableBinding(graph) {
     return graph.elements
         .filter(e => e.type === 'TEST')
         .filter(e => e.attributes?.concept !== true) // concept-only TESTs are exempt
-        .filter(e => !TestRefSchema.safeParse(e.attributes?.testRef).success)
+        // CR-SM-231: `testRefs` (Array, min 1) statt `testRef` (Objekt). Semantik unveraendert —
+        // Praesenz und Form, keine Datei-Existenz; die pruefst RC-02.
+        .filter(e => !TestRefsSchema.safeParse(e.attributes?.testRefs).success)
         .map(test => ({
         rule_id: 'R-19',
         severity: 'warning',
         element_id: test.id,
-        message: `${test.id} is a runnable TEST without a valid testRef binding`,
-        fix_hint: 'Add attributes.testRef {file, case?, tool, level?}, or set attributes.concept:true if it has no run artifact yet',
+        message: `${test.id} is a runnable TEST without a valid testRefs binding`,
+        fix_hint: 'Add attributes.testRefs [{file, case?, tool, level?}, …] with at least one entry, or set attributes.concept:true if it has no run artifact yet',
         context: { element_type: test.type, element_name: test.name },
     }));
 }
 // ---------------------------------------------------------------------------
+// R-29: Testdatei-Exklusivitaet (CR-SM-231)
+//
+// Jede Testdatei erscheint in hoechstens einem `testRefs`. Das ist die Haelfte, die 1:n
+// **erzwingt** statt es nur zu erlauben — ohne sie driftet das Attribut zurueck nach n:m,
+// und genau das war der belegte Ist-Zustand: dieselbe Spec-Datei stand im `testRef` zweier
+// TEST-Knoten. Folge: ein roter Lauf ist keiner Abnahme mehr eindeutig zuordenbar, und der
+// TRR-Gate zaehlt dieselbe Evidenz doppelt.
+//
+// `error`, nicht `warning` (Entscheid 2026-08-13): eine doppelt beanspruchte Datei macht
+// Gate-Zahlen nachweislich falsch. Das ist eine Fehlmessung, kein Vollstaendigkeits-Signal —
+// und damit eine andere Klasse als R-19/R-20, die beide `warning` sind.
+//
+// Rein graph-strukturell, kein I/O: die Datei muss nicht existieren, um doppelt beansprucht
+// zu sein.
+// ---------------------------------------------------------------------------
+function testFileExclusivity(graph) {
+    const claimedBy = new Map();
+    for (const el of graph.elements) {
+        if (el.type !== 'TEST')
+            continue;
+        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
+        if (!parsed.success)
+            continue; // keine/ungueltige Bindung → R-19-Gebiet
+        // Innerhalb EINES Knotens ist dieselbe Datei zweimal kein Konflikt, sondern eine
+        // Redundanz — sie wuerde sonst als Selbstkollision gemeldet.
+        for (const file of new Set(parsed.data.map(r => r.file))) {
+            const owners = claimedBy.get(file) ?? [];
+            owners.push(el.id);
+            claimedBy.set(file, owners);
+        }
+    }
+    const violations = [];
+    for (const [file, owners] of claimedBy) {
+        if (owners.length < 2)
+            continue;
+        const sorted = [...owners].sort();
+        // Einmal je beanspruchendem Knoten: jeder von ihnen muss handeln, und eine Meldung an
+        // nur einem waere fuer die anderen unsichtbar.
+        for (const owner of sorted) {
+            violations.push({
+                rule_id: 'R-29',
+                severity: 'error',
+                element_id: owner,
+                message: `${owner} claims test file '${file}', which is also claimed by ${sorted.filter(o => o !== owner).join(', ')}`,
+                fix_hint: 'A test file belongs to at most one TEST. Split the file, or drop the entry from all but the one acceptance it really evidences',
+                context: { element_type: 'TEST', element_name: graph.elements.find(e => e.id === owner)?.name },
+            });
+        }
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
 // R-20: FUNC realRef binding (CR-GC-205 Item 5, extended by CR-210, unified CR-228)
 // — a FUNC that is not explicitly concept-only (attributes.concept === true) or
 // externally realized (attributes.external === true) counts as BOUND when it EITHER
@@ -876,7 +940,7 @@ function modMustHaveAllocatedFunc(graph) {
 // so its Zod definition is machine-resolvable (RC-03 then checks it resolves, RC-04
 // that it is parsed at the interface). WARNING, not error: currently-unbound SCHEMAs
 // on the reference model must not turn readiness red before any binding exists — the
-// presence signal mirrors R-20 (FUNC realRef) / R-19 (testRef). Symbol RESOLUTION is
+// presence signal mirrors R-20 (FUNC realRef) / R-19 (testRefs). Symbol RESOLUTION is
 // out of scope here (pure, no I/O — that is RC-03's job).
 // ---------------------------------------------------------------------------
 function schemaMustHaveSchemaRef(graph) {
@@ -953,35 +1017,36 @@ function ebenenPraesenz(graph) {
         }];
 }
 export const V3_RULES = [
-    { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification },
-    { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq },
-    { id: 'R-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation },
-    { id: 'R-04', name: 'Max module size', severity: 'warning', evaluate: maxModuleSize },
-    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq },
-    { id: 'R-14', name: 'UC must have compose', severity: 'warning', evaluate: ucMustHaveCompose },
-    { id: 'R-15', name: 'FCHAIN must have compose', severity: 'warning', evaluate: fchainMustHaveCompose },
-    { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace },
-    { id: 'R-17', name: 'SYS must have compose', severity: 'warning', evaluate: sysMustHaveCompose },
-    { id: 'R-08', name: 'Trace consistency', severity: 'error', evaluate: traceConsistency },
-    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness },
-    { id: 'R-12', name: 'No circular dependencies', severity: 'warning', evaluate: noDirectCircular },
-    { id: 'R-18', name: 'Valid trace pattern', severity: 'error', evaluate: validTracePattern },
-    { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding },
-    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding },
-    { id: 'R-21', name: 'FUNC↔FUNC connection needs integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest },
-    { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated },
-    { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc },
-    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef },
-    { id: 'R-27', name: 'Physical MOD must have realRef', severity: 'warning', evaluate: physicalModMustHaveRealRef },
-    { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement },
-    { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency },
-    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition },
-    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth },
-    { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope },
-    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency },
-    { id: 'R-28', name: 'Ebenen-Präsenz (FLOW+SCHEMA when funcCount>1)', severity: 'warning', evaluate: ebenenPraesenz },
+    { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification, domain: ['REQ'] },
+    { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq, domain: ['FUNC'] },
+    { id: 'R-03', name: 'ASIL isolation', severity: 'error', evaluate: asilIsolation, domain: ['FUNC'] },
+    { id: 'R-04', name: 'Module size relative to crossing flows', severity: 'warning', evaluate: maxModuleSize, domain: ['MOD'] },
+    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq, domain: ['TEST'] },
+    { id: 'R-14', name: 'UC must have compose', severity: 'warning', evaluate: ucMustHaveCompose, domain: ['UC'] },
+    { id: 'R-15', name: 'FCHAIN must have compose', severity: 'warning', evaluate: fchainMustHaveCompose, domain: ['FCHAIN'] },
+    { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', evaluate: actorMustHaveTrace, domain: ['ACTOR'] },
+    { id: 'R-17', name: 'SYS must have compose', severity: 'warning', evaluate: sysMustHaveCompose, domain: ['SYS'] },
+    { id: 'R-08', name: 'Trace consistency', severity: 'error', evaluate: traceConsistency, domain: ['all'] },
+    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness, domain: ['FUNC'] },
+    { id: 'R-12', name: 'No circular dependencies', severity: 'warning', evaluate: noDirectCircular, domain: ['FUNC'] },
+    { id: 'R-18', name: 'Valid trace pattern', severity: 'error', evaluate: validTracePattern, domain: ['all'] },
+    { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding, domain: ['TEST'] },
+    { id: 'R-29', name: 'Test file exclusivity', severity: 'error', evaluate: testFileExclusivity, domain: ['TEST'] },
+    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding, domain: ['FUNC'] },
+    { id: 'R-21', name: 'FUNC↔FUNC connection needs integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN'] },
+    { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated, domain: ['FUNC'] },
+    { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc, domain: ['MOD'] },
+    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef, domain: ['SCHEMA'] },
+    { id: 'R-27', name: 'Physical MOD must have realRef', severity: 'warning', evaluate: physicalModMustHaveRealRef, domain: ['MOD'] },
+    { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement, domain: ['REQ'] },
+    { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency, domain: ['REQ'] },
+    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition, domain: ['REQ'] },
+    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
+    { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope, domain: ['MS'] },
+    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency, domain: ['MS'] },
+    { id: 'R-28', name: 'Ebenen-Präsenz (FLOW+SCHEMA when funcCount>1)', severity: 'warning', evaluate: ebenenPraesenz, domain: ['graph'] },
 ];
-/** Run all rules against a graph */
-export function evaluateRules(graph) {
-    return V3_RULES.flatMap(rule => rule.evaluate(graph));
+/** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
+export function evaluateRules(graph, policy) {
+    return V3_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

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

@@ -14,7 +14,8 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function sc02IsReferenced(graph: OntologyGraph): RuleViolation[];
 export declare function sc04FlowHasSchema(graph: OntologyGraph): RuleViolation[];
 export declare const SC_RULES: RuleDefinition[];
-export declare function evaluateSCRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateSCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -49,9 +49,11 @@ export function sc04FlowHasSchema(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
-    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced },
-    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema },
+    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced, domain: ['SCHEMA'] },
+    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema, domain: ['SCHEMA'] },
 ];
-export function evaluateSCRules(graph) {
-    return SC_RULES.flatMap(rule => rule.evaluate(graph));
+// CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
+// ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.
+export function evaluateSCRules(graph, policy) {
+    return SC_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

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

@@ -3,6 +3,7 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function uc01HasRequirements(graph: OntologyGraph): RuleViolation[];
 export declare function uc02HasActor(graph: OntologyGraph): RuleViolation[];
 export declare function uc03HasScenario(graph: OntologyGraph): RuleViolation[];
@@ -10,4 +11,4 @@ export declare function uc04GoalDefined(graph: OntologyGraph): RuleViolation[];
 export declare function uc05HasPostcondition(graph: OntologyGraph): RuleViolation[];
 export declare function uc06HasPrecondition(graph: OntologyGraph): RuleViolation[];
 export declare const UC_RULES: RuleDefinition[];
-export declare function evaluateUCRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateUCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -111,13 +111,15 @@ export function uc06HasPrecondition(graph) {
 // Aggregated
 // ---------------------------------------------------------------------------
 export const UC_RULES = [
-    { id: 'UC-01', name: 'UC has requirements', severity: 'error', evaluate: uc01HasRequirements },
-    { id: 'UC-02', name: 'UC has actor', severity: 'error', evaluate: uc02HasActor },
-    { id: 'UC-03', name: 'UC has scenario', severity: 'warning', evaluate: uc03HasScenario },
-    { id: 'UC-04', name: 'UC has goal', severity: 'warning', evaluate: uc04GoalDefined },
-    { id: 'UC-05', name: 'UC has postcondition', severity: 'info', evaluate: uc05HasPostcondition },
-    { id: 'UC-06', name: 'UC has precondition', severity: 'info', evaluate: uc06HasPrecondition },
+    { id: 'UC-01', name: 'UC has requirements', severity: 'error', evaluate: uc01HasRequirements, domain: ['UC'] },
+    { id: 'UC-02', name: 'UC has actor', severity: 'error', evaluate: uc02HasActor, domain: ['UC'] },
+    { id: 'UC-03', name: 'UC has scenario', severity: 'warning', evaluate: uc03HasScenario, domain: ['UC'] },
+    { id: 'UC-04', name: 'UC has goal', severity: 'warning', evaluate: uc04GoalDefined, domain: ['UC'] },
+    { id: 'UC-05', name: 'UC has postcondition', severity: 'info', evaluate: uc05HasPostcondition, domain: ['UC'] },
+    { id: 'UC-06', name: 'UC has precondition', severity: 'info', evaluate: uc06HasPrecondition, domain: ['UC'] },
 ];
-export function evaluateUCRules(graph) {
-    return UC_RULES.flatMap(rule => rule.evaluate(graph));
+// CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
+// ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.
+export function evaluateUCRules(graph, policy) {
+    return UC_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

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

@@ -1,11 +1,7 @@
-/**
- * CR-184: View-related quality rules.
- * VR-01: TEST without testResult attribute (info).
- * CL-01: ACTOR without UCs in at least 2 distinct operatingModes (warning).
- */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation, RuleDefinition } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function vr01TestNoResult(graph: OntologyGraph): RuleViolation[];
 export declare function cl01ConopsCompleteness(graph: OntologyGraph): RuleViolation[];
 export declare const VIEW_RULES: RuleDefinition[];
-export declare function evaluateViewRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateViewRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/view-rules.js

@@ -1,15 +1,40 @@
+/**
+ * CR-184: View-related quality rules.
+ * VR-01: TEST with a testRefs entry that has no result (info).
+ * CL-01: ACTOR without UCs in at least 2 distinct operatingModes (warning).
+ */
+import { TestRefsSchema } from './ontology.js';
 // ---------------------------------------------------------------------------
-// VR-01: TEST without testResult
+// VR-01: ein testRefs-Eintrag ohne Ergebnis
+//
+// CR-SM-231b: liest das Ergebnis PRO EINTRAG statt am Knoten. Vorher hing `testResult` am
+// TEST-Knoten — bei n Eintraegen mehrdeutig: laeuft eine Abnahme als vitest UND playwright,
+// kann ein einzelnes Ergebnis nicht sagen, welcher Lauf gemeint ist. Die Meldung nennt jetzt
+// die Dateien ohne Ergebnis, nicht nur den Knoten.
+//
+// Ein TEST ohne gueltige Bindung faellt R-19 zur Last, nicht hier: sonst meldeten beide
+// Regeln denselben Sachverhalt (Presence/Resolution-Trennung).
 // ---------------------------------------------------------------------------
 export function vr01TestNoResult(graph) {
-    return graph.elements
-        .filter(e => e.type === 'TEST' && e.attributes?.['testResult'] == null)
-        .map(e => ({
-        rule_id: 'VR-01',
-        severity: 'info',
-        element_id: e.id,
-        message: `${e.id} has no testResult — assumed pending`,
-    }));
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'TEST')
+            continue;
+        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
+        if (!parsed.success)
+            continue; // keine/ungueltige Bindung → R-19-Gebiet
+        const pending = parsed.data.filter(ref => ref.result === undefined);
+        if (pending.length === 0)
+            continue;
+        violations.push({
+            rule_id: 'VR-01',
+            severity: 'info',
+            element_id: el.id,
+            message: `${el.id} has ${pending.length} of ${parsed.data.length} testRefs entries without a result — assumed pending: ${pending.map(r => r.file).join(', ')}`,
+            fix_hint: 'Record the run outcome on the entry (result, ranAt, evidence) — a binding without a result is not evidence',
+        });
+    }
+    return violations;
 }
 // ---------------------------------------------------------------------------
 // CL-01: ACTOR without UCs in >= 2 distinct operatingModes
@@ -48,9 +73,11 @@ export function cl01ConopsCompleteness(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const VIEW_RULES = [
-    { id: 'VR-01', name: 'TestNoResult', severity: 'info', evaluate: vr01TestNoResult },
-    { id: 'CL-01', name: 'ConopsCompleteness', severity: 'warning', evaluate: cl01ConopsCompleteness },
+    { id: 'VR-01', name: 'TestNoResult', severity: 'info', evaluate: vr01TestNoResult, domain: ['TEST'] },
+    { id: 'CL-01', name: 'ConopsCompleteness', severity: 'warning', evaluate: cl01ConopsCompleteness, domain: ['ACTOR'] },
 ];
-export function evaluateViewRules(graph) {
-    return VIEW_RULES.flatMap(rule => rule.evaluate(graph));
+// CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
+// ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.
+export function evaluateViewRules(graph, policy) {
+    return VIEW_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "3.3.0",
+  "version": "4.1.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,6 +28,7 @@
     "prepublishOnly": "npm run build && npm run test"
   },
   "dependencies": {
+    "@sigloch/contracts": "^4.1.0",
     "zod": "^4.3.6"
   },
   "license": "MIT",