@sigloch/contracts 10.14.0 → 12.0.0

package/dist/se/rule-due.js

@@ -0,0 +1,72 @@
+/**
+ * FAELLIGKEIT (CR-SM-395) — der EINE Mechanismus, mit dem eine Regel auf ihren Zeitpunkt wartet.
+ *
+ * Jede Regel hat eine Menge: die Elemente, die sie prueft. Faellig ist sie, sobald die Menge nicht
+ * leer ist. Fuer die Stufen 1 bis 10 ist die Menge die `domain` der Regel — eine Regel ueber eine
+ * leere Menge schweigt von selbst, dort ist nichts zu bauen. Fuer die Stufen 11 (Bindung) und 12
+ * (Abgleich Modell gegen Code) ist die Menge der BAU: er ist eroeffnet, sobald es einen offenen
+ * AUFTRAG gibt (`hasOpenOrder` — eine Entscheidung ist ein erledigter Auftrag) oder irgendeine
+ * Bindung. Vorher ist die Regel NICHT AUSGEWERTET — nicht bestanden.
+ *
+ * Zwei Leser, eine Funktion:
+ *   - AUSWERTUNG: `whenDue` wickelt das `evaluate` der Regeln der Stufen 11 und 12 am Katalog
+ *     (`V3_RULES`, `VIEW_RULES`, `CODE_CONFORMANCE_RULES`). Wer immer die Regel ruft, bekommt das
+ *     Schweigen — auch ein direkter `rule.evaluate`-Aufruf.
+ *   - READINESS: wer einen Anteil bildet, fragt `isDue` und laesst eine nicht faellige Regel aus
+ *     Zaehler UND Nenner — sonst liest sich ihr Schweigen als Erfolg.
+ *
+ * Ersetzt `RULE_PRECONDITION` / `ruleApplies` / `withPrecondition` / `realizationBegun`
+ * (CR-SM-392): dort war „der Bau hat begonnen" eine benannte Vorbedingung an vier Regeln, mit dem
+ * Bauplan-Stempel als Ausloeser. Der Stempel wird nicht mehr gelesen; die Fuehrung uebernimmt
+ * AF-05 („es gibt Ungebautes, aber keinen offenen Auftrag").
+ */
+import { readRealRef, readTestRefs } from './ontology.js';
+import { toEvaluableGraph } from './flat-graph.js';
+/**
+ * Gibt es einen offenen Auftrag — einen CR mit `status: open`? Er muss nicht auf die Elemente zeigen.
+ *
+ * CR-SM-400 (Entscheidung des Autors 2026-10-07): ein offener CR IST ein Bauauftrag. Eine
+ * Entscheidung — das Ergebnis einer Analyse oder Optimierung — ist ein ERLEDIGTER Auftrag und
+ * eroeffnet deshalb keinen Bau. Der Filter auf `relation [label: decides]` (CR-SM-396) ist ohne
+ * Ersatz entfallen.
+ */
+export function hasOpenOrder(graph) {
+    return toEvaluableGraph(graph).elements.some((e) => e.type === 'CR' && e.attributes?.status === 'open');
+}
+const BUILD_OPEN = new WeakMap();
+/**
+ * Ist der Bau eroeffnet? Ein offener Auftrag ODER eine Bindung — ein `realRef` an irgendeinem
+ * Element oder `testRefs` an einem TEST. Eine Bindung von Hand, ohne Bauplan, zaehlt genauso.
+ * Gezaehlt wird die ANWESENHEIT des Attributs, nicht seine Gueltigkeit: eine ungueltige Bindung
+ * (leere Liste, alte Objektform) ist ein Bindungsversuch, und R-19/R-20/R-26 sind die einzigen
+ * Regeln, die sie melden — an „gueltig" gebunden schwiegen sie genau dort.
+ *
+ * Nimmt die flache wie die genestete Form; das Ergebnis haengt an der Graph-Identitaet wie `indexOf`.
+ */
+function buildOpen(graph) {
+    const cached = BUILD_OPEN.get(graph);
+    if (cached !== undefined)
+        return cached;
+    const open = hasOpenOrder(graph) ||
+        toEvaluableGraph(graph).elements.some((e) => readRealRef(e.attributes).state !== 'absent' ||
+            (e.type === 'TEST' && readTestRefs(e.attributes).state !== 'absent'));
+    BUILD_OPEN.set(graph, open);
+    return open;
+}
+/** Ist die Regel an diesem Graphen faellig — ist ihre Menge nicht leer? */
+export function isDue(rule, graph) {
+    if (rule.stage === 11 || rule.stage === 12)
+        return buildOpen(graph);
+    if (rule.domain.includes('graph'))
+        return true;
+    return graph.elements.some((e) => rule.domain.includes('all') || rule.domain.includes(e.type));
+}
+/**
+ * Wickelt das `evaluate` der Regeln, deren Menge nicht ihre `domain` ist (Stufen 11 und 12) — am
+ * Katalog, einmal. Die uebrigen Regeln kommen unveraendert (dieselbe Referenz) zurueck.
+ */
+export function whenDue(rules) {
+    return rules.map((rule) => rule.stage === 11 || rule.stage === 12
+        ? { ...rule, evaluate: (graph, ...rest) => (isDue(rule, graph) ? rule.evaluate(graph, ...rest) : []) }
+        : rule);
+}

package/dist/se/rule-help.d.ts

@@ -12,7 +12,7 @@
  * ## Was hier NICHT steht
  *
  * - **Abgeleitetes** — Titel, Severity, Meldung und `fix_hint` stehen an der Regeldefinition
