@sigloch/contracts 10.14.0 → 11.0.0

package/dist/se/rule-help.js

@@ -65,8 +65,8 @@ export const RULE_HELP = {
         prompt: "se-fmea",
     },
     'AF-05': {
-        plain: "No implementation plan is on record → derive the build order.",
-        se: "No `analysisFreshness.implplan` stamp under `SYS.attributes`.",
+        plain: "Parts of the model are not built yet and nobody has ordered the work → derive the build order.",
+        se: "Unbuilt elements exist (`TEST` / `FUNC` / `SCHEMA` without a binding, the exemptions of R-19/R-20/R-26 apply) and no `CR` has `status: open`. The plan is the set of open CRs, not a stamp; it falls due again with every change (CR-SM-395).",
         prompt: "se-plan",
     },
     'BQ-01': {
@@ -102,6 +102,7 @@ export const RULE_HELP = {
         plain: "Someone only ever uses the system in one way, which usually means their other situations are missing → describe the scenarios you left out.",
         se: "`ACTOR` whose `UC`s cover fewer than 2 distinct `operatingMode`s — a ConOps completeness signal.",
         prompt: "se-conops",
+        vorschlag: 'Ordne den Akteuren {n} Abläufe in mindestens zwei Betriebsarten zu.',
     },
     'CR-01': {
         plain: "Two parts exchange an unusually large amount of data, which usually means the boundary is in the wrong place → reconsider the cut.",
@@ -111,19 +112,17 @@ export const RULE_HELP = {
     'CR-R01': {
         plain: "A change is recorded but says nothing about what it changes → link it to what it touches.",
         se: "`CR` with no `relation` traces. It tracks nothing, so it is not traceable evidence.",
+        vorschlag: 'Verbinde die Änderungsaufträge {n} mit dem, was sie ändern.',
     },
     'CR-R02': {
         plain: "A change is marked finished but there is no commit proving it → record the commit, or set it back to open.",
         se: "`CR` with `status:done` and no `commitRef` attribute. This is the graph-vs-reality check for change history: \"done\" without evidence.",
+        vorschlag: 'Trage bei den erledigten Änderungsaufträgen {n} den Commit nach.',
     },
     'CR-R03': {
         plain: "Several open changes touch the same thing, so they will collide → sequence them or merge them.",
         se: "One element tracked by more than one `CR` with `status` open/in-progress.",
-    },
-    'CR-R05': {
-        plain: "This smallest-piece requirement has no work order — no change request points at it or at the function that fulfils it, and that function is not built yet, so no plan will ever build it → attach it to the change request that builds it.",
-        se: "Leaf `REQ` (no `compose`→`REQ` children) with no build order: no `CR -relation->` on the REQ itself nor on a `FUNC` that `satisfy`s it (CR-SM-343; the REQ side of CR-R01). A `FUNC` that is already built — valid `realRef` or `external`, not `concept` — covers the REQ without a CR (CR-SM-375). A CR on a `MOD`/`SYS` carrier does not count — a module is a container; such REQs take a direct `CR -relation-> REQ`. Silent, and not scored, on a graph without any `CR` node (`RULE_PRECONDITION`).",
-        prompt: "se-plan",
+        vorschlag: 'Kläre, welcher der offenen Änderungsaufträge an {n} zuerst ändert.',
     },
     'FC-02': {
         plain: "A scenario that is not broken into sub-scenarios has no described sequence of steps → add one, even if the steps are done by hand.",
@@ -150,16 +149,19 @@ export const RULE_HELP = {
         plain: "A requirement is marked as a risk but carries no risk ratings → rate how bad, how likely and how detectable it is (1-10 each).",
         se: "`REQ` with `role:\"risk\"` missing `severity` / `occurrence` / `detection` attributes (AIAG-VDA). The role is the requirement's motivation, not its kind — satisfy-neutral (CR-SM-365).",
         prompt: "se-fmea",
+        vorschlag: 'Bewerte die Risiken {n} nach Schwere, Auftreten und Entdeckung.',
     },
     'FM-02': {
         plain: "A known risk has nothing planned against it → write the countermeasure as its own requirement.",
         se: "`REQ` with `role:\"risk\"` and no `compose`d `REQ` with `role:\"mitigation\"`. The mitigation keeps its own kind (functional or non-functional) and is satisfied like any REQ of that kind (CR-SM-365).",
         prompt: "se-fmea",
+        vorschlag: 'Gib den Risiken {n} eine Gegenmaßnahme.',
     },
     'FM-03': {
         plain: "A high risk has no test that actually passed → add a test proving the countermeasure works.",
         se: "`REQ` with `role:\"risk\"`, Action Priority High (AIAG-VDA, RPN band as interim) and no verifying `TEST` whose every `testRefs` entry has `result:\"passed\"`.",
         prompt: "se-fmea",
+        vorschlag: 'Gib den hohen Risiken {n} einen Test.',
     },
     'IO-01': {
         plain: "Two steps in the same sequence have no described data passing between them → add the data one hands to the other.",
@@ -174,10 +176,12 @@ export const RULE_HELP = {
     'MS-01': {
         plain: "A milestone has no work assigned to it → assign the work items that belong to it.",
         se: "`MS` with no `CR` `relation`.",
+        vorschlag: 'Ordne den Meilensteinen {n} ihren Umfang zu.',
     },
     'MS-02': {
         plain: "A milestone waits on another milestone that doesn't exist → fix or remove the dependency.",
         se: "`MS` `depends-on` relation targeting a missing `MS`.",
+        vorschlag: 'Korrigiere die Abhängigkeiten der Meilensteine {n}.',
     },
     'MS-03': {
         plain: "A change is not assigned to any milestone, so it has no place in the plan → assign it.",
@@ -236,8 +240,14 @@ export const RULE_HELP = {
         vorschlag: 'Ordne die Tests {n} den Anforderungen zu, die sie prüfen.',
     },
     'R-32': {
-        plain: "A data contract exists in code but no test exercises it as a contract → add a test that tries every variant, including the ones it must reject, and link it to the schema.",
-        se: "`SCHEMA` with a symbol `realRef` (a Zod contract) and no `TEST -verify-> SCHEMA`. RC-04 checks the parse at the boundary; this checks the contract test (CR-SM-319).",
+        plain: "A data format is defined but no test exercises it as a contract → add a test that tries every variant, including the ones it must reject, and link it to the schema.",
+        se: "`SCHEMA` with no `TEST -verify-> SCHEMA` — every SCHEMA, bound or not (CR-SM-396; until then only those with a symbol `realRef`). RC-04 checks the parse at the boundary; this checks the contract test (CR-SM-319).",
+        vorschlag: 'Gib den Datenformaten {n} einen Vertragstest.',
+    },
+    'R-33': {
+        plain: "The model has no system yet — nothing says what is being built and where it ends → name the system.",
+        se: "No `SYS` element in the graph: the existence rule of stage 1. Everything else is composed below the system (CR-SM-395).",
+        vorschlag: 'Lege zuerst das System an und benenne, was gebaut wird.',
     },
     'R-08': {
         plain: "A link points at something that no longer exists → repair or remove the broken link.",
@@ -265,8 +275,8 @@ export const RULE_HELP = {
         vorschlag: 'Verbinde den Nutzer {n} über Datenflüsse mit den Funktionen.',
     },
     'R-17': {
-        plain: "The top level of your project is empty — nothing is inside it → add the main use cases, features, or modules.",
-        se: "`SYS` with no `compose` to `UC` / `REQ` / `MOD`.",
+        plain: "Nothing says yet who uses the system for what → add the main use cases.",
+        se: "`SYS` with no `compose` to a `UC`: the existence rule of stage 2. Requirements or modules below the system do not stand in for a use case (CR-SM-396).",
         vorschlag: 'Lege die Abläufe des Systems {n} an.',
     },
     'R-18': {
@@ -275,12 +285,16 @@ export const RULE_HELP = {
         vorschlag: 'Korrigiere die unzulässigen Verbindungen an {n}.',
     },
     'R-19': {
-        plain: "A test that's meant to run doesn't point to a test file → add the link to the test file, or, if it isn't written yet, mark it not-yet-written.",
-        se: "Realized `TEST` with no valid `testRefs` `[{file, case?, tool}, …]` (at least one entry); else set `concept:true` (a stub).",
+        plain: "Building has started, and a test doesn't point to a test file yet → add the link to the test file.",
+        se: "`TEST` with no valid `testRefs` `[{file, case?, tool}, …]` (at least one entry)." +
+            " Stage 11: due only once the build is open — an open CR or a first `realRef`/`testRefs` in the graph; before that it is not evaluated, not passed (CR-SM-395).",
+        vorschlag: 'Verbinde die Tests {n} mit ihren Testdateien.',
     },
     'R-20': {
-        plain: "A function is supposed to be built but doesn't point to its code → add the link to its code; or mark it not-built-yet / from-an-outside-library.",
-        se: "Realized `FUNC` with no valid `realRef` `{file, symbol}` (graph↔code binding); else `concept:true` / `external:true`.",
+        plain: "Building has started, and a function doesn't point to its code yet → add the link to its code; or mark it as coming from an outside library.",
+        se: "`FUNC` with no valid `realRef` `{file, symbol}` (graph↔code binding); else `external:true`." +
+            " Stage 11: due only once the build is open — an open CR or a first `realRef`/`testRefs` in the graph; before that it is not evaluated, not passed (CR-SM-395).",
+        vorschlag: 'Verbinde die Funktionen {n} mit ihrem Code.',
     },
     'R-21': {
         plain: "Two functions hand data over, but they are not in one chain together — or they are, and the chain is not covered: some function in it has no requirement, and no end-to-end test checks the chain → give each function of the chain a requirement it fulfils, or give the chain an end-to-end quality requirement and a test for it.",
@@ -298,12 +312,15 @@ export const RULE_HELP = {
         vorschlag: 'Gib den Modulen {n} Funktionen oder entferne sie.',
     },
     'R-26': {
-        plain: "A data format in the model isn't linked to the schema code that defines it → link it to the schema (or mark it concept/outside).",
-        se: "Realized `SCHEMA` with no valid `realRef` `{file, symbol}` (graph↔Zod binding); else `concept:true` / `external:true` (CR-211/228).",
+        plain: "Building has started, and a data format in the model isn't linked to the schema code that defines it yet → link it to the schema (or mark it as defined outside).",
+        se: "`SCHEMA` with no valid `realRef` `{file, symbol}` (graph↔Zod binding); else `external:true` (CR-211/228)." +
+            " Stage 11: due only once the build is open — an open CR or a first `realRef`/`testRefs` in the graph; before that it is not evaluated, not passed (CR-SM-395).",
+        vorschlag: 'Verbinde die Datenformate {n} mit ihrem Schema im Code.',
     },
     'R-29': {
         plain: "Two acceptances claim the same test file, so a red run cannot be traced to one of them and the gate counts that evidence twice → give the file to the one acceptance it really proves, or split it.",
         se: "Test file exclusivity (CR-SM-231): every file in `attributes.testRefs` belongs to at most one `TEST`. An acceptance may name n files (1:n) — a file may not name n acceptances. Severity `error`, deliberately sharper than R-19/R-20: a doubly claimed file makes gate numbers wrong, which is a mis-measurement, not a completeness signal. Purely structural — the file need not exist to be claimed twice.",
+        vorschlag: 'Gib jede Testdatei von {n} nur einem Test.',
     },
     'R-30': {
         plain: "This function sits in no chain of effects, so nobody can say which use case it serves — and the checks that would prove its wiring never look at it → add it to the chain of the use case it belongs to.",
@@ -318,42 +335,52 @@ export const RULE_HELP = {
     'RC-01': {
         plain: "A function points to code that isn't there anymore (file moved or name changed) → repoint it to the current code.",
         se: "FUNC `realRef` that does not resolve: file missing on disk or symbol not declared in it (CR-GC-253 conformance over CodeFacts).",
+        vorschlag: 'Korrigiere die Code-Verweise der Funktionen {n}, sie zeigen ins Leere.',
     },
     'RC-02': {
         plain: "A test points to a test file or test name that isn't there anymore → repoint it to the current test.",
         se: "A `testRefs` entry that does not resolve: file missing or `case` not declared as an it/test/describe (CR-GC-253). The message names the concrete path — with n entries the node id alone is not actionable.",
+        vorschlag: 'Korrigiere die Testverweise von {n}, die Testfälle gibt es nicht.',
     },
     'RC-03': {
         plain: "A data format points to schema code that isn't there anymore (file moved or export renamed) → repoint it to the current schema.",
         se: "SCHEMA `realRef` that does not resolve: file missing on disk or symbol not a declared export in it (CR-211/228 conformance over CodeFacts).",
+        vorschlag: 'Korrigiere die Code-Verweise der Datenformate {n}, sie zeigen ins Leere.',
     },
     'RC-04': {
         plain: "A data format is defined but the function on that interface never actually checks incoming data against it → validate with it there.",
         se: "Bound `SCHEMA` whose symbol is not imported+parsed (`.parse`/`.safeParse`) in any realized `FUNC` io-connected to it (CR-211); warn — the parse may sit in a framework layer.",
+        vorschlag: 'Lies die Datenformate {n} im Code an der Schnittstelle, an der das Modell sie führt.',
     },
     'RC-05': {
         plain: "Code in one building block imports code in another, but the model never says those two are connected → draw the connection in the model, or drop the import.",
         se: "File import crossing a `MOD` boundary with no documenting graph structure (no io/FLOW between the modules) — undocumented cross-module dependency (CR-212); warn indicator, not a blocker.",
+        vorschlag: 'Trage die Abhängigkeit der Module {n} ins Modell ein oder entferne den Import.',
     },
     'RC-06': {
         plain: "This element points at code in a package your project does not actually install → either add the package, or point at the one that owns the symbol now.",
         se: "An `external: true` `realRef` names a package that is in neither `dependencies` nor `devDependencies` of the consumer. Absent dependency data is SILENCE, not a violation — the extractor never looked, and treating that as \"declares nothing\" would report every external binding at once (CR-SM-262).",
+        vorschlag: 'Trage die Pakete, auf die {n} verweisen, als Abhängigkeit ein.',
     },
     'RC-07': {
         plain: "A change request is marked done in the model but still open in the folder (or the other way round), or an open change request has no entry in the model → the folder decides; fix the model.",
         se: "`CR` node whose `status` (closed = done; CR-SM-362) contradicts `docs/cr/open|done/`, or an OPEN CR file with no `CR` node (anchored at the first `SYS`). Nodes without a file are not reported — history. Absent `crFiles` is SILENCE (CR-SM-329).",
+        vorschlag: 'Gleiche die Änderungsaufträge {n} mit ihren Dateien ab.',
     },
     'RC-08': {
         plain: "A data contract in the model points at a type, which vanishes at runtime → write it as a Zod schema, so whoever produces the data can prove it and whoever reads it can check it.",
         se: "`SCHEMA` whose `realRef` symbol is declared but is not a Zod schema (extractor field `zodSymbols`). Every producer needs a checkable schema — \"nobody parses it\" only means the reader is not known yet. Absent `zodSymbols` is SILENCE. Owns the type-binding cause: RC-04 stays quiet on such a SCHEMA (CR-SM-358).",
+        vorschlag: 'Binde die Datenformate {n} an ein Schema statt an einen Typ.',
     },
     'RC-09': {
         plain: "Code somewhere reads a data contract on its own, but the model does not know that place → go through the one translator the model names, or add the new translator to the model.",
         se: "Zod-bound `SCHEMA` parsed (import + `.parse`/`.safeParse`) in a file that is neither its definition nor the `realRef` of a `FUNC` io-connected to a `FLOW` of this SCHEMA. The first code → model check: a second translator of one contract is a parallel path (spike CR-GC-637 — such paths share a contract, they are not similar). One finding per SCHEMA; test files exempt; runs only with `fileScope: 'all'` (CR-SM-358).",
+        vorschlag: 'Prüfe, wo die Datenformate {n} außerhalb ihrer Schnittstelle gelesen werden.',
     },
     'RC-10': {
         plain: "No file in the code can be assigned to this building block, so nobody can check whether its imports cross boundaries the model does not know → give the block its source folder, or point one of its functions at its code.",
-        se: "`MOD` with neither a `path` attribute nor an allocated `FUNC` carrying a bound `realRef` — the only two ways a file resolves to a module. Without either, RC-05 and the boundary measurement are blind for this module by construction (sigllm: 0 RC-05 findings at 19 % import coverage, 8 at 81 %). The message names the cost from `importCoverage`. `concept`/`external` modules are exempt, as for R-20 (CR-SM-344).",
+        se: "`MOD` with neither a `path` attribute nor an allocated `FUNC` carrying a bound `realRef` — the only two ways a file resolves to a module. Without either, RC-05 and the boundary measurement are blind for this module by construction (sigllm: 0 RC-05 findings at 19 % import coverage, 8 at 81 %). The message names the cost from `importCoverage`. `external` modules are exempt, as for R-20 (CR-SM-344). Stage 11: due only once the build is open — an open CR or a first `realRef`/`testRefs` in the graph; before that it is not evaluated, not passed (CR-SM-395).",
+        vorschlag: 'Gib den Modulen {n} ihren Quellordner.',
     },
     'RD-01': {
         plain: "A smallest-piece feature has nothing built to fulfil it → add what implements it.",
@@ -408,15 +435,18 @@ export const RULE_HELP = {
         plain: "A test exists but no result was ever recorded, so nobody knows if it passed → record the outcome.",
         se: "`TEST` with no `testResult` attribute — assumed pending, never assumed green.",
     },
-    // CR-SM-355: Task-Ausgaenge — sichtbar nur im Task trade / irr.
+    // CR-SM-355: die Ausgaenge von Variantenvergleich und Annahmen-Review. Sie melden erst, wenn die
+    // Analyse gestempelt ist — vorher schweigen sie von selbst (CR-SM-395).
     'TR-01': {
         plain: "The trade study is stamped, but the decision it produced is not on record as a CR (or the CR it names is missing or carries no decides edge) → record the decision as a CR and list its id in the stamp.",
         se: "Task outcome rule (CR-SM-355): `analysisFreshness.trade.crRefs` names existing CR elements, each carrying a `relation` edge labelled `decides` (the SP-1 decision record).",
         prompt: "se-trade",
+        vorschlag: 'Halte die Entscheidung des Variantenvergleichs für {n} als Änderungsauftrag fest.',
     },
     'IR-01': {
-        plain: "The assumption review names a CR that does not exist → fix the reference or add the CR; an empty list is fine when no assumption was load-bearing.",
-        se: "Task outcome rule (CR-SM-355): every id in `analysisFreshness.assumption-review.crRefs` resolves to a CR element; empty is a legitimate outcome (low-risk assumptions stay in the record).",
+        plain: "The assumption review names a requirement that does not exist → fix the reference or add the requirement with its test; an empty list is fine when no assumption was load-bearing.",
+        se: "Task outcome rule (CR-SM-355, CR-SM-397): every id in `analysisFreshness.assumption-review.reqRefs` resolves to a `REQ` element; empty is a legitimate outcome (low-risk assumptions stay in the record). The verifying `TEST` is R-01's finding. An analysis leaves requirements, never a build order.",
         prompt: "se-irr",
+        vorschlag: 'Lege die Anforderungen an, die das Annahmen-Review für {n} nennt.',
     },
 };

package/dist/se/rules.d.ts

@@ -6,6 +6,7 @@
 import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
 import type { MetricPolicy } from './policy.js';
+import type { RuleRole, RuleStage } from './readiness.js';
 export declare const RuleSeverity: z.ZodEnum<{
     error: "error";
     info: "info";
@@ -306,6 +307,14 @@ export interface RuleDefinition {
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
+    /**
+     * CR-SM-395: die STUFE — die spaeteste Menge, die die Regel braucht (`STAGE_SETS`), oder `'immer'`.
+     * Aus ihr folgen Rang und Marke (`markOfStage`); es gibt keine zweite Zuordnung. Pflichtfeld: ein
+     * Regeleintrag ohne Stufe bricht den Build.
+     */
+    stage: RuleStage;
+    /** CR-SM-395: `existence` | `analysis` — oder nichts. */
+    role?: RuleRole;
     /**
      * CR-SM-236: `policy` steht jeder Regel zur Verfuegung, damit eine Urteilsschwelle nirgends
      * als Literal im Regelcode zurueckbleibt. Regeln ohne Schwelle deklarieren den Parameter
@@ -369,6 +378,15 @@ export declare function decomposedFuncs(graph: OntologyGraph): Set<string>;
  * die zweite Wahrheit, die CR-SM-286/-302 beseitigt haben.
  */
 export declare function flowProducers(graph: OntologyGraph): Map<string, Set<string>>;
+/** Der Anker eines Befunds an einem Graphen ohne SYS — kein Element traegt diese Id. */
+export declare const GRAPH_ANCHOR = "graph";
+/**
+ * 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 declare function unbuiltElementIds(graph: OntologyGraph): string[];
 export declare const V3_RULES: RuleDefinition[];
 /** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
 export declare function evaluateRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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);
@@ -845,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,
@@ -1132,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')
@@ -1153,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 },
     }));
 }
@@ -1212,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
@@ -1230,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) => {
@@ -1294,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 },
             });
         }
@@ -1496,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
@@ -1506,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
@@ -1663,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'] },
-    { 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.