@sigloch/contracts 10.13.0 → 11.0.0

package/dist/se/rule-help.js

@@ -31,8 +31,11 @@
  * umformulierter Satz darf keinen Major ausloesen, deshalb steht im Golden-File nur die
  * Schluesselmenge, nicht die Prosa.
  *
- * Sprache: Englisch, wie die Regelbeschreibungen selbst. 18,6 KB reine Strings — der
- * `./browser`-Eintrag bleibt transitiv `node:`-frei (CR-SM-230), Strings ziehen nichts nach.
+ * Sprache: Englisch, wie die Regelbeschreibungen selbst — ausser `vorschlag`, der Satz, den ein Nutzer
+ * seinem Agenten schickt (CR-SM-384): Deutsch, weil er in der Sprache des Nutzers steht, nicht in der
+ * des Katalogs. Bis CR-SM-384 lag er als `VORSCHLAG_REGEL` in graphcode, ein paralleler Pfad zu
+ * `plain` und `fix_hint` mit derselben Driftgefahr wie oben. Reine Strings — der `./browser`-Eintrag
+ * bleibt transitiv `node:`-frei (CR-SM-230), Strings ziehen nichts nach.
  *
  * @author andreas@siglochconsulting
  */
@@ -62,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': {
@@ -93,80 +96,92 @@ export const RULE_HELP = {
     'BW-02': {
         plain: "This block hands out many different kinds of data at its edge → whoever uses it has to understand all of them, so either bundle them or split the block.",
         se: "Whitebox boundary width: distinct `SCHEMA` contracts on `FUNC` `io` `FLOW` `io` `FUNC` paths with one endpoint inside the `compose` subtree and one outside, judged against `metricPolicy.boundaryWidth.warning`. Parnas, information hiding — what a boundary HIDES is what makes it worth having. Rolled up over the subtree because a decomposed `FUNC` carries no `io` edges of its own (CR-SM-283).",
+        vorschlag: 'Bündle die Datenformate an der Grenze von {n} oder teile den Block.',
     },
     'CL-01': {
         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.",
         se: "High crossing `io` FLOW count between two `MOD`s — a coupling metric, advisory.",
+        vorschlag: 'Prüfe den Schnitt zwischen {n}, dort fließen ungewöhnlich viele Daten.',
     },
     '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.",
         se: "Leaf `UC` (no `UC -compose-> UC`) with no `FCHAIN`. A chain may consist of EXISTING FUNCs an actor strings together — it costs a node plus compose edges, not code.",
         prompt: "se:author-uc",
+        vorschlag: 'Beschreibe die Abläufe {n} als Kette von Funktionen.',
     },
     'FC-03': {
         plain: "A step inside a sequence contains further steps, so the sequence has hidden depth → lift them to the same level.",
         se: "`FUNC` inside an `FCHAIN` that itself `compose`s other `FUNC`s. Chains are flat by construction.",
+        vorschlag: 'Hebe die inneren Schritte der Funktionen {n} auf die Ebene ihrer Kette.',
     },
     'FC-04': {
         plain: "A sequence either has nobody starting it or nothing coming back out → wire both ends to whoever uses it.",
         se: "`FCHAIN` lacking an entry (`ACTOR -io-> FLOW -io-> FUNC∈chain`) or an exit (`FUNC∈chain -io-> FLOW -io-> ACTOR`). Stricter than FC-01: both directions, at FUNC/FLOW level, no UC-level bypass.",
+        vorschlag: 'Verbinde Anfang und Ende der Funktionsketten {n} mit dem Nutzer.',
     },
     'FC-05': {
         plain: "The steps of this sequence do not hand their results to each other — it falls apart into pieces, so nobody can say how long it is or where it gets stuck → add the missing step, connect the pieces with a data flow, or split it into separate sequences.",
         se: "`FCHAIN` whose member `FUNC`s do not form one (weakly) connected component along producer → consumer (`FUNC -io-> FLOW -io-> FUNC`, both ends members). Per side component the cause: `missing-link` (main and side part are joined through a `FUNC` outside the chain — compose it) or `bag` (no FUNC joins them: a missing FLOW between members, or parallel services at a shared source — split). One finding per chain, components in `context.side_components` (CR-SM-242). Silent while any member lacks an io input or output (R-31 first); entry/exit belong to FC-04 (CR-SM-363).",
+        vorschlag: 'Verbinde die Schritte der Funktionsketten {n} über Datenflüsse.',
     },
     'FM-01': {
         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.",
         se: "A `FUNC` pair inside one `FCHAIN` with no `io` path (`FUNC -io-> FLOW -io-> FUNC`) connecting them.",
+        vorschlag: 'Ergänze den Datenfluss zwischen den Schritten {n}.',
     },
     'IO-02': {
         plain: "Two different places write into the same flow, so a reader cannot tell which version arrives \u2192 give each source its own flow; they may keep sharing one contract.",
         se: "`FLOW` with more than one producer (`FUNC`/`ACTOR -io-> FLOW`). R-10 checks the LOWER bound of the same axis (at least one producer, at least one consumer); the two can never fire on the same FLOW, so there is no double count. Only the producer side is bounded: several consumers are the normal shape of a shared contract \u2014 one source, many readers, which is exactly how a central configuration looks. One finding per FLOW, `value` = number of producers, `threshold` 1. Severity `error` (hygiene) and deliberately NOT in STEER_RULES — a decision, not a measured conflict: a split flow keeps its `SCHEMA`, so BW-02 (distinct contracts per boundary) does not rise. Whether a gate blocks a new finding is the consumer's gating choice, not part of the rule.",
+        vorschlag: 'Gib jeder Quelle der Datenflüsse {n} einen eigenen Datenfluss.',
     },
     '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.",
