@sigloch/contracts 10.12.0 → 10.13.0

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.
  *
@@ -183,6 +187,36 @@ export function readRealRef(attributes) {
     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).
@@ -263,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'),
@@ -335,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)' },
@@ -356,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

@@ -152,6 +152,9 @@ export const RULE_TO_DIMENSION = {
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': '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
@@ -171,6 +174,7 @@ export const RULE_TO_DIMENSION = {
     '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
@@ -262,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',
@@ -282,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.
  *
@@ -302,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', 'RC-08', 'RC-09'],
+    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.",
@@ -310,6 +319,10 @@ export const RULE_HELP = {
         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.",
         se: "Leaf `REQ` (no `compose`→`REQ` children) with no `satisfy` from a `FUNC`/`FCHAIN`/`MOD`/`SYS`.",
@@ -338,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.",

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";

package/dist/se/rules.js

@@ -35,6 +35,17 @@ export const ViolationContext = z.object({
      * unterschlagen.
      */
     also_affects: z.array(z.string()).optional(),
+    /**
+     * CR-SM-363 (FC-05): die NEBENKOMPONENTEN einer zerfallenen FCHAIN, je mit Ursache —
+     * `missing-link` (Haupt- und Nebenteil sind ueber eine FUNC ausserhalb der Kette verbunden;
+     * `via` nennt sie) oder `bag` (nur eine gemeinsame Quelle, parallele Dienste). EIN Befund je
+     * Kette (CR-SM-242), die Komponenten hier statt als n Befunde.
+     */
+    side_components: z.array(z.object({
+        members: z.array(z.string()),
+        cause: z.enum(['missing-link', 'bag']),
+        via: z.array(z.string()),
+    })).optional(),
     /**
      * CR-SM-341: der Ablehnungsgrund von R-18, maschinenlesbar statt nur als Satz.
      *
@@ -242,24 +253,15 @@ function funcMustSatisfyReq(graph) {
                 .map(st => idx.byId.get(st.target))
                 .filter((e) => !!e)
             : [];
-        // Also include constraints whose description mentions this func's name
-        const namePattern = fn.name.toLowerCase();
-        const matchingConstraints = allReqs.filter(r => r.kinds?.includes('non-functional') && r.description.toLowerCase().includes(namePattern));
         // CR-SM-346 (ITEM-2026-299): der Kandidatenkreis wird am META-MODELL gefiltert, nicht
-        // an einer zweiten, hier abgeschriebenen kinds-Liste. `FUNC -satisfy-> REQ` laesst nur
-        // BEHAVIOURAL_KINDS zu; bis hierher bot die Regel ALLE REQ an — gemessen an sigllm hatte
-        // damit KEINER von 33 Befunden einen legalen Kandidaten, und die Vorlage aus CR-SM-342
-        // gab korrekt `null` zurueck. 86 Befunde, 0 Empfehlungen: der Befund war unbedienbar.
-        //
-        // Besonders der `matchingConstraints`-Zweig zog gezielt `non-functional` herein — genau
-        // die Sorte, die das Muster abweist. Er bleibt stehen (ein REQ kann mehrere kinds tragen,
-        // und die Namensnennung ist ein echtes Relevanzsignal), aber er entscheidet nicht mehr
-        // ueber die Legalitaet.
+        // an einer zweiten, hier abgeschriebenen kinds-Liste — `isValidTrace` statt Eigenbau: eine
+        // Regel, die Kandidaten anbietet, die ihr eigenes Meta-Modell abweist, erzeugt Waste statt
+        // Fuehrung. `FUNC -satisfy-> REQ` laesst nur `functional` zu (CR-SM-366).
         //
-        // `isValidTrace` statt Eigenbau: eine Regel, die Kandidaten anbietet, die ihr eigenes
-        // Meta-Modell abweist, erzeugt Waste statt Fuehrung — und zwei Wahrheiten ueber dieselbe
-        // Grammatik sind genau der Defekt, den CR-SM-286/-302 beseitigt haben.
-        const candidates = [...new Map([...siblingReqs, ...matchingConstraints, ...allReqs].map(e => [e.id, e])).values()]
+        // CR-SM-366: der fruehere `matchingConstraints`-Zweig (non-functional-REQ, deren Text den
+        // FUNC-Namen nennt) ist entfallen. Er zog genau die Sorte herein, die das Muster abweist;
+        // seit ein REQ genau EIN kind traegt, konnte kein Treffer den Filter je passieren.
+        const candidates = [...new Map([...siblingReqs, ...allReqs].map(e => [e.id, e])).values()]
             .filter(r => isValidTrace({ source: 'FUNC', target: 'REQ', type: 'satisfy', targetKinds: r.kinds }));
         return {
             rule_id: 'R-02',
@@ -827,7 +829,9 @@ function actorMustHaveTrace(graph) {
         severity: 'warning',
         element_id: a.id,
         message: `${a.id} has no io traces (disconnected actor)`,
-        fix_hint: 'Link to a UC or FLOW via io trace',
+        // CR-SM-371: ein ACTOR hat genau zwei legale Kanten (ACTOR -io-> FLOW, FLOW -io-> ACTOR);
+        // der UC wird ueber den FLOW an einer FUNC seiner Kette erreicht, nie direkt (R-18).
+        fix_hint: `Wire the actor through a FLOW via graph_mutate Format-E: \`${a.id} -io-> FLOW-x\` (it sends) or \`FLOW-x -io-> ${a.id}\` (it receives), plus \`FLOW-x -io-> FUNC-y\` or \`FUNC-y -io-> FLOW-x\` for a FUNC in the use case's chain — never an io edge to the UC itself`,
         context: {
             element_type: a.type,
             element_name: a.name,
@@ -927,7 +931,6 @@ function validTracePattern(graph) {
         });
         if (!why)
             return [];
-        const { detail, hint } = explainRejection(why, t, src, tgt);
         // CR-SM-341: derselbe Grund, den `detail` in Prosa giesst — hier zusaetzlich als Struktur.
         // Keine zweite Rechnung: `why` liegt vor, die Alternativen befragen `isValidTrace`.
         const shape = {
@@ -936,6 +939,7 @@ function validTracePattern(graph) {
             targetKinds: idx.byId.get(t.target)?.kinds,
         };
         const alt = admittingAlternatives(shape);
+        const { detail, hint } = explainRejection(why, t, src, tgt, alt.sources);
         const where = why.reason === 'no-pattern' ? undefined : why.pattern.where;
         return [{
                 rule_id: 'R-18',
@@ -970,7 +974,7 @@ function validTracePattern(graph) {
  * `kinds` steht da und passt nicht (Kante heben oder Kind korrigieren). Wer das nicht
  * unterscheiden kann, sucht am falschen Ende.
  */
-function explainRejection(why, t, src, tgt) {
+function explainRejection(why, t, src, tgt, admittingSources) {
     if (why.reason === 'no-pattern') {
         return {
             detail: `${src} → ${tgt} is not a valid ${t.type} pattern`,
@@ -991,7 +995,11 @@ function explainRejection(why, t, src, tgt) {
         }
         : {
             detail: `${admits}, but ${end} declares {${[...why.declared].sort().join(', ')}}`,
-            hint: `Correct '${where.field}' on ${end}, or use a source type whose ${t.type} pattern admits them (FCHAIN carries every kind)`,
+            // CR-SM-366: den Erfueller NENNEN statt "FCHAIN carries every kind" — das galt nie fuer
+            // die Code-Bindung und gilt seit dem FCHAIN-where gar nicht mehr.
+            hint: admittingSources.length > 0
+                ? `Correct '${where.field}' on ${end}, or ${t.type} it from ${admittingSources.join(' | ')} — the pattern admitting {${[...why.declared].sort().join(', ')}}`
+                : `Correct '${where.field}' on ${end} to a subset of {${allowed}} — no source type admits {${[...why.declared].sort().join(', ')}} (retired kind? split a mixed REQ)`,
         };
 }
 /**
@@ -1270,7 +1278,7 @@ function funcMustHaveCodeBinding(graph) {
                 severity: 'warning',
                 element_id: fn.id,
                 message: `${fn.id} is not fully realized — unbound compose ${leafList.length === 1 ? 'child' : 'children'}: ${leafList.join(', ')}`,
-                fix_hint: `Realize the leaves ${leafList.join(', ')} (graph_realize) — the parent inherits their binding`,
+                fix_hint: `Bind the leaves via graph_mutate Format-E (${leafList.map((id) => `\`~ ${id} @realRef {"file":…,"symbol":…}\``).join(', ')}) — the parent inherits their binding`,
                 context: { element_type: fn.type, element_name: fn.name },
             });
         }
@@ -1300,6 +1308,10 @@ function funcMustHaveCodeBinding(graph) {
 //       Co-adjacency at a shared FLOW is not an asserted interface — treating it
 //       as one produced P·C findings per hub FLOW and made reuse the expensive
 //       choice. The FCHAIN is the modelled claim; the test is owed on the claim.
+//       CR-SM-376: second way to cover a chain. Since CR-SM-366 an FCHAIN carries
+//       only NFRs; its effect is covered through its members when EVERY member
+//       FUNC (FCHAIN ─compose→ FUNC) satisfies at least one REQ. Verifying those
+//       member REQs is R-01's job, not R-21's.
 // ---------------------------------------------------------------------------
 function fchainMustHaveIntegrationTest(graph, policy) {
     const idx = indexOf(graph);
@@ -1333,6 +1345,22 @@ function fchainMustHaveIntegrationTest(graph, policy) {
             testedChains.add(t.source);
         }
     }
+    // CR-SM-376: der zweite Weg — die Kette ist ueber ihre Glieder gedeckt, wenn JEDE Glied-FUNC
+    // (direkte FCHAIN -compose-> FUNC, dieselbe Definition wie `chainsByFunc`) eine REQ erfuellt.
+    // `unmetMembers` liefert die Glieder ohne REQ; leer = gedeckt. Eine Kette ohne Glied kann hier
+    // nicht auftauchen: ZWEIG 2 hat mindestens die beiden Enden der Uebergabe als Glieder.
+    const funcsWithReq = new Set(idx.tracesOfType('satisfy').filter(t => isFunc(t.source) && typeOf.get(t.target) === 'REQ').map(t => t.source));
+    const membersOf = new Map();
+    for (const [fn, chains] of chainsOf) {
+        for (const ch of chains) {
+            const list = membersOf.get(ch);
+            if (list)
+                list.push(fn);
+            else
+                membersOf.set(ch, [fn]);
+        }
+    }
+    const unmetMembers = (ch) => (membersOf.get(ch) ?? []).filter(fn => !funcsWithReq.has(fn)).sort();
     // CR-SM-313: die Infrastruktur-Ausnahme. Die ZAHL kommt aus der Kennzahl (CR-SM-314), nicht
     // aus einer zweiten Rechnung — eine Uebergabe an eine Funktion, die quer durch alle Ketten
     // laeuft, ist kein fehlender Integrationstest, sondern ein Bus. `null` = keine Ausnahme.
@@ -1372,8 +1400,9 @@ function fchainMustHaveIntegrationTest(graph, policy) {
             });
             continue;
         }
-        // ZWEIG 2 — gemeinsame Kette, aber keine davon geprueft: Befund an der Kette. Unveraendert.
-        if (shared.some(ch => testedChains.has(ch)))
+        // ZWEIG 2 — gemeinsame Kette, aber keine davon gedeckt: Befund an der Kette. Gedeckt heisst
+        // (a) verifizierte Ketten-REQ oder (b, CR-SM-376) jede Glied-FUNC erfuellt eine REQ.
+        if (shared.some(ch => testedChains.has(ch) || unmetMembers(ch).length === 0))
             continue;
         const anchor = shared[0];
         const key = `${anchor}|${p}>${c}`;
@@ -1385,8 +1414,8 @@ function fchainMustHaveIntegrationTest(graph, policy) {
             rule_id: 'R-21',
             severity: 'warning',
             element_id: anchor,
-            message: `${anchor} has no integration test covering connection ${p} → ${c}`,
-            fix_hint: 'Verify an FCHAIN-satisfied REQ with an integration TEST',
+            message: `${anchor} has no integration test covering connection ${p} → ${c}; member FUNCs without a REQ: ${unmetMembers(anchor).join(', ')}`,
+            fix_hint: 'Give each member FUNC of the chain a REQ it satisfies (FUNC -satisfy-> REQ), or attach an end-to-end non-functional REQ to the chain (FCHAIN -satisfy-> REQ) and verify it with an integration TEST',
             context: { element_type: anchorEl?.type, element_name: anchorEl?.name },
         });
     }
@@ -1650,7 +1679,7 @@ export const V3_RULES = [
     { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding, domain: ['TEST'] },
     { id: 'R-29', name: 'Test file exclusivity', severity: 'error', evaluate: testFileExclusivity, domain: ['TEST'] },
     { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding, domain: ['FUNC'] },
-    { id: 'R-21', name: 'FUNC↔FUNC handover needs a shared chain and an integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN', 'FUNC'] },
+    { id: 'R-21', name: 'FUNC↔FUNC handover needs a shared chain covered by member REQs or an integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest, domain: ['FCHAIN', 'FUNC'] },
     { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated, domain: ['FUNC'] },
     { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc, domain: ['MOD'] },
     { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef, domain: ['SCHEMA'] },

package/package.json

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