@sigloch/contracts 10.10.0 → 10.13.0

package/dist/se/ontology.d.ts

@@ -40,24 +40,27 @@ export declare const TraceType: z.ZodEnum<{
 }>;
 export type TraceType = z.infer<typeof TraceType>;
 /**
- * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ * REQ kind — GENAU EIN Wert je REQ, aus zwei (CR-SM-366).
  *
- * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
- * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
- * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
- * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
- * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
- * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
- * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
- * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ * `functional` -> erfuellt von FUNC. `non-functional` -> erfuellt von MOD (lokales Budget), SYS
+ * (Systemebene) oder FCHAIN (Ende-zu-Ende entlang der Kette). Ohne kinds kein Erfueller (BQ-07,
+ * `satisfiesPredicate`). Ein REQ, das beides ist, ist falsch zerlegt -> teilen; die
+ * Teilmengen-Semantik der where-Praedikate laesst es von niemandem erfuellen.
+ *
+ * Entfallen (Major, CR-SM-366):
+ * - `precondition` / `postcondition`: die Vorbedingung steckt im Eingangs-FLOW der Kette, die
+ *   Nachbedingung ist das UC-Ziel — beides prueft R-21 (Integrationstest je Kette). Ihre Leser
+ *   UC-05/06 sind seit CR-SM-357 gestrichen.
+ * - `risk` / `mitigation`: die FMEA-ROLLE einer Anforderung, keine Art — `REQ.attributes.role`
+ *   (CR-SM-365), satisfy-neutral.
+ * Ein Altwert wird nicht still verworfen: `normalizeReqKinds` laesst ihn stehen, das Schema
+ * lehnt ihn ab, und R-18 meldet jede satisfy-Kante darauf als `kinds-mismatch` mit `declared`.
+ *
+ * Vorher CR-SM-266 B: `negative` entfiel (ein Verbots-REQ ist `functional`).
  */
 export declare const ReqKind: z.ZodEnum<{
     functional: "functional";
     "non-functional": "non-functional";
-    risk: "risk";
-    mitigation: "mitigation";
-    precondition: "precondition";
-    postcondition: "postcondition";
 }>;
 export type ReqKind = z.infer<typeof ReqKind>;
 /**
@@ -196,6 +199,58 @@ export declare const RealRefSchema: z.ZodObject<{
     lang: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RealRef = z.infer<typeof RealRefSchema>;
+/**
+ * Was ein Attributvertrag an einem Element aussagt — dreiwertig (CR-SM-360).
+ *
+ * `absent`  : das Attribut fehlt (auch als `null`-Grabstein — Attribute sind nur mergebar).
+ * `invalid` : es ist da, aber verletzt den Vertrag; `error` sagt wie.
+ * `bound`   : es ist da und gueltig.
+ *
+ * Bis hierher parste jeder Leser selbst (25 Stellen in contracts und graphcode), und die Leser
+ * wichen ab: einer meldete ungueltige testRefs, die anderen behandelten „ungueltig" still wie
+ * „fehlt" — die Klasse aus CR-GC-338. Ein Aufrufer, der beides gleich behandeln will, tut das jetzt
+ * sichtbar (`state !== 'bound'`), statt dass der Unterschied beim Parsen verloren geht.
+ */
+export type BindingRead<T> = {
+    state: 'absent';
+} | {
+    state: 'invalid';
+    error: string;
+} | {
+    state: 'bound';
+    value: T;
+};
+type Attributes = Record<string, unknown> | undefined;
+/** Der EINE Leser von `attributes.testRefs` (CR-SM-360). */
+export declare function readTestRefs(attributes: Attributes): BindingRead<TestRefs>;
+/** Der EINE Leser von `attributes.realRef` (CR-SM-360). */
+export declare function readRealRef(attributes: Attributes): BindingRead<RealRef>;
+/**
+ * CR-SM-364: die Kopplung eines Uebergangs — `FLOW.attributes.sync`. Fehlend heisst UNBEKANNT,
+ * nie stillschweigend `sync`: eine Kettenkennzahl (synchrone Tiefe, Engstellen-Grad) weist eine
+ * unmarkierte Kette als „nicht bewertbar" aus, statt sie ueber eine Annahme zu beurteilen.
+ */
+export declare const FlowSync: z.ZodEnum<{
+    sync: "sync";
+    async: "async";
+}>;
+export type FlowSync = z.infer<typeof FlowSync>;
+/** Der EINE Leser von `FLOW.attributes.sync` (CR-SM-364) — ungueltig ist nicht fehlend. */
+export declare function readFlowSync(attributes: Attributes): BindingRead<FlowSync>;
+/**
+ * CR-SM-365: die ROLLE einer Anforderung im FMEA-Sinn — `REQ.attributes.role`. `risk` und
+ * `mitigation` waren bis hierher `kinds`-Werte und damit satisfy-relevant (MOD/SYS erfuellten
+ * sie). Sie sind aber keine ART der Anforderung, sondern ihre Motivation: eine Gegenmassnahme ist
+ * funktional oder nicht-funktional wie jede andere REQ. Die Rolle ist satisfy-neutral — die
+ * Grammatik (`isValidTrace`) liest sie nicht; FM-01..03 lesen NUR sie.
+ */
+export declare const ReqRole: z.ZodEnum<{
+    risk: "risk";
+    mitigation: "mitigation";
+}>;
+export type ReqRole = z.infer<typeof ReqRole>;
+/** Der EINE Leser von `REQ.attributes.role` (CR-SM-365) — ungueltig ist nicht fehlend. */
+export declare function readReqRole(attributes: Attributes): BindingRead<ReqRole>;
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -288,10 +343,6 @@ export declare const OntologyElement: z.ZodObject<{
     kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         functional: "functional";
         "non-functional": "non-functional";
-        risk: "risk";
-        mitigation: "mitigation";
-        precondition: "precondition";
-        postcondition: "postcondition";
     }>>>;
     attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodDefault<z.ZodEnum<{
@@ -354,10 +405,6 @@ export declare const OntologyGraph: z.ZodObject<{
         kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             functional: "functional";
             "non-functional": "non-functional";
-            risk: "risk";
-            mitigation: "mitigation";
-            precondition: "precondition";
-            postcondition: "postcondition";
         }>>>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         status: z.ZodDefault<z.ZodEnum<{
@@ -409,3 +456,4 @@ export interface AttributeSpec {
  * the prescribed keys that rules, views, and extractors rely on.
  */
 export declare const ELEMENT_ATTRIBUTES: Partial<Record<ElementType, AttributeSpec[]>>;
+export {};

package/dist/se/ontology.js

@@ -25,21 +25,25 @@ export const TraceType = z.enum([
     'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation',
 ]);
 /**
- * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ * REQ kind — GENAU EIN Wert je REQ, aus zwei (CR-SM-366).
  *
- * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
- * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
- * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
- * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
- * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
- * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
- * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
- * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ * `functional` -> erfuellt von FUNC. `non-functional` -> erfuellt von MOD (lokales Budget), SYS
+ * (Systemebene) oder FCHAIN (Ende-zu-Ende entlang der Kette). Ohne kinds kein Erfueller (BQ-07,
+ * `satisfiesPredicate`). Ein REQ, das beides ist, ist falsch zerlegt -> teilen; die
+ * Teilmengen-Semantik der where-Praedikate laesst es von niemandem erfuellen.
+ *
+ * Entfallen (Major, CR-SM-366):
+ * - `precondition` / `postcondition`: die Vorbedingung steckt im Eingangs-FLOW der Kette, die
+ *   Nachbedingung ist das UC-Ziel — beides prueft R-21 (Integrationstest je Kette). Ihre Leser
+ *   UC-05/06 sind seit CR-SM-357 gestrichen.
+ * - `risk` / `mitigation`: die FMEA-ROLLE einer Anforderung, keine Art — `REQ.attributes.role`
+ *   (CR-SM-365), satisfy-neutral.
+ * Ein Altwert wird nicht still verworfen: `normalizeReqKinds` laesst ihn stehen, das Schema
+ * lehnt ihn ab, und R-18 meldet jede satisfy-Kante darauf als `kinds-mismatch` mit `declared`.
+ *
+ * Vorher CR-SM-266 B: `negative` entfiel (ein Verbots-REQ ist `functional`).
  */
-export const ReqKind = z.enum([
-    'functional', 'non-functional', 'risk',
-    'mitigation', 'precondition', 'postcondition',
-]);
+export const ReqKind = z.enum(['functional', 'non-functional']);
 /**
  * `kinds` in der Form, die WIRKLICH auf Platte liegt — als Liste.
  *
@@ -167,6 +171,52 @@ export const RealRefSchema = z.object({
     symbol: z.string().optional(),
     lang: z.string().optional(),
 });
+/** Der EINE Leser von `attributes.testRefs` (CR-SM-360). */
+export function readTestRefs(attributes) {
+    const raw = attributes?.testRefs;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = TestRefsSchema.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
+/** Der EINE Leser von `attributes.realRef` (CR-SM-360). */
+export function readRealRef(attributes) {
+    const raw = attributes?.realRef;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = RealRefSchema.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
+/**
+ * CR-SM-364: die Kopplung eines Uebergangs — `FLOW.attributes.sync`. Fehlend heisst UNBEKANNT,
+ * nie stillschweigend `sync`: eine Kettenkennzahl (synchrone Tiefe, Engstellen-Grad) weist eine
+ * unmarkierte Kette als „nicht bewertbar" aus, statt sie ueber eine Annahme zu beurteilen.
+ */
+export const FlowSync = z.enum(['sync', 'async']);
+/** Der EINE Leser von `FLOW.attributes.sync` (CR-SM-364) — ungueltig ist nicht fehlend. */
+export function readFlowSync(attributes) {
+    const raw = attributes?.sync;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = FlowSync.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
+/**
+ * CR-SM-365: die ROLLE einer Anforderung im FMEA-Sinn — `REQ.attributes.role`. `risk` und
+ * `mitigation` waren bis hierher `kinds`-Werte und damit satisfy-relevant (MOD/SYS erfuellten
+ * sie). Sie sind aber keine ART der Anforderung, sondern ihre Motivation: eine Gegenmassnahme ist
+ * funktional oder nicht-funktional wie jede andere REQ. Die Rolle ist satisfy-neutral — die
+ * Grammatik (`isValidTrace`) liest sie nicht; FM-01..03 lesen NUR sie.
+ */
+export const ReqRole = z.enum(['risk', 'mitigation']);
+/** Der EINE Leser von `REQ.attributes.role` (CR-SM-365) — ungueltig ist nicht fehlend. */
+export function readReqRole(attributes) {
+    const raw = attributes?.role;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = ReqRole.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -247,7 +297,7 @@ export const OntologyElement = z.object({
     description: z.string(),
     /** INCOSE TIAD verification method — only for TEST elements (CR-057). */
     method: VerificationMethod.optional(),
-    /** REQ kinds: multi-valued classification (CR-180). Only for REQ elements. */
+    /** REQ kinds: exactly ONE of functional|non-functional (CR-SM-366); a list for the on-disk form. Only for REQ elements. */
     kinds: z.array(ReqKind).optional(),
     attributes: z.record(z.string(), z.unknown()).optional(),
     status: z.enum(['draft', 'reviewed', 'open', 'done']).default('draft'),
@@ -319,6 +369,7 @@ export const ELEMENT_ATTRIBUTES = {
         { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRefs-binding requirement (CR-GC-205)' },
     ],
     REQ: [
+        { key: 'role', type: 'enum', enumValues: ReqRole.options, description: "FMEA role: 'risk' | 'mitigation' — satisfy-neutral, read by FM-01..03 via readReqRole. A mitigation is functional or non-functional like any REQ; the role is its motivation, not its kind (CR-SM-365)" },
         { key: 'severity', type: 'number', description: 'FMEA severity (1-10)' },
         { key: 'occurrence', type: 'number', description: 'FMEA occurrence (1-10)' },
         { key: 'detection', type: 'number', description: 'FMEA detection (1-10)' },
@@ -340,9 +391,10 @@ export const ELEMENT_ATTRIBUTES = {
         { key: 'rationale', type: 'string', description: 'Reason for the change' },
         { key: 'spike', type: 'boolean', description: 'CR is a spike/exploration' },
     ],
+    // CR-SM-364: genau ein Realisierungsattribut. `protocol`/`qos` entfielen — freie Strings, in
+    // 0 von 186 Familien-FLOWs gesetzt, ohne Leser. Abweichende Kopplung je Verbraucher ⇒ FLOW teilen.
     FLOW: [
-        { key: 'protocol', type: 'string', description: 'ICD protocol (e.g. REST, gRPC)' },
-        { key: 'qos', type: 'string', description: 'Quality of Service level' },
+        { key: 'sync', type: 'enum', enumValues: FlowSync.options, description: "Coupling of the transition: 'sync' | 'async'. Missing = unknown, never an implicit 'sync' — read with readFlowSync (CR-SM-364)" },
     ],
     MOD: [
         { key: 'path', type: 'string', description: 'Source file or glob the module owns, e.g. src/harness.ts — anchors the MOD<->file mapping for graph<->code conformance (CR-GC-205)' },

package/dist/se/readiness.d.ts

@@ -170,6 +170,20 @@ export type PhaseGateType = z.infer<typeof PhaseGate>;
  * single-owner convention as RULE_TO_DIMENSION.
  */
 export declare const RULE_TO_PHASE: Record<string, PhaseGateType>;
+/**
+ * CR-SM-343 — die VORBEDINGUNG einer Regel: der Elementtyp, von dem der Graph mindestens ein
+ * Element tragen muss, damit die Regel ueberhaupt ausgewertet ist.
+ *
+ * Der Nenner einer Dimension ist `Σ Grundgesamtheit` ueber ihre Regeln (`domain`). Eine Regel,
+ * die mangels Gegenstand schweigt, truege dort ihre ganze Grundgesamtheit bei und liefert null
+ * Verstoesse — der Score STIEGE, weil nicht geprueft wurde. CR-R05 fragt nach einem Bauauftrag;
+ * ein Graph ohne einen einzigen CR (`cr: docs`) hat keinen Plan im Graphen, also ist die Frage
+ * dort NICHT GESTELLT, nicht bestanden. Wer einen Anteil bildet, fragt `ruleApplies` und laesst
+ * eine nicht anwendbare Regel aus Zaehler UND Nenner.
+ */
+export declare const RULE_PRECONDITION: Readonly<Record<string, string>>;
+/** Ist die Regel an einem Graphen mit diesen Typ-Zaehlungen ausgewertet? (CR-SM-343) */
+export declare function ruleApplies(ruleId: string, countByType: Readonly<Record<string, number>>): boolean;
 /**
  * Die Eigentuemer-Spalte (CR-SM-350, Entscheidung 2026-09-22): welcher TASK eine Regel bearbeitet.
  *

package/dist/se/readiness.js

@@ -151,7 +151,10 @@ export const RULE_TO_DIMENSION = {
     // req
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': 'req',
-    'RD-01': 'req', 'RD-02': 'req', 'RD-03': 'req',
+    'RD-01': 'req', 'RD-02': 'req',
+    // CR-SM-343: CR-R05 (Blatt-REQ ohne Bauauftrag) — ein Mangel der Anforderungsdeckung, nicht
+    // der CR-Hygiene; zaehlt nur, wenn der Graph ueberhaupt CR-Knoten traegt (RULE_PRECONDITION).
+    'CR-R05': 'req',
     // RD-04 is decomposition *breadth* — an architecture concern, not a requirement one
     'RD-04': 'arch',
     // CR-SM-311: die Untergrenze derselben Breite — ebenfalls Architektur
@@ -168,10 +171,10 @@ export const RULE_TO_DIMENSION = {
     'R-30': 'arch', 'R-31': 'arch',
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
-    'UC-05': 'uc', 'UC-06': 'uc',
     'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
     // FC-04 (CR-SM-226): FCHAIN actor-bounded (trigger+consumer) — same dimension as FC-01..03.
     'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
+    'FC-05': 'uc', // CR-SM-363: Zusammenhang der Kette — dieselbe Dimension wie FC-04
     // arch
     'R-02': 'arch', 'R-10': 'arch', 'R-12': 'arch',
     // alloc
@@ -250,8 +253,8 @@ export const RULE_TO_PHASE = {
     'TR-01': 'PDR', 'IR-01': 'PDR', // CR-SM-355: Task-Ausgaenge von trade / irr — dasselbe Gate wie ihr Eintritt
     // SRR — requirements/scope clarity, system+UC boundary definition.
     'BQ-01': 'SRR', 'BQ-02': 'SRR', 'BQ-04': 'SRR', 'BQ-06': 'SRR', 'BQ-07': 'SRR',
-    'RD-01': 'SRR', 'RD-02': 'SRR', 'RD-03': 'SRR',
-    'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR', 'UC-05': 'SRR', 'UC-06': 'SRR',
+    'RD-01': 'SRR', 'RD-02': 'SRR',
+    'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR',
     'R-16': 'SRR', 'R-17': 'SRR',
     'FC-02': 'SRR',
     'CL-01': 'SRR',
@@ -263,7 +266,7 @@ export const RULE_TO_PHASE = {
     'R-02': 'PDR', 'R-08': 'PDR', 'R-10': 'PDR', 'R-12': 'PDR', 'R-18': 'PDR',
     'R-04': 'PDR', 'R-22': 'PDR', 'R-23': 'PDR',
     'R-15': 'PDR',
-    'FC-03': 'PDR', 'FC-04': 'PDR',
+    'FC-03': 'PDR', 'FC-04': 'PDR', 'FC-05': 'PDR',
     // CR-GC-366: Anschluss des Funktionsbaus — gehoert an dasselbe Gate wie R-15/IO-01,
     // die auf derselben Kette aufsetzen.
     'R-30': 'PDR', 'R-31': 'PDR',
@@ -283,7 +286,27 @@ export const RULE_TO_PHASE = {
     'VR-01': 'TRR',
     'FM-03': 'TRR',
     'CR-R02': 'TRR',
+    'CR-R05': 'TRR', // CR-SM-343: dieselbe Phase wie AF-05 (Implementierungsplan)
 };
+/**
+ * CR-SM-343 — die VORBEDINGUNG einer Regel: der Elementtyp, von dem der Graph mindestens ein
+ * Element tragen muss, damit die Regel ueberhaupt ausgewertet ist.
+ *
+ * Der Nenner einer Dimension ist `Σ Grundgesamtheit` ueber ihre Regeln (`domain`). Eine Regel,
+ * die mangels Gegenstand schweigt, truege dort ihre ganze Grundgesamtheit bei und liefert null
+ * Verstoesse — der Score STIEGE, weil nicht geprueft wurde. CR-R05 fragt nach einem Bauauftrag;
+ * ein Graph ohne einen einzigen CR (`cr: docs`) hat keinen Plan im Graphen, also ist die Frage
+ * dort NICHT GESTELLT, nicht bestanden. Wer einen Anteil bildet, fragt `ruleApplies` und laesst
+ * eine nicht anwendbare Regel aus Zaehler UND Nenner.
+ */
+export const RULE_PRECONDITION = {
+    'CR-R05': 'CR',
+};
+/** Ist die Regel an einem Graphen mit diesen Typ-Zaehlungen ausgewertet? (CR-SM-343) */
+export function ruleApplies(ruleId, countByType) {
+    const required = RULE_PRECONDITION[ruleId];
+    return required === undefined || (countByType[required] ?? 0) > 0;
+}
 /**
  * Die Eigentuemer-Spalte (CR-SM-350, Entscheidung 2026-09-22): welcher TASK eine Regel bearbeitet.
  *
@@ -303,10 +326,13 @@ export const TASK_OWNED_RULES = {
     trade: ['TR-01'], // CR-SM-355: Trade-Entscheidung als CR
     irr: ['IR-01'], // CR-SM-355: Annahmen-Review promoviert zu CR
     fmea: ['FM-01', 'FM-02', 'FM-03'],
-    plan: ['MS-01', 'MS-02', 'MS-03', 'CR-R01', 'CR-R02', 'CR-R03'],
+    // CR-SM-377: CR-R05 (Blatt-REQ ohne Bauauftrag, CR-SM-343) fragt nach einem CR — die Antwort
+    // schreibt der Plan-Task (se-plan), nicht die Generierungsschleife. FC-05 bleibt Kern: die
+    // Kette zu schliessen ist Spezifikationsarbeit wie FC-04.
+    plan: ['MS-01', 'MS-02', 'MS-03', 'CR-R01', 'CR-R02', 'CR-R03', 'CR-R05'],
     // Annahme (CR-SM-350): BQ bekommt einen eigenen Task, vorerst ohne automatischen Eintrittspunkt.
     anforderungsqualitaet: ['BQ-01', 'BQ-02', 'BQ-04', 'BQ-06', 'BQ-07'],
-    realisierung: ['R-19', 'R-20', 'R-26', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07'],
+    realisierung: ['R-19', 'R-20', 'R-26', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07', 'RC-08', 'RC-09', 'RC-10'],
 };
 /**
  * Der Eintrittspunkt eines Tasks im Kern: die Regel, die "dieses Artefakt fehlt" sagt. `null` = der

package/dist/se/rule-help.js

@@ -115,6 +115,11 @@ export const RULE_HELP = {
         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",
+    },
     '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.",
@@ -128,19 +133,23 @@ export const RULE_HELP = {
         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.",
     },
+    '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).",
+    },
     '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: "Risk `REQ` missing `severity` / `occurrence` / `detection` attributes (AIAG-VDA).",
+        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",
     },
     'FM-02': {
         plain: "A known risk has nothing planned against it → write the countermeasure as its own requirement.",
-        se: "Risk `REQ` with no `compose`d mitigation `REQ` (`kinds:[\"mitigation\"]`).",
+        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",
     },
     'FM-03': {
         plain: "A high risk has no test that actually passed → add a test proving the countermeasure works.",
-        se: "Risk `REQ` with RPN > 100 and no `TEST` carrying `testResult:\"passed\"` verifying it.",
+        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",
     },
     'IO-01': {
@@ -247,8 +256,8 @@ export const RULE_HELP = {
         se: "Realized `FUNC` with no valid `realRef` `{file, symbol}` (graph↔code binding); else `concept:true` / `external:true`.",
     },
     'R-21': {
-        plain: "Two functions hand data over, but they are not in one chain together — or they are, and nothing tests the hand-off → put both into the same chain, and give that chain an integration test.",
-        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 carries a verified integration test (`TEST` ─verify→ `REQ` ←satisfy─ `FCHAIN`) → finding at the chain. 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.",
+        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.",
     },
     '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.",
@@ -300,7 +309,19 @@ export const RULE_HELP = {
     },
     '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/dropped/rejected) 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).",
+        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).",
+    },
+    '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).",
+    },
+    '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).",
+    },
+    '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).",
     },
     'RD-01': {
         plain: "A smallest-piece feature has nothing built to fulfil it → add what implements it.",
@@ -311,10 +332,6 @@ export const RULE_HELP = {
         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.",
     },
-    'RD-03': {
-        plain: "You split a feature into pieces, but all the pieces are handled by the same one thing — the split may be pointless → consider merging them.",
-        se: "Parent `REQ` whose children all share one satisfier.",
-    },
     '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.",
@@ -334,8 +351,7 @@ export const RULE_HELP = {
     },
     'UC-02': {
         plain: "A scenario has nobody who triggers it → name who or what starts it.",
-        se: "`UC` with no `ACTOR` connected by an `io` trace (directly or via a `FLOW` of its chain).",
-        prompt: "se:author-uc",
+        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.",
     },
     'UC-03': {
         plain: "A scenario says what should be possible but not how it runs → describe the steps as a chain of functions.",
@@ -347,14 +363,6 @@ export const RULE_HELP = {
         se: "`UC` description shorter than 10 characters or containing TBD/TODO/FIXME/placeholder/XXX. Description IS the goal (CR-150).",
         prompt: "se:author-uc",
     },
-    'UC-05': {
-        plain: "A scenario does not say what must be true once it has finished → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"postcondition\"]`.",
-    },
-    'UC-06': {
-        plain: "A scenario does not say what must be true before it can start → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"precondition\"]`.",
-    },
     '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.",

package/dist/se/rules.d.ts

@@ -81,6 +81,14 @@ export declare const ViolationContext: z.ZodObject<{
     parent_module: z.ZodOptional<z.ZodString>;
     current_description: z.ZodOptional<z.ZodString>;
     also_affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    side_components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        members: z.ZodArray<z.ZodString>;
+        cause: z.ZodEnum<{
+            "missing-link": "missing-link";
+            bag: "bag";
+        }>;
+        via: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
     trace_rejection: z.ZodOptional<z.ZodObject<{
         reason: z.ZodEnum<{
             "no-pattern": "no-pattern";
@@ -212,6 +220,14 @@ export declare const RuleViolation: z.ZodObject<{
         parent_module: z.ZodOptional<z.ZodString>;
         current_description: z.ZodOptional<z.ZodString>;
         also_affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        side_components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            members: z.ZodArray<z.ZodString>;
+            cause: z.ZodEnum<{
+                "missing-link": "missing-link";
+                bag: "bag";
+            }>;
+            via: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
         trace_rejection: z.ZodOptional<z.ZodObject<{
             reason: z.ZodEnum<{
                 "no-pattern": "no-pattern";