@@ -176,10 +191,12 @@ export const RULE_HELP = {
     'MT-01': {
         plain: "This module draws more from others than others draw from it → it will keep changing whenever they do. Measured, not judged: no threshold is set by default.",
         se: "Instability I = fan_out / (fan_in + fan_out), counted in DISTINCT CONTRACTS crossing the module boundary — the same `moduleCrossings` definition CR-01, R-04 and BW-02 use (CR-SM-274/276). CR-SM-293 fixed both halves: it used to count every trace touching the module, of which only 34 % was coupling (`allocate` is module SIZE, `satisfy` is specification); and the direction was inverted — the CONSUMER depends, so supplying outward is fan_in (Martin's Ca) and drawing inward is fan_out (Ce). `metricPolicy.instability` defaults to `null`: the distribution is bimodal, so no threshold can be read from it. The number stays in every `graph_metrics` module row, next to `uphillDependencies` (CR-SM-301).",
+        vorschlag: 'Prüfe die Abhängigkeiten des Moduls {n}.',
     },
     'MT-02': {
         plain: "The parts inside this module never talk to each other → it is really several modules in one.",
         se: "LCOM4 over the BOXES of this module whitebox: its sub-MODs (`MOD -compose-> MOD`) plus its directly allocated `FUNC`s. A box owns its whole subtree, so a decomposed block carries the contracts of its leaves — the same ownership chain R-04 (CR-SM-282), BW-02 (CR-SM-283) and R-23 (CR-SM-321) use; without it a container counted as an empty group of its own and the number grew with decomposition DEPTH (CR-SM-326). Connected means a shared CONTRACT (`FLOW -relation-> SCHEMA`, else the untyped flow) — the same counting base as CR-01/R-04/MT-01 since CR-SM-274/276, not FLOW identity. CR-SM-297 dropped `satisfy`: two FUNCs meeting the same requirement can be fully decoupled at runtime, and if they share one, the REQUIREMENT is what needs decomposing. `null` (no judgement) below two boxes and where no box carries a contract at all — an unwired FUNC is R-31's statement, at the element. `info` from `metricPolicy.lcom4.info`, `warning` from `.warning` (CR-GC-329).",
+        vorschlag: 'Teile das Modul {n}, seine Teile arbeiten nicht zusammen.',
     },
     'MT-04': {
         plain: "This block's parts never talk to each other → it is really two blocks that happen to sit under one name.",
@@ -188,194 +205,248 @@ export const RULE_HELP = {
     'ND-01': {
         plain: "Two functions look like the same function written twice → merge them, or make clear what each one does differently.",
         se: "Near-duplicate `FUNC` above 0.85 similarity (name, description and legal trace partners). Since CR-SM-286 the similarity is computed IN the rule, cached per graph — before that it had to be injected, and without injection the rule returned green, indistinguishable from \"no duplicates\".",
+        vorschlag: 'Führe die doppelten Funktionen {n} zusammen oder grenze sie ab.',
     },
     '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).",
+        vorschlag: 'Führe die doppelten Datenformate {n} zusammen oder grenze sie ab.',
     },
     'NFR-01': {
         plain: "Something measured exceeds the limit that was set for it → fix it or change the limit deliberately.",
         se: "Measured value above its declared budget on a `MOD` (physical) or `FUNC`/`FCHAIN` (behavioural).",
+        vorschlag: 'Bringe {n} unter sein Budget oder ändere das Budget bewusst.',
     },
     'R-01': {
         plain: "A feature you've promised has no test proving it's met, so you can't show it works → add or author a test for it.",
         se: "`REQ` with no incoming `verify` trace (test→requirement coverage, INCOSE V&V).",
         prompt: "se:close-violations",
+        vorschlag: 'Ergänze Tests für die Anforderungen {n}.',
     },
     'R-02': {
         plain: "A function isn't linked to any feature it's meant to build, so it may be dead code → link it to the feature it serves, or delete it.",
         se: "`FUNC` with no `satisfy` trace to a `REQ` (design→requirement traceability).",
+        vorschlag: 'Ordne die Funktionen {n} den Anforderungen zu, die sie erfüllen.',
     },
     'R-04': {
         plain: "Too many different data formats cross this module's boundary → merge formats, or move the functions that carry them.",
         se: "`MOD` whose boundary is crossed by `metricPolicy.boundaryWidth.warning` or more DISTINCT contracts (`SCHEMA` on the io path `FUNC` ─io→ `FLOW` ─io→ `FUNC` across the boundary, union over all neighbours — CR-SM-276). Same question and same threshold as BW-02 on the FUNC tree (CR-SM-312); module SIZE is RD-04's question since CR-SM-311.",
         prompt: "se-view:arch",
+        vorschlag: 'Verringere die Datenformate an der Grenze des Moduls {n}.',
     },
     'R-05': {
         plain: "A test doesn't check any feature you promised → link it to the feature it tests, or remove it.",
         se: "`TEST` with no `verify` trace at all — neither to a `REQ` (test→requirement coverage) nor to a `SCHEMA` (contract test, CR-SM-317).",
+        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.",
         se: "Trace whose source or target element is missing (dangling reference).",
+        vorschlag: 'Repariere oder entferne die Verbindungen an {n}, deren Ziel fehlt.',
     },
     'R-10': {
         plain: "A piece of data goes nowhere — nothing produces or consumes it → connect it to a function or a person/outside system.",
         se: "`FLOW` with no `io` trace to a `FUNC` or `ACTOR`.",
+        vorschlag: 'Vervollständige die Datenflüsse {n}: woher sie kommen und wohin sie gehen.',
     },
     'R-12': {
         plain: "Two items depend on each other in a loop, so neither can stand alone → remove or redirect one of the two links.",
         se: "Direct cycle: A→B and B→A via the same trace type, checked on `compose` / `allocate` / `relation` only. Data (`io`) is exempt — a function that reads and writes the same `FLOW` is normal reuse, not a dependency cycle.",
+        vorschlag: 'Löse die zyklische Abhängigkeit um {n} auf.',
     },
     'R-15': {
-        plain: "A sequence of steps for a use case is empty → add the functions that make it up.",
-        se: "`FCHAIN` with no `compose` to any `FUNC`.",
+        plain: "A sequence of steps is empty, or serves no use case → add the functions that make it up, and attach it to the use case it belongs to.",
+        se: "`FCHAIN` with no `compose` to any `FUNC`, or with no incoming `compose` from a `UC` — one rule_id, up to two findings per chain (pattern of R-10).",
+        vorschlag: 'Gib den Funktionsketten {n} ihre Funktionen und ordne sie ihrem Ablauf zu.',
     },
     'R-16': {
         plain: "A person or outside system isn't connected to anything → connect it to the data it sends or receives.",
         se: "`ACTOR` with no `io` trace to a `FLOW`.",
+        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': {
         plain: "You connected two items in a combination that isn't allowed → use an allowed link, or fix what's at each end.",
         se: "Trace whose (source-type, target-type) pair isn't an allowed combination in the metamodel of legal links.",
+        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.",
         se: "FUNC↔FUNC handover (`FUNC` ─io→ `FLOW` ─io→ `FUNC`), two findings. (a) endpoints share NO `FCHAIN` → finding at the PRODUCER: no integration scope is declared. (b) endpoints share one, but no shared chain is covered → finding at the chain, naming the member FUNCs without a REQ. A chain is covered either (1) through its members — EVERY member FUNC (`FCHAIN` ─compose→ `FUNC`) satisfies at least one `REQ`; verifying those REQs is R-01's job (CR-SM-376) — or (2) end-to-end — a verified integration test (`TEST` ─verify→ `REQ` ←satisfy─ `FCHAIN`); an `FCHAIN` satisfies only non-functional REQs (CR-SM-366). SILENT when either endpoint is in no chain at all (that is R-30's statement) and when either is infrastructure (`chains >= policy.criticality.infrastructure`): a handover into a function that runs through every chain is a bus, not a missing test.",
+        vorschlag: 'Bringe die Übergaben an {n} in eine Funktionskette, deren Funktionen Anforderungen erfüllen oder die ein Integrationstest prüft.',
     },
     'R-22': {
         plain: "A function isn't assigned to any building block, so it has no home in the structure → put it on a module.",
         se: "`FUNC` with no `allocate` trace to a `MOD` (deployment assignment); every function lives on exactly one module.",
+        vorschlag: 'Ordne die Funktionen {n} Modulen zu.',
     },
     'R-23': {
         plain: "A building block is empty — no function is assigned to it or to any block inside it → put a function on it, or remove the empty block.",
         se: "`MOD` with no `FUNC` ─allocate→ trace anywhere in its `compose` subtree (`subtreeFuncs`, the same count R-04 uses, CR-SM-321); the module-side complement of R-22 (empty-container signal like R-14/R-16/R-17). A container `MOD` whose sub-modules hold functions is not empty.",
+        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.",
         se: "FUNC belongs to a function chain (CR-GC-366): a `FUNC` needs an incoming `FCHAIN -compose-> FUNC`, directly or inherited from a parent `FUNC` it decomposes from. R-15 demanded the opposite direction — that a chain has functions — and nothing demanded that a function has a chain. That gap is load-bearing: IO-01 (FLOW paths between chain members) and R-21 (integration test per chain) both scope themselves to a chain, so a function outside every chain falls through both nets silently. Severity `warning`, not error: on a real model this fires on the majority of functions, and an error would block every further mutation through the delta gate.",
+        vorschlag: 'Ordne die Funktionen {n} der Kette ihres Ablaufs zu.',
     },
     'R-31': {
         plain: "This function has no input or no output, so it is a dead block in the picture — only an actor is allowed to be an end point → connect it to a flow on the missing side.",
         se: "FUNC is wired (CR-GC-366): a `FUNC` needs at least one incoming `FLOW -io-> FUNC` and one outgoing `FUNC -io-> FLOW`. Only an `ACTOR` may terminate a chain. R-10 asks the same question from the FLOW side ('does this flow have a producer and a consumer?') and therefore never sees a function with no io edge at all — it does not appear in the FLOW loop. IO-01 presupposes chain membership and misses it too. One finding per FUNC naming the missing side(s), not one per side: otherwise the counter exceeds its own denominator contribution, the mis-measurement documented in CR-SM-242.",
+        vorschlag: 'Verbinde die Funktionen {n} auf der fehlenden Seite mit einem Datenfluss.',
     },
     '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.",
         se: "Leaf `REQ` (no `compose`→`REQ` children) with no `satisfy` from a `FUNC`/`FCHAIN`/`MOD`/`SYS`.",
         prompt: "se:close-violations",
+        vorschlag: 'Lege an, was die Anforderungen {n} erfüllt.',
     },
     'RD-02': {
         plain: "You split a feature into smaller features but you're also building the big one directly → build only the small pieces, not both.",
         se: "Parent `REQ` (has `compose`→`REQ` children) carrying a direct `FUNC` `satisfy`; the satisfy belongs on the children.",
+        vorschlag: 'Lass die Anforderungen {n} nur über ihre Teilanforderungen erfüllen.',
     },
     'RD-04': {
         plain: "One thing has more than 9 parts directly under it → group them, so each level stays readable.",
         se: "Decomposition breadth above `metricPolicy.decompositionBreadth.warning` children on one level — `FUNC` `compose` `FUNC`, `SYS` `compose` `MOD`, a `MOD`'s sub-`MOD`s plus its own leaf `FUNC` (`allocate`), and the root `FUNC` forest anchored at `SYS` (CR-SM-282). Default 9, the upper end of 7±2 (CR-SM-296). CR-SM-311: a module level counts its own functions again — breadth, not size; module coupling is R-04. The lower bound is RD-05.",
+        vorschlag: 'Gruppiere die Teile unter {n}, es sind zu viele auf einer Ebene.',
     },
     'RD-05': {
         plain: "A level has only one or two parts under it → it groups nothing; fold it into the level above, or gather the parts that belong together under it.",
-        se: "Decomposition breadth below `metricPolicy.decompositionBreadth.min` (default 3, exclusive) on one level, counted exactly like RD-04 (CR-SM-311, Z3). A level abstracts nothing below it. The finding carries no `value`/`threshold` and does not enter the steering score: it is readability, not boundary width. A level with no children at all is not this rule (empty MOD: R-23; FUNC without children is a leaf).",
+        se: "Decomposition breadth below `metricPolicy.decompositionBreadth.min` (default 3, exclusive) on one level, counted exactly like RD-04 (CR-SM-311, Z3). A level abstracts nothing below it. The finding carries no `value`/`threshold` and does not enter the steering score: it is readability, not boundary width. A level with no children at all is not this rule (empty MOD: R-23; FUNC without children is a leaf). The root level directly under `SYS` (`SYS` `compose` `MOD`, root `FUNC` forest) is exempt — there is no level above it, and one module or one root function is an architecture decision (CR-SM-388); RD-04 still applies there.",
+        vorschlag: 'Löse die Ebene {n} in die Ebene darüber auf oder sammle unter ihr, was zusammengehört.',
     },
     'SC-02': {
         plain: "A data format is defined but nothing uses it → connect it to the data it describes, or drop it.",
         se: "`SCHEMA` not referenced by any `FLOW` via a `relation` trace.",
+        vorschlag: 'Verbinde das Datenformat {n} mit seinem Datenfluss oder entferne es.',
     },
     'UC-01': {
         plain: "A scenario says what someone wants to do but never says what the system must provide → write down the requirements it needs.",
         se: "`UC` with no `compose` trace to any `REQ`. The use case carries no requirement content.",
         prompt: "se:author-req",
+        vorschlag: 'Lege für die Abläufe {n} Anforderungen mit Test an: fachliche je Funktion, Ende-zu-Ende-Vorgaben an der Kette.',
     },
     'UC-02': {
         plain: "A scenario has nobody who triggers it → name who or what starts it.",
         se: "`UC` that no `ACTOR` reaches: the one legal path is `ACTOR -io-> FLOW -io-> FUNC` (or back, `FUNC -io-> FLOW -io-> ACTOR`), the FUNC a member of one of the UC's chains (`UC -compose-> FCHAIN -compose-> FUNC`). A direct `ACTOR -io-> UC` is rejected by R-18. No skill prompt (CR-SM-370): `se:author-uc` shows creating UCs and `se:author-actor` says to leave actors unwired — neither is this work.",
+        vorschlag: 'Lege für die Abläufe {n} die Funktionen an, die der Nutzer über einen Datenfluss auslöst.',
     },
     'UC-03': {
         plain: "A scenario says what should be possible but not how it runs → describe the steps as a chain of functions.",
         se: "`UC` with no `compose` trace to an `FCHAIN`. No behavioural scenario is declared.",
         prompt: "se:author-uc",
+        vorschlag: 'Beschreibe die Abläufe {n} als Kette von Funktionen.',
     },
     'UC-04': {
         plain: "A scenario has no real description, or still carries a placeholder like TBD → write what the user actually wants to achieve.",
         se: "`UC` description shorter than 10 characters or containing TBD/TODO/FIXME/placeholder/XXX. Description IS the goal (CR-150).",
         prompt: "se:author-uc",
+        vorschlag: 'Beschreibe das Ziel der Abläufe {n}.',
     },
     'VR-01': {
         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[];