- *   (`ALL_RULE_DEFS`), die Dimensions-/Phasenzuordnung in `readiness.ts`. Kein Wort davon wird
+ *   (`ALL_RULE_DEFS`), ebenso Stufe und Marke. Kein Wort davon wird
  *   hier wiederholt; ein zweiter Speicher derselben Wahrheit laeuft auseinander.
  * - **`fix_hint` gegen `plain`/`se`** — `fix_hint` ist die Anweisung an den AGENTEN („Add a
  *   `verify` trace"), `plain`/`se` die Erklaerung fuer den MENSCHEN („was ist hier eigentlich
@@ -56,6 +56,8 @@ export interface RuleHelpEntry {
      * Fix-Vorlage — der Nutzer entscheidet, der Agent fuehrt aus (graphcode CR-GC-729/730). Genau an den
      * Regeln, die den Kern-Fokus stellen koennen: Task `kern`, Schwere nicht `info`, kein Eintrittspunkt
      * einer Analyse (die haben ihren eigenen Satz beim Konsumenten). Beidseitig erzwungen im Test.
+     * CR-SM-395: seit die Arbeitsschritt-Zuordnung auf die Anforderungsqualitaet gekuerzt ist, sind das
+     * auch die Regeln ueber Risiken, Auftraege, Meilensteine, Bindung und Abgleich.
      */
     readonly vorschlag?: string;
 }

package/dist/se/rule-help.js

@@ -12,7 +12,7 @@
  * ## Was hier NICHT steht
  *
  * - **Abgeleitetes** — Titel, Severity, Meldung und `fix_hint` stehen an der Regeldefinition
- *   (`ALL_RULE_DEFS`), die Dimensions-/Phasenzuordnung in `readiness.ts`. Kein Wort davon wird
+ *   (`ALL_RULE_DEFS`), ebenso Stufe und Marke. Kein Wort davon wird
  *   hier wiederholt; ein zweiter Speicher derselben Wahrheit laeuft auseinander.
  * - **`fix_hint` gegen `plain`/`se`** — `fix_hint` ist die Anweisung an den AGENTEN („Add a
  *   `verify` trace"), `plain`/`se` die Erklaerung fuer den MENSCHEN („was ist hier eigentlich
@@ -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.",
@@ -205,7 +209,7 @@ export const RULE_HELP = {
     },
     'ND-02': {
         plain: "Two data contracts describe the same thing twice → merge them, or say what distinguishes them.",
-        se: "Near-duplicate `SCHEMA` above 0.85 similarity (name, description, fields and legal trace partners). Partners are filtered through `isValidTrace`: a rule must not reach its verdict via an edge R-18 rejects (CR-SM-286).",
+        se: "Near-duplicate `SCHEMA` above 0.85 similarity (name, description and legal trace partners). Partners are filtered through `isValidTrace`: a rule must not reach its verdict via an edge R-18 rejects (CR-SM-286).",
         vorschlag: 'Führe die doppelten Datenformate {n} zusammen oder grenze sie ab.',
     },
     'NFR-01': {
@@ -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,4 @@ 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.
-    '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",
-    },
-    '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).",
-        prompt: "se-irr",
-    },
 };

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
@@ -313,14 +322,12 @@ export interface RuleDefinition {
      */
     evaluate: (graph: OntologyGraph, policy: MetricPolicy) => RuleViolation[];
     /**
-     * CR-SM-235: die Grundgesamtheit, ueber die die Regel feuert — der Nenner ihres
-     * Readiness-Anteils. **Der Elementtyp, ueber den sie feuert, nicht das Thema, dem sie
-     * gehoert:** MS-03 („CR ohne Milestone") feuert je CR, nicht je MS.
+     * CR-SM-235: die Grundgesamtheit, ueber die die Regel feuert — die Menge, an der ihre
+     * Faelligkeit haengt (`isDue`). **Der Elementtyp, ueber den sie feuert, nicht das Thema, dem
+     * sie gehoert:** MS-03 („CR ohne Milestone") feuert je CR, nicht je MS.
      *
-     * Pflichtfeld, damit ein neuer Regeleintrag ohne Grundgesamtheit den Build bricht. Vorher
-     * lag die Zuordnung als Handtabelle in einem anderen Paket (`se-steering`), 18 von 71 Regeln
-     * fehlten dort — sie erhoehten den Zaehler, nie den Nenner, und jede neue Regel senkte den
-     * Score automatisch, bis jemand die zweite Tabelle nachzog.
+     * Pflichtfeld, damit ein neuer Regeleintrag ohne Grundgesamtheit den Build bricht. (Bis
+     * CR-SM-401 war sie auch der Nenner eines Prozentwerts je Dimension; den gibt es nicht mehr.)
      *
      * Mehrere Typen, wo die Regel ueber mehrere feuert (RD-04: FUNC, MOD und SYS als Eltern
      * einer Zerlegung). `['all']` = jedes Nicht-SESSION-Element (R-08/R-18 pruefen Traces).
@@ -330,12 +337,6 @@ export interface RuleDefinition {
      * Analyse-Freshness-Stempel (AF-01..05). Sie tragen KEINE
      * Grundgesamtheit bei, denn sie haben keine — der Stempel haengt zwar unter SYS, geprueft
      * wird aber der Graph, nicht das Element.
-     *
-     * Warum das zaehlt: mit `['SYS']` deklariert waren sie eine Ein-Element-Gruppe mit fast
-     * sicherem Verstoss. Eine Dimension ohne eigene Elemente (z. B. `req` in einem Graphen ohne
-     * eine einzige REQ) las dadurch **0 %** statt „nichts zu messen" — und der Executor
-     * fokussierte sie. Ein Graph-Check verfeinert eine Dimension, die es gibt; er erschafft
-     * keine.
      */
     domain: readonly string[];
 }
@@ -369,6 +370,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[];