@sigloch/contracts 10.13.0 → 11.0.0

package/dist/se/rules.js

@@ -7,6 +7,7 @@ import { z } from 'zod/v4';
 import { ElementType, TraceType, readTestRefs, readRealRef } from './ontology.js';
 import { traceRejection, admittingAlternatives, isValidTrace, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
+import { whenDue } from './rule-due.js';
 import { moduleCrossings, subtreeFuncs } from './module-crossings.js';
 import { functionCriticality, chainsByFunc } from './function-criticality.js';
 export const RuleSeverity = z.enum(['error', 'warning', 'info']);
@@ -200,6 +201,10 @@ elements, ref) {
 }
 // ---------------------------------------------------------------------------
 // R-01: Every REQ must have at least one verify trace
+//
+// CR-SM-393: wieder genau das. CR-SM-391 hatte einen zweiten Befund angehaengt (Nicht-Konzept-REQ
+// braucht einen Nicht-Konzept-TEST); mit dem Attribut `concept` ist sein Gegenstand entfallen.
+// Ob der verifizierende TEST an eine Datei gebunden ist, fragt R-19 — ab Beginn der Realisierung.
 // ---------------------------------------------------------------------------
 function reqMustHaveVerification(graph) {
     const idx = indexOf(graph);
@@ -746,6 +751,12 @@ function decompositionBreadth(graph, policy) {
 // deshalb keine Zahl im Kontext und steuert nicht — sie ist Lesbarkeit, nicht Randbreite.
 // Eine Ebene ohne jedes Kind ist nicht ihr Fall: ein leeres MOD meldet R-23, eine FUNC ohne Kinder
 // ist ein Blatt.
+//
+// CR-SM-388 (ITEM-2026-731): die WURZEL ist ausgenommen — die Ebene direkt unter SYS, also beide
+// Zaehlungen mit SYS als Eltern (`SYS compose MOD` und der FUNC-Wurzelwald). Der Rat „in die Ebene
+// darueber aufloesen" ist dort nicht ausfuehrbar, ueber SYS liegt keine; und ein System aus einem
+// Modul oder einer Wurzelfunktion ist eine Architekturentscheidung, keine leere Abstraktion.
+// RD-04 (Obergrenze) gilt an der Wurzel weiter.
 // ---------------------------------------------------------------------------
 function decompositionNarrow(graph, policy) {
     const band = policy.decompositionBreadth;
@@ -753,7 +764,7 @@ function decompositionNarrow(graph, policy) {
         return [];
     const byId = indexOf(graph).byId;
     return breadthCounts(graph)
-        .filter(c => c.n < band.min)
+        .filter(c => c.n < band.min && byId.get(c.parentId)?.type !== 'SYS')
         .map(c => {
         const parent = byId.get(c.parentId);
         return {
@@ -839,19 +850,24 @@ function actorMustHaveTrace(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// R-17: SYS must have at least 1 compose trace (CR-117)
+// R-17: SYS must have at least one use case (CR-117; neu gefasst CR-SM-396).
+//
+// Die Existenz-Regel der Stufe 2. Bis CR-SM-396 schwieg sie, sobald das SYS IRGENDETWAS komponierte
+// (UC, REQ oder MOD) — ein Code-Import (SYS -compose-> MOD, kein UC) las damit SRR als erreicht,
+// „0 von 0" an der Stufe Anwendungsfall. Verlangt ist der Anwendungsfall selbst: `SYS -compose-> UC`
+// (im Meta-Modell `1..*`). Ein UC, der nicht am System haengt, genuegt nicht.
 // ---------------------------------------------------------------------------
-function sysMustHaveCompose(graph) {
+function sysMustHaveUseCase(graph) {
     const idx = indexOf(graph);
     const systems = idx.elementsOfType('SYS');
     return systems
-        .filter(sys => idx.out(sys.id, 'compose').length === 0)
+        .filter(sys => !idx.out(sys.id, 'compose').some(t => idx.typeOf(t.target) === 'UC'))
         .map(sys => ({
         rule_id: 'R-17',
         severity: 'warning',
         element_id: sys.id,
-        message: `${sys.id} has no compose traces (empty system)`,
-        fix_hint: 'Add at least one compose trace — the system decomposes into nothing',
+        message: `${sys.id} has no use case (no SYS -compose-> UC)`,
+        fix_hint: `Add at least one UC and a compose trace from ${sys.id} to it — a use case says who uses the system for what`,
         context: {
             element_type: sys.type,
             element_name: sys.name,
@@ -1126,19 +1142,18 @@ function cardinalityViolations(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
-// 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 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 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.
+// R-19: Runnable TEST binding (CR-GC-205 Item 4) — a TEST 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). File EXISTENCE is out of scope here (rules are pure, no
+// I/O — that is RC-02); this guards presence/shape only.
+//
+// CR-SM-393: keine Ausnahme je Element mehr (`concept` ist entfallen). „Noch nicht faellig" ist
+// eine Eigenschaft des Graphen: die Regel ist Stufe 11 und erst faellig, wenn der Bau eroeffnet
+// ist (`isDue`, CR-SM-395).
 // ---------------------------------------------------------------------------
 function testMustHaveRunnableBinding(graph) {
     const idx = indexOf(graph);
     return idx.elementsOfType('TEST')
-        .filter(e => e.attributes?.concept !== true) // concept-only TESTs are exempt
         // CR-SM-231: `testRefs` (Array, min 1) statt `testRef` (Objekt). Semantik unveraendert —
         // Praesenz und Form, keine Datei-Existenz; die pruefst RC-02.
         .filter(e => readTestRefs(e.attributes).state !== 'bound')
@@ -1147,7 +1162,7 @@ function testMustHaveRunnableBinding(graph) {
         severity: 'warning',
         element_id: test.id,
         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',
+        fix_hint: 'Add attributes.testRefs [{file, case?, tool, level?}, …] with at least one entry',
         context: { element_type: test.type, element_name: test.name },
     }));
 }
@@ -1206,8 +1221,8 @@ function testFileExclusivity(graph) {
 }
 // ---------------------------------------------------------------------------
 // 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
+// — a FUNC that is not externally realized (attributes.external === true) counts as
+// BOUND when it EITHER
 // carries a valid realRef {file, symbol?} OR is a blackbox parent whose compose→FUNC
 // children are ALL (recursively) bound — the parent is realized by its children
 // (e.g. FUNC-gesture-capture, gve CR-GVE-150). A partially-bound parent fires
@@ -1224,7 +1239,7 @@ function funcMustHaveCodeBinding(graph) {
         .filter(t => t.source === id && t.type === 'compose' && funcById.has(t.target))
         .map(t => t.target);
     const hasCodeRef = (el) => readRealRef(el.attributes).state === 'bound';
-    const isExempt = (el) => el.attributes?.concept === true || el.attributes?.external === true;
+    const isExempt = (el) => el.attributes?.external === true;
     // A FUNC is bound iff it is exempt, has a codeRef, or is a parent whose
     // compose→FUNC children are all bound (recursive, cycle-safe).
     const isBound = (id, stack) => {
@@ -1288,7 +1303,7 @@ function funcMustHaveCodeBinding(graph) {
                 severity: 'warning',
                 element_id: fn.id,
                 message: `${fn.id} is a FUNC without a valid realRef binding`,
-                fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (realized in another package)',
+                fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.external:true if it is realized in another package',
                 context: { element_type: fn.type, element_name: fn.name },
             });
         }
@@ -1490,7 +1505,7 @@ function modMustHaveAllocatedFunc(graph) {
 // REQ→MOD allocate edge as an invalid trace pattern.
 // ---------------------------------------------------------------------------
 // R-26: SCHEMA realRef presence (CR-211, unified CR-228) — a SCHEMA that is not
-// explicitly concept-only or external should carry a valid realRef {file, symbol?}
+// external should carry a valid realRef {file, symbol?}
 // 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
@@ -1500,54 +1515,45 @@ function modMustHaveAllocatedFunc(graph) {
 function schemaMustHaveSchemaRef(graph) {
     const idx = indexOf(graph);
     return idx.elementsOfType('SCHEMA')
-        .filter(e => e.attributes?.concept !== true && e.attributes?.external !== true)
+        .filter(e => e.attributes?.external !== true)
         .filter(e => readRealRef(e.attributes).state !== 'bound')
         .map(sc => ({
         rule_id: 'R-26',
         severity: 'warning',
         element_id: sc.id,
         message: `${sc.id} is a SCHEMA without a valid realRef binding`,
-        fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (foreign-API contract)',
+        fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.external:true if it is a foreign-API contract',
         context: { element_type: sc.type, element_name: sc.name },
     }));
 }
 // ---------------------------------------------------------------------------
-// R-32: Every realized SCHEMA must have a contract TEST (CR-SM-319, ITEM-2026-064).
-// A SCHEMA with a symbol-bearing realRef is a Zod contract in code. RC-04 checks that it is
-// PARSED at its boundary; this rule checks that it is TESTED as a contract — every variant
-// incl. rejection, independent of any scenario — via `TEST -verify-> SCHEMA` (CR-SM-317).
-// Chain tests (R-21) cover meaning end-to-end; they do not cover the contract's variants.
-// Owner's decision 2026-09-11: no exception, no KPI — a rule. concept-only SCHEMAs and
-// SCHEMAs without a symbol realRef are out of scope (presence is R-26's concern).
+// R-32: Every SCHEMA must have a contract TEST (CR-SM-319, ITEM-2026-064; alle Schemas CR-SM-396).
+// A SCHEMA is a contract. RC-04 checks that it is PARSED at its boundary; this rule checks that it
+// is TESTED as a contract — every variant incl. rejection, independent of any scenario — via
+// `TEST -verify-> SCHEMA` (CR-SM-317). Chain tests (R-21) cover meaning end-to-end; they do not
+// cover the contract's variants. Owner's decision 2026-09-11: no exception, no KPI — a rule.
+//
+// CR-SM-396 (Entscheidung des Autors 2026-10-06): die Regel gilt fuer JEDES Schema. Bis hierher
+// pruefte sie nur Schemas mit Symbol-`realRef` — als Existenz-Regel der Stufe 9 brauchte sie damit
+// die Bindung (Stufe 11), und im Entwurf verlangte keine Regel den Vertragstest: TRR las erreicht,
+// ohne dass ein Schema getestet war. Der Test ist Teil der Spezifikation, nicht des Baus.
 // ---------------------------------------------------------------------------
 function schemaMustHaveContractTest(graph) {
     const idx = indexOf(graph);
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
     const tests = idx.elementsOfType('TEST');
     return idx.elementsOfType('SCHEMA')
-        .filter(sc => sc.attributes?.concept !== true)
-        .filter(sc => { const r = readRealRef(sc.attributes); return r.state === 'bound' && r.value.symbol !== undefined; })
         .filter(sc => !graph.traces.some(t => t.type === 'verify' && t.target === sc.id && typeOf.get(t.source) === 'TEST'))
         .map(sc => ({
         rule_id: 'R-32',
         severity: 'warning',
         element_id: sc.id,
-        message: `${sc.id} is a realized SCHEMA without a contract TEST (no TEST -verify-> SCHEMA)`,
+        message: `${sc.id} is a SCHEMA without a contract TEST (no TEST -verify-> SCHEMA)`,
         fix_hint: 'Add a TEST that exercises every variant of the contract incl. rejection, and link it via verify trace to this SCHEMA',
         context: { element_type: sc.type, element_name: sc.name, candidate_targets: toCandidates(tests) },
     }));
 }
 // ---------------------------------------------------------------------------
-// R-27: physical MOD realRef presence (CR-228) — the MOD arm of the unified
-// "element must have a realRef" rule (FUNC=R-20, SCHEMA=R-26, physical MOD=R-27).
-// A physical MOD (kind='physical') is a Bauteil realized by a CAD/geometry
-// artefact, not by code (RT-01: FUNCs never allocate directly to it). Logical/SW
-// MODs are realized through their FUNCs' code (R-20) and are NOT in scope here.
-// WARNING (presence signal like R-20/R-26); concept/external MODs are exempt.
-// Symbol is optional on a realRef (a geometry file has none) — presence = a valid
-// realRef with a file. RESOLUTION (file on disk) is a consumer/RC concern.
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
 // R-28 (Ebenen-Präsenz) ist mit CR-SM-247 ersatzlos entfallen — nicht weil sie falsch war,
 // sondern weil sie seit CR-GC-366 doppelt ist. Sie schloss das Vacuous-Complete-Loch (mit 0/1
 // FUNC feuert keine Pro-Element-Regel, alles liest "fertig"); beide Hälften trägt heute je eine
@@ -1657,42 +1663,82 @@ function funcMustBeWired(graph) {
         },
     }));
 }
-export const V3_RULES = [
-    { 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'] },
+// ---------------------------------------------------------------------------
+// R-33 (CR-SM-395): die Existenz-Regel des SYSTEMS (Stufe 1).
+//
+// Jede Pflichtmenge wird von einer Existenz-Regel der Stufe davor verlangt; eine leere Pflichtmenge
+// ist deshalb immer ein Befund und nie „0 von 0 bestanden". „Kein System" stand als Code im
+// Kaltstart von graphcode (`graph_generate`), nicht im Katalog. Ein Graph ohne SYS hat kein Element,
+// an dem der Befund haengen koennte — er traegt den Anker `GRAPH_ANCHOR`.
+//
+// R-34 („FLOW hat ein SCHEMA", Stufe 8) ist mit CR-SM-396 wieder gestrichen: deckungsgleich mit der
+// R-18-Untergrenze `FLOW -relation-> SCHEMA [1]` — alle 20 Befunde des Bestands standen an FLOWs
+// mit R-18-Fehler, R-34 konnte nie allein melden. Die Stufe 8 traegt keine eigene Existenz-Regel:
+// R-18 ist `'immer'` und haelt als Fehler jede Marke, das Gate lehnt den untypisierten FLOW schon
+// beim Schreiben ab; null Datenfluesse haelt R-31 (Stufe 6).
+// ---------------------------------------------------------------------------
+/** Der Anker eines Befunds an einem Graphen ohne SYS — kein Element traegt diese Id. */
+export const GRAPH_ANCHOR = 'graph';
+function graphMustHaveSystem(graph) {
+    if (indexOf(graph).elementsOfType('SYS').length > 0)
+        return [];
+    return [{
+            rule_id: 'R-33',
+            severity: 'warning',
+            element_id: GRAPH_ANCHOR,
+            message: 'The graph has no SYS element — nothing names the system and its boundary',
+            fix_hint: 'Add one SYS element that names the system; use cases, requirements and modules are composed below it',
+        }];
+}
+/**
+ * CR-SM-395: das UNGEBAUTE — die Elemente, an denen die Praesenzregeln der Bindung melden wuerden
+ * (R-19 TEST, R-20 FUNC, R-26 SCHEMA), unabhaengig davon, ob sie schon faellig sind. EINE
+ * Definition samt Ausnahmen (`external`, Zerlegungs-Eltern mit gebundenen Kindern): AF-05 fragt
+ * damit „gibt es etwas zu bauen?", ohne die Ausnahmen ein zweites Mal zu schreiben.
+ */
+export function unbuiltElementIds(graph) {
+    return [...testMustHaveRunnableBinding(graph), ...funcMustHaveCodeBinding(graph), ...schemaMustHaveSchemaRef(graph)]
+        .map(v => v.element_id);
+}
+// CR-SM-395: die Faelligkeit haengt am KATALOG (`whenDue`), nicht am Auswerter und nicht im
+// Regelkoerper — die Regeln der Stufe 11 (R-19, R-20, R-26, R-29) schweigen, bis der Bau eroeffnet ist.
+export const V3_RULES = whenDue([
+    { id: 'R-33', name: 'Graph must have a SYS', severity: 'warning', stage: 1, role: 'existence', evaluate: graphMustHaveSystem, domain: ['graph'] },
+    { id: 'R-01', name: 'REQ must have verification', severity: 'error', stage: 9, role: 'existence', evaluate: reqMustHaveVerification, domain: ['REQ'] },
+    { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', stage: 5, evaluate: funcMustSatisfyReq, domain: ['FUNC'] },
     // CR-SM-243: domain ist MOD, nicht FUNC — die Regel iteriert Module und meldet am Modul,
     // das ASIL-D und QM mischt. Die FUNCs sind der Anlass des Urteils, nicht seine Traeger.
-    { id: 'R-04', name: 'Module boundary width', severity: 'warning', evaluate: moduleBoundaryWidth, domain: ['MOD'] },
-    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', evaluate: testMustVerifyReq, domain: ['TEST'] },
-    { id: 'R-15', name: 'FCHAIN completeness', severity: 'warning', evaluate: fchainCompleteness, 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-04', name: 'Module boundary width', severity: 'warning', stage: 7, evaluate: moduleBoundaryWidth, domain: ['MOD'] },
+    { id: 'R-05', name: 'TEST must verify REQ', severity: 'warning', stage: 9, evaluate: testMustVerifyReq, domain: ['TEST'] },
+    { id: 'R-15', name: 'FCHAIN completeness', severity: 'warning', stage: 5, role: 'existence', evaluate: fchainCompleteness, domain: ['FCHAIN'] },
+    { id: 'R-16', name: 'ACTOR must have io', severity: 'warning', stage: 2, evaluate: actorMustHaveTrace, domain: ['ACTOR'] },
+    { id: 'R-17', name: 'SYS must have a use case', severity: 'warning', stage: 2, role: 'existence', evaluate: sysMustHaveUseCase, domain: ['SYS'] },
+    { id: 'R-08', name: 'Trace consistency', severity: 'error', stage: 'immer', evaluate: traceConsistency, domain: ['all'] },
     // CR-SM-242: domain ist FLOW, nicht FUNC — die Regel iteriert ueber FLOWs und meldet am FLOW.
     // Als ['FUNC'] deklariert erhoehte sie den Zaehler einer Grundgesamtheit, zu der ihre
     // Verstoesse nicht gehoerten (bis zu 2 Legs je FLOW gegen einen FUNC-Nenner).
-    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', evaluate: flowCompleteness, domain: ['FLOW'] },
+    { id: 'R-10', name: 'FLOW completeness', severity: 'warning', stage: 6, evaluate: flowCompleteness, domain: ['FLOW'] },
     // Obergrenze zu R-10s Untergrenze — disjunkt, deshalb zwei IDs (CR-SM-307).
-    { id: 'IO-02', name: 'FLOW single producer', severity: 'error', evaluate: flowSingleProducer, domain: ['FLOW'] },
-    { 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 handover needs a shared chain covered by member REQs or an integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN', 'FUNC'] },
-    { 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-32', name: 'SCHEMA must have contract TEST', severity: 'warning', evaluate: schemaMustHaveContractTest, domain: ['SCHEMA'] },
-    { 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-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
-    { id: 'RD-05', name: 'Decomposition too narrow', severity: 'warning', evaluate: decompositionNarrow, 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: 'warning', evaluate: msDanglingDependency, domain: ['MS'] },
-    { id: 'R-30', name: 'FUNC leaf must belong to a function chain', severity: 'warning', evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },
-    { id: 'R-31', name: 'FUNC must be wired (io input + output)', severity: 'warning', evaluate: funcMustBeWired, domain: ['FUNC'] },
-];
+    { id: 'IO-02', name: 'FLOW single producer', severity: 'error', stage: 6, evaluate: flowSingleProducer, domain: ['FLOW'] },
+    { id: 'R-12', name: 'No circular dependencies', severity: 'warning', stage: 5, evaluate: noDirectCircular, domain: ['FUNC'] },
+    { id: 'R-18', name: 'Valid trace pattern', severity: 'error', stage: 'immer', evaluate: validTracePattern, domain: ['all'] },
+    { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', stage: 11, evaluate: testMustHaveRunnableBinding, domain: ['TEST'] },
+    { id: 'R-29', name: 'Test file exclusivity', severity: 'error', stage: 11, evaluate: testFileExclusivity, domain: ['TEST'] },
+    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', stage: 11, evaluate: funcMustHaveCodeBinding, domain: ['FUNC'] },
+    { id: 'R-21', name: 'FUNC↔FUNC handover needs a shared chain covered by member REQs or an integration test', severity: 'warning', stage: 9, evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN', 'FUNC'] },
+    { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', stage: 7, role: 'existence', evaluate: funcMustBeAllocated, domain: ['FUNC'] },
+    { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', stage: 7, evaluate: modMustHaveAllocatedFunc, domain: ['MOD'] },
+    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', stage: 11, evaluate: schemaMustHaveSchemaRef, domain: ['SCHEMA'] },
+    { id: 'R-32', name: 'SCHEMA must have contract TEST', severity: 'warning', stage: 9, role: 'existence', evaluate: schemaMustHaveContractTest, domain: ['SCHEMA'] },
+    { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', stage: 3, evaluate: unresolvedRequirement, domain: ['REQ'] },
+    { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', stage: 3, evaluate: decompositionConsistency, domain: ['REQ'] },
+    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', stage: 7, evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
+    { id: 'RD-05', name: 'Decomposition too narrow', severity: 'warning', stage: 7, evaluate: decompositionNarrow, domain: ['FUNC', 'MOD'] },
+    { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', stage: 10, evaluate: msEmptyScope, domain: ['MS'] },
+    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'warning', stage: 10, evaluate: msDanglingDependency, domain: ['MS'] },
+    { id: 'R-30', name: 'FUNC leaf must belong to a function chain', severity: 'warning', stage: 5, evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },
+    { id: 'R-31', name: 'FUNC must be wired (io input + output)', severity: 'warning', stage: 6, role: 'existence', evaluate: funcMustBeWired, domain: ['FUNC'] },
+]);
 /** 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

@@ -6,7 +6,7 @@
  * attributes and fired on exactly the same elements (Jaccard 1.0 vs R-26). SC-03 had
  * additionally become wrong — a SCHEMA correctly bound via `realRef` still fired it.
  * `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution);
- * a spec-only SCHEMA is `concept:true`, it does NOT carry a Zod body copy in the graph
+ * a spec-only SCHEMA simply has none yet, it does NOT carry a Zod body copy in the graph
  * (same rule as TEST: bindings point at code, they never mirror it).
  *
  * What remains here is the one SCHEMA check that is NOT about binding: is the interface

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

@@ -32,7 +32,7 @@ export const SC_RULES = [
     // Die Asymmetrie zur FLOW-Seite ist gewollt (CR-SM-242): SC-02 iteriert ueber SCHEMA
     // („wird dieses SCHEMA benutzt"); die Gegenrichtung je FLOW („hat dieser FLOW einen
     // Datenvertrag") traegt seit CR-SM-271 das R-18-Untergrenzen-Bein.
-    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced, domain: ['SCHEMA'] },
+    { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', stage: 8, evaluate: sc02IsReferenced, domain: ['SCHEMA'] },
 ];
 // 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.

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

@@ -1,4 +1,5 @@
 import { indexOf } from './graph-index.js';
+import { hasPlaceholder } from './placeholder.js';
 // ---------------------------------------------------------------------------
 // UC-01: UC must have compose→REQ trace (CR-165: satisfy UC→REQ is invalid per meta-model)
 // ---------------------------------------------------------------------------
@@ -94,13 +95,12 @@ export function uc03HasScenario(graph) {
 // UC-04: UC must have meaningful description (CR-150: description = goal)
 // ---------------------------------------------------------------------------
 const UC_DESC_MIN_LEN = 10;
-const PLACEHOLDER_RE = /\b(tbd|todo|fixme|placeholder|xxx)\b/i;
 export function uc04GoalDefined(graph) {
     return graph.elements
         .filter(e => e.type === 'UC')
         .filter(uc => {
         const d = uc.description?.trim() ?? '';
-        return d.length < UC_DESC_MIN_LEN || PLACEHOLDER_RE.test(d);
+        return d.length < UC_DESC_MIN_LEN || hasPlaceholder(d);
     })
         .map(uc => ({
         rule_id: 'UC-04',
@@ -117,10 +117,10 @@ export function uc04GoalDefined(graph) {
 // CR-SM-357: UC-05/UC-06 (Pre-/Postcondition-REQ) sind gestrichen — Schreibregel in se:author-uc,
 // wie BQ in author-req (CR-GC-602): sie feuerten an fast jedem UC, und niemand handelte darauf.
 export const UC_RULES = [
-    { id: 'UC-01', name: 'UC has requirements', severity: 'warning', evaluate: uc01HasRequirements, domain: ['UC'] },
-    { id: 'UC-02', name: 'UC has actor', severity: 'warning', 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-01', name: 'UC has requirements', severity: 'warning', stage: 3, role: 'existence', evaluate: uc01HasRequirements, domain: ['UC'] },
+    { id: 'UC-02', name: 'UC has actor', severity: 'warning', stage: 2, role: 'existence', evaluate: uc02HasActor, domain: ['UC'] },
+    { id: 'UC-03', name: 'UC has scenario', severity: 'warning', stage: 4, role: 'existence', evaluate: uc03HasScenario, domain: ['UC'] },
+    { id: 'UC-04', name: 'UC has goal', severity: 'warning', stage: 2, evaluate: uc04GoalDefined, domain: ['UC'] },
 ];
 // 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.

package/dist/se/view-rules.js

@@ -4,6 +4,7 @@
  * CL-01: ACTOR without UCs in at least 2 distinct operatingModes (warning).
  */
 import { readTestRefs } from './ontology.js';
+import { whenDue } from './rule-due.js';
 // ---------------------------------------------------------------------------
 // VR-01: ein testRefs-Eintrag ohne Ergebnis
 //
@@ -103,10 +104,11 @@ export function cl01ConopsCompleteness(graph) {
 // ---------------------------------------------------------------------------
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
-export const VIEW_RULES = [
-    { id: 'VR-01', name: 'TestNoResult', severity: 'info', evaluate: vr01TestNoResult, domain: ['TEST'] },
-    { id: 'CL-01', name: 'ConopsCompleteness', severity: 'warning', evaluate: cl01ConopsCompleteness, domain: ['ACTOR'] },
-];
+// CR-SM-395: VR-01 ist Stufe 11 — ein Testergebnis gibt es erst, wenn der Bau eroeffnet ist (`whenDue`).
+export const VIEW_RULES = whenDue([
+    { id: 'VR-01', name: 'TestNoResult', severity: 'info', stage: 11, evaluate: vr01TestNoResult, domain: ['TEST'] },
+    { id: 'CL-01', name: 'ConopsCompleteness', severity: 'warning', stage: 2, evaluate: cl01ConopsCompleteness, domain: ['ACTOR'] },
+]);
 // 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) {

package/package.json

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